VC++使用服务做守护进程的示例(转载)

转载:http://blog.csdn.net/zdy0_2004/article/details/40461571

#define _WIN32_WINNT 0x502
#define _CRT_SECURE_NO_WARNINGS
#include <Windows.h>
#include <Shlwapi.h>
#include <WtsApi32.h>
#include <UserEnv.h>
#include <iostream>
#include <fstream>
#include <atlbase.h>

static const char* const lpServiceName = "ProtectService";
static SERVICE_STATUS_HANDLE hServiceStatus = NULL;
static SERVICE_STATUS    ServiceStatus = {};
static char szCurDir[MAX_PATH+] = {};
static bool bRun = false;
static HANDLE hProcess = NULL;
static FILE* fLog = NULL;
static std::ofstream ofs_log;

bool InstallService();
VOID WINAPI ServiceMain(DWORD dwArgc,LPTSTR *lpszArgv);
VOID WINAPI HandlerFunc(DWORD dwControl);
HANDLE RunAsLoggedUser(const char* lpPath,char* lpCmdLine);
void WorkFunc();

int main(int argc, char **argv)
{
    GetModuleFileName(NULL,szCurDir,MAX_PATH);
    *strrchr(szCurDir,'\\') = '\0';

    char szLogPath[MAX_PATH+];
    sprintf(szLogPath,"%s\\Service.log",szCurDir);
    fLog = fopen(szLogPath,"a+");
    setvbuf(fLog,NULL,_IONBF,);

    ofs_log.open(szLogPath,std::ios::app);

    SERVICE_TABLE_ENTRY ServiceTable[];
    char szBuffer[];
    strcpy(szBuffer,lpServiceName);
    ServiceTable[].lpServiceName = szBuffer;
    ServiceTable[].lpServiceProc = (LPSERVICE_MAIN_FUNCTION)ServiceMain;

    ServiceTable[].lpServiceName = NULL;
    ServiceTable[].lpServiceProc = NULL;

    // 启动服务的控制分派机线程
    if (!StartServiceCtrlDispatcher(ServiceTable))
    {
        ofs_log<<"程序不是以服务方式启动"<<std::endl;
        std::cout<<"程序不是以服务方式启动，要创建服务并启动吗？y/n:";
        if (getchar() == 'y')
        {
            // 安装服务
            if (!InstallService())
            {
                ofs_log<<"安装服务失败"<<std::endl;
                std::cout<<"安装服务失败，具体原因请查看日志"<<std::endl;
                return ;
            }
            ofs_log<<"安装服务成功"<<std::endl;
        }

    }
    return ;
}

bool InstallService()
{
    SC_HANDLE hSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
    if (!hSCManager)
    {
        ofs_log<<"OpenSCManager失败，错误码为："<<GetLastError()<<std::endl;
        return false;
    }

    SC_HANDLE hService = OpenService(hSCManager,lpServiceName,SERVICE_QUERY_CONFIG);
    if (hService)
    {
        ofs_log<<"服务已经存在"<<std::endl;
        CloseServiceHandle(hSCManager);
        CloseServiceHandle(hService);
        return false;
    }

    char    szPath[MAX_PATH+];
    GetModuleFileName(NULL,szPath,MAX_PATH);
    hService = CreateService(hSCManager,
        lpServiceName,
        lpServiceName,
        SERVICE_ALL_ACCESS,
        SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS,
        SERVICE_AUTO_START,
        SERVICE_ERROR_NORMAL,
        szPath,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL);
    if (!hService)
    {
        ofs_log<<"CreateService失败，错误码为"<<GetLastError()<<std::endl;
        CloseServiceHandle(hSCManager);
        return false;
    }

    if (!StartService(hService,,NULL))
    {
        ofs_log<<"服务安装成功，但是启动服务失败，错误码为："<<GetLastError()<<std::endl;
        CloseServiceHandle(hService);
        CloseServiceHandle(hSCManager);
        return false;
    }

    CloseServiceHandle(hService);
    CloseServiceHandle(hSCManager);

    return true;
}

