当前位置:   article > 正文

【Linux系统编程】TCP通信&基于TCP实现多进程/线程并发服务器_如何在tcp、udp中加入多线程、多进程?

如何在tcp、udp中加入多线程、多进程?

1. TCP通信流程

TCP vs. UDP

TCP 和 UDP -> 传输层的协议

  • UDP:用户数据报协议,面向无连接,可以单播,多播,广播,面向数据报,不可靠;效率高
  • TCP:传输控制协议,面向连接的,仅支持单播传输,基于字节流,可靠的。
UDPTCP
是否创建连接无连接面向连接
是否可靠不可靠可靠的
连接的对象个数一对一、一对多、多对一、多对多支持一对一
传输的方式面向数据报面向字节流
首部开销8个字节最少20个字节
适用场景实时应用(视频会议,直播)可靠性高的应用(文件传输)

在这里插入图片描述

TCP通信的流程:

  • 服务器端(被动接受连接的角色)

    1. 创建一个用于监听套接字

      ​ - 监听:监听有客户端的连接

      ​ - 套接字:这个套接字其实就是一个文件描述符(读:接收数据;写:发送数据)

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

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

    3. 设置监听,监听的 fd开始工作

    4. 阻塞等待,当有客户端发起连接,解除阻塞,接受客户端的连接,会得到一个用于和客户端通信的套接字(fd)

    5. 通信

      ​ - 接收数据

      ​ - 发送数据

    6. 通信结束,断开连接

  • 客户端

    1. 创建一个用于通信的套接字(fd)

    2. 连接服务器,需要指定连接的服务器的 IP 和 端口

    3. 连接成功了,客户端可以直接和服务器通信

      • 接收数据

      • 发送数据

    4. 通信结束,断开连接

2. 套接字函数

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

实现TCP通信 (回射服务器)

案例:实现TCP通信 服务端/客户端 并实现手动从客户端输入并从服务端返回相同内容(“回射服务器”)

(但是只能接受一个客户端通信)

