2022-06-12

字数统计: 9.7k字 | 阅读时长: 40分

Linux服务器项目-8

socket通信基础

网络编程实际上是实现不同主机间进程间通信。

所谓 socket（套接字），就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。一个套接字就是网络上进程通信的一端，提供了应用层进程利用网络协议交换数据的机制。从所处的地位来讲，套接字上联应用进程，下联网络协议栈，(类似于栈先进后出)是应用程序通过网络协议进行通信的接口，是应用程序与网络协议根进行交互的接口。

socket 可以看成是两个网络应用程序进行通信时，各自通信连接中的端点，这是一个逻辑上的概念。它是网络环境中进程间通信的 API，也是可以被命名和寻址的通信端点，使用中的每一个套接字都有其类型和一个与之相连进程。通信时其中一个网络应用程序将要传输的一段信息写入它所在主机的 socket 中，该 socket 通过与网络接口卡（NIC）相连的传输介质将这段信息送到另外一台主机的 socket 中，使对方能够接收到这段信息。socket 是由 IP 地址和端口(port)结合的，提供向应用层进程传送数据包的机制。

socket 本身有“插座”的意思，在 Linux 环境下，用于表h示进程间网络通信的特殊文件类型。本质为内核借助缓冲区形成的伪文件。既然是文件，那么理所当然的，我们可以使用文件描述符引用套接字。与有名管道类似的，Linux 系统将其封装成文件的目的是为了统一接口，使得读写套接字和读写文件的操作一致。区别是管道主要应用于本地进程间通信，而套接字多应用于网络进程间数据的传递。

// 套接字通信分两部分：
- 服务器端：被动接受连接，一般不会主动发起连接
- 客户端：主动向服务器发起连接
socket是一套通信的接口，Linux 和 Windows 都有，但是有一些细微的差别。

字节序

简介

现代 CPU 的累加器一次都能装载（至少）4 字节（这里考虑 32 位机），即一个整数。那么这 4字节在内存中排列的顺序将影响它被累加器装载成的整数的值，这就是字节序问题。在各种计算机体系结构中，对于字节、字等的存储机制有所不同，因而引发了计算机通信领域中一个很重要的问题，即通信双方交流的信息单元（比特、字节、字、双字等等）应该以什么样的顺序进行传送。如果不达成一致的规则，通信双方将无法进行正确的编码/译码从而导致通信失败。

==字节序，顾名思义字节的顺序，就是大于一个字节类型的数据在内存中的存放顺序(一个字节的数
据当然就无需谈顺序的问题了)。==
字节序分为大端字节序（Big-Endian）和小端字节序（Little-Endian）。大端字节序是指一个整数的最高位字节（23 ~ 31 bit）存储在内存的低地址处，低位字节（0 ~ 7 bit）存储在内存的高地址处；小端字节序则是指整数的高位字节存储在内存的高地址处，而低位字节则存储在内存的低地址处。

判断字节序：

/*  
    字节序：字节在内存中存储的顺序。
    小端字节序：数据的高位字节存储在内存的高位地址，低位字节存储在内存的低位地址
    大端字节序：数据的低位字节存储在内存的高位地址，高位字节存储在内存的低位地址
*/

// 通过代码检测当前主机的字节序
#include <stdio.h>

int main() {

    union {
        short value;    // 2字节
        char bytes[sizeof(short)];  // char[2], 这些数据共享同一段内存，以达到节省空间的目的
    } test;

    test.value = 0x0102;
    if((test.bytes[0] == 1) && (test.bytes[1] == 2)) {
        printf("大端字节序\n");
    } else if((test.bytes[0] == 2) && (test.bytes[1] == 1)) {
        printf("小端字节序\n");
    } else {
        printf("未知\n");
    }

    return 0;
}

字节序转换函数：

当格式化的数据在两台使用不同字节序的主机之间直接传递时，接收端必然错误的解释之。解决问题的方法是：发送端总是把要发送的数据转换成大端字节序数据后再发送，而接收端知道对方传送过来的数据总是采用大端字节序，所以接收端可以根据自身采用的字节序决定是否对接收到的数据进行转换（小端机转换，大端机不转换）。

