636 lines
21 KiB
C++
636 lines
21 KiB
C++
#include "stdafx.h"
|
||
#include "ServerServiceWrapper.h"
|
||
#include "ServerSessionMonitor.h"
|
||
#include "CrashReport.h"
|
||
#include <stdio.h>
|
||
#include <winsvc.h>
|
||
#include "2015Remote.h"
|
||
|
||
// 静态变量
|
||
static SERVICE_STATUS g_ServiceStatus;
|
||
static SERVICE_STATUS_HANDLE g_StatusHandle = NULL;
|
||
static HANDLE g_StopEvent = INVALID_HANDLE_VALUE;
|
||
|
||
// 前向声明
|
||
static void WINAPI ServiceMain(DWORD argc, LPTSTR* argv);
|
||
static void WINAPI ServiceCtrlHandler(DWORD ctrlCode);
|
||
|
||
// 代理启动回调：记录启动次数
|
||
static void OnAgentStart(DWORD processId, DWORD sessionId)
|
||
{
|
||
// 递增启动次数
|
||
int startCount = THIS_CFG.GetInt(CFG_CRASH_SECTION, CFG_CRASH_STARTS, 0) + 1;
|
||
THIS_CFG.SetInt(CFG_CRASH_SECTION, CFG_CRASH_STARTS, startCount);
|
||
|
||
char buf[128];
|
||
sprintf_s(buf, sizeof(buf), "Agent started: PID=%d, Session=%d, totalStarts=%d",
|
||
(int)processId, (int)sessionId, startCount);
|
||
Mprintf(buf);
|
||
}
|
||
|
||
// 代理退出回调：累计运行时间（用于 MTBF 计算）
|
||
static void OnAgentExit(DWORD exitCode, ULONGLONG runtimeMs)
|
||
{
|
||
// 累加总运行时间
|
||
// 注意：使用字符串存储 64 位整数，避免 GetInt/SetInt 的 32 位限制
|
||
char totalStr[32];
|
||
ULONGLONG totalRuntime = 0;
|
||
std::string storedTotal = THIS_CFG.GetStr(CFG_CRASH_SECTION, CFG_CRASH_TOTAL_RUN_MS, "0");
|
||
totalRuntime = _strtoui64(storedTotal.c_str(), NULL, 10);
|
||
totalRuntime += runtimeMs;
|
||
sprintf_s(totalStr, sizeof(totalStr), "%llu", totalRuntime);
|
||
THIS_CFG.SetStr(CFG_CRASH_SECTION, CFG_CRASH_TOTAL_RUN_MS, totalStr);
|
||
|
||
// 格式化运行时间
|
||
char runtimeStr[64];
|
||
FormatRuntime(totalRuntime, runtimeStr, sizeof(runtimeStr));
|
||
|
||
// 计算 MTBF（如果有崩溃记录）
|
||
int crashCount = THIS_CFG.GetInt(CFG_CRASH_SECTION, CFG_CRASH_COUNT, 0);
|
||
int startCount = THIS_CFG.GetInt(CFG_CRASH_SECTION, CFG_CRASH_STARTS, 0);
|
||
|
||
char buf[256];
|
||
if (crashCount > 0) {
|
||
ULONGLONG mtbf = CalculateMTBF(totalRuntime, crashCount);
|
||
char mtbfStr[64];
|
||
FormatRuntime(mtbf, mtbfStr, sizeof(mtbfStr));
|
||
double failureRate = CalculateFailureRate(crashCount, startCount);
|
||
sprintf_s(buf, sizeof(buf),
|
||
"Agent exited: code=0x%08X, runtime=%llums, totalRuntime=%s, MTBF=%s, failureRate=%.2f%%",
|
||
exitCode, runtimeMs, runtimeStr, mtbfStr, failureRate * 100);
|
||
} else {
|
||
sprintf_s(buf, sizeof(buf),
|
||
"Agent exited: code=0x%08X, runtime=%llums, totalRuntime=%s (no crashes yet)",
|
||
exitCode, runtimeMs, runtimeStr);
|
||
}
|
||
Mprintf(buf);
|
||
}
|
||
|
||
// 崩溃统计回调：记录崩溃次数、时间和退出代码
|
||
static void OnAgentCrash(DWORD exitCode, ULONGLONG runtimeMs)
|
||
{
|
||
// 递增总崩溃次数
|
||
int totalCrashes = THIS_CFG.GetInt(CFG_CRASH_SECTION, CFG_CRASH_COUNT, 0) + 1;
|
||
THIS_CFG.SetInt(CFG_CRASH_SECTION, CFG_CRASH_COUNT, totalCrashes);
|
||
|
||
// 记录最后崩溃时间
|
||
char timeStr[32];
|
||
SYSTEMTIME st;
|
||
GetLocalTime(&st);
|
||
sprintf_s(timeStr, sizeof(timeStr), "%04d-%02d-%02d %02d:%02d:%02d",
|
||
st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
|
||
THIS_CFG.SetStr(CFG_CRASH_SECTION, CFG_CRASH_LAST_TIME, timeStr);
|
||
|
||
// 记录退出代码
|
||
char exitCodeStr[64];
|
||
const char* desc = GetExitCodeDescription(exitCode);
|
||
if (desc) {
|
||
sprintf_s(exitCodeStr, sizeof(exitCodeStr), "0x%08X (%s)", exitCode, desc);
|
||
} else {
|
||
sprintf_s(exitCodeStr, sizeof(exitCodeStr), "0x%08X", exitCode);
|
||
}
|
||
THIS_CFG.SetStr(CFG_CRASH_SECTION, CFG_CRASH_LAST_CODE, exitCodeStr);
|
||
|
||
// 记录运行时间（毫秒）- 使用字符串存储 64 位值
|
||
char runtimeStr[32];
|
||
sprintf_s(runtimeStr, sizeof(runtimeStr), "%llu", runtimeMs);
|
||
THIS_CFG.SetStr(CFG_CRASH_SECTION, CFG_CRASH_LAST_RUN_MS, runtimeStr);
|
||
|
||
char buf[256];
|
||
sprintf_s(buf, sizeof(buf), "Agent crash recorded: total=%d, time=%s, exitCode=%s, runtime=%llums",
|
||
totalCrashes, timeStr, exitCodeStr, runtimeMs);
|
||
Mprintf(buf);
|
||
}
|
||
|
||
// 崩溃窗口状态变化回调：持久化崩溃窗口状态
|
||
static void OnCrashWindowChange(int crashCount, ULONGLONG firstCrashTime)
|
||
{
|
||
THIS_CFG.SetInt(CFG_CRASH_SECTION, CFG_CRASH_WIN_COUNT, crashCount);
|
||
|
||
// 使用字符串存储 64 位时间戳
|
||
char timeStr[32];
|
||
sprintf_s(timeStr, sizeof(timeStr), "%llu", firstCrashTime);
|
||
THIS_CFG.SetStr(CFG_CRASH_SECTION, CFG_CRASH_WIN_START, timeStr);
|
||
|
||
char buf[128];
|
||
sprintf_s(buf, sizeof(buf), "Crash window state saved: count=%d, startTime=%llu", crashCount, firstCrashTime);
|
||
Mprintf(buf);
|
||
}
|
||
|
||
// 崩溃保护回调：写入保护标志
|
||
// 注意：不在这里停止服务，由 MonitorLoop 检测 crashProtected 后自动退出
|
||
static void OnAgentCrashProtection(void)
|
||
{
|
||
THIS_CFG.SetInt(CFG_CRASH_SECTION, CFG_CRASH_PROTECTED, 1);
|
||
// 切换到正常模式，避免用户无法启动程序
|
||
THIS_CFG.SetInt("settings", "RunNormal", 1);
|
||
// 清除崩溃窗口状态（保护已触发，不需要再保持窗口状态）
|
||
THIS_CFG.SetInt(CFG_CRASH_SECTION, CFG_CRASH_WIN_COUNT, 0);
|
||
THIS_CFG.SetStr(CFG_CRASH_SECTION, CFG_CRASH_WIN_START, "0");
|
||
Mprintf("Crash protection triggered: switched to normal mode");
|
||
}
|
||
|
||
BOOL ServerService_CheckStatus(BOOL* registered, BOOL* running,
|
||
char* exePath, size_t exePathSize)
|
||
{
|
||
*registered = FALSE;
|
||
*running = FALSE;
|
||
if (exePath && exePathSize > 0) {
|
||
exePath[0] = '\0';
|
||
}
|
||
|
||
// 打开 SCM
|
||
SC_HANDLE hSCM = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
|
||
if (!hSCM) {
|
||
return FALSE;
|
||
}
|
||
|
||
// 打开服务
|
||
SC_HANDLE hService = OpenServiceA(
|
||
hSCM,
|
||
SERVER_SERVICE_NAME,
|
||
SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG);
|
||
if (!hService) {
|
||
CloseServiceHandle(hSCM);
|
||
return FALSE; // 未注册
|
||
}
|
||
|
||
*registered = TRUE;
|
||
|
||
// 获取服务状态
|
||
SERVICE_STATUS_PROCESS ssp;
|
||
DWORD bytesNeeded = 0;
|
||
memset(&ssp, 0, sizeof(ssp));
|
||
if (QueryServiceStatusEx(
|
||
hService,
|
||
SC_STATUS_PROCESS_INFO,
|
||
(LPBYTE)&ssp,
|
||
sizeof(SERVICE_STATUS_PROCESS),
|
||
&bytesNeeded)) {
|
||
*running = (ssp.dwCurrentState == SERVICE_RUNNING);
|
||
}
|
||
|
||
// 获取 EXE 路径
|
||
if (exePath && exePathSize > 0) {
|
||
DWORD bufSize = 0;
|
||
QueryServiceConfigA(hService, NULL, 0, &bufSize);
|
||
|
||
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
|
||
LPQUERY_SERVICE_CONFIGA pConfig = (LPQUERY_SERVICE_CONFIGA)malloc(bufSize);
|
||
if (pConfig) {
|
||
if (QueryServiceConfigA(hService, pConfig, bufSize, &bufSize)) {
|
||
strncpy_s(exePath, exePathSize, pConfig->lpBinaryPathName, _TRUNCATE);
|
||
}
|
||
free(pConfig);
|
||
}
|
||
}
|
||
}
|
||
|
||
CloseServiceHandle(hService);
|
||
CloseServiceHandle(hSCM);
|
||
return TRUE;
|
||
}
|
||
|
||
int ServerService_StartSimple(void)
|
||
{
|
||
// 打开SCM
|
||
SC_HANDLE hSCM = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
|
||
if (!hSCM) {
|
||
return (int)GetLastError();
|
||
}
|
||
|
||
// 打开服务并启动
|
||
SC_HANDLE hService = OpenServiceA(hSCM, SERVER_SERVICE_NAME, SERVICE_START);
|
||
if (!hService) {
|
||
int err = (int)GetLastError();
|
||
CloseServiceHandle(hSCM);
|
||
return err;
|
||
}
|
||
|
||
// 启动服务
|
||
BOOL ok = StartServiceA(hService, 0, NULL);
|
||
int err = ok ? ERROR_SUCCESS : (int)GetLastError();
|
||
|
||
CloseServiceHandle(hService);
|
||
CloseServiceHandle(hSCM);
|
||
|
||
return err;
|
||
}
|
||
|
||
int ServerService_Run(void)
|
||
{
|
||
SERVICE_TABLE_ENTRY ServiceTable[2];
|
||
ServiceTable[0].lpServiceName = (LPSTR)SERVER_SERVICE_NAME;
|
||
ServiceTable[0].lpServiceProc = (LPSERVICE_MAIN_FUNCTION)ServiceMain;
|
||
ServiceTable[1].lpServiceName = NULL;
|
||
ServiceTable[1].lpServiceProc = NULL;
|
||
|
||
Mprintf("========================================");
|
||
Mprintf("ServerService_Run() called");
|
||
|
||
if (StartServiceCtrlDispatcher(ServiceTable) == FALSE) {
|
||
DWORD err = GetLastError();
|
||
char buffer[256];
|
||
sprintf_s(buffer, sizeof(buffer), "StartServiceCtrlDispatcher failed: %d", (int)err);
|
||
Mprintf(buffer);
|
||
return (int)err;
|
||
}
|
||
return ERROR_SUCCESS;
|
||
}
|
||
|
||
int ServerService_Stop(void)
|
||
{
|
||
// 打开SCM
|
||
SC_HANDLE hSCM = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
|
||
if (!hSCM) {
|
||
return (int)GetLastError();
|
||
}
|
||
|
||
// 打开服务
|
||
SC_HANDLE hService = OpenServiceA(hSCM, SERVER_SERVICE_NAME, SERVICE_STOP | SERVICE_QUERY_STATUS);
|
||
if (!hService) {
|
||
int err = (int)GetLastError();
|
||
CloseServiceHandle(hSCM);
|
||
return err;
|
||
}
|
||
|
||
// 查询当前状态
|
||
SERVICE_STATUS status;
|
||
if (!QueryServiceStatus(hService, &status)) {
|
||
int err = (int)GetLastError();
|
||
CloseServiceHandle(hService);
|
||
CloseServiceHandle(hSCM);
|
||
return err;
|
||
}
|
||
|
||
// 如果服务未运行，直接返回成功
|
||
if (status.dwCurrentState == SERVICE_STOPPED) {
|
||
CloseServiceHandle(hService);
|
||
CloseServiceHandle(hSCM);
|
||
return ERROR_SUCCESS;
|
||
}
|
||
|
||
// 发送停止控制命令
|
||
if (!ControlService(hService, SERVICE_CONTROL_STOP, &status)) {
|
||
DWORD err = GetLastError();
|
||
if (err != ERROR_SERVICE_NOT_ACTIVE) {
|
||
CloseServiceHandle(hService);
|
||
CloseServiceHandle(hSCM);
|
||
return (int)err;
|
||
}
|
||
}
|
||
|
||
// 等待服务停止（最多30秒）
|
||
int waitCount = 0;
|
||
while (status.dwCurrentState != SERVICE_STOPPED && waitCount < 30) {
|
||
Sleep(1000);
|
||
waitCount++;
|
||
if (!QueryServiceStatus(hService, &status)) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
int result = (status.dwCurrentState == SERVICE_STOPPED) ? ERROR_SUCCESS : ERROR_TIMEOUT;
|
||
|
||
CloseServiceHandle(hService);
|
||
CloseServiceHandle(hSCM);
|
||
|
||
return result;
|
||
}
|
||
|
||
static void WINAPI ServiceMain(DWORD argc, LPTSTR* argv)
|
||
{
|
||
(void)argc;
|
||
(void)argv;
|
||
|
||
Mprintf("ServiceMain() called");
|
||
|
||
g_StatusHandle = RegisterServiceCtrlHandler(
|
||
SERVER_SERVICE_NAME,
|
||
ServiceCtrlHandler
|
||
);
|
||
|
||
if (g_StatusHandle == NULL) {
|
||
Mprintf("RegisterServiceCtrlHandler failed");
|
||
return;
|
||
}
|
||
|
||
ZeroMemory(&g_ServiceStatus, sizeof(g_ServiceStatus));
|
||
g_ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
|
||
g_ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
|
||
g_ServiceStatus.dwControlsAccepted = 0;
|
||
g_ServiceStatus.dwWin32ExitCode = 0;
|
||
g_ServiceStatus.dwServiceSpecificExitCode = 0;
|
||
g_ServiceStatus.dwCheckPoint = 0;
|
||
g_ServiceStatus.dwWaitHint = 0;
|
||
|
||
SetServiceStatus(g_StatusHandle, &g_ServiceStatus);
|
||
|
||
g_StopEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
|
||
if (g_StopEvent == NULL) {
|
||
Mprintf("CreateEvent failed");
|
||
g_ServiceStatus.dwCurrentState = SERVICE_STOPPED;
|
||
g_ServiceStatus.dwWin32ExitCode = GetLastError();
|
||
SetServiceStatus(g_StatusHandle, &g_ServiceStatus);
|
||
return;
|
||
}
|
||
|
||
g_ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
|
||
g_ServiceStatus.dwCurrentState = SERVICE_RUNNING;
|
||
g_ServiceStatus.dwWin32ExitCode = 0;
|
||
g_ServiceStatus.dwCheckPoint = 0;
|
||
|
||
SetServiceStatus(g_StatusHandle, &g_ServiceStatus);
|
||
Mprintf("Service is now running");
|
||
|
||
HANDLE hThread = CreateThread(NULL, 0, ServerService_WorkerThread, NULL, 0, NULL);
|
||
if (hThread) {
|
||
WaitForSingleObject(hThread, INFINITE);
|
||
SAFE_CLOSE_HANDLE(hThread);
|
||
}
|
||
|
||
SAFE_CLOSE_HANDLE(g_StopEvent);
|
||
|
||
g_ServiceStatus.dwControlsAccepted = 0;
|
||
g_ServiceStatus.dwCurrentState = SERVICE_STOPPED;
|
||
g_ServiceStatus.dwWin32ExitCode = 0;
|
||
g_ServiceStatus.dwCheckPoint = 3;
|
||
|
||
SetServiceStatus(g_StatusHandle, &g_ServiceStatus);
|
||
Mprintf("Service stopped");
|
||
}
|
||
|
||
static void WINAPI ServiceCtrlHandler(DWORD ctrlCode)
|
||
{
|
||
switch (ctrlCode) {
|
||
case SERVICE_CONTROL_STOP:
|
||
Mprintf("SERVICE_CONTROL_STOP received");
|
||
|
||
if (g_ServiceStatus.dwCurrentState != SERVICE_RUNNING)
|
||
break;
|
||
|
||
g_ServiceStatus.dwControlsAccepted = 0;
|
||
g_ServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;
|
||
g_ServiceStatus.dwWin32ExitCode = 0;
|
||
g_ServiceStatus.dwCheckPoint = 4;
|
||
g_ServiceStatus.dwWaitHint = 0;
|
||
|
||
SetServiceStatus(g_StatusHandle, &g_ServiceStatus);
|
||
SetEvent(g_StopEvent);
|
||
break;
|
||
|
||
case SERVICE_CONTROL_INTERROGATE:
|
||
SetServiceStatus(g_StatusHandle, &g_ServiceStatus);
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 服务工作线程
|
||
DWORD WINAPI ServerService_WorkerThread(LPVOID lpParam)
|
||
{
|
||
(void)lpParam;
|
||
int heartbeatCount = 0;
|
||
char buf[128];
|
||
|
||
Mprintf("========================================");
|
||
Mprintf("Worker thread started");
|
||
Mprintf("Service will launch Yama GUI in user sessions");
|
||
|
||
// 读取配置：运行模式 (RunNormal: 0=服务+SYSTEM, 1=普通模式, 2=服务+User)
|
||
int runNormal = THIS_CFG.GetInt("settings", "RunNormal", 0);
|
||
|
||
// 初始化会话监控器
|
||
ServerSessionMonitor monitor;
|
||
ServerSessionMonitor_Init(&monitor);
|
||
monitor.runAsUser = (runNormal == 2);
|
||
|
||
// 从配置恢复崩溃窗口状态
|
||
int savedCrashCount = THIS_CFG.GetInt(CFG_CRASH_SECTION, CFG_CRASH_WIN_COUNT, 0);
|
||
std::string savedStartStr = THIS_CFG.GetStr(CFG_CRASH_SECTION, CFG_CRASH_WIN_START, "0");
|
||
ULONGLONG savedFirstCrashTime = _strtoui64(savedStartStr.c_str(), NULL, 10);
|
||
ULONGLONG now = GetTickCount64();
|
||
|
||
if (savedCrashCount > 0 && savedFirstCrashTime > 0) {
|
||
// 检查是否仍在窗口期内
|
||
// 注意：GetTickCount64() 在系统重启后会重置，所以如果 savedFirstCrashTime > now，说明系统重启过
|
||
if (savedFirstCrashTime <= now && (now - savedFirstCrashTime) <= CRASH_WINDOW_MS) {
|
||
// 仍在窗口期内，恢复状态
|
||
monitor.crashCount = savedCrashCount;
|
||
monitor.firstCrashTime = savedFirstCrashTime;
|
||
sprintf_s(buf, sizeof(buf), "Crash window state restored: count=%d, elapsed=%llums",
|
||
savedCrashCount, now - savedFirstCrashTime);
|
||
Mprintf(buf);
|
||
} else {
|
||
// 窗口期已过或系统重启，清除状态
|
||
THIS_CFG.SetInt(CFG_CRASH_SECTION, CFG_CRASH_WIN_COUNT, 0);
|
||
THIS_CFG.SetStr(CFG_CRASH_SECTION, CFG_CRASH_WIN_START, "0");
|
||
Mprintf("Crash window expired or system rebooted, state cleared");
|
||
}
|
||
}
|
||
|
||
// 设置回调函数
|
||
monitor.onAgentStart = OnAgentStart;
|
||
monitor.onAgentExit = OnAgentExit;
|
||
monitor.onCrash = OnAgentCrash;
|
||
monitor.onCrashWindowChange = OnCrashWindowChange;
|
||
monitor.onCrashProtection = OnAgentCrashProtection;
|
||
|
||
if (!ServerSessionMonitor_Start(&monitor)) {
|
||
Mprintf("ERROR: Failed to start session monitor");
|
||
ServerSessionMonitor_Cleanup(&monitor);
|
||
return ERROR_SERVICE_SPECIFIC_ERROR;
|
||
}
|
||
|
||
Mprintf("Session monitor started successfully");
|
||
Mprintf("Yama GUI will be launched automatically in user sessions");
|
||
|
||
// 主循环，等待停止信号或监控器停止
|
||
// 使用 1 秒超时以快速响应监控器停止
|
||
while (WaitForSingleObject(g_StopEvent, 1000) != WAIT_OBJECT_0) {
|
||
// 检查监控器是否已停止（例如代理以 EXIT_MANUAL_STOP 退出或崩溃保护触发）
|
||
if (!monitor.running) {
|
||
Mprintf("Monitor stopped - exiting worker thread");
|
||
break;
|
||
}
|
||
heartbeatCount++;
|
||
if (heartbeatCount % 60 == 0) { // 每60秒记录一次（1秒 * 60 = 60秒）
|
||
sprintf_s(buf, sizeof(buf), "Service heartbeat - uptime: %d minutes", heartbeatCount / 60);
|
||
Mprintf(buf);
|
||
}
|
||
}
|
||
|
||
Mprintf("Stop signal received");
|
||
Mprintf("Stopping session monitor...");
|
||
ServerSessionMonitor_Stop(&monitor);
|
||
ServerSessionMonitor_Cleanup(&monitor);
|
||
|
||
Mprintf("Worker thread exiting");
|
||
Mprintf("========================================");
|
||
return ERROR_SUCCESS;
|
||
}
|
||
|
||
BOOL ServerService_Install(void)
|
||
{
|
||
SC_HANDLE schSCManager = OpenSCManager(
|
||
NULL,
|
||
NULL,
|
||
SC_MANAGER_ALL_ACCESS
|
||
);
|
||
|
||
if (schSCManager == NULL) {
|
||
Mprintf("ERROR: OpenSCManager failed (%d)\n", (int)GetLastError());
|
||
Mprintf("Please run as Administrator\n");
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
char szPath[MAX_PATH];
|
||
if (!GetModuleFileNameA(NULL, szPath, MAX_PATH)) {
|
||
Mprintf("ERROR: GetModuleFileName failed (%d)\n", (int)GetLastError());
|
||
CloseServiceHandle(schSCManager);
|
||
return FALSE;
|
||
}
|
||
|
||
// 添加 -service 参数
|
||
char szPathWithArg[MAX_PATH + 32];
|
||
sprintf_s(szPathWithArg, sizeof(szPathWithArg), "\"%s\" -service", szPath);
|
||
|
||
Mprintf("Installing service...\n");
|
||
Mprintf("Executable path: %s\n", szPathWithArg);
|
||
|
||
SC_HANDLE schService = CreateServiceA(
|
||
schSCManager,
|
||
SERVER_SERVICE_NAME,
|
||
SERVER_SERVICE_DISPLAY,
|
||
SERVICE_ALL_ACCESS,
|
||
SERVICE_WIN32_OWN_PROCESS,
|
||
SERVICE_AUTO_START,
|
||
SERVICE_ERROR_NORMAL,
|
||
szPathWithArg,
|
||
NULL, NULL, NULL, NULL, NULL
|
||
);
|
||
|
||
if (schService == NULL) {
|
||
DWORD err = GetLastError();
|
||
if (err == ERROR_SERVICE_EXISTS) {
|
||
Mprintf("INFO: Service already exists\n");
|
||
schService = OpenServiceA(schSCManager, SERVER_SERVICE_NAME, SERVICE_ALL_ACCESS);
|
||
if (schService) {
|
||
Mprintf("SUCCESS: Service is already installed\n");
|
||
CloseServiceHandle(schService);
|
||
}
|
||
return TRUE;
|
||
} else if (err == ERROR_ACCESS_DENIED) {
|
||
Mprintf("ERROR: Access denied. Please run as Administrator\n");
|
||
} else {
|
||
Mprintf("ERROR: CreateService failed (%d)\n", (int)err);
|
||
}
|
||
CloseServiceHandle(schSCManager);
|
||
return FALSE;
|
||
}
|
||
|
||
Mprintf("SUCCESS: Service created successfully\n");
|
||
|
||
// 设置服务描述
|
||
SERVICE_DESCRIPTION sd;
|
||
sd.lpDescription = (LPSTR)SERVER_SERVICE_DESC;
|
||
ChangeServiceConfig2(schService, SERVICE_CONFIG_DESCRIPTION, &sd);
|
||
|
||
// 立即启动服务
|
||
DWORD err = 0;
|
||
Mprintf("Starting service...\n");
|
||
if (StartServiceA(schService, 0, NULL)) {
|
||
Mprintf("SUCCESS: Service started successfully\n");
|
||
Sleep(2000);
|
||
|
||
SERVICE_STATUS status;
|
||
if (QueryServiceStatus(schService, &status)) {
|
||
if (status.dwCurrentState == SERVICE_RUNNING) {
|
||
Mprintf("SUCCESS: Service is running\n");
|
||
} else {
|
||
Mprintf("WARNING: Service state: %d\n", (int)status.dwCurrentState);
|
||
}
|
||
}
|
||
} else {
|
||
err = GetLastError();
|
||
if (err == ERROR_SERVICE_ALREADY_RUNNING) {
|
||
Mprintf("INFO: Service is already running\n");
|
||
err = 0;
|
||
} else {
|
||
Mprintf("WARNING: StartService failed (%d)\n", (int)err);
|
||
}
|
||
}
|
||
|
||
CloseServiceHandle(schService);
|
||
CloseServiceHandle(schSCManager);
|
||
return err == 0;
|
||
}
|
||
|
||
BOOL ServerService_Uninstall(void)
|
||
{
|
||
SC_HANDLE schSCManager = OpenSCManager(
|
||
NULL,
|
||
NULL,
|
||
SC_MANAGER_ALL_ACCESS
|
||
);
|
||
|
||
if (schSCManager == NULL) {
|
||
Mprintf("ERROR: OpenSCManager failed (%d)\n", (int)GetLastError());
|
||
return FALSE;
|
||
}
|
||
|
||
SC_HANDLE schService = OpenServiceA(
|
||
schSCManager,
|
||
SERVER_SERVICE_NAME,
|
||
SERVICE_STOP | DELETE | SERVICE_QUERY_STATUS
|
||
);
|
||
|
||
if (schService == NULL) {
|
||
Mprintf("ERROR: OpenService failed (%d)\n", (int)GetLastError());
|
||
CloseServiceHandle(schSCManager);
|
||
return FALSE;
|
||
}
|
||
|
||
// 停止服务
|
||
SERVICE_STATUS status;
|
||
Mprintf("Stopping service...\n");
|
||
if (ControlService(schService, SERVICE_CONTROL_STOP, &status)) {
|
||
Mprintf("Waiting for service to stop");
|
||
Sleep(1000);
|
||
|
||
int waitCount = 0;
|
||
while (QueryServiceStatus(schService, &status) && waitCount < 30) {
|
||
if (status.dwCurrentState == SERVICE_STOP_PENDING) {
|
||
Mprintf(".");
|
||
Sleep(1000);
|
||
waitCount++;
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
Mprintf("\n");
|
||
} else {
|
||
DWORD err = GetLastError();
|
||
if (err != ERROR_SERVICE_NOT_ACTIVE) {
|
||
Mprintf("WARNING: Failed to stop service (%d)\n", (int)err);
|
||
}
|
||
}
|
||
|
||
BOOL r = FALSE;
|
||
// 删除服务
|
||
Mprintf("Deleting service...\n");
|
||
if (DeleteService(schService)) {
|
||
Mprintf("SUCCESS: Service uninstalled successfully\n");
|
||
r = TRUE;
|
||
} else {
|
||
Mprintf("ERROR: DeleteService failed (%d)\n", (int)GetLastError());
|
||
}
|
||
|
||
CloseServiceHandle(schService);
|
||
CloseServiceHandle(schSCManager);
|
||
return r;
|
||
}
|