// TCP通信 客户端
#include <stdio.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
int main()
{
    // 1. 创建套接字
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    // 2. 连接服务器端
    struct sockaddr_in serverAddr;
    serverAddr.sin_port = htons(9999);
    serverAddr.sin_family = AF_INET;
    inet_pton(AF_INET, "192.168.241.128", &serverAddr.sin_addr.s_addr);
    int ret = connect(fd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
    if(ret == -1)
    { 
        perror("connect");
        exit(-1);
    }
    // 3. 通信
    char recvBuf[1024] = {0};
    char data[1024] = {0};
    while(1)
    {
        // char * data = "hello, i am client";
        memset(data, 0, 1024); // 将data内容清空
        // 获取标准输入的数据
        fgets(data, 1024, stdin);
        // 发送给客户端数据
        write(fd, data, strlen(data));
        // 获取服务器端的数据
        memset(recvBuf, 0, 1024); // 将recvBuf内容清空
        int len = read(fd, recvBuf, sizeof(recvBuf));
        if(len == -1)
        {
            perror("read");
            exit(-1);
        }
        else if(len > 0) printf("recv server data: %s\n", recvBuf);
        else if(len == 0)
        {
            // 表示服务器端断开连接
            printf("server closed...");
            break;
        }
    }
    // 关闭连接
    close(fd);
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
// TCP 通信的服务器端
#include <stdio.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
int main()
{
    // 1. 创建用于监听的套接字
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if(lfd == -1)
    {
        perror("soclet");
        exit(-1);
    }
    // 2. 绑定 对应的IP地址和端口号port
    struct sockaddr_in saddr;
    saddr.sin_family = PF_INET;
    // inet_pton(AF_INET, "192.168.241.128", &saddr.sin_addr.s_addr);
    // 计算机有多个网卡 无线网卡、以太网卡... 
    // IP地址也都不同
    // saddr.sin_addr.s_addr = 0; 表示所有网卡都绑定 客户端连接任何IP都可以访问到主机
    saddr.sin_addr.s_addr = INADDR_ANY; // 0.0.0.0
    saddr.sin_port = htons(9999);
    int ret = bind(lfd, (struct sockaddr *) &saddr, sizeof(saddr));
    if(ret == -1)
    {
        perror("bind");
        exit(-1);
    }
    // 3. 监听是否有客户端连接
    ret = listen(lfd, 8);
    if(ret == -1)
    {
        perror("listen");
        exit(-1);
    }
    // 4. 接收客户端连接
    struct sockaddr_in clientaddr;
    socklen_t sock_len = sizeof(clientaddr);
    int cfd = accept(lfd, (struct sockaddr *) &clientaddr, &sock_len);
    if(cfd == -1)
    {
        perror("accept");
        exit(-1);
    }
    // 5. 输出客户端信息
    char clientIP[16];
    inet_ntop(AF_INET, &clientaddr.sin_addr.s_addr, clientIP, sizeof(clientIP));
    unsigned short clientPort = ntohs(clientaddr.sin_port);
    printf("client ip is %s, port is %d\n", clientIP, clientPort);
    // 5. 
    // 获取客户端的数据
    char recvBuf[1024] = {0};
    while(1)
    {
        memset(recvBuf, 0, 1024);
        int len = read(cfd, recvBuf, sizeof(recvBuf));
        if(len == -1)
        {
            perror("read");
            exit(-1);
        }
        else if(len > 0)  printf("recv client data: %s\n", recvBuf);
        else if(len == 0)
        {
            // 表示客户端断开连接
            printf("client closed...\n");
            break;
        }
        // char * data = "hello, i am server";
        // 发送给客户端数据
        write(cfd, recvBuf, strlen(recvBuf));
    }
    // 关闭文件描述符
    close(cfd);
    close(lfd);
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79

3. TCP 三次握手***

  • TCP 是一种面向连接的单播协议,在发送数据前,通信双方必须在彼此间建立一条连接。所谓的“连接”,其实是客户端和服务器的内存里保存的一份关于对方的信息,如 IP 地址、端口号等。
  • TCP 可以看成是一种字节流,它会处理 IP 层或以下的层的丢包、重复以及错误问题。在连接的建立过程中,双方需要交换一些连接的参数。这些参数可以放在 TCP 头部。
  • TCP 提供了一种可靠、面向连接、字节流、传输层的服务,采用三次握手建立一个连接。采用四次挥手来关闭一个连接。
    • 三次握手的目的:保证双方互相建立了连接

      • (为什么要三次握手而不是两次):确认客户端 和 服务端 的信息收发功能正常。
    • 三次握手发生在客户端连接的时候,当调用connect()时,底层会通过TCP协议进行三次握手。

在这里插入图片描述

  • 16 位端口号(port number):告知主机报文段是来自哪里(源端口)以及传给哪个上层协议或应用程序(目的端口)的。进行 TCP 通信时,客户端通常使用系统自动选择的临时端口号。

  • 32 位序号(sequence number):一次 TCP 通信(从 TCP 连接建立到断开)过程中某一个传输方向上的字节流的每个字节的编号。

    • 假设主机 A 和主机 B 进行 TCP 通信,A 发送给 B 的第一个 TCP 报文段中,序号值被系统初始化为某个随机值 ISN(Initial Sequence Number,初始序号值)(生成规则?)。那么在该传输方向上(从 A 到 B),后续的 TCP 报文段中序号值将被系统设置成 ISN 加上该报文段所携带数据的第一个字节在整个字节流中的偏移。例如,某个 TCP 报文段传送的数据是字节流中的第 1025 ~ 2048 字节,那么该报文段的序号值就是 ISN + 1025。另外一个传输方向(从 B 到 A)的 TCP 报文段的序号值也具有相同的含义。
  • 32 位确认号(acknowledgement number):用作对另一方发送来的 TCP 报文段的响应。其值是收到的 TCP 报文段的序号值 + 标志位长度(SYN,FIN) + 数据长度。假设主机 A 和主机 B 进行 TCP 通信,那么 A 发送出的 TCP 报文段不仅携带自己的序号,而且包含对 B 发送来的 TCP 报文段的确认号。反之,B 发送出的 TCP 报文段也同样携带自己的序号和对 A 发送来的报文段的确认序号。

    • 只有收到对方的报文段 ACK/FIN 其中一个标志位置1,自己发送时ack = 收到的 TCP 报文段的序号值 + 1

    • 只有ACK置为1,对应的ack序号才有效。

  • 4 位头部长度(head length):标识该 TCP 头部有多少个 32 bit(4 字节)。因为 4 位最大能表示 15,所以 TCP 头部最长是60 字节。

  • 6 位标志位包含如下几项:

    • URG 标志,表示紧急指针(urgent pointer)是否有效。

    • ACK 标志,表示确认号是否有效。我们称携带 ACK 标志的 TCP 报文段为确认报文段。

    • PSH 标志,提示接收端应用程序应该立即从 TCP 接收缓冲区中读走数据,为接收后续数据腾出空间(如果应用程序不将接收到的数据读走,它们就会一直停留在 TCP 接收缓冲区中)。

    • RST 标志,表示要求对方重新建立连接。我们称携带 RST 标志的 TCP 报文段为复位报文段。

    • SYN 标志,表示请求建立一个连接。我们称携带 SYN 标志的 TCP 报文段为同步报文段。

    • FIN 标志,表示通知对方本端要关闭连接了。我们称携带 FIN 标志的 TCP 报文段为结束报文段。

    • 16 位窗口大小(window size):是 TCP 流量控制的一个手段。这里说的窗口,指的是接收通告窗口(Receiver Window,RWND)。它告诉对方本端的 TCP 接收缓冲区还能容纳多少字节的数据,这样对方就可以控制发送数据的速度。

    • 16 位校验和(TCP checksum):由发送端填充,接收端对 TCP 报文段执行 CRC 算法以校验 TCP 报文段在传输过程中是否损坏。注意,这个校验不仅包括 TCP 头部,也包括数据部分。这也是 TCP 可靠传输的一个重要保障。

    • 16 位紧急指针(urgent pointer):是一个正的偏移量。它和序号字段的值相加表示最后一个紧急数据的下一个字节的序号。因此,确切地说,这个字段是紧急指针相对当前序号的偏移,不妨称之为紧急偏移。TCP 的紧急指针是发送端向接收端发送紧急数据的方法。

在这里插入图片描述
在这里插入图片描述

  • 第一次握手:

    • 客户端将SYN标志置为1

    • 生成一个随机的32位序号seq = J

      (这个序号后面可以显示携带数据的大小 eg. seq = 1001(100) -> seq = 1101)

  • 第二次握手

    • 服务器端接收客户端的连接:ACK = 1
    • 服务器回发确认序号:ack = 客户端的序号 + 数据长度 + SYN/FIN(按一个字节来算,确保数据安全性)
    • 服务器端会向客户端发起连接请求:SYN = 1
    • 服务器会生成一个随机序号:seq = K
  • 第三次握手

    • 客户端应答服务器的连接请求:ACK = 1
    • 客户端回复收到了服务器端的数据:ack = 服务端的序号 + 数据长度 + SYN/FIN(按一个字节来算,确保数据安全性)

4. TCP 滑动窗口

  • 滑动窗口(Sliding window)是一种流量控制技术。早期的网络通信中,通信双方不会考虑网络的拥挤情况直接发送数据。由于大家不知道网络拥塞状况,同时发送数据,导致中间节点阻塞掉包,谁也发不了数据,所以就有了滑动窗口机制来解决此问题。滑动窗口协议是用来改善吞吐量的一种技术,即容许发送方在接收任何应答之前传送附加的包。接收方告诉发送方在某一时刻能送多少包(称窗口尺寸)。

  • TCP 中采用滑动窗口来进行传输控制,滑动窗口的大小意味着接收方还有多大的缓冲区可以用于接收数据。发送方可以通过滑动窗口的大小来确定应该发送多少字节的数据。当滑动窗口为 0时,发送方一般不能再发送数据报。

  • 滑动窗口是 TCP 中实现诸如 ACK 确认、流量控制、拥塞控制的承载结构。

  • 窗口理解为缓冲区的大小。

  • 滑动窗口的大小会随着发送数据和接收数据而变化。

  • 通信的双方都有发送缓冲区和接收数据的缓冲区。

    • 服务器:
      • 发送缓冲区(发送缓冲区的窗口)
      • 接收缓冲区(接收缓冲区的窗口)
    • 客户端:
      • 发送缓冲区(发送缓冲区的窗口)
      • 接收缓冲区(接收缓冲区的窗口)

  • 发送方的缓冲区:
    • 白色格子:空闲空间
    • 灰色格子:数据已经被发送,但是还没有被接收。
    • 紫色格子:还没有发送出去的数据
  • 接收方的缓冲区
    • 白色格子:空闲空间
    • 紫色格子:已经接受到的数据

在这里插入图片描述

# mss:Maximum Segment Size(一条数据(报文段)的最大数据量)
# win:滑动窗口的大小  单位:字节
1. 客户端向服务器发起连接,客户端的滑动窗口是4096B,一次发送的报文段最大数据量是1460B
2. 服务器端接受连接情况,告诉客户端 服务器端的窗口大小是6144B,一次发送的报文段最大数据量是1024B
3. 第三次握手...
4-9. 客户端连续给服务器端发送了6KB的数据,每次报文段大小为1024B
10. 服务器端告诉客户端:发送的6K数据已经接收到,存储在缓冲区中,缓冲区数据已经处理了2KB,窗口大小是2KB
11. 服务器端告诉客户端:发送的6K数据已经接收到,存储在缓冲区中,缓冲区数据已经处理了4KB,窗口大小是4KB
12. 客户端给服务器端发送了1024B的数据
13. 第一次挥手,客户端主动请求和服务器断开连接 FIN = 1,并且给服务器端发送了1KB的数据
14. 第二次挥手,服务器端回复ACK 8194(1) 确认断开连接的请求 (2) 告诉客户端已经接受到刚才发的2KB的数据 (3) 滑动窗口大小是2KB
15-16. 通知客户端滑动窗口的大小。
17. 第三次挥手,服务器端给客户端发送FIN = 1,请求断开连接。
18. 第四次挥手,客户端确认服务器端的断开请求。
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

注意:

  • 第一次握手,发送方不能发送数据(不包括TCP文件头);

    第二次握手,接收方不能发送数据(只能完成三次握手后);

    第三次握手,发送方就可以发送数据了

  • 主动发送断开请求FIN的一方,在收到对方确认后,就不能再主动发送数据。但是可以再接收数据。

5. TCP 四次挥手

四次挥手:发生在断开连接的时候,在程序中当调用了close()会使用TCP协议进行4次挥手。

客户端和服务器端都可以主动发起断开连接,谁先调用close()谁就发起。

因为在TCP连接的时候,采用三次握手建立的连接是双向的,在断开的时候也需要双向断开。

在这里插入图片描述

在这里插入图片描述

6. TCP 通信并发

要实现TCP通信服务器处理并发的任务,使用多线程/多进程解决。

思路:

  1. 一个父进程,多个子进程
  2. 父进程负责等待并接受客户端的连接
  3. 子进程:完成通信。接受一个客户端的连接,就创建一个子进程用于通信

基于多进程实现并发服务器

// 服务器端
#define _DEFAULT_SOURCE
#include <stdio.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>

void recycleChild(int arg)
{
    while(1)
    {
        int ret = waitpid(-1, NULL, WNOHANG);
        if(ret == -1)
        {
            // 所有的子进程都回收完了
            break;
        }
        else if(ret == 0)
        {
            // 还有子进程活着
            break;
        }
        else if(ret > 0)
        {
            // 一个子进程被回收了
            printf("子进程 %d 被回收了\n", ret);
        }
    }
}

int main()
{
    // 注册信号捕捉
    struct sigaction act;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    act.sa_handler = recycleChild;
    sigaction(SIGCHLD, &act, NULL);
    // 创建socket
    int lfd = socket(PF_INET, SOCK_STREAM, 0);
    if(lfd == -1)
    {
        perror("socket");
        exit(-1);
    }
    // 绑定
    struct sockaddr_in seraddr;
    seraddr.sin_port = htons(9999);
    seraddr.sin_family = AF_INET;
    seraddr.sin_addr.s_addr = INADDR_ANY;
    int ret = bind(lfd, (struct sockaddr *)&seraddr, sizeof(seraddr));
    if(ret == -1)
    {
        perror("bind");
        exit(-1);
    }
    // 监听
    ret = listen(lfd, 128);
    if(ret == -1)
    {
        perror("listen");
        exit(-1);
    }
    // 循环等待客户端连接
    while(1)
    {
        // 接受连接
        struct sockaddr_in cliaddr;
        socklen_t len = sizeof(cliaddr);
        /*
        主进程可以考虑close(cfd), 因为linux系统默认最多只能开1024个文件,
        即使更改后也有4096的最高上限数量,我之前在进行65535个端口扫描时发现不及时close是会溢出报错的
        */
        int cfd = accept(lfd, (struct sockaddr *)&cliaddr,&len); 
        /* 
        如果某个子进程退出,那么主进程会收到信号SIGCHLD调用回调函数,触发软中断,
        当执行完回调函数后,回到accept()(之前主进程被阻塞的位置上),accept()会报错,返回EINTR错误
        */ 
        if(cfd == -1)
        {
            if(errno == EINTR) continue; // 如果返回EINTR错误,重新进行循环
            perror("accept");
            exit(-1);
        }
        // 每一个连接进来的客户端,就创建一个子进程和客户端通信
        pid_t pid = fork();
        if(pid > 0) continue;
        else if(pid == 0)
        {
            // 子进程
            // 获取客户端的信息
            char cliIP[16];
            inet_ntop(AF_INET, &cliaddr.sin_addr.s_addr, cliIP, sizeof(cliIP));
            unsigned short cliPort = ntohs(cliaddr.sin_port);
            printf("client ip is: %s, port is: %d\n", cliIP, cliPort);

            // 接收客户端发来的数据
            char recvBuf[1024] = {0};
            while(1)
            {
                int len = read(cfd, &recvBuf, sizeof(recvBuf));
                if(len == -1)
                {
                    perror("read");
                    exit(-1);
                }
                else if(len > 0)
                {
                    printf("recv clinet data: %s\n", recvBuf);
                    // strlen在计数的时候是结束符'\0'为止,但不包含结束符。
                    write(cfd, recvBuf, strlen(recvBuf) + 1); // +1 把结束符也发送出去
                }
                else if(len == 0)
                {
                    printf("client closed...\n");
                    break;
                }
            }
            close(cfd);
            exit(0);
        }
    }
    close(lfd);
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130

客户端:同之前的TCP通信(回射服务器)

// TCP通信 客户端
#include <stdio.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

int main()
{
    // 1. 创建套接字
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    // 2. 连接服务器端
    struct sockaddr_in serverAddr;
    serverAddr.sin_port = htons(9999);
    serverAddr.sin_family = AF_INET;
    inet_pton(AF_INET, "192.168.241.128", &serverAddr.sin_addr.s_addr);
    int ret = connect(fd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
    if(ret == -1)
    { 
        perror("connect");
        exit(-1);
    }
    // 3. 通信
    char recvBuf[1024] = {0};
    char data[1024] = {0};
    int i = 0;
    while(1)
    {
        memset(data, 0, 1024); // 将data内容清空
        // 获取标准输入的数据
        //fgets(data, 1024, stdin);
        sprintf(data, "%d\n", i++); 
        // 发送给客户端数据
        // 发送的时候不会将 \n 发送出去 因为strlen在计数的时候是结束符'\0'为止,但不包含结束符。
        // 所以write(fd, data, strlen(data) + 1); 要+1
        write(fd, data, strlen(data) + 1);
        sleep(1);
        // 获取服务器端的数据
        memset(recvBuf, 0, 1024); // 将recvBuf内容清空
        int len = read(fd, recvBuf, sizeof(recvBuf));
        if(len == -1)
        {
            perror("read");
            exit(-1);
        }
        else if(len > 0){
            printf("recv server data: %s\n", recvBuf);
        }
        else if(len == 0)
        {
            // 表示服务器端断开连接
            printf("server closed...\n");
            break;
        }
    }
    // 关闭连接
    close(fd);
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59

注意:

  • 发送数据:发送的时候不会将 \n 发送出去,因为strlen在计数的时候是结束符’\0’为止,但不包含结束符

    所以write(fd, data, strlen(data) + 1); 要+1

  • 我们设置信号捕捉函数来捕捉SIGCHLD信号,用于子进程结束通信退出,回收子进程资源。

  • 如果某个子进程退出,那么主进程会收到信号SIGCHLD调用回调函数,触发软中断,

    当执行完回调函数后,回到accept()(之前主进程被阻塞的位置上),accept()会报错,返回EINTR错误

    解决办法:可以设置 if(errno == EINTR) continue; // 如果返回EINTR错误,重新进行循环

  • 主进程可以考虑close(cfd), 因为linux系统默认最多只能开1024个文件,

    即使更改后也有4096的最高上限数量,之前在进行65535个端口扫描时发现不及时close是会溢出报错的

基于多线程实现并发服务器

从多进程转为多线程会有很多问题:

  • 首先多进程,父子进程的内存空间关系是“读时共享,写时拷贝”;而多线程之间的内存空间关系是,内核空间中大部分资源都是共享的(除了线程ID 阻塞信号集),用户空间除了.text和栈都是共享的

这会造成如下问题:

  • 我们在pthread_create()只能向目标线程运行函数传递一个参数(void*) arg,但是我们可能会需要很多参数,包括与客户端通信的fd,线程tid,客户端的socket地址结构体等等…因此需要建立一个结构体讲这些参数封装一起传过去。

  • 我们在while()循环中创建结构体,这个结构体是创建在主线程的栈中,在子线程运行过程中如果主线程退出while()循环释放资源会造成错误。

  • 即使我们可以在堆中创建结构体(malloc()),但是我们需要手动释放资源;并且如果线程数过大,我们需要申请许多线程,所需的资源巨大。

  • 结构体变量不能直接简单赋值,需要将其对应的内部变量分别进行赋值;或者使用memcpy()函数

  • pthread_t tid 在创建结构体变量之后,调用pthread_create()之前还没有初始化

    解决方案: 直接将pinfo->tid的地址传进 pthread_create(),不另外设置

服务器端:

#include <stdio.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <strings.h>
#include <sys/types.h>
#include <pthread.h>
struct sockInfo{
    int fd; // 通信的文件描述符
    pthread_t tid; // 线程号
    struct sockaddr_in addr; //客户端的socket地址结构体
};
struct sockInfo sockinfos[128]; // 同时最大连接线程数128
void * working(void* arg)
{
    // 和客户端通信
    // 获取客户端的信息
    struct sockInfo* pinfo = (struct sockInfo*) arg;
    char cliIP[16];
    inet_ntop(AF_INET, &pinfo->addr.sin_addr.s_addr, cliIP, sizeof(cliIP));
    unsigned short cliPort = ntohs(pinfo->addr.sin_port);
    printf("client ip is: %s, port is: %d\n", cliIP, cliPort);
    // 接收客户端发来的数据
    char recvBuf[1024];
    while(1)
    {
        int len = read(pinfo->fd, &recvBuf, sizeof(recvBuf));
        if(len == -1)
        {
            perror("read");
            exit(-1);
        }
        else if(len > 0)
        {
            printf("recv clinet data: %s\n", recvBuf);
            // strlen在计数的时候是结束符'\0'为止,但不包含结束符。
            write(pinfo->fd, recvBuf, strlen(recvBuf) + 1); // +1 把结束符也发送出去
        }
        else if(len == 0)
        {
            printf("client closed...\n");
            break;
        }
    }
    close(pinfo->fd);
    pinfo->fd = -1;
    return NULL;
}
int main()
{
    // 创建socket
    int lfd = socket(PF_INET, SOCK_STREAM, 0);
    if(lfd == -1)
    {
        perror("socket");
        exit(-1);
    }
    // 绑定
    struct sockaddr_in seraddr;
    seraddr.sin_port = htons(9999);
    seraddr.sin_family = AF_INET;
    seraddr.sin_addr.s_addr = INADDR_ANY;
    int ret = bind(lfd, (struct sockaddr *)&seraddr, sizeof(seraddr));
    if(ret == -1)
    {
        perror("bind");
        exit(-1);
    }
    // 监听
    ret = listen(lfd, 128);
    if(ret == -1)
    {
        perror("listen");
        exit(-1);
    }
    // 初始化数据
    int max = sizeof(sockinfos) / sizeof(sockinfos[0]);
    for(int i = 0; i < max; i++)
    {
        bzero(&sockinfos[i], sizeof(sockinfos[i]));
        sockinfos[i].fd = -1; // -1表示该sockinfos[i]空闲 否则占用中
        sockinfos[i].tid = -1;
    }
    // 循环等待客户端连接
    // 一旦一个客户端连接进来,就创建一个子线程创建连接
    while(1)
    {
        // 接受连接
        struct sockaddr_in cliaddr;
        socklen_t len = sizeof(cliaddr);
        int cfd = accept(lfd, (struct sockaddr*) &cliaddr, &len);
        // 创建子线程
        struct sockInfo * pinfo;
        for(int i = 0; i < max; ++i)
        {
            // 从数组中找到一个可用的sockinfos[i]
            if(sockinfos[i].fd == -1)
            {
                pinfo = &sockinfos[i];
                break;
            }
            if(i == max - 1)
            {
                // 当前sockinfos[i]都被占用 需等待...
                sleep(1);
                printf("当前连接链路被占用 需等待...");
                i = -1;
            }
        }
        pinfo->fd = cfd;
        memcpy(&pinfo->addr, &cliaddr, len);
        // 创建子线程
        pthread_create(&pinfo->tid, NULL, working, pinfo);
        // 设置线程分离 自主释放资源
        pthread_detach(pinfo->tid);
    }
    close(lfd);
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120

7. TCP 状态转换

在这里插入图片描述

注意:

  • 在第二次挥手和第三次挥手期间,服务器端(被动关闭方)是可以继续发送数据给对方,直到都发送完毕再进行第三次挥手申请断开连接。

  • 半连接队列(SYN队列),服务端收到第一次握手后,会将sock加入到这个队列中,队列内的sock都处于SYN_RCVD 状态。

  • 全连接队列(ACCEPT队列),在服务端收到第三次握手后,会将半连接队列的sock取出,放到全连接队列中。队列里的sock都处于 ESTABLISHED状态。这里面的连接,就等着服务端执行accept()后被取出了

在这里插入图片描述

  • 2MSL(Maximum Segment Lifetime)

    主动断开连接的一方, 最后进出入一个 TIME_WAIT状态, 这个状态会持续: 2msl

    • msl: 官方建议: 2分钟, 实际是30s

      当 TCP 连接主动关闭方接收到被动关闭方发送的 FIN 和最终的 ACK 后,连接的主动关闭方必须处于TIME_WAIT 状态并持续 2MSL 时间。

      这样就能够让 TCP 连接的主动关闭方在它发送的 ACK 丢失的情况下重新发送最终的 ACK。

      主动关闭方重新发送的最终 ACK 并不是因为被动关闭方重传了 ACK(它们并不消耗序列号,被动关闭方也不会重传),而是因为被动关闭方重传了它的 FIN。事实上,被动关闭方总是重传 FIN 直到它收到一个最终的 ACK。

  • 半关闭

    当 TCP 链接中 A 向 B 发送 FIN 请求关闭,另一端 B 回应 ACK 之后(A 端进入 FIN_WAIT_2状态),并没有立即发送 FIN 给 A,A 方处于半连接状态(半开关),此时 A 可以接收 B 发送的数据,但是 A 已经不能再向 B 发送数据。

从程序的角度,可以使用 API 来控制实现半连接状态:

#include <sys/socket.h> 
int shutdown(int sockfd, int how); 
    sockfd:	需要关闭的 socket的描述符 
    how:	允许为 shutdown操作选择以下几种方式 : 
        SHUT_RD(0): 关闭 sockfd 上的读功能,此选项将不允许 sockfd进行读操作。该套接字不再接收数据,						任何当前在套接字接受缓冲区的数据将被无声的丢弃掉。 
        SHUT_WR(1): 关闭 sockfd 的写功能,此选项将不允许 sockfd进行写操作。进程不能在对此套接字发
                    出写操作。 
        SHUT_RDWR(2):关闭 sockfd 的读写功能。相当于调用 shutdown两次:首先是以 SHUT_RD,然后以 
                    SHUT_WR。
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

使用 close 中止一个连接,但它只是减少描述符的引用计数,并不直接关闭连接,只有当描述符的引用计数为 0 时才关闭连接。shutdown 不考虑描述符的引用计数,直接关闭描述符。也可选择中止一个方向的连接,只中止读或只中止写。

注意:

  1. 如果有多个进程共享一个套接字,close 每被调用一次,计数减 1 ,直到计数为 0 时,也就是所用进程都调用了 close,套接字将被释放。
  2. 在多进程中如果一个进程调用了 shutdown(sfd, SHUT_RDWR) 后,其它的进程将无法进行通信(通过sfd)。但如果一个进程 close(sfd) 将不会影响到其它进程。

8. 端口复用

查看网络相关信息的命令:netstat

boyangcao@MyLinux:~$ netstat
	# 参数
		-a: 所有的socket
		-p: 显示正在使用socket的程序的名称
		-n: 直接使用IP地址,而不通过域名服务器
		-l: 正在监听的服务器socket
		-t: 使用tcp协议传输的socket
		-d: 使用udp协议传输的socket
		
boyangcao@MyLinux:~/Linux/Lesson34$ netstat -anp | grep -i 9999
# client server 都打开并处于连接状态
(并非所有进程都能被检测到,所有非本用户的进程信息将不会显示,如果想看到所有信息,则必须切换到 root 用户)
tcp        0      0 0.0.0.0:9999            0.0.0.0:*           LISTEN      4720/./server 
tcp        0      0 127.0.0.1:9999          127.0.0.1:50722     ESTABLISHED 4720/./server 
tcp        0      0 127.0.0.1:50722         127.0.0.1:9999      ESTABLISHED 4721/./client 
boyangcao@MyLinux:~/Linux/Lesson34$ netstat -anp | grep -i 9999
# 关闭 server
tcp        0      0 127.0.0.1:9999          127.0.0.1:50722     FIN_WAIT2   -             
tcp        1      0 127.0.0.1:50722         127.0.0.1:9999      CLOSE_WAIT  4721/./client 
boyangcao@MyLinux:~/Linux/Lesson34$ netstat -anp | grep -i 9999
# 关闭 client  (之前绑定的端口9999还未释放 处于TIME_WAIT状态)
tcp        0      0 127.0.0.1:9999          127.0.0.1:50722     TIME_WAIT   -  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

端口复用最常用的用途是:

  • 防止服务器重启时之前绑定的端口还未释放
  • 程序突然退出而系统没有释放端口
#include <sys/types.h> 
#include <sys/socket.h> 
#include <arpa/inet.h> // 包含了上面两个头文件
// 设置套接字的属性(不仅仅能设置端口复用)
int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen); 
	参数:
        - sockfd: 要操作的文件描述符
        - level: 级别 - SOL_SOCKET(端口复用的级别)
        - optname: 选项的名称
            - SO_REUSEADDR: 允许重用本地地址
			- SO_REUSEPORT: 允许重用本地端口
		- optval: 端口复用的值(整型)
            - 1: 可以复用
            - 0: 不可以复用
        - optlen: optval参数的大小
端口复用设置的时机:在服务器绑定端口之前
eg.
    int optval = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEPORT, &optval, sizeof(optval));
    // 绑定
    int ret = bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

现在的结果:

boyangcao@MyLinux:~/Linux/Lesson34$ netstat -anp | grep -i 9999# 关闭了server后在2MSL时间内再次打开Server,端口可以复用
(并非所有进程都能被检测到,所有非本用户的进程信息将不会显示,如果想看到所有信息,则必须切换到 root 用户)
tcp        0      0 0.0.0.0:9999            0.0.0.0:*           LISTEN      4728/./server
tcp        0      0 127.0.0.1:9999          127.0.0.1:50722     TIME_WAIT   -             
tcp        0      0 127.0.0.1:50724         127.0.0.1:9999      ESTABLISHED 4731/./client
tcp        0      0 127.0.0.1:9999          127.0.0.1:50724     ESTABLISHED 4728/./server
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

注意:我很疑惑为什么这里客户端设置等待键盘输入信息,然后先关闭服务器,在关闭客户端就能看到服务器进程处于time_wait状态。

但是把客户端设置成一直发送消息的状态,先关闭服务端,客户端read检测到返回值为0自动关闭,就不能看到服务器对应进程处于time_wait状态??

补充:

#include <sys/types.h>
#include <sys/socket.h>

ssize_t recv(int sockfd, void *buf, size_t len, int flags);
	参数:
        - sockfd: 用于通信的fd
        - buf: 传出参数,接受的数据放入到此数组中
        - len: buf数组长度
        - flags: (具体看man 2 recv) 此处为 0

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                struct sockaddr *src_addr, socklen_t *addrlen);

ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/小蓝xlanll/article/detail/149048
推荐阅读
相关标签
  

闽ICP备14008679号