Linux子进程继承父进程的文件描述符

待我称王封你为后i 2022-06-09 11:42 373阅读 0赞

# 一、子进程继承父进程的普通文件描述符 #

#include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <sys/wait.h>
    
    int main()
    {
    	char buf[1024]={0};
    	pid_t pid;
    	int ret=0;
    
    	int fd = open("./temp.txt", O_CREAT|O_TRUNC|O_RDWR, 0666);
    	if( fd == -1 ){
    		perror("open ./temp.txt");
    		return -1;
    	}
        
    	if ((pid = fork()) < 0) {
    		perror("fork");
    		return -1;
    	} 
    	else if (pid == 0) {	//child process
    		sleep(1);
    		ret = sprintf(buf, "child process pid:%d,parent pid:%d\n", getpid(), getppid());
    		write(fd, buf, ret);
    		close(fd);
    		exit(0);
    	}
    	else {					//parent process
    		ret = sprintf(buf, "parent process pid:%d, child pid:%d\n", getpid(), pid);
    		write(fd, buf, ret);
    		close(fd);
    	}	
    
    	waitpid(pid, NULL, 0);
    	
    	return 0;
    }

运行结果如下：

\[root@lghvm001 multi\_process\]\# gcc inherit\_fd.c   
\[root@lghvm001 multi\_process\]\# ./a.out   
\[root@lghvm001 multi\_process\]\# cat temp.txt   
parent process pid:18028, child pid:18029

child process pid:18029,parent pid:18028

**结论：子进程继承了父进程已经打开了的文件描述符。**

# 二、子进程继承父进程的TCP Socket #

写一个简单的TCP Server回射程序，即客户端给服务器端发一段字符串，服务器端将字符串原样返回。这里服务器端的Server程序采用主进程+工作进程的模式：主进程负责接收客户端的连接请求，然后fork一个子进程（也叫工作进程）来处理客户端的请求数据，即子进程接收客户端发来的字符串，然后将字符串原样返回给客户端。这里主要演示子进程继承父进程的TCP Socket，下面来看代码：

tcp\_server.c

/* tcp_server.c */  
      
    #include <stdio.h>  
    #include <stdlib.h>  
    #include <string.h>  
    #include <errno.h>  
    #include <sys/types.h>  
    #include <sys/socket.h>  
    #include <netinet/in.h>   
    #include <arpa/inet.h>
    #include <sys/ioctl.h>
    #include <net/if.h>
    #include <signal.h>
    
    
    #define MAXLINE 1024  
    #define BACKLOG 50  
    
    
    int main(int argc, char** argv)  
    {   
    	int    listenfd, connfd, n = 0;     
        struct sockaddr_in  servaddr, cliaddr;     
        pid_t pid;      
        socklen_t clilen;  
    
    	signal(SIGCHLD, SIG_IGN); //避免子进程成为僵尸进程  
        
        if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1 ){      
            printf("create socket error: %s(errno: %d)\n",strerror(errno),errno);      
            return -1;      
        }      
    	
        memset(&servaddr, 0, sizeof(servaddr));      
        servaddr.sin_family = AF_INET;          		//IPv4  
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);   //自动填入本机的IP地址    
        /*
        if( inet_pton(AF_INET, "172.23.1.180", &servaddr.sin_addr) <= 0){   // [将“点分十进制”ip－> 网络字节序“整数”ip]   
            printf("inet_pton error for %s\n","172.23.1.180");      
            return -1;    
        }
        	*/
    	
        servaddr.sin_port = htons(6666);        //将端口号转换为网络字节序  
        if( bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1){      
            printf("bind socket error: %s(errno: %d)\n",strerror(errno),errno);      
            return -1;      
        }  
    	
        if( listen(listenfd, BACKLOG) == -1){      
            printf("listen socket error: %s(errno: %d)\n",strerror(errno),errno);      
            return -1;      
        }  
    	
        printf("======waiting for client's connect requestion======\n");   
        
        while(1){              
            if( (connfd = accept(listenfd, (struct sockaddr*)&cliaddr, &clilen)) == -1){          
                printf("accept socket error: %s(errno: %d)", strerror(errno),errno);          
                continue;      
            } 
    
    		if ((pid = fork()) < 0) {
    			perror("fork");
    			return -1;
    		} 
    		else if (pid == 0) {	//child process
    			char    buff[MAXLINE];
    
    			close(listenfd);
    	        fprintf(stdout, "Connected, client addr: %s\n", inet_ntoa(cliaddr.sin_addr));  
    	        if((n = recv(connfd, buff, MAXLINE-1, 0)) < 0) {  
    	            printf("Failed to receive bytes from client\n");  
    	            return -1; 
    	        }      
    	        buff[n] = '\0';      
    	        fputs("recv msg from client: ", stdout);  
    	        fputs(buff, stdout);  
    	        while (n > 0) {  
    	            if (send(connfd, buff, n, 0) != n) {  
    	                printf("send msg error: %s(errno: %d)\n", strerror(errno), errno);      
    	                return -1;   
    	            }   
    	            if((n = recv(connfd, buff, MAXLINE-1, 0)) < 0) {  
    	                printf("Failed to receive bytes from client\n");  
    	                return -1; 
    	            }      
    	            buff[n] = '\0';      
    	            fputs(buff, stdout);  
    	        }  
    	        close(connfd);
    			exit(0);
    		}
    		else {					//parent process
    			close(connfd);
    			continue;
    		}     
        }  
    
    	return 0;
    }

