六十一、linux 编程—— 守护进程

61.1 介绍

• 守护进程(daemon)是生存期长的一种进程。它们常常在系统引导装入时启动，在系统关闭时终止
• 守护进程也称为后台进程
• 所有守护进程都以超级用户(用户 ID 为0)的优先权运行。
• 守护进程没有控制终端
• 守护进程的父进程都是 init 进程

62.2 例子

62.2.1 编程步骤

• 使用 umask 将文件模式创建屏蔽字设置为0
• 调用 fork ，然后让父进程退出(exit)
• 调用 setsid 创建一个新会话
• 将当前工作目录更改为根目录
• 关闭不需要的文件描述符

62.2.2 守护进程出错处理

• 由于守护进程完全脱离了控制终端，因此，不能像其他程序一样通过输出错误信息到控制台的方式来通知程序员
• 通常办法是使用 syslog 服务，将出错信息输出到"/var/log/syslog" 系统日志文件中去
• syslog 是 linux 中的系统日志管理服务，通过守护进程 syslog 来维护
• openlog 函数用于打开系统日志服务的一个连接
• syslog 函数用于向日志文件中写入信息，在这里可以规定消息的优先级、消息的输出格式等
• closelog 函数用于关闭系统日志服务的连接

62.2.3 函数原型

　　

　　

　　

61.2.4 例子

　　echo_tcp_server_daemon.c

#include <netdb.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <signal.h>
#include <fcntl.h>
#include <time.h>
#include <arpa/inet.h>
#include <errno.h>
#include <pthread.h>
#include <syslog.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "vector_fd.h"

vector_fd *vfd;
int sockfd;

/**
 * fd 对应于某个连接的客户端，和某一个连接的客户端进行双向通信(非阻塞方式)
 */
