参考:TCP三次握手详解.

【资料图】

简单分层：

其中，链路层还可以分出物理层和数据链路层。应用层可以分出会话层，表示层和应用层。

七层模型：

链路层：只是物理的比特流和简单封装的数据帧

网络层：主要任务是，通过路由选择算法，为报文通过通信子网选择最适当的路径。也就是通过ip地址来寻址，对应的协议是IP协议。

而ICMP，是基于IP协议的一种协议，但是按功能划分属于网络层，而不是自下而上分到传输层。该协议主要用于确认IP包是否成功到达目标地址，以及返回在发送过程中IP地址被丢弃的原因。

ARP协议，也是网络层的，就是用来将ip地址解析成物理mac地址的，并将ip和mac关联存在ARP缓存表的协议，以便之后再访问，就不用再解析了。

传输层：拎出来详细研究，见下

会话层：就是用于建立会话的,主要步骤：

为会话实体间创建连接：为给两个对等会话服务用户创建一个会话连接，应该做如下几项工作。

将会话地址映射为运输地址。

选择需要的运输服务质量参数（QoS）。

对会话参数进行协商。

识别各个会话连接。

传送有限的透明用户数据。

数据传输阶段：这个阶段是在两个会话用户之间实现有组织的，同步的数据传输。用户数据单元为SSDU,而协议数据单元为SPDU.会话用户之间的数据传送过程是将SSDU转变成SPDU进行的。

连接释放：连接释放是通过"有序释放","废弃"，"有限量透明用户数据传送"等功能单元来释放会话连接的。

from知乎.

借助chatgpt。

TCP（Transmission Control Protocol）协议是一种面向连接的、可靠的、基于流的传输协议，是互联网中最常用的传输协议之一。TCP协议主要用于在网络上进行可靠的数据传输，其特点是建立连接、传输数据、维护连接和释放连接。

TCP协议的主要特点如下：

面向连接：TCP协议在传输数据之前，需要先建立连接，以确保通信双方能够相互识别和配合。

可靠性：TCP协议能够保证数据能够被正确地传输和接收，通过检验和和确认机制，可以检测和纠正传输过程中出现的错误和丢包。

按顺序传输：TCP协议能够保证数据按照发送顺序进行传输和接收，避免数据的乱序和丢失。

流控制：TCP协议通过滑动窗口机制，控制发送方的数据流量，避免网络拥塞和数据包的丢失。

拥塞控制：TCP协议通过拥塞窗口控制机制，动态调整发送方的数据传输速率，避免网络拥塞和数据包的丢失。

面向字节流：TCP协议将数据看作一个字节流进行传输，不考虑数据的边界和长度，能够传输任意类型的数据。

TCP协议实现面向连接的方式主要是通过三次握手建立连接和四次挥手释放连接。

建立连接的过程如下：

客户端向服务器发送SYN（同步）请求，表示客户端要建立连接，并带有一个随机数A。

服务器收到请求后，返回SYN+ACK（同步+确认）响应，表示服务器收到了连接请求，并带有一个随机数B和确认数A+1。

客户端收到响应后，发送ACK（确认）响应，表示客户端确认收到了服务器的响应，并带有确认数B+1。

完成以上三步，TCP连接就建立成功了。

释放连接的过程如下：

客户端发送FIN（结束）请求，表示客户端不再发送数据。

服务器收到请求后，发送ACK响应，表示已经收到了FIN请求。

服务器再发送FIN请求，表示服务器不再发送数据。

客户端收到FIN请求后，发送ACK响应，表示已经收到了服务器的请求，连接正式关闭。

完成以上四步，TCP连接就被正常关闭了

TCP协议实现可靠性的方式主要有以下几个方面：

序列号和确认号：TCP协议在传输数据时，使用序列号和确认号来保证数据的可靠传输。发送方在发送数据时，为每个数据包设置一个序列号，接收方在接收到数据包之后，会向发送方发送一个确认号，表示接收到了序列号对应的数据。如果发送方没有收到确认号，则会重新发送数据包。

检验和：TCP协议使用检验和来保证数据在传输过程中不被篡改。发送方在发送数据时，会计算数据包的检验和，接收方在接收到数据包后，会重新计算检验和，如果接收到的数据包的检验和与发送方发送的不一致，则会丢弃该数据包。

超时重传：TCP协议在发送数据时，会设置一个超时时间（RTT），如果在超时时间内没有接收到接收方的确认号，则会重新发送数据包，以保证数据的可靠传输。

