C / C++ / 系统课时

编写 TCP 客户端

编写 TCP 客户端

本课实现一个可直接编译运行的 Linux TCP 客户端:建立带超时的连接,可靠发送完整请求,半关闭写方向,并持续接收直到对端 EOF,同时把短写、系统调用中断和常见网络错误纳入处理路径。

学习目标

  • 使用 socket、connect、send、recv 完成 TCP 客户端主流程
  • 正确处理 send 短写、recv 返回 0、EINTR 与连接错误
  • 为连接建立和接收阶段增加明确的超时边界

客户端调用顺序

TCP 客户端先用 socket 创建文件描述符,再用 connect 发起连接。连接成功后,应用层可以双向收发;当请求发送完成时,可用 shutdown(fd, SHUT_WR) 告诉对端“后续不再发送”,但仍保留接收能力。最终 recv 返回 0,才表示对端已经关闭其发送方向。

TCP 客户端调用与异常分支

connect 默认可能阻塞较久,因此主示例把套接字临时切成非阻塞模式:如果返回 EINPROGRESS,就用 poll 等待可写,再读取 SO_ERROR 判断连接究竟成功还是失败。仅看到“可写”并不等于连接成功,这个二次检查不能省略。

实现可靠发送与超时连接

下面的程序连接到命令行指定的 IPv4 地址和端口,连接超时为 3 秒。send_all 不假设一次 send 能写完全部数据;接收阶段每次等待最多 3 秒,并把多次 recv 的结果累积起来,直到 EOF。

c
#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

static int connect_with_timeout(int fd,
                                const struct sockaddr *addr,
                                socklen_t addrlen,
                                int timeout_ms) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
        return -1;
    }

    int rc = connect(fd, addr, addrlen);
    if (rc == -1 && errno != EINPROGRESS) {
        return -1;
    }

    if (rc == -1) {
        struct pollfd pfd = {.fd = fd, .events = POLLOUT};
        do {
            rc = poll(&pfd, 1, timeout_ms);
        } while (rc == -1 && errno == EINTR);

        if (rc == 0) {
            errno = ETIMEDOUT;
            return -1;
        }
        if (rc == -1) {
            return -1;
        }

        int so_error = 0;
        socklen_t len = sizeof(so_error);
        if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &so_error, &len) == -1) {
            return -1;
        }
        if (so_error != 0) {
            errno = so_error;
            return -1;
        }
    }

    return fcntl(fd, F_SETFL, flags);
}

static int send_all(int fd, const char *buf, size_t len) {
    size_t sent = 0;
    while (sent < len) {
        ssize_t n = send(fd, buf + sent, len - sent, MSG_NOSIGNAL);
        if (n > 0) {
            sent += (size_t)n;
            continue;
        }
        if (n == -1 && errno == EINTR) {
            continue;
        }
        return -1;
    }
    return 0;
}

int main(int argc, char **argv) {
    if (argc != 3) {
        fprintf(stderr, "usage: %s <ipv4> <port>\n", argv[0]);
        return 2;
    }

    char *end = NULL;
    long port = strtol(argv[2], &end, 10);
    if (*argv[2] == '\0' || *end != '\0' || port < 1 || port > 65535) {
        fprintf(stderr, "invalid port\n");
        return 2;
    }

    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if (fd == -1) {
        perror("socket");
        return 1;
    }

    struct sockaddr_in peer = {
        .sin_family = AF_INET,
        .sin_port = htons((uint16_t)port)
    };
    if (inet_pton(AF_INET, argv[1], &peer.sin_addr) != 1) {
        fprintf(stderr, "invalid IPv4 address\n");
        close(fd);
        return 2;
    }

    if (connect_with_timeout(fd, (struct sockaddr *)&peer,
                             sizeof(peer), 3000) == -1) {
        perror("connect");
        close(fd);
        return 1;
    }

    const char request[] = "ping\n";
    if (send_all(fd, request, sizeof(request) - 1) == -1) {
        perror("send");
        close(fd);
        return 1;
    }

    if (shutdown(fd, SHUT_WR) == -1) {
        perror("shutdown");
        close(fd);
        return 1;
    }
    printf("sent: ping\n");

    char response[4096];
    size_t used = 0;

    for (;;) {
        struct pollfd pfd = {.fd = fd, .events = POLLIN};
        int rc;
        do {
            rc = poll(&pfd, 1, 3000);
        } while (rc == -1 && errno == EINTR);

        if (rc == 0) {
            fprintf(stderr, "recv timeout\n");
            close(fd);
            return 1;
        }
        if (rc == -1) {
            perror("poll");
            close(fd);
            return 1;
        }

        ssize_t n = recv(fd, response + used,
                         sizeof(response) - 1 - used, 0);
        if (n > 0) {
            used += (size_t)n;
            if (used == sizeof(response) - 1) {
                fprintf(stderr, "response too large\n");
                close(fd);
                return 1;
            }
            continue;
        }
        if (n == 0) {
            break;
        }
        if (errno == EINTR) {
            continue;
        }

        perror("recv");
        close(fd);
        return 1;
    }

    response[used] = '\0';
    printf("response: %s", response);
    printf("peer closed\n");
    close(fd);
    return 0;
}

使用系统自带的 python3 临时启动一个只处理一次连接的测试服务端,再编译并运行客户端:

bash
gcc -Wall -Wextra -O2 tcp_client.c -o tcp_client
python3 -u -c 'import socket; s=socket.socket(); s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1); s.bind(("127.0.0.1",18080)); s.listen(1); print("READY", flush=True); c,_=s.accept(); c.recv(5, socket.MSG_WAITALL); c.sendall(b"pong\n"); c.close(); s.close()' >test-server.log 2>&1 &
SERVER_PID=$!
until grep -q '^READY$' test-server.log; do
    if ! kill -0 "$SERVER_PID" 2>/dev/null; then
        cat test-server.log
        exit 1
    fi
    sleep 0.01
done
./tcp_client 127.0.0.1 18080
wait "$SERVER_PID"
rm -f test-server.log

预期输出

text
sent: ping
response: pong
peer closed

如果本机端口 18080 已被占用,请同时修改测试服务端和客户端命令中的端口。真实网络中的建立时间和分段方式可能不同,但客户端不应依赖一次 send 或一次 recv 完成全部数据。

识别返回值的真实含义

send 返回正数时只代表这部分字节已被内核接受,并不代表对端应用已经处理;返回值可能小于待发送长度,所以要继续发送剩余部分。Linux 上使用 MSG_NOSIGNAL 可以避免对端已关闭时由 SIGPIPE 直接终止进程,让代码有机会检查 EPIPE 等错误。

recv 返回正数表示拿到这批字节,TCP 不保留应用层“消息边界”;返回 0 表示对端已正常关闭发送方向;返回 -1 才是错误。阻塞套接字上,暂时没有数据通常会等待,而不是返回 0。

超时与协议边界

示例为连接建立和“等待下一批响应数据”设置了 3 秒上限。生产程序通常还要把总请求时限拆成连接、发送和接收预算;若发送量很大,也应配合非阻塞 send 与 poll(POLLOUT),否则阻塞发送仍可能超过业务预算。

这里通过半关闭写方向让服务端知道请求结束,这是教学用的简单消息边界。长期连接协议通常不能依赖 EOF 分隔消息,而应使用固定长度、长度前缀、分隔符或 HTTP 等明确的应用层协议。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

编写 TCP 客户端

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通