网络编程第五章:TCP客户服务器程序一和 signal函数

柔情只为你懂 2023-07-21 11:15 13阅读 0赞

服务器:
    #include "unp.h"
    
    void str_echo(int sockfd){ 
    	ssize_t n;
    	char buf[MAXLINE];
    again:
    	while((n=read(sockfd,buf,MAXLINE))>0)
    		write(sockfd,buf,n);
    	if(n<0&&errno == EINTR)
    		goto again;
    	else if(n<0)
    		printf("read error");
    
    	
    }
    
    int
    main(int argc, char **argv)
    { 
        int                 listenfd, connfd;
        pid_t               childpid;
        socklen_t           clilen;
        struct sockaddr_in  cliaddr, servaddr;
     
        listenfd = socket(AF_INET, SOCK_STREAM, 0);
     
        bzero(&servaddr, sizeof(servaddr));
        servaddr.sin_family      = AF_INET;
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
        servaddr.sin_port        = htons(SERV_PORT);
     
        bind(listenfd, (SA *) &servaddr, sizeof(servaddr));
     
        listen(listenfd, LISTENQ);
     
        for ( ; ; ) { 
            clilen = sizeof(cliaddr);
            connfd = accept(listenfd, (SA *) &cliaddr, &clilen);
     
            if ( (childpid = fork()) == 0) {     /* child process */
                close(listenfd);    /* close listening socket */
                str_echo(connfd);   /* process the request */
                exit(0);
            }
            close(connfd);          /* parent closes connected socket */
        }
    }
    
    客户端:
    #include "unp.h"
    
    
    void
    str_cli(FILE *fp, int sockfd)
    { 
    	char	sendline[MAXLINE], recvline[MAXLINE];
    
    	while (Fgets(sendline, MAXLINE, fp) != NULL) { 
    
    		Writen(sockfd, sendline, strlen(sendline));
    
    		if (Readline(sockfd, recvline, MAXLINE) == 0)
    			err_quit("str_cli: server terminated prematurely");
    
    		Fputs(recvline, stdout);
    	}
    }
    
    int
    main(int argc, char **argv)
    { 
    	int					sockfd;
    	struct sockaddr_in	servaddr;
    
    	if (argc != 2)
    		err_quit("usage: tcpcli <IPaddress>");
    
    	sockfd = Socket(AF_INET, SOCK_STREAM, 0);
    
    	bzero(&servaddr, sizeof(servaddr));
    	servaddr.sin_family = AF_INET;
    	servaddr.sin_port = htons(SERV_PORT);
    	Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
    
    	Connect(sockfd, (SA *) &servaddr, sizeof(servaddr));
    
    	str_cli(stdin, sockfd);		/* do it all */
    
    	exit(0);
    }

建立信号处理的方法就是调用sigaction函数,但是调用这个函数比较复杂.

简单些的方法是调用signal函数,

Sigfunc * signal(int signo,Sigfunc *  func)
    
    
    
    signal(信号名,函数或者SIG_IGN或者SIGDFL).第二个参数和返回值都是指向信号处理函数的指针.
    
    
    /* include signal */
    #include "unp.h"
    
    Sigfunc *
    signal(int signo, Sigfunc *func)
    { 
    	struct sigaction	act, oact;
    
    	act.sa_handler = func;//指向信号处理函数
    	sigemptyset(&act.sa_mask);//这个信号设置成空集,表示不阻塞任何信号,posix允许指定的信号,在函数调用期间,任何被阻塞的信号都不能传递给进程,就被阻塞
    	act.sa_flags = 0;
    	if (signo == SIGALRM) { 
    #ifdef SA_INTERRUPT
    		act.sa_flags |= SA_INTERRUPT;	/* SunOS 4.x */
    #endif
    	} else {   
    #ifdef SA_RESTART
    		act.sa_flags |= SA_RESTART;		/* SVR4, 44BSD */
    #endif
    	}//sa_restart标志是可选的,如果设置,由相应信号中断的系统调用讲由内核自动重启
    	if (sigaction(signo, &act, &oact) < 0)//调用sigaction函数
    		return(SIG_ERR);
    	return(oact.sa_handler);
    }
    /* end signal */

