connection.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_CONNECTION_HPP
#define WEBSOCKETPP_CONNECTION_HPP
 
#include <websocketpp/close.hpp>
#include <websocketpp/error.hpp>
#include <websocketpp/frame.hpp>
 
#include <websocketpp/logger/levels.hpp>
#include <websocketpp/processors/processor.hpp>
#include <websocketpp/transport/base/connection.hpp>
#include <websocketpp/http/constants.hpp>
 
#include <websocketpp/common/connection_hdl.hpp>
#include <websocketpp/common/cpp11.hpp>
#include <websocketpp/common/functional.hpp>
 
#include <queue>
#include <sstream>
#include <string>
#include <vector>
 
namespace websocketpp {
 
 
typedef lib::function<void(connection_hdl)> open_handler;
 
 
typedef lib::function<void(connection_hdl)> close_handler;
 
 
typedef lib::function<void(connection_hdl)> fail_handler;
 
 
typedef lib::function<void(connection_hdl)> interrupt_handler;
 
 
typedef lib::function<bool(connection_hdl,std::string)> ping_handler;
 
 
typedef lib::function<void(connection_hdl,std::string)> pong_handler;
 
 
typedef lib::function<void(connection_hdl,std::string)> pong_timeout_handler;
 
 
typedef lib::function<bool(connection_hdl)> validate_handler;
 
 
typedef lib::function<void(connection_hdl)> http_handler;
 
//
typedef lib::function<void(lib::error_code const & ec, size_t bytes_transferred)> read_handler;
typedef lib::function<void(lib::error_code const & ec)> write_frame_handler;
 
// constants related to the default WebSocket protocol versions available
#ifdef _WEBSOCKETPP_INITIALIZER_LISTS_ // simplified C++11 version
 
    static std::vector<int> const versions_supported = {0,7,8,13};
#else
    static int const helper[] = {0,7,8,13};
 
    static std::vector<int> const versions_supported(helper,helper+4);
#endif
 
namespace session {
namespace state {
    // externally visible session state (states based on the RFC)
    enum value {
        connecting = 0,
        open = 1,
        closing = 2,
        closed = 3
    };
} // namespace state
 
 
namespace fail {
namespace status {
    enum value {
        GOOD = 0,           // no failure yet!
        SYSTEM = 1,         // system call returned error, check that code
        WEBSOCKET = 2,      // websocket close codes contain error
        UNKNOWN = 3,        // No failure information is available
        TIMEOUT_TLS = 4,    // TLS handshake timed out
        TIMEOUT_WS = 5      // WS handshake timed out
    };
} // namespace status
} // namespace fail
 
namespace internal_state {
    // More granular internal states. These are used for multi-threaded
    // connection synchronization and preventing values that are not yet or no
    // longer available from being used.
 
    enum value {
        USER_INIT = 0,
        TRANSPORT_INIT = 1,
        READ_HTTP_REQUEST = 2,
        WRITE_HTTP_REQUEST = 3,
        READ_HTTP_RESPONSE = 4,
        WRITE_HTTP_RESPONSE = 5,
        PROCESS_HTTP_REQUEST = 6,
        PROCESS_CONNECTION = 7
    };
} // namespace internal_state
 
 
namespace http_state {
    // states to keep track of the progress of http connections
 
