accept函数解释：

专注于把拿上来的链接进行通信

注意一下这里的sockfd和返回值的区别：

sockfd相当于是一个在门口招呼客人的引导员，至于具体是谁来招待你，那是另外你个里面的人了，这个里面的人就相当于返回值的这个文件描述符。

下面是参考的相关的文献，关于其解释的比较合理的地方，引用并标注了出来。

有一种比较老的连接服务器的方式 : 直接telnet 后面跟上端口号 /IP/网址

第二个和第三个参数表明你要连接谁。

在连接的时候，系统底层就自动为我们进行了绑定（实际上是进行三次握手，我们后面会说）

tcp服务器和udp服务器代码实现：

udp服务器：

 udpServer.hpp

 1 #pragma once                                                                                                                                                                                                  2 #include<stdlib.h>3 #include<cstdio>4 #include<unistd.h>5 #include <iostream>6 #include <string>7 #include<arpa/inet.h>8 #include<sys/types.h>9 #include<sys/socket.h>10 #include<netinet/in.h>11 class udpServer12 {13   private:14 //    std::string ip;15     int port;16     int sock;17   public:18     udpServer(int _port = 8080)19       ://ip(_ip)20        port(_port)21   {}22     void InitServer()23     {24       sock = socket(AF_INET ,SOCK_DGRAM ,0);//系统信息我有，网络信息我有（都在这里创建的），但是二者之间没有关系，AF_INET 是一个宏的值，为2,代表其为ipv4的一个ip地址。25       //SOCK_DGRAM表示其所采用的为udp协议26       std::cout << "sock :" <<sock << std::endl;27       struct sockaddr_in local;//到目前为止，其也只是保存在用户栈上的，我们要让操作系统拿到它，用到它，需要将其bind起来，弄到内核栈中去28       local.sin_family = AF_INET;29       local.sin_port = htons(port);30       local.sin_addr.s_addr = INADDR_ANY;31       //bind 将网络文件将文件和网络关联起来，即将系统信息和网络信息关联起来32       if(bind(sock, (struct sockaddr*)&local, sizeof(local))<0)33         //搞这么复杂，其本质上还是让我们能用一套接口完成所有的调用34       {35         std::cerr << "bind error\n"<<std::endl;36         exit(1);37       }38     }39 40     void start()41     {42         char msg[256];43         //std::string msg;44         for(;;)45         {46           //我们来将客户端的ip地址和端口号拿出来看下：47           msg[0] = 0;48           struct sockaddr_in end_point;49           socklen_t len = sizeof(end_point);                                                                                                                          50            ssize_t s = recvfrom(sock,msg,sizeof(msg)-1,\51               0,(struct sockaddr*)&end_point,&len);52            if(s > 0)                                                                                                                   53            {                     54              char buf[16];         55              sprintf(buf, "%d",ntohs(end_point.sin_port));56              std::string cli = inet_ntoa(end_point.sin_addr);              57              cli += ":";                                       58              cli += buf;                                          59              msg[s] = '\0';60              std::cout <<cli<< "# "<<msg<<std::endl;61              std::string echo_string = msg;62              echo_string += "[server echo!]";63              sendto(sock,echo_string.c_str(),echo_string.size(),0,(struct sockaddr*)&end_point,len);64            }65         }       66     }67                       68     ~udpServer()          69     {          70       close(sock);71     }                                                 72 };                              

udpServer.cc

  1 #include "udpServer.hpp"                                                                                                                                                                                      2 3 void Usage(std::string proc)4 {5   std::cout << "Usage :" <<proc << "loca_port "<<std::endl;6 }7 8 int main(int argc, char* argv[])9 {10   if(argc != 2)11   {12     Usage(argv[0]);13     exit(1);14   }15   udpServer* up = new udpServer(atoi(argv[1]));16   up->InitServer();17   up->start();18   delete up;19   return 0;20 }

