devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

简单的TCP网络程序：英译汉服务器

作者：花生_TL007 | 2024-05-28 23:07:09

赞

踩

简单的TCP网络程序：英译汉服务器

一、服务器的初始化

下面介绍程序中用到的socket API,这些函数都在sys/socket.h中。

1.创建套接字

socket()：

⭐参数介绍：

  • socket()打开一个网络通讯端口,如果成功的话,就像open()一样返回一个文件描述符;
  • 应用程序可以像读写文件一样用read/write在网络上收发数据;
  • 如果socket()调用出错则返回-1;
  • 对于IPv4, family参数指定为AF_INET;
  • 对于TCP协议,type参数指定为SOCK_STREAM, 表示面向流的传输协议
  • protocol参数的介绍从略,指定为0即可。
  1. class TcpServer
  2. {
  3. public:
  4.     TcpServer()
  5.         : _sockfd(defaultsockfd)
  6.     {
  7.     }
  8.     void Init()
  9.     {
  10.         _sockfd = socket(AF_INET, SOCK_STREAM, 0);
  11.         if (_sockfd < 0) // 创建套接字失败
  12.         {
  13.             lg(Fatal, "create socket, errno : %d, errstring: %s", errno, strerror(errno));
  14.             exit(SocketError);
  15.         }
  16.         lg(Info, "create socket success, socket: %d", _sockfd);
  17.     }
  18.     ~TcpServer()
  19.     {
  20.         close(_sockfd);
  21.     }
  22.  
  23. private:
  24.     int _sockfd; // 套接字
  25. };

2.绑定端口号和ip

bind()：

⭐参数介绍：

  • 服务器程序所监听的网络地址和端口号通常是固定不变的,客户端程序得知服务器程序的地址和端口号后 就可以向服务器发起连接; 服务器需要调用bind绑定一个固定的网络地址和端口号;
  • bind()成功返回0,失败返回-1。
  • bind()的作用是将参数sockfd和myaddr绑定在一起, 使sockfd这个用于网络通讯的文件描述符监听 myaddr所描述的地址和端口号;
  • 前面讲过,struct sockaddr *是一个通用指针类型,myaddr参数实际上可以接受多种协议的sockaddr结 构体,而它们的长度各不相同,所以需要第三个参数addrlen指定结构体的长度;

我们先来看看地址转换函数

本节只介绍基于IPv4的socket网络编程,sockaddr_in中的成员struct in_addr sin_addr表示32位 的IP 地址 但是我们通常用点分十进制的字符串表示IP 地址,以下函数可以在字符串表示 和in_addr表示之间转换;

字符串转in_addr的函数:

in_addr转字符串的函数:

其中inet_pton和inet_ntop不仅可以转换IPv4的in_addr,还可以转换IPv6的in6_addr,因此函数接口是void *addrptr。inet_ntoa这个函数返回了一个char*, 很显然是这个函数自己在内部为我们申请了一块内存来保存ip的结果. 那么是 否需要调用者手动释放呢?

man手册上说, inet_ntoa函数, 是把这个返回结果放到了静态存储区. 这个时候不需要我们手动进行释放. 那么问题来了, 如果我们调用多次这个函数, 会有什么样的效果呢? 参见如下代码:

因为inet_ntoa把结果放到自己内部的一个静态存储区, 这样第二次调用时的结果会覆盖掉上一次的结果

  • 思考: 如果有多个线程调用 inet_ntoa, 是否会出现异常情况呢?
  • 在APUE中, 明确提出inet_ntoa不是线程安全的函数;
  • 但是在centos7上测试, 并没有出现问题, 可能内部的实现加了互斥锁;
  • 自己写程序验证一下在自己的机器上inet_ntoa是否会出现多线程的问题;
  • 在多线程环境下, 推荐使用inet_ntop, 这个函数由调用者提供一个缓冲区保存结果, 可以规避线程安全问 题;

我们的程序中对myaddr参数是这样初始化的：

  • 1. 将整个结构体清零；
  • 2. 设置地址类型为AF_INET；
  • 3. 网络地址为0.0.0.0, 这个宏表示本地的任意IP地址,因为服务器可能有多个网卡,每个网卡也可能绑定多个IP 地址, 这样设置可以在所有的IP地址上监听,直到与某个客户端建立了连接时才确定下来到底用 哪个IP 地址；
  1. class TcpServer
  2. {
  3. public:
  4.     TcpServer(const uint16_t& port, const string& ip = defaultip)
  5.         : _sockfd(defaultsockfd)
  6.         , _port(port)
  7.         , _ip(ip)
  8.     {
  9.     }
  10.     void Init()
  11.     {
  12.         // 1.创建套接字
  13.         _sockfd = socket(AF_INET, SOCK_STREAM, 0);
  14.         if (_sockfd < 0) // 创建套接字失败
  15.         {
  16.             lg(Fatal, "create socket error, errno : %d, errstring: %s", errno, strerror(errno));
  17.             exit(SocketError);
  18.         }
  19.         lg(Info, "create socket success, socket: %d", _sockfd);
  20.  
  21.         //2.绑定端口号
  22.         // 使用这个结构体需要包头文件
  23.         struct sockaddr_in local;
  24.         memset(&local, 0, sizeof(local));
  25.         local.sin_family = AF_INET;
  26.         // 转化为网络序列
  27.         local.sin_port = htons(_port);
  28.         // 字符串转化为点时分形式的ip
  29.         inet_aton(_ip.c_str(), &(local.sin_addr));
  30.         //此时我们仅仅只在用户栈填好了,并没有写进到打开的网络文件和套接字中,没有设置系统中
  31.         int n = bind(_sockfd, (const struct sockaddr*)&local, sizeof(local));
  32.         if(n < 0)
  33.         {
  34.             lg(Fatal, "bind error, errno : %d, errstring: %s", errno, strerror(errno));
  35.             exit(BindError);
  36.         }
  37.     }
  38.     ~TcpServer()
  39.     {
  40.         close(_sockfd);
  41.     }
  42.  
  43. private:
  44.     int _sockfd; // 套接字
  45.     uint16_t _port; // 端口号
  46.     string _ip; // ip地址
  47. };

3.设置监听状态

listen():

  • listen()声明sockfd处于监听状态, 并且最多允许有backlog个客户端处于连接等待状态, 如果接收到更多 的连接请求就忽略, 这里设置不会太大(一般是5);
  • listen()成功返回0,失败返回-1;
  1. #pragma onec
  2.  
  3. #include <iostream>
  4. #include <sys/types.h>
  5. #include <sys/socket.h>
  6. #include <unistd.h>
  7. #include <cstdlib>
  8. #include <cstring>
  9. #include <arpa/inet.h>
  10. #include <netinet/in.h>
  11. #include "log.hpp"
  12. using namespace std;
  13.  
  14. const int defaultsockfd = -1;
  15. const string defaultip = "0.0.0.0";
  16. const int backlog = 10; // 但是一般不要设置的太大
  17. Log lg;
  18.  
  19. enum
  20. {
  21.     UsageError = 1,
  22.     SocketError = 2,
  23.     BindError = 3,
  24.     ListenError = 4
  25. };
  26.  
  27. class TcpServer
  28. {
  29. public:
  30.     TcpServer(const uint16_t& port, const string& ip = defaultip)
  31.         : _sockfd(defaultsockfd)
  32.         , _port(port)
  33.         , _ip(ip)
  34.     {
  35.     }
  36.     void Init()
  37.     {
  38.         // 1.创建套接字
  39.         _sockfd = socket(AF_INET, SOCK_STREAM, 0);
  40.         if (_sockfd < 0) // 创建套接字失败
  41.         {
  42.             lg(Fatal, "create socket error, errno : %d, errstring: %s", errno, strerror(errno));
  43.             exit(SocketError);
  44.         }
  45.         lg(Info, "create socket success, socket: %d", _sockfd);
  46.  
  47.         //2.绑定端口号
  48.         // 使用这个结构体需要包头文件
  49.         struct sockaddr_in local;
  50.         memset(&local, 0, sizeof(local));
  51.         local.sin_family = AF_INET;
  52.         // 转化为网络序列
  53.         local.sin_port = htons(_port);
  54.         // 字符串转化为点时分形式的ip
  55.         inet_aton(_ip.c_str(), &(local.sin_addr));
  56.         //此时我们仅仅只在用户栈填好了,并没有写进到打开的网络文件和套接字中,没有设置系统中
  57.         int n = bind(_sockfd, (const struct sockaddr*)&local, sizeof(local));
  58.         if(n < 0)
  59.         {
  60.             lg(Fatal, "bind error, errno : %d, errstring: %s", errno, strerror(errno));
  61.             exit(BindError);
  62.         }
  63.         lg(Info, "bind socket success, socket: %d", _sockfd);
  64.  
  65.  
  66.         // 3.设置监听状态
  67.         // Tcp是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
  68.         if (listen(_sockfd, backlog) < 0)
  69.         {
  70.             lg(Fatal, "listen error, errno: %d, errstring: %s", errno, strerror(errno));
  71.             exit(ListenError);
  72.         }   
  73.         lg(Info, "bind socket success, socket: %d", _sockfd);
  74.  
  75.         
  76.     }
  77.     ~TcpServer()
  78.     {
  79.         close(_sockfd);
  80.     }
  81.  
  82. private:
  83.     int _sockfd; // 套接字
  84.     uint16_t _port; // 端口号
  85.     string _ip; // ip地址
  86. };

4.设置服务器的端口号和ip

未来我们向让用户设置端口号，所以我们可以在main函数中借助命令行参数传递，对于ip我们就直接使用默认的ip参数"0.0.0.0"即可。

  1. #include "TcpServer.hpp"
  2.  
  3. #include <memory>
  4.  
  5. void Usage(std::string proc)
  6. {
  7.     std::cout << "\n\rUsage: " << proc << " port[1024+]\n" << std::endl;
  8. }
  9.  
  10. // ./tcpserver 8080
  11. int main(int argc, char* argv[])
  12. {
  13.     if(argc != 2)
  14.     {
  15.         Usage(argv[0]);
  16.         exit(UsageError);
  17.     }
  18.     uint16_t port = std::stoi(argv[1]);
  19.     unique_ptr<TcpServer> tcpSvr(new TcpServer(port));
  20.     tcpSvr->Init();
  21.     //tcpSvr->Start();
  22.     return 0;
  23. }