    enum value {
        init = 0,
        deferred = 1,
        headers_written = 2,
        body_written = 3,
        closed = 4
    };
} // namespace http_state
 
} // namespace session
 
template <typename config>
class connection
 : public config::transport_type::transport_con_type
 , public config::connection_base
{
public:
    typedef connection<config> type;
    typedef lib::shared_ptr<type> ptr;
    typedef lib::weak_ptr<type> weak_ptr;
 
    typedef typename config::concurrency_type concurrency_type;
    typedef typename config::alog_type alog_type;
    typedef typename config::elog_type elog_type;
 
    typedef typename config::transport_type::transport_con_type
        transport_con_type;
    typedef typename transport_con_type::ptr transport_con_ptr;
 
    typedef lib::function<void(ptr)> termination_handler;
 
    typedef typename concurrency_type::scoped_lock_type scoped_lock_type;
    typedef typename concurrency_type::mutex_type mutex_type;
 
    typedef typename config::request_type request_type;
    typedef typename config::response_type response_type;
 
    typedef typename config::message_type message_type;
    typedef typename message_type::ptr message_ptr;
 
    typedef typename config::con_msg_manager_type con_msg_manager_type;
    typedef typename con_msg_manager_type::ptr con_msg_manager_ptr;
 
    typedef typename config::rng_type rng_type;
 
    typedef processor::processor<config> processor_type;
    typedef lib::shared_ptr<processor_type> processor_ptr;
 
    // Message handler (needs to know message type)
    typedef lib::function<void(connection_hdl,message_ptr)> message_handler;
 
    typedef typename transport_con_type::timer_ptr timer_ptr;
 
    // Misc Convenience Types
    typedef session::internal_state::value istate_type;
 
private:
    enum terminate_status {
        failed = 1,
        closed,
        unknown
    };
public:
 
    explicit connection(bool p_is_server, std::string const & ua, alog_type& alog,
        elog_type& elog, rng_type & rng)
      : transport_con_type(p_is_server, alog, elog)
      , m_handle_read_frame(lib::bind(
            &type::handle_read_frame,
            this,
            lib::placeholders::_1,
            lib::placeholders::_2
        ))
      , m_write_frame_handler(lib::bind(
            &type::handle_write_frame,
            this,
            lib::placeholders::_1
        ))
      , m_user_agent(ua)
      , m_open_handshake_timeout_dur(config::timeout_open_handshake)
      , m_close_handshake_timeout_dur(config::timeout_close_handshake)
      , m_pong_timeout_dur(config::timeout_pong)
      , m_max_message_size(config::max_message_size)
      , m_state(session::state::connecting)
      , m_internal_state(session::internal_state::USER_INIT)
      , m_msg_manager(new con_msg_manager_type())
      , m_send_buffer_size(0)
      , m_write_flag(false)
      , m_read_flag(true)
      , m_is_server(p_is_server)
      , m_alog(alog)
      , m_elog(elog)
      , m_rng(rng)
      , m_local_close_code(close::status::abnormal_close)
      , m_remote_close_code(close::status::abnormal_close)
      , m_is_http(false)
      , m_http_state(session::http_state::init)
      , m_was_clean(false)
    {
        m_alog.write(log::alevel::devel,"connection constructor");
    }
 
    ptr get_shared() {
        return lib::static_pointer_cast<type>(transport_con_type::get_shared());
    }
 
    // Set Handler Callbacks //
 
 
    void set_open_handler(open_handler h) {
        m_open_handler = h;
    }
 
 
    void set_close_handler(close_handler h) {
        m_close_handler = h;
    }
 
 
    void set_fail_handler(fail_handler h) {
        m_fail_handler = h;
    }
 
 
    void set_ping_handler(ping_handler h) {
        m_ping_handler = h;
    }
 
 
    void set_pong_handler(pong_handler h) {
        m_pong_handler = h;
    }
 
 
    void set_pong_timeout_handler(pong_timeout_handler h) {
        m_pong_timeout_handler = h;
    }
 
 
    void set_interrupt_handler(interrupt_handler h) {
        m_interrupt_handler = h;
    }
 
 
    void set_http_handler(http_handler h) {
        m_http_handler = h;
    }
 
 
    void set_validate_handler(validate_handler h) {
        m_validate_handler = h;
    }
 
 
    void set_message_handler(message_handler h) {
        m_message_handler = h;
    }
 
    // Connection timeouts and other limits //
 
 
    void set_open_handshake_timeout(long dur) {
        m_open_handshake_timeout_dur = dur;
    }
 
 
    void set_close_handshake_timeout(long dur) {
        m_close_handshake_timeout_dur = dur;
    }
 
 
    void set_pong_timeout(long dur) {
        m_pong_timeout_dur = dur;
    }
 
 
    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;
        if (m_processor) {
            m_processor->set_max_message_size(new_value);
        }
    }
    
 
    size_t get_max_http_body_size() const {
        return m_request.get_max_body_size();
    }
    
 
    void set_max_http_body_size(size_t new_value) {
        m_request.set_max_body_size(new_value);
    }
 
    // Uncategorized public methods //
 
 
    size_t get_buffered_amount() const;
 
 
    size_t buffered_amount() const {
        return get_buffered_amount();
    }
 
    // Action Methods //
 
 
    lib::error_code send(std::string const & payload, frame::opcode::value op =
        frame::opcode::text);
 
 
    lib::error_code send(void const * payload, size_t len, frame::opcode::value
        op = frame::opcode::binary);
 
 
    lib::error_code send(message_ptr msg);
 
 
    lib::error_code interrupt();
    
    void handle_interrupt();
    
 
    lib::error_code pause_reading();
 
    void handle_pause_reading();
 
 
    lib::error_code resume_reading();
 