在本文开头,那个服务器客户端程序,服务器父进程创建子进程,子进程销毁的时候向服务器发送一个sigchle信号,然后处于僵死状态.

僵死状态存在的理由是:为了方便以后父进程或者这个已经僵死的进程的信息.

如果父进程死亡,那么僵死进程的父进程将会重置为1,也就是init进程,init进程将会清理这些僵死进程.

在fork的时候都wait子进程,以防子进程变为僵死进程.

处理sigchld的函数如下:

#include "unp.h"
    
    void sig_chld(int signo){ 
    	pid_t	pid;
    	int		stat;
    	pid = wait(&stat);
    	printf("child %d terminated\n", pid);
    	return;
    }

修改服务器程序:

#include "unp.h"
    
    void str_echo(int sockfd){ 
    	ssize_t n;
    	char buf[MAXLINE];
    again:
    	while((n=read(sockfd,buf,MAXLINE))>0)
    		write(sockfd,buf,n);
    	if(n<0&&errno == EINTR)
    		goto again;
    	else if(n<0)
    		printf("read error");
    
    	
    
    }
    
    void sig_chld(int signo){ 
    	pid_t	pid;
    	int		stat;
    	pid = wait(&stat);
    	printf("child %d terminated\n", pid);
    	return;
    }
    int
    main(int argc, char **argv)
    { 
    	int					listenfd, connfd;
    	pid_t				childpid;
    	socklen_t			clilen;
    	struct sockaddr_in	cliaddr, servaddr;
    	void				sig_chld(int);
    
    	listenfd = Socket(AF_INET, SOCK_STREAM, 0);
    
    	bzero(&servaddr, sizeof(servaddr));
    	servaddr.sin_family      = AF_INET;
    	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    	servaddr.sin_port        = htons(SERV_PORT);
    
    	Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));
    
    	Listen(listenfd, LISTENQ);
    
    	Signal(SIGCHLD, sig_chld);//在listen之后调用这个信号处理函数
    
    	for ( ; ; ) { 
    		clilen = sizeof(cliaddr);
    		connfd = Accept(listenfd, (SA *) &cliaddr, &clilen);
    
    		if ( (childpid = Fork()) == 0) { 	/* child process */
    			Close(listenfd);	/* close listening socket */
    			str_echo(connfd);	/* process the request */
    			exit(0);
    		}
    		Close(connfd);			/* parent closes connected socket */
    	}
    }

对于accept来讲,是一个慢系统调用,也就是说,也就是系统调用这个函数有可能永远都不会返回.  
在上述代码中,sigchld信号在accept调用被父进程捕获,accept返回一个enter错误,父进程不处理该错误.  
有些内核会重启enter错误导致的系统调用中断,但是有些不会,(这里不是太懂,)

wait和waitpid的区别  
pid\_t wait(int \*slatloc)\{\}  
pid\_t waitpid(pid\_t pid,int \*statloc,int options)

如果成功返回ID,如果出错返回0或者-1  
wait信号处理函数只执行一次,然而Unix信号是不排队的,所以同时多个进程僵死,只能处理一个僵死进程,但是waitpid可以,如下:

#include "unp.h"
    void sig_child(int signo){ 
    	pid_t pid;
    	int stat;
    	while((pid = waitpid(-1,stat,WNOHANG))>0){ //使用WNOHANG在有尚未终止的进程的时候不能阻塞,不阻塞就会有循环,有循环就能一直调用waitpid从而处理所有的僵死进程
    		printf("子进程已经终止");
    	}
    	return ;
    }

网络编程中可能遇到的三个情况:  
1 : fork子进程的时候必须捕获sigchld信号,  
2 :捕获信号的时候,必须处理被中断的系统调用  
3 :sigchld捕获函数必须正确编写(waitpid)

关于被中断的系统调用:  
我们的服务器函数必须从for循环开始改起.

for(;;){ 
    		clilen = sizeof(cliaddr);
    		if((connfd=accept(listenfd,(SA*)&cliaddr,&clilen)<0)){ 
    			if(errno == EINTR)continue;
    			else err_sys("accept error");
    		}
    	}