现在我们就可以来测试一下啦！

二、服务器的运行

1.建立新链接

accept()：

  • 三次握手完成后, 服务器调用accept()接受连接;
  • 如果服务器调用accept()时还没有客户端的连接请求,就阻塞等待直到有客户端连接上来;
  • addr是一个传出参数,accept()返回时传出客户端的地址和端口号;
  • 如果给addr参数传NULL,表示不关心客户端的地址;
  • addrlen参数是一个传入传出参数(value-result argument), 传入的是调用者提供的, 缓冲区addr的长度 以避免缓冲区溢出问题, 传出的是客户端地址结构体的实际长度(有可能没有占满调用者提供的缓冲区);
  • 获取连接成功返回接收到的套接字的文件描述符，获取连接失败返回-1，同时错误码会被设置。

⭐accept函数返回的套接字是什么？

调用accept函数获取连接时，是从监听套接字当中获取的。如果accept函数获取连接成功，此时会返回接收到的套接字对应的文件描述符。

⭐监听套接字与accept函数返回的套接字的作用：

  • 监听套接字：用于获取客户端发来的连接请求。accept函数会不断从监听套接字当中获取新连接。
  • accept函数返回的套接字：用于为本次accept获取到的连接提供服务。监听套接字的任务只是不断获取新连接，类似于餐厅门口的迎宾，而真正为这些连接提供服务的套接字是accept函数返回的套接字，类似于餐厅的服务员，而不是监听套接字。

所以初始化TCP服务器时创建的套接字应该叫做监听套接字。为了表明寓意，我们将代码中套接字的名字由_sockfd改为_listensocket，这样写着更清楚明了。

  1. #pragma onec
  2.  
  3. #include <iostream>
  4. #include <sys/types.h>
  5. #include <sys/socket.h>
  6. #include <unistd.h>
  7. #include <cstdlib>
  8. #include <cstring>
  9. #include <arpa/inet.h>
  10. #include <netinet/in.h>
  11. #include "log.hpp"
  12. using namespace std;
  13.  
  14. const int defaultsockfd = -1;
  15. const string defaultip = "0.0.0.0";
  16. const int backlog = 10; // 但是一般不要设置的太大
  17. Log lg;
  18.  
  19. enum
  20. {
  21.     UsageError = 1,
  22.     SocketError = 2,
  23.     BindError = 3,
  24.     ListenError = 4
  25. };
  26.  
  27. class TcpServer
  28. {
  29. public:
  30.     TcpServer(const uint16_t& port, const string& ip = defaultip)
  31.         : _listensocket(defaultsockfd)
  32.         , _port(port)
  33.         , _ip(ip)
  34.     {
  35.     }
  36.     void Init()
  37.     {
  38.         // 1.创建套接字
  39.         _listensocket = socket(AF_INET, SOCK_STREAM, 0);
  40.         if (_listensocket < 0) // 创建套接字失败
  41.         {
  42.             lg(Fatal, "create socket error, errno : %d, errstring: %s", errno, strerror(errno));
  43.             exit(SocketError);
  44.         }
  45.         lg(Info, "create socket success, socket: %d", _listensocket);
  46.  
  47.         //2.绑定端口号
  48.         // 使用这个结构体需要包头文件
  49.         struct sockaddr_in local;
  50.         memset(&local, 0, sizeof(local));
  51.         local.sin_family = AF_INET;
  52.         // 转化为网络序列
  53.         local.sin_port = htons(_port);
  54.         // 字符串转化为点时分形式的ip
  55.         inet_aton(_ip.c_str(), &(local.sin_addr));
  56.         //此时我们仅仅只在用户栈填好了,并没有写进到打开的网络文件和套接字中,没有设置系统中
  57.         int n = bind(_listensocket, (const struct sockaddr*)&local, sizeof(local));
  58.         if(n < 0)
  59.         {
  60.             lg(Fatal, "bind error, errno : %d, errstring: %s", errno, strerror(errno));
  61.             exit(BindError);
  62.         }
  63.         lg(Info, "bind socket success, socket: %d", _listensocket);
  64.  
  65.  
  66.         // 3.设置监听状态
  67.         // Tcp是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
  68.         if (listen(_listensocket, backlog) < 0)
  69.         {
  70.             lg(Fatal, "listen error, errno: %d, errstring: %s", errno, strerror(errno));
  71.             exit(ListenError);
  72.         }   
  73.         lg(Info, "bind socket success, socket: %d", _listensocket);
  74.     }
  75.  
  76.     void Start()
  77.     {
  78.         lg(Info, "tcpServer is running....");
  79.         for (;;)
  80.         {
  81.             // 1. 获取新连接 - 知道客户端的ip地址和端口号
  82.             struct sockaddr_in client;
  83.             socklen_t len = sizeof(client);
  84.             // _sockfd的核心工作是: 从底层获取客户端的请求 - 餐厅门口的迎宾 
  85.             // sockdf的核心工作是: 处理会去来的客户请求 - 餐厅的服务员
  86.             int sockfd = accept(_listensocket, (struct sockaddr *)&client, &len);
  87.             if (sockfd < 0)
  88.             {
  89.                 // 从底层获取客户端的请求 - 餐厅门口的迎宾 - 路人不来吃饭 - 换一下批路人
  90.                 lg(Warning, "accept error, errno: %d, errstring: %s", errno, strerror(errno)); //?
  91.                 continue; // 所以这里使用continue
  92.             }
  93.             lg(Info, "get a new link..., sockfd: %d", sockfd);
  94.         }
  95.     }
  96.  
  97.     ~TcpServer()
  98.     {
  99.         close(_listensocket);
  100.     }
  101.  
  102. private:
  103.     int _listensocket; // 套接字
  104.     uint16_t _port; // 端口号
  105.     string _ip; // ip地址
  106. };

此时我们想来测试一下，但是我们的客户端还没有写，咋办呢？

telnet 127.0.0.1 8888

是一个网络诊断命令，它的作用是尝试通过Telnet协议连接到本地主机（本机）的8888端口。这里：

  • telnet 是命令本身，用于进行远程登录和管理。
  • 127.0.0.1 是IPv4环回地址，指向本地计算机。使用这个地址，你实际上是尝试连接到你自己的机器。
  • 8888 是端口号，许多应用程序和服务会监听特定的端口来接收数据。8888是一个常见的测试或备用端口。

上一个知识点我们提到udp它是不能绑定我们云服务器的公网ip的，但是绑定本地环回127.0.0.1可以的，我们看看tcp可不可以。

答案是也不可以绑定我们云服务器的公网ip的。那么绑定本地环回127.0.0.1可以嘛？

所以为了能连接我们的与服务器的公网ip，我们将服务器的ip设置为0.0.0.0，这就意味着该tcp服务器可以读取服务器任何一个ip，保证一定能连接上我们的服务器。

2.进行通信

建立通信我们首先就要获取到给服务器发送请求的端口号和ip地址

我们来测试一下，看看此时能不能接收到客户端的端口号和ip地址。

此时我们就能知道我们确实有连接到我们的服务器了。

⭐注意：我们使用的云服务默认是将端口号禁用了，我们需要在云服务器后台将我们的端口号取消禁用，否则的话我们只能在本地通信，我们可以使用windows连接一下服务器，看看出现上面情况。

所以就需要前往服务器进行安全组的设置。

随后我们再来测试一下哈。

同时我们这里还有一个问题，我们之前的端口号和网络序列都要转成网络序列，我们都使用了相应的接口，但是为什么用户发送来的数据，我们不需要手动调用接口转化为网络序列呢？在使用套接字通信的时候，会默认将用户发送来的数据转化成网络序列，而端口号和网络序列比较特殊，需要写给操作系统的，所以需要我们自己去转的。现在我们就可以进行通信了，由于tcp是基于数据流的，所以直接使用write和read接口即可。

  1. void Service( int sockfd,const string& ip,const uint16_t& port)
  2. {
  3.     char buffer[4096];
  4.     while(true)
  5.     {
  6.         // 读取用户发送的请求
  7.         ssize_t n = read(sockfd, buffer, sizeof(buffer));
  8.         if(n > 0)
  9.         {
  10.             buffer[n] = '\0';
  11.             cout << "client says: " << buffer << endl;
  12.             string echo_string = "tcpserver echo# ";
  13.             echo_string += buffer;
  14.  
  15.             write(sockfd, echo_string.c_str(), echo_string.size());
  16.         }
  17.         
  18.     }
  19. }

我们来运行一下：

此时我们发现就可以通信啦！！！但是上面的客户端不是我们写的，我们自己来写一个。

三、客户端的初始化

1.创建套接字

  1. int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  2. if(sockfd < 0)
  3. {
  4.     cerr << "socket error" << endl;
  5. }

2.绑定端口号和ip

由于客户端不需要固定的端口号,因此不必调用bind(),客户端的端口号由内核自动分配

注意:

  • 客户端不是不允许调用bind(), 只是没有必要调用bind()固定一个端口号. 否则如果在同一台机器上启动 多个客户端, 就会出现端口号被占用导致不能正确建立连接;
  • 服务器也不是必须调用bind(), 但如果服务器不调用bind(), 内核会自动给服务器分配监听端口, 每次启动 服务器时端口号都不一样, 客户端要连接服务器就会遇到麻烦;

测试多个连接的情况

再启动一个客户端, 尝试连接服务器, 发现第二个客户端, 不能正确的和服务器进行通信. 分析原因, 是因为我们accecpt了一个请求之后, 就在一直while循环尝试read, 没有继续调用到accecpt, 导致不能接 受新的请求. 我们当前的这个TCP, 只能处理一个连接, 这是不科学的.后面我们会改成多线程版本的。

3.连接服务器

