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

网络编程套接字（三）之TCP服务器简单实现_tcp 服务器 简单

作者：你好赵伟 | 2024-05-08 10:40:05

赞

踩

tcp 服务器 简单

目录

一、服务端TcpServer

1、tcp_server.hpp

2、tcp_server.cc

二、客户端TcpClient

tcp_client.cc

三、服务器和客户端进行通信

四、完整代码

一、服务端TcpServer

首先我们需要对服务端进行封装。我们需要的成员变量有IP地址，端口号port，以及监听套接字listensock。Tcp服务器实现的一般步骤就是：创建套接字，进行绑定，监听等待连接，获取连接，开始通信服务。下面我们一一讲解。

1、tcp_server.hpp

第一步，创建套接字使用的函数和UDP完全一样，只不过我们需要把socket的第二个参数由基于数据报的SOCK_DGRAM 更改为基于字节流式的SOCK_STREAM，SOCK_STREAM提供的就是一个有序的、可靠的、全双工的、基于连接的流式服务。其他参数和后续步骤完全一样。

第二步，进行绑定时使用的bind函数及其参数设置与UDP完全一样。

第三步，TCP和UDP不一样的地方就是这里了。前面我们知道UDP不是面向连接的，而TCP是面向连接的，所以服务器和客户端之间需要建立连接。而服务器首先需要做的就是进行监听，等待客户端的连接。需要使用listen函数。

  1. NAME
  2.        listen - listen for connections on a socket
  3.  
  4. SYNOPSIS
  5.        #include <sys/types.h>          /* See NOTES */
  6.        #include <sys/socket.h>
  7.  
  8.        int listen(int sockfd, int backlog);

参数说明：

sockfd：需要设置为监听状态的套接字对应的文件描述符。

backlog：全连接队列的最大长度。如果有多个客户端同时发来连接请求，此时未被服务器处理的连接就会放入连接队列，该参数代表的就是这个全连接队列的最大长度，一般不要设置太大，设置为5或10即可。

返回值：监听成功返回0，监听失败返回-1，同时错误码会被设置。

以上三步就是服务器的初始化。

第四步，TCP服务器初始化后就可以开始运行了，但TCP服务器在与客户端进行网络通信之前，服务器需要先获取到客户端的连接请求。我们需要使用accept函数。

  1. NAME
  2.        accept, accept4 - accept a connection on a socket
  3.  
  4. SYNOPSIS
  5.        #include <sys/types.h>          /* See NOTES */
  6.        #include <sys/socket.h>
  7.  
  8.        int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

参数说明：

sockfd：特定的监听套接字，表示从该监听套接字中获取连接。

addr：对端网络相关的属性信息，包括协议家族、IP地址、端口号等。

addrlen：调用时传入期望读取的addr结构体的长度，返回时代表实际读取到的addr结构体的长度，这是一个输入输出型参数。

返回值：获取连接成功返回接收到的套接字的文件描述符，获取连接失败返回-1，同时错误码会被设置。

注意：为什么获取连接成功了还要返回一个新的套接字呢？

类里面的监听套接字：用于获取客户端发来的连接请求。accept函数会不断从监听套接字当中获取新连接。
accept函数返回的套接字：用于为本次accept获取到的连接提供服务。

所以说，监听套接字的任务只是不断获取新连接，而真正为这些连接提供服务的套接字是accept函数返回的套接字，而不是监听套接字。

第五步，我们只要获取到客户端的连接，就可以对客户端进行服务了。

2、tcp_server.cc

与UDP相同，我们需要创建TCP服务器对象，然后对其进行初始化，然后运行。我们也是只需要绑定端口号即可。

二、客户端TcpClient

tcp_client.cc

作为TCP客户端，首先也是需要创建套接字。然后向服务器发起连接，最后就可以开始通信了。和UDP一样，客户端不需要绑定端口号。

