connect 的断线重连：从失败处理到自动重连与心跳保活

#include <csignal>   // 引入信号相关头文件，提供 signal、SIGPIPE 等
 
// 把 SIGPIPE 信号的处理方式设成 SIG_IGN（忽略），
// 这样之后写已断开连接时进程不会被默认行为杀死，
// write 才能以返回 -1 的方式把错误交还给我们处理
signal(SIGPIPE, SIG_IGN);

// send 的 flags 传 MSG_NOSIGNAL，表示发送失败时不要产生 SIGPIPE 信号，
// 而是用返回值和 errno 告诉我们结果，从而避免进程被信号杀死
ssize_t n = send(sockfd, buf, len, MSG_NOSIGNAL);

#include <sys/types.h>
#include <sys/socket.h>   // 提供 socket、setsockopt 与相关常量
 
int keepAlive = 1;                                     // 1 表示开启 SO_KEEPALIVE
setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE,
           &keepAlive, sizeof(keepAlive));             // 设置到 socket 上

#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>   // TCP_KEEPIDLE / TCP_KEEPINTVL / TCP_KEEPCNT 所在头文件
 
int idle = 30;    // 连续 30 秒没有任何数据往来时，才开始发第一个探测包
setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPIDLE, &idle, sizeof(idle));
 
int intvl = 5;    // 每次探测包之间的间隔为 5 秒
setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPINTVL, &intvl, sizeof(intvl));
 
int cnt = 3;      // 连续 3 次探测没有回应，才判定对方死亡
setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPCNT, &cnt, sizeof(cnt));

# 查看 TCP keepalive 的三个默认参数（单位：秒）
cat /proc/sys/net/ipv4/tcp_keepalive_time
cat /proc/sys/net/ipv4/tcp_keepalive_intvl
cat /proc/sys/net/ipv4/tcp_keepalive_probes

#include <sys/time.h>     // struct timeval
#include <sys/types.h>
#include <sys/socket.h>   // setsockopt、SO_RCVTIMEO
 
struct timeval timeo;
timeo.tv_sec  = 30;      // 超过 30 秒没有数据进来就超时返回
timeo.tv_usec = 0;       // 微秒部分为 0
setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO,
           &timeo, sizeof(timeo));   // 应用于后续的所有 recv/read

ssize_t m = read(sockfd, buf, sizeof(buf));
if (m > 0) {
    // 收到数据（可能是业务数据，也可能是心跳回报），刷新"最近活跃"时间戳
    UpdateLastActive();
} else if (m == 0) {
    // 对端发了 FIN，连接被对端正常关闭，立即进入重连流程
    HandleDisconnect();
} else if (errno == EAGAIN || errno == EWOULDBLOCK) {
    // 接收超时：太久没数据，判定对端可能失联，进入重连流程
    HandleTimeoutReconnect();
} else {
    // 其他真实错误，如 ECONNRESET
    HandleError();
}

// TcpClient.cc —— 一个带状态机、支持自动重连的 TCP 客户端
// 编译：g++ -std=c++11 -o tcp_client TcpClient.cc
#include <iostream>      // cout / cerr / endl 输出流
#include <string>        // string 字符串
#include <cstring>       // strerror：把 errno 转成可读字符串
#include <cerrno>        // errno：全局错误码变量
#include <cstdlib>       // atoi：字符串转整数
#include <cstdint>       // uint16_t 无符号16位整数
#include <unistd.h>      // socket/connect/close/read/write/sleep 等系统调用声明
#include <sys/socket.h>  // 提供 socket、sockaddr、AF_INET 等
#include <netinet/in.h>  // 提供 sockaddr_in 结构体
#include <arpa/inet.h>   // 提供 inet_pton：字符串 IP 转二进制
#include <csignal>       // signal、SIGPIPE、SIG_IGN
 
using std::cout;
using std::cerr;
using std::endl;
using std::string;
 
// 打印命令行的用法说明
void Usage(const string& process)
{
    cout << "Usage: " << process << " server_ip server_port" << endl;
}
 
// 强类型枚举（C++11）：描述一条连接所处的生命周期状态
enum class Status
{
    NEW,           // 新建状态：什么都没做，准备首次连接
    CONNECTING,    // 正在尝试握手：用于查询连接中间态
    CONNECTED,     // 已连接：可以收发数据了
    DISCONNECTED,  // 掉线或首次连失败：等待重连
    CLOSED         // 重连次数用尽或正常退出：彻底放弃
};
 