connect：

  • 客户端需要调用connect()连接服务器;
  • connect和bind的参数形式一致, 区别在于bind的参数是自己的地址, 而connect的参数是对方的地址;
  • connect()成功返回0,出错返回-1;
  1. #include <iostream>
  2. #include <arpa/inet.h>
  3. #include <netinet/in.h>
  4. #include <sys/types.h>
  5. #include <sys/socket.h>
  6. #include <unistd.h>
  7. #include <string.h>
  8.  
  9. using namespace std;
  10. void Usage(const string &proc)
  11. {
  12.     cout << "\n\rUsage: " << proc << " serverip serverport\n"
  13.          << endl;
  14. }
  15.  
  16. // ./tcpclient serverip serverport
  17. int main(int argc, char *argv[])
  18. {
  19.     if (argc != 3)
  20.     {
  21.         Usage(argv[0]);
  22.         exit(1);
  23.     }
  24.     string serverip = argv[1];
  25.     uint16_t serverport = stoi(argv[2]);
  26.  
  27.     int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  28.     if (sockfd < 0)
  29.     {
  30.         cerr << "socket error" << endl;
  31.     }
  32.  
  33.     // 客户端也需要有ip和端口号,这样服务器才能找到用户,返回用户的请求
  34.     // tcp客户端要不要bind?一定要显示绑定只不过不需要用户显示的bind！一般有OS自由随机选择！
  35.     // 一个端口号只能被一个进程bind，对server是如此，对于client，也是如此！
  36.     // 如果用户自行绑定,有可能绑定同一个端口号,导致应用无法运行
  37.     // 其实client的port是多少，其实不重要，只要能保证主机上的唯一性就可以！
  38.     // 未来是用户给服务器,一旦绑定,用户的端口号是先发给服务端,此时服务器就知道是谁了!
  39.     // 但是server的port需要唯一确定,用户要访问服务器,随机变化导致第一天还可以,后面无法运行
  40.     // 系统什么时候给我bind呢？首次发送connect的时候,进行自动随机绑定
  41.  
  42.     // 可是客户端此时不知道服务器的ip和端口号
  43.     // 使用命令行参数来解决
  44.     struct sockaddr_in server;
  45.     memset(&server, 0, sizeof(server));
  46.     server.sin_family = AF_INET;
  47.     server.sin_port = htons(serverport);
  48.     inet_pton(AF_INET, serverip.c_str(), &(server.sin_addr));
  49.     
  50.     int n = connect(sockfd, (const struct sockaddr*)&server, sizeof(server));
  51.     if(n < 0)
  52.     {
  53.         cerr << "connect error..." << endl;
  54.         exit(2);
  55.     }
  56.     close(sockfd);
  57.     return 0;
  58. }

4.给服务端发送信息

  1. string message;
  2. while (true)
  3. {
  4.     cout << "Please Enter# ";
  5.     getline(cin, message);
  6.     // 发送数据
  7.     int n = write(sockfd, message.c_str(), message.size());
  8.     // 读取数据
  9.     char inbuffer[4096];
  10.     n = read(sockfd, inbuffer, sizeof(inbuffer));
  11.     if (n > 0)
  12.     {
  13.         inbuffer[n] = 0;
  14.         std::cout << inbuffer << std::endl;
  15.     }
  16. }

此时我们的服务器和客户端就可以运行啦！

四、一些安全问题的处理

1.客户端直接退出，服务器处理

客户端直接退出，服务器会怎么样，服务器读取不到客户端发来的请求，此时read返回值为0，应该关闭网络文件描述符，剩余一种情况就是读取失败，我们直接打印警告日志信息。

  1. void Service( int sockfd,const string& ip,const uint16_t& port)
  2. {
  3.     char buffer[4096];
  4.     while(true)
  5.     {
  6.         // 读取用户发送的请求
  7.         ssize_t n = read(sockfd, buffer, sizeof(buffer));
  8.         if(n > 0)
  9.         {
  10.             buffer[n] = '\0';
  11.             cout << "client says: " << buffer << endl;
  12.             string echo_string = "tcpserver echo# ";
  13.             echo_string += buffer;
  14.  
  15.             write(sockfd, echo_string.c_str(), echo_string.size());
  16.         }
  17.         else if(n == 0)
  18.         {
  19.             // 此时需要关闭文件描述符
  20.             // 我们在返回调用该函数的地方该关闭文件描述符
  21.             lg(Info, "%s:%d quit, server close sockfd: %d", ip.c_str(), port, sockfd);
  22.             break;
  23.         }
  24.         else
  25.         {
  26.             lg(Warning, "read error, errno : %d, errstring: %s", errno, strerror(errno));
  27.             break;
  28.         }
  29.     }
  30. }

运行一下：

2.单进程服务器，多个客户端连接

我们直接来看现象

然后我们让客户端分别写一条数据

我们发现此时客户端1能成功发送数据并接收数据，但是客户端2不行，随后我们来关闭客户端1.

此时客户端1一退出，客户端2立马连接，并且将刚刚的数据发送给服务器并成功并接收数据。为什么呢？因为此时我们的服务器是一个单进程，一个服务器为一个客户端提供服务时，此时由于我们写的是while循环，此时必须等客户端1退出，才能关闭文件描述符(让)，然后这个服务器才会空闲，然后此时客户端2才能建立连接，服务器才会提供服务。此时就相当于餐厅只有一个服务员，等这个服务员服务好了客户端1，才能接待客户端2，所以我们这里需要改一下，让多个客户端共同使用。

  1. void Start()
  2. {
  3.     lg(Info, "tcpServer is running....");
  4.     for (;;)
  5.     {
  6.         // 1. 获取新连接 - 知道客户端的ip地址和端口号
  7.         struct sockaddr_in client;
  8.         socklen_t len = sizeof(client);
  9.         // _sockfd的核心工作是: 从底层获取客户端的请求 - 餐厅门口的迎宾 
  10.         // sockdf的核心工作是: 处理会去来的客户请求 - 餐厅的服务员
  11.         int sockfd = accept(_listensocket, (struct sockaddr *)&client, &len);
  12.         if (sockfd < 0)
  13.         {
  14.             // 从底层获取客户端的请求 - 餐厅门口的迎宾 - 路人不来吃饭 - 换一下批路人
  15.             lg(Warning, "accept error, errno: %d, errstring: %s", errno, strerror(errno)); //?
  16.             continue; // 所以这里使用continue
  17.         }
  18.         lg(Info, "get a new link..., sockfd: %d", sockfd);
  19.  
  20.         // 2.根据新连接来进行通信
  21.         // 获取客户端的ip地址和端口号
  22.         uint16_t clientport = ntohs(client.sin_port);
  23.         char clientip[32];
  24.         // 转化成主机序列
  25.         inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));
  26.         cout << "clientport: " << clientport << ", clientip: " << clientip << endl;
  27.         // 单进程版本
  28.         // Service(sockfd, clientip, clientport);
  29.         // close(sockfd);
  30.  
  31.         // 多进程版本
  32.         pid_t id = fork();
  33.         if(id == 0)
  34.         {
  35.             // 子进程
  36.             // 子进程会继承父进程的文件描述符
  37.             close(_listensocket);
  38.             if(fork() > 0) exit(0); // 此时子进程退出了
  39.             Service(sockfd, clientip, clientport); // 孙子进程执行
  40.             // 对于孙子进程,它的父进程已经退出了,此时孙子进程被系统领养
  41.             close(sockfd);
  42.             exit(0);
  43.         }
  44.         // 父进程
  45.         // 文件描述符使用的是引用计数
  46.         // 关闭父进程的文件描述符不会影响子进程
  47.         close(sockfd);
  48.         // 这里等待回收子进程的方式不能是阻塞等待
  49.         pid_t rid = waitpid(id, nullptr, 0);
  50.     }
  51. }

此时我们再来测试一下：

此时我们无论来多少个客户端，我们的服务器都能解决！！！除了上面一种方法，我们还可以使用信号的方式，注意使用这个需要带上头文件<signal.h>

signal(SIGVHLD, SIG_IGN);

