【网络编程】之TCP实现客户端远程控制服务器端及断线重连

TCP网络通信实现客户端简单远程控制主机

基本功能演示

客户端与服务器端连接后，可以通过Linux中的指令来控制它：

但是为了防止客户端恶意破坏服务器，我们必须创建一个配置文件，只有在这个配置文件里的命令，客户端才能执行。

通信过程

1. 服务器端创建监听套接字，监听客户端，等待客户端连接。
2. 客户端发起连接请求。
3. 连接成功，开始通信。
4. 客户端发送命令。
5. 服务器端接收到命令，并创建一个新线程，线程在线程调用的函数中设置为分离状态，主线程不需要对子线程等待。
6. 新线程执行一系列函数后给客户端返回执行结果。

代码实现

服务器模块

TcpServer.hpp：

#pragma once
#include<unistd.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<sys/types.h>
#include<cstdio>
#include<cstdlib>
#include"Log.hpp"
#include<functional>
#include"ThreadPool.hpp"
#include"InetAddr.hpp"

// 定义错误码
enum
{
    SOCKETERROR = 1, // 套接字创建失败
    BINDERROR,       // 套接字绑定失败
    USAGEERROR       // 用法错误
};

// 定义服务函数的类型别名
using funcservice = function<void(int sockfd, InetAddr addr)>;

// 用于多线程任务的数据结构
struct Threaddata
{
    int _sockfd;            // 客户端连接的套接字
    InetAddr _addr;         // 客户端的地址信息
    funcservice _exec;      // 执行的服务函数
    Threaddata(int sockfd, InetAddr addr, funcservice exec)
        : _sockfd(sockfd), _addr(addr), _exec(exec)
    {}
};

// 定义业务逻辑函数类型别名
using funcexec = function<string(const string&)>;

// 定义 TcpServer 类
class TcpServer
{
private:
    int _listensock;         // 监听套接字
    uint16_t _port;          // 监听端口号
    bool _is_running;        // 服务器运行状态
    funcexec _exec;          // 业务逻辑处理函数

public:
    // 构造函数，初始化成员变量
    TcpServer(uint16_t port, funcexec exec)
        : _listensock(-1), _port(port), _is_running(false), _exec(exec)
    {}

    // 初始化服务器，包括创建套接字、绑定地址和监听
    void InitServer()
    {
        _listensock = socket(AF_INET, SOCK_STREAM, 0); // 创建 TCP 套接字
        if (_listensock == -1)
        {
            LOG(FATAL, "socket error");
            exit(1); // 套接字创建失败，退出
        }
        LOG(INFO, "socket success");

        struct sockaddr_in addr;
        addr.sin_family = AF_INET;               // 使用 IPv4
        addr.sin_port = htons(_port);            // 设置端口号（网络字节序）
        addr.sin_addr.s_addr = INADDR_ANY;       // 监听本机所有网卡

        // 绑定地址
        if (bind(_listensock, (struct sockaddr*)&addr, sizeof(addr)) == -1)
        {
            LOG(FATAL, "bind error");
            exit(1); // 绑定失败，退出
        }
        LOG(INFO, "bind success");

        // 开始监听，最大连接数为 5
        if (listen(_listensock, 5) == -1)
        {
            LOG(FATAL, "listen error");
            exit(1); // 监听失败，退出
        }
    }

    // 服务函数，处理客户端请求
    void Service(int sockfd, InetAddr addr)
    {
        LOG(INFO, "new connect: %s:%d", inet_ntoa(addr.addr().sin_addr), ntohs(addr.addr().sin_port));
        while (_is_running)
        {
            char buffer[1024];                   // 接收缓冲区
            memset(buffer, 0, sizeof(buffer));   // 清空缓冲区
            int n = recv(sockfd, buffer, sizeof(buffer), 0); // 接收数据

            string sender = "[" + addr.ip() + ":" + to_string(addr.port()) + "]#"; // 记录客户端信息
            if (n == -1)
            {
                perror("recv");
                break;
            }
            else if (n == 0)
            {
                LOG(INFO, "%sclient close", sender.c_str());
                break; // 客户端断开连接
            }
            else
            {
                buffer[n] = 0; // 确保字符串以 '\0' 结束
                LOG(INFO, "%s%s", sender.c_str(), buffer);

                // 执行业务逻辑函数
                string result = _exec(buffer);

                // 返回处理结果给客户端
                string echoserver = "[echo server]#\n" + result;
                send(sockfd, echoserver.c_str(), echoserver.size(), 0);
            }
        }
        close(sockfd); // 关闭客户端连接
    }