udpClient.hpp

  1 #pragma once                                                                                                                                                                                                  2 #include<stdlib.h>3 #include<unistd.h>4 #include <iostream>5 #include <string>6 #include<arpa/inet.h>7 #include<sys/types.h>8 #include<sys/socket.h>9 #include<netinet/in.h>10 class udpClient11 {12   private:13     std::string ip;14     int port;15     int sock;16   public:17     //ip,port ? 是server的 18     udpClient(std::string _ip = "127.0.0.1",int _port = 8080)19       :ip(_ip)20        ,port(_port)21   {}22     void InitClient()23     {24       sock = socket(AF_INET ,SOCK_DGRAM ,0);//系统信息我有，网络信息我有（都在这里创建的），但是二者之间没有关系，AF_INET 是一个宏的值，为225       std::cout << "sock :" <<sock << std::endl;26       //客户端不需要绑定27       //struct sockaddr_in local;//到目前为止，其也只是保存在用户栈上的，我们要让操作系统拿到它，用到它，需要将其bind起来，弄到内核栈中去28       //local.sin_family = AF_INET;29       //local.sin_port = htons(port);30       //local.sin_addr.s_addr = inet_addr(ip.c_str());31       bind 将网络文件将文件和网络关联起来，即将系统信息和网络信息关联起来32       //if(bind(sock, (struct sockaddr*)&local, sizeof(local))<0)33       //  //搞这么复杂，其本质上还是让我们能用一套接口完成所有的调用34       //{35       //  std::cerr << "bind error\n"<<std::endl;36       //  exit(1);37       //}38     }39 40     void start()41     {42         //char msg[256];43         std::string msg;44         struct sockaddr_in peer;45         peer.sin_family = AF_INET;46         peer.sin_port = htons(port);47         peer.sin_addr.s_addr = inet_addr(ip.c_str());48         for(;;)            49         {                                                    50           std::cout << "please Enter# ";51           std::cin >>msg;52           sendto(sock ,msg.c_str(),msg.size(),0,(struct sockaddr*)&peer,sizeof(peer));53          char echo[128];54           ssize_t s = recvfrom(sock,echo,sizeof(echo)-1 ,0,nullptr,nullptr);55           if(s > 0)                                                                                                                        56           {                                     57             echo[s] = 0;58             std::cout << "server# "<< echo <<std::endl;                                                                                  59           }                        60                                      61           // msg[0] = 0;                              62          // struct sockaddr_in end_point;                                    63          // socklen_t len = sizeof(end_point);                   64          //  ssize_t s = recvfrom(sock,msg,sizeof(msg)-1,\          65          //     0,(struct sockaddr*)&end_point,&len);66          //  if(s > 0)                           67          //  {    68          //    msg[s] = '\0';69          //    std::cout << "client# "<<msg<<std::endl;70          //  }71         }       72     }73                         74     ~udpClient()        75     {                           76       close(sock);                77     }                               78 };

udpClient.cc

 1 #include "udpClient.hpp"                                                                                                                                                                                      2 3 void Usage(std::string proc)4 {5   std::cout << "Usage :" <<proc << "svr_ip svr_port "<<std::endl;6 }7 int main(int argc,char* argv[])8 {9   if(argc != 3)10   {11     Usage(argv[0]);12     exit(1);13   }14   udpClient uc(argv[1],atoi(argv[2]));15   uc.InitClient();16   uc.start();17   return 0;18 }

（由于每一行的代码前面有数字，所以建议各位自行实践一遍）

TCP服务器：

（这里所有的代码都是优化之后的最终版本）