如果我们此时来了一大批客户，那么此时就会为每一个客户创建一个进程，而我们之前学过，创建子进程的成本是非常大的，所以此时我们可以使用多线程来解决。

  1. #pragma onec
  2.  
  3. #include <iostream>
  4. #include <sys/types.h>
  5. #include <sys/socket.h>
  6. #include <unistd.h>
  7. #include <cstdlib>
  8. #include <cstring>
  9. #include <arpa/inet.h>
  10. #include <netinet/in.h>
  11. #include <sys/wait.h>
  12. #include <pthread.h>
  13. #include "log.hpp"
  14. using namespace std;
  15.  
  16. const int defaultsockfd = -1;
  17. const string defaultip = "0.0.0.0";
  18. const int backlog = 10; // 但是一般不要设置的太大
  19. Log lg;
  20.  
  21. enum
  22. {
  23.     UsageError = 1,
  24.     SocketError = 2,
  25.     BindError = 3,
  26.     ListenError = 4
  27. };
  28.  
  29. class TcpServer;
  30.  
  31. class ThreadData
  32. {
  33. public:
  34.     ThreadData(int fd, const std::string &ip, const uint16_t &p, TcpServer *t)
  35.     : sockfd(fd)
  36.     , clientip(ip)
  37.     , clientport(p)
  38.     , tsvr(t)
  39.     {}
  40. public:
  41.     int sockfd;
  42.     string clientip;
  43.     uint16_t clientport;
  44.     TcpServer *tsvr;
  45. };
  46.  
  47.  
  48. class TcpServer
  49. {
  50. public:
  51.     TcpServer(const uint16_t &port, const string &ip = defaultip)
  52.         : _listensocket(defaultsockfd), _port(port), _ip(ip)
  53.     {
  54.     }
  55.     void Init()
  56.     {
  57.         // 1.创建套接字
  58.         _listensocket = socket(AF_INET, SOCK_STREAM, 0);
  59.         if (_listensocket < 0) // 创建套接字失败
  60.         {
  61.             lg(Fatal, "create socket error, errno : %d, errstring: %s", errno, strerror(errno));
  62.             exit(SocketError);
  63.         }
  64.         lg(Info, "create socket success, listensocket: %d", _listensocket);
  65.  
  66.         // 2.绑定端口号
  67.         //  使用这个结构体需要包头文件
  68.         struct sockaddr_in local;
  69.         memset(&local, 0, sizeof(local));
  70.         local.sin_family = AF_INET;
  71.         // 转化为网络序列
  72.         local.sin_port = htons(_port);
  73.         // 字符串转化为点时分形式的ip
  74.         inet_aton(_ip.c_str(), &(local.sin_addr));
  75.         // local.sin_addr.s_addr = INADDR_ANY;
  76.         // 此时我们仅仅只在用户栈填好了,并没有写进到打开的网络文件和套接字中,没有设置系统中
  77.         int n = bind(_listensocket, (const struct sockaddr *)&local, sizeof(local));
  78.         if (n < 0)
  79.         {
  80.             lg(Fatal, "bind error, errno : %d, errstring: %s", errno, strerror(errno));
  81.             exit(BindError);
  82.         }
  83.         lg(Info, "bind socket success, listensocket: %d", _listensocket);
  84.  
  85.         // 3.设置监听状态
  86.         // Tcp是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
  87.         if (listen(_listensocket, backlog) < 0)
  88.         {
  89.             lg(Fatal, "listen error, errno: %d, errstring: %s", errno, strerror(errno));
  90.             exit(ListenError);
  91.         }
  92.         lg(Info, "bind socket success, listensocket: %d", _listensocket);
  93.     }
  94.  
  95.     void Start()
  96.     {
  97.         lg(Info, "tcpServer is running....");
  98.         for (;;)
  99.         {
  100.             // 1. 获取新连接 - 知道客户端的ip地址和端口号
  101.             struct sockaddr_in client;
  102.             socklen_t len = sizeof(client);
  103.             // _sockfd的核心工作是: 从底层获取客户端的请求 - 餐厅门口的迎宾
  104.             // sockdf的核心工作是: 处理会去来的客户请求 - 餐厅的服务员
  105.             int sockfd = accept(_listensocket, (struct sockaddr *)&client, &len);
  106.             if (sockfd < 0)
  107.             {
  108.                 // 从底层获取客户端的请求 - 餐厅门口的迎宾 - 路人不来吃饭 - 换一下批路人
  109.                 lg(Warning, "accept error, errno: %d, errstring: %s", errno, strerror(errno)); //?
  110.                 continue;                                                                      // 所以这里使用continue
  111.             }
  112.             lg(Info, "get a new link..., sockfd: %d", sockfd);
  113.  
  114.             // 2.根据新连接来进行通信
  115.             // 获取客户端的ip地址和端口号
  116.             uint16_t clientport = ntohs(client.sin_port);
  117.             char clientip[32];
  118.             // 转化成主机序列
  119.             inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));
  120.             cout << "clientport: " << clientport << ", clientip: " << clientip << endl;
  121.             // 单进程版本
  122.             // Service(sockfd, clientip, clientport);
  123.             // close(sockfd);
  124.  
  125.             // 多进程版本
  126.             // pid_t id = fork();
  127.             // if(id == 0)
  128.             //{
  129.                 // 子进程
  130.                 // 子进程会继承父进程的文件描述符
  131.                 // close(_listensocket);
  132.                 // if(fork() > 0) exit(0); // 此时子进程退出了
  133.                 // Service(sockfd, clientip, clientport); // 孙子进程执行
  134.                 // 对于孙子进程,它的父进程已经退出了,此时孙子进程被系统领养
  135.                 // close(sockfd);
  136.                 // exit(0);
  137.             //}
  138.             // 父进程
  139.             // 文件描述符使用的是引用计数
  140.             // 关闭父进程的文件描述符不会影响子进程
  141.             // close(sockfd);
  142.             // 这里等待回收子进程的方式不能是阻塞等待
  143.             // pid_t rid = waitpid(id, nullptr, 0);
  144.  
  145.             // 多线程版本
  146.             ThreadData* td = new ThreadData(sockfd, clientip, clientport, this);
  147.             pthread_t tid;
  148.             pthread_create(&tid, nullptr, Rountine, td);
  149.  
  150.             // 这里不用join,因为它是阻塞等待
  151.             // pthread_join(tid, nullptr);
  152.  
  153.         }
  154.     }
  155.  
  156.     static void* Rountine(void* args)
  157.     {
  158.         pthread_detach(pthread_self()); // 设置分离状态
  159.         // 文件描述符共享,此时我们就不能关闭
  160.         // 多线程只拥有tcb
  161.         ThreadData *td = static_cast<ThreadData *>(args);
  162.         // static静态成员方法无法使用非静态成员方法和成员
  163.         // 1.将Service放到TcpServer类外
  164.         // 2.将当前对象的this指针传入
  165.         td->tsvr->Service(td->sockfd, td->clientip, td->clientport);
  166.         delete td;
  167.         return nullptr;
  168.     }
  169.  
  170.     void Service(int sockfd, const string &ip, const uint16_t &port)
  171.     {
  172.         char buffer[4096];
  173.         while (true)
  174.         {
  175.             // 读取用户发送的请求
  176.             ssize_t n = read(sockfd, buffer, sizeof(buffer));
  177.             if (n > 0)
  178.             {
  179.                 buffer[n] = '\0';
  180.                 cout << "client says: " << buffer << endl;
  181.                 string echo_string = "tcpserver echo# ";
  182.                 echo_string += buffer;
  183.  
  184.                 write(sockfd, echo_string.c_str(), echo_string.size());
  185.             }
  186.             else if (n == 0)
  187.             {
  188.                 // 此时需要关闭文件描述符
  189.                 lg(Info, "%s:%d quit, server close sockfd: %d", ip.c_str(), port, sockfd);
  190.                 break;
  191.             }
  192.             else
  193.             {
  194.                 lg(Warning, "read error, errno : %d, errstring: %s", errno, strerror(errno));
  195.                 break;
  196.             }
  197.         }
  198.     }
  199.     ~TcpServer()
  200.     {
  201.         close(_listensocket);
  202.     }
  203.  
  204. private:
  205.     int _listensocket; // 套接字
  206.     uint16_t _port;    // 端口号
  207.     string _ip;        // ip地址
  208. };

此时我们再来运行一下：

此时我们是每次来一个客户端，然后就创建一个线程，也有点消耗，毕竟俺们每次都要创建，我们来写一个线程池，一开始我们就创建一大批进程，来一个客户端直接给它一个线程。并且我们上面的代码还存在一个问题，我们的服务是一直服务用户请求的，只要客户端不退，即使客户端不发信息，我们为该用户创建的线程也不会销毁，这样就会导致系统中的线程越来越多，直接来写代码。

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <vector>
  5. #include <string>
  6. #include <queue>
  7. #include <pthread.h>
  8. #include <unistd.h>
  9.  
  10. struct ThreadInfo
  11. {
  12.     pthread_t tid;
  13.     std::string name;
  14. };
  15.  
  16. static const int defalutnum = 10;
  17.  
  18. template <class T>
  19. class ThreadPool
  20. {
  21. public:
  22.     void Lock()
  23.     {
  24.         pthread_mutex_lock(&mutex_);
  25.     }
  26.     void Unlock()
  27.     {
  28.         pthread_mutex_unlock(&mutex_);
  29.     }
  30.     void Wakeup()
  31.     {
  32.         pthread_cond_signal(&cond_);
  33.     }
  34.     void ThreadSleep()
  35.     {
  36.         pthread_cond_wait(&cond_, &mutex_);
  37.     }
  38.     bool IsQueueEmpty()
  39.     {
  40.         return tasks_.empty();
  41.     }
  42.     std::string GetThreadName(pthread_t tid)
  43.     {
  44.         for (const auto &ti : threads_)
  45.         {
  46.             if (ti.tid == tid)
  47.                 return ti.name;
  48.         }
  49.         return "None";
  50.     }
  51.  
  52. public:
  53.     static void *HandlerTask(void *args)
  54.     {
  55.         ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(args);
  56.         std::string name = tp->GetThreadName(pthread_self());
  57.         while (true)
  58.         {
  59.             tp->Lock();
  60.  
  61.             while (tp->IsQueueEmpty())
  62.             {
  63.                 tp->ThreadSleep();
  64.             }
  65.             T t = tp->Pop();
  66.             tp->Unlock();
  67.  
  68.             t();
  69.         }
  70.     }
  71.     void Start()
  72.     {
  73.         int num = threads_.size();
  74.         for (int i = 0; i < num; i++)
  75.         {
  76.             threads_[i].name = "thread-" + std::to_string(i + 1);
  77.             pthread_create(&(threads_[i].tid), nullptr, HandlerTask, this);
  78.         }
  79.     }
  80.     T Pop()
  81.     {
  82.         T t = tasks_.front();
  83.         tasks_.pop();
  84.         return t;
  85.     }
  86.     void Push(const T &t)
  87.     {
  88.         Lock();
  89.         tasks_.push(t);
  90.         Wakeup();
  91.         Unlock();
  92.     }
  93.     static ThreadPool<T> *GetInstance()
  94.     {
  95.         if (nullptr == tp_) // ???
  96.         {
  97.             pthread_mutex_lock(&lock_);
  98.             if (nullptr == tp_)
  99.             {
  100.                 std::cout << "log: singleton create done first!" << std::endl;
  101.                 tp_ = new ThreadPool<T>();
  102.             }
  103.             pthread_mutex_unlock(&lock_);
  104.         }
  105.  
  106.         return tp_;
  107.     }
  108.  
  109. private:
  110.     ThreadPool(int num = defalutnum) : threads_(num)
  111.     {
  112.         pthread_mutex_init(&mutex_, nullptr);
  113.         pthread_cond_init(&cond_, nullptr);
  114.     }
  115.     ~ThreadPool()
  116.     {
  117.         pthread_mutex_destroy(&mutex_);
  118.         pthread_cond_destroy(&cond_);
  119.     }
  120.     ThreadPool(const ThreadPool<T> &) = delete;
  121.     const ThreadPool<T> &operator=(const ThreadPool<T> &) = delete; // a=b=c
  122. private:
  123.     std::vector<ThreadInfo> threads_;
  124.     std::queue<T> tasks_;
  125.  
  126.     pthread_mutex_t mutex_;
  127.     pthread_cond_t cond_;
  128.  
  129.     static ThreadPool<T> *tp_;
  130.     static pthread_mutex_t lock_;
  131. };
  132.  
  133. template <class T>
  134. ThreadPool<T> *ThreadPool<T>::tp_ = nullptr;
  135.  
  136. template <class T>
  137. pthread_mutex_t ThreadPool<T>::lock_ = PTHREAD_MUTEX_INITIALIZER;

