processor.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015, 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_PROCESSOR_HPP
#define WEBSOCKETPP_PROCESSOR_HPP
 
#include <websocketpp/processors/base.hpp>
#include <websocketpp/common/system_error.hpp>
 
#include <websocketpp/close.hpp>
#include <websocketpp/utilities.hpp>
#include <websocketpp/uri.hpp>
 
#include <sstream>
#include <string>
#include <utility>
#include <vector>
 
namespace websocketpp {
 
namespace processor {
 
 
template <typename request_type>
bool is_websocket_handshake(request_type& r) {
    using utility::ci_find_substr;
 
    std::string const & upgrade_header = r.get_header("Upgrade");
 
    if (ci_find_substr(upgrade_header, constants::upgrade_token,
        sizeof(constants::upgrade_token)-1) == upgrade_header.end())
    {
        return false;
    }
 
    std::string const & con_header = r.get_header("Connection");
 
    if (ci_find_substr(con_header, constants::connection_token,
        sizeof(constants::connection_token)-1) == con_header.end())
    {
        return false;
    }
 
    return true;
}
 
 
template <typename request_type>
int get_websocket_version(request_type& r) {
    if (!r.ready()) {
        return -2;
    }
    
    if (r.get_header("Sec-WebSocket-Version").empty()) {
        return 0;
    }
 
    int version;
    std::istringstream ss(r.get_header("Sec-WebSocket-Version"));
 
    if ((ss >> version).fail()) {
        return -1;
    }
 
    return version;
}
 
 
template <typename request_type>
uri_ptr get_uri_from_host(request_type & request, std::string scheme) {
    std::string h = request.get_header("Host");
 
    size_t last_colon = h.rfind(":");
    size_t last_sbrace = h.rfind("]");
 
    // no : = hostname with no port
    // last : before ] = ipv6 literal with no port
    // : with no ] = hostname with port
    // : after ] = ipv6 literal with port
    if (last_colon == std::string::npos ||
        (last_sbrace != std::string::npos && last_sbrace > last_colon))
    {
        return lib::make_shared<uri>(scheme, h, request.get_uri());
    } else {
        return lib::make_shared<uri>(scheme,
                               h.substr(0,last_colon),
                               h.substr(last_colon+1),
                               request.get_uri());
    }
}
 
template <typename config>
class processor {
public:
    typedef processor<config> type;
    typedef typename config::request_type request_type;
    typedef typename config::response_type response_type;
    typedef typename config::message_type::ptr message_ptr;
    typedef std::pair<lib::error_code,std::string> err_str_pair;
 
    explicit processor(bool secure, bool p_is_server)
      : m_secure(secure)
      , m_server(p_is_server)
      , m_max_message_size(config::max_message_size)
    {}
 
    virtual ~processor() {}
 
    virtual int get_version() const = 0;
 
 
    size_t get_max_message_size() const {
        return m_max_message_size;
    }
    
 
    void set_max_message_size(size_t new_value) {
        m_max_message_size = new_value;
    }
 
 
    virtual bool has_permessage_compress() const {
        return false;
    }
 
 
    virtual err_str_pair negotiate_extensions(request_type const &) {
        return err_str_pair();
    }
    
 
    virtual err_str_pair negotiate_extensions(response_type const &) {
        return err_str_pair();
    }
 
 
    virtual lib::error_code validate_handshake(request_type const & request) const = 0;
 
 
    virtual lib::error_code process_handshake(request_type const & req,
        std::string const & subprotocol, response_type& res) const = 0;
 
 
    virtual lib::error_code client_handshake_request(request_type & req,
        uri_ptr uri, std::vector<std::string> const & subprotocols) const = 0;
 
 
    virtual lib::error_code validate_server_handshake_response(request_type
        const & req, response_type & res) const = 0;
 
    virtual std::string get_raw(response_type const & request) const = 0;
 
    virtual std::string const & get_origin(request_type const & request) const = 0;
 
 
    virtual lib::error_code extract_subprotocols(const request_type & req,
        std::vector<std::string> & subprotocol_list) = 0;
 
    virtual uri_ptr get_uri(request_type const & request) const = 0;
 
 
    virtual size_t consume(uint8_t *buf, size_t len, lib::error_code & ec) = 0;
 
 
    virtual bool ready() const = 0;
 
 
    virtual message_ptr get_message() = 0;
 
    virtual bool get_error() const = 0;
 
    virtual size_t get_bytes_needed() const {
        return 1;
    }
 
 
    virtual lib::error_code prepare_data_frame(message_ptr in, message_ptr out) = 0;
 
 
    virtual lib::error_code prepare_ping(std::string const & in, message_ptr out) const 
        = 0;
 
 
    virtual lib::error_code prepare_pong(std::string const & in, message_ptr out) const 
        = 0;
 
 
    virtual lib::error_code prepare_close(close::status::value code,
        std::string const & reason, message_ptr out) const = 0;
protected:
    bool const m_secure;
    bool const m_server;
    size_t m_max_message_size;
};
 
} // namespace processor
} // namespace websocketpp
 
#endif //WEBSOCKETPP_PROCESSOR_HPP