    void handle_resume_reading();
 
 
    void ping(std::string const & payload);
 
    void ping(std::string const & payload, lib::error_code & ec);
 
    void handle_pong_timeout(std::string payload, lib::error_code const & ec);
 
 
    void pong(std::string const & payload);
 
    void pong(std::string const & payload, lib::error_code & ec);
 
 
    void close(close::status::value const code, std::string const & reason);
 
    void close(close::status::value const code, std::string const & reason,
        lib::error_code & ec);
 
    // Pass-through access to the uri information //
 
 
    bool get_secure() const;
 
 
    std::string const & get_host() const;
 
 
    std::string const & get_resource() const;
 
 
    uint16_t get_port() const;
 
 
    uri_ptr get_uri() const;
 
 
    void set_uri(uri_ptr uri);
 
    // Subprotocol negotiation //
 
 
    std::string const & get_subprotocol() const;
 
 
    std::vector<std::string> const & get_requested_subprotocols() const;
 
 
    void add_subprotocol(std::string const & request, lib::error_code & ec);
 
 
    void add_subprotocol(std::string const & request);
 
 
    void select_subprotocol(std::string const & value, lib::error_code & ec);
 
 
    void select_subprotocol(std::string const & value);
 
    // Pass-through access to the request and response objects //
 
 
    std::string const & get_request_header(std::string const & key) const;
 
 
    std::string const & get_request_body() const;
 
 
    std::string const & get_response_header(std::string const & key) const;
 
 
    http::status_code::value get_response_code() const {
        return m_response.get_status_code();
    }
 
 
    std::string const & get_response_msg() const {
        return m_response.get_status_msg();
    }
    
 
    void set_status(http::status_code::value code);
 
 
    void set_status(http::status_code::value code, std::string const & msg);
 
 
    void set_body(std::string const & value);
    void set_body(std::string && value);
 
 
    void append_header(std::string const & key, std::string const & val);
 
 
    void replace_header(std::string const & key, std::string const & val);
 
 
    void remove_header(std::string const & key);
 
 
    request_type const & get_request() const {
        return m_request;
    }
    
 
    response_type const & get_response() const {
        return m_response;
    }
    
 
    lib::error_code defer_http_response();
    
 
    void send_http_response(lib::error_code & ec);
    
    void send_http_response();
    
    // TODO HTTPNBIO: write_headers
    // function that processes headers + status so far and writes it to the wire
    // beginning the HTTP response body state. This method will ignore anything
    // in the response body.
    
    // TODO HTTPNBIO: write_body_message
    // queues the specified message_buffer for async writing
    
    // TODO HTTPNBIO: finish connection
    //
    
    // TODO HTTPNBIO: write_response
    // Writes the whole response, headers + body and closes the connection
    
    
 
    // Pass-through access to the other connection information //
 
 
    connection_hdl get_handle() const {
        return m_connection_hdl;
    }
 
 
    bool is_server() const {
        return m_is_server;
    }
 
 
    std::string const & get_origin() const;
 
 
    session::state::value get_state() const;
 
 
 
    close::status::value get_local_close_code() const {
        return m_local_close_code;
    }
 
 
    std::string const & get_local_close_reason() const {
        return m_local_close_reason;
    }
 
 
    close::status::value get_remote_close_code() const {
        return m_remote_close_code;
    }
 
 
    std::string const & get_remote_close_reason() const {
        return m_remote_close_reason;
    }
 
 
    lib::error_code get_ec() const {
        return m_ec;
    }
 
 
    message_ptr get_message(websocketpp::frame::opcode::value op, size_t size)
        const
    {
        return m_msg_manager->get_message(op, size);
    }
 
    // The remaining public member functions are for internal/policy use  //
    // only. Do not call from application code unless you understand what //
    // you are doing.                                                     //
 
    
 
    void read_handshake(size_t num_bytes);
 
    void handle_read_handshake(lib::error_code const & ec,
        size_t bytes_transferred);
    void handle_read_http_response(lib::error_code const & ec,
        size_t bytes_transferred);
 
    
    void handle_write_http_response(lib::error_code const & ec);
    void handle_send_http_request(lib::error_code const & ec);
 
    void handle_open_handshake_timeout(lib::error_code const & ec);
    void handle_close_handshake_timeout(lib::error_code const & ec);
 
    void handle_read_frame(lib::error_code const & ec, size_t bytes_transferred);
    void read_frame();
 
    std::vector<int> const & get_supported_versions() const;
 
