Windows 服务程序(二)

服务控制管理器 (SCM, Service Control Manager),它在系统启动时自动启动，其主要作用是维护和管理一张服务信息表。

OpenSCManager() 介绍：
功能：建立了一个到服务控制管理器的连接，并打开指定的数据库。
函数原型：SC_HANDLE OpenSCManager(
                  LPCSTR lpMachineName,   // 指向零终止字符串，指定目标计算机的名称。  通常为 NULL。

                  LPCSTR lpDatabaseName, // 指向零终止字符串，指定将要打开的服务控制管理数据库的名称。通常为 NULL。

                  DWORD  dwDesiredAccess  // 指定服务访问控制管理器的权限。通常为 SC_MANAGER_ALL_ACCESS。
                  );
参数：
lpMachineName
指向零终止字符串，指定目标计算机的名称。
如果该指针为NULL ，或者它指向一个空字符串，那么该函数连接到本地计算机上的服务控制管理器。
lpDatabaseName
指向零终止字符串，指定将要打开的服务控制管理数据库的名称。
此字符串应被置为 SERVICES_ACTIVE_DATABASE。
如果该指针为NULL ，则打开默认的 SERVICES_ACTIVE_DATABASE 数据库。
dwDesiredAccess
指定服务访问控制管理器的权限。
在授予要求的权限前，系统会检查调用进程的权限令牌，该令牌针对与服务控制管理器相关的安全描述符的权限控制列表。
此外，该函数的调用将隐式地指定 SC_MANAGER_CONNECT 的访问权限。
此外，下列服务控制管理器对象的访问类型可以被指定：
SC_MANAGER_ALL_ACCESS 除了所有此表中列出的访问类型，还包括 STANDARD_RIGHTS_REQUIRED。
SC_MANAGER_CONNECT 可以连接到服务控制管理器。
SC_MANAGER_CREATE_SERVICE 使要求的 CreateService 函数创建一个服务对象，并将其添加到数据库中。
SC_MANAGER_ENUMERATE_SERVICE 使要求的 EnumServicesStatus 功能清单的服务，这是在数据库中。
SC_MANAGER_LOCK 使要求的 LockServiceDatabase 功能获得锁定数据库。
SC_MANAGER_QUERY_LOCK_STATUS 使要求的 QueryServiceLockStatus 检索功能锁定状态信息的数据库。
 
返回值
如果函数成功，返回值是一个指定的服务控制管理器数据库的句柄。如果函数失败，返回值为NULL 。
 
OpenService() 介绍：
功能：打开一个服务对象。
函数原型：SC_HANDLE OpenService(
                  SC_HANDLE hSCManager,   // 使用 OpenSCManager() 打开后返回的对象句柄。
                  LPCSTR  lpServiceName,      // 需要打开的服务的名称，其中不能出现斜杆。
                  DWORD  dwDesiredAccess   // 打开权限。通常为 SC_MANAGER_ALL_ACCESS。
                  );
参数：
lpServiceName
这是在创建服务对象时由 CreateService 函数的 lpServiceName 参数指定的名称,
而不是用户界面应用程序显示的用于标识服务的服务显示名称。
dwDesiredAccess
权限同上。
在授予请求的访问权限之前, 系统将根据与服务对象关联的安全描述符的自由访问控制列表检查调用进程的访问令牌。
返回值：如果函数成功, 则返回值是服务的句柄。如果函数失败，返回值为NULL 。

CreateService() 介绍：
功能：创建一个服务对象，并将其添加到指定的服务控制管理器数据库的函数。

函数原型：SC_HANDLE CreateService(
                  SC_HANDLE  hSCManager,    // 服务控制管理器数据库的句柄。
                  LPCSTR  lpServiceName,    // 要安装的服务的名称。
                  LPCSTR  lpDisplayName,  // 用户界面程序用来标识服务的显示名称。
                  DWORD  dwDesiredAccess, // 对服务的访问权限。通常为 SC_MANAGER_ALL_ACCESS。
                  DWORD  dwServiceType,  // 服务类型。 通常为 SERVICE_WIN32_OWN_PROCESS。
                  DWORD  dwStartType,   // "服务启动" 选项。通常为 SERVICE_AUTO_START。
                  DWORD  dwErrorControl, // 错误的严重性和所采取的操作。
                  LPCSTR  lpBinaryPathName,  // 服务二进制文件的完全限定路径。
                  LPCSTR  lpLoadOrderGroup,  // 通常不关心，设置为 NULL。
                  LPDWORD  lpdwTagId,  // 通常不关心，设置为 NULL。
                  LPCSTR lpDependencies,  // 通常不关心，设置为 NULL。
                  LPCSTR  lpServiceStartName,  // 通常不关心，设置为 NULL。
                  LPCSTR  lpPassword  // 通常不关心，设置为 NULL。
                  );

