探索TCP：分包与粘包解析

#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

void sendMessage(int socket, const char* message) {
    uint32_t len = strlen(message);
    uint32_t networkLen = htonl(len);  // 转换为网络字节序

    // 发送消息长度
    send(socket, &networkLen, sizeof(networkLen), 0);
    // 发送消息体
    send(socket, message, len, 0);
}

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in serv_addr;

    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(12345);
    serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

    connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));

    sendMessage(sockfd, "Hello");
    sendMessage(sockfd, "World");

    close(sockfd);
    return 0;
}

在网络编程中，ET（边缘触发）和LT（水平触发）是两种常见的事件通知机制，用于非阻塞IO操作。这些机制在Linux系统中常通过epoll来实现。下面我将给出示例代码，分别展示如何在接收方使用ET和LT模式处理TCP数据。

4.4接收方代码

4.4.1水平触发（LT）模式

水平触发（Level Triggered）是默认的工作方式，如果文件描述符准备好了，它会一直通知你，直到你做了相应的操作。

在 LT 模式中，每次 epoll_wait 调用返回时，程序只需处理当前可用的数据。它不需要一次性读取所有数据，因为如果有剩余数据，epoll 会在下一次循环中再次通知该文件描述符的事件，直到所有数据被处理完毕。

cpp 复制代码

#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#include <unistd.h>

void lt_epoll(int listen_sock) {
    int epfd = epoll_create(1);
    struct epoll_event ev, events[10];

    ev.events = EPOLLIN; // 监听输入事件
    ev.data.fd = listen_sock;
    epoll_ctl(epfd, EPOLL_CTL_ADD, listen_sock, &ev);

    while (true) {
        int nfds = epoll_wait(epfd, events, 10, -1);
        for (int i = 0; i < nfds; ++i) {
            if (events[i].data.fd == listen_sock) {
                struct sockaddr_in client_addr;
                socklen_t client_addr_len = sizeof(client_addr);
                int conn_sock = accept(listen_sock, (struct sockaddr *)&client_addr, &client_addr_len);
                char buffer[1024];
                ssize_t nread = read(conn_sock, buffer, sizeof(buffer));
                if (nread > 0) {
                    buffer[nread] = '\0';
                    std::cout << "Received: " << buffer << std::endl;
                }
                close(conn_sock);
            }
        }
    }
    close(epfd);
}

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in serv_addr;

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

    bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    listen(sockfd, 10);
    lt_epoll(sockfd);
    close(sockfd);
    return 0;
}

4.4.2边缘触发（ET）模式

边缘触发（Edge Triggered）是一种更高效的方式，只有在状态发生变化时，即文件描述符从未准备好变为准备好时，会通知一次。

在 ET 模式下，接收方需要在每次 epoll_wait 返回时尽可能多地读取数据，直到返回 EAGAIN 错误，表明当前没有更多数据可读。这种模式要求程序更加精确地控制数据的读取过程，以避免漏掉任何数据，因为如果有数据未被读取完毕，epoll 不会再次通知你这一事件。

cpp 复制代码

#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <fcntl.h>

void setNonBlocking(int sock) {
    int opts;
    opts = fcntl(sock, F_GETFL);
    if (opts < 0) {
        perror("fcntl(F_GETFL)");
        exit(EXIT_FAILURE);
    }
    opts = (opts | O_NONBLOCK);
    if (fcntl(sock, F_SETFL, opts) < 0) {
        perror("fcntl(F_SETFL)");
        exit(EXIT_FAILURE);
    }
}

void et_epoll(int listen_sock) {
    int epfd = epoll_create(1);
    struct epoll_event ev, events[10];

    ev.events = EPOLLIN | EPOLLET; // 监听输入事件，边缘触发
    ev.data.fd = listen_sock;
    epoll_ctl(epfd, EPOLL_CTL_ADD, listen_sock, &ev);

    while (true) {
        int nfds = epoll_wait(epfd, events, 10, -1);
        for (int i = 0; i < nfds; ++i) {
            if (events[i].data.fd == listen_sock) {
                struct sockaddr_in client_addr;
                socklen_t client_addr_len = sizeof(client_addr);
                int conn_sock = accept(listen_sock, (struct sockaddr *)&client_addr, &client_addr_len);
                setNonBlocking(conn_sock);
                while (true) {
                    char buffer[1024];
                    ssize_t nread = read(conn_sock, buffer, sizeof(buffer));
                    if (nread > 0) {
                        buffer[nread] = '\0';
                        std::cout << "Received: " << buffer << std::endl;
                    } else if (nread == 0 || (nread < 0 && errno != EAGAIN)) {
                        close(conn_sock);
                        break;
                    }
                }
            }
        }
    }
    close(epfd);
}

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in serv_addr;

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

    bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    listen(sockfd, 10);
    setNonBlocking(sockfd);
    et_epoll(sockfd);
    close(sockfd);
    return 0;
}

4.4.5注意点

在LT模式中，每次epoll_wait返回时，如果文件描述符有事件，它会继续通知直到处理完毕。
在ET模式中，你必须循环处理数据直到EAGAIN返回，因为新事件只在状态变化时通知一次。
setNonBlocking函数设置套接字为非阻塞模式，这对ET模式尤为重要，以确保不会因为阻塞调用而停滞。