    // 线程入口函数
    static void* ThreadRun(void* arg)
    {
        pthread_detach(pthread_self()); // 设置线程分离，防止资源泄漏
        Threaddata* data = (Threaddata*)arg; // 获取任务数据
        data->_exec(data->_sockfd, data->_addr); // 执行服务函数
        delete data; // 释放任务数据
        return nullptr;
    }

    // 主循环，接受客户端连接并分配任务
    void Loop()
    {
        _is_running = true;
        while (_is_running)
        {
            struct sockaddr_in peer;           // 客户端地址
            socklen_t len = sizeof(peer);
            int sockfd = accept(_listensock, (struct sockaddr*)&peer, &len); // 接受连接
            if (sockfd == -1)
            {
                perror("accept");
                break;
            }

            InetAddr addr(peer); // 将客户端地址封装为 InetAddr 对象

            // 多线程版本
            Threaddata* data = new Threaddata(sockfd, addr, std::bind(&TcpServer::Service, this, placeholders::_1, placeholders::_2));
            pthread_t tid;
            pthread_create(&tid, nullptr, ThreadRun, data); // 创建线程处理任务
        }
        _is_running = false;
    }

    // 析构函数，清理资源
    ~TcpServer()
    {
        if (_listensock != -1)
        {
            close(_listensock); // 关闭监听套接字
        }
    }
};

• 执行命令的函数在外面传入类中，当新线程接收数据后回调这个函数处理任务（创建子进程处理执行命令并返回数据）。

执行命令模块

#pragma once
#include<string>
#include<set>
#include<fstream>
#include<iostream>
#include"Log.hpp"
using namespace std;

const static string seq = " ";
const static string commandpath = "./command.txt";

class ExecuteCommand
{
private:
    set<string> _CommandSet;//安全命令集合
    string _cond_path;//命令的路径
private:
    void LoadCommandSet()//加载安全命令集合
    {
        ifstream infile(commandpath, ios::in);//打开文件以读取的方式
        if(!infile.is_open())//判断文件是否打开成功
        {
            LOG(FATAL, "open command.txt failed");  //打开文件失败
            return;
        }
        string line;
        while(getline(infile, line))//读取文件中的安全命令
        {
            _CommandSet.insert(line);//插入到安全命令集合中
        }
        infile.close();//关闭文件
    }

    bool IsSecure(const string& Command)//判断是否是安全命令
    {
        if(Command.empty())//判断命令是否为空
        {
            return false;
        }
        //先把核心命令提取出来（不要后面的选项）
        int pos = Command.find(seq);//找到空格的位置
        string core = Command.substr(0, pos);//提取核心命令
        //判断是否在安全命令集合中
        if(_CommandSet.find(core) != _CommandSet.end())//在安全命令集合中
        {
            return true;
        }

        return false;//不在安全命令集合中
    }
public:
    ExecuteCommand(const string path = commandpath):_cond_path(path)
    {
        LoadCommandSet();//加载安全命令集合
    }

    string Execute(const string& Command)
    {
        //1.先fork && pipe
        //2.再exec 执行命令
        //3. 执行命令前 dup2
        //这些都可以通过库函数popen来实现
        //(这个函数是一个标准库函数，用于创建一个管道，然后调用fork产生一个子进程，然后调用exec执行一个命令) 
        if(!IsSecure(Command))//判断是否是安全命令
        {
            LOG(WARNING, "command is not secure");
            return "command is not secure";
        }
        else//是安全的命令
        {
            FILE* fp = popen(Command.c_str(), "r");//执行命令
            if(fp == nullptr)//判断是否执行成功
            {
                LOG(WARNING, "command execute failed");
                return "command execute failed";
            }
            string result;
            char output[1024] = {0};//定义一个缓冲区
            while(fgets(output, sizeof(output)-1, fp) != nullptr)//读取命令的输出
            {
                result += output;
            }
            pclose(fp);//关闭文件
            return result;
        }
    }
    