tcpServer.hpp

    1#pragma once                                                                                                                                                                                                2 #include<iostream>3 #include<pthread.h>4 #include<unistd.h>5 #include<string.h>6 #include<string>7 #include<stdlib.h>8 #include<signal.h>9 #include<sys/types.h>10 #include<sys/socket.h>11 #include<netinet/in.h>12 #include<arpa/inet.h>13 14 #define BACKLOG 515 16 17 class tcpServer{18   private:19     int port;20     int lsock;21   public:22     tcpServer(int _port):port(_port),lsock(-1)23   {}24 25     void InitServer()26     {27       signal(SIGCHLD,SIG_IGN);28       lsock = socket(AF_INET,SOCK_STREAM,0);29       if(lsock < 0)30       {31         std::cerr << "socket error" <<std::endl;32         exit(2);33       }34       struct sockaddr_in local;35       local.sin_family = AF_INET;36       local.sin_port = htons(port);37       local.sin_addr.s_addr = INADDR_ANY;38       39       if(bind(lsock, (struct sockaddr*)&local, sizeof(local)) < 0)40       {41         std::cerr << "bind error" << std::endl;42         exit(3);43       }44 45       if(listen(lsock,BACKLOG) < 0)46       {47         std::cerr << "bind error" << std::endl;48         exit(4);49       }50 51     }52 53 54     static void service(int sock)55     {56 57       char buffer[1024];58       while(true)59       {60         //可以用read和write，因为这个时候的链接已经在等待队列里等待获取调用了。61         //send = write; recv = read;62         size_t s = recv(sock,buffer,sizeof(buffer)-1,0);63         if(s > 0)64         {65           buffer[s-1] = 0;66           fflush(stdout);67           std::cout << "client# " << buffer <<std::endl;68 69           send(sock,buffer,strlen(buffer),0); 70         }71         else if(s == 0)72         {73           std::cout << "client quit" <<std::endl;74           close(sock);75           break;76         }77         else 78         {79           std::cout << "recv client data error..."<<std::endl;80           break;81         }82 83       }84     }85     static void* serviceRoutine(void* arg)86     {87       pthread_detach(pthread_self());88       std::cout <<"create a new thread for IO"<<std::endl;                                                                                                                                                  89       int* p = (int*)arg;90       int sock = *p;91 92       service(sock);93       delete p;94     }95 96     void start()97     {98 99         sockaddr_in endpoint;100         while(true)101         {102           std::cout <<"Please Enter Message"<<std::endl;103           socklen_t len = sizeof(endpoint);104           int sock = accept(lsock,(struct sockaddr*)&endpoint,&len);105           if(sock < 0)106           {107             std::cerr<<"accept error"<<std::endl;108             continue;109           }110           std::string cli_info = inet_ntoa(endpoint.sin_addr);111           cli_info += ":";112           cli_info += std::to_string(ntohs(endpoint.sin_port));113           std::cout << "get a new link ..." << cli_info <<std::endl;114           int* p = new int(sock);115           pthread_t tid;116           pthread_create(&tid,nullptr,serviceRoutine,(void*)p);117 118     //      pid_t id = fork();119     //      if(id == 0)120     //      {121     //        close(lsock);122     //        service(sock);123     //        exit(0);124     //      }125     //      close(sock);//建议关闭：因为1、不要相信任何使用者；2、如果不关闭，会导致父进程可使用的文件描述符越来越少126         }127     }128      129 130 131 132 133     ~tcpServer()134     {135       close(lsock);136     }                                                                                                                                                                                                       137 };

tcpServer.cc

  1                                                                                                                                                                                                               2 #include"tcpServer.hpp"3 4 5 void  Usage(std::string proc)6 {7   std::cout << "Usage :" <<std::endl;8   std::cout << '\t' << proc << "port" <<std::endl;9 10 }11 12 13 int main(int argc, char* argv[])14 {15   if(argc != 2)16   {17     Usage(argv[0]);18     exit(1);19   }20   tcpServer * tp = new tcpServer(atoi(argv[1]));21   tp->InitServer();22   tp->start();23 24   delete tp;25   return 0;26 }

tcpClient.hpp

  1 #pragma once 2 3 #include<iostream>4 #include<stdlib.h>                                                                                                                                                                                            5 #include<unistd.h>6 #include<sys/types.h>7 #include<sys/socket.h>8 #include<netinet/in.h>9 #include<arpa/inet.h>10 #include<string>11 #include<string.h>12 class tcpClient13 {14   private:15     int port;//服务器的端口号和ip16     std::string ip;17     int sock;18   public:19     tcpClient(std::string _ip = "127.0.0.1",int _port = 8080)20       :port(_port),ip(_ip)21     {}22 23     void InitClient()24      {25         sock = socket(AF_INET,SOCK_STREAM,0);26         if(sock < 0)27         {28           std::cerr << "socket error" << std::endl;29           exit(2);30         }31 32         struct sockaddr_in svr;33         svr.sin_family = AF_INET;34         svr.sin_port = htons(port);35         svr.sin_addr.s_addr = inet_addr(ip.c_str());36         if(connect(sock, (struct sockaddr*)&svr,sizeof(svr)) != 0)37         {38             std::cerr << "connect error" <<std::endl;39         }40      }41      void start()42      {43 44        char msg[64];45         while(true)46         {47           size_t s = read(0,msg,sizeof(msg)-1);48           if(s > 0)49           {50             msg[s] = 0;51             send(sock,msg,strlen(msg),0);52             size_t ss = recv(sock,msg,sizeof(msg)-1,0);53             if(ss > 0) 54             {55               msg[ss] = 0;56               std::cout << "server echo #" << msg <<std::endl;57             }58           }59         }60      }61     ~tcpClient()62     {63       close(sock);64     }65 };

