网络编程（TCP）

TCP编程

TCP：全双工通信、面向连接、可靠

TCP（即传输控制协议）：是一种面向连接的传输层协议，它能提供高可靠性通信(即数据无误、数据无丢失、数据无失序、数据无重复到达的通信)。

高可靠原因：

三次握手、四次挥手

序列号和应答机制

超时，错误重传机制

拥塞控制、流量控制(滑动窗口)

适用场景

适合于对传输质量要求较高的通信

在需要可靠数据传输的场合，通常使用TCP协议

MSN/QQ等即时通讯软件的用户登录账户管理相关的功能通常采用TCP协议

通信流程

函数接口

• socket

int socket(int domain, int type, int protocol);
功能：创建套接字
参数：
   domain：协议族
     AF_UNIX, AF_LOCAL  本地通信
     AF_INET            ipv4
     AF_INET6            ipv6
  type：套接字类型
     SOCK_STREAM：流式套接字
     SOCK_DGRAM：数据报套接字
     SOCK_RAW：原始套接字
  protocol：协议 - 填0 自动匹配底层 ，根据type
  系统默认自动帮助匹配对应协议
     传输层：IPPROTO_TCP、IPPROTO_UDP、IPPROTO_ICMP
     网络层：htons(ETH_P_IP|ETH_P_ARP|ETH_P_ALL)
返回值：
    成功 文件描述符
    失败 -1，更新errno

• bind

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
功能：绑定
参数：
    socket：套接字
    addr：用于通信结构体 (提供的是通用结构体，需要根据选择通信方式，填充对应结构体-通信当时socket第一个参数确定)   
    addrlen：结构体大小   
返回值：成功 0   
       失败-1,更新errno
  
通用结构体：
struct sockaddr {
    sa_family_t sa_family;
    char        sa_data[14];
}

ipv4通信结构体：
struct sockaddr_in {
    sa_family_t    sin_family;
    in_port_t      sin_port;  
    struct in_addr sin_addr;  
};
struct in_addr {
    uint32_t       s_addr;    
};

本地通信结构体：
struct sockaddr_un {
     sa_family_t sun_family;               /* AF_UNIX */
     char        sun_path[108];            /* pathname */
 };

• listen

int listen(int sockfd, int backlog);
功能:监听，将主动套接字变为被动套接字
参数：
 sockfd：套接字
 backlog：同时响应客户端请求链接的最大个数，不能写0.
          不同平台可同时链接的数不同，一般写6-8个
          (队列1：保存正在连接)
          (队列2，连接上的客户端)
返回值：成功 0   
       失败-1,更新errno 

• accept

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
accept(sockfd,NULL,NULL);
功能：阻塞函数，阻塞等待客户端的连接请求，如果有客户端连接，
则accept()函数返回，返回一个用于通信的套接字文件;
参数：
   Sockfd ：套接字
   addr： 链接客户端的ip和端口号
      如果不需要关心具体是哪一个客户端，那么可以填NULL;
   addrlen：结构体的大小
     如果不需要关心具体是哪一个客户端，那么可以填NULL;
返回值： 
     成功：文件描述符; //用于通信
	 失败：-1，更新errno

• recv

ssize_t recv(int sockfd, void *buf, size_t len, int flags);
功能: 接收数据 
参数： 
    sockfd： acceptfd ;
    buf  存放位置
    len  大小
    flags  一般填0，相当于read()函数
    MSG_DONTWAIT  非阻塞
返回值： 
    < 0  失败出错  更新errno
    ==0  表示客户端退出
    >0   成功接收的字节个数

• connect

int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
功能：用于连接服务器；
参数：
     sockfd：socket函数的返回值
     addr：填充的结构体是服务器端的；
     addrlen：结构体的大小
返回值: 
      -1 失败，更新errno
      正确 0 

• send