VOID WINAPI ServiceMain( DWORD dwArgc,LPTSTR *lpszArgv )
{
    ServiceStatus.dwServiceType = SERVICE_WIN32;
    ServiceStatus.dwCurrentState = SERVICE_RUNNING;
    ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_SHUTDOWN | SERVICE_ACCEPT_STOP;
    hServiceStatus = RegisterServiceCtrlHandler(lpServiceName,HandlerFunc);
    if (!hServiceStatus)
    {
        ofs_log<<"RegisterServiceCtrlHandler失败，错误码为："<<GetLastError()<<std::endl;
        return;
    }
    if (!SetServiceStatus(hServiceStatus,&ServiceStatus))
    {
        ofs_log<<"SetServiceStatus失败，错误码为："<<GetLastError()<<std::endl;
        return;
    }

    bRun = true;
    WorkFunc();
}

VOID WINAPI HandlerFunc( DWORD dwControl )
{
    ofs_log<<"收到服务消息："<<dwControl<<std::endl;

    if (dwControl == SERVICE_CONTROL_STOP || dwControl == SERVICE_CONTROL_SHUTDOWN)
    {
        // 停止服务
        ofs_log<<"服务停止"<<std::endl;
        ServiceStatus.dwCurrentState = SERVICE_STOPPED;
        bRun = false;
        if (hProcess)
        {
            TerminateProcess(hProcess,);
        }
    }

    SetServiceStatus(hServiceStatus,&ServiceStatus);
}

HANDLE RunAsCreator(const char* lpPath, char* lpCmdLine)
{
    if (!PathFileExists(lpPath))
    {
        ofs_log<<"指定的要启动的程序不存在"<<std::endl;
        return NULL;
    }

    char szSubProcCurDir[MAX_PATH];
    strcpy(szSubProcCurDir,lpPath);
    *strrchr(szSubProcCurDir,'\\') = '\0';

    STARTUPINFO si = {};
    PROCESS_INFORMATION pi = {};
    si.cb = sizeof(si);

    if (!CreateProcess(lpPath,lpCmdLine,NULL,NULL,FALSE,NORMAL_PRIORITY_CLASS | CREATE_NEW_CONSOLE,NULL,szSubProcCurDir,&si,&pi))
    {
        ofs_log<<"CreateProcess失败，错误码为："<<GetLastError()<<std::endl;
        return NULL;
    }

    if (pi.hThread && pi.hThread != INVALID_HANDLE_VALUE)
    {
        CloseHandle(pi.hThread);
    }

    return pi.hProcess;
}

HANDLE RunAsLoggedUser( const char* lpPath,char* lpCmdLine )
{
    if (!PathFileExists(lpPath))
    {
        ofs_log<<"指定的要启动的程序不存在"<<std::endl;
        return NULL;
    }

    DWORD dwSid = WTSGetActiveConsoleSessionId();
    ofs_log<<"当前登录用户ID为："<<dwSid<<std::endl;

    HANDLE hExistingToken = NULL;
    if (!WTSQueryUserToken(dwSid,&hExistingToken))
    {
        ofs_log<<"WTSQueryUserToken失败，错误码为："<<GetLastError()<<std::endl;
        return NULL;
    }

    HANDLE hNewToken = NULL;
    if (!DuplicateTokenEx(hExistingToken,MAXIMUM_ALLOWED,NULL,SecurityIdentification,TokenPrimary,&hNewToken))
    {
        ofs_log<<"DuplicateTokenEx失败，错误码为："<<GetLastError()<<std::endl;
        CloseHandle(hExistingToken);
        return NULL;
    }
    CloseHandle(hExistingToken);

    LPVOID pEnv = NULL;
    DWORD dwCreationFlags = NORMAL_PRIORITY_CLASS | CREATE_NEW_CONSOLE;
    if (CreateEnvironmentBlock(&pEnv,hNewToken,FALSE))
    {
        dwCreationFlags |= CREATE_UNICODE_ENVIRONMENT;
    }

    STARTUPINFO si = {};
    PROCESS_INFORMATION pi = {};
    si.cb = sizeof(si);
    si.lpDesktop = "WinSta0\\Default";

    char szSubProcCurDir[MAX_PATH+];
    strcpy(szSubProcCurDir,lpPath);
    *strrchr(szSubProcCurDir,'\\') = '\0';

    if (!CreateProcessAsUser(hNewToken,lpPath,lpCmdLine,NULL,NULL,FALSE,dwCreationFlags,pEnv,szSubProcCurDir,&si,&pi))
    {
        ofs_log<<"CreateProcessAsUser失败，错误码为："<<GetLastError()<<std::endl;
        if (pEnv)
        {
            DestroyEnvironmentBlock(pEnv);
        }
        return NULL;
    }

    if (pi.hThread && pi.hThread != INVALID_HANDLE_VALUE)
    {
        CloseHandle(pi.hThread);
    }

    if (pEnv)
    {
        DestroyEnvironmentBlock(pEnv);
    }

    return pi.hProcess;
}

