endpoint.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_ENDPOINT_HPP
#define WEBSOCKETPP_ENDPOINT_HPP
 
#include <websocketpp/connection.hpp>
 
#include <websocketpp/logger/levels.hpp>
#include <websocketpp/version.hpp>
 
#include <string>
 
namespace websocketpp {
 
template <typename connection, typename config>
class endpoint : public config::transport_type, public config::endpoint_base {
public:
    // Import appropriate types from our helper class
    // See endpoint_types for more details.
    typedef endpoint<connection,config> type;
 
    typedef typename config::transport_type transport_type;
    typedef typename config::concurrency_type concurrency_type;
 
    typedef connection connection_type;
    typedef typename connection_type::ptr connection_ptr;
    typedef typename connection_type::weak_ptr connection_weak_ptr;
 
    typedef typename transport_type::transport_con_type transport_con_type;
    typedef typename transport_con_type::ptr transport_con_ptr;
 
    typedef typename connection_type::message_handler message_handler;
    typedef typename connection_type::message_ptr message_ptr;
 
    typedef typename config::elog_type elog_type;
    typedef typename config::alog_type alog_type;
 
    typedef typename concurrency_type::scoped_lock_type scoped_lock_type;
    typedef typename concurrency_type::mutex_type mutex_type;
 
    typedef typename config::rng_type rng_type;
 
    // TODO: organize these
    typedef typename connection_type::termination_handler termination_handler;
 
    // This would be ideal. Requires C++11 though
    //friend connection;
 
    explicit endpoint(bool p_is_server)
      : m_alog(config::alog_level, log::channel_type_hint::access)
      , m_elog(config::elog_level, log::channel_type_hint::error)
      , m_user_agent(::websocketpp::user_agent)
      , 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_max_http_body_size(config::max_http_body_size)
      , m_is_server(p_is_server)
    {
        m_alog.set_channels(config::alog_level);
        m_elog.set_channels(config::elog_level);
 
        m_alog.write(log::alevel::devel, "endpoint constructor");
 
        transport_type::init_logging(&m_alog, &m_elog);
    }
 
 
    ~endpoint<connection,config>() {}
 
    #ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
        // no copy constructor because endpoints are not copyable
        endpoint(endpoint &) = delete;
    
        // no copy assignment operator because endpoints are not copyable
        endpoint & operator=(endpoint const &) = delete;
    #endif // _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
 
    #ifdef _WEBSOCKETPP_MOVE_SEMANTICS_
        endpoint(endpoint && o) 
         : config::transport_type(std::move(o))
         , config::endpoint_base(std::move(o))
         , m_alog(std::move(o.m_alog))
         , m_elog(std::move(o.m_elog))
         , m_user_agent(std::move(o.m_user_agent))
         , m_open_handler(std::move(o.m_open_handler))
         
         , m_close_handler(std::move(o.m_close_handler))
         , m_fail_handler(std::move(o.m_fail_handler))
         , m_ping_handler(std::move(o.m_ping_handler))
         , m_pong_handler(std::move(o.m_pong_handler))
         , m_pong_timeout_handler(std::move(o.m_pong_timeout_handler))
         , m_interrupt_handler(std::move(o.m_interrupt_handler))
         , m_http_handler(std::move(o.m_http_handler))
         , m_validate_handler(std::move(o.m_validate_handler))
         , m_message_handler(std::move(o.m_message_handler))
 
         , m_open_handshake_timeout_dur(o.m_open_handshake_timeout_dur)
         , m_close_handshake_timeout_dur(o.m_close_handshake_timeout_dur)
         , m_pong_timeout_dur(o.m_pong_timeout_dur)
         , m_max_message_size(o.m_max_message_size)
         , m_max_http_body_size(o.m_max_http_body_size)
 
         , m_rng(std::move(o.m_rng))
         , m_is_server(o.m_is_server)         
        {}
 
    #ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
        // no move assignment operator because of const member variables
        endpoint & operator=(endpoint &&) = delete;
    #endif // _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
 
    #endif // _WEBSOCKETPP_MOVE_SEMANTICS_
 
 
 
    std::string get_user_agent() const {
        scoped_lock_type guard(m_mutex);
        return m_user_agent;
    }
 
 
    void set_user_agent(std::string const & ua) {
        scoped_lock_type guard(m_mutex);
        m_user_agent = ua;
    }
 
 
    bool is_server() const {
        return m_is_server;
    }
 
    /********************************/
    /* Pass-through logging adaptor */
    /********************************/
 
 
    void set_access_channels(log::level channels) {
        m_alog.set_channels(channels);
    }
 
 
    void clear_access_channels(log::level channels) {
        m_alog.clear_channels(channels);
    }
 
 
    void set_error_channels(log::level channels) {
        m_elog.set_channels(channels);
    }
 
 
    void clear_error_channels(log::level channels) {
        m_elog.clear_channels(channels);
    }
 
 
    alog_type & get_alog() {
        return m_alog;
    }
 
 
    elog_type & get_elog() {
        return m_elog;
    }
 
    /*************************/
    /* Set Handler functions */
    /*************************/
 