参数：

hSCManager

服务控制管理器数据库的句柄。此句柄由 OpenSCManager 函数返回,

并且必须具有 SC_MANAGER_CREATE_SERVICE 访问权限。

lpServiceName

要安装的服务的名称。最大字符串长度为256个字符。

服务控制管理器数据库保留字符的大小写, 但服务名称比较始终不区分大小写。正斜杠 (/) 和反斜线 () 不是有效的服务名称字符。

lpDisplayName

用户界面程序用来标识服务的显示名称。此字符串的最大长度为256个字符。

该名称在服务控制管理器中保留为 case。显示名称比较始终不区分大小写。

dwDesiredAccess

对服务的访问。在授予请求的访问权限之前, 系统将检查调用进程的访问令牌。值同 OpenSCManager() 的该参数。

dwServiceType

服务类型

值	含义
SERVICE_FILE_SYSTEM_DRIVER	文件系统驱动程序服务。
SERVICE_KERNEL_DRIVER	驱动程序服务。
SERVICE_WIN32_OWN_PROCESS	在其自己的进程中运行的服务。(常用的值)
SERVICE_USER_OWN_PROCESS	该服务在登录用户帐户下在其自己的进程中运行。

dwStartType

"服务启动" 选项

值	含义
SERVICE_AUTO_START	在系统启动期间, 服务控制管理器自动启动服务。(常用的值)
SERVICE_BOOT_START	由系统加载器启动的设备驱动程序。此值仅对驱动程序服务有效。
SERVICE_DEMAND_START	当进程调用 StartService 函数时, 由服务控制管理器启动的服务。
SERVICE_DISABLED	无法启动的服务。尝试启动服务会导致错误代码 ERROR_SERVICE_DISABLED。
SERVICE_SYSTEM_START	由 IoInitSystem 函数启动的设备驱动程序。此值仅对驱动程序服务有效。

dwErrorControl

错误的严重性和所采取的操作

值	含义
SERVICE_ERROR_CRITICAL	如果可能, 启动程序会在事件日志中记录错误。如果正在启动最后一次已知良好的配置, 则启动操作将失败。否则, 系统将以最后一次正确的配置重新启动。
SERVICE_ERROR_IGNORE	启动程序忽略错误并继续启动操作。
SERVICE_ERROR_NORMAL	启动程序在事件日志中记录错误, 但继续启动操作。
SERVICE_ERROR_SEVERE	启动程序在事件日志中记录错误。如果正在启动最后一次已知良好的配置, 则启动操作将继续进行。否则, 系统将以上次已知良好的配置重新启动。

lpBinaryPathName

服务二进制文件的完全限定路径。如果路径包含空格, 则必须引用它以使其正确解释。
该路径还可以包含自动启动服务的参数。例如, "d:mysharemyservice.exe arg1 arg2"。这些参数被传递到服务入口点。
如果在另一台计算机上指定路径, 则该共享必须由本地计算机的计算机帐户访问, 因为这是远程调用中使用的安全上下文。

但是, 此要求允许远程计算机中的任何潜在漏洞影响本地计算机。因此, 最好使用本地文件。

返回值：如果函数成功, 则返回值是服务的句柄。如果函数失败, 返回值为 NULL。

StartService() 介绍：
功能：启动服务。

函数原型：BOOL StartService(
                  SC_HANDLE hService,  

                  //此句柄由 OpenService 或 CreateService 函数返回, 并且必须具有 SERVICE_START 访问权限。
                  DWORD     dwNumServiceArgs,  //  通常不关心，设置为 NULL。
                  LPCSTR    *lpServiceArgVectors  //  通常不关心，设置为 NULL。
                  );