网络字节顺序是 TCP/IP 中规定好的一种数据表示格式，它与具体的 CPU 类型、操作系统等无关，从而可以保证数据在不同主机之间传输时能够被正确解释，网络字节顺序采用大端排序方式。

BSD Socket提供了封装好的转换接口，方便程序员使用。包括从主机字节序到网络字节序的转换函数：htons、htonl；从网络字节序到主机字节序的转换函数：ntohs、ntohl。

h - host 主机，主机字节序
to - 转换成什么
n - network 网络字节序
s - short unsigned short
l - long unsigned int

#include <arpa/inet.h>
// 转换端口, 0 ~ 25536, 16位
uint16_t htons(uint16_t hostshort); // 主机字节序 - 网络字节序
uint16_t ntohs(uint16_t netshort); // 主机字节序 - 网络字节序
// 转IP, IP地址32位
uint32_t htonl(uint32_t hostlong); // 主机字节序 - 网络字节序
uint32_t ntohl(uint32_t netlong); // 主机字节序 - 网络字节序

应用实例：

/*

    网络通信时，需要将主机字节序转换成网络字节序（大端），
    另外一段获取到数据以后根据情况将网络字节序转换成主机字节序。

    // 转换端口
    uint16_t htons(uint16_t hostshort);		// 主机字节序 - 网络字节序
    uint16_t ntohs(uint16_t netshort);		// 主机字节序 - 网络字节序

    // 转IP
    uint32_t htonl(uint32_t hostlong);		// 主机字节序 - 网络字节序
    uint32_t ntohl(uint32_t netlong);		// 主机字节序 - 网络字节序

*/

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

int main() {

    // htons 转换端口
    unsigned short a = 0x0102; //没有负数时用unsigned比较规范
    printf("a : %x\n", a);
    unsigned short b = htons(a);
    printf("b : %x\n", b);

    printf("=======================\n");

    // htonl  转换IP
    char buf[4] = {192, 168, 1, 100};
    int num = *(int *)buf;
    int sum = htonl(num);
    unsigned char *p = (char *)&sum;

    printf("%d %d %d %d\n", *p, *(p+1), *(p+2), *(p+3));

    printf("=======================\n");

    // ntohl
    unsigned char buf1[4] = {1, 1, 168, 192};
    int num1 = *(int *)buf1;
    int sum1 = ntohl(num1);
    unsigned char *p1 = (unsigned char *)&sum1;
    printf("%d %d %d %d\n", *p1, *(p1+1), *(p1+2), *(p1+3));
     // ntohs
    return 0;
}

3. Socket地址

1
2
3

// socket地址其实是一个结构体，封装端口号和IP等信息。后面的socket相关的api中需要使用到这个
socket地址。
// 客户端 -> 服务器（IP, Port）

socket 网络编程接口中表示 socket 地址的是结构体 sockaddr，其定义如下：

#include <bits/socket.h>
struct sockaddr {
sa_family_t sa_family; //地址族类型
char sa_data[14]; //地址详细的数据，包括IP的值，端口的值等
};
typedef unsigned short int sa_family_t; //2个字节

sa_family 成员是地址族类型（sa_family_t）的变量。地址族类型通常与协议族类型对应。常见的协议族（protocol family，也称 domain）和对应的地址族入下所示：

宏 PF_ 和 AF_ 都定义在 bits/socket.h 头文件中，且后者与前者有完全相同的值，所以二者通常混用。

sa_data 成员用于存放 socket 地址值。但是，不同的协议族的地址值具有不同的含义和长度，如下所示：

由上表可知，14 字节的 sa_data 根本无法容纳多数协议族的地址值。因此，Linux 定义了下面这个新的通用的 socket 地址结构体，这个结构体不仅提供了足够大的空间用于存放地址值，而且是内存对齐的。

#include <bits/socket.h>
struct sockaddr_storage
{
sa_family_t sa_family; //地址族类型
unsigned long int __ss_align; //用于内存对齐
char __ss_padding[ 128 - sizeof(__ss_align) ]; //存取具体的IP，端口号等信息
};
typedef unsigned short int sa_family_t;

专用socket地址

很多网络编程函数诞生早于 IPv4 协议，那时候都使用的是 struct sockaddr 结构体，为了向前兼容，现在sockaddr 退化成了（void *）的作用，传递一个地址给函数，至于这个函数是 sockaddr_in 还是sockaddr_in6，由地址族确定，然后函数内部再强制类型转化为所需的地址类型。

