Linux網絡編程之socket:使用fork併發處理多個client的請求和對等通信P2P

一、如何同時服務多個客戶端呢？在未講到select/poll/epoll等高級IO之前，比較老土的辦法是使用fork來實現。網絡服務器通常用fork來同時服務多個客戶端，父進程專門負責監聽端口，每次accept一個新的客戶端連接就fork出一個子進程專門服務這個客戶端。但是子進程退出時會產生殭屍進程，父進程要注意處理SIGCHLD信號和調用wait清理殭屍進程，最簡單的辦法就是直接忽略SIGCHLD信號。

下面爲服務器端程序:

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<signal.h>

#define ERR_EXIT(m) \
    do { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while (0)

void do_service(int);

int main(void)
{
    signal(SIGCHLD, SIG_IGN);
    int listenfd; //被動套接字(文件描述符），即只可以accept, 監聽套接字
    if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
        //  listenfd = socket(AF_INET, SOCK_STREAM, 0)
        ERR_EXIT("socket error");

    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(5188);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    /* servaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); */
    /* inet_aton("127.0.0.1", &servaddr.sin_addr); */

    int on = 1;
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
        ERR_EXIT("setsockopt error");

    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
        ERR_EXIT("bind error");

    if (listen(listenfd, SOMAXCONN) < 0) //listen應在socket和bind之後，而在accept之前
        ERR_EXIT("listen error");

    struct sockaddr_in peeraddr; //傳出參數
    socklen_t peerlen = sizeof(peeraddr); //傳入傳出參數，必須有初始值
    int conn; // 已連接套接字(變爲主動套接字，即可以主動connect)

    pid_t pid;

    while (1)
    {
        if ((conn = accept(listenfd, (struct sockaddr *)&peeraddr, &peerlen)) < 0) //3次握手完成的序列
            ERR_EXIT("accept error");
        printf("recv connect ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr),
               ntohs(peeraddr.sin_port));

        pid = fork();
        if (pid == -1)
            ERR_EXIT("fork error");
        if (pid == 0)
        {
            // 子進程
            close(listenfd);
            do_service(conn);
            exit(EXIT_SUCCESS);
        }
        else
            close(conn); //父進程
    }

    return 0;
}

void do_service(int conn)
{
    char recvbuf[1024];
    while (1)
    {
        memset(recvbuf, 0, sizeof(recvbuf));
        int ret = read(conn, recvbuf, sizeof(recvbuf));
        if (ret == 0)   //客戶端關閉了
        {
            printf("client close\n");
            break;
        }
        else if (ret == -1)
            ERR_EXIT("read error");
        fputs(recvbuf, stdout);
        write(conn, recvbuf, ret);
    }
}

客戶端程序：

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>


#define ERR_EXIT(m) \
    do { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while (0)




int main(void)
{
    int sock;
    if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
        //  listenfd = socket(AF_INET, SOCK_STREAM, 0)
        ERR_EXIT("socket error");


    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(5188);
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    /* inet_aton("127.0.0.1", &servaddr.sin_addr); */

    if (connect(sock, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
        ERR_EXIT("connect error");


    char sendbuf[1024] = {0};
    char recvbuf[1024] = {0};
    while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
    {

        write(sock, sendbuf, strlen(sendbuf));
        read(sock, recvbuf, sizeof(recvbuf));


        fputs(recvbuf, stdout);

        memset(sendbuf, 0, sizeof(sendbuf));
        memset(recvbuf, 0, sizeof(recvbuf));
    }


    close(sock);


    return 0;
}

上述程序利用了一點，就是父子進程共享打開的文件描述符，因爲在子進程已經用不到監聽描述符，故將其關閉，而連接描述符對父進程也沒價值，將其關閉。當某個客戶端關閉，則read 返回0，退出循環，子進程順便exit，但如果沒有設置對SIGCHLD信號的忽略，則因爲父進程還沒退出，故子進程會變成殭屍進程。

現在先運行server，再打開另外兩個終端，運行client，可以看到server輸出如下：

同時在另外一個終端PS一下:

發現共有3個進程，其中一個是父進程處於監聽中，另外兩個是子進程處於對客戶端服務中，現在ctrl+c 掉其中一個client，由上面的分析可知對應服務的子進程也會退出，而因爲我們設置了父進程對SIGCHLD信號進行忽略，故不會產生殭屍進程，輸出如下：

如果把主函數的第一行去掉，上述的情景輸出可能爲：

如果不想忽略SIGCHLD信號，則必須在信號處理函數中調用wait處理，但這裏需要注意的是wait只能等待第一個退出的子進程，所以這裏需要使用

waitpid。若當前只有一個子進程退出，則waitpid一次之後因爲其他子進程狀態尚未改變，故返回0退出循環；若幾個連接同時斷開，信號因爲不能排隊

而只接收到一個SIGCHLD信號，waitpid多次之後已經不存在子進程了，返回-1退出循環。如下所示：

signal(SIGCHLD, handler);
.....................

void handler(int sig)
{
    /*  wait(NULL); //只能等待第一個退出的子進程 */
 
    while (waitpid(-1, NULL, WNOHANG) > 0)
        ;
}

2.P2P通信

如果我們想實現對等通信，即P2P，可以在服務器程序用使用兩個進程，一個進程接收用戶的輸入併發送給客戶端，另一個進程被動接收客戶端的消息並打印出來，此進程當read 返回0 時得知客戶端已經關閉需要退出進程，此時尚有另一個進程未退出，可以通過在退出前發送消息給它，在消息處理函數中退出。當然客戶端也必須使用雙進程，原理與服務器程序相同。

服務端程序：

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<signal.h>

#define ERR_EXIT(m) \
    do { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while (0)

void handler(int sig)
{
    printf("recv a sig=%d\n", sig);
    exit(EXIT_SUCCESS);
}

int main(void)
{
    int listenfd; //被動套接字(文件描述符），即只可以accept
    if ((listenfd = socket(AF_INET, SOCK_STREAM,0)) < 0)
        ERR_EXIT("socket error");

    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(5188);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    int on = 1;
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
        ERR_EXIT("setsockopt error");

    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
        ERR_EXIT("bind error");

    if (listen(listenfd, SOMAXCONN) < 0) //listen應在socket和bind之後，而在accept之前
        ERR_EXIT("listen error");

    struct sockaddr_in peeraddr; //傳出參數
    socklen_t peerlen = sizeof(peeraddr); //傳入傳出參數，必須有初始值
    int conn; // 已連接套接字(變爲主動套接字，即可以主動connect)
    if ((conn = accept(listenfd, (struct sockaddr *)&peeraddr, &peerlen)) < 0)
        ERR_EXIT("accept error");
    printf("recv connect ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr),
           ntohs(peeraddr.sin_port));

    pid_t pid;
    pid = fork();
    if (pid == -1)
        ERR_EXIT("fork error");
    if (pid == 0)//此子進程用於接收終端輸入並且發送給客戶端       
    {

        signal(SIGUSR1, handler);

        char sendbuf[1024] = {0};
        while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
        {
            write(conn, sendbuf, strlen(sendbuf));
            memset(sendbuf, 0, sizeof(sendbuf));
        }
        exit(EXIT_SUCCESS);
    }
    else    //此進程用於接收客戶端信息
    {
        char recvbuf[1024];
        while (1)
        {
            memset(recvbuf, 0, sizeof(recvbuf));
            int ret = read(conn, recvbuf, sizeof(recvbuf));
            if (ret == -1)
                ERR_EXIT("read error");
            else if (ret == 0)
            {
                printf("peer close\n");
                break;
            }
            fputs(recvbuf, stdout);
        }
        kill(pid, SIGUSR1); //父進程退出時發送信號給子進程
        exit(EXIT_SUCCESS);
    }
}

客戶端：

#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<stdio.h>

#define ERR_EXIT(m)\
	do{\
	perror(m);\
	exit(EXIT_FAILURE);\
	}while(0)

int main(void)
{
	int sock;
	if((sock = socket(AF_INET,SOCK_STREAM,0)) <  0)
		ERR_EXIT("socket error");
	struct sockaddr_in servaddr;
	memset(&servaddr,0,sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(5188);
	servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
	if(connect(sock,(struct sockaddr *)&servaddr,sizeof(servaddr)) < 0)
		ERR_EXIT("connect error");
	
	pid_t pid;
	pid = fork();
	if(pid == -1)
		ERR_EXIT("fork error");
	if(pid == 0)//此子進程用於發送數據
	{	
		char sendbuf[1024] = {0};
		while(fgets(sendbuf,sizeof(sendbuf),stdin) != NULL)
		{
			write(sock,sendbuf,strlen(sendbuf));
			memset(sendbuf,0,sizeof(sendbuf));
		}
		exit(EXIT_SUCCESS);
	}
	else//此進程用於接收數據
	{
		char recvbuf[1024] = {0};
		while(1)
		{
			int ret = read(sock,recvbuf,sizeof(recvbuf));
			if(ret == -1)
				ERR_EXIT("read error");
			else if (ret == 0)
			{
				printf("client close\n");
				break;
			}
			fputs(recvbuf,stdout);
			memset(recvbuf,0,sizeof(recvbuf));
		}
		exit(EXIT_SUCCESS);
	}
}

這裏是使用父子進程來完成對等通信，即雙方都可以發送信息給對方，也可以接收對方的信息，

上面使用了kill 函數來發現自定義信號，如果子進程發送信號給父進程，可以使用getppid 函數得到父進程的id。

客戶端接入服務器端：

服務器端與客戶端進行雙向通信：

客戶端斷開：

注意，ctrl+c 會將前臺進程組中的兩個進程都終止掉，即父子進程都打開了conn，只有兩個進程都close(conn)，將file 的引用計數減爲0，纔會真正關

閉sockfs 文件，這樣client 其中一個進程才能read 返回0打印peer close，並發信號給另一個進程，在信號處理函數中退出。

Mr_weng_

發佈了51 篇原創文章 · 獲贊 9 · 訪問量 5萬+

私信關注

Linux網絡編程之socket:使用fork併發處理多個client的請求和對等通信P2P

使用c#強大的表達式樹實現對象的深克隆之解決循環引用的問題

free AI online tools All In One

痞子衡嵌入式：恩智浦i.MX RT1xxx系列MCU啓動那些事（12.A）- uSDHC eMMC啓動時間(RT1170)

linux安裝cuda和cudnn

Mellanox網卡開啓SR-IOV

模擬手機設備：使用 Playwright 實現移動端自動化測試

HTML 00 Tutorial

全面系統的AI學習路徑，幫助普通人也能玩轉AI

從零開始：使用 Playwright 腳本錄製實現自動化測試

uni-app實現上拉加載

Linux編程基礎:read/write函數以及(非)阻塞I/O的概念

Linux網絡編程之socket:select函數的併發限制與poll函數

Linux編程基礎:C標準IO庫函數與Unbuffered IO函數

Linux網絡編程之socket:socket與字節序以及地址轉換函數

Linux網絡編程：信號

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結