滑动窗口：TCP协议使用滑动窗口机制来控制数据的传输速率和流量。发送方和接收方会维护一个窗口大小，发送方根据窗口大小和接收方的确认号来控制发送数据的速度和流量，接收方则根据窗口大小来控制接收数据的流量。

TCP协议实现顺序传输的方式主要是通过序列号和确认号来保证数据的顺序传输。

在TCP协议中，发送方为每个数据包设置一个序列号，接收方在接收数据包时，会根据序列号来确定数据包的顺序，如果接收到的数据包的序列号不是按照顺序递增的，则会缓存该数据包，等待后面的数据包到达后再进行排序和组合。

在发送数据时，TCP协议会按照顺序将数据分成多个数据包进行传输，每个数据包都带有一个序列号，接收方会根据序列号来确定数据包的顺序，并向发送方发送确认号，表示已经接收到了序列号对应的数据包。如果发送方没有收到确认号，则会重新发送数据包，保证数据包的顺序传输。

TCP流控制是通过滑动窗口机制实现的。具体实现机制如下：

发送方和接收方都会维护一个滑动窗口，用于控制数据的流动。

发送方会根据接收方的窗口大小来动态调整自己的发送速率。如果接收方窗口变小了，发送方就会减慢发送速率，以避免数据的拥塞。

接收方会在收到一定量的数据后，向发送方发送一个确认消息（ACK），告诉发送方接收到了这些数据。同时，接收方会把窗口向前滑动一定的距离，让发送方继续发送数据。

如果发送方发送的数据过多，超过了接收方的窗口大小，接收方就会发送一个窗口更新消息，告诉发送方可以继续发送的数据量。

通过这样的机制，TCP流控制可以保证数据的流动速率适应网络的情况，避免数据的拥塞和丢失。同时，这种机制还可以适应不同的网络环境和数据传输需求，具有很高的灵活性和可靠性。

发送方和接收方都会维护一个拥塞窗口（cwnd），用于控制数据的发送速率。初始时，cwnd的大小为一个最大段大小（MSS）。

发送方会根据接收方的窗口大小和拥塞窗口的大小来动态调整自己的发送速率。发送方每收到一个ACK就会把cwnd增加一个MSS的大小，以逐步增加发送速率，但是在拥塞发生时，cwnd会被减小以减少发送速率。

接收方在收到数据后，会向发送方发送一个窗口更新消息，告诉发送方可以接收的数据量。如果接收方的窗口变小了，发送方就会减慢发送速率，以避免数据的拥塞。如果发送方没有收到ACK，就会认为网络出现了拥塞，就会把cwnd减小以降低发送速率。

发送方还会根据网络的拥塞情况来调整拥塞窗口的大小。如果发送方收到了重复的ACK，就表示网络出现了拥塞，就会把cwnd减小一定的量，以避免继续发送造成更严重的拥塞。如果发送方发现没有收到ACK，就会认为网络出现了拥塞，就会把cwnd减小以降低发送速率。

通过这样的机制，TCP拥塞控制可以保证在网络出现拥塞时，发送方能够自动降低发送速率，避免数据的丢失和网络拥堵。同时，这种机制还可以适应不同的网络环境和数据传输需求，具有很高的灵活性和可靠性。

TCP（传输控制协议）是一种面向字节流的协议，这意味着TCP将数据视为一个连续的字节流，而不是一系列独立的数据包或消息。传输的数据没有固定的边界或大小，TCP只是把数据看作是一个字节序列，并在传输时按照这个字节序列进行处理。

在TCP中，发送方把需要传输的数据按照字节流的形式分割成小的数据块，称为TCP段。然后，发送方把每个TCP段封装成一个TCP报文段，并在报文头中添加一些控制信息，如源端口、目的端口、序号、确认号、窗口大小等。发送方把TCP报文段发送给接收方。

接收方在收到TCP报文段后，按照报文头中的序号和确认号信息，将TCP段重新组装成原始的数据。如果接收方收到了乱序的TCP段，它会先缓存这些TCP段，等待缺失的TCP段到来后再进行组装。如果接收方收到了重复的TCP段，它会忽略这些TCP段，只发送一次ACK确认报文段。

UDP（用户数据报协议）是一种简单的、无连接的、面向数据报的协议，它可以在IP网络中进行快速传输。与TCP协议不同，UDP协议不提供可靠性和流量控制等服务，但是它的优点是速度快，具有较低的延迟和较小的网络开销。

UDP协议的特点如下：

无连接性：UDP协议是无连接的，发送数据前不需要建立连接。这意味着应用程序可以快速地发送数据，并且不需要等待建立连接这一步骤。