用的时候创建结构体，然后为结构体内的成员赋值就行了。

UNIX 本地域协议族使用如下专用的 socket 地址结构体：

#include <sys/un.h>
struct sockaddr_un
{
sa_family_t sin_family;
char sun_path[108];
};

TCP/IP 协议族有 sockaddr_in 和 sockaddr_in6 两个专用的 socket 地址结构体，它们分别用于 IPv4 和IPv6：

#include <netinet/in.h>
struct sockaddr_in
{
	sa_family_t sin_family; /* __SOCKADDR_COMMON(sin_) */
	in_port_t sin_port; /* Port number. */
	struct in_addr sin_addr; /* Internet address. */
	/* Pad to size of `struct sockaddr'. */
	unsigned char sin_zero[sizeof (struct sockaddr) - __SOCKADDR_COMMON_SIZE -
	sizeof (in_port_t) - sizeof (struct in_addr)];//填充的部分
};
struct in_addr
{
	in_addr_t s_addr;
};
struct sockaddr_in6
{
	sa_family_t sin6_family;
	in_port_t sin6_port; /* Transport layer port # */
	uint32_t sin6_flowinfo; /* IPv6 flow information */
	struct in6_addr sin6_addr; /* IPv6 address */
	uint32_t sin6_scope_id; /* IPv6 scope-id */
};
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef uint16_t in_port_t; //unsigned short
typedef uint32_t in_addr_t; //unsigned int
#define __SOCKADDR_COMMON_SIZE (sizeof (unsigned short int))

所有专用 socket 地址（以及 sockaddr_storage）类型的变量在实际使用时都需要转化为通用 socket 地址类型 sockaddr（强制转化即可），因为所有 socket 编程接口使用的地址参数类型都是 sockaddr。

4. IP地址转换（字符串ip-整数，主机、网络字节序的转换）

通常，人们习惯用可读性好的字符串来表示 IP 地址，比如用点分十进制字符串表示 IPv4 地址，以及用十六进制字符串表示 IPv6 地址。但编程中我们需要先把它们转化为整数（二进制数）方能使用。而记录日志时则相反，我们要把整数表示的 IP 地址转化为可读的字符串。下面 3 个函数可用于用点分十进制字符串表示的 IPv4 地址和用网络字节序整数表示的 IPv4 地址之间的转换：

#include <arpa/inet.h>
in_addr_t inet_addr(const char *cp);
int inet_aton(const char *cp, struct in_addr *inp);
char *inet_ntoa(struct in_addr in);

下面这对更新的函数也能完成前面 3 个函数同样的功能，并且它们同时适用 IPv4 地址和 IPv6 地址：

#include <arpa/inet.h>
// p:点分十进制的IP字符串，n:表示network，网络字节序的整数
int inet_pton(int af, const char *src, void *dst);
	af:地址族： AF_INET AF_INET6
	src:需要转换的点分十进制的IP字符串
	dst:转换后的结果保存在这个里面
// 将网络字节序的整数，转换成点分十进制的IP地址字符串
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
	af:地址族： AF_INET AF_INET6
	src: 要转换的ip的整数的地址
	dst: 转换成IP地址字符串保存的地方
	size：第三个参数的大小（数组的大小）
	返回值：返回转换后的数据的地址（字符串），和 dst 是一样的

socket中IP地址转换函数的使用

/*
    #include <arpa/inet.h>
    // p:点分十进制的IP字符串，n:表示network，网络字节序的整数
    int inet_pton(int af, const char *src, void *dst);
        af:地址族： AF_INET  AF_INET6
        src:需要转换的点分十进制的IP字符串
        dst:转换后的结果保存在这个里面

    // 将网络字节序的整数，转换成点分十进制的IP地址字符串
    const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
        af:地址族： AF_INET  AF_INET6
        src: 要转换的ip的整数的地址
        dst: 转换成IP地址字符串保存的地方
        size：第三个参数的大小（数组的大小）
        返回值：返回转换后的数据的地址（字符串），和 dst 是一样的

*/

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

