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;
}