网络编程--探讨一些边界条件

四五又十

已于 2022-04-12 22:07:06 修改

阅读量3.1k

点赞数

分类专栏：网络编程文章标签： linux c++ 后端

于 2022-04-05 23:26:57 首次发布

本文链接：https://blog.csdn.net/weixin_44706647/article/details/123980129

版权

网络编程专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本篇文章接上一节《网络编程–堵塞式IO相关函数介绍》，在上一节中主要介绍了TCP程序中几个出现的必要程序，例如scoket、bind、listen、accept函数，但是并没有介绍在接受发送数据时的写入写出函数，我觉得这些虽然在堵塞IO中时堵塞的关键之一，但是并不打算介绍这些流函数，在书中是对这些函数有介绍的。本节主要是第五章的学习笔记，会探讨一些边界条件：

当程序运行的时候，客户和服务器同时启动会发生什么？
客户正常终止会发生什么？
若服务器进程在客户之前终止，会发生什么？
服务器主机崩溃会发生什么？

正常启动

service.cpp

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cerrno>
#include <cstring>

#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/wait.h>

#define MAXLINE     4096
#define	LISTENQ		1024
#define	SA	struct sockaddr
#define SERV_PORT 9788
using namespace std;


typedef void sigfunc(int);
void str_echo(int sockfd);
void sig_chld(int signo);
sigfunc *signal(int signo,sigfunc *func);


int main() {
    int     listenfd, connfd;
    char	buff[MAXLINE];
    socklen_t clilen;
    struct sockaddr_in clientaddr, servaddr;
    char clientIP[INET_ADDRSTRLEN] = "";

    if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        cout << "Error : socket" << endl;
        return 0;
    }
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(8899);  
    if(bind(listenfd, (SA *) &servaddr, sizeof(servaddr)) == -1) {
        cout << "Error : bind" << endl;
        return 0;
    }
    if(listen(listenfd, 5) == -1) {
        cout << "Error : listenfd" << endl;
        return 0;
    }
    signal(SIGCHLD,sig_chld);
    pid_t child;
    clilen = sizeof(clientaddr);
    for(;;) {
        cout << "...listening" << endl;
        connfd = accept(listenfd, (SA *) &clientaddr, &clilen);     //堵塞
        if(connfd < 0) {
            cout << "Error : accept" << endl;
            continue;
        }
        inet_ntop(AF_INET, &clientaddr.sin_addr, clientIP, INET_ADDRSTRLEN);
        cout << "...connect" << clientIP << ":" << ntohs(clientaddr.sin_port) << endl;  
        if((child = fork()) == 0){
            cout << "childPid" << getpid() << endl;
            close(listenfd);
            while(true) {
                memset(buff, 0, sizeof(buff));
                int len = recv(connfd, buff, sizeof(buff), 0);      //堵塞
                buff[len] = '\0';
                if(strcmp(buff, "exit") == 0) {
                    cout << "...disconnect " << clientIP << ":" << ntohs(clientaddr.sin_port) <<endl;
                    break;
                }
                cout << buff << endl;
                send(connfd, buff, len, 0);
            }
            exit(0);
        }
        close(connfd);
    }
    close(listenfd);
}


void sig_chld(int signo)
{
	pid_t pid;
	int stat;
    while((pid = waitpid(-1, &stat, WNOHANG)) > 0) {
        printf("child %d terminated.\n",pid);
    } 
	
	return;
}
sigfunc* signal(int signo,sigfunc *func)
{
	struct sigaction act,oact;
	act.sa_handler=func;
	sigemptyset(&act.sa_mask);
	act.sa_flags=0;
	if(signo==SIGALRM)
	{
#ifdef SA_INTERRUPT
		act.sa_flags|=SA_INTERRUPT;
#endif
	}else{
#ifdef SA_RESTART
		act.sa_flags|=SA_RESTART;
#endif
	}
	if(sigaction(signo,&act,&oact)<0)
		return(SIG_ERR);
	return(oact.sa_handler);
}

Client.cpp

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cerrno>
#include <cstring>

#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>

using namespace std;

#define MAXLINE     255
#define	LISTENQ		1024
#define	SA	struct sockaddr

int main() {
    int                 sockfd, n;
    char                recvline[MAXLINE + 1];
    struct sockaddr_in  servaddr;
    
    for(int i = 1;i <= 5; i++){
           if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
                cout << "Error : socket" << endl;
            }

            servaddr.sin_family = AF_INET;
            servaddr.sin_port = htons(8899);
            servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");   

            if(connect(sockfd, (SA *) &servaddr, sizeof(servaddr)) < 0) {
                cout << "Error : connect" << endl;
                return 0;
            }

            char data[MAXLINE] = "zhang";
            char buf[MAXLINE];
            while(true){
                //cin >> data;
                send(sockfd, data, strlen(data), 0);
                if(strcmp(data, "exit") == 0) {
                    cout << "..disconnect" << endl;
                    break;
                }
                memset(buf, 0, sizeof(buf));
                int len = recv(sockfd, buf, sizeof(buf), 0);
                buf[len] = '\0';
                cout << buf << endl;
            }
            close(sockfd);
    }

}