int main()
{
    //创建一个字符串
    char buf[] = "192.168.1.4";
    unsigned int num = 0;

    //将点分十进制IP字符串转换为网络字节序的整数
    inet_pton(AF_INET, buf, &num);
    unsigned char *p = (unsigned char *)&num;
    printf("%d %d %d %d\n",*p, *(p+1), *(p+2), *(p+3));

    //将网络字节序的IP整数转换为点分十进制的IP字符串
    char ip[16] = "";
    const char* str = inet_ntop(AF_INET, &num, ip, 16);
    printf("str:%s\n", str);
    printf("%d\n", ip == str); //传入的IP和返回的str一样
    return 0;
}

TCP通信流程

// TCP 和 UDP -> 传输层的协议
UDP:用户数据报协议，面向无连接，可以单播，多播，广播， 面向数据报，不可靠，没有拥塞控制
TCP:传输控制协议，面向连接的，可靠的，基于字节流，仅支持单播传输
             	UDP                          TCP
是否创建连接 	  无连接                         面向连接
是否可靠       不可靠                         可靠的  
连接的对象个数  一对一、一对多、多对一、多对多    支持一对一
传输的方式     面向数据报                      面向字节流
首部开销       8个字节                        最少20个字节
适用场景       实时应用（视频会议，直播）        可靠性高的应用（文件传输）

socket通信基础

// TCP 通信的流程
// 服务器端 （被动接受连接的角色）
1. 创建一个用于监听的套接字
- 监听：监听有客户端的连接
- 套接字：这个套接字其实就是一个文件描述符
2. 将这个监听文件描述符和本地的IP和端口绑定（IP和端口就是服务器的地址信息）
- 客户端连接服务器的时候使用的就是这个IP和端口
3. 设置监听，监听的fd开始工作,监听服务器端的读缓冲区
4. 阻塞等待，当有客户端发起连接，解除阻塞，接受客户端的连接，会得到一个和客户端通信的套接字（fd）与监听的fd不一样
5. 通信
- 接收数据
- 发送数据
6. 通信结束，断开连接

// 客户端
1. 创建一个用于通信的套接字（fd）
2. 连接服务器，需要指定连接的服务器的 IP 和 端口
3. 连接成功了，客户端可以直接和服务器通信
- 接收数据
- 发送数据
4. 通信结束，断开连接// 客户端

6. 套接字函数

#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
		- SOCK_STREAM : 流式协议默认使用 TCP
		- 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 : 未连接的和已经连接的和的最大值，一般取5就行了，不放心就取128
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
	- 功能：接收客户端连接，默认是一个阻塞的函数，阻塞等待客户端连接
	- 参数：
		- sockfd : 用于监听的文件描述符
		- 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); // 读数据

利用socket实现客户端和服务端之间通信

// TCP 通信的服务器端

#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main()
{
    //1.创建套接字，用于监听
    int lfd = socket(AF_INET, SOCK_STREAM, 0); //lfd是用于监听的文件描述符
    if(lfd == -1){
        perror("socket");
        exit(-1);
    }

    //2.绑定
    struct sockaddr_in saddr;
    saddr.sin_family = PF_INET;
    //inet_pton(AF_INET, "192.168.74.128", saddr.sin_addr.s_addr);
    saddr.sin_addr.s_addr = INADDR_ANY; //0.0.0.0,监听了服务器端所有的网卡IP地址
    saddr.sin_port = htons(9999); 
    int ret = bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
    if(ret == -1){
        perror("bind");
        exit(-1);
    }

    //3.监听
    listen(lfd, 8);
    if(ret == -1){
        perror("listen");
        exit(-1);
    }

    //4.接收客户端数据
    struct sockaddr_in clientaddr;
    socklen_t len = sizeof(clientaddr);
    int sfd = accept(lfd, (struct sockaddr *)&clientaddr, &len); //cfd表示客户端ID
    if(sfd == -1){
        perror("accept");
        exit(-1);
    }

    //输出客户端的信息
    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);
    char recvBuf[1024] = {0};
    //5.
    //获取客户端的数据
    while(1){
    
    int let = read(sfd, recvBuf, sizeof(recvBuf));
    if(let == -1)
    {
        perror("read");
        exit(-1);
    }   else if(let > 0){
        printf("recv client data: %s\n", recvBuf);
    }   else if(let == 0) {
        //表示客户端断开连接
        printf("client closed... \n");
        break;
    }

    //给客户端发送数据
    char *data = "hello, i am server";
    write(sfd, data, strlen(data));
    }
    //关闭文件描述符
    close(sfd);
    close(lfd);
    return 0;
}