面向数据报：UDP协议是面向数据报的，每个数据包都是独立的，UDP协议不会像TCP协议那样把数据流分割成小的数据块，也不会在发送和接收的数据之间维护状态信息。

不可靠性：UDP协议不提供可靠性和流量控制等服务，因此在传输过程中可能会出现数据包丢失、重复、乱序等问题。但是，这也使得UDP协议的传输速度更快，适用于那些对可靠性要求不高的应用程序。

简单性：UDP协议非常简单，它只包含了必要的功能，没有复杂的控制机制和状态信息。这使得UDP协议的实现非常容易，并且可以在资源有限的设备上使用。

UDP协议适用于一些对可靠性要求不高的应用程序，如视频流、音频流、DNS服务等。这些应用程序需要快速传输数据，而且可以容忍一定的数据丢失和重复。

与TCP不同，UDP不会在传输之前建立连接，并且不会在传输后关闭连接。这种无连接的特性使得UDP具有更高的传输速率和更低的延迟，但也意味着数据传输的可靠性较低，因为UDP无法保证数据的完整性和正确性。

在UDP协议中，数据包只包含源地址、目标地址、数据和一些控制信息，如校验和等。这些信息足以保证数据包能够被正确地传输，但是它们不能确保数据包能够被正确地接收。如果数据包在传输过程中丢失或损坏，UDP不会自动重传数据包，而是将它们丢弃。因此，在使用UDP进行数据传输时，需要对数据的完整性和正确性进行额外的检验和控制。

UDP的底层使用的是IP协议，就是网络层的IP协议。在网络层中，IP协议传输的消息类型是IP数据报，它是无连接的，且不可靠的。所以UDP数据报也是无连接、不可靠的。但是因为直接使用IP协议，速度快，占用小。在UDP的基础上加上源地址、目的地址、控制信息就组成了IP数据报，直接在网络层传输。

参考：csdn-网络通信.

服务器端：建立socket,绑定scoket和地址信息，开启监听，收到请求后发送数据

客户端：建立socket，连接到服务器端，接收并打印服务器发送的数据

socket：创建一个套接字

bind：用于绑定IP地址和端口号到socket;

listen：设置能处理的最大连接要求，listen并未开始接收连线，只是设置socket为listen模式

accept：用来接收socket连接

connect：用于绑定之后的client端与服务器建立连接

sockaddr_in是用于表示IPv4地址和端口号的结构体。其定义如下：