客户端向服务器发起连接需要使用connect函数。

  1. NAME
  2.        connect - initiate a connection on a socket
  3.  
  4. SYNOPSIS
  5.        #include <sys/types.h>          /* See NOTES */
  6.        #include <sys/socket.h>
  7.  
  8.        int connect(int sockfd, const struct sockaddr *addr,
  9.                    socklen_t addrlen);

参数说明：

sockfd：特定的套接字，表示通过该套接字发起连接请求。

addr：对端网络相关的属性信息，包括协议家族、IP地址、端口号等。

addrlen：传入的addr结构体的长度。

返回值：连接或绑定成功返回0，连接失败返回-1，同时错误码会被设置。

三、服务器和客户端进行通信

首先，我们要知道：对于TCP服务器和客户端，我们也可以使用write函数和read函数进行消息的读取和发送。

我们先写一个服务，实现客户端给服务器发送什么消息，服务器就返回什么消息。

我们先写一个单进程版本的服务。tcp_server.hpp：

  1. #include <iostream>
  2. #include <string>
  3. #include <cstring>
  4. #include <unistd.h>
  5. #include <sys/types.h>
  6. #include <sys/wait.h>
  7. #include <sys/socket.h>
  8. #include <netinet/in.h>
  9. #include <arpa/inet.h>
  10. #include <cassert>
  11. #include <signal.h>
  12.  
  13. static int gmv = 20;
  14.  
  15. static void service(int sock, const std::string &clientip, const uint16_t &clientport)
  16. {
  17.     char buffer[1024];
  18.     while (true)
  19.     {
  20.         ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
  21.         if (s < 0)
  22.         {
  23.             std::cout << "接收信息失败！" << std::endl;
  24.             break;
  25.         }
  26.         else if (s > 0)
  27.         {
  28.             buffer[s] = 0;
  29.             std::cout << clientip << ":" << clientport << std::endl;
  30.         }
  31.         else
  32.         {
  33.             std::cout << "客户端关闭！" << std::endl;
  34.             break;
  35.         }
  36.         write(sock, buffer, strlen(buffer));
  37.     }
  38. }
  39.  
  40. class TcpServer
  41. {
  42. public:
  43.     TcpServer(const uint16_t port, const std::string &ip = "") : listensock_(-1), ip_(ip), port_(port)
  44.     {
  45.     }
  46.  
  47.     void initTcpServer()
  48.     {
  49.         // 1.创建套接字
  50.         listensock_ = socket(AF_INET, SOCK_STREAM, 0);
  51.         if (listensock_ < 0)
  52.         {
  53.             std::cout << "创建套接字失败！" << std::endl;
  54.             exit(0);
  55.         }
  56.  
  57.         // 2.进行绑定
  58.         struct sockaddr_in src_server;
  59.         bzero(&src_server, sizeof(src_server));
  60.         src_server.sin_family = AF_INET;
  61.         src_server.sin_port = htons(port_);
  62.         inet_pton(AF_INET, ip_.c_str(), &src_server);
  63.         socklen_t len = sizeof(src_server);
  64.         if (bind(listensock_, (struct sockaddr *)&src_server, len) < 0)
  65.         {
  66.             std::cout << "绑定失败！" << std::endl;
  67.             exit(1);
  68.         }
  69.  
  70.         // 3.开始监听,等待连接
  71.         if (listen(listensock_, gmv) < 0)
  72.         {
  73.             std::cout << "监听失败！" << std::endl;
  74.             exit(2);
  75.         }
  76.  
  77.         std::cout << "服务器初始化成功！" << std::endl;
  78.     }
  79.  
  80.     void start()
  81.     {
  82.         //signal(SIGCHLD, SIG_IGN);
  83.         while (true)
  84.         {
  85.             // 4.获取链接
  86.             struct sockaddr_in client_sock;
  87.             socklen_t len = sizeof(client_sock);
  88.             int serversock = accept(listensock_, (struct sockaddr *)&client_sock, &len);
  89.             if (serversock < 0)
  90.             {
  91.                 std::cout << "获取链接失败！" << std::endl;
  92.                 exit(3);
  93.             }
  94.             // 5.开始通信服务
  95.             uint16_t client_port = ntohs(client_sock.sin_port);
  96.             std::string client_ip = inet_ntoa(client_sock.sin_addr);
  97.             std::cout << "[" << client_port << "-" << client_ip << "]" << std::endl;
  98.  
  99.             //version 1：单进程版服务————服务器一次只能处理一个客户端，只有处理完一个，才能处理下一个
  100.             service(serversock, client_ip, client_port);
  101.         }
  102.     }
  103.  
  104.     ~TcpServer()
  105.     {
  106.         close(listensock_);
  107.     }
  108.  
  109. private:
  110.     int listensock_;
  111.     std::string ip_;
  112.     uint16_t port_;
  113. };

