Linux 网络编程详解六（多进程服务器僵尸进程解决方案）

小结：在点对点p2p程序中，服务器端子程序退出，子进程会主动发送信号，关闭父进程，
但是这种模式导致服务器只能支持一个客户端连接，本章节中使用新的框架，子进程退出，不主动发送信号关闭父进程，而是父进程安装SIGCHLD信号，wait()子进程。
这样就支持了多客户端。

僵尸进程解决方案
.忽略SIGCHLD信号，这样不会出现僵尸进程
.安装信号，父进程接收到SIGCHLD信号后，wait()子进程

//头文件
int server_socket();

int client_socket();

//服务器端
#include "pub.h"

int main(int arg,char *args[])
{
    server_socket();
    return ;
}

//客户端
#include "pub.h"

int main(int arg,char *args[])
{
    client_socket();
    return ;
}

//辅助类实现
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <sys/wait.h>
#include <signal.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "pub.h"

ssize_t readn(int fd, const void *buf, ssize_t count)
{
    if (buf == NULL)
    {
        printf("readn() params is not correct !\n");
        return -;
    }
    //定义剩余字节数
    ssize_t lread = count;
    //定义辅助指针变量
    char *pbuf = (char *) buf;
    //定义每次读取的字节数
    ssize_t nread = ;
    while (lread > )
    {
        nread = read(fd, pbuf, lread);
        if (nread == -)
        {
            //read是可中断睡眠函数，需要屏蔽信号
            if (errno == EINTR)
                continue;
            perror("read() err");
            return -;
        } else if (nread == )
        {
            printf("peer read socket is closed !\n");
            //返回已经读取的字节数
            return count - lread;
        }
        //重置剩余字节数
        lread -= nread;
        //辅助指针后移
        pbuf += nread;
    }
    return count;
}

ssize_t writen(int fd, const void *buf, ssize_t count)
{
    if (buf == NULL)
    {
        printf("writen() params is not correct !\n");
        return -;
    }
    //定于剩余字节数
    ssize_t lwrite = count;
    //定义每次写入字节数
    ssize_t nwrite = ;
    //定义辅助指针变量
    char *pbuf = (char *) buf;
    while (lwrite > )
    {
        nwrite = write(fd, pbuf, lwrite);
        if (nwrite == -)
        {
            if (errno == EINTR)
                continue;
            perror("write() err");
            return -;
        } else if (nwrite == )
        {
            printf("peer write socket is closed !\n");
            return count - lwrite;
        }
        //重置剩余字节数
        lwrite -= nwrite;
        //辅助指针变量后移
        pbuf += nwrite;
    }
    return count;
}

ssize_t recv_peek(int fd, const void *buf, ssize_t count)
{
    if (buf == NULL)
    {
        printf("recv_peek() params is not correct !\n");
        return -;
    }
    ssize_t ret = ;
    while ()
    {
        //此处有多少读取多少，不一定ret==count
        ret = recv(fd, (void *)buf, count, MSG_PEEK);
        if (ret == - && errno == EINTR)
            continue;
        return ret;
    }
    return -;
}

ssize_t mreadline(int fd, const void *buf, ssize_t count)
{
    //定义剩余字节数
    ssize_t lread = count;
    //定义每次读取的字节数
    ssize_t nread = ;
    //定义辅助指针变量
    char *pbuf = (char *) buf;
    int i = , ret = ;
    while ()
    {
        nread = recv_peek(fd, pbuf, count);
        printf("recv_peek() 执行！\n");
        if (nread == -)
        {
            perror("recv_peek() err");
            return -;
        } else if (nread == )
        {
            //注意：这里不要返回已经读取字节数，增加了调用函数的判断，直接返回-1，让调用函数当错误处理
            printf("peer socket is closed !\n");
            return -1;
        }
        for (i = ; i < nread; i++)
        {
            if (pbuf[i] == '\n')
            {
                //这是一段报文
                memset(pbuf, , count);
                //从socket缓存区读取i+1个字节
                ret = readn(fd, pbuf, i + );
                if (ret != i + )
                    return -;
                return ret;
            }
        }
        //如果当前socket缓存区中没有\n,
        //那么先判断自定义buf是否还有空间，如果没有空间,直接退出
        //如果有空间，先将当前socket缓存区中的数据读出来，放入buf中，清空socket缓存
        //继续recv，判断下一段报文有没有\n
        if (lread >= count)
        {
            printf("自定义buf太小了!\n");
            return -;
        }
        //读取当前socket缓存
        ret = readn(fd, pbuf, nread);
        if (ret != nread)
            return -;
        lread -= nread;
        pbuf += nread;
    }
    return -;
}