我们上面实现的线程池是一个单例模式，只允许创建一个对象，并且我们的线程池可以发送任务，它可以处理好，所以我们可以把服务器接收到的任务给我们的线程池，所以我们再来写一个任务。

  1. #pragma once
  2. #include <iostream>
  3. #include <string>
  4. #include "log.hpp"
  5. #include <string.h>
  6.  
  7. extern Log lg;
  8. using namespace std;
  9.  
  10. class Task
  11. {
  12. public:
  13.     Task(int sockfd, const std::string &clientip, const uint16_t &clientport)
  14.         : sockfd_(sockfd), clientip_(clientip), clientport_(clientport)
  15.     {
  16.     }
  17.     void run()
  18.     {
  19.         char buffer[4096];
  20.  
  21.         // 读取用户发送的请求
  22.         ssize_t n = read(sockfd_, buffer, sizeof(buffer));
  23.         if (n > 0)
  24.         {
  25.             buffer[n] = '\0';
  26.             cout << "client says: " << buffer << endl;
  27.             string echo_string = "tcpserver echo# ";
  28.             echo_string += buffer;
  29.  
  30.             write(sockfd_, echo_string.c_str(), echo_string.size());
  31.         }
  32.         else if (n == 0)
  33.         {
  34.             // 此时需要关闭文件描述符
  35.             lg(Info, "%s:%d quit, server close sockfd: %d", clientip_.c_str(), clientport_, sockfd_);
  36.         }
  37.         else
  38.         {
  39.             lg(Warning, "read error, errno : %d, errstring: %s", errno, strerror(errno));
  40.         }
  41.         close(sockfd_);
  42.     }
  43.     void operator()()
  44.     {
  45.         run();
  46.     }
  47.     ~Task()
  48.     {
  49.     }
  50.  
  51. private:
  52.     int sockfd_;
  53.     std::string clientip_;
  54.     uint16_t clientport_;
  55. };

此时对于客户端，我们让它输入一次信息就不要再输入了，你要是再输入就需要重新连接服务器。

  1. #include <iostream>
  2. #include <arpa/inet.h>
  3. #include <netinet/in.h>
  4. #include <sys/types.h>
  5. #include <sys/socket.h>
  6. #include <unistd.h>
  7. #include <string.h>
  8.  
  9. using namespace std;
  10. void Usage(const string &proc)
  11. {
  12.     cout << "\n\rUsage: " << proc << " serverip serverport\n"
  13.          << endl;
  14. }
  15.  
  16. // ./tcpclient serverip serverport
  17. int main(int argc, char *argv[])
  18. {
  19.     if (argc != 3)
  20.     {
  21.         Usage(argv[0]);
  22.         exit(1);
  23.     }
  24.     string serverip = argv[1];
  25.     uint16_t serverport = stoi(argv[2]);
  26.  
  27.     int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  28.     if (sockfd < 0)
  29.     {
  30.         cerr << "socket error" << endl;
  31.     }
  32.  
  33.     // 客户端也需要有ip和端口号,这样服务器才能找到用户,返回用户的请求
  34.     // tcp客户端要不要bind?一定要显示绑定只不过不需要用户显示的bind！一般有OS自由随机选择！
  35.     // 一个端口号只能被一个进程bind，对server是如此，对于client，也是如此！
  36.     // 如果用户自行绑定,有可能绑定同一个端口号,导致应用无法运行
  37.     // 其实client的port是多少，其实不重要，只要能保证主机上的唯一性就可以！
  38.     // 未来是用户给服务器,一旦绑定,用户的端口号是先发给服务端,此时服务器就知道是谁了!
  39.     // 但是server的port需要唯一确定,用户要访问服务器,随机变化导致第一天还可以,后面无法运行
  40.     // 系统什么时候给我bind呢？首次发送connect的时候,进行自动随机绑定
  41.  
  42.     // 可是客户端此时不知道服务器的ip和端口号
  43.     // 使用命令行参数来解决
  44.     struct sockaddr_in server;
  45.     memset(&server, 0, sizeof(server));
  46.     server.sin_family = AF_INET;
  47.     server.sin_port = htons(serverport);
  48.     inet_pton(AF_INET, serverip.c_str(), &(server.sin_addr));
  49.  
  50.     int n = connect(sockfd, (const struct sockaddr *)&server, sizeof(server));
  51.     if (n < 0)
  52.     {
  53.         cerr << "connect error..." << endl;
  54.         exit(2);
  55.     }
  56.  
  57.     string message;
  58.     
  59.     
  60.         cout << "Please Enter# ";
  61.         getline(cin, message);
  62.         // 发送数据
  63.         n = write(sockfd, message.c_str(), message.size());
  64.         // 读取数据
  65.         char inbuffer[4096];
  66.         n = read(sockfd, inbuffer, sizeof(inbuffer));
  67.         if (n > 0)
  68.         {
  69.             inbuffer[n] = 0;
  70.             std::cout << inbuffer << std::endl;
  71.         }
  72.     
  73.  
  74.     close(sockfd);
  75.     return 0;
  76. }

此时我们就不需要再创建线程了，并且用户发一次信息，服务处理完该线程就退了，用户如果还有就需要重新连接服务器。

3.服务端写入失败，写入需要判断

此时我们再来看看结果：

此时就符合我们的预期结果啦！

4.服务器未写，sockfd链接断开

当我们的服务器已经读到数据的时候，但是此时文件描述符的链接一键断开，此时再向这个失效的文件描述符写那么程序就会出问题，这个就相当于之前的管道，如果读端关掉，那么写端继续写当前进行就会收到SIGPIPE信号，将进程终止掉，此时程序就会出现SIGPIPE信号，我们直接将其直接终止。

5.客户端多次链接，服务器提供多次服务

然后我们来测试一下：

这里我们再次链接的到时候为什么失败了呢？这是因为我们第一次发出请求的时候，服务器处理完了之后就将文件描述符关掉了，而链接的时候使用的文件描述符已经被关了，此时会链接失败，所以要想再次链接，就必须要再次创建套接字。

此时就解决问题啦！

6.客户端未发送，服务器断开

当客户端向服务器写的时候，此时服务器断开了，此时我们希望能够重新连接服务器，如果重连5次还没有连接上，用户也离线。

  1. #include <iostream>
  2. #include <arpa/inet.h>
  3. #include <netinet/in.h>
  4. #include <sys/types.h>
  5. #include <sys/socket.h>
  6. #include <unistd.h>
  7. #include <string.h>
  8.  
  9. using namespace std;
  10. void Usage(const string &proc)
  11. {
  12.     cout << "\n\rUsage: " << proc << " serverip serverport\n"
  13.          << endl;
  14. }
  15.  
  16. // ./tcpclient serverip serverport
  17. int main(int argc, char *argv[])
  18. {
  19.     if (argc != 3)
  20.     {
  21.         Usage(argv[0]);
  22.         exit(1);
  23.     }
  24.     string serverip = argv[1];
  25.     uint16_t serverport = stoi(argv[2]);
  26.  
  27.     // 客户端也需要有ip和端口号,这样服务器才能找到用户,返回用户的请求
  28.     // tcp客户端要不要bind?一定要显示绑定只不过不需要用户显示的bind！一般有OS自由随机选择！
  29.     // 一个端口号只能被一个进程bind，对server是如此，对于client，也是如此！
  30.     // 如果用户自行绑定,有可能绑定同一个端口号,导致应用无法运行
  31.     // 其实client的port是多少，其实不重要，只要能保证主机上的唯一性就可以！
  32.     // 未来是用户给服务器,一旦绑定,用户的端口号是先发给服务端,此时服务器就知道是谁了!
  33.     // 但是server的port需要唯一确定,用户要访问服务器,随机变化导致第一天还可以,后面无法运行
  34.     // 系统什么时候给我bind呢？首次发送connect的时候,进行自动随机绑定
  35.  
  36.     // 可是客户端此时不知道服务器的ip和端口号
  37.     // 使用命令行参数来解决
  38.     struct sockaddr_in server;
  39.     memset(&server, 0, sizeof(server));
  40.     server.sin_family = AF_INET;
  41.     server.sin_port = htons(serverport);
  42.     inet_pton(AF_INET, serverip.c_str(), &(server.sin_addr));
  43.  
  44.     while (true)
  45.     {
  46.         int cnt = 5; // 重连的次数
  47.         bool isreconnect = false;
  48.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  49.         if (sockfd < 0)
  50.         {
  51.             cerr << "socket error" << endl;
  52.         }
  53.         do
  54.         {
  55.             int n = connect(sockfd, (const struct sockaddr *)&server, sizeof(server));
  56.             if (n < 0)
  57.             {
  58.                 isreconnect = true;
  59.                 cnt--;
  60.                 std::cerr << "connect error..., reconnect: " << cnt << std::endl;
  61.                 close(sockfd);
  62.                 sleep(2);
  63.             }
  64.             else
  65.             {
  66.                 break;
  67.             }
  68.         } while (cnt && isreconnect);
  69.         if (cnt == 0)
  70.         {
  71.             std::cerr << "user offline..." << std::endl;
  72.             break;
  73.         }
  74.  
  75.         string message;
  76.  
  77.         cout << "Please Enter# ";
  78.         getline(cin, message);
  79.         // 发送数据
  80.         n = write(sockfd, message.c_str(), message.size());
  81.         if (n < 0)
  82.         {
  83.             isreconnect = true;
  84.             std::cerr << "write error..." << std::endl;
  85.             continue;
  86.         }
  87.         // 读取数据
  88.         char inbuffer[4096];
  89.         n = read(sockfd, inbuffer, sizeof(inbuffer));
  90.         if (n > 0)
  91.         {
  92.             inbuffer[n] = 0;
  93.             std::cout << inbuffer << std::endl;
  94.         }
  95.         close(sockfd);
  96.     }
  97.  
  98.     return 0;
  99. }

