• TCP 通信流程详解（附有案例代码）

    一、TCP、UDP间的关系

    TCP 和 UDP -> 传输层的协议：

    UDP：用户数据报协议，面向无连接，可以单播，多播，广播， 面向数据报，不可靠

    TCP：传输控制协议，面向连接的，可靠的，基于字节流，仅支持单播传输

                                                    UDP                                                 TCP

    是否创建连接                         无连接                                           面向连接

    是否可靠                                不可靠                                             可靠的

    连接的对象个数       一对一、一对多、多对一、多对多            支持一对一

    传输的方式                         面向数据报                                     面向字节流

    首部开销                               8个字节                                      最少20个字节

    适用场景                 实时应用（视频会议，直播）         可靠性高的应用（文件传输）

    二、TCP通信的流程

    1、服务器端（被动接收连接的角色） 

    （1）创建一个用于监听的套接字

            - 监听：监听有客户端的连接

            - 套接字：这个套接字其实就是一个文件描述符

    （2）将这个监听文件描述符和本地的IP和端口绑定（IP和端口就是服务器的地址信息）

            - 客户端连接服务器的时候使用的就是这个IP和端口

    （3）设置监听，监听的fd开始工作

    （4） 阻塞等待，当有客户端发起连接，解除阻塞，接受客户端的连接，会得到一个和客户端通信的套接字（fd）

    （5）通信

            - 接收数据

            - 发送数据

    （6）通信结束，断开连接 

    2、客户端

    （1）创建一个用于通信的套接字（fd）

    （2）连接服务器，需要指定连接的服务器的 IP 和 端口

    （3）连接成功了，客户端可以直接和服务器通信

            - 接收数据

            - 发送数据

    （4） 通信结束，断开连接

    3、TCP通信流程图

     三、套接字函数

    1. #include  
    2. #include  
    3. #include  // 包含了这个头文件，上面两个就可以省略 
    4. int socket(int domain, int type, int protocol); 
    5. - 功能：创建一个套接字 
    6. - 参数：
    7.     - domain: 协议族
    8.         AF_INET : ipv4 
    9.         AF_INET6 : ipv6 
    10.         AF_UNIX, AF_LOCAL : 本地套接字通信（进程间通信） 
    11.     - type: 通信过程中使用的协议类型 
    12.         SOCK_STREAM : 流式协议 
    13.         SOCK_DGRAM : 报式协议 
    14.     - protocol : 具体的一个协议。一般写0 
    15.         - SOCK_STREAM : 流式协议默认使用 TCP 
    16.         - SOCK_DGRAM : 报式协议默认使用 UDP 
    17. - 返回值： 
    18.     - 成功：返回文件描述符，操作的就是内核缓冲区。 
    19.     - 失败：-1 
    20.  
    21. int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen); // socket命 名 
    22. - 功能：绑定，将fd 和本地的IP + 端口进行绑定 
    23. - 参数： 
    24.     - sockfd : 通过socket函数得到的文件描述符 
    25.     - addr : 需要绑定的socket地址，这个地址封装了ip和端口号的信息 - addrlen : 第二个参数结构体        
    26. 占的内存大小 
    27.  
    28. int listen(int sockfd, int backlog); // /proc/sys/net/core/somaxconn 
    29. - 功能：监听这个socket上的连接 
    30. - 参数：
    31.     - sockfd : 通过socket()函数得到的文件描述符 
    32.     - backlog : 未连接的和已经连接的和的最大值， 5 
    33.  
    34. int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); 
    35. - 功能：接收客户端连接，默认是一个阻塞的函数，阻塞等待客户端连接 
    36. - 参数： 
    37.     - sockfd : 用于监听的文件描述符 
    38.     - addr : 传出参数，记录了连接成功后客户端的地址信息（ip，port） 
    39.     - addrlen : 指定第二个参数的对应的内存大小 - 返回值：- 成功 ：用于通信的文件描述符 - -1 ： 失败 
    40.  
    41. int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
    42. - 功能： 客户端连接服务器 
    43. - 参数： 
    44.     - sockfd : 用于通信的文件描述符 
    45.     - addr : 客户端要连接的服务器的地址信息 
    46.     - addrlen : 第二个参数的内存大小 
    47. - 返回值：
    48.     成功 0， 
    49.     失败 -1 
    50.  
    51. ssize_t write(int fd, const void *buf, size_t count); // 写数据 
    52. ssize_t read(int fd, void *buf, size_t count); // 读数据

    四、TCP通信案例

    1、服务器端

    1. // TCP 通信的服务器端
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. int main() {
    10.  
    11.     // 1.创建socket(用于监听的套接字)
    12.     int lfd = socket(AF_INET, SOCK_STREAM, 0);
    13.  
    14.     if(lfd == -1) {
    15.         perror("socket");
    16.         exit(-1);
    17.     }
    18.  
    19.     // 2.绑定（IP地址和端口）
    20.     struct sockaddr_in saddr;
    21.     saddr.sin_family = AF_INET;
    22.     // inet_pton(AF_INET, "192.168.193.128", saddr.sin_addr.s_addr);    //指定具体网卡
    23.     saddr.sin_addr.s_addr = INADDR_ANY;  // 0.0.0.0 同时绑定多个网卡，使用哪个都可以
    24.     saddr.sin_port = htons(9999);
    25.     int ret = bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
    26.  
    27.     if(ret == -1) {
    28.         perror("bind");
    29.         exit(-1);
    30.     }
    31.  
    32.     // 3.监听
    33.     ret = listen(lfd, 8);
    34.     if(ret == -1) {
    35.         perror("listen");
    36.         exit(-1);
    37.     }
    38.  
    39.     // 4.接收客户端连接
    40.     struct sockaddr_in clientaddr;
    41.     int len = sizeof(clientaddr);
    42.     int cfd = accept(lfd, (struct sockaddr *)&clientaddr, &len);
    43.     
    44.     if(cfd == -1) {
    45.         perror("accept");
    46.         exit(-1);
    47.     }
    48.  
    49.     // 输出客户端的信息
    50.     char clientIP[16];
    51.     inet_ntop(AF_INET, &clientaddr.sin_addr.s_addr, clientIP, sizeof(clientIP));
    52.     unsigned short clientPort = ntohs(clientaddr.sin_port);
    53.     printf("client ip is %s, port is %d\n", clientIP, clientPort);
    54.  
    55.     // 5.通信
    56.     char recvBuf[1024] = {0};
    57.     while(1) {
    58.         
    59.         // 获取客户端的数据
    60.         int num = read(cfd, recvBuf, sizeof(recvBuf));
    61.         if(num == -1) {
    62.             perror("read");
    63.             exit(-1);
    64.         } else if(num > 0) {
    65.             printf("recv client data : %s\n", recvBuf);
    66.         } else if(num == 0) {
    67.             // 表示客户端断开连接
    68.             printf("clinet closed...");
    69.             break;
    70.         }
    71.  
    72.         char * data = "hello,i am server";
    73.         // 给客户端发送数据
    74.         write(cfd, data, strlen(data));
    75.     }
    76.    
    77.     // 关闭文件描述符
    78.     close(cfd);
    79.     close(lfd);
    80.  
    81.     return 0;
    82. }

    2、客户端

    1. // TCP通信的客户端
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. int main() {
    10.  
    11.     // 1.创建套接字
    12.     int fd = socket(AF_INET, SOCK_STREAM, 0);
    13.     if(fd == -1) {
    14.         perror("socket");
    15.         exit(-1);
    16.     }
    17.  
    18.     // 2.连接服务器端
    19.     struct sockaddr_in serveraddr;
    20.     serveraddr.sin_family = AF_INET;
    21.     inet_pton(AF_INET, "192.168.193.128", &serveraddr.sin_addr.s_addr);
    22.     serveraddr.sin_port = htons(9999);
    23.     int ret = connect(fd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
    24.  
    25.     if(ret == -1) {
    26.         perror("connect");
    27.         exit(-1);
    28.     }
    29.  
    30.     
    31.     // 3. 通信
    32.     char recvBuf[1024] = {0};
    33.     while(1) {
    34.  
    35.         char * data = "hello,i am client";
    36.         // 给客户端发送数据
    37.         write(fd, data , strlen(data));
    38.  
    39.         sleep(1);
    40.         
    41.         int len = read(fd, recvBuf, sizeof(recvBuf));
    42.         if(len == -1) {
    43.             perror("read");
    44.             exit(-1);
    45.         } else if(len > 0) {
    46.             printf("recv server data : %s\n", recvBuf);
    47.         } else if(len == 0) {
    48.             // 表示服务器端断开连接
    49.             printf("server closed...");
    50.             break;
    51.         }
    52.  
    53.     }
    54.  
    55.     // 关闭连接
    56.     close(fd);
    57.  
    58.     return 0;
    59. }

    说明：在两个函数编译好后，在会话窗口1，先执行服务器端函数，他会阻塞等待；复制会话在新会话窗口执行客户端，开始通信； 

  • 相关阅读:
    vsCode 格式化配置
    Java学习笔记_No.1
    K8s: 在Pod中使用亲和性调度节点
    HTML期末学生大作业-使用HTML+CSS技术仿传智博客网站
    WebDAV之葫芦儿·派盘+FV管理器
    基于JavaWeb的大学社团管理系统的设计与实现
    Android 日期筛选器
    Pytest 的高级用法之插件开发
    【Unity每日一记】资源加载相关和检测相关
    Web版RSS阅读器yarr
  • 原文地址：https://blog.csdn.net/weixin_47156401/article/details/125884879