ssize_t send(int sockfd, const void *buf, size_t len, int flags);
功能：发送数据
参数：
    sockfd:socket函数的返回值
    buf：发送内容存放的地址
    len：发送内存的长度
    flags：如果填0，相当于write();

服务器

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
// tcp服务器一共有两种文件描述符，一类用于连接，一类用于通信
int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("usage:%s <端口号>\n", argv[0]);
        return -1;
    }
    char buf[128];
    int ret;
    // 1.创建套接字（socket）
    // socket函数返回值：用于连接的文件描述符
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err");
        return -1;
    }
    printf("sockfd:%d\n", sockfd);

    // 2. 指定网络信息
    struct sockaddr_in saddr,caddr;
    saddr.sin_family = AF_INET;            // IPV4
    saddr.sin_port = htons(atoi(argv[1])); // 端口号
    // saddr.sin_addr.s_addr = inet_addr("0.0.0.0"); // 虚拟机IP地址(自动获取)
    saddr.sin_addr.s_addr = INADDR_ANY; // 虚拟机IP地址()
    // INADDR_ANY是一个常量，它指代的是一个特殊的IP地址，即0.0.0.0
    // 在网络编程中，当一个进程需要绑定一个网络端口时，可以使用INADDR_ANY来指定该端口可以接受来自任何IP地址的连接请求
    int len=sizeof(caddr);
    // 3.绑定套接字（bind）
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err");
        return -1;
    }
    printf("bind ok\n");

    // 4.监听套接字（listen）
    if (listen(sockfd, 6) < 0)
    {
        perror("listen err");
        return -1;
    }
    printf("listen ok\n");

    // 5.接受客户端连接请求（accept）
    // accept函数返回值：用于通信的文件描述符
    while (1)
    {
        int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &len);
        if (acceptfd < 0)
        {
            perror("accpet err");
            return -1;
        }
        printf("port:%d ip:%s\n",ntohs(caddr.sin_port),inet_ntoa(caddr.sin_addr));
        printf("accpetfd:%d\n", acceptfd);

        // 6. 接收，发送数据（recv，send）
        while (1)
        {
            ret = recv(acceptfd, buf, sizeof(buf), 0);
            if (ret < 0)
            {
                perror("recv err");
                return -1;
            }
            else if (ret == 0)
            {
                printf("client exit\n");
                break;
            }
            else
            {
                printf("buf:%s\n", buf);
                memset(buf, 0, sizeof(buf));
            }
        }
        // 7.关闭套接字（close）
        close(acceptfd);
    }
    close(sockfd);

    return 0;
}

客户端

#include <stdio.h>
#include<stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
int main(int argc, char const *argv[])
{
    if (argc != 3)
    {
        printf("usage:%s <IP地址> <端口号>\n", argv[0]);
        return -1;
    }
    char buf[128];
    // 1.创建套接字（socket）
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err");
        return -1;
    }
    printf("sockfd:%d\n", sockfd);
    // 2.指定（服务器）网络信息
    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;                 // IPV4
    saddr.sin_port = htons(atoi(argv[2]));      // 端口号
    saddr.sin_addr.s_addr = inet_addr(argv[1]); // 虚拟机IP地址
    // 3.连接（connect）
    if (connect(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("connect err");
        return -1;
    }
    printf("connect ok\n");
    // 4.接收发送消息（recv send）
    while (1)
    {
        fgets(buf, sizeof(buf), stdin);
        send(sockfd, buf, sizeof(buf), 0);
        if (strcmp(buf, "quit\n") == 0)
            break;
    }

    // 5.关闭套接字（close）
    close(sockfd);
    return 0;
}

三次握手与四次挥手

三次握手

第一次握手必须由客户端发起

在TCP/IP协议中，TCP协议提供可靠的连接服务，采用三次握手建立一个连接。

服务器必须准备好接受外来的连接。这通过调用socket、 bind和listen函数来完成，称为被动打开(passive open)。

