Linux网络——TcpServer

一、UDP 与 TCP

在现实生活中，Udp 类似于发传单，Tcp 类似于邮局的挂号信服务。

1.1 UDP（用户数据报协议）

• 无连接：发放传单时，你不需要提前和接受传单的人建立联系，直接把传单发出去。
• 不可靠：有些传单可能会丢失、被扔掉或者没有被正确传递，但你不会重新发放。
• 无流控制和无拥塞控制：你可以很快地发放很多传单，不考虑每个人是否能接收到。
• 低延迟：由于不需要建立联系和跟踪，传单发放的速度非常快。

1.2 TCP（传输控制协议）

• 面向连接：寄挂号信之前，你需要填写表单并支付费用，类似于 TCP 建立连接的过程。
• 可靠性：挂号信可以跟踪，每一步都有记录，确保信件安全送达。若有问题，邮局会负责调查并重新投递。
• 流控制和拥塞控制：邮局会根据工作负荷调整处理速度，避免一次处理过多信件导致延误。
• 数据传输顺序：挂号信件会按照顺序逐步处理和递送，确保不会弄乱信件的顺序。

1.3 总结

UDP：适用于对传输速度和实时性要求高，但对可靠性要求较低的场景，例如视频直播、在线游戏和语音通信。UDP 的传单发放方式虽然不保证每张传单都能被接收，但可以快速地将信息传递出去，适用于实时性和速度优先的通信。

TCP：适用于需要可靠传输和顺序保证的场景，例如网页浏览、文件传输和电子邮件。TCP 的挂号信服务确保每一封信都能安全到达目的地，适用于需要可靠性和顺序的通信。

二、TCP 的三次握手与四次挥手

为了提高接计算效率，需要发送方与接收方约定：一起开启、一起结束。这个约定的开启与结束就叫做连接的建立与关闭。

2.1 三次握手

1. TCP建立连接时，发送方先传达一个连接意愿

2. 接收方收到后需要响应这个消息，若不响应，发送方可能会一直重发消息。除此之外，接收方还要表达连接意愿

3.发送方响应接收方的意愿。

这就是TCP协议中所谓的三次握手。

2.2 TCP的面向字节流

面向字节流意味着数据被视为一连串无结构的字节，而不是一个个独立的数据包或消息。在发送数据时，应用程序可以将数据作为一个连续的字节流发送，TCP 会负责将这些字节分割成适当大小的数据段（segments）并通过网络传输。

2.2.1 TCP 面向字节流的特点和原因

1.数据传输的连续性：

TCP 提供一种连续的数据传输方式，应用程序可以以任意大小发送数据，无需关心底层网络的传输单元（数据包）。

这种方式对于许多应用场景来说非常方便，例如文件传输、流媒体传输等，数据可以以任意大小和顺序发送。

2.数据的有序性：

TCP 确保数据按照发送的顺序到达接收方，即使底层网络可能会将数据包乱序传输。

通过面向字节流，TCP 可以在接收端重新组装数据，确保数据的顺序性，对于依赖顺序数据的应用非常重要。

3.数据分段和重组：

TCP 将应用程序发送的字节流分割成适合传输的段，每个段包含一个序列号，用于在接收端重新组装数据。

接收方可以根据这些序列号将数据段正确地拼接成原始的字节流。

4.流控制和拥塞控制：

• TCP 的流控制机制（如滑动窗口协议）和拥塞控制机制能够更好地管理和优化字节流传输。
• 这些机制帮助 TCP 在保证数据完整性和顺序性的同时，提高网络传输的效率和可靠性。

2.2.2 实际应用中的好处

• 灵活性：面向字节流使得应用程序可以以任意大小和任意顺序发送数据，TCP 负责处理这些数据的传输细节。
• 简化应用开发：应用开发者不需要处理底层网络传输的复杂性，可以专注于应用逻辑。
• 可靠性：TCP 确保数据完整无误地传输到目的地，即使网络环境不稳定。

2.3 四次挥手

1. 发送方发起断开意愿

2. 接收端响应消息

3. 接收方表达断开意愿

4. 发送方响应断开意愿

可以看出，这和三次握手的规律大致相同，只是把中间一条拆分成了两条，其中2和3不可以合并为一条，当接收方等待数据数据接收完整后，才可以表达断开意愿。