结果：

上面的结果没有什么问题，那么，如果我们同时有两个客户端访问服务器，会发生什么呢？

因为我们目前所写的是一个单执行流版的服务器，这个服务器一次只能为一个客户端提供服务。所以我们发现，当其中一个客户端在和服务器进行通信的时候，另一个客户端并不能与服务器通信，也就是说服务器在某一时刻只能向一个客户端提供服务，只有对一个客户端提供服务完成后，才能对下一个服务器提供服务。

很显然，这种提供服务的方式是不符合实际的，一个服务器应该要能够同时给多个客户端提供服务。所以我们需要改进代码。

多进程服务版本：既然单进程不符合实际，那么我们最先想到的就是使用多进程——创建子进程给新的连接提供服务，父进程去继续获取新的连接。

  1. #include <iostream>
  2. #include <string>
  3. #include <cstring>
  4. #include <unistd.h>
  5. #include <sys/types.h>
  6. #include <sys/wait.h>
  7. #include <sys/socket.h>
  8. #include <netinet/in.h>
  9. #include <arpa/inet.h>
  10. #include <cassert>
  11. #include <signal.h>
  12.  
  13. static int gmv = 20;
  14.  
  15. static void service(int sock, const std::string &clientip, const uint16_t &clientport)
  16. {
  17.     char buffer[1024];
  18.     while (true)
  19.     {
  20.         ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
  21.         if (s < 0)
  22.         {
  23.             std::cout << "接收信息失败！" << std::endl;
  24.             break;
  25.         }
  26.         else if (s > 0)
  27.         {
  28.             buffer[s] = 0;
  29.             std::cout << clientip << ":" << clientport << std::endl;
  30.         }
  31.         else
  32.         {
  33.             std::cout << "客户端关闭！" << std::endl;
  34.             break;
  35.         }
  36.         write(sock, buffer, strlen(buffer));
  37.     }
  38. }
  39.  
  40. class TcpServer
  41. {
  42. public:
  43.     TcpServer(const uint16_t port, const std::string &ip = "") : listensock_(-1), ip_(ip), port_(port)
  44.     {
  45.     }
  46.  
  47.     void initTcpServer()
  48.     {
  49.         // 1.创建套接字
  50.         listensock_ = socket(AF_INET, SOCK_STREAM, 0);
  51.         if (listensock_ < 0)
  52.         {
  53.             std::cout << "创建套接字失败！" << std::endl;
  54.             exit(0);
  55.         }
  56.  
  57.         // 2.进行绑定
  58.         struct sockaddr_in src_server;
  59.         bzero(&src_server, sizeof(src_server));
  60.         src_server.sin_family = AF_INET;
  61.         src_server.sin_port = htons(port_);
  62.         inet_pton(AF_INET, ip_.c_str(), &src_server);
  63.         socklen_t len = sizeof(src_server);
  64.         if (bind(listensock_, (struct sockaddr *)&src_server, len) < 0)
  65.         {
  66.             std::cout << "绑定失败！" << std::endl;
  67.             exit(1);
  68.         }
  69.  
  70.         // 3.开始监听,等待连接
  71.         if (listen(listensock_, gmv) < 0)
  72.         {
  73.             std::cout << "监听失败！" << std::endl;
  74.             exit(2);
  75.         }
  76.  
  77.         std::cout << "服务器初始化成功！" << std::endl;
  78.     }
  79.  
  80.     void start()
  81.     {
  82.         signal(SIGCHLD, SIG_IGN);
  83.         while (true)
  84.         {
  85.             // 4.获取链接
  86.             struct sockaddr_in client_sock;
  87.             socklen_t len = sizeof(client_sock);
  88.             int serversock = accept(listensock_, (struct sockaddr *)&client_sock, &len);
  89.             if (serversock < 0)
  90.             {
  91.                 std::cout << "获取链接失败！" << std::endl;
  92.                 exit(3);
  93.             }
  94.             // 5.开始通信服务
  95.             uint16_t client_port = ntohs(client_sock.sin_port);
  96.             std::string client_ip = inet_ntoa(client_sock.sin_addr);
  97.             std::cout << "[" << client_port << "-" << client_ip << "]" << std::endl;
  98.             // version 2.0：多进程版本——创建子进程给新的连接提供服务，父进程去继续获取新的连接
  99.             pid_t id = fork();
  100.             assert(id != -1);
  101.             if (id == 0)
  102.             {
  103.                 // child 并且注意僵尸状态
  104.                 // child会继承父进程打开的文件及其fd，子进程不需要进行监听的套接字，关闭
  105.                 close(listensock_);
  106.                 //子进程只需要给连接客户端提供服务的套接字
  107.                 service(serversock, client_ip, client_port);
  108.                 exit(0);
  109.             } 
  110.             close(serversock);
  111.         }
  112.     }
  113.  
  114.     ~TcpServer()
  115.     {
  116.         close(listensock_);
  117.     }
  118.  
  119. private:
  120.     int listensock_;
  121.     std::string ip_;
  122.     uint16_t port_;
  123. };