    ~ExecuteCommand(){}
};

• 需求：1. 执行安全的命令 2.将命令执行的结果发送给客户端。
• 实现:
  • 执行命令：不能在子线程中执行命令，因为子线程还要接收来自某个客户端的数据，所有应该子线程创建一个子进程调用exec系列的函数执行命令。
  • 返回数据：进程之间具有独立性，我们选择使用匿名管道进行进程间通信。
  • 安全的命令可以通过创建一个配置文件，然后创建命令对象时，将配置文件加载进集合（文件IO慢），如果命令前缀在集合中就执行，反之直接返回提示信息。

上述两个步骤都不需要我们自己去实现，C语言库中提供了一个这样的函数，可以帮我们完成上述功能，我们来介绍这个函数：

popen系列函数

FILE *popen(const char *command, const char *type)

• 函数功能：popen 是一个 C 库函数，提供了一种简单的方式来创建一个管道（pipe），并启动一个子进程以执行外部命令。popen 允许父进程与子进程之间进行单向通信。

• 参数：

  • const char *command：你需要执行的命令及其选项，例如：

    ls -l
    

  • const char *type：

    • "r": 打开管道用于读取子进程的标准输出。

    • "w": 打开管道用于写入子进程的标准输入。

• 返回值：

  • 成功：返回一个指向管道文件的 FILE 指针。

  • 失败：返回 NULL。

• 头文件：<stdio.h>

int pclose(FILE *stream);

• 功能：

  • 关闭管道文件。
  • 回收子进程，防止它变成僵尸进程。

• 参数：

  • FILE *stream：由 popen 返回的指向管道的 FILE 指针。

• 返回值：

  • 成功: 返回子进程的退出状态（以 waitpid 的方式返回，可以通过 WEXITSTATUS 宏提取退出码）。

  • 失败: 返回 -1，并设置 errno。

• 头文件：<stdio.h>

客户端模块

和echo功能中的客户端模块基本一致。

#include <iostream>
#include <string>
#include <unistd.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>

using namespace std;

void Usage(char* s)
{
    cout << "Usage:\n\t" << s << " serverip" << "serverport" << endl;
    exit(1);
}


int main(int argc,char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        return 1;
    }
    string ip = argv[1];
    uint16_t port = stoi(argv[2]);
    int sockfd = socket(AF_INET,SOCK_STREAM,0);//创建套接字
    if(sockfd == -1)
    {
        perror("socket creat error");
        return 1;
    }
    
    //客户端需要bind,但是不需要我们显示的bind

    //客户端也不需要listen，监听请求是服务器程序的工作
    struct sockaddr_in addr;//服务器的地址信息
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    inet_pton(AF_INET,ip.c_str(),&addr.sin_addr.s_addr);
    if(connect(sockfd,(struct sockaddr*)&addr,sizeof(addr)) == -1)
    {
        perror("connect error");
        return 1;
    }

    while(true)
    {
        string message;
        cout << "please input message:";
        getline(cin,message);//获取用户输入的信息,一行一行的获取
        send(sockfd,message.c_str(),message.size()+1,0);
        char buffer[1024];
        memset(buffer,0,sizeof(buffer));
        int n = recv(sockfd,buffer,sizeof(buffer),0);
        if(n == -1)
        {
            perror("recv error");
            break;
        }
        else if(n == 0)
        {
            cout << "server close" << endl;
            break;
        }
        else
        {
            buffer[n] = 0;
            cout << buffer;
        }
    }

    close(sockfd);
    return 0;
}

服务器主程序

服务器主程序将命令处理函数bind并传给服务器类的成员，以供子线程调用该方法。