三、TCPServer 的封装

3.1 整体框架

TCPServer 的整体框架与 UDPServer 基本相同，都是采用默认不传入 ip ，只传入 port ，并在类内创建套接字并完成绑定。但是TCP有一个不同点，TCP会处于监听状态，等待用户的请求。

在 TCP 通信中，服务器需要等待客户端的连接请求。listen 函数将一个已经绑定到特定地址和端口的套接字转换为监听套接字，这意味着服务器开始监听指定的地址和端口上的连接请求。
建立连接：在 TCP 中，通信开始前必须先建立连接。listen 函数使服务器进入监听状态，准备处理来自客户端的连接请求。这与 TCP 的面向连接特性直接相关。

根据上面的描述，可以得到，在TCP协议中，一般存在两个 sockfd ，第一个 sockfd 类似于UDP协议中的 sockfd，以下称为 listensockfd ，它标定TCP服务端，用于客户端与服务器的链接，当客户端与服务器已经连接时，第二个 sockfd 就要产生作用了，它用于标定与TCP客户端相连的唯一用户。

以饭店拉客为例子， listensockfd 用于标定唯一的一家饭店，当顾客进入饭店时，就会有专门的一个服务员为顾客提供服务，这就是 sockfd 。

#include <iostream>

static const int gdefaultsockfd = -1;
class TcpServer
{
public:
    TcpServer(uint16_t port) : _listensockfd(gdefaultsockfd), _port(port), _isrunning(false)
    {
    }
    ~TcpServer() {}

private:
    int _listensockfd;
    uint16_t _port;
    bool _isrunning;
};

3.2 服务器的初始化

初始化的前半部分工作与UDP类似，都是创建套接字、创建并填充 sockaddr_in 结构体、绑定地址与端口。不同的是，在创建套接字时， socket 的第二个参数设置为 SOCK_STREAM ，用于标定 TCP 协议，在绑定后，使用 listen 函数持续监听是否有新用户的到来。

listen 函数

其中，listen 函数原型如下：

参数：
声明 sockfd 处于监听状态, 并且最多允许有 backlog 个客户端处于连接等待状态, 如果接收到更多的连接请求就忽略，这里设置不会太大（一般是5）。
返回值：
listen() 成功返回0，失败返回 -1;

enum
{
    SOCKET_ERROR = 1,
    BIND_ERROR,
    LISTEN_ERROR,
};
static const int gdefaultsockfd = -1;
static const int gbacklog = 8;    
    void InitServer()
    {
        _listensockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (_listensockfd < 0)
        {
            LOG(FATAL, "socket erro ");
            exit(SOCKET_ERROR);
        }

        struct sockaddr_in local;

        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(_port);
        local.sin_addr.s_addr = INADDR_ANY;

        int n = ::bind(_listensockfd, (struct sockaddr *)&local, sizeof(local));
        if (n < 0)
        {
            LOG(FATAL, "bind error");
            exit(BIND_ERROR);
        }
        LOG(DEBUG, "bind success, sockfd is : %d\n", _listensockfd);

        n = listen(_listensockfd, gbacklog);
        if (n < 0)
        {
            LOG(FATAL, "listen error");
            exit(LISTEN_ERROR);
        }
        LOG(DEBUG, "listen success, sockfd is : %d\n", _listensockfd);
    }

3.3 服务器的运行

因为UDP服务器允许接入多一个用户，为了让多个用户之间的操作不受影响，可以有很多种策略，比如多进程、多线程、线程池等方案，这里例举多线程。

多线程写法

多线程首先就要使用到 pthread_create 函数，下面再来回顾一下该函数原型：


首先就要定义一个 thread_t 类型的变量用于记录线程的ID，在调用该函数时，传入的回调方法与回调方法需要的参数都需要根据要求而定，下面就直接忽略了：

//主函数体内：
pthread_t t;
pthread_create(&t, nullptr, HandlerSock, ...);

使用 pthread_detach(pthread_self()) 标识线程主动分离

//执行的回调方法
static void *HandlerSock(void *args)
{
    pthread_detach(pthread_self());
    xxx = static_cast<ThreadData *>(args);
    //可以进一步封装要执行的操作
    delete xxx;
    return nullptr;
}