结果：

这种方法可以解决问题。

当然，我们还有如下的多进程版本：

  1. ​
  2. #include <iostream>
  3. #include <string>
  4. #include <cstring>
  5. #include <unistd.h>
  6. #include <sys/types.h>
  7. #include <sys/wait.h>
  8. #include <sys/socket.h>
  9. #include <netinet/in.h>
  10. #include <arpa/inet.h>
  11. #include <cassert>
  12. #include <signal.h>
  13.  
  14. static int gmv = 20;
  15.  
  16. static void service(int sock, const std::string &clientip, const uint16_t &clientport)
  17. {
  18.     char buffer[1024];
  19.     while (true)
  20.     {
  21.         ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
  22.         if (s < 0)
  23.         {
  24.             std::cout << "接收信息失败！" << std::endl;
  25.             break;
  26.         }
  27.         else if (s > 0)
  28.         {
  29.             buffer[s] = 0;
  30.             std::cout << clientip << ":" << clientport << std::endl;
  31.         }
  32.         else
  33.         {
  34.             std::cout << "客户端关闭！" << std::endl;
  35.             break;
  36.         }
  37.         write(sock, buffer, strlen(buffer));
  38.     }
  39. }
  40.  
  41. class TcpServer
  42. {
  43. public:
  44.     TcpServer(const uint16_t port, const std::string &ip = "") : listensock_(-1), ip_(ip), port_(port)
  45.     {
  46.     }
  47.  
  48.     void initTcpServer()
  49.     {
  50.         // 1.创建套接字
  51.         listensock_ = socket(AF_INET, SOCK_STREAM, 0);
  52.         if (listensock_ < 0)
  53.         {
  54.             std::cout << "创建套接字失败！" << std::endl;
  55.             exit(0);
  56.         }
  57.  
  58.         // 2.进行绑定
  59.         struct sockaddr_in src_server;
  60.         bzero(&src_server, sizeof(src_server));
  61.         src_server.sin_family = AF_INET;
  62.         src_server.sin_port = htons(port_);
  63.         inet_pton(AF_INET, ip_.c_str(), &src_server);
  64.         socklen_t len = sizeof(src_server);
  65.         if (bind(listensock_, (struct sockaddr *)&src_server, len) < 0)
  66.         {
  67.             std::cout << "绑定失败！" << std::endl;
  68.             exit(1);
  69.         }
  70.  
  71.         // 3.开始监听,等待连接
  72.         if (listen(listensock_, gmv) < 0)
  73.         {
  74.             std::cout << "监听失败！" << std::endl;
  75.             exit(2);
  76.         }
  77.  
  78.         std::cout << "服务器初始化成功！" << std::endl;
  79.     }
  80.  
  81.     void start()
  82.     {
  83.         while (true)
  84.         {
  85.             // 4.获取链接
  86.             struct sockaddr_in client_sock;
  87.             socklen_t len = sizeof(client_sock);
  88.             int serversock = accept(listensock_, (struct sockaddr *)&client_sock, &len);
  89.             if (serversock < 0)
  90.             {
  91.                 std::cout << "获取链接失败！" << std::endl;
  92.                 exit(3);
  93.             }
  94.             // 5.开始通信服务
  95.             uint16_t client_port = ntohs(client_sock.sin_port);
  96.             std::string client_ip = inet_ntoa(client_sock.sin_addr);
  97.             std::cout << "[" << client_port << "-" << client_ip << "]" << std::endl;
  98.  
  99.             // version 2.1:多进程版
  100.             pid_t pid = fork();
  101.             if (pid == 0)
  102.             {
  103.                 // 子进程
  104.                 if (fork() > 0)
  105.                     exit(0);
  106.                 // 孙子进程
  107.                 close(listensock_);
  108.                 service(serversock, client_ip, client_port);
  109.             }
  110.              // 父进程
  111.             waitpid(pid, nullptr, 0);
  112.             close(serversock);
  113.         }
  114.     }
  115.  
  116.     ~TcpServer()
  117.     {
  118.         close(listensock_);
  119.     }
  120.  
  121. private:
  122.     int listensock_;
  123.     std::string ip_;
  124.     uint16_t port_;
  125. };

