# 原理（常用函数）

## **1****、****Pthread_create****函数**

​    创建一个新 的线程，其功能对应进程中的fork函数，如果成功返回0，不成功返回一个错误的号码

### 函数原型：

```
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
```


### 参数

> - pthread_t *thread：这是一个指向pthread_t类型变量的指针，用于存储新创建的线程的标识符。当函数成功时，这个变量会被设置为新线程的线程 ID。
> - const pthread_attr_t *attr：这是一个指向const pthread_attr_t结构的指针，用于设置线程的属性。如果你不需要设置特殊的属性，可以传递NULL。
> - void *(*start_routine) (void *)：这是一个指向函数的指针，该函数将成为新线程的入口点。这个函数应该接受一个void指针作为参数，并返回一个void指针。通常，这个函数不会返回任何值，但在某些情况下，它可能用于线程间的通信。当指定的函数运行完后，则线程就结束了。
> - void *arg：设置线程主函数的参数，如果没有，这设置为NULL。你可以通过这个参数向新线程传递数据。



## **2****、****Pthread_join****函数**

​    等待执行的线程，并接受子进程返回的状态

### 函数原型

```
int pthread_join(pthread_t thread, void **retval);
```


### 参数

> - pthread_t thread：这是要等待的线程的标识符。这个标识符通常是在调用 pthread_create 函数时返回的。
> - void **retval：这是一个指向指针的指针，用于接收子线程的返回值。如果不需要子线程的返回值，可以将这个参数设置为 NULL。



## 3、**pthread_self****函数**

​    获取当前线程的id，其返回值为Pthread_t类型（线程id类型）

###  函数原型

```
pthread_t pthread_self(void);
```


## 4、**Pthread_key_create****函数**

​    创建线程私有数据pthread_key_t结构

### 函数原型

```
int pthread_key_create(pthread_key_t *key, void (*destructor)(void*));
```


### 参数

> - **pthread_key_t \*key：这是一个指向pthread_key_t类型变量的指针，用于存储新创建的键。在成功调用pthread_key_create后，这个变量将包含新键的标识符。**
> - **void (\*destructor)(void\*)：这是一个函数指针，指向一个析构函数。析构函数在线程退出时自动调用，用于释放与键关联的数据。如果不需要析构函数，可以将此参数设置为NULL。**

​     注意：此处的pthread_key_t结构，**可以理解为各个线性中，同名但内容不同的变量**



## 5、pthread_key_delete函数

​    注销线程中的私有数据

### 函数原型

```
int pthread_key_delete(pthread_key_t key);
```


## 6、pthread_setspecific函数

​    写线程私有数据

### 函数原型

```
int pthread_setspecific(pthread_key_t key, const void *value);
```


### 参数

> - pthread_key_t key：这是通过pthread_key_create函数创建的线程特定数据键。
> - const void *value：这是要与键相关联的值。这个值可以是任何类型的数据，因为void *是一个通用指针类型。



## 7、pthread_getspecific函数

​    读线程私有数据

### 函数原型

```
void *pthread_getspecific(pthread_key_t key);
```


### 参数

> - 第一个参数为**指定需要内容的****pthread_key_t**变量。此处需要注意，如果**pthread_key_t**变量的内容为空，则会返回0（NULL）



# 示例

## 在main函数中创建两个子线程，两个子线程的函数为child1和child2

```
#include <stdio.h>  
#include <stdlib.h>  
#include <pthread.h>  
void* child1(){  
    printf("Child 1 is running\n");  
    pthread_exit(NULL);  
}  
void* child2(){  
    printf("Child 2 is running\n");  
    pthread_exit(NULL);  
}  
int main() {  
    printf("this is main thread\n");
    pthread_t tid1, tid2;  
    int ret;  
    ret = pthread_create(&tid1, NULL, child1, NULL);  
    if (ret != 0) {  
        printf("Error creating tid 1\n");  
        exit(EXIT_FAILURE);  
    }  
    ret = pthread_create(&tid2, NULL, child2, NULL);  
    if (ret != 0) {  
        printf("Error creating tid 2\n");  
        exit(EXIT_FAILURE);  
    }  
    pthread_join(tid1, NULL);  
    pthread_join(tid2, NULL);  
    return 0;  
}
```


![](/static/img/Linux下多线程的创建和控制/3a6677cbaa8a42ce9bc9f161ce7d1817.png)

Linux下多线程的创建和控制

socket编程的常用函数，可以参考以下这篇博客