// TCP通信的客户端

#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main() {

    //1.创建一个用于通信的socket
    int cfd = socket(AF_INET, SOCK_STREAM, 0);
    if(cfd == -1)
    {
        perror("socket");
        exit(-1);
    }
    //2.连接服务器端
    struct sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    inet_pton(AF_INET, "192.168.74.128", &serverAddr.sin_addr.s_addr);
    serverAddr.sin_port = htons(9999);

    int ret = connect(cfd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
    if(ret == -1){
        perror("connect");
        exit(-1);
    }
    char recvBuf[1024] = {0};
    while(1){
    //3.通信
    char *data = "hello, i am client";
    //给服务端发送数据
    sleep(1);
    write(cfd, data, strlen(data));
    
    int len = read(cfd, 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(cfd);
    return 0;
}

一些可行的处理

//char * data = "hello,i am server";
//实现客户端发什么，服务器就回什么
  char * data = recvBuf;//回射

//实现发送键盘输入的字符串
//char * data = "hello,i am client";
char data[1024]; //注意这里在每次循环的时候应该通过memset(data, 0, 1024)清空客户端和服务器端的缓存区。
printf("请输入字符串：");
scanf("%s",data);//自己输入字符串

7. TCP 三次握手

TCP 是一种面向连接的单播协议，在发送数据前，通信双方必须在彼此间建立一条连接。所谓的“连接”，其实是客户端和服务器的内存里保存的一份关于对方的信息，如 IP 地址、端口号等。

TCP 可以看成是一种字节流，它会处理 IP 层或以下的层的丢包、重复以及错误问题。在连接的建立过程中，双方需要交换一些连接的参数。这些参数可以放在 TCP 头部。

TCP 提供了一种可靠、面向连接、字节流、传输层的服务，采用三次握手建立一个连接。采用四次挥手来关闭一个连接。

三次握手的目的是保证双方互相之间建立了连接。三次握手发生在客户端连接的时候，当调用connect()，底层会通过TCP协议进行三次握手。

ACK用来做确认，SYN用来做连接，FIN用来断开连接。

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 发送来的报文段的确认序号。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 的紧急指针是发送端向接收端发送紧急数据的方法。

第三步的目的：确定Client端的接收没问题；ACK代表标志位，ack表示确认序号，seq代表序号，标志位为1确认需要才有效。

第一次握手：
	1.客户端将SYN标志位置为1
	2.生成一个随机的32位的序号seq=J ， 这个序号后边是可以携带数据（数据的大小）
第二次握手：
	1.服务器端接收客户端的连接： ACK=1
	2.服务器会回发一个确认序号： ack=客户端的序号 + 数据长度 + SYN/FIN(按一个字节算)
	3.服务器端会向客户端发起连接请求： SYN=1
	4.服务器会生成一个随机序号：seq = K
第三次握手：
	1.客户单应答服务器的连接请求：ACK=1
	2.客户端回复收到了服务器端的数据：ack=服务端的序号 + 数据长度 + SYN/FIN(按一个字节算)

8. TCP 滑动窗口

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

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

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

窗口理解为缓冲区的大小；滑动窗口的大小会随着发送数据和接收数据而变化。通信的双方都有发送缓冲区和接收数据的缓冲区。

发送方的缓冲区：
	白色格子：空闲的空间
	灰色格子：数据已经被发送出去了，但是还没有被接收
	紫色格子：还没有发送出去的数据
接收方的缓冲区：
	白色格子：空闲的空间
	紫色格子：已经接收到的数据

# mss: Maximum Segment Size(一条数据的最大的数据量)
# win: 滑动窗口
1. 客户端向服务器发起连接，客户端的滑动窗口是4096，一次发送的最大数据量是1460
2. 服务器接收连接情况，告诉客户端服务器的窗口大小是6144，一次发送的最大数据量是1024
3. 第三次握手
4. 4-9 客户端连续给服务器发送了6k的数据，每次发送1k
5. 第10次，服务器告诉客户端：发送的6k数据已经接收到，存储在缓冲区中，缓冲区数据已经处理了2k,窗
口大小是2k
6. 第11次，服务器告诉客户端：发送的6k数据已经接收到，存储在缓冲区中，缓冲区数据已经处理了4k,窗
口大小是4k
7. 第12次，客户端给服务器发送了1k的数据
8. 第13次，客户端主动请求和服务器断开连接，并且给服务器发送了1k的数据，第一次挥手
9. 第14次，服务器回复ACK 8194, a:同意断开连接的请求 b:告诉客户端已经接受到方才发的2k的数据
c:滑动窗口2k，第二次回收
10.第15、16次，通知客户端滑动窗口的大小
11.第17次，第三次挥手，服务器端给客户端发送FIN,请求断开连接
12.第18次，第四次挥手，客户端同意了服务器端的断开请求

1
2
3

四次挥手发生在断开连接的时候，在程序中当调用了close()会使用TCP协议进行四次挥手。
客户端和服务器端都可以主动发起断开连接，谁先调用close()谁就是发起。
因为在TCP连接的时候，采用三次握手建立的的连接是双向的，在断开的时候需要双向断开。

10. TCP 通信并发

要实现TCP通信服务器处理并发的任务，使用多线程或者多进程来解决。
思路：
	1. 一个父进程，多个子进程
	2.父进程负责等待并接受客户端的连接
	3.子进程：完成通信，接受一个客户端连接，就创建一个子进程用于通信。

多进程实现TCP并发通信：

//服务器端
#include <stdio.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <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 serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(9999);
    serverAddr.sin_addr.s_addr = INADDR_ANY; //0 
    //绑定
    int bret = bind(lfd, (struct sockaddr*) &serverAddr, sizeof(serverAddr));
    if(bret == -1)
    {
        perror("bind");
        exit(-1); //exit(0)正常退出
    }

    //监听
    int lret = listen(lfd, 128);
    if(lret == -1)
    {
        perror("listen");
        exit(-1);
    }

    //不断循环等待客户端连接
    while(1)
    {
        //接收连接
        struct sockaddr_in clientAddr;
        int len  = sizeof(clientAddr);
        int cfd = accept(lfd, (struct sockaddr *) &clientAddr, &len);
        if(cfd == -1)
        {
            if(errno == EINTR){ //加上这个处理，防止client终止后再想进入出错
                continue;
            }
            perror("accept");
            exit(-1);
        }

        //每一个连接进来，就创建一个子进程与客户端通信
        pid_t pid = fork();
        if(pid == 0){
            //子进程
            //获取客户端的信息
            char clientIP[16];
            inet_ntop(AF_INET, &clientAddr.sin_addr.s_addr, clientIP, sizeof(clientIP));
            unsigned short clientPort = ntohs(clientAddr.sin_port);
            printf("clientIP = %s, port = %d\n", clientIP, clientPort);

            // /接收客户端发来的数据
            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("receive client buf : %s\n", recvbuf);
                }   else{
                    printf("client close...\n");
                    exit(-1);
                }

                write(cfd, recvbuf, strlen(recvbuf));
            }
            close(cfd);
            exit(0); //退出当前子进程
        }
    }
    close(lfd);
    return 0;
}

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