accept 函数

三次握手完成后，服务器调用accept()接受连接，函数原型如下：

传入参数：

1. 如果服务器调用 accept() 时还没有客户端的连接请求,就阻塞等待直到有客户端连接上来;
2. addr 是一个传出参数，accept() 返回时传出客户端的地址和端口号;
3. 如果给 addr 参数传 NULL，表示不关心客户端的地址;
4. addrlen 参数是一个传入传出参数(value-result argument), 传入的是调用者提供的, 缓冲区addr 的长度以避免缓冲区溢出问题, 传出的是客户端地址结构体的实际长度（有可能没有占满调用者提供的缓冲区）

返回值：

这里的返回值就是我们在上面所说的单独服务每桌客人的服务员，该函数返回一个新的 sockfd 用于标定与服务器相连的唯一用户。

运行函数

    void Loop()
    {
        _isrunning = true;
        while (_isrunning)
        {
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int sockfd = accept(_listensockfd, (struct sockaddr *)&peer, &len);
            if (sockfd > 0)
            {
                LOG(WARNING, "accept error\n");
                continue;
            }
            pthread_t t;
            pthread_create(&t, nullptr, ...); // 线程执行的回调方法与传参
        }
    }

四、TCPClient 的封装

TcpClient 的封装与 UdpClient 类似，调用时都需要传入ip地址与端口号，在main函数中设置环境变量，根据环境变量的值来判断执行是否有误。

Linux网络——套接字与UdpServer-CSDN博客

其中也有不同，下面先来看引入的两个新函数：

connect 函数

客户端需要调用connect()连接服务器，在三次握手中，connect 函数主要负责发起第一次握手和完成第三次握手。

• 当客户端调用 connect 函数时，它会向服务器发送一个 SYN 包（第一次握手）。
• 客户端的 TCP/IP 协议栈会处理来自服务器的 SYN-ACK 包，并自动回复一个 ACK 包（第三次握手）。

函数原型：

传入参数：

connect和bind的参数形式一致，区别在于bind的参数是自己的地址，而connect的参数是对方的地址。

返回值：
connect() 成功返回0，出错返回-1。

send 函数

send 函数是用于在网络编程中通过已连接的套接字发送数据的函数，通常用于 TCP 套接字编程。

传入参数：

sockfd：一个已连接的套接字描述符。这个套接字通常是通过 socket 函数创建、通过 connect 函数连接（客户端）或者通过 accept 函数接受（服务器）得到的。

buf：指向要发送的数据的缓冲区。

len：要发送的数据的长度（以字节为单位）。

flags：用于指定发送行为的标志位，一般设置为 0 即可。

    常用的标志位有：

     0：默认行为。

     MSG_DONTWAIT：非阻塞发送。

     MSG_OOB：发送带外数据。

     MSG_NOSIGNAL：发送时不触发 SIGPIPE 信号。

#include <iostream>
#include <string>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <cstring>

void Usage(std::string proc)
{
    std::cout << "Usage:\n\t" << proc << " serverip serverport\n"
              << std::endl;
}

int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    std::string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]);

    int sockfd = ::socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        std::cerr << "socket error" << std::endl;
        exit(2);
    }

    // tcp client 要bind，不要显示的bind.
    struct sockaddr_in server;
    // 构建目标主机的socket信息
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport);
    server.sin_addr.s_addr = inet_addr(serverip.c_str());

    int n = connect(sockfd, (struct sockaddr *)&server, sizeof(server));
    if (n < 0)
    {
        std::cerr << "connect error" << std::endl;
        exit(3);
    }

    while(true)
    {
        std::cout << "Please Enter# ";
        std::string outstring;
        std::getline(std::cin, outstring);

        ssize_t s = send(sockfd, outstring.c_str(), outstring.size(), 0); //write
        if(s > 0)
        {
            char inbuffer[1024];
            ssize_t m = recv(sockfd, inbuffer, sizeof(inbuffer)-1, 0);
            if(m > 0)
            {
                inbuffer[m] = 0;
                std::cout << inbuffer<< std::endl;
            }
            else
            {
                break;
            }
        }
        else
        {
            break;
        }
    }

    ::close(sockfd);
    return 0;
}