[socket编程-----常用socket编程函数![img](https://csdnimg.cn/release/blog_editor_html/release2.4.5/ckeditor/plugins/CsdnLink/icons/icon-default.png?t=PBP8)https://blog.csdn.net/ZZZCY2003/article/details/138071210](https://blog.csdn.net/ZZZCY2003/article/details/138071210)

关于TCP的三次挥手、四次挥手过程和UDP的报文分析可以参考以下两篇博客

[计算机网络--运输层![img](https://csdnimg.cn/release/blog_editor_html/release2.4.5/ckeditor/plugins/CsdnLink/icons/icon-default.png?t=PBP8)https://blog.csdn.net/ZZZCY2003/article/details/138007052](https://blog.csdn.net/ZZZCY2003/article/details/138007052)

[TCP协议数据传输过程及报文分析![img](https://csdnimg.cn/release/blog_editor_html/release2.4.5/ckeditor/plugins/CsdnLink/icons/icon-default.png?t=PBP8)https://blog.csdn.net/ZZZCY2003/article/details/138035752](https://blog.csdn.net/ZZZCY2003/article/details/138035752)



# 一、socket

## 1.1、socket概述

​    Socket编程是计算机网络通信中的一种重要技术，它允许不同的计算机程序通过网络进行通信和数据交换。在Socket编程中，一个程序（通常称为客户端）通过创建Socket对象并与另一个程序（通常称为服务器）建立连接，从而进行通信。



## 1.2、基本概念

1. **IP地址和端口号**：IP地址用于标识网络上的设备，而端口号用于标识设备上的特定服务或应用程序。Socket通过组合IP地址和端口号来唯一标识一个网络上的通信端点。
2. **客户端与服务器**：在Socket编程中，通常有一个服务器程序等待客户端的连接请求。一旦连接建立，客户端和服务器就可以互相发送和接收数据。
3. **流式套接字（SOCK_STREAM）**：通常用于**TCP协议**，提供可靠的、面向连接的通信服务。数据按照字节流的形式发送和接收。
4. **数据报套接字（SOCK_DGRAM）**：通常用于**UDP协议**，提供无连接的通信服务。数据以数据报的形式发送和接收，不保证数据的顺序和可靠性。



## 1.3、关键步骤

1. **创建Socket**：使用socket函数创建一个新的Socket对象。
2. **绑定（Bind）**：对于服务器来说，需要将Socket绑定到一个特定的IP地址和端口号上，以便客户端能够连接。
3. **监听（Listen）**：服务器Socket使用listen函数开始监听来自客户端的连接请求。
4. **接受连接（Accept）**：服务器使用accept函数接受客户端的连接请求，并返回一个新的Socket对象用于与客户端通信。
5. **连接（Connect）**：对于客户端来说，使用connect函数向服务器发起连接请求。
6. **发送和接收数据**：使用send或sendto函数发送数据，使用recv或recvfrom函数接收数据。
7. **关闭Socket**：使用close函数关闭Socket连接，释放资源。



## 1.4、在Linux系统上执行socket过程

假设已经写好服务端代码（service.c）和客户端代码（client.c）（注意：示例用的是C语言代码，且代码已附在文章最下面）

1、开启两个终端，并对服务端代码和客户端代码进行编译。在两个终端中分别执行以下各一条代码，作为服务端和客户端。

```
gcc service.c -o service
gcc client.c -o client
```


2、运行服务端，使服务端处于等待连接状态。等待客户端的请求连接。

```
./service
```


3、在另一个终端运行客户端，向服务端发出请求连接的请求

```
./client
```


4、最后，执行完成！



# 二、基于socket编程的TCP通信过程

## 2.1、基于socket编程的TCP通信流程

### 2.1.1、服务端（service.c）

#### **2.1.1.1、创建socket**

```
//创建socket文件描述符  
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {  
    perror("socket failed");  
    exit(EXIT_FAILURE);  
}  
```


#### **2.1.1.2、绑定socket到端口**

```
address.sin_family = AF_INET;
address.sin_addr.s_addr = inet_addr("127.0.0.1");
address.sin_port = htons(PORT);

//绑定socket到端口
if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
	perror("bind failed");
	exit(EXIT_FAILURE);
}
```

#### **2.1.1.3、开始监听连接**

```
//开始监听连接
if (listen(server_fd, 3) < 0) {
	perror("listen");
	exit(EXIT_FAILURE);
}
```


#### **2.1.1.4、接受客户端连接**

```
//接受客户端连接
if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
	perror("accept");
	exit(EXIT_FAILURE);
}
```


#### **2.1.1.5、读取客户端发送的数据**

```
//读取客户端发送的数据
int valread = read(new_socket, buffer, BUFFER_SIZE);
printf("%s\n", buffer);
```


#### **2.1.1.6、发送响应给客户端**

```
//发送响应给客户端
send(new_socket, hello, strlen(hello), 0);
printf("Hello message sent\n");
```


#### **2.1.1.7**、关闭套接字

```
//关闭套接字
close(server_fd);
close(new_socket);
```


### 2.1.2、客户端（client.c） 

#### **2.1.2.1、创建socket**

```
//创建socket文件描述符
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
	perror("Socket creation error");
	exit(EXIT_FAILURE);
}
```


#### **2.1.2.2、设置服务器地址结构并来连接服务器**

```
//设置服务器地址结构
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);

//连接到服务器
if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
	perror("Connection failed");
	exit(EXIT_FAILURE);
}

printf("Connected to server\n");
```


#### **2.1.2.3、发送数据给服务器**

```
//发送数据给服务器
if (send(sock, hello, strlen(hello), 0) < 0) {
	perror("Send failed");
	exit(EXIT_FAILURE);
}
printf("Hello message sent\n");
```

#### **2.1.2.4、读取服务器的响应**

```
//读取服务器的响应
while ((valread = read(sock, buffer, BUFFER_SIZE - 1)) > 0) {
	buffer[valread] = '\0';
	printf("Received from server: %s\n", buffer);
}

if (valread < 0) {
	perror("Read failed");
}
```


#### **2.1.2.5、关闭套接字**

```
//关闭socket
close(sock);
```


## 2.2、基于socket编程的TCP通信流程图

![](/static/img/基于socket编程实现TCP和UDP的通信流程/bd5f6e4bf5d675ec4332f89b0b18363d.png)


## 2.3、基于socket编程的TCP示例

### 2.3.1、服务端（service.c）

```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
	int server_fd, new_socket;
	struct sockaddr_in address;
	int opt = 1;
	int addrlen = sizeof(address);
	char buffer[BUFFER_SIZE] = {0};
	const char *hello = "Hello from server";

	//创建socket文件描述符
	if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
		perror("socket failed");
		exit(EXIT_FAILURE);
	}

	//设置socket选项，允许地址重用
	if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
		perror("setsockopt");
		exit(EXIT_FAILURE);
	}

	address.sin_family = AF_INET;
	address.sin_addr.s_addr = inet_addr("127.0.0.1");
	address.sin_port = htons(PORT);

	//绑定socket到端口
	if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
		perror("bind failed");
		exit(EXIT_FAILURE);
	}

	//开始监听连接
	if (listen(server_fd, 3) < 0) {
		perror("listen");
		exit(EXIT_FAILURE);
	}

	//接受客户端连接
	if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
		perror("accept");
		exit(EXIT_FAILURE);
	}

	//读取客户端发送的数据
	int valread = read(new_socket, buffer, BUFFER_SIZE);
	printf("%s\n", buffer);

	//发送响应给客户端
	send(new_socket, hello, strlen(hello), 0);
	printf("Hello message sent\n");
	
	//关闭套接字
	close(server_fd);
	close(new_socket);
	return 0;
}
```


### 2.3.2、客户端（client.c）

```
#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <unistd.h>  
#include <sys/types.h>  
#include <sys/socket.h>  
#include <netinet/in.h>  
#include <netdb.h>  
  
#define PORT 8080  
#define BUFFER_SIZE 1024  
  
int main() {  
    int sock = 0;  
    struct sockaddr_in serv_addr;  
    char *hello = "Hello from client";  
    char buffer[BUFFER_SIZE] = {0};  
    int valread;  
      
    //创建socket文件描述符  
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {  
        perror("Socket creation error");  
        exit(EXIT_FAILURE);  
    }  
      
    //设置服务器地址结构  
    memset(&serv_addr, 0, sizeof(serv_addr));  
    serv_addr.sin_family = AF_INET;  
    serv_addr.sin_port = htons(PORT);  

      
    //连接到服务器  
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {  
        perror("Connection failed");  
        exit(EXIT_FAILURE);  
    }  
      
    printf("Connected to server\n");  
      
    //发送数据给服务器  
    if (send(sock, hello, strlen(hello), 0) < 0) {  
        perror("Send failed");  
        exit(EXIT_FAILURE);  
    }  
    printf("Hello message sent\n");  
      
    //读取服务器的响应  
    while ((valread = read(sock, buffer, BUFFER_SIZE - 1)) > 0) {  
        buffer[valread] = '\0';  
        printf("Received from server: %s\n", buffer);  
    }  
      
    if (valread < 0) {  
        perror("Read failed");  
    }  
      
    //关闭socket  
    close(sock);  
    return 0;  
}
```



# 三、基于socket编程的UDP通信过程

## 3.1、基于socket编程的UDP通信流程

### 3.1.1、服务端

#### **3.1.1.1、创建socket**

```
//创建socket
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
	perror("socket creation failed");
	exit(EXIT_FAILURE);
}
```


#### **3.1.1.2、设置服务器地址结构**

```
//设置服务器地址结构
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");//具体的ip地址
server_addr.sin_port = htons(SERVER_PORT);
```


#### **3.1.1.3、绑定socket**

```
//绑定socket
if (bind(sockfd, (const struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
	perror("bind failed");
	exit(EXIT_FAILURE);
}
```


#### **3.1.1.4、打印监听信息**

```
printf("Server is listening on port %d\n", SERVER_PORT);
```


#### **3.1.1.5、接收数据**

```
//接收数据
n = recvfrom(sockfd, (char *)buffer, BUFFER_SIZE, MSG_WAITALL, (struct sockaddr *)&client_addr, &len);
buffer[n] = '\0';
printf("Received from client: %s\n", buffer);
```


#### **3.1.1.6、关闭socket**

```
//关闭socket
close(sockfd);
```


### 3.1.2、客户端

#### **3.1.2.1、创建socket**

```
//创建socket
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
	perror("socket creation failed");
	exit(EXIT_FAILURE);
}
```


#### **3.1.2.2、设置服务器地址结构**

```
//设置服务器地址结构
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SERVER_PORT);
if (inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr) <= 0) {
	perror("Invalid address/Address not supported");
	exit(EXIT_FAILURE);
}
```


#### **3.1.2.3、发送数据**

```
//发送数据
len = sendto(sockfd, (const char *)buffer, strlen(buffer), MSG_CONFIRM,(const struct sockaddr *)&server_addr, sizeof(server_addr));
if (len < 0) {
	perror("sendto failed");
	exit(EXIT_FAILURE);
}
```


#### **3.1.2.4、打印发送信息**

打印一条消息到控制台，表明数据已成功发送到服务器

```
printf("Message sent to server: %s\n", buffer);
```


#### **3.1.2.5、关闭socket**

```
//关闭socket
close(sockfd);
```



## 3.2、基于socket编程的UDP通信流程图

![](/static/img/基于socket编程实现TCP和UDP的通信流程/94cb3815a6c79fe698c62ae2b50312cb.png)


## 3.3、基于socket编程的UDP通信示例

### 3.3.1、服务端（service.c）

```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define SERVER_PORT 8888
#define BUFFER_SIZE 1024

int main() {
	int sockfd;
	struct sockaddr_in server_addr, client_addr;
	socklen_t len = sizeof(client_addr);
	char buffer[BUFFER_SIZE];
	ssize_t n;

	//创建socket
	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		perror("socket creation failed");
		exit(EXIT_FAILURE);
	}

	//设置服务器地址结构
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");//具体的ip地址
	server_addr.sin_port = htons(SERVER_PORT);

	//绑定socket
	if (bind(sockfd, (const struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
		perror("bind failed");
		exit(EXIT_FAILURE);
	}

	printf("Server is listening on port %d\n", SERVER_PORT);

	//接收数据
	n = recvfrom(sockfd, (char *)buffer, BUFFER_SIZE, MSG_WAITALL,
	             (struct sockaddr *)&client_addr, &len);
	buffer[n] = '\0';
	printf("Received from client: %s\n", buffer);

	//关闭socket
	close(sockfd);
	return 0;
}
```


### 3.3.2、客户端（client.c）

```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define SERVER_IP "127.0.0.1"
#define SERVER_PORT 8888
#define BUFFER_SIZE 1024

int main() {
	int sockfd;
	struct sockaddr_in server_addr;
	char buffer[BUFFER_SIZE] = "Hello from UDP client!";
	ssize_t len;

	//创建socket
	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		perror("socket creation failed");
		exit(EXIT_FAILURE);
	}

	//设置服务器地址结构
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(SERVER_PORT);
	if (inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr) <= 0) {
		perror("Invalid address/Address not supported");
		exit(EXIT_FAILURE);
	}

	//发送数据
	len = sendto(sockfd, (const char *)buffer, strlen(buffer), MSG_CONFIRM,
	             (const struct sockaddr *)&server_addr, sizeof(server_addr));
	if (len < 0) {
		perror("sendto failed");
		exit(EXIT_FAILURE);
	}

	printf("Message sent to server: %s\n", buffer);

	//关闭socket
	close(sockfd);
	return 0;
}
```

基于socket编程实现TCP和UDP的通信流程

> 操作系统：Linux
>
> 编程语言：C语言
>
> 简述：socket编程函数是socket编程中的基础，通过组合使用它们，可以实现各种网络通信功能。
>
> socket编程函数较多，在这里只是列出较为常用的socket函数



## socket()函数

​    socket()函数是网络编程中用于创建新套接字的基本接口。它允许开发者指定套接字的类型、使用的通信协议族以及协议类型，从而创建一个可以用于网络通信的端点。



### 头文件

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

### 函数原型

```
int socket(int domain, int type, int protocol);
```


### 参数

> 1、**domain(地址族)：**指定协议族，决定了套接字使用的底层协议。常见的协议族包括：
>
> - AF_INET：IPv4 地址族
> - AF_INET6：：IPv6 地址族
>
> 2、**type(种类)：**指定套接字的类型，决定了通信的方式。常见的套接字类型有：
>
> - SOCK_STREAM：提供可靠的、面向连接的字节流服务，通常用于 TCP 协议。
> - SOCK_DGRAM：提供无连接的数据报服务，通常用于 UDP 协议。
>
> 3、**protocol(协议)：**通常设置为 0，表示使用默认的协议。如果为特定的套接字类型指定了非默认的协议，这里可以设置该协议。
>
> - IPPROTO_TCP：TCP传输协议
> - IPPTOTO_UDP：UDP传输协议

### 返回值

​    如果socket()函数成功，它返回一个非负整数，即新创建的套接字的文件描述符。这个文件描述符在后续的网络操作中用于标识和操作该套接字。

​    如果函数失败，它将返回 -1，并设置全局变量errno以指示错误类型。你可以检查errno的值或使用perror()函数来获取错误信息。

### 示例

​    使用IPv4协议、面向连接的数据传输方式、TCP传输协议，来创建套接字

```
int sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
//注意：一般第三个参数protocol直接设置为0即可
```



## bind()函数

​    bind()函数在网络编程中用于将套接字绑定到特定的地址和端口。



### 头文件

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

### 函数原型

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


### 参数

> - sockfd：这是一个由socket()函数返回的套接字描述符。
> - addr：这是一个指向sockaddr结构的指针，该结构包含了要绑定的地址和端口信息。对于 IPv4 地址，通常使用sockaddr_in结构体；对于 IPv6 地址，使用sockaddr_in6。
> - addrlen：这是addr参数所指向地址结构的长度，通常使用sizeof(struct sockaddr_in)或sizeof(struct sockaddr_in6)来获取。

### 返回值

​    如果bind()函数成功执行，它将返回 0。如果发生错误，它将返回 -1，并设置全局变量errno来指示错误类型。

### 示例

```
//创建TCP套接字  
int sockfd = socket(AF_INET, SOCK_STREAM, 0);  
if (sockfd == -1) {  
    perror("socket creation failed");  
    exit(EXIT_FAILURE);  
}  

//创建sockaddr_in结构体变量
struct sockaddr_in server_addr;

//设置服务器地址结构  
memset(&server_addr, 0, sizeof(server_addr));  
server_addr.sin_family = AF_INET;//使用IPv4地址
server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");监听具体的ip地址  
server_addr.sin_port = htons(12345); // 端口号  

//绑定套接字到地址和端口  
bind(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));
```



### 结构体

#### sockaddr_in结构体

##### 头文件

```
#include <arpa/inet.h>
```


##### 代码块

```
struct sockaddr_in{ 
    sa_family_t sin_family;    //地址类型 
    uint16_t sin_port;    //16位的端口号 
    struct in_addr sin_addr;    //32位的IP地址 
    char sin_zero[8];    //一般用0填充 
};
```


#### in_addr结构体

##### 头文件

```
#include <netinet/in.h>
```

##### 代码块

```
struct in_addr {  
    in_addr_t s_addr;    //32位的IPv4地址
};
```


#### sockaddr结构体

##### 头文件

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


##### 代码块

```
struct sockaddr{ 
    sa_family_t sin_family;    //地址类型 
    char sa_data[14];    //IP地址和端口号 
};
```



## listen()函数

​    listen()函数用于将套接字设置为监听模式，以便可以接受连接请求。



### 头文件

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


### 函数原型

```
int listen(int sockfd, int backlog);
```

### 参数

> - sockfd：这是需要被设置为监听模式的套接字描述符，它应该是一个绑定了地址的套接字。
> - backlog：请求队列的最大长度（能存放多少个客户端请求）。实际队列的大小可能比这个值大，也可能小，具体取决于系统实现和可用资源。

### 返回值

​    如果函数成功执行，则返回 0。

​    如果函数执行失败，则返回 -1，并设置全局变量errno以指示错误。

### 示例

```
//开始监听连接请求  
if (listen(server_fd, 10) == -1) {  
    perror("listen failed");  
    exit(EXIT_FAILURE);  
}  
```




## accept()函数

​    accept()函数是网络编程中用于接受客户端连接请求的系统调用。当一个客户端尝试连接到服务器时，服务器通过调用accept()函数来接受这个连接，并返回一个新的套接字描述符，用于与客户端进行通信。



### 头文件

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


### 函数原型

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

### 参数

> - sockfd：这是服务器套接字描述符，即之前通过socket()创建并通过bind()和listen()初始化的套接字。
> - addr：这是一个指向sockaddr 结构体的指针，用于存储客户端的地址信息。如果不需要获取客户端地址，这个参数可以设置为NULL。
> - addrlen：这是一个指向socklen_t类型变量的指针，它用于传入addr结构体的大小，并在调用后返回实际客户端地址的大小。如果addr设置为NULL，则addrlen也应该设置为NULL。

### 返回值

​    如果函数成功执行，accept()返回一个新的套接字描述符，这个描述符用于与客户端进行通信。

​    如果函数执行失败，返回 -1，并设置全局变量errno以指示错误。

### 示例

```
struct sockaddr_in client_addr; 
sin_size = sizeof(client_addr); 
accept(sockfd, (struct sockaddr *)&client_addr, &sin_size));
```



## connect()函数

​    connect()函数通常用于在套接字编程中建立客户端与服务器之间的连接。它是 POSIX 套接字 API 的一部分，并且主要用于 TCP 连接。



### 头文件

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


### 函数原型

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


### 参数

> sockfd：这是一个套接字描述符，标识了要用于连接的本地端点套接字。它通常是由socket()函数创建的。
>
> serv_addr：这是一个指向sockaddr结构的指针，该结构包含了目标服务器的地址信息。对于 IPv4 地址，通常使用sockaddr_in结构，而对于 IPv6 地址，使用sockaddr_in6结构。
>
> addrlen：这是serv_addr指针指向的sockaddr结构的长度，通常通过sizeof()函数得到。

### 返回值

​    如果连接成功，返回 0。

​    如果连接失败，返回 -1，并设置全局变量errno以指示错误原因。

### 示例

```
struct sockaddr_in serv_addr;
//连接到服务器  
if (connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {  
    perror("ERROR connecting");  
    exit(1);  
}
```




## send()函数

​    send()函数用于在套接字编程中发送数据。它是 POSIX 套接字 API 的一部分，可用于 TCP 和 UDP 套接字。



### 头文件

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


### 函数原型

```
ssize_t send(int sockfd, const void *buf, size_t len, int flags);
```


### 参数

> sockfd：这是套接字描述符，标识了发送数据的套接字。
>
> buf：这是一个指向要发送数据的缓冲区的指针。
>
> len：这是要发送数据的字节数。
>
> flags：这是控制发送操作的标志位。通常设置为 0，但可以使用特定于协议的标志（如MSG_DONTWATTMSG_OOB等）。一般设置为0。

### 返回值

​    如果发送成功，返回实际发送的字节数。

​    如果发送失败，返回 -1，并设置全局变量errno以指示错误原因。

### 示例

```
char *message = "Hello, server!";  
int message_len = strlen(message);
sockfd = socket(AF_INET, SOCK_STREAM, 0); 
// 连接到服务器 
connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)
ssize_t sent_bytes = send(sockfd, message, message_len, 0);
```




## recv()函数

​    recv()函数是一个用于从已连接的套接字接收数据的函数，通常在套接字编程中使用。



### 头文件

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


### 函数原型

```
ssize_t recv(int sockfd, void *buf, size_t len, int flags);
```


### 参数

> sockfd：接收数据的套接字的文件描述符。
>
> buf：指向缓冲区的指针，该缓冲区用于存储接收到的数据。
>
> len：接收的最大字节数。
>
> flags：这是一组标志，用于修改接收操作的行为。常用的标志包括MSG_WAITALL（等待直到接收到完整的消息）和MSG_DONWAIT（非阻塞接收）。一般设置为0。

### 返回值

​    如果成功，recv()函数返回接收到的字节数。

​    如果套接字已关闭，且没有剩余数据可接收，则返回 0。

​    如果发生错误，则返回 -1，并设置全局变量errno以指示错误。

### 示例

```
struct sockaddr_in server_addr;  
char buffer[BUFFER_SIZE];  
ssize_t bytes_received;  
//创建套接字  
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr))
//从服务器接收数据  
bytes_received = recv(sockfd, buffer, BUFFER_SIZE, 0);  
```



## close()或closesocket()函数

​    close()和closesocket()函数都是用于关闭文件描述符或套接字描述符的。尽管这两个函数在功能上是相似的，但它们通常在不同的编程环境和库中使用。（close()函数在linux系统上使用，closesocket()函数在Windows系统上使用）

### 头文件

​    close()函数

```
#include <unistd.h>
```

​    closesocket()函数

```
#include <winsock2.h>
```


### 函数原型

​    close()函数

```
int close(int fd);
```


​    closesocket()函数

```
int closesocket(SOCKET s);
```

### 参数

​    参数皆为要关闭的套接字

### 返回值

​    close()函数

> 如果成功，返回 0。
>
> 如果失败，返回 -1 并设置全局变量errno以指示错误。

​    closesocket()函数

> 如果成功，返回 0。
>
> 如果失败，返回 SOCKET_ERROR 并设置全局错误码WSAGetLastErrdr()。

### 示例

​    close()函数

```
close(sockfd);
```

​    closesocket()函数

```
closesocket(sockfd)
```

socket编程-----常用socket编程函数

## 概述：

运输层（也称为传输层）是OSI七层模型中的第四层，它位于网络层之上、会话层之下。运输层的主要功能是向应用层提供通信服务，确保数据的可靠传输，并负责端到端的通信。它是整个协议层次中最核心的一层，也是面向网络通信的低三层和面向信息处理的最高三层之间的中间层。

根据应用层的不同需要，传输层可以提供两类服务：可靠的服务（TCP）和不可靠的服务（UDP）。

- 可靠的服务（TCP）。发送进程的应用层报文交给运输层后，运输层能够保证将数据顺序地、无差错地、无丢失地交给接收方应用进程。运输层在完成这个任务时，需要使用下面层次（网络层）的服务。当网络层不能保证可靠性时，交给网络层的数据可能会丢失，但运输层要采取重传等的方式，对应用层屏蔽这些处理细节，为应用层提供一条无差错、可靠的数据通道。
- 不可靠的服务（UDP）。运输层不能保证数据的有序、可靠的投递，应用层报文可能会丢失乱序和出错。



### 运输层功能：

1. **复用和分用**：**复用**：多个应用层进程可同时使用下面运输层的服务，不仅在发送方，接收方也存在复用。这就意味着，多个应用可以同时发送和接收数据，运输层负责将这些数据正确地传输到对应的应用进程。**分用**：运输层从收到的信息中能够识别出是哪一个进程的。也就是说，当数据到达接收方的运输层时，它需要根据某些信息（如端口号）将数据分发给正确的应用进程。
2. **差错检测**：运输层需要检测传输过程中可能发生的错误，并采取相应的措施进行纠正。例如，TCP协议通过校验和来检测数据包在传输过程中是否发生错误。
3. **流量控制**：由于发送方和接收方的处理能力可能不同，发送方可能发送过多的数据导致接收方无法处理。因此，运输层需要实现流量控制机制，确保发送方发送的数据速率不会超过接收方的处理能力。
4. **可靠传输**：对于某些应用（如文件传输），数据必须准确无误地到达接收方。运输层需要实现可靠传输机制，例如通过确认、重传等机制来确保数据的完整性和顺序性。TCP就是一个提供可靠传输服务的协议。
5. **拥塞控制**：当网络中出现拥塞时，如果继续发送大量数据，只会加剧拥塞并可能导致数据丢失。因此，运输层需要实现拥塞控制机制，通过降低发送速率、丢弃部分数据包等方式来避免或减轻网络拥塞。



其中TCP/IP的运输层通过端口来实现多路复用和多路分解。一个应用进程通过系统调用可以绑定到运输层协议（UDP或TCP）的一个端口上，这样通过端口号就能确定对应的应用进程，端口和应用进程是一一对应的。当应用进程有数据需要运输层传递时，他将数据放入对应的端口中；运输层协议会将其取走，并在数据前面添加运输层首部，再首部里写入发送方的端口号（源端口）和接收方的端口号（目的端口）。这样，当对方的运输层协议收到时，就可以根据目的端口号将数据交给正确的应用进程。

![](/static/img/计算机网络--运输层/dfcc5fa4032afc00e8c0c73805124d35.png)

端口机制的工作原理



### 端口：

> 熟记端口号：0~1023  -----常用应用程序固定使用
>
> 登记端口号：1024~49151
>
> 动态端口号：49152~65535

在TCP/IP体系中，熟知的服务（web服务、FTP服务等）使用的运输层协议和端口号都是固定的，这些端口被称为数值端口，且其数值一般小于1024。

| 应用       | 应用层协议 | 运输层协议 | 端口 |
| ---------- | ---------- | ---------- | ---- |
| 网页浏览   | HTTP       | TCP        | 80   |
| 文件传输   | FTP        | TCP        | 21   |
| 电子邮件   | SMTP       | TCP        | 25   |
| 电子邮件   | POP3       | TCP        | 110  |
| 远程登录   | Telnet     | TCP        | 23   |
| 动态获取IP | DNCP       | UDP        | 67   |
| 域名解析   | DNS        | UDP        | 53   |
| 网络管理   | SNMP       | UDP        | 161  |



## UDP：

### 概述：

UDP（User Datagram Protocol，用户数据报协议）是传输层协议的一种，与TCP协议一样都位于IP协议之上。与TCP不同的是，UDP不提供数据包分组、组装和排序功能，它只是把应用程序传给IP层的数据报发送出去，但是并不能保证它们能到达目的地。由于UDP在传输数据报前不用在客户和服务器之间建立一个连接，且没有超时重发等机制，故而传输速度很快。



### UDP协议的主要特点：

1. **无连接**：UDP在发送数据之前不需要建立连接，因此减少了开销和延迟。这种特性使得UDP非常适合于实时通信和广播应用，如音频和视频流。
2. **不可靠传输**：UDP不提供像TCP那样的确认和重传机制，因此它不能保证数据的可靠传输。如果数据包在传输过程中丢失或损坏，UDP不会进行任何恢复操作。UDP提供了差错检测的功能（可选），一旦检测出UDP数据报出现错误就将其丢弃，不向应用层传递。
3. **面向报文**：UDP对应用程序交下来的报文，在添加首部后就向下交付给IP层。既不拆分，也不合并，而是保留这些报文的边界。因此，应用程序需要自行处理报文的大小和分割。
4. **支持一对一、一对多、多对一和多对多的交互通信**：由于UDP的无连接特性，它可以很容易地支持多种通信模式，包括多播和广播。
5. **首部开销小**：UDP的首部只有8个字节，比TCP的20个字节小得多。这减少了每个数据包的开销，使得UDP在传输大量小数据包时更加高效。
6. **没有拥塞控制**：UDP不会因为网络拥塞而降低发送速率，这可能导致在网络拥塞时丢包率增加。

由于UDP的这些特性，它通常用于那些对实时性要求较高、但对数据传输的可靠性要求相对较低的应用场景，如实时音视频传输、在线游戏、DNS查询等。



| 应用         | 应用层协议 | 运输层协议 |
| ------------ | ---------- | ---------- |
| 域名解析     | DNS        | UDP        |
| 网络管理     | SNMP       | UDP        |
| 路由信息交换 | RIP        | UDP        |
| 简单文件传输 | TFTP       | UDP        |
| 网络文件系统 | NFS        | UDP        |
| IP电话       | 专有协议   | UDP        |
| 流式多媒体   | 专有协议   | UDP        |



### UDP数据报：

UDP（User Datagram Protocol，用户数据报协议）是一种无连接的传输层协议，它的首部由8个字节组成，这8个字节进一步分为4个字段，每个字段的长度都是2个字节。以下是这四个字段的详细解释：

![](/static/img/计算机网络--运输层/27b66e5b5dac49200e5b33a788057b0f.png)


1. **源端口号**：这是发送方应用进程对应的端口号。当需要对方回复时，会选用这个端口号。如果不需要对方回复，这个字段可以全部置为0。端口号的主要作用是帮助实现数据的定向传输，确保数据能够准确地发送到目标应用进程。
2. **目的端口号**：这是接收方应用进程对应的端口号。利用源端口和目的端口，可以实现多路复用和多路分解。多路复用允许多个应用进程同时使用同一个传输层协议进行通信，而多路分解则确保每个数据报都能被正确地发送到对应的应用进程。
3. **长度**：这个字段表示UDP用户数据报的长度，即数据字段和UDP首部长度的总和。长度字段的值以字节为单位，理论上UDP数据报的长度可以达到2^16字节（即65536字节）。然而，实际上由于数据链路层的限制（如MTU，即最大传输单元的限制），UDP数据报的长度会远远小于这个理论值。
4. **校验和**：这个字段用于检测UDP用户数据报在传输过程中是否有错误。在发送方，校验和是通过特定的算法计算得出的，接收方在收到数据报后会重新计算校验和，并与发送方提供的校验和进行比较。如果两者不一致，说明数据在传输过程中出现了错误，接收方会丢弃这个UDP数据报。这种机制有助于确保数据的完整性和准确性。



## TCP：

### 概述：

TCP（Transmission Control Protocol，传输控制协议）是专门为了在不可靠的互联网络中提供一个可靠的端到端的通信而设计的，是TCP/IP协议体系中运输层的重要协议。TCP为应用层提供面向连接的、可的数据传输服务。发送方应用进程将数据交给TCP，TCP保证将这些数据有序地、无差错地、完整地送达目的应用进程。TCP为应用进程构建了一个可靠的比特流管道，发送方应用进程的报文从一端流人，无差错地、完整地从另一端流出，交给接收方应用进程。

| 应用     | 应用层协议 | 运输层协议 |
| -------- | ---------- | ---------- |
| 网页浏览 | HTTP       | TCP        |
| 文件传输 | FTP        | TCP        |
| 电子邮件 | SMTP、POP3 | TCP        |
| 远程登录 | Ｔelnet    | TCP        |



### TCP协议的主要特点：

**1、TCP是面向连接的运输层协议**：

- TCP协议在传输应用层数据之前，要求两端（客户端和服务器）先建立一个可靠的连接。这个过程通常涉及三次握手，确保双方都已准备好进行数据传输。
- 数据传输完成后，TCP连接会被释放，通常通过四次挥手来完成。这种面向连接的方式确保了数据传输的可靠性和有序性。

**2、TCP提供可靠的数据传输服务**：

- TCP通过多种机制确保数据的可靠传输，包括校验和、序列号、确认应答和重传控制等。这些机制共同作用，使得TCP能够在不稳定的网络环境中提供可靠的数据传输。
- 即使下层网络存在不可靠性，TCP也能通过其内部机制屏蔽这种不可靠性，为上层应用提供稳定的数据传输服务。

**3、TCP提供流量控制**：

- TCP通过滑动窗口机制实现流量控制，允许发送方根据接收方的接收能力来调整发送速率。这可以防止发送方发送数据过快，导致接收方缓冲区溢出。

**4、TCP提供拥塞控制**：

- 当网络出现拥塞时，TCP通过慢开始、拥塞避免、快重传和快恢复等算法来减小发送速率，从而缓解网络拥塞。这有助于维护网络的稳定性和性能。

**5、TCP提供全双工通信**：

- TCP支持双向数据传输，即通信双方可以同时发送和接收数据。这使得TCP能够高效地支持交互式应用，如实时聊天和在线游戏等。
- TCP连接的两端都设有发送缓存和接收缓存，用于临时存储待发送和已接收的数据。这有助于平滑数据传输过程，提高网络利用率。

**6、TCP是面向字节流的**：

- TCP将应用程序交下来的数据视为无结构的字节流，不对数据进行任何解释或处理。这意味着TCP不关心数据的具体含义或格式，只负责将数据以字节为单位进行传输。
- TCP对传输的每个字节都进行编号，并在报文段中进行封装。这使得接收方能够按照正确的顺序和顺序重建原始数据，确保数据的完整性和有序性。

总的来说，TCP协议通过其面向连接、可靠传输、流量控制、拥塞控制、全双工通信和面向字节流等特性，为应用程序提供了高效、可靠的网络传输服务。



### TCP报文段：

![](/static/img/计算机网络--运输层/7721905764b40ab7f074fce443405c7f.png)

TCP报文段是TCP协议中用于传输数据的基本单位。每个TCP报文段都包含源端口号、目的端口号、序列号、确认序号、数据偏移、保留字段、控制位、窗口大小、校验和以及紧急指针等字段。这些字段共同协作，确保数据的可靠传输。

> - 源端口和目的端口：源端口和目的端口字段（各占 2 字节，16比特）。源端口 用来 标识 发送该TCP报文段的应用进程。目的端口 用来 标识接受该TCP报文段的应用进程。 
> - 序列号和确认序号：用于对字节流进行编号和确认，确保数据的按序到达和无损传输。
> - 数据偏移：占4比特。表示TCP报子段中的数据部分距离TCP首部的起始位置有多少字节。数据部分前面是TCP首部，所以数据偏移实际上就是TCP首部的长度。
> - 标志字段：占6比特。每个比特都代表特定的含义，当其值为1时称为置位。
> - 窗口大小：占16比特。窗口大小的值代表了发送方当前TCP连接接收缓存的大小。这个字段用于流量控制，告诉对方下一次可以发送的数据量。通过动态调整窗口大小，TCP可以确保发送方不会发送过多的数据，导致接收方缓冲区溢出。
> - 校验和：占16比特。用于检测数据的传输中是否发生了错误。通过计算校验和，接收方可以验证数据的完整性，确保数据在传输过程中没有被修改或损坏。
> - 紧急指针：紧急指针仅在URG控制位为1时才有意义。它指出了本报文段中的紧急数据的字节数。当发送方需要向接收方发送紧急数据时，可以设置URG控制位，并通过紧急指针来指示紧急数据的长度。

#### 标志字段：

TCP报文段的标志字段是用于控制和管理TCP连接的各种状态和操作的重要部分。这些标志字段包括：

> 1. **SYN（同步）**：用于建立连接。当一个TCP数据包携带SYN标志并设置为1时，它表示请求建立连接。在三次握手过程中，客户端发送的第一个报文段就会设置SYN标志。
> 2. **ACK（确认）**：用于确认接收到的数据。当ACK标志为1时，表示这是一个应答报文段，其中确认号字段的值表示接收方期望从发送方接收的下一个字节的序号。
> 3. **FIN（结束）**：用于结束连接。当FIN标志为1时，表示发送方已经没有更多的数据要发送，并希望关闭连接。在四次挥手过程中，FIN标志用于通知对方准备关闭连接。
> 4. **RST（复位）**：用于强制关闭连接。当检测到严重错误或异常时，接收方可以发送一个携带RST标志的TCP报文段来关闭连接。
> 5. **PSH（推送）**：通知协议栈尽快把TCP数据提交给上层程序处理。当发送方希望接收方尽快处理接收到的数据时，可以设置PSH标志。
> 6. **URG（紧急）**：表示报文段中有紧急数据。当URG标志为1时，紧急指针字段有效，用于指示紧急数据的位置。

这些标志字段在TCP报文段头部中占据一定的位数，并通过设置相应的比特位来表示不同的状态和操作。它们共同协作，确保TCP连接的建立、数据传输的可靠性、连接的正常关闭以及异常情况的处理。



\---------------------------------------------------------------------------------------------------------------------------------

这里只是关于UDP、TCP的介绍和报文字段的分析，若想了解关于TCP的数据传输过程，可以观看[这篇博客](https://blog.csdn.net/ZZZCY2003/article/details/138035752)。

计算机网络--运输层

## TCP数据的传输过程

​    TCP（Transmission Control Protocol，传输控制协议）是专门为了在不可靠的互联网络中提供一个可靠的端到端的通信而设计的，是TCP/IP协议体系中运输层的重要协议。TCP为应用层提供面向连接的、可的数据传输服务。发送方应用进程将数据交给TCP，TCP保证将这些数据有序地、无差错地、完整地送达目的应用进程。TCP为应用进程构建了一个可靠的比特流管道，发送方应用进程的报文从一端流人，无差错地、完整地从另一端流出，交给接收方应用进程。

​    使用TCP进行数据传输包括三个阶段，依次分别是：建立连接（三次握手）、数据传输、断开连接（四次挥手）。

> - 建立连接：目的是使通信双方在开始传输数据前建立联系，使双方都确定对方愿意与之通信；同时在建立连接的过程中还要相互传递和协商一些必要的参数（如发送字节的起始编号、窗口大小等），为后面的数据传输打下基础。
> - 数据传输：连接建立后，开始传输数据，TCP连接的数据传输是双向的，在数据传输阶段TCP要纠正数据传输中的丢失、错误、乱序等问题,并要进行流量控制和拥塞控制。
> - 关闭连接：在两个通信的应用进程之间的数据传输完毕后，就要关闭它们之间的连接，释放资源。

​    整个TCP数据传输如下图所示：

![](/static/img/TCP协议数据传输过程及报文分析/12ea870d286b3e8dda930eb23ed1360f.png)



## 建立连接（三次握手）

​    为了保证客户端和服务器端的可靠连接，TCP建立连接时必须要进行三次会话（发送三个数据包），也叫TCP三次握手，进行三次握手的目的是为了确认双方的接收能力和发送能力是否正常。如下图：

![](/static/img/TCP协议数据传输过程及报文分析/68682fc90727798ae195f11829261977.png)




### 第一次握手

![](/static/img/TCP协议数据传输过程及报文分析/bdff934a495b591296998636d26787c6.png)


​    最开始的时候客户端和服务器都是处于CLOSED关闭状态。主动打开连接的为客户端，被动打开连接的是服务器。（所以源端口是我们的客户端：56069，目的端口是服务端：8080）

​    TCP客户端进程也是先创建传输控制块TCB，然后向服务器发出连接请求报文，这是报文首部中的标志位SYN置1，同时选择一个初始序列号 seq=x（这里seq为0） ，此时，TCP客户端进程进入了 SYN-SENT 同步已发送状态，并正在等待接受方的确认（ACK）以及相应的SYN-ACK回应。



### 第二次握手

![](/static/img/TCP协议数据传输过程及报文分析/c45cc9cbc7a7ca151c3f55ee587d7ed1.png)


​    TCP服务器收到请求报文后，如果同意连接，则会向客户端发出确认报文。确认报文中标志位ACK置1，SYN置1，确认号是ack number=x+1（这里ack number为1），同时也要为自己初始化一个序列号 seq=y(这里为0)，此时，TCP服务器进程收到客户端的SYN（同步）请求后，会回复一个SYN-ACK（同步-应答）报文，并进入SYN-RCVD状态。这个状态表示接受方已经收到了发起方的SYN请求，并且正在等待发起方确认（ACK）以完成连接的建立。



### 第三次握手

![](/static/img/TCP协议数据传输过程及报文分析/d15bb73e1410703760e83e5a1e907c71.png)


​    TCP客户端收到确认后，还要向服务器给出确认。确认报文的ACK置1，ack number=y+1（这里ack number为1），自己的序列号seq=x+1（这里seq为1），此时，TCP连接建立，客户端进入ESTABLISHED已建立连接状态，触发三次握手。

​    当TCP连接的发起方收到接受方的SYN-ACK（同步-应答）报文，并发送了确认（ACK）报文后，连接状态就会从SYN-SENT转变为ESTABLISHED。同样地，当接受方收到发起方的ACK报文后，其连接状态也会从SYN-RCVD转变为ESTABLISHED。所以在第三次握手报文成功发出并收到后，客户端和服务端就成功建立了连接。



### 总结

> - 第一次握手：客户端向服务器发送一个SYN包，并进入SYN_SEND状态，等待服务器确认。这个SYN包中包含了客户端的初始序列号，用于后续的数据传输。
> - 第二次握手：服务器收到客户端的SYN包后，会发送一个SYN+ACK包给客户端，确认客户端的SYN包（通过ACK=客户端初始序列号+1实现），同时服务器也进入SYN_RECV状态，并发送自己的SYN包，其中包含了服务器的初始序列号。
> - 第三次握手：客户端收到服务器的SYN+ACK包后，会向服务器发送一个ACK包，用来确认收到服务器的SYN包（通过ACK=服务器初始序列号+1实现）。当这个ACK包发送完毕，客户端和服务器都进入ESTABLISHED状态，表示TCP连接已经成功建立。

​    所以，在整个握手过程中，双方通过交换SYN和ACK包，确认了彼此的初始序列号，以及双方都能够正常接收和发送数据。这就为后续的数据传输建立了一个可靠的通道。需要注意的是，握手过程中传送的包里不包含数据，三次握手完毕后，客户端与服务器才正式开始传送数据。



## 数据传输

![](/static/img/TCP协议数据传输过程及报文分析/01d906e65f52e88e628b2dc8a660cff5.png)

> - 在连接建立之后，客户端和服务器开始进行数据传输。
> - 数据在应用层被拆分成数据段，然后在传输层被进一步拆分成TCP报文段（也称为数据包）。每个TCP报文段都包含源端口号、目标端口号、序列号、确认号、标志位等信息。
> - 客户端发送TCP报文段给服务器，并等待服务器的确认。服务器接收到报文段后，会进行校验和验证，确保数据的完整性，然后发送确认报文段给客户端。
> - 如果客户端在规定时间内未收到确认报文段，会进行重传操作，直到数据被成功接收



## 断开连接（四次挥手）

​    数据传输完毕后，双方都可释放连接。最开始的时候，客户端和服务器都是处于ESTABLISHED状态，然后客户端主动关闭，服务器被动关闭。在这个过程中，每个方向都需要进行关闭操作，因此称为“四次挥手”。通过这个过程，TCP协议能够确保双方都能够优雅地关闭连接，避免数据丢失和连接残留等问题。

![](/static/img/TCP协议数据传输过程及报文分析/36a1e31e22933194c3b7d13c51a2dd8c.png)



### 第一次挥手

![](/static/img/TCP协议数据传输过程及报文分析/c9e968d3f138af186b1c93d710d56137.png)


​    第一次挥手（即第一个FIN报文的发送）通常是由想要关闭连接的一方发起的，这可以是客户端，也可以是服务端。

​    客户端发出连接释放报文，并且停止发送数据。释放数据报文首部，FIN=1，其序列号为seq=u（等于前面已经传送过来的数据的最后一个字节的序号加1），此时，客户端进入FIN-WAIT-1（终止等待1）状态。（注意：上面的报文，首先发出断开连接的是服务端，并非是客户端。）



### 第二次挥手

![](/static/img/TCP协议数据传输过程及报文分析/ee6f3ff6d57645da1954b453bdd36288.png)


​    服务器端接收到连接释放报文后，发出确认报文，ACK=1，ack=u+1，并且带上自己的序列号seq=v，此时，服务端就进入了CLOSE-WAIT 关闭等待状态。（注意：这里首先发出断开连接申请的是服务端，所以这里发出第二次挥手的是客户端）



### 第三次挥手

![](/static/img/TCP协议数据传输过程及报文分析/52222657dbf68f8fc1f9e720d2998726.png)


​    客户端接收到服务器端的确认请求后，客户端就会进入FIN-WAIT-2（终止等待2）状态，等待服务器发送连接释放报文，服务器将最后的数据发送完毕后，就向客户端发送连接释放报文，服务器就进入了LAST-ACK（最后确认）状态，等待客户端的确认。（注意：这里首先发出断开连接申请的是服务端，所以这里发出第三次挥手的是客户端）



### 第四次挥手

![](/static/img/TCP协议数据传输过程及报文分析/d28906b5a2a58ead5a22c1164b308fa1.png)

​    客户端收到服务器的连接释放报文后，必须发出确认，ACK=1，ack=w+1，而自己的序列号是seq=u+1，此时，客户端就进入了TIME-WAIT（时间等待）状态，但此时TCP连接还未终止，必须要经过2MSL后（最长报文寿命），当客户端撤销相应的TCB后，客户端才会进入CLOSED关闭状态，服务器端接收到确认报文后，会立即进入CLOSED关闭状态，到这里TCP连接就断开了，至此四次挥手完成。



### 总结

> 1. 当一方（通常是客户端）决定结束连接时，它会发送一个FIN包给另一方（通常是服务器），表示自己没有数据需要发送了。
> 2. 服务器收到FIN包后会发送一个ACK包进行确认，并进入CLOSE_WAIT状态，表示收到客户端的关闭请求。
> 3. 服务器也会发送一个FIN包给客户端，表示它也没有数据需要发送了，也准备关闭连接。
> 4. 客户端收到服务器的FIN包后，会发送一个ACK包进行确认，确认收到服务器的关闭请求然后进入TIME_WAIT状态，等待一段时间后最终进入CLOSED状态，表示连接已经完全关闭。



## 最后 

> ​    三次握手是TCP协议建立连接时，为了保证连接的可靠性而采取的一种通信机制。这个机制涉及到客户端和服务器之间的三次交互。
>
> ​    通过这三次握手，客户端和服务器之间可以确认双方的初始序列号，以及对方能够正常接收和发送数据，从而建立起一个可靠的连接。
>
> ​    而四次挥手是TCP协议在关闭连接时，为了保证数据传输的完整性和连接的可靠性而采取的一种通信机制。这个机制涉及到客户端和服务器之间的四次交互。通过这四次挥手，客户端和服务器之间可以确保双方都能够正常关闭连接，并且数据传输的完整性得到了保证。

原理（常用函数）

1**、Pthread_create函数**

概述：

TCP数据的传输过程

1、Pthread_create函数