嵌入式Linux Socket编程实战：非阻塞连接与WiFi断线自动重连机制

在嵌入式Linux系统进行高速数据传输时，Socket通信最忌讳的就是“死等”。想象一下，当设备依赖的WiFi信号突然消失，如果使用默认的阻塞式connect或send，你的线程可能会被卡住数十秒，直接导致Ring Buffer溢出，数据丢失。为了解决这个痛点，我们必须摒弃传统的阻塞模式，转而使用非阻塞IO (Non-blocking IO) 配合 select() 或 poll() 来实现带超时的连接，并构建一个智能的状态机来处理自动重连，赋予网络连接“自愈”能力。

本文将分享一个封装好的、具备自愈能力的Socket发送函数。其核心逻辑围绕三点展开：

1. 忽略 SIGPIPE 信号：防止向已关闭的连接写入数据时程序直接崩溃。
2. 非阻塞连接与超时控制：设置一个短暂的连接超时（如2秒），如果连不上立即返回，稍后自动重试，避免线程长时间阻塞。
3. 状态检查与自动恢复：在发送数据前判断Socket状态，若发现连接失效，则立即关闭旧连接并触发重连流程。

下面，我们通过具体的C语言代码来剖析这一机制的实现。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <sys/select.h>

#define SERVER_IP   "192.168.1.100"
#define SERVER_PORT 8888
#define CONN_TIMEOUT_SEC 2    // 连接超时时间
#define RETRY_INTERVAL_US 500000 // 重连间隔 500ms

int setup_nonblocking_socket(int *sock_fd){
    *sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (*sock_fd < 0) return -1;

    // 1. 设置非阻塞模式
    int flags = fcntl(*sock_fd, F_GETFL, 0);
    fcntl(*sock_fd, F_SETFL, flags | O_NONBLOCK);

    // 2. 优化：禁用 Nagle 算法，设置缓冲区
    int opt = 1;
    setsockopt(*sock_fd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt));
    int snd_size = 2 * 1024 * 1024; // 2MB 发送缓冲区
    setsockopt(*sock_fd, SOL_SOCKET, SO_SNDBUF, &snd_size, sizeof(snd_size));

    return 0;
}

int connect_with_timeout(int sock_fd, const char *ip, int port){
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    inet_pton(AF_INET, ip, &addr.sin_addr);

    int res = connect(sock_fd, (struct sockaddr *)&addr, sizeof(addr));
    if (res < 0) {
        if (errno == EINPROGRESS) {
            // 连接正在进行中，使用 select 等待
            fd_set write_fds;
            struct timeval tv;
            FD_ZERO(&write_fds);
            FD_SET(sock_fd, &write_fds);
            tv.tv_sec = CONN_TIMEOUT_SEC;
            tv.tv_usec = 0;

            res = select(sock_fd + 1, NULL, &write_fds, NULL, &tv);
            if (res > 0) {
                // 检查 socket 错误状态
                int error = 0;
                socklen_t len = sizeof(error);
                getsockopt(sock_fd, SOL_SOCKET, SO_ERROR, &error, &len);
                if (error == 0) return 0; // 连接成功
            }
        }
    } else {
        return 0; // 立即连接成功
    }
    return -1; // 连接失败
}

// 核心发送逻辑：带自动重连
int safe_send(int *sock_fd, uint8_t *data, size_t len){
    if (*sock_fd < 0) {
        // 如果当前没有连接，尝试重连
        if (setup_nonblocking_socket(sock_fd) == 0) {
            if (connect_with_timeout(*sock_fd, SERVER_IP, SERVER_PORT) == 0) {
                printf("WiFi 重新连接成功！\n");
            } else {
                close(*sock_fd);
                *sock_fd = -1;
                return -1;
            }
        }
    }

    // 执行发送
    ssize_t sent = send(*sock_fd, data, len, MSG_NOSIGNAL); // 使用 NOSIGNAL 防止崩溃
    if (sent < 0) {
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            // 发送缓冲区满，WiFi 拥堵
            return 0;
        } else {
            // 链路断开 (EPIPE, ECONNRESET 等)
            perror("发送失败，链路可能已断开");
            close(*sock_fd);
            *sock_fd = -1;
            return -1;
        }
    }
    return (int)sent;
}

