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

TCP网络通信实现客户端简单远程控制主机
- 基本功能演示
- 通信过程
- 代码实现
- - 服务器模块
  - 执行命令模块
  - - popen系列函数
  - 客户端模块
  - 服务器主程序
windows作为客户端与服务器通信
- #pragma comment介绍
客户端使用状态机断线重连
- 代码实现
- 运行结果

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

基本功能演示

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

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

通信过程

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

代码实现

服务器模块

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;               // 使用 IPv4addr.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");// 开始监听，最大连接数为 5if (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));  // 将缓冲区初始化为0int 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：客户端套接字关闭，一般发生在重连失败后。
状态机执行过程：