我们让子进程创建完孙子进程后立刻退出，此时服务进程（父进程）调用wait/waitpid函数等待子进程就能立刻等待成功，此后服务进程就能继续调用accept函数获取其他客户端的连接请求。

而由于子进程退出，孙子进程就变成孤儿进程，被os领养，最后由os自动回收。 

结果：

多线程版本：我们还可以创建新的线程去对客户端进行服务，让主线程继续获取连接：

  1. #include <iostream>
  2. #include <string>
  3. #include <cstring>
  4. #include <unistd.h>
  5. #include <sys/types.h>
  6. #include <sys/wait.h>
  7. #include <sys/socket.h>
  8. #include <netinet/in.h>
  9. #include <arpa/inet.h>
  10. #include <cassert>
  11. #include <signal.h>
  12.  
  13. static int gmv = 20;
  14.  
  15. static void service(int sock, const std::string &clientip, const uint16_t &clientport)
  16. {
  17.     char buffer[1024];
  18.     while (true)
  19.     {
  20.         ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
  21.         if (s < 0)
  22.         {
  23.             std::cout << "接收信息失败！" << std::endl;
  24.             break;
  25.         }
  26.         else if (s > 0)
  27.         {
  28.             buffer[s] = 0;
  29.             std::cout << clientip << ":" << clientport << std::endl;
  30.         }
  31.         else
  32.         {
  33.             std::cout << "客户端关闭！" << std::endl;
  34.             break;
  35.         }
  36.         write(sock, buffer, strlen(buffer));
  37.     }
  38. }
  39.  
  40. class threaddata
  41. {
  42. public:
  43.     int sock_;
  44.     std::string ip_;
  45.     uint16_t port_;
  46. };
  47.  
  48. class TcpServer
  49. {
  50. public:
  51.     static void *threadRountine(void *arg)
  52.     {
  53.         pthread_detach(pthread_self());
  54.         threaddata *td = static_cast<threaddata *>(arg);
  55.         service(td->sock_, td->ip_, td->port_);
  56.         delete td;
  57.     }
  58.  
  59.     TcpServer(const uint16_t port, const std::string &ip = "") : listensock_(-1), ip_(ip), port_(port)
  60.     {
  61.     }
  62.  
  63.     void initTcpServer()
  64.     {
  65.         // 1.创建套接字
  66.         listensock_ = socket(AF_INET, SOCK_STREAM, 0);
  67.         if (listensock_ < 0)
  68.         {
  69.             std::cout << "创建套接字失败！" << std::endl;
  70.             exit(0);
  71.         }
  72.  
  73.         // 2.进行绑定
  74.         struct sockaddr_in src_server;
  75.         bzero(&src_server, sizeof(src_server));
  76.         src_server.sin_family = AF_INET;
  77.         src_server.sin_port = htons(port_);
  78.         inet_pton(AF_INET, ip_.c_str(), &src_server);
  79.         socklen_t len = sizeof(src_server);
  80.         if (bind(listensock_, (struct sockaddr *)&src_server, len) < 0)
  81.         {
  82.             std::cout << "绑定失败！" << std::endl;
  83.             exit(1);
  84.         }
  85.  
  86.         // 3.开始监听,等待连接
  87.         if (listen(listensock_, gmv) < 0)
  88.         {
  89.             std::cout << "监听失败！" << std::endl;
  90.             exit(2);
  91.         }
  92.  
  93.         std::cout << "服务器初始化成功！" << std::endl;
  94.     }
  95.  
  96.     void start()
  97.     {
  98.         while (true)
  99.         {
  100.             // 4.获取链接
  101.             struct sockaddr_in client_sock;
  102.             socklen_t len = sizeof(client_sock);
  103.             int serversock = accept(listensock_, (struct sockaddr *)&client_sock, &len);
  104.             if (serversock < 0)
  105.             {
  106.                 std::cout << "获取链接失败！" << std::endl;
  107.                 exit(3);
  108.             }
  109.             // 5.开始通信服务
  110.             uint16_t client_port = ntohs(client_sock.sin_port);
  111.             std::string client_ip = inet_ntoa(client_sock.sin_addr);
  112.             std::cout << "[" << client_port << "-" << client_ip << "]" << std::endl;
  113.  
  114.             // version 3——多线程版本
  115.             pthread_t tid;
  116.             threaddata *td = new threaddata();
  117.             td->sock_ = serversock;
  118.             td->ip_ = client_ip;
  119.             td->port_ = client_port;
  120.             pthread_create(&tid, nullptr, threadRountine, td);
  121.         }
  122.     }
  123.  
  124.     ~TcpServer()
  125.     {
  126.         close(listensock_);
  127.     }
  128.  
  129. private:
  130.     int listensock_;
  131.     std::string ip_;
  132.     uint16_t port_;
  133. };

 