#include"TcpServer.hpp"  // 引入自定义的头文件，用于创建并管理服务器
#include<memory>  // 引入内存管理的头文件，用于创建智能指针
#include"ExecuteCommand.hpp"  // 引入自定义的头文件，用于执行命令
#include<functional>  // 引入函数式编程的头文件，用于创建函数对象


void Usage(char* s)
{
    cout << "Usage:\n\t" << s << " serverport" << endl;  // 打印程序的命令行使用格式，提示用户输入端口号
    exit(USAGEERROR);
}

int main(int argc,char* argv[])
{
    // 判断命令行参数是否正确
    if(argc != 2)  // 程序需要接收一个参数：端口号
    {
        Usage(argv[0]);  // 如果参数不为2，则调用Usage函数打印使用说明
        return 1;  // 退出程序，返回错误码1
    }
    
    // 将命令行参数转为端口号（uint16_t类型），这是服务器监听的端口号
    uint16_t port = stoi(argv[1]);  // 使用stoi将字符串转化为整数类型的端口号

    // 创建TcpServer对象，并初始化
    unique_ptr<TcpServer> server = make_unique<TcpServer>(port,std::bind(&ExecuteCommand::Execute,
                                                                         ExecuteCommand()      , 
                                                                         placeholders::_1      ));  // 使用从命令行获得的端口号创建TcpServer实例
    server->InitServer();  // 初始化服务器，进行绑定等操作
    server->Loop();  // 启动服务器，开始接收和处理客户端请求
    return 0;
}

windows作为客户端与服务器通信

我们修改一下客户端的echo代码即可，windows中的网络库与Linux上的有一些差异，在Udp通信的时候已经介绍过了：

#include <iostream>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <string.h>
#include<string>
#pragma comment(lib, "ws2_32.lib")  // 自动链接 Winsock 库


using namespace std;

const string ip = "47.98.179.70";
const uint16_t port = 8080;