当程序正常启动时，首先启动服务端，服务器启动之后调用socket、bind、listen和accept，并且堵塞于accept调用，并且使用netstat工具，可以查看到相关的状态

[root@iz2ze3u71xuet3hjszh72jz MyC++]# netstat -tuln | grep 8899
tcp        0      0 0.0.0.0:8899            0.0.0.0:*               LISTEN

正是我们需要的，在服务器端游一个8899端口处于监听状态，当客户调用socket和connect，则发生三次握手，三次握手完成之后，客户中的connect和服务器中的accept均返回，连接于是建立

正常终止

当连接建立的时候，服务端和客户端都处于ESTABLISHED状态，使用netstat可以查看相关的状态

当我们在client端输入exit时，当前连接的客户端进入time_wait状态，目前的端口号是57180，监听服务器仍然还是堵塞在accept调用上

另外我们需要注意的一点是，我们在服务端程序中使用fork来处理一个客户的请求，当客户端连接输入exit时，该服务器的子进程终止，但是父进程并没有调用wiat或者waitpid获取子进程的状态信息，导致进程中的状态描述符一直保存在系统中，也就是会产生僵尸进程

孤儿进程：一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。**

僵尸进程：一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。**

在服务器子进程终止的时候，会给父进程发送一个SIGCHLD信号，只需要处理该信号，捕获到该信号，然后调用wait或者waitpid，信号就是告知某个进程发送了某个事件的通知，也被称为软件中断，而且信号是异步发生的，也就是说进程预先不知道信号发生的时刻

在本程序中使用signal函数去处理SIGCHLD信号，接收到该信号之后我们有两个选择，使用wait或者waitpid函数：

pid_t wait(int *statloc)
pid_t waitpid(pid_t pid, int *statloc, int options)

两个函数的区别是，在一个子进程终止前，wait使其调用者堵塞，waitpid有一个选项，可以选择不堵塞或者堵塞，options参数选项如下：

WCONTINUED：若实现支持作业控制，那么由pid指定的任一子进程在暂停后已经继续，但是状态没报告，则返回其状态
WNOHANG：若由pid指定的子进程并不是立即可用的，则waitpid不阻塞，此时返回值为0
WUNTRACED：若实现支持作业控制，那么由pid指定的任一子进程已经处于暂停状态并没报告过，则返回其状态

wait只是waitpid的简化版，在考虑使用wait或者是waitpid的时候，我们先将客户端程序修改为，也就是客户建立五个与服务器的连接

当客户终止的时候，所有打开的描述符由内核自动关闭，且五个进程基本在同一时间终止，这就导致客户端发送五个FIN，每个连接一个，使得服务端程序的5个子进程基本在同一个时刻终止，也就是说在这一时刻五个SIGCHLD信号递交给父进程，如下图：

如果我们使用wait函数，只建立一个信号处理函数并且调用wait是不足以防止出现僵尸进程的，问题是所有的5个信号都在信号处理函数执行之前产生，但是信号处理函数只处理一次，那么就会留下4个僵尸进程

所以正确的做法是使用waitpid，我们在一个循环里面调用waitpid，因为waitpid是不堵塞的，无法在循环中调用wait，因为wait是会堵塞于第一个终止的子进程

void sig_chld(int signo)
{
	pid_t pid;
	int stat;
    while((pid = waitpid(-1, &stat, WNOHANG)) > 0) {
        printf("child %d terminated.\n",pid);
    } 
	return;
}

同时启动

这里同时启动的概念是，两个应用程序彼此执行主动打开的情况，也就是说两个主机同时发送SYN请求报文，这种情况是由可能存在的，但是在上面的代码中无法模拟，因为客户端只是作为客户，服务端只是作为服务。

当每一方发送一个SYN，并且SYN必须传递给对方，例如主机A的一个应用程序使用本地端口7777，并与主机B的端口8888执行主动打开，主机B的应用程序则使用8888端口与主机A的7777端口执行主动打开。TCP的特意设计为了可以处理同时打开，对于同时打开它仅建立一条连接，而不是两条连接，当出现同时打开时，状态变迁图如下所示