返回值：非零表示成功，零表示失败。

QueryServiceStatus() 介绍：

功能：检索指定服务的当前状态。

函数原型：BOOL QueryServiceStatus(
                  SC_HANDLE   hService, 

                  // 此句柄由 OpenService 或 CreateService 函数返回, 并且必须具有 SERVICE_START 访问权限。
                  LPSERVICE_STATUS  lpServiceStatus // 指向接收状态信息的 SERVICE_STATUS 结构的指针。
                  );

返回值：非零表示成功，零表示失败。

ControlService() 介绍：

功能：向服务发送控制代码。

函数原型：BOOL ControlService(
                  SC_HANDLE   hService,

                   // 此句柄由 OpenService 或 CreateService 函数返回, 并且必须具有 SERVICE_START 访问权限。
                  DWORD   dwControl,   // 控制代码。
                  LPSERVICE_STATUS  lpServiceStatus  // 指向接收最新服务状态信息的 SERVICE_STATUS 结构的指针。
                  );

参数

dwControl

控制代码	含义
SERVICE_CONTROL_CONTINUE	通知暂停的服务应恢复。hService 句柄必须具有 SERVICE_PAUSE_CONTINUE 访问权限。
SERVICE_CONTROL_INTERROGATE	通知服务应将其当前状态信息报告给服务控制管理器。hService 句柄必须具有 SERVICE_INTERROGATE 访问权限。
SERVICE_CONTROL_NETBINDADD	通知网络服务有一个用于绑定的新组件。hService 句柄必须具有 SERVICE_PAUSE_CONTINUE 访问权限。
SERVICE_CONTROL_NETBINDDISABLE	通知网络服务其中一个绑定已被禁用。hService 句柄必须具有 SERVICE_PAUSE_CONTINUE 访问权限。
SERVICE_CONTROL_NETBINDENABLE	通知网络服务已启用已禁用的绑定。hService 句柄必须具有 SERVICE_PAUSE_CONTINUE 访问权限。
SERVICE_CONTROL_NETBINDREMOVE	通知网络服务已删除绑定的组件。hService 句柄必须具有 SERVICE_PAUSE_CONTINUE 访问权限。
SERVICE_CONTROL_PARAMCHANGE	通知服务其启动参数已更改。hService 句柄必须具有 SERVICE_PAUSE_CONTINUE 访问权限。
SERVICE_CONTROL_PAUSE	通知服务应暂停。hService 句柄必须具有 SERVICE_PAUSE_CONTINUE 访问权限。
SERVICE_CONTROL_STOP	通知服务应停止。hService 句柄必须具有 SERVICE_STOP 访问权限。

返回值：非零表示成功，零表示失败。

DeleteService() 介绍：

功能：将指定的服务标记为从服务控制管理器数据库中删除。

函数原型：BOOL DeleteService(
                  SC_HANDLE hService // 此句柄由 OpenService 或 CreateService 函数返回, 并且必须具有 "删除" 访问权限。
                  );

返回值：非零表示成功，零表示失败。

CloseServiceHandle() 介绍：

功能：关闭服务控制管理器或服务对象的句柄。

函数原型：BOOL CloseServiceHandle(
                  SC_HANDLE hSCObject  // 要关闭的服务控件管理器对象或服务对象的句柄。
                  );

参数

hSCObject

要关闭的服务控件管理器对象或服务对象的句柄。

服务控制管理器对象的句柄由 OpenSCManager 函数返回, 并且服务对象的句柄由 OpenService 或 CreateService 函数返回。

返回值：非零表示成功，零表示失败。

DemoCode： 

