651 lines
20 KiB
C++
651 lines
20 KiB
C++
#include "Netra.hpp"
|
||
|
||
namespace QCL
|
||
{
|
||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
TcpServer::TcpServer(int port)
|
||
: port_(port), running_(false), serverSock_(-1) {}
|
||
|
||
/**
|
||
* @brief 析构函数中调用stop()确保服务器资源被释放
|
||
*/
|
||
TcpServer::~TcpServer()
|
||
{
|
||
stop();
|
||
}
|
||
|
||
/**
|
||
* @brief 启动服务器：
|
||
* 1. 创建监听socket（TCP）
|
||
* 2. 绑定端口
|
||
* 3. 监听端口
|
||
* 4. 启动监听线程acceptThread_
|
||
*
|
||
* @return 成功返回true，失败返回false
|
||
*/
|
||
bool TcpServer::start()
|
||
{
|
||
// 创建socket
|
||
serverSock_ = socket(AF_INET, SOCK_STREAM, 0);
|
||
if (serverSock_ < 0)
|
||
{
|
||
std::cerr << "Socket 创建失败\n";
|
||
return false;
|
||
}
|
||
|
||
// 设置socket地址结构
|
||
sockaddr_in serverAddr;
|
||
std::memset(&serverAddr, 0, sizeof(serverAddr));
|
||
serverAddr.sin_family = AF_INET;
|
||
serverAddr.sin_port = htons(port_); // 端口转网络字节序
|
||
serverAddr.sin_addr.s_addr = INADDR_ANY; // 监听所有网卡IP
|
||
|
||
// 允许端口重用，防止服务器异常关闭后端口被占用
|
||
int opt = 1;
|
||
setsockopt(serverSock_, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
|
||
|
||
// 绑定端口
|
||
if (bind(serverSock_, (sockaddr *)&serverAddr, sizeof(serverAddr)) < 0)
|
||
{
|
||
std::cerr << "绑定失败\n";
|
||
return false;
|
||
}
|
||
|
||
// 开始监听，最大等待连接数为5
|
||
if (listen(serverSock_, 5) < 0)
|
||
{
|
||
std::cerr << "监听失败\n";
|
||
return false;
|
||
}
|
||
|
||
// 设置运行标志为true
|
||
running_ = true;
|
||
|
||
// 启动专门接受客户端连接的线程
|
||
acceptThread_ = std::thread(&TcpServer::acceptClients, this);
|
||
|
||
std::cout << "服务器启动，监听端口：" << port_ << std::endl;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* @brief 停止服务器：
|
||
* 1. 设置运行标志为false，通知线程退出
|
||
* 2. 关闭监听socket
|
||
* 3. 关闭所有客户端socket，清理客户端列表
|
||
* 4. 等待所有线程退出
|
||
*/
|
||
void TcpServer::stop()
|
||
{
|
||
running_ = false;
|
||
|
||
if (serverSock_ >= 0)
|
||
{
|
||
close(serverSock_);
|
||
serverSock_ = -1;
|
||
}
|
||
|
||
{
|
||
// 线程安全关闭所有客户端socket
|
||
std::lock_guard<std::mutex> lock(clientsMutex_);
|
||
for (int sock : clientSockets_)
|
||
{
|
||
close(sock);
|
||
}
|
||
clientSockets_.clear();
|
||
}
|
||
|
||
// 等待监听线程退出
|
||
if (acceptThread_.joinable())
|
||
acceptThread_.join();
|
||
|
||
// 等待所有客户端处理线程退出
|
||
for (auto &t : clientThreads_)
|
||
{
|
||
if (t.joinable())
|
||
t.join();
|
||
}
|
||
|
||
std::cout << "服务器已停止\n";
|
||
}
|
||
|
||
/**
|
||
* @brief acceptClients函数循环监听客户端连接请求
|
||
* 每当accept成功：
|
||
* 1. 打印客户端IP和Socket信息
|
||
* 2. 线程安全地将客户端Socket加入clientSockets_列表
|
||
* 3. 创建新线程调用handleClient处理该客户端收发
|
||
*/
|
||
void TcpServer::acceptClients()
|
||
{
|
||
while (running_)
|
||
{
|
||
sockaddr_in clientAddr;
|
||
socklen_t clientLen = sizeof(clientAddr);
|
||
int clientSock = accept(serverSock_, (sockaddr *)&clientAddr, &clientLen);
|
||
if (clientSock < 0)
|
||
{
|
||
if (running_)
|
||
std::cerr << "接受连接失败\n";
|
||
continue;
|
||
}
|
||
|
||
// 将客户端IP转换成字符串格式打印
|
||
char clientIP[INET_ADDRSTRLEN];
|
||
inet_ntop(AF_INET, &(clientAddr.sin_addr), clientIP, INET_ADDRSTRLEN);
|
||
std::cout << "客户端连接，IP: " << clientIP << ", Socket: " << clientSock << std::endl;
|
||
|
||
{
|
||
// 加锁保护共享的clientSockets_容器
|
||
std::lock_guard<std::mutex> lock(clientsMutex_);
|
||
clientSockets_.push_back(clientSock);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 发送消息给指定客户端
|
||
* @param clientSock 客户端socket
|
||
* @param message 发送消息内容
|
||
*/
|
||
void TcpServer::sendToClient(int clientSock, const std::string &message)
|
||
{
|
||
send(clientSock, message.c_str(), message.size(), 0);
|
||
}
|
||
|
||
/**
|
||
* @brief 单次接收指定客户端数据
|
||
* @param clientSock 客户端socket
|
||
*/
|
||
std::string TcpServer::receiveFromClient(int clientSock, bool flag)
|
||
{
|
||
char buffer[1024];
|
||
std::memset(buffer, 0, sizeof(buffer));
|
||
|
||
int flags = flag ? 0 : MSG_DONTWAIT;
|
||
ssize_t bytesReceived = recv(clientSock, buffer, sizeof(buffer) - 1, flags);
|
||
|
||
if (bytesReceived <= 0)
|
||
return {};
|
||
|
||
return std::string(buffer, bytesReceived);
|
||
}
|
||
|
||
/**
|
||
* @brief 获取当前所有客户端Socket副本（线程安全）
|
||
* @return 包含所有客户端socket的vector副本
|
||
*/
|
||
std::vector<int> TcpServer::getClientSockets()
|
||
{
|
||
std::lock_guard<std::mutex> lock(clientsMutex_);
|
||
return clientSockets_;
|
||
}
|
||
|
||
/**
|
||
* @brief 获取连接客户端的IP和端口
|
||
* @param clientSock 客户端Socket描述符
|
||
*/
|
||
char *TcpServer::getClientIPAndPort(int clientSock)
|
||
{
|
||
struct sockaddr_in addr;
|
||
socklen_t addr_size = sizeof(addr);
|
||
|
||
// 获取客户端地址信息
|
||
if (getpeername(clientSock, (struct sockaddr *)&addr, &addr_size) == -1)
|
||
{
|
||
perror("getpeername failed");
|
||
return NULL;
|
||
}
|
||
|
||
// 分配内存存储结果(格式: "IP:PORT")
|
||
char *result = (char *)malloc(INET_ADDRSTRLEN + 10);
|
||
if (!result)
|
||
return NULL;
|
||
|
||
// 转换IP和端口
|
||
char *ip = inet_ntoa(addr.sin_addr);
|
||
unsigned short port = ntohs(addr.sin_port);
|
||
|
||
snprintf(result, INET_ADDRSTRLEN + 10, "%s:%d", ip, port);
|
||
return result;
|
||
}
|
||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
WriteFile::WriteFile(const std::string &filePath)
|
||
: filePath_(filePath) {}
|
||
|
||
/**
|
||
* @brief 覆盖写文本（线程安全）
|
||
*/
|
||
bool WriteFile::overwriteText(const std::string &content)
|
||
{
|
||
std::lock_guard<std::mutex> lock(writeMutex_); // 加锁
|
||
return writeToFile(content, std::ios::out | std::ios::trunc);
|
||
}
|
||
|
||
/**
|
||
* @brief 追加写文本（线程安全）
|
||
*/
|
||
bool WriteFile::appendText(const std::string &content)
|
||
{
|
||
std::lock_guard<std::mutex> lock(writeMutex_);
|
||
return writeToFile(content, std::ios::out | std::ios::app);
|
||
}
|
||
|
||
/**
|
||
* @brief 覆盖写二进制（线程安全）
|
||
*/
|
||
bool WriteFile::overwriteBinary(const std::vector<char> &data)
|
||
{
|
||
std::lock_guard<std::mutex> lock(writeMutex_);
|
||
return writeBinary(data, std::ios::out | std::ios::trunc | std::ios::binary);
|
||
}
|
||
|
||
/**
|
||
* @brief 追加写二进制（线程安全）
|
||
*/
|
||
bool WriteFile::appendBinary(const std::vector<char> &data)
|
||
{
|
||
std::lock_guard<std::mutex> lock(writeMutex_);
|
||
return writeBinary(data, std::ios::out | std::ios::app | std::ios::binary);
|
||
}
|
||
|
||
/**
|
||
* @brief 通用文本写入（私有）
|
||
*/
|
||
bool WriteFile::writeToFile(const std::string &content, std::ios::openmode mode)
|
||
{
|
||
std::ofstream file(filePath_, mode);
|
||
if (!file.is_open())
|
||
return false;
|
||
file << content;
|
||
file.close();
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* @brief 通用二进制写入（私有）
|
||
*/
|
||
bool WriteFile::writeBinary(const std::vector<char> &data, std::ios::openmode mode)
|
||
{
|
||
std::ofstream file(filePath_, mode);
|
||
if (!file.is_open())
|
||
return false;
|
||
file.write(data.data(), data.size());
|
||
file.close();
|
||
return true;
|
||
}
|
||
|
||
size_t WriteFile::countBytesPattern(const std::string &pattern, bool includePattern)
|
||
{
|
||
std::lock_guard<std::mutex> lock(writeMutex_);
|
||
|
||
if (pattern.empty())
|
||
return 0;
|
||
|
||
std::ifstream file(filePath_, std::ios::binary);
|
||
if (!file.is_open())
|
||
return 0;
|
||
|
||
const size_t chunkSize = 4096;
|
||
std::string buffer;
|
||
buffer.reserve(chunkSize * 2);
|
||
|
||
size_t totalRead = 0;
|
||
char chunk[chunkSize];
|
||
|
||
while (file.read(chunk, chunkSize) || file.gcount() > 0)
|
||
{
|
||
size_t bytesRead = file.gcount();
|
||
buffer.append(chunk, bytesRead);
|
||
|
||
size_t pos = buffer.find(pattern);
|
||
if (pos != std::string::npos)
|
||
{
|
||
size_t absolutePos = totalRead + pos; // 关键：加上 totalRead
|
||
return includePattern ? (absolutePos + pattern.size()) : absolutePos;
|
||
}
|
||
|
||
if (buffer.size() > pattern.size())
|
||
buffer.erase(0, buffer.size() - pattern.size());
|
||
|
||
totalRead += bytesRead; // 读完后再累计
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
bool WriteFile::writeAfterPatternOrAppend(const std::string &pattern, const std::string &content)
|
||
{
|
||
std::lock_guard<std::mutex> lock(writeMutex_);
|
||
|
||
// 读取整个文件
|
||
std::ifstream in(filePath_, std::ios::binary);
|
||
if (!in.is_open())
|
||
return false;
|
||
|
||
std::string fileData((std::istreambuf_iterator<char>(in)), {});
|
||
in.close();
|
||
|
||
size_t pos = fileData.find(pattern);
|
||
if (pos != std::string::npos)
|
||
{
|
||
// 模式存在，插入位置在模式结尾
|
||
pos += pattern.size();
|
||
|
||
// 删除模式后所有内容
|
||
if (pos < fileData.size())
|
||
fileData.erase(pos);
|
||
|
||
// 插入新内容
|
||
fileData.insert(pos, content);
|
||
}
|
||
else
|
||
{
|
||
// 模式不存在，直接追加到文件末尾
|
||
if (!fileData.empty() && fileData.back() != '\n')
|
||
fileData += '\n'; // 保证换行
|
||
fileData += content;
|
||
}
|
||
|
||
// 写回文件
|
||
std::ofstream out(filePath_, std::ios::binary | std::ios::trunc);
|
||
if (!out.is_open())
|
||
return false;
|
||
|
||
out.write(fileData.data(), fileData.size());
|
||
return true;
|
||
}
|
||
|
||
bool WriteFile::overwriteAtPos(const std::string &content, size_t pos, size_t length)
|
||
{
|
||
std::lock_guard<std::mutex> lock(writeMutex_);
|
||
|
||
// 打开文件读取
|
||
std::ifstream in(filePath_, std::ios::binary);
|
||
if (!in.is_open())
|
||
return false;
|
||
|
||
std::string fileData((std::istreambuf_iterator<char>(in)), {});
|
||
in.close();
|
||
|
||
// 边界检查
|
||
if (pos >= fileData.size())
|
||
return false; // pos 超过文件范围，无法覆盖
|
||
|
||
// 生成要覆盖的实际数据块
|
||
std::string overwriteBlock;
|
||
if (content.size() >= length)
|
||
{
|
||
overwriteBlock = content.substr(0, length);
|
||
}
|
||
else
|
||
{
|
||
overwriteBlock = content;
|
||
overwriteBlock.append(length - content.size(), '\0'); // 补齐
|
||
}
|
||
|
||
// 计算实际可写范围
|
||
size_t maxWritable = std::min(length, fileData.size() - pos);
|
||
|
||
// 覆盖
|
||
fileData.replace(pos, maxWritable, overwriteBlock.substr(0, maxWritable));
|
||
|
||
// 写回文件
|
||
std::ofstream out(filePath_, std::ios::binary | std::ios::trunc);
|
||
if (!out.is_open())
|
||
return false;
|
||
|
||
out.write(fileData.data(), fileData.size());
|
||
return true;
|
||
}
|
||
|
||
bool WriteFile::insertAfterPos(const std::string &content, size_t pos, size_t length)
|
||
{
|
||
std::lock_guard<std::mutex> lock(writeMutex_);
|
||
|
||
// 打开文件读取
|
||
std::ifstream in(filePath_, std::ios::binary);
|
||
if (!in.is_open())
|
||
return false;
|
||
|
||
std::string fileData((std::istreambuf_iterator<char>(in)), {});
|
||
in.close();
|
||
|
||
// 边界检查
|
||
if (pos > fileData.size())
|
||
pos = fileData.size(); // 如果 pos 超出范围，就视为文件末尾
|
||
|
||
// 生成要插入的实际数据块
|
||
std::string insertBlock;
|
||
if (content.size() >= length)
|
||
{
|
||
insertBlock = content.substr(0, length); // 只取前 length 个字节
|
||
}
|
||
else
|
||
{
|
||
insertBlock = content; // 全部内容
|
||
insertBlock.append(length - content.size(), '\0'); // 补足空字节
|
||
}
|
||
|
||
// 插入到 pos 后面
|
||
fileData.insert(pos + 1, insertBlock);
|
||
|
||
// 写回文件
|
||
std::ofstream out(filePath_, std::ios::binary | std::ios::trunc);
|
||
if (!out.is_open())
|
||
return false;
|
||
|
||
out.write(fileData.data(), fileData.size());
|
||
return true;
|
||
}
|
||
|
||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
ReadFile::ReadFile(const std::string &filename) : filename_(filename) {}
|
||
|
||
ReadFile::~ReadFile()
|
||
{
|
||
std::lock_guard<std::mutex> lock(mtx_);
|
||
Close();
|
||
}
|
||
|
||
bool ReadFile::Open()
|
||
{
|
||
std::lock_guard<std::mutex> lock(mtx_);
|
||
if (file_.is_open())
|
||
file_.close();
|
||
file_.open(filename_, std::ios::in | std::ios::binary);
|
||
return file_.is_open();
|
||
}
|
||
|
||
void ReadFile::Close()
|
||
{
|
||
if (file_.is_open())
|
||
{
|
||
std::lock_guard<std::mutex> lock(mtx_);
|
||
file_.close();
|
||
}
|
||
}
|
||
|
||
bool ReadFile::IsOpen() const
|
||
{
|
||
std::lock_guard<std::mutex> lock(mtx_);
|
||
return file_.is_open();
|
||
}
|
||
|
||
std::string ReadFile::ReadAllText()
|
||
{
|
||
std::lock_guard<std::mutex> lock(mtx_);
|
||
if (!file_.is_open() && !Open())
|
||
return "";
|
||
|
||
std::ostringstream ss;
|
||
ss << file_.rdbuf();
|
||
return ss.str();
|
||
}
|
||
|
||
std::vector<char> ReadFile::ReadAllBinary()
|
||
{
|
||
std::lock_guard<std::mutex> lock(mtx_);
|
||
if (!file_.is_open() && !Open())
|
||
return {};
|
||
|
||
return ReadBytes(GetFileSize());
|
||
}
|
||
|
||
std::vector<std::string> ReadFile::ReadLines()
|
||
{
|
||
std::lock_guard<std::mutex> lock(mtx_);
|
||
if (!file_.is_open() && !Open())
|
||
return {};
|
||
|
||
std::vector<std::string> lines;
|
||
std::string line;
|
||
while (std::getline(file_, line))
|
||
{
|
||
lines.push_back(line);
|
||
}
|
||
return lines;
|
||
}
|
||
|
||
std::vector<char> ReadFile::ReadBytes(size_t count)
|
||
{
|
||
std::lock_guard<std::mutex> lock(mtx_);
|
||
if (!file_.is_open() && !Open())
|
||
return {};
|
||
|
||
std::vector<char> buffer(count);
|
||
file_.read(buffer.data(), count);
|
||
buffer.resize(file_.gcount());
|
||
return buffer;
|
||
}
|
||
|
||
size_t ReadFile::GetBytesBefore(const std::string &marker, bool includeMarker)
|
||
{
|
||
std::lock_guard<std::mutex> lock(mtx_);
|
||
|
||
if (!file_.is_open() && !Open())
|
||
return 0;
|
||
|
||
file_.clear(); // 清除EOF和错误状态
|
||
file_.seekg(0, std::ios::beg); // 回到文件开头
|
||
|
||
const size_t chunkSize = 4096;
|
||
std::string buffer;
|
||
buffer.reserve(chunkSize * 2);
|
||
|
||
size_t totalRead = 0;
|
||
char chunk[chunkSize];
|
||
|
||
while (file_.read(chunk, chunkSize) || file_.gcount() > 0)
|
||
{
|
||
buffer.append(chunk, file_.gcount());
|
||
size_t pos = buffer.find(marker);
|
||
if (pos != std::string::npos)
|
||
{
|
||
// 如果 includeMarker 为 true，返回包含 marker 的长度
|
||
if (includeMarker)
|
||
return pos + marker.size();
|
||
else
|
||
return pos;
|
||
}
|
||
|
||
// 保留末尾部分，避免 buffer 无限增长
|
||
if (buffer.size() > marker.size())
|
||
buffer.erase(0, buffer.size() - marker.size());
|
||
|
||
totalRead += file_.gcount();
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
std::vector<char> ReadFile::ReadBytesFrom(size_t pos, size_t count)
|
||
{
|
||
std::lock_guard<std::mutex> lock(mtx_);
|
||
|
||
if (!file_.is_open() && !Open())
|
||
return {};
|
||
|
||
size_t filesize = GetFileSize();
|
||
if (pos >= filesize)
|
||
return {}; // 起始位置超出文件大小
|
||
|
||
file_.clear(); // 清除 EOF 和错误状态
|
||
file_.seekg(pos, std::ios::beg);
|
||
if (!file_)
|
||
return {};
|
||
|
||
size_t bytes_to_read = count;
|
||
if (count == 0 || pos + count > filesize)
|
||
bytes_to_read = filesize - pos; // 读取到文件末尾
|
||
|
||
std::vector<char> buffer(bytes_to_read);
|
||
file_.read(buffer.data(), bytes_to_read);
|
||
|
||
// 实际读取的字节数可能少于请求的数量
|
||
buffer.resize(file_.gcount());
|
||
|
||
return buffer;
|
||
}
|
||
|
||
bool ReadFile::FileExists() const
|
||
{
|
||
return std::filesystem::exists(filename_);
|
||
}
|
||
|
||
size_t ReadFile::GetFileSize() const
|
||
{
|
||
if (!FileExists())
|
||
return 0;
|
||
return std::filesystem::file_size(filename_);
|
||
}
|
||
|
||
void ReadFile::Reset()
|
||
{
|
||
std::lock_guard<std::mutex> lock(mtx_);
|
||
if (file_.is_open())
|
||
{
|
||
file_.clear();
|
||
file_.seekg(0, std::ios::beg);
|
||
}
|
||
}
|
||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
// 屏蔽所有信号
|
||
void blockAllSignals()
|
||
{
|
||
// 忽略全部的信号
|
||
for (int ii = 1; ii <= 64; ii++)
|
||
signal(ii, SIG_IGN);
|
||
}
|
||
|
||
std::string Ltrim(const std::string &s)
|
||
{
|
||
size_t start = 0;
|
||
while (start < s.size() && std::isspace(static_cast<unsigned char>(s[start])))
|
||
{
|
||
++start;
|
||
}
|
||
return s.substr(start);
|
||
}
|
||
|
||
std::string Rtrim(const std::string &s)
|
||
{
|
||
if (s.empty())
|
||
return s;
|
||
|
||
size_t end = s.size();
|
||
while (end > 0 && std::isspace(static_cast<unsigned char>(s[end - 1])))
|
||
{
|
||
--end;
|
||
}
|
||
return s.substr(0, end);
|
||
}
|
||
|
||
std::string LRtrim(const std::string &s)
|
||
{
|
||
return Ltrim(Rtrim(s));
|
||
}
|
||
|
||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
} |