Expose OS-chosen address and port from async_server

dnachbaur · dnachbaur · commit 3439043720e1 · 2017-02-01T11:21:30.000+01:00
diff --git a/boost/network/protocol/http/server/async_server.hpp b/boost/network/protocol/http/server/async_server.hpp
@@ -42,6 +42,7 @@ struct async_server_base : server_storage_base, socket_options_base {
         handler(options.handler()),
         address_(options.address()),
         port_(options.port()),
+        protocol_(options.protocol()),
         thread_pool(options.thread_pool()
                         ? options.thread_pool()
                         : std::make_shared<utils::thread_pool>()),
@@ -108,11 +109,19 @@ struct async_server_base : server_storage_base, socket_options_base {
     }
   }
 
+  /// Returns the server socket address, either IPv4 or IPv6 depending on
+  /// server_options.protocol()
+  const string_type& address() const { return address_; }
+
+  /// Returns the server socket port
+  const string_type& port() const { return port_; }
+
  private:
   typedef std::unique_lock<std::mutex> scoped_mutex_lock;
 
   Handler &handler;
   string_type address_, port_;
+  boost::asio::ip::tcp protocol_;
   std::shared_ptr<utils::thread_pool> thread_pool;
   boost::asio::ip::tcp::acceptor acceptor;
   bool stopping;
@@ -165,7 +174,7 @@ struct async_server_base : server_storage_base, socket_options_base {
     // this allows repeated cycles of run -> stop -> run
     service_.reset();
     tcp::resolver resolver(service_);
-    tcp::resolver::query query(address_, port_);
+    tcp::resolver::query query(protocol_, address_, port_);
     tcp::resolver::iterator endpoint_iterator = resolver.resolve(query, error);
     if (error) {
       BOOST_NETWORK_MESSAGE("Error resolving '" << address_ << ':' << port_);
@@ -185,6 +194,8 @@ struct async_server_base : server_storage_base, socket_options_base {
                                                      << port_);
       return;
     }
+    address_ = acceptor.local_endpoint().address().to_string();
+    port_ = std::to_string(acceptor.local_endpoint().port());
     acceptor.listen(boost::asio::socket_base::max_connections, error);
     if (error) {
       BOOST_NETWORK_MESSAGE("Error listening on socket: '"
diff --git a/boost/network/protocol/http/server/options.hpp b/boost/network/protocol/http/server/options.hpp
@@ -9,6 +9,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <memory>
+#include <boost/asio/ip/tcp.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/socket_base.hpp>
 #include <boost/network/protocol/stream_handler.hpp>
@@ -34,6 +35,7 @@ struct server_options {
         handler_(handler),
         address_("localhost"),
         port_("80"),
+        protocol_(boost::asio::ip::tcp::v6()),
         reuse_address_(false),
         report_aborted_(false),
         non_blocking_io_(true),
@@ -88,6 +90,12 @@ struct server_options {
     return *this;
   }
 
+  /// Set the protocol for address resolving and binding. Default is IPv6.
+  server_options &protocol(boost::asio::ip::tcp const &v) {
+    protocol_ = v;
+    return *this;
+  }
+
   /// Set whether to reuse the address (SO_REUSE_ADDR). Default is false.
   server_options &reuse_address(bool v) {
     reuse_address_ = v;
@@ -159,6 +167,9 @@ struct server_options {
   /// Returns the port to listen on.
   string_type port() const { return port_; }
 
+  /// Returns the protocol used for address resolving and binding.
+  boost::asio::ip::tcp protocol() const { return protocol_; }
+
   /// Returns a reference to the provided handler.
   Handler &handler() const { return handler_; }
 
@@ -215,6 +226,7 @@ struct server_options {
     swap(io_service_, other.io_service_);
     swap(address_, other.address_);
     swap(port_, other.port_);
+    swap(protocol_, other.protocol_);
     swap(reuse_address_, other.reuse_address_);
     swap(report_aborted_, other.report_aborted_);
     swap(non_blocking_io_, other.non_blocking_io_);
@@ -233,6 +245,7 @@ struct server_options {
   Handler &handler_;
   string_type address_;
   string_type port_;
+  boost::asio::ip::tcp protocol_;
   bool reuse_address_;
   bool report_aborted_;
   bool non_blocking_io_;