#include<stdio.h>
#include<Windows.h>
#include<winsock.h>
#pragma comment(lib, "Advapi32")
#pragma comment(lib,"ws2_32")
#define MYPORT 1234
#define BACKLOG 10
SERVICE_STATUS ServiceStatus;
SERVICE_STATUS_HANDLE hStatus;
SC_HANDLE SCManager;
SC_HANDLE SCService;
void WINAPI ServiceMain(DWORD dwArgc, LPSTR *lpszArgv);
void WINAPI ServiceHandler(DWORD fdwControl);
void InstallService();
void StartService0();
void StopService();
void UnInstallService();
void MyWork();   // 自定义特定功能的函数。本打算用线程调用完成的，简单起见就这样吧。
//DWORD WINAPI MyWork(LPVOID lpParam);  该函数涉及到线程，先放这里。
int main(void)
{
    SERVICE_TABLE_ENTRY ServTable[2];
    ServTable[0].lpServiceName = (LPSTR)"Test";
    ServTable[0].lpServiceProc = (LPSERVICE_MAIN_FUNCTION)ServiceMain;
    ServTable[1].lpServiceName = NULL;
    ServTable[1].lpServiceProc = NULL;
    StartServiceCtrlDispatcher(ServTable);
    InstallService();
    StartService0();
    return 0;
}