// 封装一条"面向单个服务端"的连接，负责建连、断线检测、自动重连
class ClientConnection
{
public:
    // 构造：记录服务端 IP/端口，并给重连策略设初始值
    ClientConnection(uint16_t serverport, const string& serverip)
        : _sockfd(-1),                      // 初始没有 fd
          _serverport(serverport),          // 服务端端口
          _serverip(serverip),              // 服务端 IP
          _retry_interval(1),               // 首次重连等待 1 秒
          _max_retries(5),                  // 最多重试 5 次
          _max_interval(30),                // 退避间隔封顶 30 秒
          _status(Status::NEW)              // 初始状态：NEW
    {}
 
    // 创建一份全新的 TCP 流式 socket，失败返回 false
    bool CreateSocket()
    {
        _sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (_sockfd < 0)
        {
            cerr << "socket 创建失败: " << strerror(errno) << endl;
            return false;
        }
        return true;
    }
 
    // 用当前 _sockfd 发起一次 connect；失败返回 false 并打印错误
    bool DoConnect()
    {
        struct sockaddr_in server;              // 对端地址结构
        memset(&server, 0, sizeof(server));     // 先清零，避免残留垃圾数据
        server.sin_family = AF_INET;            // 统一用 IPv4
        server.sin_port = htons(_serverport);   // 端口转成网络字节序(大端)
        // inet_pton：把点分十进制字符串 IP 解析成 4 字节二进制网络序地址
        // 返回值 >0 成功；==0 表示字符串非法；<0 表示地址族不支持
        if (inet_pton(AF_INET, _serverip.c_str(), &server.sin_addr) <= 0)
        {
            cerr << "inet_pton 解析 IP 失败: " << _serverip << endl;
            return false;
        }
 
        // connect 发起三次握手；返回 0 表示成功，-1 表示失败（看 errno）
        int n = connect(_sockfd,
                        (struct sockaddr*)&server,   // 要转成通用 sockaddr*
                        sizeof(server));
        if (n < 0)
        {
            cerr << "connect 失败, errno=" << errno
                 << " (" << strerror(errno) << ")" << endl;
            return false;
        }
        return true;
    }
 
    // 首次连接：建 socket -> 握手。失败则关闭描述符并置为 DISCONNECTED
    void Connect()
    {
        if (!CreateSocket())
        {
            _status = Status::CLOSED;      // 连 socket 都建不了，直接放弃
            return;
        }
        if (!DoConnect())
        {
            Disconnect();                  // 关掉这个失败的 fd
            _status = Status::DISCONNECTED;// 转入"待重连"状态
            return;
        }
        _status = Status::CONNECTED;       // 握手成功
    }
 
    // 核心：自动重连。每次重连都新建 fd，指数退避，带次数上限
    void Reconnect()
    {
        _status = Status::CONNECTING;
        int interval = _retry_interval;    // 从 1 秒开始
        for (int count = 0; count < _max_retries; ++count)
        {
            // 每次都新建描述符，绝不复用旧 fd
            if (!CreateSocket())
            {
                cout << "重连时创建 socket 失败" << endl;
                break;
            }
            if (DoConnect())
            {
                _status = Status::CONNECTED;
                cout << "重连成功" << endl;
                return;
            }
            Disconnect();   // 连接失败，关掉刚建的 fd 再等下一轮
            cout << "重连次数: " << (count + 1)
                 << ", 最大上限: " << _max_retries
                 << ", 等待 " << interval << " 秒" << endl;
            sleep(interval);   // 退避等待
            // 指数退避并封顶：interval*2 一旦超过上限就保持在上限，不再翻倍
            interval = (interval * 2 > _max_interval)
                           ? _max_interval
                           : interval * 2;
        }
        _status = Status::CLOSED;   // 次数用尽仍未成功，认输
    }
 
    int     SocketFd()  const { return _sockfd; }   // 暴露 fd 给上层收发
    Status  GetStatus() const { return _status; }   // 查询当前状态
 