客户端代码tcp\_client.c

/* tcp_client.c */  
    
    #include<stdio.h>  
    #include<stdlib.h>  
    #include<string.h>  
    #include<errno.h>  
    #include<sys/types.h>  
    #include<sys/socket.h>  
    #include<netinet/in.h>  
    
    #define MAXLINE 1024  
    
    int main(int argc, char** argv)  
    {   int    sockfd, n, received;   
        int len, bytes;     
        char    recvline[MAXLINE], sendline[MAXLINE];      
        struct sockaddr_in    servaddr;     
          
        /*if( argc != 2){      
            printf("usage: ./client <ipaddress>\n");      
            exit(0);      
        }*/      
        memset(recvline, 0, MAXLINE);  
        memset(sendline, 0, MAXLINE);  
    	
        if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){      
            printf("create socket error: %s(errno: %d)\n", strerror(errno),errno);      
            return -1;      
        }      
        memset(&servaddr, 0, sizeof(servaddr));      
        servaddr.sin_family = AF_INET;      
        servaddr.sin_port = htons(6666);   
    	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    	/*
        if( inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0){ 
            printf("inet_pton error for %s\n",argv[1]);      
            return -1;      
        }*/      
    	
        if( connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0){      
            printf("connect error: %s(errno: %d)\n", strerror(errno),errno);      
            return -1;   
        }      
    	
        printf("send msg to server: \n"); 
    	
        while(1) {    
            fgets(sendline, MAXLINE, stdin);     
            len = strlen(sendline);   
            if( send(sockfd, sendline, len, 0) != len) {      
                printf("send msg error: %s(errno: %d)\n", strerror(errno), errno);      
                return -1;      
            }  
    		
            fputs("echo from server:\n", stdout);  
            received = 0;  
            while(received < len) {  
                bytes = 0;  
                if ((bytes = recv(sockfd, recvline, MAXLINE-1, 0)) == -1 ){  
                    perror("recv");  
                    return -1;  
                }  
                else if(bytes == 0) {  
                    printf("recv fail:the server has closed the connection prematually!\n");  
                    return -1;  
                }  
                received += bytes;  
                recvline[bytes] = '\0';  
                fputs(recvline, stdout);  
            }  
            fputs("\n", stdout);   
        }     
    	
        close(sockfd);      
        return 0; 
    }

打开linux的命令行终端，编译运行tcp\_server

另外再打开两个命令行终端，编译运行tcp\_client

运行结果如下：

tcp\_server

[root@lghvm001 multi_process]# gcc tcp_server.c -o tcp_server
    [root@lghvm001 multi_process]# ./tcp_server
    ======waiting for client's connect requestion======
    Connected, client addr: 255.127.0.0
    recv msg from client: hi,this is client1.
    Connected, client addr: 127.0.0.1
    recv msg from client: hi, this is client2.

tcp\_client1

[root@lghvm001 multi_process]# gcc tcp_client.c -o tcp_client
    [root@lghvm001 multi_process]# ./tcp_client
    send msg to server: 
    hi,this is client1.
    echo from server:
    hi,this is client1.

tcp\_client2

[lgh@lghvm001 multi_process]$ ./tcp_client
    send msg to server: 
    hi, this is client2.
    echo from server:
    hi, this is client2.

该示例有多少个客户端连接就会产生多少个子进程，目前有主进程，两个子进程：

[lgh@lghvm001 Desktop]$ ps -ef | grep tcp_server
    root      18302  43605  0 14:08 pts/14   00:00:00 ./tcp_server
    root      18309  18302  0 14:09 pts/14   00:00:00 ./tcp_server
    root      18311  18302  0 14:09 pts/14   00:00:00 ./tcp_server
    lgh       18313  18132  0 14:09 pts/22   00:00:00 grep tcp_server
    [lgh@lghvm001 Desktop]$

若客户端连接太多，会导致多过的子进程，可以使用多路IO复用进行优化，在Linux下epoll是不二选择。