四、完整代码

tcp_server.hpp

  1. #include <iostream>
  2. #include <string>
  3. #include <cstring>
  4. #include <unistd.h>
  5. #include <sys/types.h>
  6. #include <sys/wait.h>
  7. #include <sys/socket.h>
  8. #include <netinet/in.h>
  9. #include <arpa/inet.h>
  10. #include <cassert>
  11. #include <signal.h>
  12.  
  13. static int gmv = 20;
  14.  
  15. static void service(int sock, const std::string &clientip, const uint16_t &clientport)
  16. {
  17.     char buffer[1024];
  18.     while (true)
  19.     {
  20.         ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
  21.         if (s < 0)
  22.         {
  23.             std::cout << "接收信息失败！" << std::endl;
  24.             break;
  25.         }
  26.         else if (s > 0)
  27.         {
  28.             buffer[s] = 0;
  29.             std::cout << clientip << ":" << clientport << std::endl;
  30.         }
  31.         else
  32.         {
  33.             std::cout << "客户端关闭！" << std::endl;
  34.         }
  35.         write(sock, buffer, strlen(buffer));
  36.     }
  37. }
  38.  
  39. class threaddata
  40. {
  41. public:
  42.     int sock_;
  43.     std::string ip_;
  44.     uint16_t port_;
  45. };
  46.  
  47. class TcpServer
  48. {
  49. public:
  50.     static void *threadRountine(void *arg)
  51.     {
  52.         pthread_detach(pthread_self());
  53.         threaddata *td = static_cast<threaddata *>(arg);
  54.         service(td->sock_, td->ip_, td->port_);
  55.         delete td;
  56.     }
  57.  
  58.     TcpServer(const uint16_t port, const std::string &ip = "") : listensock_(-1), ip_(ip), port_(port)
  59.     {
  60.     }
  61.  
  62.     void initTcpServer()
  63.     {
  64.         // 1.创建套接字
  65.         listensock_ = socket(AF_INET, SOCK_STREAM, 0);
  66.         if (listensock_ < 0)
  67.         {
  68.             std::cout << "创建套接字失败！" << std::endl;
  69.             exit(0);
  70.         }
  71.  
  72.         // 2.进行绑定
  73.         struct sockaddr_in src_server;
  74.         bzero(&src_server, sizeof(src_server));
  75.         src_server.sin_family = AF_INET;
  76.         src_server.sin_port = htons(port_);
  77.         inet_pton(AF_INET, ip_.c_str(), &src_server);
  78.         socklen_t len = sizeof(src_server);
  79.         if (bind(listensock_, (struct sockaddr *)&src_server, len) < 0)
  80.         {
  81.             std::cout << "绑定失败！" << std::endl;
  82.             exit(1);
  83.         }
  84.  
  85.         // 3.开始监听,等待连接
  86.         if (listen(listensock_, gmv) < 0)
  87.         {
  88.             std::cout << "监听失败！" << std::endl;
  89.             exit(2);
  90.         }
  91.  
  92.         std::cout << "服务器初始化成功！" << std::endl;
  93.     }
  94.  
  95.     void start()
  96.     {
  97.         signal(SIGCHLD, SIG_IGN);
  98.         while (true)
  99.         {
  100.             // 4.获取链接
  101.             struct sockaddr_in client_sock;
  102.             socklen_t len = sizeof(client_sock);
  103.             int serversock = accept(listensock_, (struct sockaddr *)&client_sock, &len);
  104.             if (serversock < 0)
  105.             {
  106.                 std::cout << "获取链接失败！" << std::endl;
  107.                 exit(3);
  108.             }
  109.             // 5.开始通信服务
  110.             uint16_t client_port = ntohs(client_sock.sin_port);
  111.             std::string client_ip = inet_ntoa(client_sock.sin_addr);
  112.             std::cout << "[" << client_port << "-" << client_ip << "]" << std::endl;
  113.  
  114.             // version 1：单进程版服务————服务器一次只能处理一个客户端，只有处理完一个，才能处理下一个
  115.             // service(serversock, client_ip, client_port);
  116.  
  117.             // version 2.0：多进程版本——创建子进程给新的连接提供服务，父进程去继续获取新的连接
  118.             /* pid_t id = fork();
  119.             assert(id != -1);
  120.             if (id == 0)
  121.             {
  122.                 // child 并且注意僵尸状态
  123.                 // child会继承父进程打开的文件及其fd，子进程不需要进行监听的套接字，关闭
  124.                 close(listensock_);
  125.                 //子进程只需要给连接客户端提供服务的套接字
  126.                 service(serversock, client_ip, client_port);
  127.                 exit(0);
  128.             } */
  129.  
  130.             /* // version 2.1:多进程版
  131.             pid_t pid = fork();
  132.             if (pid == 0)
  133.             {
  134.                 // 子进程
  135.                 if (fork() > 0)
  136.                     exit(0);
  137.                 // 孙子进程
  138.                 close(listensock_);
  139.                 service(serversock, client_ip, client_port);
  140.             }
  141.             // 父进程
  142.             waitpid(pid, nullptr, 0); */
  143.  
  144.             // version 3——多线程版本
  145.             pthread_t tid;
  146.             threaddata *td = new threaddata();
  147.             td->sock_ = serversock;
  148.             td->ip_ = client_ip;
  149.             td->port_ = client_port;
  150.             pthread_create(&tid, nullptr, threadRountine, td);
  151.  
  152.             close(serversock);
  153.         }
  154.     }
  155.  
  156.     ~TcpServer()
  157.     {
  158.         close(listensock_);
  159.     }
  160.  
  161. private:
  162.     int listensock_;
  163.     std::string ip_;
  164.     uint16_t port_;
  165. };