    // 简单的收发流程：从控制台读一行发给服务端，再读回 echo 并打印
    // 返回后，调用方应重新根据 GetStatus() 决定是重连还是退出
    void Process()
    {
        string inbuffer;
        cout << "Please Enter# ";
        while (getline(cin, inbuffer))   // 从标准输入读一行
        {
            if (inbuffer.empty())        // 空行忽略，继续等待输入
            {
                cout << "Please Enter# ";
                continue;
            }
 
            // 发送给服务端；n<0 说明发送失败
            ssize_t n = write(_sockfd, inbuffer.c_str(), inbuffer.size());
            if (n < 0)
            {
                cout << "write 返回 " << n << ", errno=" << errno
                     << " (" << strerror(errno) << ")" << endl;
                _status = Status::DISCONNECTED;  // 发送失败，转入待重连
                break;
            }
 
            // 读取服务端的 echo 回显
            char buffer[1024] = {0};     // 接收缓冲区
            ssize_t m = read(_sockfd, buffer, sizeof(buffer) - 1);
            if (m > 0)
            {
                buffer[m] = 0;           // 手动补 0，便于当作字符串打印
                cout << "echo message -> " << buffer << endl;
            }
            else if (m == 0)
            {
                // 关键判断：read 返回 0 表示对端关闭了连接
                cout << "对端关闭连接，准备重连" << endl;
                _status = Status::DISCONNECTED;
                break;
            }
            else
            {
                cout << "read 返回 " << m << ", errno=" << errno
                     << " (" << strerror(errno) << ")" << endl;
                _status = Status::DISCONNECTED;  // 读出错也视为断开
                break;
            }
            cout << "Please Enter# ";
        }
        // getline 读到文件末尾（Ctrl+D）会退出循环
        if (cin.eof())
        {
            cout << "用户输入结束，正常退出" << endl;
            _status = Status::CLOSED;
        }
    }
 
    ~ClientConnection() { Disconnect(); }   // 析构时确保关闭 fd
 
private:
    // 关闭描述符并把 fd 复位，供重连/析构复用
    void Disconnect()
    {
        if (_sockfd != -1)
        {
            close(_sockfd);
            _sockfd = -1;
        }
    }
 
    int      _sockfd;           // 当前连接的文件描述符，-1 表示没有
    uint16_t _serverport;       // 服务端端口
    string   _serverip;         // 服务端 IP
    int      _retry_interval;   // 重连起始间隔（秒），指数退避的底数
    int      _max_retries;      // 最大重试次数
    int      _max_interval;     // 退避间隔封顶（秒）
    Status   _status;           // 当前连接状态
};
 
// 最外层封装的"客户端"：持有连接对象，用循环驱动状态机运转
class TcpClient
{
public:
    TcpClient(uint16_t serverport, const string& serverip)
        : _conn(serverport, serverip)
    {}
 
    // 状态机主循环：根据当前状态决定动作，直到 CLOSED 才退出
    void Execute()
    {
        while (true)
        {
            switch (_conn.GetStatus())
            {
            case Status::NEW:          // 从未连过 -> 首次连接
                cout << "首次连接..." << endl;
                _conn.Connect();
                break;
            case Status::CONNECTED:    // 已连接 -> 进入收发流程
                cout << "连接成功, 开始进行通信." << endl;
                _conn.Process();       // Process 内部一旦发现断开会改成其他状态
                break;
            case Status::DISCONNECTED: // 掉线 -> 自动重连
                cout << "连接失败或对方掉线，开始重连." << endl;
                _conn.Reconnect();
                break;
            case Status::CLOSED:       // 重连失败或正常退出 -> 结束
                Disconnect();
                cout << "重连失败, 退出." << endl;
                return;
            default:                   // 其他情况（CONNECTING 等）暂不处理
                break;
            }
        }
    }
 
private:
    // 对外不暴露 fd；为完整性提供一个供内部使用的清理入口
    void Disconnect() {}
 
    ClientConnection _conn;   // 简单组合一个连接对象，就构成了客户端
};
 
// 程序入口：./tcp_client server_ip server_port
int main(int argc, char* argv[])
{
    if (argc != 3)               // 参数必须是 IP 和端口两个
    {
        Usage(argv[0]);
        return 1;
    }
 
    // 忽略 SIGPIPE：防止 write 到已断开连接时进程被默认信号杀死，
    // 这样错误才能以返回负值的方式交还给我们处理
    signal(SIGPIPE, SIG_IGN);
 
    string    serverip   = argv[1];                       // 服务端 IP
    uint16_t  serverport = (uint16_t)atoi(argv[2]);       // 服务端端口
    TcpClient client(serverport, serverip);               // 组装客户端
    client.Execute();                                     // 跑状态机
    return 0;                                             // 正常退出
}