    void set_open_handler(open_handler h) {
        m_alog.write(log::alevel::devel,"set_open_handler");
        scoped_lock_type guard(m_mutex);
        m_open_handler = h;
    }
    void set_close_handler(close_handler h) {
        m_alog.write(log::alevel::devel,"set_close_handler");
        scoped_lock_type guard(m_mutex);
        m_close_handler = h;
    }
    void set_fail_handler(fail_handler h) {
        m_alog.write(log::alevel::devel,"set_fail_handler");
        scoped_lock_type guard(m_mutex);
        m_fail_handler = h;
    }
    void set_ping_handler(ping_handler h) {
        m_alog.write(log::alevel::devel,"set_ping_handler");
        scoped_lock_type guard(m_mutex);
        m_ping_handler = h;
    }
    void set_pong_handler(pong_handler h) {
        m_alog.write(log::alevel::devel,"set_pong_handler");
        scoped_lock_type guard(m_mutex);
        m_pong_handler = h;
    }
    void set_pong_timeout_handler(pong_timeout_handler h) {
        m_alog.write(log::alevel::devel,"set_pong_timeout_handler");
        scoped_lock_type guard(m_mutex);
        m_pong_timeout_handler = h;
    }
    void set_interrupt_handler(interrupt_handler h) {
        m_alog.write(log::alevel::devel,"set_interrupt_handler");
        scoped_lock_type guard(m_mutex);
        m_interrupt_handler = h;
    }
    void set_http_handler(http_handler h) {
        m_alog.write(log::alevel::devel,"set_http_handler");
        scoped_lock_type guard(m_mutex);
        m_http_handler = h;
    }
    void set_validate_handler(validate_handler h) {
        m_alog.write(log::alevel::devel,"set_validate_handler");
        scoped_lock_type guard(m_mutex);
        m_validate_handler = h;
    }
    void set_message_handler(message_handler h) {
        m_alog.write(log::alevel::devel,"set_message_handler");
        scoped_lock_type guard(m_mutex);
        m_message_handler = h;
    }
 
    // Connection timeouts and other limits //
 
 
    void set_open_handshake_timeout(long dur) {
        scoped_lock_type guard(m_mutex);
        m_open_handshake_timeout_dur = dur;
    }
 
 
    void set_close_handshake_timeout(long dur) {
        scoped_lock_type guard(m_mutex);
        m_close_handshake_timeout_dur = dur;
    }
 
 
    void set_pong_timeout(long dur) {
        scoped_lock_type guard(m_mutex);
        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;
    }
 
 
    size_t get_max_http_body_size() const {
        return m_max_http_body_size;
    }
    
 
    void set_max_http_body_size(size_t new_value) {
        m_max_http_body_size = new_value;
    }
 
    /*************************************/
    /* Connection pass through functions */
    /*************************************/
 
    void interrupt(connection_hdl hdl, lib::error_code & ec);
    void interrupt(connection_hdl hdl);
 
 
    void pause_reading(connection_hdl hdl, lib::error_code & ec);
    
    void pause_reading(connection_hdl hdl);
 
 
    void resume_reading(connection_hdl hdl, lib::error_code & ec);
 
    void resume_reading(connection_hdl hdl);
 
 
    void send_http_response(connection_hdl hdl, lib::error_code & ec);
        
 
    void send_http_response(connection_hdl hdl);
 
 
    void send(connection_hdl hdl, std::string const & payload,
        frame::opcode::value op, lib::error_code & ec);
 
    void send(connection_hdl hdl, std::string const & payload,
        frame::opcode::value op);
 
    void send(connection_hdl hdl, void const * payload, size_t len,
        frame::opcode::value op, lib::error_code & ec);
    void send(connection_hdl hdl, void const * payload, size_t len,
        frame::opcode::value op);
 
    void send(connection_hdl hdl, message_ptr msg, lib::error_code & ec);
    void send(connection_hdl hdl, message_ptr msg);
 
    void close(connection_hdl hdl, close::status::value const code,
        std::string const & reason, lib::error_code & ec);
    void close(connection_hdl hdl, close::status::value const code,
        std::string const & reason);
 
 
    void ping(connection_hdl hdl, std::string const & payload,
        lib::error_code & ec);
 
    void ping(connection_hdl hdl, std::string const & payload);
 
 
    void pong(connection_hdl hdl, std::string const & payload,
        lib::error_code & ec);
 
    void pong(connection_hdl hdl, std::string const & payload);
 
 
    connection_ptr get_con_from_hdl(connection_hdl hdl, lib::error_code & ec) {
        connection_ptr con = lib::static_pointer_cast<connection_type>(
            hdl.lock());
        if (!con) {
            ec = error::make_error_code(error::bad_connection);
        }
        return con;
    }
 
    connection_ptr get_con_from_hdl(connection_hdl hdl) {
        lib::error_code ec;
        connection_ptr con = this->get_con_from_hdl(hdl,ec);
        if (ec) {
            throw exception(ec);
        }
        return con;
    }
protected:
    connection_ptr create_connection();
 
    alog_type m_alog;
    elog_type m_elog;
private:
    // dynamic settings
    std::string                 m_user_agent;
 
    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;
    size_t                      m_max_http_body_size;
 
    rng_type m_rng;
 
    // static settings
    bool const                  m_is_server;
 
    // endpoint state
    mutable mutex_type          m_mutex;
};
 
} // namespace websocketpp
 
#include <websocketpp/impl/endpoint_impl.hpp>
 
#endif // WEBSOCKETPP_ENDPOINT_HPP