void WINAPI ServiceMain(DWORD dwArgc, LPSTR *lpszArgv)
{
    ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
    ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
    ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP |
        SERVICE_ACCEPT_PAUSE_CONTINUE | SERVICE_ACCEPT_SHUTDOWN;
    ServiceStatus.dwWin32ExitCode = 0;
    ServiceStatus.dwCheckPoint = 0;
    ServiceStatus.dwServiceSpecificExitCode = 0;
    ServiceStatus.dwWaitHint = 0;
    hStatus = RegisterServiceCtrlHandler("BackDoor",
        (LPHANDLER_FUNCTION)ServiceHandler);
    if (!hStatus)
    {
        printf("Register Service Error!
");
        system("pause");
        return;
    }
    SetServiceStatus(hStatus, &ServiceStatus);
    if (GetLastError() != NO_ERROR)
    {
        ServiceStatus.dwCurrentState = SERVICE_STOPPED;
        ServiceStatus.dwCheckPoint = 0;
        ServiceStatus.dwWaitHint = 0;
        SetServiceStatus(hStatus, &ServiceStatus);
        printf("Start Error!
");
        system("pause");
        return;
    }
    ServiceStatus.dwCurrentState = SERVICE_RUNNING;
    ServiceStatus.dwCheckPoint = 0;
    ServiceStatus.dwWaitHint = 0;
    SetServiceStatus(hStatus, &ServiceStatus);
    // 从这里开始可以放入你想服务为你做的事情。
    /*
    HANDLE hThread = CreateThread(NULL, 0, MyWork, NULL, 0, NULL);
    if (hThread = NULL)
        return;
    */
    MyWork();
    return;
}

void WINAPI ServiceHandler(DWORD fdwControl)
{
    switch (fdwControl)
    {
    case SERVICE_CONTROL_PAUSE:
        ServiceStatus.dwCurrentState = SERVICE_PAUSED;
        break;
    case SERVICE_CONTROL_CONTINUE:
        ServiceStatus.dwCurrentState = SERVICE_RUNNING;
        break;
    case SERVICE_CONTROL_STOP:
    case SERVICE_CONTROL_SHUTDOWN:
        ServiceStatus.dwCurrentState = SERVICE_STOPPED;
        ServiceStatus.dwCheckPoint = 0;
        ServiceStatus.dwWaitHint = 0;
        SetServiceStatus(hStatus, &ServiceStatus);
        StopService();
        UnInstallService();
        return;
    default:
        break;
    }
    SetServiceStatus(hStatus, &ServiceStatus);
    return;
}

void InstallService()
{
    char PathName[MAX_PATH];
    char SysName[MAX_PATH];
    GetModuleFileName(NULL, PathName, MAX_PATH);
    GetSystemDirectory(SysName, MAX_PATH);
    wsprintf(SysName, "%s\Test.exe", SysName);
    if (!MoveFile(PathName, SysName))
    {
        printf(" Move File Error!
");
        system("pause");
        return;
    }
    SCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (SCManager == NULL)
    {
        printf("OpenSCManager Error!
");
        system("pause");
        return;
    }
    SCService = CreateService(
        SCManager,
        "BackDoor",
        "Service32",
        SC_MANAGER_ALL_ACCESS,
        SERVICE_WIN32_OWN_PROCESS,
        SERVICE_AUTO_START,
        SERVICE_ERROR_IGNORE,
        SysName,
        NULL, NULL, NULL, NULL, NULL);
    if (SCService == NULL)
    {
        printf("CreateService Error!
");
        CloseServiceHandle(SCManager);
        system("pause");
        return;
    }
    printf("Create Service Succeed!
");
    CloseServiceHandle(SCService);
    CloseServiceHandle(SCManager);
    return;
}

void StartService0()
{
    SCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (SCManager == NULL)
    {
        printf("OpenSCManager Error!
");
        system("pause");
        return;
    }
    SCService = OpenService(SCManager, "BackDoor", SC_MANAGER_ALL_ACCESS);
    if(SCService == NULL)
    {
        printf("OpenService Error!
");
        CloseServiceHandle(SCManager);
        system("pause");
        return;
    }
    if (StartService(SCService, NULL, NULL))
    {
        while (QueryServiceStatus(SCService,&ServiceStatus))
        {
            if (ServiceStatus.dwCurrentState == SERVICE_RUNNING)
                break;
            else
                Sleep(100);
        }
        printf("Service Start Succeed!
");
    }
    CloseServiceHandle(SCService);
    CloseServiceHandle(SCManager);
    return;
}

void StopService()
{
    SCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (SCManager == NULL)
    {
        printf("OpenSCManager Error!
");
        system("pause");
        return;
    }
    SCService = OpenService(SCManager, "BackDoor", SC_MANAGER_ALL_ACCESS);
    if (SCService == NULL)
    {
        printf("Open Service Error!
");
        CloseServiceHandle(SCManager);
        system("pause");
        return;
    }
    if (ControlService(SCService, SERVICE_CONTROL_STOP, &ServiceStatus))
    {
        while (QueryServiceStatus(SCService, &ServiceStatus))
        {
            if (ServiceStatus.dwCurrentState == SERVICE_STOPPED)
                break;
            else
                Sleep(100);
        }
        printf("Service Stop Succeed!
");
    }
    CloseServiceHandle(SCService);
    CloseServiceHandle(SCManager);
    return;
}

void UnInstallService()
{
    SCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (SCManager == NULL)
    {
        printf("OpenSCManager Error!
");
        system("pause");
        return;
    }
    SCService = OpenService(SCManager, "BackDoor", SC_MANAGER_ALL_ACCESS);
    if (SCService == NULL)
    {
        printf("Open Service Error!
");
        CloseServiceHandle(SCManager);
        system("pause");
        return;
    }
    if (DeleteService(SCService))
        printf("Uninstall Service Succeed!
");
    else
        printf("Unistall Service Error!
");
    CloseServiceHandle(SCService);
    CloseServiceHandle(SCManager);
    return;
}

void MyWork()
{
    SOCKET sockfd, new_fd;
    struct sockaddr_in my_addr;
    struct sockaddr_in their_addr;
    int sin_size = sizeof(struct sockaddr_in);
    WSADATA ws;
    if (WSAStartup(MAKEWORD(2, 2), &ws) != 0)
    {
        printf("WSAStart up Error!
");
        WSACleanup();
        system("pause");
        exit(0);
    }
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
    {
        printf("Socket Error!
");
        system("pause");
        exit(0);
    }
    my_addr.sin_family = AF_INET;
    my_addr.sin_port = htons(MYPORT);
    my_addr.sin_addr.S_un.S_addr = INADDR_ANY;
    if (bind(sockfd, (struct sockaddr*)&my_addr, sizeof(struct sockaddr)) == -1)
    {
        printf("Bind Error!
");
        closesocket(sockfd);
        system("pause");
        exit(0);
    }
    if (listen(sockfd, BACKLOG) == SOCKET_ERROR)
    {
        printf("Listen Error!
");
        closesocket(sockfd);
        system("pause");
        exit(0);
    }
    if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) == INVALID_SOCKET)
    {
        printf("Accept Error!
");
        closesocket(sockfd);
        exit(0);
    }
    closesocket(sockfd);
    closesocket(new_fd);
    WSACleanup();
    return;
}

/*
DWORD WINAPI MyWork(LPVOID lpParam)
{
    return 0;
}
*/

这个程序需要用管理员身份运行，运行结果如下图：