// 消费者线程主循环
void *wifi_consumer_thread(void *arg){
    int wifi_sock = -1;
    uint8_t packet_buffer[4096 + 16]; // 对应协议帧大小

    // 忽略 SIGPIPE，防止 send 到断开的 socket 时程序退出
    signal(SIGPIPE, SIG_IGN);

    while (1) {
        // 从 Ring Buffer 获取数据
        size_t data_len = rb_read(&my_ring_buffer, packet_buffer, sizeof(packet_buffer));

        if (data_len > 0) {
            // 尝试发送，直到成功或放入重连逻辑
            while (safe_send(&wifi_sock, packet_buffer, data_len) <= 0) {
                // 如果发送失败，等待片刻重试，避免占满 CPU
                usleep(RETRY_INTERVAL_US);
            }
        } else {
            // 缓冲区空，稍作休息
            usleep(1000);
        }
    }
}

关键技术点解析

1. 处理 SIGPIPE 信号
在 Linux 系统中，如果对一个已经被对端关闭的 Socket 调用 send，内核会向进程发送 SIGPIPE 信号。该信号的默认行为是终止进程，这对于需要7x24小时运行的嵌入式设备来说是灾难性的。除了在程序初始化时调用 signal(SIGPIPE, SIG_IGN) 来忽略该信号，我们在 send 函数的第四个参数中传入 MSG_NOSIGNAL 标志，相当于加了双重保险。这确保了即使网络意外断开，程序也只会收到错误返回值（EPIPE），而不会直接崩溃。

2. 实现非阻塞连接与超时
标准的 connect 是同步阻塞的。如果目标服务器关机或IP地址错误，它可能会阻塞长达75秒，这对于实时系统是不可接受的。我们的策略是：首先，通过 fcntl 将 Socket 设置为 O_NONBLOCK 模式。接着调用 connect，它会立即返回 EINPROGRESS 错误，表示连接正在进行中。此时，我们使用 select() 系统调用来监控这个Socket的“可写”状态，并设置一个超时（如2秒）。如果在超时前Socket变得可写，我们再通过 getsockopt 检查是否有错误，若无错误则表明TCP/IP连接成功建立。这套组合拳极大地提升了系统在恶劣网络环境下的响应能力。

3. 优化重连与发送策略

• 指数退避重连：示例代码中使用了固定的重试间隔 RETRY_INTERVAL_US。在实际工业场景中，更推荐使用指数退避策略：第一次重连等待0.5秒，第二次1秒，第三次2秒……直到一个上限（如30秒）。这能有效防止在网络环境持续恶劣时，设备（SoC）和WiFi模块因频繁发起握手而消耗过多CPU资源并产生不必要的热量。
• 区分发送失败原因：在 safe_send 函数中，我们特别处理了 send 返回 EAGAIN 或 EWOULDBLOCK 的情况。这通常是因为内核的网络发送缓冲区已满（例如WiFi带宽瞬间波动导致数据堆积）。此时，正确的做法不是断开连接，而是等待一小段时间（usleep）后再尝试发送，就像水管堵了需要等水流走一些再继续抽水。
• 启用TCP Keepalive：我们的 safe_send 函数能检测到发送时的连接错误，但如果连接长时间空闲（例如数据采集暂停），Socket可能会在后台悄无声息地断开。为了应对这种情况，建议开启内核的TCP Keepalive保活机制：

  int keepalive = 1;
  int keepidle = 5;  // 5秒无数据则开始探测
  int keepintvl = 2; // 探测间隔2秒
  int keepcnt = 3;   // 探测3次失败则关闭连接
  setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &keepalive, sizeof(keepalive));
  setsockopt(sock, IPPROTO_TCP, TCP_KEEPIDLE, &keepidle, sizeof(keepidle));
  setsockopt(sock, IPPROTO_TCP, TCP_KEEPINTVL, &keepintvl, sizeof(keepintvl));
  setsockopt(sock, IPPROTO_TCP, TCP_KEEPCNT, &keepcnt, sizeof(keepcnt));

4. 进阶思路：链路冗余
对于可靠性要求极高的场景，如果设备同时具备以太网和WiFi接口，你可以创建两个独立的Socket。通过监控各自的发送失败率，当WiFi链路的失败次数超过某个阈值时，系统可以自动无缝切换到以太网路径进行数据传输，从而实现网络链路的冗余备份，进一步提升系统可用性。

总结来说，在资源受限且环境多变的嵌入式Linux开发中，构建一个健壮、自适应的Socket通信层至关重要。通过结合非阻塞IO、超时控制、智能重连和错误处理，我们可以让应用程序从容应对网络波动，确保数据传输的连续性。如果你对更底层的C/C++ 网络编程或系统优化技巧感兴趣，欢迎在云栈社区与我们继续深入探讨。