Using acceptor::close instead of acceptor::cancel

As raised by vusak and as documented by Boost.Asio
the recommended way for stopping all acceptor
operations is to use close instead of cancel.

Author: deanberris

boost/network/protocol/http/server/async_server.hpp

@@ -6,6 +6,7 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
+#include <boost/network/detail/debug.hpp>
 #include <boost/network/protocol/http/server/async_connection.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/network/protocol/http/server/storage_base.hpp>
@@ -56,12 +57,17 @@ namespace boost { namespace network { namespace http {
             // handlers finish.
             stopping = true;
             system::error_code ignored;
-            acceptor.cancel(ignored);
+            acceptor.close(ignored);
         }
 
         void listen() {
             boost::unique_lock<boost::mutex> listening_lock(listening_mutex_);
+            BOOST_NETWORK_MESSAGE("Listening on " << address_ << ':' << port_);
             if (!listening) start_listening();
+            if (!listening) {
+                BOOST_NETWORK_MESSAGE("Error listening on " << address_ << ':' << port_);
+                boost::throw_exception(std::runtime_error("Error listening on provided port."));
+            }
         }
 
     private:
@@ -94,33 +100,50 @@ namespace boost { namespace network { namespace http {
                             )
                         );
                 }
+            } else {
+                BOOST_NETWORK_MESSAGE("Error accepting connection, reason: " << ec);
             }
         }
-
+        
         void start_listening() {
             using boost::asio::ip::tcp;
-            tcp::resolver resolver(service_);
-            tcp::resolver::query query(address_, port_);
-            tcp::endpoint endpoint = *resolver.resolve(query);
 
             system::error_code error;
+            tcp::resolver resolver(service_);
+            tcp::resolver::query query(address_, port_);
+            tcp::resolver::iterator endpoint_iterator = resolver.resolve(query, error);
+            if (error) {
+                BOOST_NETWORK_MESSAGE("Error resolving '" << address_ << ':' << port_);
+                return;
+            }
+            tcp::endpoint endpoint = *endpoint_iterator;
             acceptor.open(endpoint.protocol(), error);
-            if (error) return;
+            if (error) {
+                BOOST_NETWORK_MESSAGE("Error opening socket: " << address_ << ":" << port_);
+                return;
+            }
             acceptor.bind(endpoint, error);
-            if (error) return;
+            if (error) {
+                BOOST_NETWORK_MESSAGE("Error binding socket: " << address_ << ":" << port_);
+                return;
+            }
             socket_options_base::acceptor_options(acceptor);
             acceptor.listen(asio::socket_base::max_connections, error);
-            if (error) return;
+            if (error) {
+                BOOST_NETWORK_MESSAGE("Error listening on socket: '" << error << "' on " << address_ << ":" << port_);
+                return;
+            }
             new_connection.reset(new connection(service_, handler, thread_pool));
             acceptor.async_accept(new_connection->socket(),
                 boost::bind(
                     &async_server_base<Tag,Handler>::handle_accept
                     , this
                     , boost::asio::placeholders::error));
             listening = true;
+            BOOST_NETWORK_MESSAGE("Now listening on socket: '" << address_ << ":" << port_ << "'");
         }
     };
-
+    
 } /* http */
 
 } /* network */

boost/network/protocol/http/server/sync_server.hpp

@@ -8,6 +8,7 @@
 #ifndef BOOST_NETWORK_PROTOCOL_HTTP_SERVER_SYNC_SERVER_HPP_20101025
 #define BOOST_NETWORK_PROTOCOL_HTTP_SERVER_SYNC_SERVER_HPP_20101025
 
+#include <boost/network/detail/debug.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/bind.hpp>
 #include <boost/asio/ip/tcp.hpp>
@@ -58,7 +59,7 @@ namespace boost { namespace network { namespace http {
         void stop() {
             // stop accepting new connections and let all the existing handlers finish.
             system::error_code ignored;
-            acceptor_.cancel(ignored);
+            acceptor_.close(ignored);
             service_.stop();
         }
 
@@ -89,13 +90,31 @@ namespace boost { namespace network { namespace http {
 
         void start_listening() {
             using boost::asio::ip::tcp;
+            system::error_code error;
             tcp::resolver resolver(service_);
             tcp::resolver::query query(address_, port_);
-            tcp::endpoint endpoint = *resolver.resolve(query);
-            acceptor_.open(endpoint.protocol());
+            tcp::resolver::iterator endpoint_iterator = resolver.resolve(query, error);
+            if (error) {
+                BOOST_NETWORK_MESSAGE("Error resolving address: " << address_ << ':' << port_);
+                return;
+            }
+            tcp::endpoint endpoint = *endpoint_iterator;
+            acceptor_.open(endpoint.protocol(), error);
+            if (error) {
+                BOOST_NETWORK_MESSAGE("Error opening socket: " << address_ << ':' << port_ << " -- reason: '" << error << '\'');
+                return;
+            }
             socket_options_base::acceptor_options(acceptor_);
-            acceptor_.bind(endpoint);
-            acceptor_.listen();
+            acceptor_.bind(endpoint, error);
+            if (error) {
+                BOOST_NETWORK_MESSAGE("Error binding to socket: " << address_ << ':' << port_ << " -- reason: '" << error << '\'');
+                return;
+            }
+            acceptor_.listen(tcp::socket::max_connections, error);
+            if (error) {
+                BOOST_NETWORK_MESSAGE("Error listening on socket: " << address_ << ':' << port_ << " -- reason: '" << error << '\'');
+                return;
+            }
             new_connection.reset(new sync_connection<Tag,Handler>(service_, handler_));
             acceptor_.async_accept(new_connection->socket(),
                 boost::bind(&sync_server_base<Tag,Handler>::handle_accept,