tcpClient.cc

  1 #include"tcpClient.hpp"2 3 void Usage(std::string proc)4 {5   std::cout << "Usage:" << proc <<std::endl;6   std::cout << '\t'<<"server_port server_ip"<<std::endl;7 }8 9 10 int main(int argc,char* argv[])11 {12   if(argc != 3)13   {14     Usage(argv[0]);15     exit(1);16   }17 18 19   tcpClient* tc = new tcpClient();20   tc->InitClient();21   tc->start();                                                                                                                                                                                                22   return 0;23 }

我们最初的版本，当客户端退出的时候，服务器要么在recv阻塞，要么在send阻塞，反正是在某一个地方阻塞住了。

那么我们作为服务器，如何能够判断出外部的服务器链接退出了呢？

答案就在我们的recv上面。当recv的返回值为0的时候，就代表着客户端链接退出。

而当一个客户端链接退出的时候，我们应当让服务器从当循环中退出，然后关闭和客户端建立连接的套接字

而上面版本的又是单进程（线程）的。

不能支持同时连接多个客户端（想一下，为什么我们之前的udp可以？）

因为udp不管那么多事情，把报文扔出去的那一个瞬间，它的任务就完成了。也就是说，其是无连接的。

所以，我们进行了优化，将其改成了多进程的版本（我们在上面的代码略有提到）

代码运行实验与进程监视（ps aux | grep -E 'tcpClient'），如下：

（注：上述的ctrl + z表示将其放在后台运行，如上）

（退出方式） （fg + 序号）则可表示将其放在前台运行（注意：同一个时间前台运行的程序只能有一个，如上）

（也可以采用这样的监控脚本进行监控，如上）

（监视其网络状态，如下）

关于多进程的写法，我们也可以采用爷孙的方式（如下），但是这种方法不是很推荐，因为创建新的进程需要资源。

我们还可以考虑采用多线程的写法（即上述代码的最终版）：

代码实验结果以及监视结果（对多线程进行监视  ps -aL）

也可以考虑采用这样的监控脚本：

总结一下，我们的服务器经历了：

（关于线程池的代码我们稍后再说）

短链接：

并且，向上面这种设计方法，实际上是基于短链接的：

每一次链接只完成一次任务，一次请求，一次回复，这样的 链接称为短链接。

我们将上述的接口现在对比着TCP通讯的流程，

来解释一下各个接口的作用：

首先，我们所用的模型通常被称之为CS模型：

即客户端主动连接服务端，而服务端不会主动连接客户端的这样一种连接方式

以TCP三次握手、四次挥手为例：

（先来说一下三次握手）

1、客户端向服务器发起SYN请求：客户端给服务器发了一个数据报，在数据报中有一个标志位SYN，如果经过了某种设置，那么其就是一个服务器连接请求

2、服务器进行相应，发出含有SYN+ACK的报文。这里的ACK即表明一种成功应答

3、客户端再次向服务器发出回应ACK，服务器接收后，三次握手完成。

（包括四次挥手后面具体再说）

我们这里要说的是其和系统调用接口的关系：

在服务器处于listen状态时，（即此时服务端已经建立了listen套接字）

1、connect本质上是触发客户端向服务器发送SYN的数据报，触发链接建立，即触发三次握手

2、三次握手之后，accept返回，即此时建立分配了新的文件描述符用于和客户端通信。

3、接下来，就是双方的数据接收和发送。Send = write; recv = read(注意，这里收发数据之后另一方需要ACK，即应答（为了保证可靠性，同时也是因为双方的通信地位时对等的）)

4、紧接着，如果要断开连接，服务器和客户端都要调用close。客户端调用close是向服务器发送FIN，服务器自动ACK。而服务器调用close本质上时服务器给客户端调用FIN,然后客户端自动ACK.

TCP协议是全双工的。即接收端和发送端在地位上是平等的，即一端在发送的时候也可以进行发送数据。

与之对应的是半双工，即一端发送或者接收的时候，另一端只能够听着或者看着。

我们最后来理解一下文件描述符和套接字是怎么产生关联的（从内核代码的角度）

我们本质上调用了sys_socket等函数指针，然后创建了一个socket结构体， 而这个结构体里面又包含了一个文件指针和一个sock指针（文件指针指向描述符，sock指针则指向sock结构体）。

而sock结构体中有一个接收队列和写入队列的概念。

在tcp_sock和udp_sock中，第一个为inet_connection_sock，而在inet_connection_sock中，第一个又为sock指针。

所以说，这些关系只要强转一下，就可以直接转换了。

并且在file文件中，还有一个private_data，而它的定义就是sock。

即通过sock可以指向file，通过file也可以找到sock。

好啦，本节内容到此结束啦~~