HANDLE RunAsSpecifiedUser(const char* lpUserName,const char* lpPassword,const char* lpPath,char* lpCmdLine)
{
    if (!PathFileExists(lpPath))
    {
        ofs_log<<"指定的要启动的程序不存在"<<std::endl;
        return NULL;
    }

    HANDLE hExistingToken = NULL;
    if (!LogonUser(lpUserName,NULL,lpPassword,LOGON32_LOGON_INTERACTIVE,LOGON32_PROVIDER_DEFAULT,&hExistingToken))
    {
        ofs_log<<"LogonUser失败，错误码为："<<GetLastError()<<std::endl;
        return NULL;
    }

    HANDLE hNewToken = NULL;
    if (!DuplicateTokenEx(hExistingToken,MAXIMUM_ALLOWED,NULL,SecurityIdentification,TokenPrimary,&hNewToken))
    {
        ofs_log<<"DuplicateTokenEx失败，错误码为："<<GetLastError()<<std::endl;
        CloseHandle(hExistingToken);
        return NULL;
    }
    CloseHandle(hExistingToken);

    LPVOID pEnv = NULL;
    DWORD dwCreationFlags = NORMAL_PRIORITY_CLASS | CREATE_NEW_CONSOLE;
    if (CreateEnvironmentBlock(&pEnv,hNewToken,FALSE))
    {
        dwCreationFlags |= CREATE_UNICODE_ENVIRONMENT;
    }

    STARTUPINFO si = {};
    PROCESS_INFORMATION pi = {};
    si.cb = sizeof(si);
    //si.lpDesktop = "WinSta0\\Default";

    char szSubProcCurDir[MAX_PATH+];
    strcpy(szSubProcCurDir,lpPath);
    *strrchr(szSubProcCurDir,'\\') = '\0';

    if (!CreateProcessAsUser(hNewToken,lpPath,lpCmdLine,NULL,NULL,FALSE,dwCreationFlags,pEnv,szSubProcCurDir,&si,&pi))
    {
        ofs_log<<"CreateProcessAsUser失败，错误码为："<<GetLastError()<<std::endl;
        if (pEnv)
        {
            DestroyEnvironmentBlock(pEnv);
        }
        return NULL;
    }

    if (pi.hThread && pi.hThread != INVALID_HANDLE_VALUE)
    {
        CloseHandle(pi.hThread);
    }

    if (pEnv)
    {
        DestroyEnvironmentBlock(pEnv);
    }

    return pi.hProcess;
}

void WorkFunc()
{
    char szIniPath[MAX_PATH+];
    sprintf(szIniPath,"%s\\config.ini",szCurDir);
    if (!PathFileExists(szCurDir))
    {
        ofs_log<<"配置文件不存在"<<std::endl;
    }

    char szProgPath[MAX_PATH+];
    GetPrivateProfileString("PROGRAM","PATH","",szProgPath,MAX_PATH,szIniPath);
    char szCmdLine[];
    GetPrivateProfileString("PROGRAM","CMD","",szCmdLine,,szIniPath);
    int method = GetPrivateProfileInt("USERINFO","METHOD",,szIniPath);
    char szUserName[];
    char szPassword[];
    GetPrivateProfileString("USERINFO","UID","",szUserName,,szIniPath);
    GetPrivateProfileString("USERINFO","PWD","",szPassword,,szIniPath);

    while (bRun)
    {
        switch (method)
        {
        case :
            hProcess = RunAsCreator(szProgPath,szCmdLine);
            break;
        case :
            hProcess = RunAsLoggedUser(szProgPath,szCmdLine);
            break;
        case :
            hProcess = RunAsSpecifiedUser(szUserName,szPassword,szProgPath,szCmdLine);
            break;
        default:
            ofs_log<<"未知的启动方式："<<method<<std::endl;
            return;
        }

        if (!hProcess)
        {
            ofs_log<<"创建进程失败失败"<<std::endl;
        }
        WaitForSingleObject(hProcess,INFINITE);
        CloseHandle(hProcess);
        hProcess = NULL;
        ofs_log<<"被守护进程退出"<<std::endl;
        Sleep();
    }
}

守护进程Demo