// EchoServer.cc —— 一个极简的 echo 服务端：客户端发什么，就原样回什么
// 编译：g++ -std=c++11 -o echo_server EchoServer.cc
#include <iostream>      // 输入输出
#include <cstring>       // strerror / memset
#include <cstdlib>       // atoi
#include <cstdint>       // uint16_t
#include <unistd.h>      // close / read / write
#include <sys/socket.h>  // socket / bind / listen / accept
#include <netinet/in.h>  // sockaddr_in
#include <arpa/inet.h>   // inet_pton
#include <csignal>       // signal / SIGPIPE / SIG_IGN
 
using std::cout;
using std::cerr;
using std::endl;
 
int main(int argc, char* argv[])
{
    // 忽略 SIGPIPE：对端断开后我们回显 write 时也不至于被信号杀死
    signal(SIGPIPE, SIG_IGN);
 
    if (argc != 3)                      // 用法：./echo_server ip port
    {
        cerr << "Usage: " << argv[0] << " ip port" << endl;
        return 1;
    }
 
    // 创建监听 socket
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (lfd < 0)
    {
        cerr << "socket: " << strerror(errno) << endl;
        return 1;
    }
 
    // SO_REUSEADDR：允许 TIME_WAIT 状态下的端口快速重用，方便反复起服务
    int opt = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
 
    // 组装本机监听地址
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port   = htons((uint16_t)atoi(argv[2]));
    inet_pton(AF_INET, argv[1], &addr.sin_addr);
 
    // 绑定并开始监听
    if (bind(lfd, (struct sockaddr*)&addr, sizeof(addr)) < 0)
    {
        cerr << "bind: " << strerror(errno) << endl;
        return 1;
    }
    if (listen(lfd, 5) < 0)             // 最多排 5 个等待队列
    {
        cerr << "listen: " << strerror(errno) << endl;
        return 1;
    }
    cout << "echo server listening on " << argv[1] << ":" << argv[2] << endl;
 
    // 主循环：接受连接，读到一行就原样回显，直到对端关闭
    while (true)
    {
        int cfd = accept(lfd, nullptr, nullptr);   // 等待并接受一个连接
        if (cfd < 0)
        {
            cerr << "accept: " << strerror(errno) << endl;
            continue;
        }
        cout << "accept a client" << endl;
        char buf[1024];
        ssize_t m;
        while ((m = read(cfd, buf, sizeof(buf))) > 0)   // 有数据就回显
        {
            write(cfd, buf, m);
        }
        close(cfd);           // 对端关闭，收工
        cout << "client closed" << endl;
    }
    return 0;
}

# 编译两端程序
g++ -std=c++11 -o echo_server EchoServer.cc
g++ -std=c++11 -o tcp_client TcpClient.cc
 
# 一个终端开服务端，绑在回环地址的 8888 端口
./echo_server 127.0.0.1 8888

./tcp_client 127.0.0.1 8888

#include <sys/types.h>
#include <sys/socket.h>
#include <fcntl.h>      // fcntl、F_SETFL
#include <sys/select.h> // select、fd_set
#include <unistd.h>     // close
 
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
 
// 把描述符设为非阻塞：后续 read/write/connect 都不会卡住线程
int flags = fcntl(sockfd, F_GETFL, 0);
fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
 
struct sockaddr_in server;
// ...（组装 server，同上，略）
 
// 非阻塞下 connect 几乎立刻返回
int r = connect(sockfd, (struct sockaddr*)&server, sizeof(server));
if (r != 0 && errno != EINPROGRESS)
{
    // 真正的失败，比如 ECONNREFUSED
}
 
// 等待连接结果：最多等 3 秒，用 select 观察"可写"事件
fd_set wfds;
FD_ZERO(&wfds);
FD_SET(sockfd, &wfds);
struct timeval tv = {3, 0};   // 3 秒超时
int s = select(sockfd + 1, NULL, &wfds, NULL, &tv);
if (s == 0)
{
    // 3 秒没结果，可以判定连接超时，关闭并进入重连
}
else if (s > 0 && FD_ISSET(sockfd, &wfds))
{
    int err = 0;
    socklen_t len = sizeof(err);
    // 用 SO_ERROR 取出底层结果：0 表示连接成功，非 0 表示对应 errno
    getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &err, &len);
    if (err == 0)
    {
        // 连接成功
    }
    else
    {
        // 连接失败，err 里就是失败原因（如 ECONNREFUSED）
    }
}