void handler(int sign)
{
    if (sign == SIGCHLD)
    {
        printf("子进程退出 ！\n");
        wait(NULL);
    }
}

int server_socket()
{
    int listenfd = socket(AF_INET, SOCK_STREAM, );
    if (listenfd == -)
    {
        perror("socket() err");
        return -;
    }
    //reuseaddr
    int optval = ;
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval))
            == -)
    {
        perror("setsockopt() err");
        return -;
    }
    //bind
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons();
    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    if (bind(listenfd, (struct sockaddr *) &addr, sizeof(addr)) == -)
    {
        perror("bind() err");
        return -;
    }
    //listen
    if (listen(listenfd, SOMAXCONN) == -)
    {
        perror("listen()err");
        return -;
    }
    pid_t pid = ;
    //忽略SIGCHLD信号
    //signal(SIGCHLD,SIG_IGN);
    //安装信号
    if (signal(SIGCHLD, handler) == SIG_ERR)
    {
        printf("signal() failed !\n");
        return -;
    }
    while ()
    {
        struct sockaddr_in peeraddr;
        socklen_t peerlen = sizeof(peeraddr);
        int conn = accept(listenfd, (struct sockaddr *)&peeraddr, &peerlen);
        printf("accept by %s\n", inet_ntoa(peeraddr.sin_addr));
        if (conn == -)
        {
            perror("accept() err");
            return -;
        }
        pid = fork();
        if (pid == -)
        {
            perror("fork() err");
            return -;
        }
        //子进程接收数据
        if (pid == )
        {
            //关闭监听套接字
            close(listenfd);
            char buf[] = {  };
            int ret = ;
            while ()
            {
                ret = mreadline(conn, buf, );
                if (ret == -)
                {
                    close(conn);
                    return -;
                }
                //打印客户端数据
                fputs(buf, stdout);
                //把数据返回给客户端
                writen(conn, buf, ret);
                memset(buf, , sizeof(buf));
            }
        } else if (pid > )
        {
            close(conn);
        }
    }
    return ;
}

int client_socket()
{
    int sockfd = socket(AF_INET, SOCK_STREAM, );
    if (sockfd == -)
    {
        perror("socket() err");
        return -;
    }
    //bind
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons();
    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    if(connect(sockfd,(struct sockaddr *)&addr,sizeof(addr))==-)
    {
        perror("connect() err");
        return -;
    }
    pid_t pid=;
    pid=fork();
    if(pid==-)
    {
        perror("fork() err");
        return -;
    }
    char buf[]={};
    int ret=;
    //子进程发送数据
    if(pid==)
    {
        while(fgets(buf,sizeof(buf),stdin)!=NULL)
        {
            ret=writen(sockfd,buf,strlen(buf));
            if(ret!=strlen(buf))
                return -;
            memset(buf,,sizeof(buf));
        }
    }else if(pid>)
    {
        //父进程接收数据
        while()
        {
            ret=mreadline(sockfd,buf,sizeof(buf));
            if(ret==-)
                return -;
            //打印数据
            fputs(buf,stdout);
            memset(buf,,sizeof(buf));
        }
    }
    return ;
}

.SUFFIXES:.c .o
CC=gcc
SRCS=tec01.c\
    pub.c
OBJS=$(SRCS:.c=.o)
EXEC=runc

SRCS1=hello.c\
    pub.c
OBJS1=$(SRCS1:.c=.o)
EXEC1=hello

start:$(OBJS) $(OBJS1)
    $(CC) -o $(EXEC) $(OBJS)
    $(CC) -o $(EXEC1) $(OBJS1)
    @echo "-------OK----------"
.c.o:
    $(CC) -Wall -g -o $@ -c $<
clean:
    rm -f $(OBJS)
    rm -f $(EXEC)
    rm -f $(OBJS1)
    rm -f $(EXEC1)