int main() {

    // 1.创建套接字
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if(fd == -1) {
        perror("socket");
        exit(-1);
    }

    // 2.连接服务器端
    struct sockaddr_in serveraddr;
    serveraddr.sin_family = AF_INET;
    inet_pton(AF_INET, "192.168.74.128", &serveraddr.sin_addr.s_addr);
    serveraddr.sin_port = htons(9999);
    int ret = connect(fd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));

    if(ret == -1) {
        perror("connect");
        exit(-1);
    }
    
    // 3. 通信
    char recvBuf[1024];
    int i = 0;
    while(1) {
        
        sprintf(recvBuf, "data : %d\n", i++);
        
        // 给服务器端发送数据
        write(fd, recvBuf, strlen(recvBuf)+1);

        int len = read(fd, recvBuf, sizeof(recvBuf));
        if(len == -1) {
            perror("read");
            exit(-1);
        } else if(len > 0) {
            printf("recv server : %s\n", recvBuf);
        } else if(len == 0) {
            // 表示服务器端断开连接
            printf("server closed...");
            break;
        }
        memset(recvBuf, 0, 1024);
        sleep(1);
    }

    // 关闭连接
    close(fd);
    return 0;
}

多线程实现TCP通信并发实现

//服务器端，多线程实现
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

struct sockInfo {
    int fd; // 通信的文件描述符
    struct sockaddr_in addr;
    pthread_t tid;  // 线程号
};