两端几乎同时在发送SYN，并且进入到SYN_SENT状态，每一端收到SYN时，状态变为SYN_RECV，同时他们都在发送SYN确认报文，当双方都收到SYN及相应的及相应的ACK时，状态都变为ESTABLISHED，一个同时打开的连接需要交换4个报文，同时我们没有将任何一端称为客户或者服务器，因为他们每一端即是客户又是服务器。

同时关闭

TCP协议允许双方都同时执行主动关闭，当执行主动关闭时，状态变迁图如下：

当应用层发出关闭命令时，两端均从 ESTABLISHED变为FIN_WAIT_1。这将导致双方各发送一个FIN ，两个 F I N 经过网络传送后分别到达另一端。收到FIN后，状态由FIN_WAIT_1变迁到 CLOSING，并发送最后的ACK。当收到最后的ACK时，状态变化为 TIME_WAIT

服务器进程关闭

首先正确启动客户/服务器，然后找到子进程的pid，最后将该子进程kill掉，发生的步骤如下：

在同一个主机上启动客户和服务端程序，并且在客户上输入文本，验证一切正常
找到服务器子进程的进程pid，并且执行kill命令，作为终止进程的部分工作，将导致子进程中所有打开的描述符都关闭，这就导致向客户发送一个FIN，而客户TCP则相应一个ACK，这就是TCP连接终止工作的前半部分
SIGCHLD信号被发送给服务器父进程，并得到正确处理
客户TCP接收来自服务器TCP的FIN并响应一个ACK，但是客户进程堵塞在输入调用上，等待从终端中输入一行文本
当在客户上输入一行文本，客户TCP可以将数据发送给服务器，TCP是全双工通信，允许在服务端向客户端发送一个FIN报文的情况下，客户端还可以向服务端发送数据
当服务端收到一个数据的时候，由于套接字进程描述符已经全部被关闭，于是响应一个RST
但是客户接受不到这个RST，因为客户一旦将数据发送过去，将会堵塞在readline上

通过上面的步骤，总结为当服务端的FIN到达客户套接字的时候，客户正在堵塞recv读取一行上。所以客户在同时处理两个进程描述符：套接字和用户输入，它不能单纯的堵塞在这两个源的特定源的输入上，而是应该堵塞在其中任何一个源的输入上，这也就是后来由select和poll函数的目的之一

服务器主机崩溃

当服务器主机崩溃的时候，已有的网络连接上不发出任何东西，当我们在客户上输入一行文本，它将写入内核，再由TCP作为一个数据分节发出，因为服务器主机崩溃，所以客户TCP持续重传数据分节，并且试图从服务器上获取一个ACK，当客户TCP最后放弃的时候，给客户进程返回一个错误，服务器主机已经崩溃，从而对客户的数据分节根本没有任何响应，那么返回的错误的ETIMEDOUT，假如在某个中间路由器判定服务器主机不可达，那么会响应一个错误的ICMP消息。当然我们不想主动发送数据也想检测到服务器主机的崩溃，那么需要采用另外一个技术，就是在套接字中使用SO_KEEPALIVE字段

结语

在这两篇文章中，介绍了TCP的堵塞IO，所谓堵塞主要是指，当用户进行IO请求的时候，内核要去查看相应的缓冲区数据是否已经准备好，如果没有准备好就会一直等待，同时使用了Socket编程的一些重要函数socket、bind、listen、accept等等完成了一个TCP回射程序，通过这个程序来说明一些比较重要的问题，例如正常启动TCP完成三路握手；正常关闭完成四次挥手并且需要等待time_wait时间；当两端同时发送SYN请求时，只是产生一个连接需要发送四次报文；同时关闭也是被TCP标准所允许的；当服务器进程关闭时，由于客户端要同时处理套接字和io进程描述符，可能会接收不到服务器端发送来的FIN，这就需要我们后来介绍的select和poll函数

参考

《UNIX网络编程卷1：套接字联网API（第3版）》第三、四、五章
《TCP-IP详解卷一：协议》
《TCP-IP详解卷二：实现》
https://www.jianshu.com/p/3b233facd6bb

四五又十

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
网络编程--探讨一些边界条件

本篇文章接上一节《C++Scoket编程–堵塞式IO相关函数介绍》，在上一节中主要介绍了TCP程序中几个出现的必要程序，例如scoket、bind、listen、accept函数，但是并没有介绍在接受发送数据时的写入写出函数，我觉得这些虽然在堵塞IO中时堵塞的关键之一，但是并不打算介绍这些流函数，在书中是对这些函数有介绍的。本节主要是第五章的学习笔记，会探讨一些边界条件：当程序运行的时候，客户和服务器同时启动会发生什么？客户正常终止会发生什么？若服务器进程在客户之前终止，会发生什么？服务器主机崩溃
复制链接

扫一扫