// daemon.cpp// 该例子演示结合ASIO和POSIX标准系统的fork系统调用，产生一个守护进程。//时间服务器？// Copyright (c) 2003-2014 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_service.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;//定义个UDP时间服务器类class udp_daytime_server{public:  udp_daytime_server(boost::asio::io_service& io_service)    : socket_(io_service, 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 || ec == boost::asio::error::message_size)    {      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_service io_service;    // 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.    //如果程序是通过shell启动的，那么所有错误将返回给用户。    udp_daytime_server server(io_service);    // 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.    //注册信号handlers。以便退出，停止。    boost::asio::signal_set signals(io_service, SIGINT, SIGTERM);    signals.async_wait(        boost::bind(&boost::asio::io_service::stop, &io_service));    // Inform the io_service that we are about to become a daemon. The    // io_service cleans up any internal resources, such as threads, that may    // interfere with forking.    //通知io_service，要将进程进行daemon化，io_service将清除任意内部资源？比如说线程，将会影响fork    io_service.notify_fork(boost::asio::io_service::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().    //fork该进程后，父进程退出。如果该进程是从shell启动的，那么对于用户来说将是立刻返回。    //fork一个新的进程也是随后调用setsid的先决条件。setsid创建一个新的会话。    //这些步骤是守护进程编程规则。详情见APUE第十三章。    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_service object is a local variable, this means        // we do not have to call:        //        //   io_service.notify_fork(boost::asio::io_service::fork_parent);        //        // However, this line should be added before each call to exit() if        // using a global io_service object. An additional call:        //        //   io_service.notify_fork(boost::asio::io_service::fork_prepare);        //        // should also precede the second fork().          /*              此处为父进程逻辑，当exit函数调用后。程序将不会调用局部变量的析构函数，而全局变量的析构函数会被调用。          因为io_service是局部对象，所以这就意味着我们没有必要调用          io_service.notify_fork(boost::asio::io_service::fork_parent);          但是，当使用io_service作为全局对象的时候，是有必要在每次调用exit之前调用以上一行代码。          另外需要在第二次fork前调用o_service.notify_fork(boost::asio::io_service::fork_prepare);          */        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.    //开启新的会话，并作为会话leader，与终端分离。    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    umask(0);    // A second fork ensures the process cannot acquire a controlling terminal.    //第二次fork保证该进程无法获取终端，因为不是leader？    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.    //重定向标准输出至log文件    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_service that we have finished becoming a daemon. The    // io_service uses this opportunity to create any internal file descriptors    // that need to be private to the new process.    //告知io_service已变成守护进程。    io_service.notify_fork(boost::asio::io_service::fork_child);    // The io_service can now be used normally.    syslog(LOG_INFO | LOG_USER, "Daemon started");    io_service.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;  }}