struct sockaddr_in {    sa_family_t sin_family; // 地址族，一般为AF_INET    in_port_t sin_port; // 端口号，网络字节序    struct in_addr sin_addr; // IPv4地址    char sin_zero[8]; // 填充，一般为0};

其中，sa_family_t类型表示地址族，一般情况下为AF_INET表示IPv4地址；in_port_t类型表示端口号，为网络字节序；struct in_addr类型表示IPv4地址，其定义如下：

struct in_addr {    in_addr_t s_addr; // IPv4地址，网络字节序};

in_addr_t类型表示IPv4地址，为32位无符号整数，也是网络字节序。

使用sockaddr_in结构体可以方便地表示IPv4地址和端口号。

errno是C/C++语言中的一个全局变量，用于记录最近一次系统调用发生错误的错误码。系统调用包括文件操作、网络操作、进程操作等等。

errno变量通常定义在头文件中，其类型是int。在发生错误时，系统会将相应的错误码存储到errno变量中，以便程序员可以根据错误码进行相应的处理。

对于网络编程中的Socket库，send、recv等函数在发生错误时会设置errno变量，因此程序员可以通过检查errno变量来判断函数是否执行成功。例如，send函数在发送数据失败时会返回-1，并设置errno变量指示失败的原因。

常见的errno错误码包括：

struct timeval是linux系统中定义的结构体：

struct timeval{__time_t tv_sec;        /* Seconds. */__suseconds_t tv_usec;  /* Microseconds. */};

tv_sec是秒,tv_usec是微秒

__time_t和__suseconds_t都是long int的扩展名

htons是一个用于将主机字节序转换为网络字节序的函数，其函数原型如下：

#include uint16_t htons(uint16_t hostshort);

htons函数的参数hostshort是一个16位整数，表示要进行转换的主机字节序数据。该函数将主机字节序数据转换为网络字节序数据，然后返回转换后的结果。网络字节序采用大端字节序，即高位字节存储在低地址，低位字节存储在高地址。

htons函数将主机字节序转换为网络字节序的过程如下：

判断本地主机的字节序是大端字节序还是小端字节序。如果本地主机是大端字节序，则不需要进行转换，直接返回原始数据即可。

如果本地主机是小端字节序，则需要将主机字节序数据转换为网络字节序数据。具体操作是将低位字节存储在高地址，高位字节存储在低地址。

例如，如果要将一个16位整数0x1234（主机字节序）转换为网络字节序，htons函数将执行以下操作：

检测本地主机的字节序，如果本地主机是小端字节序，则需要进行转换。

将低位字节0x34存储在高地址，高位字节0x12存储在低地址，得到0x3412（网络字节序）。

返回转换后的结果0x3412。

需要注意的是，htons函数只能用于16位整数的转换，如果要转换32位整数，需要使用htonl函数。另外，在网络编程中，所有传输到网络上的数据都必须使用网络字节序，否则可能会导致数据传输错误。因此，在编写网络程序时，应该使用htons等函数将主机字节序数据转换为网络字节序数据。

socket原意“插座”，在计算机通信领域，被翻译为“套接字”，是计算机之间进行通信的一种约定或一种方式，通过socket这种约定，计算机之间可以相互发送接收数据。socket的本质就是一个文件，通信的本质就是在计算之间传递这个文件。

基本语法：SOCKET socket(int af,int type,int protocol);。

af：地址族，address family，就是IP地址的类型，值包括AF_INET(IPv4)、AF_INET6(IPv6)。

type：数据传输方式/套接字类型，值包括SOCK_STREAM(流格式套接字/面向连接的套接字)和SCOK_DGRAM(datagram数据报套接字/无连接的套接字)

protocol:协议，值包括 IPPROTO_TCP(TCP协议)，IPPROTO_UDP(UDP 传输协议)

返回值SOCKET是int型：

返回值为 -1：通常表示函数调用失败，可能是由于参数错误、权限不足、系统资源不足等原因引起的。

返回值为 0：通常表示一个连接已经关闭，此时应该关闭套接字并释放资源。

返回值为正整数：通常表示已经成功地进行了某种操作，具体含义要根据函数的不同而定。例如：

socket 函数成功地创建了一个新套接字，返回的是新套接字的描述符。

bind 函数成功地将一个套接字与一个本地地址绑定，返回的是 0。

listen 函数成功地将一个套接字设置为监听状态，返回的是 0。

accept 函数成功地接受了一个连接请求，返回的是新建立连接的套接字描述符。

EAGAIN/EWOULDBLOCK：表示当前情况下资源已经不可用，需要等待一段时间或者采取其他措施再尝试操作。

EINTR：表示当前操作被中断，可能是由于信号的到来或者其他原因引起的，需要重新尝试操作。

运用socket,首先需要相关的头文件：

：定义了 socket 相关的数据类型、结构体和函数。

：定义了网络地址结构体、地址族、端口号等相关的数据类型和宏定义。

：定义了一些 IP 地址转换的函数。

：定义了一些网络数据库相关的函数，如获取主机信息、服务信息等。

例子：用socket套接字访问百度服务器

#include #include #include #include #include using namespace std;int main() {    // 创建 socket 套接字    int client_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);    if (client_sock == -1) {        cerr << "Failed to create socket." << endl;        return -1;    }    // 建立连接    sockaddr_in server_addr;//这个结构初始是空的，所以需要申请字节空间    memset(&server_addr, 0, sizeof(server_addr));//可以用memset    server_addr.sin_family = AF_INET;//设置IPv4    server_addr.sin_addr.s_addr =inet_addr("112.80.248.75");//设置IP主机号，不能是网址，必须先解析成IP    server_addr.sin_port = htons(80);//设置端口    if (connect(client_sock, (sockaddr*)&server_addr, sizeof(server_addr)) == -1) {        cerr << "Failed to connect to server." << endl;        return -1;    }    // 发送请求    const char* request = "GET / HTTP/1.1\r\nHost: www.baidu.com\r\n\r\n";    write(client_sock, request, strlen(request));//向百度的服务器主机发送消息    // 接收响应    char buffer[10240];    int len = read(client_sock, buffer, sizeof(buffer) - 1);    if (len == -1) {        cerr << "Failed to receive response." << endl;        return -1;    }    buffer[len] = "\0";//字符型的数组的长度可能设置的很大，用这个来截取有效部分，就可以直接cou    cout << buffer << endl;    // 关闭连接    close(client_sock);    return 0;}

运行结果：

在网络编程中，bind()函数用于将一个套接字（socket）与一个本地的IP地址和端口号绑定起来。在客户端程序中不常使用，但是在服务器端程序中，一般需要先创建一个套接字，然后将其绑定到一个固定的本地IP地址和端口号上，以便客户端可以通过这个地址和端口号与服务器进行通信。

bind()函数的函数原型如下：

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

其中，sockfd是已经创建好的套接字描述符，addr是一个指向本地IP地址和端口号的sockaddr类型的指针，addrlen是sockaddr类型的指针的长度。

bind()函数的返回值为0表示绑定成功，否则表示绑定失败。在调用bind()函数之前，需要先通过socket()函数创建一个套接字，并且需要在sockaddr结构体中指定本地IP地址和端口号，例如：

struct sockaddr_in server_addr;memset(&server_addr, 0, sizeof(server_addr));server_addr.sin_family = AF_INET;server_addr.sin_addr.s_addr = htonl(INADDR_ANY);  // 绑定到本地任意IP地址server_addr.sin_port = htons(PORT);  // 绑定到指定端口号

接下来就可以调用bind()函数将套接字与本地IP地址和端口号绑定起来了，例如：

int ret = bind(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));if (ret == -1) {    perror("bind error");    exit(1);}

详细例子：

#include#include#include//sockaddr_in#include//memsetusing namespace std;int main(){    int sockfd=socket(AF_INET,SOCK_STREAM,0);    if(sockfd==-1){        cerr<<"failed to create socket"<

int listen(int sockfd, int backlog);

int backlog = 10;  // 等待连接队列的最大长度int ret = listen(sockfd, backlog);  // 将套接字转换成监听套接字if (ret == -1) {    perror("listen error");    exit(1);}

#include#include#include//sockaddr_in#include//memsetusing namespace std;int main(){    int sockfd=socket(AF_INET,SOCK_STREAM,0);    if(sockfd==-1){        cerr<<"failed to create socket"<

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

struct timeval timeout; timeout.tv_sec = 5;timeout.tv_usec = 0;setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));