运行结果：

上面这个情况就是我们打游戏的时候，我们的网断开了，就相当于连接不上服务器了，此时就会多次连接，如果连接了很多次都没有连接上，此时游戏也就会退出啦。

五、英译汉服务器

makefile

  1. .PHONY:all
  2. all:tcpserver tcpclient
  3. tcpserver:Main.cc
  4. 	g++ -o $@ $^ -std=c++11 -lpthread
  5. tcpclient:TcpClient.cc
  6. 	g++ -o $@ $^ -std=c++11 
  7.  
  8. .PHONY:clean
  9. clean:
  10. 	rm -f tcpserver tcpclient

dict.txt

  1. apple:苹果...
  2. banana:香蕉...
  3. red:红色...
  4. yellow:黄色...
  5. the: 这
  6. be: 是
  7. to: 朝向/给/对
  8. and: 和
  9. I: 我
  10. in: 在...里
  11. that: 那个
  12. have: 有
  13. will: 将
  14. for: 为了
  15. but: 但是
  16. as: 像...一样
  17. what: 什么
  18. so: 因此
  19. he: 他
  20. her: 她
  21. his: 他的
  22. they: 他们
  23. we: 我们
  24. their: 他们的
  25. his: 它的
  26. with: 和...一起
  27. she: 她
  28. he: 他（宾格）
  29. it: 它

Main.cc

  1. #include "TcpServer.hpp"
  2.  
  3. #include <memory>
  4.  
  5. void Usage(std::string proc)
  6. {
  7.     std::cout << "\n\rUsage: " << proc << " port[1024+]\n" << std::endl;
  8. }
  9.  
  10. // ./tcpserver 8080
  11. int main(int argc, char* argv[])
  12. {
  13.     if(argc != 2)
  14.     {
  15.         Usage(argv[0]);
  16.         exit(UsageError);
  17.     }
  18.     uint16_t port = std::stoi(argv[1]);
  19.     unique_ptr<TcpServer> tcpSvr(new TcpServer(port));
  20.     tcpSvr->Init();
  21.     tcpSvr->Start();
  22.     return 0;
  23. }

Task.hpp

  1. #pragma once
  2. #include <iostream>
  3. #include <string>
  4. #include "log.hpp"
  5. #include "Init.hpp"
  6. #include <string.h>
  7.  
  8. extern Log lg;
  9. Init init;
  10. using namespace std;
  11.  
  12. class Task
  13. {
  14. public:
  15.     Task(int sockfd, const std::string &clientip, const uint16_t &clientport)
  16.         : sockfd_(sockfd), clientip_(clientip), clientport_(clientport)
  17.     {
  18.     }
  19.     void run()
  20.     {
  21.         char buffer[4096];
  22.  
  23.         // 读取用户发送的请求
  24.         ssize_t n = read(sockfd_, buffer, sizeof(buffer));
  25.         if (n > 0)
  26.         {
  27.             buffer[n] = '\0';
  28.             cout << "client keys: " << buffer << endl;
  29.             string echo_string = init.translation(buffer);
  30.             int n = write(sockfd_, echo_string.c_str(), echo_string.size());
  31.             if(n < 0)
  32.             {
  33.                 lg(Warning, "write error, errno : %d, errstring: %s", errno, strerror(errno));
  34.             }
  35.         }
  36.         else if (n == 0)
  37.         {
  38.             // 此时需要关闭文件描述符
  39.             lg(Info, "%s:%d quit, server close sockfd: %d", clientip_.c_str(), clientport_, sockfd_);
  40.         }
  41.         else
  42.         {
  43.             lg(Warning, "read error, errno : %d, errstring: %s", errno, strerror(errno));
  44.         }
  45.         close(sockfd_);
  46.     }
  47.     void operator()()
  48.     {
  49.         run();
  50.     }
  51.     ~Task()
  52.     {
  53.     }
  54.  
  55. private:
  56.     int sockfd_;
  57.     std::string clientip_;
  58.     uint16_t clientport_;
  59. };

Init.pp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5. #include <fstream>
  6. #include <unordered_map>
  7. #include "log.hpp"
  8.  
  9. Log lg;
  10.  
  11. const std::string dictname = "./dict.txt";
  12. const std::string sep = ":";
  13.  
  14. static bool Split(std::string &s, std::string *part1, std::string *part2)
  15. {
  16.     auto pos = s.find(sep);
  17.     if (pos == std::string::npos)
  18.         return false;
  19.     *part1 = s.substr(0, pos);
  20.     *part2 = s.substr(pos + 1);
  21.     return true;
  22. }
  23.  
  24. class Init
  25. {
  26. public:
  27.     Init()
  28.     {
  29.         std::ifstream in(dictname); // 打开配置文件
  30.         if (!in.is_open())          // 打开配置文件失败
  31.         {
  32.             lg(Fatal, "ifstream open %s error", dictname.c_str());
  33.             exit(1);
  34.         }
  35.         std::string line;
  36.         while (std::getline(in, line))
  37.         {
  38.             std::string part1, part2;
  39.             Split(line, &part1, &part2);
  40.             dict.insert({part1, part2});
  41.         }
  42.         in.close();
  43.     }
  44.     std::string translation(const std::string &key)
  45.     {
  46.         auto iter = dict.find(key);
  47.         if (iter == dict.end())
  48.             return "Unknow";
  49.         else
  50.             return iter->second;
  51.     }
  52.  
  53. private:
  54.     std::unordered_map<std::string, std::string> dict;
  55. };

log.hpp

  1. #pragma once
  2. #include <iostream>
  3. #include <string>
  4. #include "log.hpp"
  5. #include "Init.hpp"
  6. #include <string.h>
  7.  
  8. extern Log lg;
  9. Init init;
  10. using namespace std;
  11.  
  12. class Task
  13. {
  14. public:
  15.     Task(int sockfd, const std::string &clientip, const uint16_t &clientport)
  16.         : sockfd_(sockfd), clientip_(clientip), clientport_(clientport)
  17.     {
  18.     }
  19.     void run()
  20.     {
  21.         char buffer[4096];
  22.  
  23.         // 读取用户发送的请求
  24.         ssize_t n = read(sockfd_, buffer, sizeof(buffer));
  25.         if (n > 0)
  26.         {
  27.             buffer[n] = '\0';
  28.             cout << "client keys: " << buffer << endl;
  29.             string echo_string = init.translation(buffer);
  30.             int n = write(sockfd_, echo_string.c_str(), echo_string.size());
  31.             if(n < 0)
  32.             {
  33.                 lg(Warning, "write error, errno : %d, errstring: %s", errno, strerror(errno));
  34.             }
  35.         }
  36.         else if (n == 0)
  37.         {
  38.             // 此时需要关闭文件描述符
  39.             lg(Info, "%s:%d quit, server close sockfd: %d", clientip_.c_str(), clientport_, sockfd_);
  40.         }
  41.         else
  42.         {
  43.             lg(Warning, "read error, errno : %d, errstring: %s", errno, strerror(errno));
  44.         }
  45.         close(sockfd_);
  46.     }
  47.     void operator()()
  48.     {
  49.         run();
  50.     }
  51.     ~Task()
  52.     {
  53.     }
  54.  
  55. private:
  56.     int sockfd_;
  57.     std::string clientip_;
  58.     uint16_t clientport_;
  59. };

