• 套接字编程：TCP通信程序

    目录

    一、服务端编写流程

    二、客户端编写流程

    三、相关接口

    1. 创建套接字

    2. 为套接字绑定地址信息

    3. 客户端：向服务器发起连接请求

    4. 服务端：监听接口

    5. 服务端：获取新建连接

    6. 收发数据

    7. 关闭套接字

    四、代码实现

    1. 头文件-套接字接口封装

    2. 服务端实现

    2.1 多进程实现

    2.2 多线程实现

    3. 客户端实现

    一、服务端编写流程

    1. 创建套接字

    2. 为套接字绑定地址信息

    3. 开始监听

    将套接字状态置为LISTEN：

            1）告诉服务器，当前socket可以开始处理连接请求。

            2）若有客户端发送连接请求过来，服务器会为客户端创建一个新的socket，这个socket负责专门与该客户端进行通信。

    4. 获取新建连接

            从已完成连接队列中取出一个新建套接字的描述符。这个描述符对应了指定的socket与指定客户端进行通信。

    5. 收发数据

    6. 关闭套接字

    二、客户端编写流程

    1. 创建套接字

    2. 为套接字绑定地址信息（不推荐）

    3. 向服务器发起连接请求

            客户端的tcp套接字中也会保存完整的五元组。

    4. 收发数据

    5. 关闭套接字

    三、相关接口

    1. 创建套接字

    int socket(int domain, int type, int protocol)；        

            domain：地址域类型：       

                    ipv4： AF_INET；

                    ipv6：AF_INET6；

            type：套接字类型：

                    SOCK_STREAM：提供字节流传输服务；

            protocol：协议类型：

                    TCP：IPPROTO_TCP；

    返回值：

            成功，返回一个套接字描述符；失败，返回-1。

    2. 为套接字绑定地址信息

    int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

            sockfd：创建套接字返回的描述符；

            addr：要绑定的地址信息结构：

                    ipv4：struct sockaddr_in;

                    ipv6：struct sockaddr_in6;

            addrlen：地址信息长度；

    返回值：

            成功，返回0；失败，返回-1。

    3. 客户端：向服务器发起连接请求

    int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

            sockfd：套接字描述符；

            *addr：服务器地址信息；

            addrlen：地址信息长度。

    返回值：

            成功，返回0；失败，返回-1。

    4. 服务端：监听接口

    int listen(int sockfd, int backlog);

            sockfd：监听套接字描述符；

            backlog：服务器端同一时间最大并发连接数。

    注意：第二个参数限制的是同一时间所能处理的最大连接请求数量，而不是服务器所能建立的总连接数量。

    在内核中，存在一个socket连接队列，其最大容量就是backlog+1。如果连接队列已满，则新到的连接请求会被丢弃。

    5. 服务端：获取新建连接

    int accept(int listen_sockfd, struct sockaddr *addr, socklen_t *addrlen);

            listen_sockfd：监听套接字，决定获取的是哪个监听套接字的新建连接；

            addr：地址结构的空间首地址，用于接收新连接的客户端地址信息；

            *addrlen：用于指定想要获取的地址长度，以及返回实际的长度。

    返回值：

            成功，返回新建连接的描述符；失败，返回-1。

    6. 收发数据

            因为tcp通信的套接字中保存了完整的五元组，所以收发数据时，不需要再指定和获取对端的地址信息。

    接收数据：

    ssize_t recv(int sockfd, char *buf, int len, int flag);

            sockfd：新建的套接字的描述符；

            buf：用于存放接收的数据的空间首地址；

            len：想要获取的数据长度；

            flag：0-阻塞接收；

    返回值：

            成功，返回实际获取到的数据长度；出错，返回-1；连接断开，返回0。

    发送数据：

    ssize_t send(int sockfd, char *data, int len, int flag);

            sockfd：新建的套接字的描述符；

            data：要发送的数据的空间首地址；

            len：要发送的数据长度；

            flag：0-默认阻塞发送；

    返回值：

            成功，返回实际发送成功的数据长度；出错，返回-1。

    7. 关闭套接字

    int close(fd);

            fd：套接字描述符。

    注：关闭套接字时，监听套接字一般不关闭，不需要与哪个客户端通信，则关闭那个对应的通信套接字即可。

    四、代码实现

    1. 头文件-套接字接口封装

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8.  
    9. //封装TCPsocket类
    10. #define MAX_LISTEN 5
    11. #define CHECK_RETURN(X) if((X) == false) {return -1;}
    12.  
    13. class TCPsocket {
    14.   private:
    15.     int _sockfd;
    16.   public:
    17.     TCPsocket () : _sockfd(-1) {}
    18.  
    19.     //1.创建套接字
    20.     bool Socket() {
    21.       _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    22.       if (_sockfd < 0) {
    23.         perror("create socket error!");
    24.         return false;
    25.       }
    26.       return true;
    27.     } 
    28.  
    29.     //2.为套接字绑定地址信息
    30.     bool Bind(const std::string &ip, uint16_t port) {
    31.       struct sockaddr_in addr;
    32.       addr.sin_family = AF_INET;
    33.       addr.sin_port = htons(port);
    34.       addr.sin_addr.s_addr = inet_addr(ip.c_str());
    35.       socklen_t len = sizeof(struct sockaddr_in);
    36.  
    37.       int ret = bind(_sockfd, (struct sockaddr*)&addr, len);
    38.       if (ret < 0) {
    39.         perror("bind error!");
    40.         return false;
    41.       }
    42.       return true;
    43.     }
    44.  
    45.     //客户端：3.向服务器发起连接请求
    46.     bool Connect(const std::string &ip, uint16_t port) {
    47.       struct sockaddr_in addr;
    48.       addr.sin_family = AF_INET;
    49.       addr.sin_port = htons(port);
    50.       addr.sin_addr.s_addr = inet_addr(ip.c_str());
    51.       socklen_t len = sizeof(struct sockaddr_in);
    52.       
    53.       int ret = connect(_sockfd, (struct sockaddr*)&addr, len);
    54.       if (ret < 0) {
    55.         perror("connect error!");
    56.         return false;
    57.       }
    58.       return true;
    59.     }
    60.  
    61.     //服务端：3.开始监听
    62.     bool Listen(int backlog = MAX_LISTEN) {
    63.       int ret = listen(_sockfd, backlog);
    64.       if (ret < 0) {
    65.         perror("connect error!");
    66.         return false;
    67.       }
    68.       return true;
    69.     }
    70.  
    71.     //服务端：4. 获取新建连接
    72.     bool Accept(TCPsocket *sock, std::string *ip = NULL, uint16_t *port = NULL) {
    73.       struct sockaddr_in addr;
    74.       socklen_t len = sizeof(struct sockaddr_in);
    75.  
    76.       int newfd = accept(_sockfd, (struct sockaddr*)&addr, &len);
    77.       if (newfd < 0) {
    78.         perror("accept error!");
    79.         return false;
    80.       }
    81.       sock -> _sockfd = newfd;
    82.  
    83.       if (ip != NULL) *ip = inet_ntoa(addr.sin_addr);
    84.       if (port != NULL) *port = ntohs(addr.sin_port);
    85.  
    86.       return true;
    87.     }
    88.  
    89.     //4. 接收数据
    90.     bool Recve(std::string *body) {
    91.       char temp[4096] = {0};
    92.  
    93.       int ret = recv(_sockfd, temp, 4095, 0);
    94.       if (ret < 0) {
    95.         perror("recve error!");
    96.         return false;
    97.       }
    98.       else if (ret == 0) {
    99.         std::cout<<"peer shutdown!"<< std::endl;
    100.         return false;
    101.       }
    102.  
    103.       body -> assign(temp, ret);
    104.       return true;
    105.     }
    106.  
    107.     //5.发送数据
    108.     bool Send(const std::string &body) {
    109.       int ret = send(_sockfd, body.c_str(), body.size(), 0);
    110.       if (ret < 0) {
    111.         perror("send error!");
    112.         return false;
    113.       }
    114.       return true;
    115.     }
    116.  
    117.     //6.关闭套接字
    118.     bool Close() {
    119.       if (_sockfd != -1) close(_sockfd);
    120.       return true;
    121.     }
    122. };

    2. 服务端实现

    2.1 多进程实现

    1. #include "socket_tcp.hpp"
    2. #include
    3.  
    4. int new_worker(TCPsocket& conn_sock) {
    5.   pid_t pid = fork();
    6.   if (pid < 0) {
    7.     perror("fork error!");
    8.     return -1;
    9.   }
    10.   else if(pid == 0){
    11.     while (1) {
    12.       std::string buf;
    13.       bool ret = conn_sock.Recve(&buf);
    14.       if (ret == false) {
    15.         conn_sock.Close();
    16.         break;
    17.       }
    18.       std::cout<<"clinet send: "<
    19.       std::cout<<"server reply: ";
    20.       fflush(stdout);
    21.       std::cin>>buf;
    22.       ret = conn_sock.Send(buf);
    23.       if (ret == false) {
    24.         conn_sock.Close();
    25.         break;
    26.       }
    27.     }
    28.     //出错，则关闭套接字，直接退出当前进程
    29.     conn_sock.Close();
    30.     exit(-1);
    31.   }
    32.   return 0;
    33. }
    34.  
    35. int main() {
    36.   signal(SIGCHLD, SIG_IGN);//或略进行退出信息；子进程退出则会直接释放资源
    37.   TCPsocket sock;
    38.   //1.创建套接字
    39.   CHECK_RETURN(sock.Socket());
    40.   //2。绑定地址信息
    41.   CHECK_RETURN(sock.Bind("192.168.247.128", 8888));
    42.   //3.开始监听
    43.   CHECK_RETURN(sock.Listen());
    44.  
    45.   while (1) {
    46.     //4.获取新建连接
    47.     TCPsocket conn_sock;
    48.     std::string client_ip;
    49.     uint16_t client_port;
    50.  
    51.     bool ret = sock.Accept(&conn_sock, &client_ip, &client_port);
    52.     if (ret == false) continue;
    53.     std::cout<<"new connect:"<"  "<
    54.  
    55.     //5.使用新建连接与客户端通信
    56.     //创建子进程负责通信
    57.     new_worker(conn_sock);
    58.     //父进程本质并不与客户端进行通信，所以父进程需要关闭该套接字,防止资源耗尽
    59.     //因为父子进程数据独有，所以父进程的关闭不会影响子进程进行通信
    60.     conn_sock.Close();
    61.   }
    62.  
    63.   //6.关闭套接字
    64.   sock.Close();
    65.  
    66.   return 0;
    67. }

    2.2 多线程实现

    1. #include "socket_tcp.hpp"
    2. #include
    3.  
    4. void *entry(void *arg) {
    5.   TCPsocket *conn_sock = (TCPsocket*)arg;
    6.   while (1) {
    7.     std::string buf;
    8.     bool ret = conn_sock->Recve(&buf);
    9.     if (ret == false) {
    10.       conn_sock->Close();
    11.       break;
    12.     }
    13.     std::cout<<"clinet send: "<
    14.     std::cout<<"server reply: ";
    15.     fflush(stdout);
    16.     std::cin>>buf;
    17.     ret = conn_sock->Send(buf);
    18.     if (ret == false) {
    19.       conn_sock->Close();
    20.       break;
    21.     }
    22.  
    23.   }
    24.   conn_sock->Close();
    25.   delete conn_sock;
    26. }
    27.  
    28. bool new_worker(TCPsocket*conn_sock) {
    29.   pthread_t tid;
    30.   int ret = pthread_create(&tid, NULL, entry, (void*)conn_sock);
    31.   if (ret != 0) {
    32.     std::cout<<"create thread error!"<
    33.     return false;
    34.   }
    35.   pthread_detach(tid);//设置分离属性，不关心返回值，退出直接释放资源
    36.   return true;
    37. }
    38.  
    39. int main() {
    40.   TCPsocket sock;
    41.   //1.创建套接字
    42.   CHECK_RETURN(sock.Socket());
    43.   //2。绑定地址信息
    44.   CHECK_RETURN(sock.Bind("192.168.247.128", 8888));
    45.   //3.开始监听
    46.   CHECK_RETURN(sock.Listen());
    47.  
    48.   while (1) {
    49.     //4.获取新建连接
    50.     TCPsocket *conn_sock = new TCPsocket();
    51.     std::string client_ip;
    52.     uint16_t client_port;
    53.  
    54.     bool ret = sock.Accept(conn_sock, &client_ip, &client_port);
    55.     if (ret == false) continue;
    56.     std::cout<<"new connect:"<"  "<
    57.  
    58.     //5.使用新建连接与客户端通信
    59.     new_worker(conn_sock);
    60.     //注意：线程间共享文件描述符表，所以这里不能关闭套接字
    61.   }
    62.  
    63.   //6.关闭套接字
    64.   sock.Close();
    65.  
    66.   return 0;
    67. }

    3. 客户端实现

    1. #include "socket_tcp.hpp"
    2.  
    3. int main(int argc, char *argv[]) {
    4.   if (argc != 3) {
    5.     std::cout<<"please add server address!"<
    6.     std::cout<<"usage: ./clinet_tcp  ip  port"<
    7.     return -1;
    8.   }
    9.  
    10.   std::string server_ip = argv[1];
    11.   uint16_t server_port = std::stoi(argv[2]);
    12.   TCPsocket sock;
    13.  
    14.   //1.创建套接字
    15.   CHECK_RETURN(sock.Socket());
    16.   //2.绑定地址信息（客户端不推荐）
    17.   //3.向服务器发起连接请求
    18.   CHECK_RETURN(sock.Connect(server_ip, server_port));
    19.   //4.与服务器通信
    20.   while (1) {
    21.     std::string buf;
    22.     std::cout<<"client send:";
    23.     fflush(stdout);
    24.     std::cin>>buf;
    25.     
    26.     //发送数据
    27.     bool ret = sock.Send(buf);
    28.     if (ret == false) {
    29.       perror("send error!");
    30.       sock.Close();
    31.       return -1;
    32.     }
    33.  
    34.     //接收数据
    35.     buf.clear();
    36.     ret = sock.Recve(&buf);
    37.     if (ret == false) {
    38.       perror("recve error!");
    39.       sock.Close();
    40.       return -1;
    41.     }
    42.     std::cout<<"server reply:"<< buf << std::endl;
    43.   }
    44.   //5.关闭套接字
    45.   sock.Close();
    46.   return 0;
    47. }

  • 相关阅读:
    Go 语言变量
    ＜C++＞【入门篇】
    Wordpress - Xydown独立下载页面插件
    嵌入式Linux裸机开发（三）SDK移植及BSP管理
    DJYOS开源往事三：DJYOS源码发布网络实证
    Linux 中的 chage 命令及示例
    （附源码）ssm基于web技术的医务志愿者管理系统 毕业设计 100910
    深度解析：为何在 SwiftUI 视图的 init 初始化器里无法更改 @State 的值？
    Java 并发编程解析 | 如何正确理解Java领域中的并发锁，我们应该具体掌握到什么程度？
    支持向量机(SVM)----sklearn库的应用
  • 原文地址：https://blog.csdn.net/m0_63020222/article/details/127574155