[DEV] add v1.66.0

libs/asio/example/cpp11/fork/Jamfile.v2

@@ -0,0 +1,59 @@
+#
+# Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+#
+# Distributed under the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#
+
+import os ;
+
+if [ os.name ] = SOLARIS
+{
+  lib socket ;
+  lib nsl ;
+}
+else if [ os.name ] = NT
+{
+  lib ws2_32 ;
+  lib mswsock ;
+}
+else if [ os.name ] = HPUX
+{
+  lib ipv6 ;
+}
+else if [ os.name ] = HAIKU
+{
+  lib network ;
+}
+
+exe daemon
+  : daemon.cpp
+    /boost/system//boost_system
+  : <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <os>SOLARIS:<library>socket
+    <os>SOLARIS:<library>nsl
+    <os>NT:<define>_WIN32_WINNT=0x0501
+    <os>NT,<toolset>gcc:<library>ws2_32
+    <os>NT,<toolset>gcc:<library>mswsock
+    <os>NT,<toolset>gcc-cygwin:<define>__USE_W32_SOCKETS
+    <os>HPUX,<toolset>gcc:<define>_XOPEN_SOURCE_EXTENDED
+    <os>HPUX:<library>ipv6
+    <os>HAIKU:<library>network
+  ;
+
+exe process_per_connection
+  : process_per_connection.cpp
+    /boost/system//boost_system
+  : <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <os>SOLARIS:<library>socket
+    <os>SOLARIS:<library>nsl
+    <os>NT:<define>_WIN32_WINNT=0x0501
+    <os>NT,<toolset>gcc:<library>ws2_32
+    <os>NT,<toolset>gcc:<library>mswsock
+    <os>NT,<toolset>gcc-cygwin:<define>__USE_W32_SOCKETS
+    <os>HPUX,<toolset>gcc:<define>_XOPEN_SOURCE_EXTENDED
+    <os>HPUX:<library>ipv6
+    <os>HAIKU:<library>network
+  ;

libs/asio/example/cpp11/fork/daemon.cpp

@@ -0,0 +1,189 @@
+//
+// daemon.cpp
+// ~~~~~~~~~~
+//
+// Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/ip/udp.hpp>
+#include <boost/asio/signal_set.hpp>
+#include <array>
+#include <ctime>
+#include <iostream>
+#include <syslog.h>
+#include <unistd.h>
+
+using boost::asio::ip::udp;
+
+class udp_daytime_server
+{
+public:
+  udp_daytime_server(boost::asio::io_context& io_context)
+    : socket_(io_context, {udp::v4(), 13})
+  {
+    receive();
+  }
+
+private:
+  void receive()
+  {
+    socket_.async_receive_from(
+        boost::asio::buffer(recv_buffer_), remote_endpoint_,
+        [this](boost::system::error_code ec, std::size_t /*n*/)
+        {
+          if (!ec)
+          {
+            using namespace std; // For time_t, time and ctime;
+            time_t now = time(0);
+            std::string message = ctime(&now);
+
+            boost::system::error_code ignored_ec;
+            socket_.send_to(boost::asio::buffer(message),
+                remote_endpoint_, 0, ignored_ec);
+          }
+
+          receive();
+        });
+  }
+
+  udp::socket socket_;
+  udp::endpoint remote_endpoint_;
+  std::array<char, 1> recv_buffer_;
+};
+
+int main()
+{
+  try
+  {
+    boost::asio::io_context io_context;
+
+    // Initialise the server before becoming a daemon. If the process is
+    // started from a shell, this means any errors will be reported back to the
+    // user.
+    udp_daytime_server server(io_context);
+
+    // Register signal handlers so that the daemon may be shut down. You may
+    // also want to register for other signals, such as SIGHUP to trigger a
+    // re-read of a configuration file.
+    boost::asio::signal_set signals(io_context, SIGINT, SIGTERM);
+    signals.async_wait(
+        [&](boost::system::error_code /*ec*/, int /*signo*/)
+        {
+          io_context.stop();
+        });
+
+    // Inform the io_context that we are about to become a daemon. The
+    // io_context cleans up any internal resources, such as threads, that may
+    // interfere with forking.
+    io_context.notify_fork(boost::asio::io_context::fork_prepare);
+
+    // Fork the process and have the parent exit. If the process was started
+    // from a shell, this returns control to the user. Forking a new process is
+    // also a prerequisite for the subsequent call to setsid().
+    if (pid_t pid = fork())
+    {
+      if (pid > 0)
+      {
+        // We're in the parent process and need to exit.
+        //
+        // When the exit() function is used, the program terminates without
+        // invoking local variables' destructors. Only global variables are
+        // destroyed. As the io_context object is a local variable, this means
+        // we do not have to call:
+        //
+        //   io_context.notify_fork(boost::asio::io_context::fork_parent);
+        //
+        // However, this line should be added before each call to exit() if
+        // using a global io_context object. An additional call:
+        //
+        //   io_context.notify_fork(boost::asio::io_context::fork_prepare);
+        //
+        // should also precede the second fork().
+        exit(0);
+      }
+      else
+      {
+        syslog(LOG_ERR | LOG_USER, "First fork failed: %m");
+        return 1;
+      }
+    }
+
+    // Make the process a new session leader. This detaches it from the
+    // terminal.
+    setsid();
+
+    // A process inherits its working directory from its parent. This could be
+    // on a mounted filesystem, which means that the running daemon would
+    // prevent this filesystem from being unmounted. Changing to the root
+    // directory avoids this problem.
+    chdir("/");
+
+    // The file mode creation mask is also inherited from the parent process.
+    // We don't want to restrict the permissions on files created by the
+    // daemon, so the mask is cleared.
+    umask(0);
+
+    // A second fork ensures the process cannot acquire a controlling terminal.
+    if (pid_t pid = fork())
+    {
+      if (pid > 0)
+      {
+        exit(0);
+      }
+      else
+      {
+        syslog(LOG_ERR | LOG_USER, "Second fork failed: %m");
+        return 1;
+      }
+    }
+
+    // Close the standard streams. This decouples the daemon from the terminal
+    // that started it.
+    close(0);
+    close(1);
+    close(2);
+
+    // We don't want the daemon to have any standard input.
+    if (open("/dev/null", O_RDONLY) < 0)
+    {
+      syslog(LOG_ERR | LOG_USER, "Unable to open /dev/null: %m");
+      return 1;
+    }
+
+    // Send standard output to a log file.
+    const char* output = "/tmp/asio.daemon.out";
+    const int flags = O_WRONLY | O_CREAT | O_APPEND;
+    const mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
+    if (open(output, flags, mode) < 0)
+    {
+      syslog(LOG_ERR | LOG_USER, "Unable to open output file %s: %m", output);
+      return 1;
+    }
+
+    // Also send standard error to the same log file.
+    if (dup(1) < 0)
+    {
+      syslog(LOG_ERR | LOG_USER, "Unable to dup output descriptor: %m");
+      return 1;
+    }
+
+    // Inform the io_context that we have finished becoming a daemon. The
+    // io_context uses this opportunity to create any internal file descriptors
+    // that need to be private to the new process.
+    io_context.notify_fork(boost::asio::io_context::fork_child);
+
+    // The io_context can now be used normally.
+    syslog(LOG_INFO | LOG_USER, "Daemon started");
+    io_context.run();
+    syslog(LOG_INFO | LOG_USER, "Daemon stopped");
+  }
+  catch (std::exception& e)
+  {
+    syslog(LOG_ERR | LOG_USER, "Exception: %s", e.what());
+    std::cerr << "Exception: " << e.what() << std::endl;
+  }
+}

