close.hpp

Go to the documentation of this file.

 
/*
 * Copyright (c) 2014, Peter Thorson. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the WebSocket++ Project nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
 
#ifndef WEBSOCKETPP_CLOSE_HPP
#define WEBSOCKETPP_CLOSE_HPP
 
#include <websocketpp/error.hpp>
#include <websocketpp/common/network.hpp>
#include <websocketpp/common/stdint.hpp>
#include <websocketpp/utf8_validator.hpp>
 
#include <string>
 
namespace websocketpp {
namespace close {
namespace status {
    typedef uint16_t value;
 
    static value const blank = 0;
 
 
    static value const omit_handshake = 1;
 
 
    static value const force_tcp_drop = 2;
 
    static value const normal = 1000;
 
    static value const going_away = 1001;
 
    static value const protocol_error = 1002;
 
 
    static value const unsupported_data = 1003;
 
 
    static value const no_status = 1005;
 
 
    static value const abnormal_close = 1006;
 
 
    static value const invalid_payload = 1007;
 
 
    static value const policy_violation = 1008;
 
    static value const message_too_big = 1009;
 
 
    static value const extension_required = 1010;
 
    static value const internal_endpoint_error = 1011;
 
    static value const service_restart = 1012;
 
    static value const try_again_later = 1013;
 
 
    static value const tls_handshake = 1015;
    
 
    static value const subprotocol_error = 3000;
    
 
    static value const invalid_subprotocol_data = 3001;
 
    static value const rsv_start = 1016;
    static value const rsv_end = 2999;
 
 
    inline bool reserved(value code) {
        return ((code >= rsv_start && code <= rsv_end) ||
                code == 1004 || code == 1014);
    }
 
    static value const invalid_low = 999;
    static value const invalid_high = 5000;
 
 
    inline bool invalid(value code) {
        return (code <= invalid_low || code >= invalid_high ||
                code == no_status || code == abnormal_close ||
                code == tls_handshake);
    }
 
 
    inline bool terminal(value code) {
        return (code == protocol_error || code == invalid_payload ||
                code == policy_violation || code == message_too_big ||
                 code == internal_endpoint_error);
    }
    
 
    inline std::string get_string(value code) {
        switch (code) {
            case normal:
                return "Normal close";
            case going_away:
                return "Going away";
            case protocol_error:
                return "Protocol error";
            case unsupported_data:
                return "Unsupported data";
            case no_status:
                return "No status set";
            case abnormal_close:
                return "Abnormal close";
            case invalid_payload:
                return "Invalid payload";
            case policy_violation:
                return "Policy violoation";
            case message_too_big:
                return "Message too big";
            case extension_required:
                return "Extension required";
            case internal_endpoint_error:
                return "Internal endpoint error";
            case tls_handshake:
                return "TLS handshake failure";
            case subprotocol_error:
                return "Generic subprotocol error";
            case invalid_subprotocol_data:
                return "Invalid subprotocol data";
            default:
                return "Unknown";
        }
    }
} // namespace status
 
union code_converter {
    uint16_t i;
    char c[2];
};
 
 
inline status::value extract_code(std::string const & payload, lib::error_code
    & ec)
{
    ec = lib::error_code();
 
    if (payload.size() == 0) {
        return status::no_status;
    } else if (payload.size() == 1) {
        ec = make_error_code(error::bad_close_code);
        return status::protocol_error;
    }
 
    code_converter val;
 
    val.c[0] = payload[0];
    val.c[1] = payload[1];
 
    status::value code(ntohs(val.i));
 
    if (status::invalid(code)) {
        ec = make_error_code(error::invalid_close_code);
    }
 
    if (status::reserved(code)) {
        ec = make_error_code(error::reserved_close_code);
    }
 
    return code;
}
 
 
inline std::string extract_reason(std::string const & payload, lib::error_code
    & ec)
{
    std::string reason;
    ec = lib::error_code();
 
    if (payload.size() > 2) {
        reason.append(payload.begin()+2,payload.end());
    }
 
    if (!websocketpp::utf8_validator::validate(reason)) {
        ec = make_error_code(error::invalid_utf8);
    }
 
    return reason;
}
 
} // namespace close
} // namespace websocketpp
 
#endif // WEBSOCKETPP_CLOSE_HPP