tcp_server.cc

  1. #include "tcp_server.hpp"
  2. #include <memory>
  3.  
  4. static void usage(std::string proc)
  5. {
  6.     std::cout << "\n"
  7.               << proc << " port"
  8.               << std::endl;
  9. }
  10.  
  11. // ./tcpserver 8080
  12. int main(int argc, char *argv[])
  13. {
  14.     if (argc != 2)
  15.     {
  16.         usage(argv[0]);
  17.         exit(0);
  18.     }
  19.     uint16_t server_port=atoi(argv[1]);
  20.     std::unique_ptr<TcpServer> sev(new TcpServer(server_port));
  21.     sev->initTcpServer();
  22.     sev->start();
  23.  
  24.     return 0;
  25. }

tcp_client.cc 

  1. #include <iostream>
  2. #include <sys/types.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <sys/socket.h>
  6. #include <netinet/in.h>
  7. #include <arpa/inet.h>
  8.  
  9. static void usage(std::string proc)
  10. {
  11.     std::cout << "\n"
  12.               << proc << " port"
  13.               << std::endl;
  14. }
  15.  
  16. // ./tcpclient IP port
  17. int main(int argc, char *argv[])
  18. {
  19.     if (argc != 3)
  20.     {
  21.         usage(argv[0]);
  22.         exit(1);
  23.     }
  24.     std::string server_ip = argv[1];
  25.     uint16_t server_port = atoi(argv[2]);
  26.  
  27.     int sock = socket(AF_INET, SOCK_STREAM, 0);
  28.     if (sock < 0)
  29.     {
  30.         std::cout << "创建套接字失败！" << std::endl;
  31.         exit(0);
  32.     }
  33.  
  34.     struct sockaddr_in server;
  35.     memset(&server, 0, sizeof server);
  36.     server.sin_family = AF_INET;
  37.     server.sin_port = htons(server_port);
  38.     server.sin_addr.s_addr = inet_addr(server_ip.c_str());
  39.     if (connect(sock, (struct sockaddr *)&server, sizeof server) < 0)
  40.     {
  41.         std::cout << "连接失败！" << std::endl;
  42.         exit(0);
  43.     }
  44.  
  45.     // 开始通信
  46.     while (true)
  47.     {
  48.         std::string line;
  49.         std::cout << "请输入# ";
  50.         std::getline(std::cin, line);
  51.         ssize_t s = write(sock, line.c_str(), line.size());
  52.  
  53.         char buffer[1024];
  54.         ssize_t m = read(sock, buffer, sizeof buffer - 1);
  55.         buffer[m] = 0;
  56.         std::cout << "服务器：" << buffer << std::endl;
  57.     }
  58.  
  59.     return 0;
  60. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/554119
推荐阅读
相关标签

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

  

闽ICP备14008679号