passenger 6.0.7 → 6.0.8

data/src/cxx_supportlib/vendor-copy/websocketpp/websocketpp/transport/asio/connection.hpp

@@ -98,12 +98,12 @@ public:
     friend class endpoint<config>;
 
     // generate and manage our own io_service
-    explicit connection(bool is_server, alog_type & alog, elog_type & elog)
+    explicit connection(bool is_server, const lib::shared_ptr<alog_type> & alog, const lib::shared_ptr<elog_type> & elog)
       : m_is_server(is_server)
       , m_alog(alog)
       , m_elog(elog)
     {
-        m_alog.write(log::alevel::devel,"asio con transport constructor");
+        m_alog->write(log::alevel::devel,"asio con transport constructor");
     }
 
     /// Get a shared pointer to this component
@@ -284,7 +284,7 @@ public:
         std::string ret = socket_con_type::get_remote_endpoint(ec);
 
         if (ec) {
-            m_elog.write(log::elevel::info,ret);
+            m_elog->write(log::elevel::info,ret);
             return "Unknown";
         } else {
             return ret;
@@ -311,9 +311,10 @@ public:
      * needed.
      */
     timer_ptr set_timer(long duration, timer_handler callback) {
-        timer_ptr new_timer = lib::make_shared<lib::asio::steady_timer>(
-            lib::ref(*m_io_service),
-            lib::asio::milliseconds(duration)
+        timer_ptr new_timer(
+            new lib::asio::steady_timer(
+                *m_io_service,
+                lib::asio::milliseconds(duration))
         );
 
         if (config::enable_multithreading) {
@@ -408,8 +409,8 @@ public:
      */
 protected:
     void init(init_handler callback) {
-        if (m_alog.static_test(log::alevel::devel)) {
-            m_alog.write(log::alevel::devel,"asio connection init");
+        if (m_alog->static_test(log::alevel::devel)) {
+            m_alog->write(log::alevel::devel,"asio connection init");
         }
 
         // TODO: pre-init timeout. Right now no implemented socket policies
@@ -461,8 +462,7 @@ protected:
         m_io_service = io_service;
 
         if (config::enable_multithreading) {
-            m_strand = lib::make_shared<lib::asio::io_service::strand>(
-                lib::ref(*io_service));
+            m_strand.reset(new lib::asio::io_service::strand(*io_service));
         }
 
         lib::error_code ec = socket_con_type::init_asio(io_service, m_strand,
@@ -472,8 +472,8 @@ protected:
     }
 
     void handle_pre_init(init_handler callback, lib::error_code const & ec) {
-        if (m_alog.static_test(log::alevel::devel)) {
-            m_alog.write(log::alevel::devel,"asio connection handle pre_init");
+        if (m_alog->static_test(log::alevel::devel)) {
+            m_alog->write(log::alevel::devel,"asio connection handle pre_init");
         }
 
         if (m_tcp_pre_init_handler) {
@@ -494,8 +494,8 @@ protected:
     }
 
     void post_init(init_handler callback) {
-        if (m_alog.static_test(log::alevel::devel)) {
-            m_alog.write(log::alevel::devel,"asio connection post_init");
+        if (m_alog->static_test(log::alevel::devel)) {
+            m_alog->write(log::alevel::devel,"asio connection post_init");
         }
 
         timer_ptr post_timer;
@@ -540,7 +540,7 @@ protected:
 
         if (ec) {
             if (ec == transport::error::operation_aborted) {
-                m_alog.write(log::alevel::devel,
+                m_alog->write(log::alevel::devel,
                     "asio post init timer cancelled");
                 return;
             }
@@ -555,7 +555,7 @@ protected:
             }
         }
 
-        m_alog.write(log::alevel::devel, "Asio transport post-init timed out");
+        m_alog->write(log::alevel::devel, "Asio transport post-init timed out");
         cancel_socket_checked();
         callback(ret_ec);
     }
@@ -575,7 +575,7 @@ protected:
         if (ec == transport::error::operation_aborted ||
             (post_timer && lib::asio::is_neg(post_timer->expires_from_now())))
         {
-            m_alog.write(log::alevel::devel,"post_init cancelled");
+            m_alog->write(log::alevel::devel,"post_init cancelled");
             return;
         }
 
@@ -583,8 +583,8 @@ protected:
             post_timer->cancel();
         }
 
-        if (m_alog.static_test(log::alevel::devel)) {
-            m_alog.write(log::alevel::devel,"asio connection handle_post_init");
+        if (m_alog->static_test(log::alevel::devel)) {
+            m_alog->write(log::alevel::devel,"asio connection handle_post_init");
         }
 
         if (m_tcp_post_init_handler) {
@@ -595,12 +595,12 @@ protected:
     }
 
     void proxy_write(init_handler callback) {
-        if (m_alog.static_test(log::alevel::devel)) {
-            m_alog.write(log::alevel::devel,"asio connection proxy_write");
+        if (m_alog->static_test(log::alevel::devel)) {
+            m_alog->write(log::alevel::devel,"asio connection proxy_write");
         }
 
         if (!m_proxy_data) {
-            m_elog.write(log::elevel::library,
+            m_elog->write(log::elevel::library,
                 "assertion failed: !m_proxy_data in asio::connection::proxy_write");
             callback(make_error_code(error::general));
             return;
@@ -611,7 +611,7 @@ protected:
         m_bufs.push_back(lib::asio::buffer(m_proxy_data->write_buf.data(),
                                            m_proxy_data->write_buf.size()));
 
-        m_alog.write(log::alevel::devel,m_proxy_data->write_buf);
+        m_alog->write(log::alevel::devel,m_proxy_data->write_buf);
 
         // Set a timer so we don't wait forever for the proxy to respond
         m_proxy_data->timer = this->set_timer(
@@ -651,14 +651,14 @@ protected:
     void handle_proxy_timeout(init_handler callback, lib::error_code const & ec)
     {
         if (ec == transport::error::operation_aborted) {
-            m_alog.write(log::alevel::devel,
+            m_alog->write(log::alevel::devel,
                 "asio handle_proxy_write timer cancelled");
             return;
         } else if (ec) {
             log_err(log::elevel::devel,"asio handle_proxy_write",ec);
             callback(ec);
         } else {
-            m_alog.write(log::alevel::devel,
+            m_alog->write(log::alevel::devel,
                 "asio handle_proxy_write timer expired");
             cancel_socket_checked();
             callback(make_error_code(transport::error::timeout));
@@ -668,8 +668,8 @@ protected:
     void handle_proxy_write(init_handler callback,
         lib::asio::error_code const & ec)
     {
-        if (m_alog.static_test(log::alevel::devel)) {
-            m_alog.write(log::alevel::devel,
+        if (m_alog->static_test(log::alevel::devel)) {
+            m_alog->write(log::alevel::devel,
                 "asio connection handle_proxy_write");
         }
 
@@ -681,7 +681,7 @@ protected:
         if (ec == lib::asio::error::operation_aborted ||
             lib::asio::is_neg(m_proxy_data->timer->expires_from_now()))
         {
-            m_elog.write(log::elevel::devel,"write operation aborted");
+            m_elog->write(log::elevel::devel,"write operation aborted");
             return;
         }
 
@@ -696,12 +696,12 @@ protected:
     }
 
     void proxy_read(init_handler callback) {
-        if (m_alog.static_test(log::alevel::devel)) {
-            m_alog.write(log::alevel::devel,"asio connection proxy_read");
+        if (m_alog->static_test(log::alevel::devel)) {
+            m_alog->write(log::alevel::devel,"asio connection proxy_read");
         }
 
         if (!m_proxy_data) {
-            m_elog.write(log::elevel::library,
+            m_elog->write(log::elevel::library,
                 "assertion failed: !m_proxy_data in asio::connection::proxy_read");
             m_proxy_data->timer->cancel();
             callback(make_error_code(error::general));
@@ -742,8 +742,8 @@ protected:
     void handle_proxy_read(init_handler callback,
         lib::asio::error_code const & ec, size_t)
     {
-        if (m_alog.static_test(log::alevel::devel)) {
-            m_alog.write(log::alevel::devel,
+        if (m_alog->static_test(log::alevel::devel)) {
+            m_alog->write(log::alevel::devel,
                 "asio connection handle_proxy_read");
         }
 
@@ -753,7 +753,7 @@ protected:
         if (ec == lib::asio::error::operation_aborted ||
             lib::asio::is_neg(m_proxy_data->timer->expires_from_now()))
         {
-            m_elog.write(log::elevel::devel,"read operation aborted");
+            m_elog->write(log::elevel::devel,"read operation aborted");
             return;
         }
 
@@ -761,12 +761,12 @@ protected:
         m_proxy_data->timer->cancel();
 
         if (ec) {
-            m_elog.write(log::elevel::info,
+            m_elog->write(log::elevel::info,
                 "asio handle_proxy_read error: "+ec.message());
             callback(make_error_code(error::pass_through));
         } else {
             if (!m_proxy_data) {
-                m_elog.write(log::elevel::library,
+                m_elog->write(log::elevel::library,
                     "assertion failed: !m_proxy_data in asio::connection::handle_proxy_read");
                 callback(make_error_code(error::general));
                 return;
@@ -783,7 +783,7 @@ protected:
                 return;
             }
 
-            m_alog.write(log::alevel::devel,m_proxy_data->res.raw());
+            m_alog->write(log::alevel::devel,m_proxy_data->res.raw());
 
             if (m_proxy_data->res.get_status_code() != http::status_code::ok) {
                 // got an error response back
@@ -795,7 +795,7 @@ protected:
                   << " ("
                   << m_proxy_data->res.get_status_msg()
                   << ")";
-                m_elog.write(log::elevel::info,s.str());
+                m_elog->write(log::elevel::info,s.str());
                 callback(make_error_code(error::proxy_failed));
                 return;
             }
@@ -820,16 +820,16 @@ protected:
     void async_read_at_least(size_t num_bytes, char *buf, size_t len,
         read_handler handler)
     {
-        if (m_alog.static_test(log::alevel::devel)) {
+        if (m_alog->static_test(log::alevel::devel)) {
             std::stringstream s;
             s << "asio async_read_at_least: " << num_bytes;
-            m_alog.write(log::alevel::devel,s.str());
+            m_alog->write(log::alevel::devel,s.str());
         }
 
         // TODO: safety vs speed ?
         // maybe move into an if devel block
         /*if (num_bytes > len) {
-            m_elog.write(log::elevel::devel,
+            m_elog->write(log::elevel::devel,
                 "asio async_read_at_least error::invalid_num_bytes");
             handler(make_error_code(transport::error::invalid_num_bytes),
                 size_t(0));
@@ -871,7 +871,7 @@ protected:
     void handle_async_read(read_handler handler, lib::asio::error_code const & ec,
         size_t bytes_transferred)
     {
-        m_alog.write(log::alevel::devel, "asio con handle_async_read");
+        m_alog->write(log::alevel::devel, "asio con handle_async_read");
 
         // translate asio error codes into more lib::error_codes
         lib::error_code tec;
@@ -897,7 +897,7 @@ protected:
         } else {
             // This can happen in cases where the connection is terminated while
             // the transport is waiting on a read.
-            m_alog.write(log::alevel::devel,
+            m_alog->write(log::alevel::devel,
                 "handle_async_read called with null read handler");
         }
     }
@@ -989,7 +989,7 @@ protected:
         } else {
             // This can happen in cases where the connection is terminated while
             // the transport is waiting on a read.
-            m_alog.write(log::alevel::devel,
+            m_alog->write(log::alevel::devel,
                 "handle_async_write called with null write handler");
         }
     }
@@ -1034,8 +1034,8 @@ protected:
 
     /// close and clean up the underlying socket
     void async_shutdown(shutdown_handler callback) {
-        if (m_alog.static_test(log::alevel::devel)) {
-            m_alog.write(log::alevel::devel,"asio connection async_shutdown");
+        if (m_alog->static_test(log::alevel::devel)) {
+            m_alog->write(log::alevel::devel,"asio connection async_shutdown");
         }
 
         timer_ptr shutdown_timer;
@@ -1074,7 +1074,7 @@ protected:
 
         if (ec) {
             if (ec == transport::error::operation_aborted) {
-                m_alog.write(log::alevel::devel,
+                m_alog->write(log::alevel::devel,
                     "asio socket shutdown timer cancelled");
                 return;
             }
@@ -1085,7 +1085,7 @@ protected:
             ret_ec = make_error_code(transport::error::timeout);
         }
 
-        m_alog.write(log::alevel::devel,
+        m_alog->write(log::alevel::devel,
             "Asio transport socket shutdown timed out");
         cancel_socket_checked();
         callback(ret_ec);
@@ -1097,7 +1097,7 @@ protected:
         if (ec == lib::asio::error::operation_aborted ||
             lib::asio::is_neg(shutdown_timer->expires_from_now()))
         {
-            m_alog.write(log::alevel::devel,"async_shutdown cancelled");
+            m_alog->write(log::alevel::devel,"async_shutdown cancelled");
             return;
         }
 
@@ -1116,21 +1116,14 @@ protected:
                 tec = socket_con_type::translate_ec(ec);
                 m_tec = ec;
 
-                if (tec == transport::error::tls_short_read) {
-                    // TLS short read at this point is somewhat expected if both
-                    // sides try and end the connection at the same time or if
-                    // SSLv2 is being used. In general there is nothing that can
-                    // be done here other than a low level development log.
-                } else {
-                    // all other errors are effectively pass through errors of
-                    // some sort so print some detail on the info channel for
-                    // library users to look up if needed.
-                    log_err(log::elevel::info,"asio async_shutdown",ec);
-                }
+                // all other errors are effectively pass through errors of
+				// some sort so print some detail on the info channel for
+				// library users to look up if needed.
+				log_err(log::elevel::info,"asio async_shutdown",ec);
             }
         } else {
-            if (m_alog.static_test(log::alevel::devel)) {
-                m_alog.write(log::alevel::devel,
+            if (m_alog->static_test(log::alevel::devel)) {
+                m_alog->write(log::alevel::devel,
                     "asio con handle_async_shutdown");
             }
         }
@@ -1143,7 +1136,7 @@ protected:
         if (cec) {
             if (cec == lib::asio::error::operation_not_supported) {
                 // cancel not supported on this OS, ignore and log at dev level
-                m_alog.write(log::alevel::devel, "socket cancel not supported");
+                m_alog->write(log::alevel::devel, "socket cancel not supported");
             } else {
                 log_err(log::elevel::warn, "socket cancel failed", cec);
             }
@@ -1156,13 +1149,13 @@ private:
     void log_err(log::level l, const char * msg, const error_type & ec) {
         std::stringstream s;
         s << msg << " error: " << ec << " (" << ec.message() << ")";
-        m_elog.write(l,s.str());
+        m_elog->write(l,s.str());
     }
 
     // static settings
     const bool m_is_server;
-    alog_type& m_alog;
-    elog_type& m_elog;
+    lib::shared_ptr<alog_type> m_alog;
+    lib::shared_ptr<elog_type> m_elog;
 
     struct proxy_data {
         proxy_data() : timeout_proxy(config::timeout_proxy) {}

data/src/cxx_supportlib/vendor-copy/websocketpp/websocketpp/transport/asio/endpoint.hpp

@@ -35,6 +35,7 @@
 #include <websocketpp/uri.hpp>
 #include <websocketpp/logger/levels.hpp>
 
+#include <websocketpp/common/asio.hpp>
 #include <websocketpp/common/functional.hpp>
 
 #include <sstream>
@@ -87,11 +88,14 @@ public:
     /// Type of a shared pointer to an io_service work object
     typedef lib::shared_ptr<lib::asio::io_service::work> work_ptr;
 
+    /// Type of socket pre-bind handler
+    typedef lib::function<lib::error_code(acceptor_ptr)> tcp_pre_bind_handler;
+
     // generate and manage our own io_service
     explicit endpoint()
       : m_io_service(NULL)
       , m_external_io_service(false)
-      , m_listen_backlog(0)
+      , m_listen_backlog(lib::asio::socket_base::max_connections)
       , m_reuse_addr(false)
       , m_state(UNINITIALIZED)
     {
@@ -191,8 +195,7 @@ public:
 
         m_io_service = ptr;
         m_external_io_service = true;
-        m_acceptor = lib::make_shared<lib::asio::ip::tcp::acceptor>(
-            lib::ref(*m_io_service));
+        m_acceptor.reset(new lib::asio::ip::tcp::acceptor(*m_io_service));
 
         m_state = READY;
         ec = lib::error_code();
@@ -259,6 +262,19 @@ public:
         m_external_io_service = false;
     }
 
+    /// Sets the tcp pre bind handler
+    /**
+     * The tcp pre bind handler is called after the listen acceptor has
+     * been created but before the socket bind is performed.
+     *
+     * @since 0.8.0
+     *
+     * @param h The handler to call on tcp pre bind init.
+     */
+    void set_tcp_pre_bind_handler(tcp_pre_bind_handler h) {
+        m_tcp_pre_bind_handler = h;
+    }
+
     /// Sets the tcp pre init handler
     /**
      * The tcp pre init handler is called after the raw tcp connection has been
@@ -314,8 +330,10 @@ public:
      *
      * New values affect future calls to listen only.
      *
-     * A value of zero will use the operating system default. This is the
-     * default value.
+     * The default value is specified as *::asio::socket_base::max_connections
+     * which uses the operating system defined maximum queue length. Your OS
+     * may restrict or silently lower this value. A value of zero may cause
+     * all connections to be rejected.
      *
      * @since 0.3.0
      *
@@ -328,10 +346,13 @@ public:
     /// Sets whether to use the SO_REUSEADDR flag when opening listening sockets
     /**
      * Specifies whether or not to use the SO_REUSEADDR TCP socket option. What
-     * this flag does depends on your operating system. Please consult operating
-     * system documentation for more details.
+     * this flag does depends on your operating system.
      *
-     * New values affect future calls to listen only.
+     * Please consult operating system documentation for more details. There
+     * may be security consequences to enabling this option.
+     *
+     * New values affect future calls to listen only so set this value prior to
+     * calling listen.
      *
      * The default is false.
      *
@@ -403,27 +424,33 @@ public:
         lib::asio::error_code bec;
 
         m_acceptor->open(ep.protocol(),bec);
-        if (!bec) {
-            m_acceptor->set_option(lib::asio::socket_base::reuse_address(m_reuse_addr),bec);
-        }
-        if (!bec) {
-            m_acceptor->bind(ep,bec);
-        }
-        if (!bec) {
-            m_acceptor->listen(m_listen_backlog,bec);
-        }
-        if (bec) {
-            if (m_acceptor->is_open()) {
-                m_acceptor->close();
+        if (bec) {ec = clean_up_listen_after_error(bec);return;}
+        
+        m_acceptor->set_option(lib::asio::socket_base::reuse_address(m_reuse_addr),bec);
+        if (bec) {ec = clean_up_listen_after_error(bec);return;}
+        
+        // if a TCP pre-bind handler is present, run it
+        if (m_tcp_pre_bind_handler) {
+            ec = m_tcp_pre_bind_handler(m_acceptor);
+            if (ec) {
+                ec = clean_up_listen_after_error(ec);
+                return;
             }
-            log_err(log::elevel::info,"asio listen",bec);
-            ec = make_error_code(error::pass_through);
-        } else {
-            m_state = LISTENING;
-            ec = lib::error_code();
         }
+        
+        m_acceptor->bind(ep,bec);
+        if (bec) {ec = clean_up_listen_after_error(bec);return;}
+        
+        m_acceptor->listen(m_listen_backlog,bec);
+        if (bec) {ec = clean_up_listen_after_error(bec);return;}
+        
+        // Success
+        m_state = LISTENING;
+        ec = lib::error_code();
     }
 
+
+
     /// Set up endpoint for listening manually
     /**
      * Bind the internal acceptor using the settings specified by the endpoint e
@@ -660,9 +687,7 @@ public:
      * @since 0.3.0
      */
     void start_perpetual() {
-        m_work = lib::make_shared<lib::asio::io_service::work>(
-            lib::ref(*m_io_service)
-        );
+        m_work.reset(new lib::asio::io_service::work(*m_io_service));
     }
 
     /// Clears the endpoint's perpetual flag, allowing it to exit when empty
@@ -727,7 +752,7 @@ public:
                 m_elog->write(log::elevel::info,
                     "asio handle_timer error: "+ec.message());
                 log_err(log::elevel::info,"asio handle_timer",ec);
-                callback(make_error_code(error::pass_through));
+                callback(socket_con_type::translate_ec(ec));
             }
         } else {
             callback(lib::error_code());
@@ -743,7 +768,7 @@ public:
     void async_accept(transport_con_ptr tcon, accept_handler callback,
         lib::error_code & ec)
     {
-        if (m_state != LISTENING) {
+        if (m_state != LISTENING || !m_acceptor) {
             using websocketpp::error::make_error_code;
             ec = make_error_code(websocketpp::error::async_accept_not_listening);
             return;
@@ -795,7 +820,7 @@ protected:
      * haven't been constructed yet, and cannot be used in the transport
      * destructor as they will have been destroyed by then.
      */
-    void init_logging(alog_type* a, elog_type* e) {
+    void init_logging(const lib::shared_ptr<alog_type>& a, const lib::shared_ptr<elog_type>& e) {
         m_alog = a;
         m_elog = e;
     }
@@ -812,7 +837,7 @@ protected:
                 ret_ec = make_error_code(websocketpp::error::operation_canceled);
             } else {
                 log_err(log::elevel::info,"asio handle_accept",asio_ec);
-                ret_ec = make_error_code(error::pass_through);
+                ret_ec = socket_con_type::translate_ec(asio_ec);
             }
         }
 
@@ -826,8 +851,7 @@ protected:
 
         // Create a resolver
         if (!m_resolver) {
-            m_resolver = lib::make_shared<lib::asio::ip::tcp::resolver>(
-                lib::ref(*m_io_service));
+            m_resolver.reset(new lib::asio::ip::tcp::resolver(*m_io_service));
         }
 
         tcon->set_uri(u);
@@ -955,7 +979,7 @@ protected:
 
         if (ec) {
             log_err(log::elevel::info,"asio async_resolve",ec);
-            callback(make_error_code(error::pass_through));
+            callback(socket_con_type::translate_ec(ec));
             return;
         }
 
@@ -1063,7 +1087,7 @@ protected:
 
         if (ec) {
             log_err(log::elevel::info,"asio async_connect",ec);
-            callback(make_error_code(error::pass_through));
+            callback(socket_con_type::translate_ec(ec));
             return;
         }
 
@@ -1112,6 +1136,16 @@ private:
         m_elog->write(l,s.str());
     }
 
+    /// Helper for cleaning up in the listen method after an error
+    template <typename error_type>
+    lib::error_code clean_up_listen_after_error(error_type const & ec) {
+        if (m_acceptor->is_open()) {
+            m_acceptor->close();
+        }
+        log_err(log::elevel::info,"asio listen",ec);
+        return socket_con_type::translate_ec(ec);
+    }
+
     enum state {
         UNINITIALIZED = 0,
         READY = 1,
@@ -1119,6 +1153,7 @@ private:
     };
 
     // Handlers
+    tcp_pre_bind_handler    m_tcp_pre_bind_handler;
     tcp_init_handler    m_tcp_pre_init_handler;
     tcp_init_handler    m_tcp_post_init_handler;
 
@@ -1133,8 +1168,8 @@ private:
     int                 m_listen_backlog;
     bool                m_reuse_addr;
 
-    elog_type* m_elog;
-    alog_type* m_alog;
+    lib::shared_ptr<elog_type> m_elog;
+    lib::shared_ptr<alog_type> m_alog;
 
     // Transport state
     state               m_state;