第一次握手：客户通过调用connect进行主动打开(active open)。这引起客户TCP发送一个SYN（表示同步）分节（SYN=J），它告诉服务器客户将在连接中发送到数据的初始序列号。并进入SYN_SEND状态，等待服务器的确认。

第二次握手：服务器必须确认客户的SYN，同时自己也得发送一个SYN分节，它含有服务器将在同一连接中发送的数据的初始序列号。服务器以单个字节向客户发送SYN和对客户SYN的ACK（表示确认），此时服务器进入SYN_RECV状态。

第三次握手：客户收到服务器的SYN+ACK。向服务器发送确认分节，此分节发送完毕，客户服务器进入ESTABLISHED状态，完成三次握手。

1. ‌SYN_SEND：客户端发送SYN报文后进入此状态，等待服务器的确认。
2. ‌SYN_RECV‌：服务器收到SYN报文后进入此状态，等待客户端的确认。
3. ‌ESTABLISHED‌：当客户端和服务器端都发送和接收了ACK报文后，连接进入此状态，表示连接已经建立，可以进行数据传输。

客户端的初始序列号为J，而服务器的初始序列号为K。在ACK里的确认号为发送这个ACK的一端所期待的下一个序列号。因为SYN只占一个字节的序列号空间，所以每一个SYN的ACK中的确认号都是相应的初始序列号加1，类似地，每一个FIN（表示结束）的ACK中的确认号为FIN的序列号加1。

第一次握手：客户端发送SYN握手包（seq：a），进入等待服务器应答的状态（SYN_SEND）

第二次握手：服务器在收到客户端发送的握手包之后，给客户端回复一个ACK，还有一个握手包SYN（seq：b ack：a+1），进入等待接收的状态（SYN_RECV）

第三次握手：客户端在收到服务器发送的握手包以及确认包之后，给服务器再回复一个确认包ACK（seq：c，ack：b+1）

发送一次数据都要有序列号，但是不一定有应答号，只有这一次的数据中有应答包的时候才会有应答号

四次挥手

第一次挥手既可以由客户端发起，也可以由服务器发起

TCP连接终止需四个分节

第一次挥手：某个应用进程首先调用close，我们称这一端执行主动关闭。这一端的TCP于是发送一个FIN分节，表示数据发送完毕。

第二次挥手：接收到FIN的另一端执行被动关闭（passive close）。这个FIN由TCP确认。它的接收也作为文件结束符传递给接收端应用进程（放在已排队等候应用进程接收到任何其他数据之后）。

第三次挥手：一段时间后，接收到文件结束符的应用进程将调用close关闭它的套接口。这导致它的TCP也发送一个FIN。

第四次挥手：接收到这个FIN的原发送端TCP对它进行确认。

TCP粘包、拆包

tcp粘包

tcp拆包

TCP粘包、拆包发生原因:

发生TCP粘包或拆包有很多原因，常见的几点：

1、要发送的数据大于TCP发送缓冲区剩余空间大小，将会发生拆包。

2、待发送数据大于MSS（传输层的最大报文长度），将进行拆包(到网络层拆包 - id ipflags )。

3、要发送的数据小于TCP发送缓冲区的大小，TCP将多次写入缓冲区的数据一次发送出去，将会发生粘包。

4、接收数据端的应用层没有及时读取接收缓冲区中的数据，将发生粘包。

粘包解决办法:

解决问题的关键在于如何给每个数据包添加边界信息，常用的方法有如下：

1、发送端给每个数据包添加包首部，首部中应该至少包含数据包的长度，这样接收端在接收到数据后，通过读取包首部的长度字段，便知道每一个数据包的实际长度了。

2、发送端将每个数据包封装为固定长度，这样接收端每次从接收缓冲区中读取固定长度的数据就自然而然的把每个数据包拆分开来。

3、可以在数据包之间设置边界，如添加特殊符号，这样，接收端通过这个边界就可以将不同的数据包拆分开。

4、延时发送

https://www.cnblogs.com/111testing/p/12810253.html