int main()
{
   

    // 初始化 Winsock 库
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)  // 以指定版本初始化
    {
        cerr << "WSAStartup failed" << endl;
        return 1;
    }

    // 创建套接字，使用IPv4地址族和TCP协议（SOCK_STREAM表示流式套接字）
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);  // 创建TCP套接字
    if (sockfd == INVALID_SOCKET)  // 如果创建套接字失败，打印错误并返回
    {
        cerr << "Socket creation failed: " << WSAGetLastError() << endl;
        WSACleanup();
        return 1;
    }

    // 设置服务器的地址信息
    struct sockaddr_in addr;  // sockaddr_in结构体用于存储服务器的网络地址
    addr.sin_family = AF_INET;  // 使用IPv4地址族
    addr.sin_port = htons(port);  // 设置服务器的端口号（htons将端口号转换为网络字节序）
    inet_pton(AF_INET, ip.c_str(), &addr.sin_addr.s_addr);  // 将IP地址字符串转换为网络字节序的二进制格式

    // 连接到服务器
    if (connect(sockfd, (struct sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR)  // 调用connect连接服务器
    {
        cerr << "Connect failed: " << WSAGetLastError() << endl;  // 如果连接失败，输出错误信息
        closesocket(sockfd);
        WSACleanup();
        return 1;
    }

    // 客户端和服务器之间进行通信
    while (true)
    {
        string message;
        cout << "Please input message: ";  // 提示用户输入消息
        getline(cin, message);  // 从标准输入获取一行字符串作为消息

        // 将输入的消息发送到服务器
        int bytesSent = send(sockfd, message.c_str(), message.size() + 1, 0);  // 发送消息到服务器，+1用于包括消息结尾的'\0'
        if (bytesSent == SOCKET_ERROR)  // 如果发送失败
        {
            cerr << "Send failed: " << WSAGetLastError() << endl;
            break;
        }

        // 接收服务器返回的消息
        char buffer[1024];  // 定义接收缓冲区，大小为1024字节
        memset(buffer, 0, sizeof(buffer));  // 将缓冲区初始化为0

        int n = recv(sockfd, buffer, sizeof(buffer), 0);  // 从服务器接收数据
        if (n == SOCKET_ERROR)  // 如果接收数据失败
        {
            cerr << "Recv failed: " << WSAGetLastError() << endl;  // 输出错误信息
            break;  // 跳出循环，关闭连接
        }
        else if (n == 0)  // 如果服务器关闭了连接
        {
            cout << "Server closed the connection." << endl;  // 打印提示信息
            break;  // 跳出循环，结束通信
        }
        else  // 数据接收成功
        {
            buffer[n] = 0;  // 确保接收到的数据是一个合法的C字符串（添加终止符'\0'）
            cout << "Server: " << buffer << endl;  // 输出服务器返回的消息
        }
    }

    // 关闭套接字，结束与服务器的通信
    closesocket(sockfd);  // Windows 关闭套接字时使用 closesocket()
    WSACleanup();  // 清理 Winsock 库

    return 0;  // 程序正常结束
}

运行结果：

#pragma comment介绍

这是一条预处理指令，是Microsoft Visual C++ 编译器MSVC的扩展指令，它的功能和gcc/g++中的-l选项类似，可以告诉编译器要链接的库的名称。

MSVC（Microsoft Visual C++）是由微软开发的一款集成开发环境（IDE）和编译器工具套件，用于开发基于 C、C++ 和 C++/CLI 的应用程序。

客户端使用状态机断线重连

状态机是一种用于描述系统行为数学模型，它的核心是状态，它通过定义不同的状态让系统执行不同的操作，且执行这些操作时得到的结果会更新状态。

代码实现

#include<iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include<memory>
#include<string>
#include<string.h>

// 枚举类型定义退出码
enum Exitcode
{
    USAGEERR = 1,  // 命令输入错误
    SOCKETERR,     // 创建 socket 失败
    INET_PTONERR   // 地址转换失败
};

// 枚举类型定义连接状态
enum Status
{
    NEW,            // 新建连接的状态
    CONNECTED,      // 已连接状态（连接或重连成功）
    DISCONNECTED,   // 连接失败的状态
    CONNECTEDING,   // 正在连接的状态
    CLOSED          // 经历重连，但是失败了
};

// 常量定义
const int defaultsocketfd = -1;  // 默认 socket 文件描述符
const int maxreconnectcount = 5; // 最大重连次数
const int defaultinterval = 2;   // 每次重连的时间间隔（秒）

// Clientconnect 类：封装与服务器的连接管理和通信
class Clientconnect
{
public:
    // 构造函数，初始化连接信息，包括 IP，端口，最大重连次数和重连间隔
    Clientconnect(int16_t port, std::string ip, int maxcount = maxreconnectcount, int interval = defaultinterval):
    _port(port), _ip(ip), _maxcount(maxcount), _interval(interval), _socketfd(defaultsocketfd), _status(Status::NEW)
    {}

    // 连接服务器
    void Connect()
    {
        // 1. 创建 socket
        _socketfd = socket(AF_INET, SOCK_STREAM, 0);
        if (_socketfd < 0)
        {
            std::cerr << "create socket failed" << std::endl;
            exit(Exitcode::SOCKETERR);
        }

        struct sockaddr_in addr;
        memset(&addr, 0, sizeof(addr));

        addr.sin_family = AF_INET;
        addr.sin_port = htons(_port); // 设置端口
        if (inet_pton(AF_INET, _ip.c_str(), &addr.sin_addr.s_addr) <= 0)  // 地址转换
        {
            std::cerr << "inet_pton error" << std::endl;
            exit(Exitcode::INET_PTONERR);
        }

        // 尝试连接
        int n = connect(_socketfd, (struct sockaddr*)&addr, sizeof(addr));
        if (n < 0)
        {
            Close();  // 连接失败，关闭文件描述符
            _status = Status::DISCONNECTED;  // 设置为连接失败状态
            return;
        }

        _status = Status::CONNECTED;  // 连接成功
    }

    // 尝试重连
    void Reconnect()
    {
        _status = Status::CONNECTEDING;  // 设置为正在连接状态

        int cnt = 0;
        while (true)
        {
            cnt++;
            std::cout << "正在重连中... 重连次数: " << cnt << std::endl;
            Connect();  // 尝试重新连接

            // 如果连接成功，跳出循环
            if (_status == Status::CONNECTED)
            {
                std::cout << "重连成功!" << std::endl;
                break;
            }

            // 如果超过最大重连次数，退出
            if (cnt >= _maxcount)
            {
                _status = Status::CLOSED;  // 设置为关闭状态
                std::cout << "已达最大重连次数..." << std::endl;
                break;
            }
            sleep(_interval);  // 重连间隔
        }
    }

    // 基本的 I/O 处理
    void Process()
    {
        while (true)
        {
            std::cout << "client#";
            std::string message = "hello server!!";
            int n = send(_socketfd, message.c_str(), message.size(), 0);  // 发送数据
            if (n < 0)
            {
                std::cerr << "send error" << std::endl;
                _status = Status::CLOSED;  // 发送失败，关闭连接
            }

            if (n > 0)
            {
                char buffer[1024] = {0};
                n = recv(_socketfd, buffer, sizeof(buffer), 0);  // 接收数据
                if (n <= 0)
                {
                    std::cerr << "recv error" << std::endl;
                    Close();
                    _status = Status::DISCONNECTED;  // 接收失败，设置为断开连接
                    break;
                }
                buffer[n] = 0;
                std::cout << "server#" << buffer << std::endl;
            }
            sleep(1);
        }
    }

    // 关闭连接
    void Close()
    {
        if (_socketfd > 0)
        {
            close(_socketfd);  // 关闭 socket
            _status = Status::CLOSED;  // 设置为关闭状态
            _socketfd = -1;
        }
    }

    // 获取当前连接的状态
    Status status()
    {
        return _status;
    }

private:
    std::string _ip;
    uint16_t _port;
    int _socketfd;
    int _maxcount;  // 最大重连次数
    int _interval;  // 重连间隔
    Status _status; // 当前连接状态
};

// 客户端类：负责管理客户端连接的生命周期
class Client
{
public:
    // 构造函数
    Client(int16_t port, std::string ip): _connect(port, ip)
    {}

    // 执行客户端操作
    void Excute()
    {
        while (true)
        {
            switch (_connect.status())  // 根据状态执行不同的操作
            {
            case Status::NEW:            // 初始状态，尝试连接
                _connect.Connect();
                break;
            case Status::CONNECTED:      // 已连接状态，处理数据
                _connect.Process();
                break;
            case Status::DISCONNECTED:   // 连接失败，尝试重连
                _connect.Reconnect();
                break;
            case Status::CLOSED:         // 已关闭，退出
                _connect.Close();
                return;
            default:
                break;
            }
        }
    }

    ~Client() {}

private:
    Clientconnect _connect;  // 客户端连接对象
};

// 输出程序用法
void Usage(const std::string& process)
{
    std::cout << process << " serverip serverport" << std::endl;
    exit(Exitcode::USAGEERR);
}

// 程序入口
int main(int argc, char* argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
    }
    int16_t port = std::stoi(argv[2]);
    std::string ip = argv[1];
    std::unique_ptr<Client> client = std::make_unique<Client>(port, ip);

    client->Excute();
    return 0;
}

• 状态说明：

  • NEW：初始状态，处于这个状态的客户端，还未尝试连接服务器。
  • CONNECTED：连接服务器成功，处于这个状态的客户端，即将开始IO通信。
  • CONNECTING：正在连接服务器的状态，这个状态一般是瞬时状态，发生在开始连接了，但是还未连接成功。
  • DISCONNECTED：连接失败的状态，处于这个状态的服务器将会开始重连逻辑。
  • CLOSED：客户端套接字关闭，一般发生在重连失败后。

• 状态机执行过程：

  

运行结果

我们编译客户端程序，并在本地云服务器创建一个具有echo功能的服务器程序，测试如下情况：

1. 服务器未运行，客户端运行起来了。
   • 连接肯定是失败的，进入重连逻辑。
2. 服务器运行起来后，关闭服务器。
   • 一开始连接是成功的，服务器和客户端可以正常的通信。但是服务器不再运行后，客户端又开始重连，未达到重连次数时，又运行起服务器就可以重连成功。否则重连失败。