TcpServer.hpp

  1. #pragma onec
  2.  
  3. #include <iostream>
  4. #include <sys/types.h>
  5. #include <sys/socket.h>
  6. #include <unistd.h>
  7. #include <cstdlib>
  8. #include <cstring>
  9. #include <arpa/inet.h>
  10. #include <netinet/in.h>
  11. #include <sys/wait.h>
  12. #include <signal.h>
  13. #include <pthread.h>
  14. #include "log.hpp"
  15. #include "ThreadPool.hpp"
  16. #include "Task.hpp"
  17. using namespace std;
  18.  
  19. const int defaultsockfd = -1;
  20. const string defaultip = "0.0.0.0";
  21. const int backlog = 10; // 但是一般不要设置的太大
  22. extern Log lg;
  23.  
  24. enum
  25. {
  26.     UsageError = 1,
  27.     SocketError = 2,
  28.     BindError = 3,
  29.     ListenError = 4
  30. };
  31.  
  32. class TcpServer;
  33.  
  34. class ThreadData
  35. {
  36. public:
  37.     ThreadData(int fd, const std::string &ip, const uint16_t &p, TcpServer *t)
  38.     : sockfd(fd)
  39.     , clientip(ip)
  40.     , clientport(p)
  41.     , tsvr(t)
  42.     {}
  43. public:
  44.     int sockfd;
  45.     string clientip;
  46.     uint16_t clientport;
  47.     TcpServer *tsvr;
  48. };
  49.  
  50.  
  51. class TcpServer
  52. {
  53. public:
  54.     TcpServer(const uint16_t &port, const string &ip = defaultip)
  55.         : _listensocket(defaultsockfd), _port(port), _ip(ip)
  56.     {
  57.     }
  58.     void Init()
  59.     {
  60.         // 1.创建套接字
  61.         _listensocket = socket(AF_INET, SOCK_STREAM, 0);
  62.         if (_listensocket < 0) // 创建套接字失败
  63.         {
  64.             lg(Fatal, "create socket error, errno : %d, errstring: %s", errno, strerror(errno));
  65.             exit(SocketError);
  66.         }
  67.         lg(Info, "create socket success, listensocket: %d", _listensocket);
  68.  
  69.         // 2.绑定端口号
  70.         //  使用这个结构体需要包头文件
  71.         struct sockaddr_in local;
  72.         memset(&local, 0, sizeof(local));
  73.         local.sin_family = AF_INET;
  74.         // 转化为网络序列
  75.         local.sin_port = htons(_port);
  76.         // 字符串转化为点时分形式的ip
  77.         inet_aton(_ip.c_str(), &(local.sin_addr));
  78.         // local.sin_addr.s_addr = INADDR_ANY;
  79.         // 此时我们仅仅只在用户栈填好了,并没有写进到打开的网络文件和套接字中,没有设置系统中
  80.         int n = bind(_listensocket, (const struct sockaddr *)&local, sizeof(local));
  81.         if (n < 0)
  82.         {
  83.             lg(Fatal, "bind error, errno : %d, errstring: %s", errno, strerror(errno));
  84.             exit(BindError);
  85.         }
  86.         lg(Info, "bind socket success, listensocket: %d", _listensocket);
  87.  
  88.         // 3.设置监听状态
  89.         // Tcp是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
  90.         if (listen(_listensocket, backlog) < 0)
  91.         {
  92.             lg(Fatal, "listen error, errno: %d, errstring: %s", errno, strerror(errno));
  93.             exit(ListenError);
  94.         }
  95.         lg(Info, "bind socket success, listensocket: %d", _listensocket);
  96.     }
  97.  
  98.     void Start()
  99.     {
  100.         signal(SIGPIPE, SIG_IGN);
  101.         ThreadPool<Task>::GetInstance()->Start();
  102.         lg(Info, "tcpServer is running....");
  103.         for (;;)
  104.         {
  105.             // 1. 获取新连接 - 知道客户端的ip地址和端口号
  106.             struct sockaddr_in client;
  107.             socklen_t len = sizeof(client);
  108.             // _sockfd的核心工作是: 从底层获取客户端的请求 - 餐厅门口的迎宾
  109.             // sockdf的核心工作是: 处理会去来的客户请求 - 餐厅的服务员
  110.             int sockfd = accept(_listensocket, (struct sockaddr *)&client, &len);
  111.             if (sockfd < 0)
  112.             {
  113.                 // 从底层获取客户端的请求 - 餐厅门口的迎宾 - 路人不来吃饭 - 换一下批路人
  114.                 lg(Warning, "accept error, errno: %d, errstring: %s", errno, strerror(errno)); //?
  115.                 continue;                                                                      // 所以这里使用continue
  116.             }
  117.             lg(Info, "get a new link..., sockfd: %d", sockfd);
  118.  
  119.             // 2.根据新连接来进行通信
  120.             // 获取客户端的ip地址和端口号
  121.             uint16_t clientport = ntohs(client.sin_port);
  122.             char clientip[32];
  123.             // 转化成主机序列
  124.             inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));
  125.             cout << "clientport: " << clientport << ", clientip: " << clientip << endl;
  126.             // 单进程版本
  127.             // Service(sockfd, clientip, clientport);
  128.             // close(sockfd);
  129.  
  130.             // 多进程版本
  131.             // pid_t id = fork();
  132.             // if(id == 0)
  133.             //{
  134.                 // 子进程
  135.                 // 子进程会继承父进程的文件描述符
  136.                 // close(_listensocket);
  137.                 // if(fork() > 0) exit(0); // 此时子进程退出了
  138.                 // Service(sockfd, clientip, clientport); // 孙子进程执行
  139.                 // 对于孙子进程,它的父进程已经退出了,此时孙子进程被系统领养
  140.                 // close(sockfd);
  141.                 // exit(0);
  142.             //}
  143.             // 父进程
  144.             // 文件描述符使用的是引用计数
  145.             // 关闭父进程的文件描述符不会影响子进程
  146.             // close(sockfd);
  147.             // 这里等待回收子进程的方式不能是阻塞等待
  148.             // pid_t rid = waitpid(id, nullptr, 0);
  149.  
  150.             // 多线程版本
  151.             // ThreadData* td = new ThreadData(sockfd, clientip, clientport, this);
  152.             // pthread_t tid;
  153.             // pthread_create(&tid, nullptr, Rountine, td);
  154.             // 这里不用join,因为它是阻塞等待
  155.             // pthread_join(tid, nullptr);
  156.  
  157.             // 线程池版本
  158.             Task t(sockfd, clientip, clientport);
  159.             // 单例模式
  160.             ThreadPool<Task>::GetInstance()->Push(t);
  161.         }
  162.     }
  163.  
  164.     //static void* Rountine(void* args)
  165.     //{
  166.        // pthread_detach(pthread_self()); // 设置分离状态
  167.         // 文件描述符共享,此时我们就不能关闭
  168.         // 多线程只拥有tcb
  169.         //ThreadData *td = static_cast<ThreadData *>(args);
  170.         // static静态成员方法无法使用非静态成员方法和成员
  171.         // 1.将Service放到TcpServer类外
  172.         // 2.将当前对象的this指针传入
  173.         //td->tsvr->Service(td->sockfd, td->clientip, td->clientport);
  174.         //delete td;
  175.         //return nullptr;
  176.     //}
  177.  
  178.     ~TcpServer()
  179.     {
  180.         close(_listensocket);
  181.     }
  182.  
  183. private:
  184.     int _listensocket; // 套接字
  185.     uint16_t _port;    // 端口号
  186.     string _ip;        // ip地址
  187. };

TcpClient.cc

  1. #include <iostream>
  2. #include <arpa/inet.h>
  3. #include <netinet/in.h>
  4. #include <sys/types.h>
  5. #include <sys/socket.h>
  6. #include <unistd.h>
  7. #include <string.h>
  8.  
  9. using namespace std;
  10. void Usage(const string &proc)
  11. {
  12.     cout << "\n\rUsage: " << proc << " serverip serverport\n"
  13.          << endl;
  14. }
  15.  
  16. // ./tcpclient serverip serverport
  17. int main(int argc, char *argv[])
  18. {
  19.     if (argc != 3)
  20.     {
  21.         Usage(argv[0]);
  22.         exit(1);
  23.     }
  24.     string serverip = argv[1];
  25.     uint16_t serverport = stoi(argv[2]);
  26.  
  27.     // 客户端也需要有ip和端口号,这样服务器才能找到用户,返回用户的请求
  28.     // tcp客户端要不要bind?一定要显示绑定只不过不需要用户显示的bind！一般有OS自由随机选择！
  29.     // 一个端口号只能被一个进程bind，对server是如此，对于client，也是如此！
  30.     // 如果用户自行绑定,有可能绑定同一个端口号,导致应用无法运行
  31.     // 其实client的port是多少，其实不重要，只要能保证主机上的唯一性就可以！
  32.     // 未来是用户给服务器,一旦绑定,用户的端口号是先发给服务端,此时服务器就知道是谁了!
  33.     // 但是server的port需要唯一确定,用户要访问服务器,随机变化导致第一天还可以,后面无法运行
  34.     // 系统什么时候给我bind呢？首次发送connect的时候,进行自动随机绑定
  35.  
  36.     // 可是客户端此时不知道服务器的ip和端口号
  37.     // 使用命令行参数来解决
  38.     struct sockaddr_in server;
  39.     memset(&server, 0, sizeof(server));
  40.     server.sin_family = AF_INET;
  41.     server.sin_port = htons(serverport);
  42.     inet_pton(AF_INET, serverip.c_str(), &(server.sin_addr));
  43.  
  44.     while (true)
  45.     {
  46.         int cnt = 5; // 重连的次数
  47.         bool isreconnect = false;
  48.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  49.         if (sockfd < 0)
  50.         {
  51.             cerr << "socket error" << endl;
  52.         }
  53.         do
  54.         {
  55.             int n = connect(sockfd, (struct sockaddr *)&server, sizeof(server));
  56.             if (n < 0)
  57.             {
  58.                 isreconnect = true;
  59.                 cnt--;
  60.                 std::cerr << "connect error..., reconnect: " << cnt << std::endl;
  61.                 sleep(2);
  62.             }
  63.             else
  64.             {
  65.                 break;
  66.             }
  67.         } while (cnt && isreconnect);
  68.         if (cnt == 0)
  69.         {
  70.             std::cerr << "user offline..." << std::endl;
  71.             break;
  72.         }
  73.  
  74.         string message;
  75.  
  76.         cout << "Please Enter# ";
  77.         getline(cin, message);
  78.         // 发送数据
  79.         int n = write(sockfd, message.c_str(), message.size());
  80.         if (n < 0)
  81.         {
  82.             isreconnect = true;
  83.             std::cerr << "write error..." << std::endl;
  84.             continue;
  85.         }
  86.         // 读取数据
  87.         char inbuffer[4096];
  88.         n = read(sockfd, inbuffer, sizeof(inbuffer));
  89.         if (n > 0)
  90.         {
  91.             inbuffer[n] = 0;
  92.             std::cout << inbuffer << std::endl;
  93.         }
  94.         close(sockfd);
  95.     }
  96.  
  97.     return 0;
  98. }

服务端：

客户端：

然后我们再来测试一下如果服务器断开了我们还能不能重新连上。

我们发现此时不能重现连接成功，这是因为我们的端口号不能重现启动，所以我们要在服务器端加两句代码。

  1. int opt = 1;
  2. setsockopt(_listensocket, SOL_SOCKET, SO_REUSEADDR|SO_REUSEPORT, &opt, sizeof(opt)); 
  3. // 防止偶发性的服务器无法进行立即重启(tcp协议的时候再说)

此时我们来看看运行结果：

六、前台和后台进程

可是万一有一天我们不小心将我们的xshell关掉了呢？此时服务器就断开了，我们想xshell关掉了服务器依然能跑，要做到这个，我们要理解前台进程和后台进程，先来测试一下它们的特点。

  1. #include <iostream>
  2. #include <string>
  3. #include <unistd.h>
  4.  
  5. int main()
  6. {
  7.     while(true)
  8.     {
  9.         std::cout << "hello ...." << std::endl;
  10.         sleep(1);
  11.     }
  12.     return 0;
  13. }

前台进程：

后台进程：