    void set_termination_handler(termination_handler new_handler);
 
    void terminate(lib::error_code const & ec);
    void handle_terminate(terminate_status tstat, lib::error_code const & ec);
 
 
    void write_frame();
 
 
    void handle_write_frame(lib::error_code const & ec);
// protected:
    // This set of methods would really like to be protected, but doing so 
    // requires that the endpoint be able to friend the connection. This is 
    // allowed with C++11, but not prior versions
 
    void start();
 
 
    void set_handle(connection_hdl hdl) {
        m_connection_hdl = hdl;
        transport_con_type::set_handle(hdl);
    }
protected:
    void handle_transport_init(lib::error_code const & ec);
 
    lib::error_code initialize_processor();
 
    lib::error_code process_handshake_request();
private:
    
 
    void write_http_response(lib::error_code const & ec);
 
    void send_http_request();
 
    void write_http_response_error(lib::error_code const & ec);
 
 
    void process_control_frame(message_ptr msg);
 
 
    lib::error_code send_close_ack(close::status::value code =
        close::status::blank, std::string const & reason = std::string());
 
 
    lib::error_code send_close_frame(close::status::value code =
        close::status::blank, std::string const & reason = std::string(), bool ack = false,
        bool terminal = false);
 
 
    processor_ptr get_processor(int version) const;
 
 
    void write_push(message_ptr msg);
 
 
    message_ptr write_pop();
 
 
    void log_open_result();
 
 
    void log_close_result();
 
 
    void log_fail_result();
    
 
    void log_http_result();
 
    template <typename error_type>
    void log_err(log::level l, char const * msg, error_type const & ec) {
        std::stringstream s;
        s << msg << " error: " << ec << " (" << ec.message() << ")";
        m_elog.write(l, s.str());
    }
 
    // internal handler functions
    read_handler            m_handle_read_frame;
    write_frame_handler     m_write_frame_handler;
 
    // static settings
    std::string const       m_user_agent;
 
    connection_hdl          m_connection_hdl;
 
    open_handler            m_open_handler;
    close_handler           m_close_handler;
    fail_handler            m_fail_handler;
    ping_handler            m_ping_handler;
    pong_handler            m_pong_handler;
    pong_timeout_handler    m_pong_timeout_handler;
    interrupt_handler       m_interrupt_handler;
    http_handler            m_http_handler;
    validate_handler        m_validate_handler;
    message_handler         m_message_handler;
 
    long                    m_open_handshake_timeout_dur;
    long                    m_close_handshake_timeout_dur;
    long                    m_pong_timeout_dur;
    size_t                  m_max_message_size;
 
 
    session::state::value   m_state;
 
 
    istate_type             m_internal_state;
 
    mutable mutex_type      m_connection_state_lock;
 
 
    mutex_type              m_write_lock;
 
    // connection resources
    char                    m_buf[config::connection_read_buffer_size];
    size_t                  m_buf_cursor;
    termination_handler     m_termination_handler;
    con_msg_manager_ptr     m_msg_manager;
    timer_ptr               m_handshake_timer;
    timer_ptr               m_ping_timer;
 
    std::string m_handshake_buffer;
 
 
    processor_ptr           m_processor;
 
 
    std::queue<message_ptr> m_send_queue;
 
 
    size_t m_send_buffer_size;
 
 
    std::vector<transport::buffer> m_send_buffer;
 
    std::vector<message_ptr> m_current_msgs;
 
 
    bool m_write_flag;
 
    bool m_read_flag;
 
    // connection data
    request_type            m_request;
    response_type           m_response;
    uri_ptr                 m_uri;
    std::string             m_subprotocol;
 
    // connection data that might not be necessary to keep around for the life
    // of the whole connection.
    std::vector<std::string> m_requested_subprotocols;
 
    bool const              m_is_server;
    alog_type& m_alog;
    elog_type& m_elog;
 
    rng_type & m_rng;
 
    // Close state
    close::status::value    m_local_close_code;
 
    std::string             m_local_close_reason;
 
    close::status::value    m_remote_close_code;
 
    std::string             m_remote_close_reason;
 
    lib::error_code m_ec;
    
    bool m_is_http;
    
    session::http_state::value m_http_state;
 
    bool m_was_clean;
 
    bool                    m_closed_by_me;
 
    bool                    m_failed_by_me;
 
    bool                    m_dropped_by_me;
};
 
} // namespace websocketpp
 
#include <websocketpp/impl/connection_impl.hpp>
 
#endif // WEBSOCKETPP_CONNECTION_HPP