libs/asio/example/cpp11/fork/process_per_connection.cpp

@@ -0,0 +1,162 @@
+//
+// process_per_connection.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/signal_set.hpp>
+#include <boost/asio/write.hpp>
+#include <cstdlib>
+#include <iostream>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+using boost::asio::ip::tcp;
+
+class server
+{
+public:
+  server(boost::asio::io_context& io_context, unsigned short port)
+    : io_context_(io_context),
+      signal_(io_context, SIGCHLD),
+      acceptor_(io_context, {tcp::v4(), port}),
+      socket_(io_context)
+  {
+    wait_for_signal();
+    accept();
+  }
+
+private:
+  void wait_for_signal()
+  {
+    signal_.async_wait(
+        [this](boost::system::error_code /*ec*/, int /*signo*/)
+        {
+          // Only the parent process should check for this signal. We can
+          // determine whether we are in the parent by checking if the acceptor
+          // is still open.
+          if (acceptor_.is_open())
+          {
+            // Reap completed child processes so that we don't end up with
+            // zombies.
+            int status = 0;
+            while (waitpid(-1, &status, WNOHANG) > 0) {}
+
+            wait_for_signal();
+          }
+        });
+  }
+
+  void accept()
+  {
+    acceptor_.async_accept(
+        [this](boost::system::error_code ec, tcp::socket new_socket)
+        {
+          if (!ec)
+          {
+            // Take ownership of the newly accepted socket.
+            socket_ = std::move(new_socket);
+
+            // Inform the io_context that we are about to fork. The io_context
+            // cleans up any internal resources, such as threads, that may
+            // interfere with forking.
+            io_context_.notify_fork(boost::asio::io_context::fork_prepare);
+
+            if (fork() == 0)
+            {
+              // Inform the io_context that the fork is finished and that this
+              // is the child process. The io_context uses this opportunity to
+              // create any internal file descriptors that must be private to
+              // the new process.
+              io_context_.notify_fork(boost::asio::io_context::fork_child);
+
+              // The child won't be accepting new connections, so we can close
+              // the acceptor. It remains open in the parent.
+              acceptor_.close();
+
+              // The child process is not interested in processing the SIGCHLD
+              // signal.
+              signal_.cancel();
+
+              read();
+            }
+            else
+            {
+
+              // Inform the io_context that the fork is finished (or failed)
+              // and that this is the parent process. The io_context uses this
+              // opportunity to recreate any internal resources that were
+              // cleaned up during preparation for the fork.
+              io_context_.notify_fork(boost::asio::io_context::fork_parent);
+
+              // The parent process can now close the newly accepted socket. It
+              // remains open in the child.
+              socket_.close();
+
+              accept();
+            }
+          }
+          else
+          {
+            std::cerr << "Accept error: " << ec.message() << std::endl;
+            accept();
+          }
+        });
+  }
+
+  void read()
+  {
+    socket_.async_read_some(boost::asio::buffer(data_),
+        [this](boost::system::error_code ec, std::size_t length)
+        {
+          if (!ec)
+            write(length);
+        });
+  }
+
+  void write(std::size_t length)
+  {
+    boost::asio::async_write(socket_, boost::asio::buffer(data_, length),
+        [this](boost::system::error_code ec, std::size_t /*length*/)
+        {
+          if (!ec)
+            read();
+        });
+  }
+
+  boost::asio::io_context& io_context_;
+  boost::asio::signal_set signal_;
+  tcp::acceptor acceptor_;
+  tcp::socket socket_;
+  std::array<char, 1024> data_;
+};
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 2)
+    {
+      std::cerr << "Usage: process_per_connection <port>\n";
+      return 1;
+    }
+
+    boost::asio::io_context io_context;
+
+    using namespace std; // For atoi.
+    server s(io_context, atoi(argv[1]));
+
+    io_context.run();
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << std::endl;
+  }
+}