前台进程：

  1. 直接交互：前台进程直接与用户交互，意味着用户可以通过命令行与这些进程进行输入和输出操作。
  2. 终端阻塞：当一个进程在前台运行时，它通常会阻塞用户终端，直到该进程完成或被挂起。这意味着用户不能在同一终端启动其他需要交互的进程。
  3. 数量限制：在一个会话中，同时只能有一个进程组在前台运行，尽管这个进程组内可能包含多个进程。

后台进程：

  1. 非交互式运行：后台进程在后台运行，不直接与用户交互，即使用户没有主动与其互动，也能持续执行任务。
  2. 不阻塞终端：用户可以在后台进程运行的同时，在同一个终端上执行其他命令或启动其他进程，因为它不阻塞用户界面。
  3. 启动方式：可以通过在命令末尾添加符号&来将进程置于后台启动。

此时我们可以把进程运行的结果重定向到文件中，如果交给我们的前台进程，那么此时只能执行一个写入文件操作，因为我们的前台进程只有一个，但是后台进程有多个，我们可以交给后台进程，并且还能通过jobs来查看后台进程。

如果我们向终止任务，可以使用fg 任务号将这个任务提到前台进程，但是此时bash就会变成后台进程，然后将它干掉即可。如果我们不想干掉，想重新仍会后台进程呢？

此时我们暂停前台进程，系统要不要把bash提到前台进程，把暂停的进程提到后台进程，要的，bash必须变成前台进程，所以在命令行中，前台进程一定存在。

随后我们再来理解一下后台进程。

每次登录的时候，我们的session都是不同的，所以session id也是不同的。

这里我们在开启两个终端。

如果我们的前台进程退了，开启的后台进程呢？它会自己退嘛？

此时我们发现后台进程也退出了，所以用户在退出的时候，会将自己启动的所有进程关掉，这就是注销，如果我们不想让我们的后台进程不随任何用户的登录或者退出受影响，此时我们就要守护进程化，我们将自成session自成进程组的进程，称为守护进程。

注意：如果调用进程不是一个进程组组长，则创建一个新的会话，但是我们怎么保证不是进程组组长的呢？我们可以创建一个子进程，然后父进程退出，此时的子进程就不是一个进程组组长，则创建一个新的会话，所以守护进程的本质，也是孤儿进程！但是该孤儿进程很坚强，它把自己设置成新的session，它就是一个独立的session，这样不隶属于任何用户登录和注销的影响。

  1. #pragma onec
  2.  
  3. #include <unistd.h>
  4. #include <iostream>
  5. #include <signal.h>
  6. #include <cstdlib>
  7. #include <sys/types.h>
  8. #include <sys/stat.h>
  9. #include <fcntl.h>
  10.  
  11. const std::string nullfile = "/dev/null";
  12.  
  13. // 让服务器调用还函数,以守护进程的形式进行运行
  14. void Daemon(const std::string &cwd = "")
  15. {
  16.     // 1.忽略其他异常信号
  17.     signal(SIGCLD, SIG_IGN);
  18.     signal(SIGPIPE, SIG_IGN);
  19.     signal(SIGSTOP, SIG_IGN);
  20.  
  21.     // 2.将自己变成独立的会话
  22.     // 父进程退出
  23.     if(fork() > 0) exit(0);
  24.     setsid(); 
  25.  
  26.     // 3. 更改当前调用进程的工作目录
  27.     if (!cwd.empty())
  28.         chdir(cwd.c_str());
  29.  
  30.     // 4.关闭? 标准输入,标准输出,标准错误
  31.     // 但是如果我们关闭了,那此时日志里面的打印全都会出错
  32.     // 系统为我们提供了一个/dev/null文件,它像一个垃圾桶
  33.     // 凡是向/dev/null文件里面写入的信息全部都会被丢弃
  34.     // 4.标准输入,标准输出,标准错误 -> 重定向到/dev/null文件
  35.     // 此时日志的信息都会丢弃,那么我们看不到错误的信息了嘛?是滴
  36.     // 所以日志的信息我们可以将它写到文件中,反正不应该出现在显示器文件
  37.     int fd = open(nullfile.c_str(), O_RDWR); // 读写方式打开
  38.     if(fd > 0) // 打开成功
  39.     {
  40.         dup2(fd, 0);
  41.         dup2(fd, 1);
  42.         dup2(fd, 2);
  43.         close(fd);
  44.     }
  45. }

随后我们将守护进程的代码加入服务器启动的最开始的地方。

随后我们开始运行一下：

并且此时我们能够确定我们的服务器的进程不隶属于bash的session，而是单成session。

bash的session id和我们的服务器的session id不一样哦！

此时我们能够发现我们已经将日志重定向到垃圾桶啦！随后我们再将我们的xshell关掉，然后我们再打开xshell，运行我们的服务器，看看结果：

此时只要我们一运行我们的客户端，就可以访问，真正做到了24小时提供服务，那我们怎么关掉我们的服务器呢？直接kill就行啦！！！

注意：为了标识守护进程，我们一般给文件名为末尾加上d。

如果我们想保留日志文件，那么我们就要传入写入的方式。

此时我们就能在日志里面看到该日志文件，但是守护进程还是太麻烦了，要自己来写，其实系统也为我们实现了。

这个函数接受两个整型参数：

  1. nochdir:

    • 如果 nochdir 参数为0，daemon() 函数将会把当前工作目录更改为根目录（"/"）。这是守护进程的标准行为，避免因当前工作目录被卸载而导致的问题。
    • 如果 nochdir 为非0值，则不改变当前工作目录。

  2. noclose:

    • 如果 noclose 参数为0，daemon() 函数会关闭标准输入、标准输出和标准错误，并将它们都重定向到 /dev/null。这可以防止守护进程因为试图写入终端而阻塞或产生不必要的输出。
    • 如果 noclose 为非0值，标准输入、输出和错误保持不变。但通常情况下，为了确保守护进程的无终端运行，我们会选择关闭它们。

使用 daemon() 函数的基本步骤通常包括：

  • 调用 fork() 创建子进程，父进程退出，这样新进程就不再与终端关联。
  • 在子进程中调用 setsid() 成为新的会话领导并脱离控制终端。
  • 调用 umask() 设置合适的权限掩码。
  • 根据需要调用 chdir("/") 更改当前工作目录到根目录。
  • 重定向标准输入、输出和错误流，或者通过 daemon() 函数自动处理。
  • 继续执行守护进程的具体任务。

七、TCP协议通讯流程

下图是基于TCP协议的客户端/服务器程序的一般流程：

服务器初始化:

  • 调用socket, 创建文件描述符;
  • 调用bind, 将当前的文件描述符和ip/port绑定在一起;
  • 如果这个端口已经被其他进程占用了, 就会bind失败;
  • 调用listen, 声明当前这个文件描述符作为一个服务器的文件描述符, 为后面的accept做好准备; 调用accecpt, 并阻塞, 等待客户端连接过来;

建立连接的过程:

  • 调用socket, 创建文件描述符;
  • 调用connect, 向服务器发起连接请求;
  • connect会发出SYN段并阻塞等待服务器应答;
  • (第一次) 服务器收到客户端的SYN, 会应答一个SYN-ACK段表示"同意建立连接"; (
  • 第二次) 客户端收到SYN-ACK后会从connect()返回, 同时应答一个ACK段; (第三次)

这个建立连接的过程, 通常称为 三次握手;

数据传输的过程

  • 建立连接后,TCP协议提供全双工的通信服务;
  • 所谓全双工的意思是, 在同一条连接中, 同一时刻, 通信双方 可以同时写数据;
  • 相对的概念叫做半双工, 同一条连接在同一时刻, 只能由一方来写数据;
  • 服务器从accept()返回后立刻调 用read(), 读socket就像读管道一样, 如果没有数据到达就阻塞等待;
  • 这时客户端调用write()发送请求给服务器, 服务器收到后从read()返回,对客户端的请求进行处理, 在此期 间客户端调用read()阻塞等待服务器的应答;
  • 服务器调用write()将处理结果发回给客户端, 再次调用read()阻塞等待下一条请求;
  • 客户端收到后从read()返回, 发送下一条请求,如此循环下去;

断开连接的过程:

  • 如果客户端没有更多的请求了, 就调用close()关闭连接, 客户端会向服务器发送FIN段(第一次);
  • 此时服务器收到FIN后, 会回应一个ACK, 同时read会返回0 (第二次);
  • read返回之后, 服务器就知道客户端关闭了连接, 也调用close关闭连接, 这个时候服务器会向客户端发送 一个FIN;(第三次)
  • 客户端收到FIN, 再返回一个ACK给服务器; (第四次)

这个断开连接的过程, 通常称为 四次挥手

在学习socket API时要注意应用程序和TCP协议层是如何交互的:

  • 应用程序调用某个socket函数时TCP协议层完成什么动作,比如调用connect()会发出SYN段
  • 应用程序如何知道TCP协议层的状态变化,比如从某个阻塞的socket函数返回就表明TCP协议收到了某些 段,再比如read()返回0就表明收到了FIN段

谈恋爱例子

八、TCP全双工通信

全双工通信：

  • 在全双工模式下，数据可以同时在两个方向上传输，即通信的双方能够同时进行发送和接收操作，互不影响。这就像两个人在打电话，双方可以同时说话和聆听，无需等待对方说完再回应。

半双工通信：

  • 半双工模式允许数据在两个方向上传输，但不能同时进行。这意味着在任何给定的时间点，数据只能在一个方向流动。一旦一方开始发送数据，另一方就必须停止发送并转为接收模式，直到前一方发送完毕。这种模式类似于对讲机，使用者必须等待对方讲完并说“Over”后，才可开始自己的讲话。

我们为什么要讲这个呢？因为我们的tcp是全双工通信的，它是如何做到的呢？

每个TCP连接都有独立的发送缓冲区和接收缓冲区。这意味着一个端点可以在其发送缓冲区排队待发送的数据，同时从接收缓冲区读取对方发送过来的数据。这两个操作可以并发进行，从而实现了数据的双向同时传输，所以未来我们可以对一个套接字多进程的并发的读和写，但是两个线程不能同时读和同时写。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/639658
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号