struct sockInfo sockinfos[128];

void * working(void * arg) {
    // 子线程和客户端通信   cfd 客户端的信息 线程号
    // 获取客户端的信息
    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, prot 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 client : %s\n", recvBuf);
        } else if(len == 0) {
            printf("client closed....\n");
            break;
        }
        write(pinfo->fd, recvBuf, strlen(recvBuf) + 1);
    }
    close(pinfo->fd);
    return NULL;
}

int main() {

    // 创建socket
    int lfd = socket(PF_INET, SOCK_STREAM, 0);
    if(lfd == -1){
        perror("socket");
        exit(-1);
    }

    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(9999);
    saddr.sin_addr.s_addr = INADDR_ANY;

    // 绑定
    int ret = bind(lfd,(struct sockaddr *)&saddr, sizeof(saddr));
    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;
        sockinfos[i].tid = -1;
    }

    // 循环等待客户端连接，一旦一个客户端连接进来，就创建一个子线程进行通信
    while(1) {

        struct sockaddr_in cliaddr;
        int len = sizeof(cliaddr);
        // 接受连接
        int cfd = accept(lfd, (struct sockaddr*)&cliaddr, &len);

        struct sockInfo * pinfo;
        for(int i = 0; i < max; i++) {
            // 从这个数组中找到一个可以用的sockInfo元素
            if(sockinfos[i].fd == -1) {
                pinfo = &sockinfos[i];
                break;
            }
            if(i == max - 1) {
                sleep(1);
                i--;
            }
        }

        pinfo->fd = cfd;
        memcpy(&pinfo->addr, &cliaddr, len);

        // 创建子线程
        pthread_create(&pinfo->tid, NULL, working, pinfo);

        pthread_detach(pinfo->tid);
    }

    close(lfd);
    return 0;
}

11. TCP状态转换

红色实线：客户端；绿色虚线：服务端

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 来控制实现半连接状态：

从程序的角度，可以使用 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。

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

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

12. 端口复用

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

防止服务器重启时之前绑定的端口还未释放

程序突然退出而系统没有释放端口

常看网络相关信息的命令netstat
	参数：
		-a 所有的socket
		-p 显示正在使用socket的程序的名称
		-n 直接使用IP地址，而不通过域名服务器
    netstat -anp | grep 9999 //查看9999端口的socket,程序名称和IP

//当发送端和接收端都开启时
tcp   0      0 0.0.0.0:9999            0.0.0.0:*               LISTEN      25728/./server      
tcp   0      0 127.0.0.1:9999          127.0.0.1:38928         ESTABLISHED 25728/./server      
tcp   0      0 127.0.0.1:38928         127.0.0.1:9999          ESTABLISHED 25783/./client

//当服务器端断开连接时
tcp   0      0 127.0.0.1:9999          127.0.0.1:38928         FIN_WAIT2   -                   
tcp   1      0 127.0.0.1:38928         127.0.0.1:9999          CLOSE_WAIT  25783/./client 

//当两端都结束时
tcp   0      0 127.0.0.1:9999          127.0.0.1:38978         TIME_WAIT   -

出现的问题：服务器重启有一个2MSL的时间，这段时间不能再用该端口，否则会报错bind()；为了解决这个问题，可以通过端口复用。

#include <sys/types.h>
#include <sys/socket.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参数的大小
	端口复用，设置的时机是在服务器绑定端口之前。
	setsockopt();
	bind();

Linux服务器项目-8

socket通信基础

字节序

简介

字节序转换函数：

3. Socket地址

专用socket地址

4. IP地址转换（字符串ip-整数 ，主机、网络字节序的转换）

TCP通信流程

6. 套接字函数

7. TCP 三次握手

8. TCP 滑动窗口

10. TCP 通信并发

11. TCP状态转换

12. 端口复用

4. IP地址转换（字符串ip-整数，主机、网络字节序的转换）