1.socket函数
int socket(int protofamily, int type, int protocol);//返回sockfd，描述符
protofamily：即协议域，又称为协议族（family）。常用的协议族有，AF_INET(IPV4)、AF_INET6(IPV6)、AF_LOCAL（或称AF_UNIX，Unix域socket）、AF_ROUTE等等。协议族决定了socket的地址类型，在通信中必须采用对应的地址，如AF_INET决定了要用ipv4地址（32位的）与端口号（16位的）的组合、AF_UNIX决定了要用一个绝对路径名作为地址。
type：指定socket类型。常用的socket类型有，SOCK_STREAM、SOCK_DGRAM、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等（socket的类型有哪些？）。
protocol：故名思意，就是指定协议。常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议（这个协议我将会单独开篇讨论！）。
注意：
并不是上面的type和protocol可以随意组合的，如SOCK_STREAM不可以跟IPPROTO_UDP组合。当protocol为0时，会自动选择type类型对应的默认协议。
当我们调用socket创建一个socket时，返回的socket描述字它存在于协议族（address family，AF_XXX）空间中，但没有一个具体的地址。如果想要给它赋值一个地址就必须调用bind()函数，否则就当调用connect()、listen()时系统会自动随机分配一个端口
实现
当服务器程序调用socket系统调用之后，内核会创建一个struct socket和一个struct sock结构，两者可以通过指针成员变量相互访问对方。内核直接操作的是struct sock结构。struct socket的存在是为了适应linux的虚拟文件系统，把socket也当作一个文件系统，通过指定superblock中不同的操作函数实现完成相应的功能。在linux内核中存在不同的sock类型，与TCP相关的有struct sock、 struct inet_connection_sock,、struct tcp_sock等。这些结构的实现非常灵活,可以相互进行类型转换。这个机制的实现是结构体的一层层包含关系：struct tcp_sock的第一个成员变量是struct inet_connection_sock，struct inet_connection_sock的第一个成员变量是struct sock。
通过这种包含关系，可以将不同的sock类型通过指针进行相互转换。比如：
struct tcp_sock tcp_sk; struct sock *sk = (struct sock *)&tcp_sk;
为了避免从小的结构体转换到大的结构体造成内存越界，对于TCP协议，内核在初始化一个stuct sock时给它分配的空间大小是一个struct tcp_sock的大小。这样sock类型的相互转换便可以灵活的进行。另外，在内核创建完sock和socket之后,还需要绑定到对应的文件描述符以便应用层能够访问。一个task_struct中有一个文件描述符数组，存储所有该进程打开的文件，因为socket也可以看做是文件，也存储在这个数组中。文件描述符就是该socket在该数组中的下标，具体的实现请参照虚拟文件系统。
2.bind函数
bind()函数把一个地址族中的特定地址（本地协议地址）赋给socket(即地址的绑定)。例如对应AF_INET、AF_INET6就是把一个ipv4或ipv6地址和端口号组合赋给socket。
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
sockfd：即socket描述字，它是通过socket()函数创建了，唯一标识一个socket。bind()函数就是将给这个描述字绑定一个名字。
addr：一个const struct sockaddr *指针，指向要绑定给sockfd的协议地址。这个地址结构根据地址创建socket时的地址协议族的不同而不同，如ipv4对应的是： 限定了只接受地址为addr的客户信息，若服务器没有绑定ip地址，则内核就把客户端发送的SYN目的地址作为服务器的源IP地址，一般我们捆绑统配地址：INADDR_ANY，告诉系统，若系统是多宿主机，我们将接受目的地址为任何本地接口的连接。
addrlen：对应的是地址的长度。
错误信息：
- EACCES：地址受到保护，用户非超级用户。
- EADDRINUSE：指定的地址已经在使用。
- EBADF：sockfd参数为非法的文件描述符。
- EINVAL：socket已经和地址绑定。
- ENOTSOCK：参数sockfd为文件描述符。
注意：
- 如果TCP客户或服务器未曾调用bind捆绑一个端口，当调用connect或listen时内核就选择一个临时端口，这对客户来说是正常的，服务器应该调用众所周知的端口
- 在将一个地址绑定到socket的时候，请先将主机字节序转换成为网络字节序，务必将其转化为网络字节序再赋给socket
实现
该调用通过传递进来的文件描述符找到对应的socket结构，然后通过socket访问sock结构。操作sock进行地址的绑定。如果指定了端口检查端口的可用性并绑定，否则随机分配一个端口进行绑定。但是怎样获知当前系统的端口绑定状态呢？通过一个全局变量inet_hashinfo进行，每次成功绑定一个端口会都将该sock加入到inet_hashinfo的绑定散列表中。加入之后bind的系统调用已基本完成了。
3.listen函数
int listen(int sockfd, int backlog);
- 第一个参数即为要监听的socket描述字
- 第二个参数为相应socket可以排队的最大连接个数
socket()函数创建的socket默认是一个主动类型的，listen函数将socket变为被动类型的，等待客户的连接请求，把CLOSED状态转换为LISTEN状态。
未完成队列：
每个这样的SYN分节对应其中一项，客服发送至服务器，服务器等待完成TCP的三次握手，这些套接字处于SYN_RCVD状态。
已完成队列：
每个已完成的TCP完成三路握手的客户对应其中一项，这些套接字处于ESTABLISHED状态。
注意：
- 每在未完成队列中创建一项时，来自监听套接字的参数就立即复制到建立连接中，链接创建自动完成。
- 来自客户的SYN到达时，TCP在未完成对队列中创建一项，然后相应三路握手的第二个分节：服务器SYN相应，捎带对客户的SYN分节的ACK，这一项一直保留在未完成队列中，直到三路握手的第三个分节客户对服务器的SYN的ACK到达或该项超时为止。
- 已完成队列的对头返回给进程，如果进程为空，队列被投入睡眠，直到TCP在该队列中放一项为止；若当客户的一个SYN到达时，这些队列是满的，TCP就忽略该分节，也就是不发送RST，因为这些情况是暂时的，期望不就就能在这些队列中找到一个可用的空间，若服务器响应RST，客户端connect调用就会返回一个错误。
- backlog不能为0
实现
和listen相关的大部分信息存储在inet_connection_sock结构中。同样的内核通过文件描述符找到对应的sock，然后将其转换为inet_connection_sock结构。在inet_connection_sock结构体中含有一个类型为request_sock_queue的icsk_accept_queue变量，存储一些希望建立连接的sock相关的信息。结构为：
struct request_sock_queue { struct request_sock *rskq_accept_head; struct request_sock *rskq_accept_tail; rwlock_t syn_wait_lock; u8 rskq_defer_accept; struct listen_sock *listen_opt; };
listen_opt用了存储当前正在请求建立连接的sock，称作半连接状态，用request_sock表示。request_sock有个成员变量指针指向对应的strut sock。rskq_accept_head和rskq_accept_tail分别指向已经建立完连接的request_sock，称作全连接状态，这些sock都是完成了三次握手等待程序调用accept接受。程序调用listen之后会为icsk_accept_queue分配内存，并且将当前的监听sock放到全局变量inet_hashinfo中的监听散列表中。当内核收到一个带有skb之后会通过tcp_v4_rcv函数进行处理。因为只有skb，还需找到对应的sock。该过程通过 __inet_lookup_skb进行实现。该函数主要调用__inet_lookup，其中：
- 首先看看这个包是不是一个已经建立好连接的sock中的包，通过__inet_lookup_established函数进行操作(一个连接通过源IP,目的IP,源PORT和目的PORT标识)。
- 失败的话可能是一个新的SYN数据包，此时还没有建立连接所以没有对应的sock，和该sock相关的只可能是监听sock了。
所以通过__inet_lookup_listener函数找到在本地的监听对应端口的sock。无论哪种情况，找到sock之后便会将sock和skb一同传入tcp_v4_do_rcv函数作统一处理
if (sk->sk_state == TCP_ESTABLISHED) { sock_rps_save_rxhash(sk, skb->rxhash); TCP_CHECK_TIMER(sk); if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) { rsk = sk; goto reset; } TCP_CHECK_TIMER(sk); return 0; } if (sk->sk_state == TCP_LISTEN) { struct sock *nsk = tcp_v4_hnd_req(sk, skb); if (!nsk) goto discard; if (nsk != sk) { if (tcp_child_process(sk, nsk, skb)) { rsk = nsk; goto reset; } return 0; } } if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) { rsk = sk; goto reset; }
- 如果是一个已建立连接的sock，调用tcp_rcv_established函数进行相应的处理。
- 如果是一个正在监听的sock，需要新建一个sock来保存这个半连接请求，该操作通过tcp_v4_hnd_req实现。
这里我们只关注tcp的建立过程，所以只分析tcp_v4_hnd_req和tcp_child_process函数：
static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb) { struct tcphdr *th = tcp_hdr(skb); const struct iphdr *iph = ip_hdr(skb); struct sock *nsk; struct request_sock **prev; struct request_sock *req = inet_csk_search_req(sk, &prev, th->source, iph->saddr, iph->daddr); if (req) return tcp_check_req(sk, skb, req, prev); nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr, th->source, iph->daddr, th->dest, inet_iif(skb)); if (nsk) { if (nsk->sk_state != TCP_TIME_WAIT) { bh_lock_sock(nsk); return nsk; } inet_twsk_put(inet_twsk(nsk)); return NULL; } return sk; }
- 首先调用inet_csk_search_req查找在半连接队列中是否已经存在对应的request_sock。有的话说明这个请求连接已经存在，调用tcp_check_req处理第三次握手的情况，当sock的状态从SYN_RCV变迁到ESTABLISHED状态时，连接建立完成。需要将该request_sock从request_sock_queue队列中的listen_opt半连接队列取出，放入全连接队列等待进程调用accept取走，同时是request_sock指向一个新建的sock并返回。
- 没有的话调用inet_lookup_established从已经建立连接sock中查找,如果找到的话说明这是一条已经建立的连接,当该sock不处于timewait将sock返回状态时将sock返回,否则返回NULL。
- 当上述两种情况都失败了,表示这是一个新的为创建的连接,直接返回sk。这样通过tcp_v4_hnd_req函数就能够找到或创建和这个skb相关的sock。
A.如果返回的sock和处于Listen状态的sock不同，表示返回的是一个新的sock，第三次握手已经完成了。调用tcp_child_process处理。该函数的逻辑是让这个新的tcp_sock开始处理TCP段，同时唤醒应用层调用accept阻塞的程序，告知它有新的请求建立完成，可以从全连接队列中取出了。
B.如果返回的sock没有变化，表示是一个新的请求，调用tcp_rcv_state_process函数处理第一次连接的情况。该函数的逻辑较为复杂，简单的可以概括为新建一个request_sock并插入半连接队列，设置该request_sock的sock为SYN_RCV状态。然后构建SYN+ACK发送给客户端，完成TCP三次握手连接的第二步。
4.connect函数
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
第一个参数即为客户端的socket描述字，第二参数为服务器的socket地址，第三个参数为socket地址的长度。
对于客户端的 connect() 函数，该函数的功能为客户端主动连接服务器，建立连接是通过三次握手，而这个连接的过程是由内核完成，不是这个函数完成的，这个函数的作用仅仅是通知 Linux 内核，让 Linux 内核自动完成 TCP 三次握手连接，最后把连接的结果返回给这个函数的返回值（成功连接为0， 失败为-1）。
注意：
- 若TCP客户没75s有收到SYN分节的响应（时隔6s发一个），返回ETIMEDOUT，
- 对客户的SUN分节的相应是RST，表明服务器主机在我们指定的端口无进程等待，或服务器没有运行，硬错误，返回ECONNREFUSED
- 若客户发生ICMP（目的地不可到达错误），软错误，客户内核保存该消息，并按照第一种情况再次发送，若75s后还没相应，咋把内核保存的EHOSTUNREACH或ENETUNREACH返回给进程，以下两种情况也可能一：按照本地系统的转发没有到达远程系统的路径。二：connect不等待就返回
实现
connect系统调用根据文件描述符找到socket和sock，如果当前socket的状态时SS_UNCONNECTED的情况下才正常处理连接请求。首先调用tcp协议簇的connect函数(即tcp_v4_connect)发送SYN，然后将socket状态置为SS_CONNECTING，将进程阻塞等待连接的完成。剩下的两次握手由协议栈自动完成。
tcp_v4_connect函数:该函数首先进行一些合法性验证，随后调用ip_route_connect函数查找路由信息，将当前sock置为SYN_SENT状态，然后调用inet_hash_connect函数绑定本地的端口，和服务器端绑定端口的过程类似，但是会额外的将sock添加inet_hashinfo中的ehash散列表中(添加到这的原因是因为希望以后收到的SYN+ACK时能够找到对应的sock，虽然当前并没有真正意义上的建立连接)。到最后调用tcp_connect构建SYN数据包发送。
tcp_connect:该函数逻辑比较简单，构造SYN数据段并设置相应的字段，将该段添加到发送队列上调用tcp_transmit_skb发送skb，最后重设重传定时器以便重传SYN数据段。
当客户端收到SYN+ACK之后，首先会通过tcp_v4_rcv从已建立连接散列表中找到对应的sock，然后调用tcp_v4_do_rcv函数进行处理，在该函数中主要的执行过程是调用tcp_rcv_state_process。又回到了tcp_rcv_state_process函数，它处理sock不处于ESTABLISHED和LISTEN的所有情况。当发现是一个SYN+ACK段并且当前sock处于SYN_SENT状态时，表示连接建立马上要完成了。首先初始化TCP连接中一些需要的信息，如窗口大小，MSS，保活定时器等信息。然后给该sock的上层应用发送信号告知它连接建立已经完成，最后通过tcp_send_ack发送ACK完成最后一次握手。
5.accept函数
在三次握手之后
服务器端依次调用socket()、bind()、listen()之后，就会监听指定的socket地址了。TCP客户端依次调用socket()、connect()之后就向TCP服务器发送了一个连接请求。TCP服务器监听到这个请求之后，就会调用accept()函数取接收请求，这样连接就建立好了。之后就可以开始网络I/O操作了，即类同于普通文件的读写I/O操作。
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); //返回连接connect_fd
sockfd
参数sockfd就是上面解释中的监听套接字，这个套接字用来监听一个端口，当有一个客户与服务器连接时，它使用这个一个端口号，而此时这个端口号正与这个套接字关联。当然客户不知道套接字这些细节，它只知道一个地址和一个端口号。
addr
这是一个结果参数，它用来接受一个返回值，这返回值指定客户端的地址，当然这个地址是通过某个地址结构来描述的，用户应该知道这一个什么样的地址结构。如果对客户的地址不感兴趣，那么可以把这个值设置为NULL。
len
如同大家所认为的，它也是结果的参数，用来接受上述addr的结构的大小的，它指明addr结构所占有的字节个数。同样的，它也可以被设置为NULL。
如果accept成功返回，则服务器与客户已经正确建立连接了，此时服务器通过accept返回的套接字来完成与客户的通信。
注意：
- accept默认会阻塞进程，直到有一个客户连接建立后返回，它返回的是一个新可用的套接字，这个套接字是连接套接字
- 连接套接字socketfd_new 并没有占用新的端口与客户端通信，依然使用的是与监听套接字socketfd一样的端口号
需要区分两种套接字
- 监听套接字:监听套接字正如accept的参数sockfd，它是监听套接字，在调用listen函数之后，是服务器开始调用socket()函数生成的，称为监听socket描述字(监听套接字)
- 连接套接字：一个套接字会从主动连接的套接字变身为一个监听套接字；而accept函数返回的是已连接socket描述字(一个连接套接字)，它代表着一个网络已经存在的点点连接。
一个服务器通常通常仅仅只创建一个监听socket描述字，它在该服务器的生命周期内一直存在。内核为每个由服务器进程接受的客户连接创建了一个已连接socket描述字，当服务器完成了对某个客户的服务，相应的已连接socket描述字就被关闭。
实现
该调用创建新的struct socket表示新的连接，搜寻全连接队列，如果队列为空，将程序自身挂起等待连接请求的完成。否则从队列中取出头部request_sock，并设置新的struct socket和request_sock中的struct sock的对应关系。这样一个连接至此就建立完成了。客户端可以通过新返回的struct socket进行通信，同时旧的struct socket继续在监听。
服务器代码
- fork子进程时(一个服务器同一时刻只能处理一个客户，提高并发度)，必须捕获SIGCHLD信号
- 当信号捕获时，必须处理被中断系统调用
- SIGCHLD(子进程结束后向父进程发送的信号)的信号处理函数必须正确编写，用waitpid函数以免留下僵尸进程
#include "unp.h" #include "my_err.h" /* * 若使用wait，会导致使用wait的进程(父进程)阻塞，直到子进程结束或者收到一 *信号为止；如果在同一台主机上运行，启动多个客户信号处理函数只会执行一次，在 *不同主机上运行，信号处理函数执行两次，一次是产生信号，一次是其他信号处理 *函数在执行时发生，也不能如下在循环中调用wait：没有办法防止wait正在运行的 *子进程尚有未终止的阻塞。 * 用waitpid，指定WNOHANG选项，提供一个非阻塞的wait版本，pid=-1等待任 *何一个子进程退出，与wait作用一样，所以用waitpid。1.在信号处理函数中，如果 *有子进程终止，通过while一次性回收2.非阻塞模式：保证回收最后一个中止的子进 *程后，没有子进程退出时，waitpid返回出错，主进程从信号处理函数中跳出而不是 *阻塞在信号处理函数中 */ void header(int signo) { pid_t pid; int stat; while((pid=waitpid(-1,&stat,WNOHANG))>0) printf("child %d terminated ",pid); return; } void str_echo(int sockfd) { ssize_t n; char buffer[MAXLINE]; again: while((n=read(sockfd,buffer,MAXLINE))>0) write(sockfd,buffer,n); //处理被中断的慢系统调用 if(n<0&&errno==EINTR) goto again; else if(n<0) err_sys("str_echo:read error"); } int main() { int listenfd=socket(AF_INET,SOCK_STREAM,0); struct sockaddr_in cliaddr,servaddr; 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,(struct sockaddr *)&servaddr,sizeof(servaddr)); listen(listenfd,LISTENQ); /* *客户套接字发送FIN给服务器，服务器收到回应ACK以确认，这就是TCP的终止链 *的前半部分 *当服务器TCP收到FIN时，该连接的读半部关闭，read返回0,str_echo返回，至 *子进程服务器exit终止返回至main函数，子进程服务器打开的所有描述符全部 *关闭，由子进程关闭套接字会发tcp终止连接的最后连个分节，一个服务器到 *客户的FIN和客户到服务器的ACK，至此完全终止链接，客户套接字进入 *TIME_WAIT状态。由于任何子进程终止时会给父进程发放送一个SIGCHLD信号，该 *信号的默认处理是忽略，父进程不处理此信号，子进程会进入僵尸状态，所以父 *进程要捕获该信号。 */ signal(SIGCHLD,header); while(1) { socklen_t clilen=sizeof(cliaddr); /* * 当一直没有客户连接到服务器，accept函数会阻塞，当在accept中阻塞时 * 收到某个信号且从信号处理程序中返回，这个系统调用会被中断，调用返 * 错误，设置errno为EINTR，对于accept系统调用要进行人为重启，但是co * nnect不能重启，否则会返回错误，处理方法是：用select等待连接而完成 *递交SIGCHLD信号时，父进程阻塞于accept调用 */ int connfd=accept(listenfd,(struct sockaddr *)&cliaddr,&clilen); if(connfd<0) if(errno==EINTR) continue; else err_sys("accept error"); pid_t cpid; //fork之后listenfd和connfd的引用计数都为2 if((cpid=fork())==0) { close(listenfd);//关闭监听套接字，时listenfd计数一直为一 str_echo(connfd); close(connfd); exit(0); } close(connfd);//新的客户由子进程提供服务，父进程可以关掉已连接套接字 } exit(0); }
客户代码
阻塞的客户端
#include "unp.h" #include "my_err.h" void str_cli(FILE *fp,int sockfd) { char buffer[MAXLINE]; int stdineof=0; fd_set rest; FD_ZERO(&rest); int n; while(1) { if(stdineof==0) FD_SET(fileno(fp),&rest); FD_SET(sockfd,&rest);//把socked描述符加入rest集合 int maxfd=max(fileno(fp),sockfd)+1; /* *客户端等待可读：标准输入可读或是套接字可读，select返回后会把以前 *加入的但并无时间发生的fd清空，所以每次select开始之前要把fd逐个加入 */ select(maxfd,&rest,NULL,NULL,NULL); /*等待套接字可读 * 1.对端tcp发送数据，该套接字变为可读，read并返回个大于0的数 * 2.对端tcp发送FIN(对端进程终止)，该套接字变为可读，read返回0(EOF) * 3.对端tcp发送RST(对端主机)崩溃并重启，该套接字变为可读，read返回 * -1，errno中含有确切的错误代码 */ /*补充下服务器端的套接字可读或可写 * 1.accept成功之后便是可读 * 2.当客户端发送recv函数，服务器端便知道客户端可写， */ if(FD_ISSET(sockfd,&rest)) { if((n=read(sockfd,buffer,MAXLINE))==0) if(stdineof==1) return; else err_quit("str_cli: server terinated prematurely"); write(fileno(stdout),buffer,n); } //等待stdin可读，有数据就可读 if(FD_ISSET(fileno(fp),&rest)) { //客户端输入完成 if((n=read(fileno(fp),buffer,MAXLINE))==0) { stdineof=1; /*SHUT_WR * send FIN，留在当前缓冲区中的数据被发送，后跟TCP的终止序列 * 不论socket的引用是否为0，都关闭；在标准输入的方式下，输入 * 的eof并不以为socket同时也完成了读，有可能请求在区服务器的 * 路上，或者答应可能返回客户的路上，所以需要一种关闭tcp一般 * 的方法，给服务器发送FIN，告诉服务器我们已经完成了数据输入 * 但socket仍打开保持读。 */ shutdown(sockfd,SHUT_WR); //客户端完成了数据发送，要清除stdin文件描符，防止再次发送数 //据 FD_CLR(fileno(fp),&rest); continue; } write(sockfd,buffer,n); } } return ; } int main(int argc,char **argv) { //命令行获取服务器ip if(argc!=2) err_quit("please input tcplicent <IP-address"); int sockfd=socket(AF_INET,SOCK_STREAM,0); struct sockaddr_in servaddr; bzero(&servaddr,sizeof(servaddr)); servaddr.sin_family=AF_INET; servaddr.sin_port=htons(SERV_PORT); inet_pton(AF_INET,argv[1],&servaddr.sin_addr);//把assic转换为二进制 connect(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr)); str_cli(stdin,sockfd); exit(0); }
connect出错
- 若TCP客户端没有收到syn分节的响应，则返回ETIMEOUT错误；调用connect函数时，内核发送一个syn，若无响应则等待6s后再发送一个，若仍然无响应则等待24s后在发送一个，若总共等待75s后仍未收到响应则返回本错误；
- 若对客户的syn响应是rst，则表明该服务器在我们指定的端口上没有进程在等待与之连接，这是一种硬错误，客户一收到rst马上返回ECONNREFUSED错误（产生RST三个条件：1.目的地为某个端口的SYN到达而端口上没有正在监听的服务器2.TCP想取消一个已有的连接3.TCP收到一个根本不存在的连接上的分节）；
- 若客户发送的syn在中间的某个路由器上引发了目的不可达icmp错误，则认为是一种软错误。客户主机内核保存该消息，并按照第一种情况的时间间隔继续发送syn，咋某个规定时间后仍未收到响应，则把保存的消息作为EHOSTUNREACH或者ENETUNREACH错误返回给进程；
accept返回前连接中止
在比较忙的服务器中，在建立三次握手之后，调用accept之前，可能出现客户端断开连接的情况；如，三次握手之后，客户端发送rst，然后服务器调用accept。posix指出这种情况errno设置为CONNABORTED;注意Berkeley实现中，没有返回这个错误，而是EPROTO，同时完成三次握手的连接会从已完成队列中移除；在这种情况下，如果我们用select监听到有新的连接完成，但之后又被从完成队列中删除，此时如果调用阻塞accept就会产生阻塞；
解决办法：
- 使用select监听套接字是否有完成连接的时候，总是把这个监听套接字设置为非阻塞；
- 在后续的accept调用中忽略以下错误，EWOULDBLOCK(Berkeley实现，客户中止连接), ECONNABORTED(posix实现，客户中止连接), EPROTO(serv4实现，客户中止连接)和EINTR(如果有信号被捕获)；
服务器进程终止(崩溃)
在客户端和服务器端建立连接之后，使用kill命令杀死服务器进程，进程终止会关闭所有打开的描述符，这导致了其向客户端发送了一个FIN，而客户端则响应了一个ack，这就完成了tcp连接终止的前半部分，只代表服务器不在发送数据了；但是客户端并不知道服务器端已经终止了，当客户端向服务器写数据的时候，由于服务器进程终止，所以响应了rst，如果我们使用select等方式，能够立即知道当前连接状态；如下：
- 如果对端tcp发送数据，那么套接字可读，并且read返回一个大于0的值(读入字节数)；
- 如果对端tcp发送了fin(对端进程终止)，那么该套接字变为可读，并且read返回0(EOF)；
- 如果对端tcp发送rst(对端主机崩溃并重启)，那么该套接字变为可读，并且read返回-1，errno中含有确切错误码；
sigpipe信号
当服务器关闭连接时，客户端收到FIN（read==0），但是FIN的接受并没有告知服务器已经终止连接，只是告诉了服务器不再向客户发送数据，若此时服务器又接收到来自客户端数据，因为先前打开的套接字的那个进程已被终止，所以此时回会相应一个RST。
当一个进程向某个收到rst的套接字执行写操作的时候，内核向该进程发送一个SIGPIPE信号，该信号的默认行为是终止进程，因此进程必须捕获它以免不情愿的被终止；不论进程是捕捉了该信号并从信号处理函数中返回，还是简单忽略该信号，写操作都讲返回EPIPE错误；
服务器主机崩溃
建立连接之后，服务器主机崩溃，此时如果客户端发送数据，会发现客户端会在一定时间内持续重传，视图从服务器端收到数据的ack，当重传时间超过指定时间后，服务器仍然没有响应，那么返回的是ETIMEDOUT；
服务器主机不可达
建立连接之后，服务器主机未崩溃，但是由于中间路由器故障灯，判定主机或网络不可达，此时如果客户端发送数据，会发现客户端会在一定时间内持续重传，视图从服务器端收到数据的ack，当重传时间超过指定时间后，服务器仍然没有响应，那么返回的是EHOSTUNREACH或ENETUNREACH；
服务器主机崩溃后重启
当服务器主机崩溃重启后，之前所有的tcp连接丢失，此时服务器若收到来自客户端的数据，会响应一个rst；客户端调用read将返回一个ECONNRESET错误；
服务器主机关机
系统关机时，init进程给所有进程发送SIGTERM信号，等待固定的时间，然后给所有仍在运行的进程发送SIGKILL信号，我们的进程会被SIGTERM或者SIGKILL信号终止，所以与前面服务器进程终止相同，进程关闭所有描述符，并发送fin，完成服务器端的半关闭
以下code含以上问题及解决办法
客户
/************************************************************************* > File Name: client.cpp > Author: Chen Tianzeng > Mail: 971859774@qq.com > Created Time: 2019年03月04日 星期一 08时51分56秒 ************************************************************************/ #include <iostream> #include <sys/socket.h> #include <cstring> #include <unistd.h> #include <arpa/inet.h> #include <sys/types.h> #include <netinet/in.h> #include <netinet/tcp.h> #include <fcntl.h> #include <sys/select.h> #include <sys/time.h> using namespace std; void cli_echo(int sockfd) { //设置等待时间等待connect连接成功 struct timeval tval; tval.tv_sec=6; tval.tv_usec=0; fd_set set,wset; FD_ZERO(&set); FD_ZERO(&wset); string s; while(1) { FD_SET(fileno(stdin),&set); FD_SET(sockfd,&set); FD_SET(sockfd,&wset); //客户端对应两个输入，套接字和用户输入，他不能单纯的阻塞在某个中断 //上，应该阻塞在任何一个中断上 int maxfd=max(fileno(stdin),sockfd)+1; int res=select(maxfd,&set,&wset,NULL,&tval); if(res<=0) { cerr<<"connect time out"<<endl; close(sockfd); exit(0); } /* * socket描述符只可写，连接成功 * 若即可读又可写，分为两种情况： * 第一种:出错,因为可能是connect连接成功后远程主机断开连接close(socket) * 第二种:连接成功，socket读缓冲区得到了远程主机发送的数据，根据 * connect连接成功后errno的返回值来判定，或通过getsockopt函数返回值 * 来判断,但linux下getsockopt始终返回0，错误的情况下应返回-1 */ int n=0; if(FD_ISSET(fileno(stdin),&set)) { if((n=read(fileno(stdin),(void*)s.c_str(),1024))==0) { shutdown(sockfd,SHUT_WR); continue; } //只可写肯定返回成功 if(FD_ISSET(sockfd,&wset)&&!FD_ISSET(sockfd,&set)) { //3.对已经收到RST的套接字进行写操作，内核向进程发送SIGPIPE //第一次write引发RST，第二次产生SIGPIPE,如何在第一次写操作 //捕获SIGPIPE，做不到 write(sockfd,(void *)s.c_str(),1); sleep(1); write(sockfd,(void *)(s.c_str()+1),n-1); } } else if(FD_ISSET(sockfd,&set)&&FD_ISSET(sockfd,&wset)) { int err; socklen_t len=sizeof(err); //不通过getsockopt返回值判断，通过返回的参数判断 getsockopt(sockfd,SOL_SOCKET,SO_ERROR,&err,&len); if(err) { cerr<<err<<" :"<<strerror(err)<<endl; exit(0); } if((n=read(sockfd,(void *)s.c_str(),1024))>0) write(fileno(stdout),(void *)s.c_str(),n); if(n==0)//2.服务器端进程关闭,客户会收到服务器的一个RST { cerr<<strerror(errno)<<endl; exit(0); } } } return ; } int main() { int sockfd=socket(AF_INET,SOCK_STREAM,0); //禁用nagle算法 const char opt=1; setsockopt(sockfd,IPPROTO_TCP,TCP_NODELAY,&opt,sizeof(opt)); sockaddr_in servadddr; memset(&servadddr,sizeof(servadddr),0); servadddr.sin_family=AF_INET; servadddr.sin_port=htons(9877); inet_pton(AF_INET,"127.0.0.1",&servadddr.sin_addr); int res=connect(sockfd,(struct sockaddr *)&servadddr,sizeof(servadddr)); //1.connect返回立即发送RST struct linger l; l.l_onoff=1; l.l_linger=0; setsockopt(sockfd,SOL_SOCKET,SO_LINGER,&l,sizeof(l)); fcntl(sockfd,F_SETFL,fcntl(sockfd,F_GETFL,0)|O_NONBLOCK); //res==0连接成功 //==-1开始三次握手但未完成 if(res==-1) { if(errno!=EINPROGRESS)//表示正在试图连接，不能表示连接失败 { //oeration now progress:套接字为非阻塞套接字，且原来的连接未完成 cout<<strerror(errno)<<endl; exit(0); } /** * 也可以在此处处理select连接 */ } cli_echo(sockfd); close(sockfd); return 0; }
服务器
/************************************************************************* > File Name: server.cpp > Author: Chen Tianzeng > Mail: 971859774@qq.com > Created Time: 2019年03月04日 星期一 09时35分26秒 ************************************************************************/ #include <iostream> #include <cstring> #include <sys/socket.h> #include <arpa/inet.h> #include <netinet/in.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <signal.h> #include <sys/wait.h> using namespace std; void header(int num) { pid_t pid; int stat; while((pid=waitpid(-1,&stat,WNOHANG))>0) cout<<"child:"<<pid<<"terminated"<<endl; return ; } void str_echo(int fd) { ssize_t n=0; char buf[1024]; again:while((n=read(fd,buf,1024))>0) write(fd,buf,n); //处理中断系统调用错误 if(n<0&&errno==EINTR) goto again; else if(n<0&&errno==ECONNRESET)//1. { cerr<<"reset by perr"<<endl; exit(0); } else cerr<<"read error"<<endl; } int main() { int sockfd=socket(AF_INET,SOCK_STREAM,0); int keepidle=1; setsockopt(sockfd,SOL_SOCKET,SO_KEEPALIVE,(void *)&keepidle,sizeof(keepidle)); sockaddr_in cliaddr,servaddr; memset(&servaddr,sizeof(servaddr),0); servaddr.sin_family=AF_INET; servaddr.sin_port=htons(9877); servaddr.sin_addr.s_addr=htonl(0);//INADDR_ANY bind(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr)); listen(sockfd,1024); signal(SIGCHLD,header); while(1) { socklen_t len=sizeof(cliaddr); //1.模拟较忙的服务器 //sleep(10);//完成三路握手后客户发送RST(复位) conn:int connfd=accept(sockfd,(sockaddr *)&cliaddr,&len); //处理被中断的系统调用，因为在阻塞于某个中断时，这时候进来一个 //信号，执行信号处理函数返回后系统调用会返回EINTR if(connfd<0) { if(errno==EINTR) goto conn; else if(errno==ECONNABORTED) { cerr<<"accept:connect reset by peer"<<endl; exit(0); } } else { pid_t pid; if((pid=fork())==0) { close(sockfd); char des[100]; //cout<<getpid()<<endl; inet_ntop(AF_INET,&cliaddr.sin_addr.s_addr,des,sizeof(des)); cout<<"accept success,cliaddr is:"<<des<<endl; str_echo(connfd); close(connfd); exit(0); } close(connfd); } } return 0; }
在这些基础的socket API中，accept，connect，send，recv都可能是阻塞的，但是可以把他们编程非阻塞；
- 对于accept，send，recv来说，设置为非阻塞时errno返回值为-1且通常设置为EAGAIN（再来一次）或EWOULDBLOCk（期望阻塞）
- 对于connect，errno被置为EINPROGRESS（在处理中）