if(apct==-1){    cerr<<"connect configure error";}else if(acpt==EAGAIN){    cerr<<"timeout"<

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);

int sockfd = socket(AF_INET, SOCK_STREAM, 0);while (1) {    fd_set read_fds;    FD_ZERO(&read_fds);    FD_SET(sock, &read_fds);    struct timeval tv;    tv.tv_sec = 1;    tv.tv_usec = 0;    int ret = select(sockfd + 1, &read_fds, NULL, NULL, &tv);    if (ret == -1) {        // select出错        continue;    } else if (ret == 0) {        // 没有新连接        continue;    }    int new_sock = accept(sockfd, (struct sockaddr *)&caddr, &len);    if (new_sock == -1) {        // accept出错        continue;    }    // 处理新连接}

#include int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

int sock = socket(AF_INET, SOCK_STREAM, 0);int flags = fcntl(sockfd, F_GETFL, 0);fcntl(sock, F_SETFL, flags | O_NONBLOCK);

#include int fcntl(int fd, int cmd, ...);

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

#include#include#includeusing namespace std;int main(){    int servsock=socket(AF_INET,SOCK_STREAM,0);    sockaddr_in servaddr;    servaddr.sin_family=AF_INET;    servaddr.sin_addr.s_addr=inet_addr("127.0.0.1");    servaddr.sin_port=htons(2337);    int con=connect(servsock,(sockaddr*)&servaddr,sizeof(servaddr));    if(con==0){        cout<<"connected to server"<

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

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

int epoll_create(int size);

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

#include//epoll#includeint main(){    int sockfd=socket(AF_INET,SOCK_STREAM,0);    struct epoll_event event;//事件结构体    event.events=EPOLLIN;    event.data.fd=listen_fd;    int epollfd=epoll_create(0);    epoll_ctl(epollfd,EPOLL_CTL_ADD,sockfd,&event);}

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

#include "server.h"int main(){    int server_socket=socket(AF_INET, SOCK_STREAM, 0);    sockaddr_in server_addr;    memset(&server_addr, 0, sizeof(sockaddr_in));    server_addr.sin_family=AF_INET;    server_addr.sin_port=htons(SERVER_PORT);    server_addr.sin_addr.s_addr=INADDR_ANY;    if(bind(server_socket,(sockaddr *)&server_addr,sizeof(server_addr))<0){        cerr<<"chat_server: main: server bind error"<

readlink /proc/74103/fd/fdnumber

ls /proc/72539/fd 

#! /bin/bashwhile :do        readlink /proc/72539/fd/5 >> ./socket.logdone