add debug printing of basic headers

allows the processor to log directly to the connection’s log

examples/testee_server/testee_server.cpp

@@ -45,7 +45,7 @@ struct testee_config : public websocketpp::config::asio {
     typedef core::rng_type rng_type;
     typedef core::endpoint_base endpoint_base;
 
-    static bool const enable_multithreading = false;
+    static bool const enable_multithreading = true;
 
     struct transport_config : public core::transport_config {
         typedef core::concurrency_type concurrency_type;
@@ -54,7 +54,7 @@ struct testee_config : public websocketpp::config::asio {
         typedef core::request_type request_type;
         typedef core::response_type response_type;
 
-        static bool const enable_multithreading = false;
+        static bool const enable_multithreading = true;
     };
 
     typedef websocketpp::transport::asio::endpoint<transport_config>
@@ -104,6 +104,7 @@ int main(int argc, char * argv[]) {
 
         // Initialize ASIO
         testee_server.init_asio();
+        testee_server.set_reuse_addr(true);
 
         // Register our message handler
         testee_server.set_message_handler(bind(&on_message,&testee_server,::_1,::_2));

test/processors/hybi00.cpp

@@ -36,6 +36,7 @@
 #include <websocketpp/http/response.hpp>
 #include <websocketpp/message_buffer/message.hpp>
 #include <websocketpp/message_buffer/alloc.hpp>
+#include <websocketpp/logger/stub.hpp>
 
 struct stub_config {
 	typedef websocketpp::http::parser::request request_type;
@@ -46,7 +47,12 @@ struct stub_config {
 	typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
 		con_msg_manager_type;
 	
+	typedef websocketpp::log::stub alog_type;
+	typedef websocketpp::log::stub elog_type;
+	
 	static const size_t max_message_size = 16000000;
+	
+	
 };
 
 struct processor_setup {

test/processors/hybi07.cpp

@@ -38,6 +38,7 @@
 #include <websocketpp/message_buffer/alloc.hpp>
 #include <websocketpp/extensions/permessage_deflate/disabled.hpp>
 #include <websocketpp/random/none.hpp>
+#include <websocketpp/logger/stub.hpp>
 
 struct stub_config {
 	typedef websocketpp::http::parser::request request_type;
@@ -48,6 +49,9 @@ struct stub_config {
 	typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
 		con_msg_manager_type;
 
+    typedef websocketpp::log::stub alog_type;
+	typedef websocketpp::log::stub elog_type;
+
     typedef websocketpp::random::none::int_generator<uint32_t> rng_type;
 
     static const size_t max_message_size = 16000000;

test/processors/hybi08.cpp

@@ -38,6 +38,7 @@
 #include <websocketpp/message_buffer/alloc.hpp>
 #include <websocketpp/extensions/permessage_deflate/disabled.hpp>
 #include <websocketpp/random/none.hpp>
+#include <websocketpp/logger/stub.hpp>
 
 struct stub_config {
 	typedef websocketpp::http::parser::request request_type;
@@ -48,6 +49,9 @@ struct stub_config {
 	typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
 		con_msg_manager_type;
 
+    typedef websocketpp::log::stub alog_type;
+	typedef websocketpp::log::stub elog_type;
+
     typedef websocketpp::random::none::int_generator<uint32_t> rng_type;
 
     static const size_t max_message_size = 16000000;

test/processors/hybi13.cpp

@@ -38,6 +38,7 @@
 #include <websocketpp/message_buffer/message.hpp>
 #include <websocketpp/message_buffer/alloc.hpp>
 #include <websocketpp/random/none.hpp>
+#include <websocketpp/logger/stub.hpp>
 
 #include <websocketpp/extensions/permessage_deflate/disabled.hpp>
 #include <websocketpp/extensions/permessage_deflate/enabled.hpp>
@@ -51,6 +52,9 @@ struct stub_config {
 	typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
 		con_msg_manager_type;
 
+    typedef websocketpp::log::stub alog_type;
+	typedef websocketpp::log::stub elog_type;
+
     typedef websocketpp::random::none::int_generator<uint32_t> rng_type;
 
     struct permessage_deflate_config {
@@ -73,6 +77,9 @@ struct stub_config_ext {
 	typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
 		con_msg_manager_type;
 
+    typedef websocketpp::log::stub alog_type;
+	typedef websocketpp::log::stub elog_type;
+
     typedef websocketpp::random::none::int_generator<uint32_t> rng_type;
 
     struct permessage_deflate_config {

websocketpp/impl/connection_impl.hpp

@@ -95,7 +95,9 @@ lib::error_code connection<config>::send(const void* payload, size_t len,
 template <typename config>
 lib::error_code connection<config>::send(typename config::message_type::ptr msg)
 {
-    m_alog.write(log::alevel::devel,"connection send");
+    if (m_alog.static_test(log::alevel::devel)) {
+        m_alog.write(log::alevel::devel,"connection send");
+    }
     // TODO:
 
     if (m_state != session::state::open) {
@@ -141,7 +143,9 @@ lib::error_code connection<config>::send(typename config::message_type::ptr msg)
 
 template <typename config>
 void connection<config>::ping(const std::string& payload, lib::error_code& ec) {
-    m_alog.write(log::alevel::devel,"connection ping");
+    if (m_alog.static_test(log::alevel::devel)) {
+        m_alog.write(log::alevel::devel,"connection ping");
+    }
 
     if (m_state != session::state::open) {
         ec = error::make_error_code(error::invalid_state);
@@ -230,7 +234,9 @@ void connection<config>::handle_pong_timeout(std::string payload, const lib::err
 
 template <typename config>
 void connection<config>::pong(const std::string& payload, lib::error_code& ec) {
-    m_alog.write(log::alevel::devel,"connection pong");
+    if (m_alog.static_test(log::alevel::devel)) {
+        m_alog.write(log::alevel::devel,"connection pong");
+    }
 
     if (m_state != session::state::open) {
         ec = error::make_error_code(error::invalid_state);
@@ -276,7 +282,9 @@ template <typename config>
 void connection<config>::close(close::status::value const code,
     std::string const & reason, lib::error_code & ec)
 {
-    m_alog.write(log::alevel::devel,"connection close");
+    if (m_alog.static_test(log::alevel::devel)) {
+        m_alog.write(log::alevel::devel,"connection close");
+    }
 
     if (m_state != session::state::open) {
        ec = error::make_error_code(error::invalid_state);
@@ -957,7 +965,7 @@ void connection<config>::handle_read_frame(lib::error_code const & ec,
         if (m_processor->ready()) {
             if (m_alog.static_test(log::alevel::devel)) {
                 std::stringstream s;
-                s << "Complete frame received. Dispatching";
+                s << "Complete message received. Dispatching";
                 m_alog.write(log::alevel::devel,s.str());
             }
 
@@ -1997,6 +2005,7 @@ connection<config>::get_processor(int version) const {
     }
     
     // Settings not configured by the constructor
+    p->init_logging(&m_alog,&m_elog);
     p->set_max_message_size(m_max_message_size);
     
     return p;
@@ -2012,10 +2021,12 @@ void connection<config>::write_push(typename config::message_type::ptr msg)
     m_send_buffer_size += msg->get_payload().size();
     m_send_queue.push(msg);
 
-    std::stringstream s;
+    if (m_alog.static_test(log::alevel::devel)) {
-    s << "write_push: message count: " << m_send_queue.size()
+        std::stringstream s;
-      << " buffer size: " << m_send_buffer_size;
+        s << "write_push: message count: " << m_send_queue.size()
-    m_alog.write(log::alevel::devel,s.str());
+          << " buffer size: " << m_send_buffer_size;
+        m_alog.write(log::alevel::devel,s.str());
+    }
 }
 
 template <typename config>
@@ -2032,10 +2043,12 @@ typename config::message_type::ptr connection<config>::write_pop()
     m_send_buffer_size -= msg->get_payload().size();
     m_send_queue.pop();
 
-    std::stringstream s;
+    if (m_alog.static_test(log::alevel::devel)) {
-    s << "write_pop: message count: " << m_send_queue.size()
+        std::stringstream s;
-      << " buffer size: " << m_send_buffer_size;
+        s << "write_pop: message count: " << m_send_queue.size()
-    m_alog.write(log::alevel::devel,s.str());
+          << " buffer size: " << m_send_buffer_size;
+        m_alog.write(log::alevel::devel,s.str());
+    }
     return msg;
 }
 

websocketpp/processors/hybi13.hpp

@@ -331,6 +331,14 @@ public:
                     continue;
                 }
 
+                if (base::m_alog->static_test(log::alevel::devel)) {
+                    std::stringstream s;
+                    s << "Received frame basic header: "
+                      << utility::to_hex(&m_basic_header.b0,1)
+                      << utility::to_hex(&m_basic_header.b1,1);
+                    base::m_alog->write(log::alevel::devel,s.str());
+                }
+
                 ec = this->validate_incoming_basic_header(
                     m_basic_header, base::m_server, !m_data_msg.msg_ptr
                 );
@@ -348,6 +356,17 @@ public:
                     continue;
                 }
 
+                if (base::m_alog->static_test(log::alevel::devel)) {
+                    std::stringstream s;
+                    s << "Received frame full header: "
+                      << utility::to_hex(&m_basic_header.b0,1)
+                      << utility::to_hex(&m_basic_header.b1,1)
+                      << utility::to_hex(m_extended_header.bytes,
+                            frame::get_header_len(m_basic_header) -
+                            frame::BASIC_HEADER_LENGTH);
+                    base::m_alog->write(log::alevel::devel,s.str());
+                }
+
                 ec = validate_incoming_extended_header(m_basic_header,m_extended_header);
                 if (ec){break;}
 

websocketpp/processors/processor.hpp

@@ -31,9 +31,12 @@
 #include <websocketpp/processors/base.hpp>
 #include <websocketpp/common/system_error.hpp>
 
+
 #include <websocketpp/close.hpp>
+#include <websocketpp/common/cpp11.hpp>
 #include <websocketpp/utilities.hpp>
 #include <websocketpp/uri.hpp>
+#include <websocketpp/logger/levels.hpp>
 
 #include <map>
 #include <string>
@@ -159,10 +162,17 @@ public:
     typedef typename config::message_type::ptr message_ptr;
     typedef std::pair<lib::error_code,std::string> err_str_pair;
 
+    /// Type of this processor's error logging policy
+    typedef typename config::elog_type elog_type;
+    /// Type of this processor's access logging policy
+    typedef typename config::alog_type alog_type;
+
     explicit processor(bool secure, bool p_is_server)
       : m_secure(secure)
       , m_server(p_is_server)
       , m_max_message_size(config::max_message_size)
+      , m_elog(_WEBSOCKETPP_NULLPTR_TOKEN_)
+      , m_alog(_WEBSOCKETPP_NULLPTR_TOKEN_)
     {}
 
     virtual ~processor() {}
@@ -170,6 +180,25 @@ public:
     /// Get the protocol version of this processor
     virtual int get_version() const = 0;
 
+    /// Initialize logging
+    /**
+     * The loggers are managed by the owner of the processor. As such, the
+     * processor doesn't have direct access to them. This method is called by
+     * the owner to allow shared logging from the processor component. These are
+     * raw pointers to the logging types specified in the config. It is the
+     * responsibility of the owning object to ensure that they remain in scope
+     * until the processor goes out of scope.
+     *
+     * TODO: better way of handling non-initialized logging?
+     *
+     * @param a A pointer to the access logger to use.
+     * @param e A pointer to the error logger to use.
+     */
+    void init_logging(alog_type * a, elog_type * e) {
+        m_elog = e;
+        m_alog = a;
+    }
+
     /// Get maximum message size
     /**
      * Get maximum message size. Maximum message size determines the point at which the
@@ -389,6 +418,8 @@ protected:
     bool const m_secure;
     bool const m_server;
     size_t m_max_message_size;
+    elog_type* m_elog;
+    alog_type* m_alog;
 };
 
 } // namespace processor