void do_service(int fd)
{
    char buff[512];
    memset(buff, 0, sizeof(buff));

    /**
     *  因为采用非阻塞方式，若读不到数据直接返回，
     *  直接服务于下一个客户端,
     *  因此不需要判断 size < 0 的情况 */
    ssize_t size = read(fd, buff, sizeof(buff));

    if(size == 0){
        /** 客户端已经关闭连接 */
        syslog(LOG_DEBUG, "client closed");
        /** 从动态数组中删除对应的 fd */
        remove_fd(vfd, fd);
        /** 关闭对应客户端的 socket */
        close(fd);
    }
    else if(size > 0){
        syslog(LOG_DEBUG, "%s", buff);
        if(write(fd, buff, size) < 0){
            if(errno == EPIPE){
                /** 客户端关闭连接 */
                syslog(LOG_DEBUG, "write error:%s
", strerror(errno));
                remove_fd(vfd, fd);
                close(fd);
            }
        }
    }
}

void out_addr(struct sockaddr_in *clientaddr)
{
    char ip[16];
    memset(ip, 0, sizeof(ip));
    int port = ntohs(clientaddr->sin_port);
    inet_ntop(AF_INET, &clientaddr->sin_addr.s_addr, ip, sizeof(ip));
    syslog(LOG_DEBUG, "%s(%d) connected!
", ip, port);
}

/** 遍历出动态数组中所有的描述符并加入到描述符集 set
 * 中，同时此函数返回动态数组中最大的那个描述符 */
int add_set(fd_set *set)
{
    FD_ZERO(set);   ///< 清空描述符集
    int max_fd = vfd->fd[0];
    int i = 0;
    for(; i < vfd->counter; i++){
        int fd = get_fd(vfd, i);
        if(fd > max_fd) max_fd = fd;
        FD_SET(fd, set);    ///< 将 fd 加入到描述符集中
    }

    return max_fd;
}

void *th_fn(void *arg)
{
    /** 设置超时时间 2s */
    struct timeval t;
    t.tv_sec = 2;
    t.tv_usec = 0;

    int n = 0;
    int maxfd;
    fd_set set; ///< 描述符集
    maxfd = add_set(&set);

    /**
     * 调用 select 函数会阻塞，委托内核去检查传入的描述符是否准备好，
     * 若有则返回准备好的描述符；超时则返回 0
     * 第一个参数为描述符集中的描述符的范围(最大描述符 + 1)
     */
    while((n = select(maxfd + 1, &set, NULL, NULL, &t)) >= 0){
        /** 检测哪些描述符准备好, 并和这些准备好的描述符对应的客户端进行数据的双向通信 */
        if(n > 0){
            int i = 0;
            for(; i < vfd->counter; i++){
                int fd = get_fd(vfd, i);
                if(FD_ISSET(fd, &set)){
                    do_service(fd);
                }
            }
        }
        /** 重新设置时间和清空描述符集 */
        t.tv_sec = 2;
        t.tv_usec = 0;
        /** 重新遍历动态数组中最新的描述符放置到描述符集中 */
        maxfd = add_set(&set);
    }

    return (void *)0;
}

int main(int argc, char *argv[])
{
    if(argc < 2){
        printf("usage: %s #port
", argv[0]);
        exit(1);
    }

    /** 守护进程编程的5个步骤 */
    /** 步骤1: 创建屏蔽字为 0 */
    umask(0);
    /** 步骤2: 调用 fork 函数创建子进程，然后父进程退出 */
    pid_t pid = fork();
    if(pid > 0) exit(0);
    /** 步骤3: 调用 setsid 函数创建一个新会话 */
    setsid();
    /** 步骤4: 将当前工作目录更改为更目录 */
    chdir("/");
    /** 步骤5: 关闭不需要的文件描述符 */
    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);

    /** 打开系统日志服务的一个连接 */
    openlog(argv[0], LOG_PID, LOG_SYSLOG);


    /** 步骤1: 创建 socket(套接字)
     *  注: socket 创建在内核中，是一个结构体.
     *  AF_INET: IPV4
     *  SOCK_STREAM: tcp 协议
     *  AF_INET6: IPV6
     */
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd < 0){
        /** 将日志信息写入到系统日志文件中(/var/log/syslog) */
        syslog(LOG_DEBUG, "socket:%s
", strerror(errno));
        exit(1);
    }

    /**
     * 步骤2: 调用 bind 函数将 socket 和地址(包括 ip、port)进行绑定
     */
    struct sockaddr_in  serveraddr;
    memset(&serveraddr, 0, sizeof(struct sockaddr_in));
    /** 往地址中填入 ip、port、internet 地址族类型 */
    serveraddr.sin_family = AF_INET;    ///< IPV4
    serveraddr.sin_port = htons(atoi(argv[1])); ///< 填入端口
    serveraddr.sin_addr.s_addr = INADDR_ANY; ///< 填入 IP 地址
    if(bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in))){
        syslog(LOG_DEBUG, "bind:%s
", strerror(errno));
        exit(1);
    }

    /**
     *  步骤3: 调用 listen 函数启动监听(指定 port 监听)
     *         通知系统去接受来自客户端的连接请求
     *         (将接受到的客户端连接请求放置到对应的队列中)
     *  第二个参数: 指定队列的长度
     */
    if(listen(sockfd, 10) < 0){
        syslog(LOG_DEBUG, "listen:%s
", strerror(errno));
        exit(1);
    }

    /** 创建放置套接字描述符 fd 的动态数组 */
    vfd = create_vector_fd();

    /** 设置线程的分离属性 */
    pthread_t th;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    int err;
    if((err = pthread_create(&th, &attr, th_fn, (void *)0)) != 0){
        syslog(LOG_DEBUG, "pthread create:%s
", strerror(errno));
        exit(1);
    }
    pthread_attr_destroy(&attr);

    /**
     * 1)主控线程获得客户端的链接，将新的 socket 描述符放置到动态数组中
     * 2) (a)启动的子线程调用 select 函数委托内核去检查传入到 select
     *       中的描述符是否准备好.
     *    (b)利用 FD_ISSET 来找出准备好的那些描述符,
     *       并和对应的客户端进行双向通信(非阻塞)
     */
    struct sockaddr_in clientaddr;
    socklen_t len = sizeof(clientaddr);

    while(1){
        /**
         *  步骤4: 调用 accept 函数从队列中获得一个客户端的请求连接, 并返回新的
         *         socket 描述符
         *  注意:  若没有客户端连接，调用此函数后会阻塞, 直到获得一个客户端的连接
         */
        /** 主控线程负责调用 accept 去获得客户端的连接 */
        int fd = accept(sockfd, (struct sockaddr *)&clientaddr, &len);
        if(fd < 0){
            syslog(LOG_DEBUG, "accept:%s
", strerror(errno));
            continue;
        }

        out_addr(&clientaddr);

        /** 将返回的新的 socket 描述符加入到动态数组中 */
        add_fd(vfd, fd);
    }
    closelog();

    return 0;
}

　　编译运行如下：

　　查看 /var/log/syslog/