[DEV] add v1.66.0

libs/asio/example/cpp03/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/cpp03/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 <boost/array.hpp>
+#include <boost/bind.hpp>
+#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::endpoint(udp::v4(), 13))
+  {
+    start_receive();
+  }
+
+private:
+  void start_receive()
+  {
+    socket_.async_receive_from(
+        boost::asio::buffer(recv_buffer_), remote_endpoint_,
+        boost::bind(&udp_daytime_server::handle_receive, this, _1));
+  }
+
+  void handle_receive(const boost::system::error_code& ec)
+  {
+    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);
+    }
+
+    start_receive();
+  }
+
+  udp::socket socket_;
+  udp::endpoint remote_endpoint_;
+  boost::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::bind(&boost::asio::io_context::stop, &io_context));
+
+    // 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/cpp03/fork/process_per_connection.cpp

@@ -0,0 +1,160 @@
+//
+// 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 <boost/array.hpp>
+#include <boost/bind.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::endpoint(tcp::v4(), port)),
+      socket_(io_context)
+  {
+    start_signal_wait();
+    start_accept();
+  }
+
+private:
+  void start_signal_wait()
+  {
+    signal_.async_wait(boost::bind(&server::handle_signal_wait, this));
+  }
+
+  void handle_signal_wait()
+  {
+    // 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) {}
+
+      start_signal_wait();
+    }
+  }
+
+  void start_accept()
+  {
+    acceptor_.async_accept(socket_,
+        boost::bind(&server::handle_accept, this, _1));
+  }
+
+  void handle_accept(const boost::system::error_code& ec)
+  {
+    if (!ec)
+    {
+      // 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();
+
+        start_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);
+
+        socket_.close();
+        start_accept();
+      }
+    }
+    else
+    {
+      std::cerr << "Accept error: " << ec.message() << std::endl;
+      start_accept();
+    }
+  }
+
+  void start_read()
+  {
+    socket_.async_read_some(boost::asio::buffer(data_),
+        boost::bind(&server::handle_read, this, _1, _2));
+  }
+
+  void handle_read(const boost::system::error_code& ec, std::size_t length)
+  {
+    if (!ec)
+      start_write(length);
+  }
+
+  void start_write(std::size_t length)
+  {
+    boost::asio::async_write(socket_, boost::asio::buffer(data_, length),
+        boost::bind(&server::handle_write, this, _1));
+  }
+
+  void handle_write(const boost::system::error_code& ec)
+  {
+    if (!ec)
+      start_read();
+  }
+
+  boost::asio::io_context& io_context_;
+  boost::asio::signal_set signal_;
+  tcp::acceptor acceptor_;
+  tcp::socket socket_;
+  boost::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;
+  }
+}