编写一个简单的服务程序

Windows服务程序编写

最新推荐文章于 2024-10-16 09:28:19 发布

原创最新推荐文章于 2024-10-16 09:28:19 发布 · 865 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#service #框架 #null #function #interface #table

本文介绍了一个简单的Windows服务程序框架，包括main()、ServiceMain()和ServiceCtrlHandler()三个关键函数的作用及实现方式，并提供了一个具体的示例代码。

网上已经有很多介绍编写服务程序的文章，而且《Win32系统服务开发与实例》这本书更加系统详细地介绍了。不过我想自己下笔写写，这样更能帮助我消化。

每个服务都是根据一个框架来搭建的，只要掌握了这个框架，就可以编写一个简单的服务程序了。下面首先来介绍这个框架。

这个框架主要包括3个函数:main(),ServiceMain()和ServiceCtrlHandler()。

main()函数，主要向SCM注册ServiceMain函数，它先初始化一个SERVICE_TABLE_ENTRY结构，这个结构主要记载了你将要创建的服务名称和对应服务的ServiceMain函数，这里可以填写多个服务，后面会介绍如何填写这个结构。填写了这个结构之后，就该时候调用StartServiceCtrlDispatcher函数来向SCM注册这个结构了。这里有一点要注意的是，从main开始执行，到调用StartServiceCtrlDispatcher函数之间的时间不能超过30秒，不然的话，SCM就会认为是时间超时，内部出现错误，从而终止服务。

ServiceMain()函数，当SCM启动服务的时候，系统会自动调用相应服务的ServiceMain函数。在这个函数里面可以完成一些初始化工作，主要包括注册请求操作函数，调用RegisterServiceCtrlHandler函数来完成。当SCM发送停止、暂停、重新开始等等请求的时候，该函数会自动被调用，来处理这些请求信息。ServiceMain函数的另外一个重大任务是创建真正的服务线程或者进程，这些线程和进程主要来执行你要做的服务工作。这里要注意的是，如果ServiceMain函数返回了，该服务就会终止，所以在正常的情况下，你要保证你的服务继续运行，你可以通过设置一个事件，然后在ServiceMain函数的后面等待这个事件。

ServiceCtrlHandler()函数，该函数主要处理发送给服务的请求信息，例如停止、暂停、重新开始。它接收一个整数控制代码，然后你需要判断这个控制代码对应的是什么请求，然后再完成相应的处理工作。
主要的控制代码有：
SERVICE_CONTROL_STOP:通知服务停止
SERVICE_CONTROL_PAUSE:通知服务暂停
SERVICE_CONTROL_CONTINUE:通知服务重新开始
SERVICE_CONTROL_INTERROGATE:通知服务立即报告当前状态
SERVICE_CONTROL_SHUTDOWN:通知服务紧急关闭

下面是一个简单服务程序:

#include <windows.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <dbt.h>
using namespace std;

GUID WceusbshGUID = { 0x25dbce51, 0x6c8f, 0x4a72, 
                                            0x8a,0x6d,0xb5,0x4c,0x2b,0x4f,0xc8,0x35 };
HDEVNOTIFY m_hDevNotify;

char* SERVICE_NAME = "usbdetect";
HANDLE terminateEvent = NULL;
SERVICE_STATUS_HANDLE serviceStatusHandle;

BOOL pauseService = FALSE;
BOOL runningService = FALSE;

HANDLE threadHandle = 0;

int WriteToLog(char* str)
{
     FILE* log;
     log = fopen("c://log.txt", "a+");
     if (log == NULL){
        OutputDebugString("Log file open failed.");
            return -1;
     }
     fprintf(log, "%s/n", str);
     fclose(log);
     return 0;
}

VOID ErrorHandler(char* s,DWORD err) {
  cout<<s<<endl;
  cout<<"Error Number: "<<err<<endl;
  ExitProcess(err);
}

DWORD ServiceThread(LPDWORD param) {
  WriteToLog("The ServiceThread is running.......");
  while(1) {
  }
  return 0;
}

BOOL InitService(){
  DWORD id;
  WriteToLog("InitService");
  threadHandle = CreateThread( 0,0,(LPTHREAD_START_ROUTINE)ServiceThread,
                 0,0,&id);
  if(threadHandle == 0){
    return FALSE;
  }else{
    runningService = TRUE;
    return TRUE;
  }
}

VOID ResumeService(){
  pauseService = FALSE;
  ResumeThread(threadHandle);
  WriteToLog("ResumeService");
}

VOID PauseService(){
  pauseService = TRUE;
  SuspendThread(threadHandle);
  WriteToLog("PauseService");
}

VOID StopService(){
  runningService = FALSE;
  SetEvent(terminateEvent);
  WriteToLog("StopService");
}

BOOL SendStatusToSCM( DWORD dwCurrentStatus,
             DWORD dwWin32ExitCode,
             DWORD dwServiceSpecificExitCode,
             DWORD dwCheckPoint,
             DWORD dwWaitHint )
{
  BOOL success;
  SERVICE_STATUS serviceStatus;

serviceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
  serviceStatus.dwCurrentState = dwCurrentStatus;

if(dwCurrentStatus == SERVICE_START_PENDING)
    serviceStatus.dwControlsAccepted = 0;
  else
    serviceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP |
                         SERVICE_ACCEPT_PAUSE_CONTINUE |
                         SERVICE_ACCEPT_SHUTDOWN;

if(dwServiceSpecificExitCode == 0)
    serviceStatus.dwWin32ExitCode = dwWin32ExitCode;
  else
    serviceStatus.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR;

serviceStatus.dwServiceSpecificExitCode = dwServiceSpecificExitCode;
  serviceStatus.dwCheckPoint = dwCheckPoint;
  serviceStatus.dwWaitHint = dwWaitHint;

success = SetServiceStatus(serviceStatusHandle, &serviceStatus);
  if(!success)
    StopService();

return success;
}

VOID ServiceCtrlHandler(DWORD controlCode) {
  DWORD currentStatus = 0;
  BOOL success;

switch(controlCode) {
    case SERVICE_CONTROL_STOP:
      currentStatus = SERVICE_STOP_PENDING;
      success = SendStatusToSCM( SERVICE_STOP_PENDING,
                        NO_ERROR,
                        0,1,5000 );
      StopService();
      return;
    case SERVICE_CONTROL_PAUSE:
      if(runningService && !pauseService ) {
        success = SendStatusToSCM( SERVICE_PAUSE_PENDING,
                         NO_ERROR,
                         0,1,1000 );
        PauseService();
        currentStatus = SERVICE_PAUSED;
      }
      break;
    case SERVICE_CONTROL_CONTINUE:
      if(runningService && pauseService ) {
        success = SendStatusToSCM( SERVICE_CONTINUE_PENDING,
                         NO_ERROR,
                         0,1,1000 );
        ResumeService();
        currentStatus = SERVICE_RUNNING;
      }
      break;
    case SERVICE_CONTROL_INTERROGATE:
      break;
    case SERVICE_CONTROL_SHUTDOWN:
      return;
    case WM_DEVICECHANGE:
      WriteToLog("Device Change");
      return;
    default:
      break;

}
  SendStatusToSCM(currentStatus,
          NO_ERROR,
          0,0,0 );
}

VOID terminate(DWORD error)
{  
  if(terminateEvent)
    CloseHandle(terminateEvent);

if(serviceStatusHandle)
    SendStatusToSCM( SERVICE_STOPPED,error,
             0,0,0 );
  
  if(threadHandle)
    CloseHandle(threadHandle);
}

VOID ServiceMain(DWORD argc, LPTSTR* argv)
{
  BOOL success;
  DEV_BROADCAST_DEVICEINTERFACE NotificationFilter;
  HDEVNOTIFY hDeviceNotify;

//  注册一个ServiceCtrlHandler
  serviceStatusHandle = RegisterServiceCtrlHandler( SERVICE_NAME,
                             (LPHANDLER_FUNCTION)ServiceCtrlHandler );
  if(!serviceStatusHandle){
    terminate(GetLastError());
    return;
  }

//  注册DeviceNotification
        ZeroMemory( &NotificationFilter, sizeof(NotificationFilter) );
        NotificationFilter.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
        NotificationFilter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
        NotificationFilter.dbcc_classguid = WceusbshGUID;

m_hDevNotify = RegisterDeviceNotification( 
                serviceStatusHandle,                // events recipient
                &NotificationFilter,                // type of device
                DEVICE_NOTIFY_SERVICE_HANDLE | DEVICE_NOTIFY_ALL_INTERFACE_CLASSES);// type of recipient handle

if ( NULL == m_hDevNotify ) 
        {
                ErrorHandler(TEXT("RegisterDeviceNotification"),GetLastError());
                return;
        }

success = SendStatusToSCM( SERVICE_START_PENDING,
                    NO_ERROR,
                    0,1,5000 );
  if(!success){
    terminate(GetLastError());
    return;
  }

terminateEvent = CreateEvent(0,TRUE,FALSE,0);
  if(!success){
    terminate(GetLastError());
    return;
  }

success = SendStatusToSCM( SERVICE_START_PENDING,
                    NO_ERROR,
                    0,2,1000 );
  if(!success){
    terminate(GetLastError());
    return;
  }

success = InitService();
  if(!success){
    terminate(GetLastError());
    return;
  }

success = SendStatusToSCM( SERVICE_RUNNING,
                    NO_ERROR,
                    0,0,0 );
  if(!success){
    terminate(GetLastError());
    return;
  }

WaitForSingleObject(terminateEvent,INFINITE);

terminate(0);
}

VOID main(VOID)
{
  BOOL success;
  SERVICE_TABLE_ENTRY serviceTable[] = {
    {SERVICE_NAME, (LPSERVICE_MAIN_FUNCTION)ServiceMain},
    {NULL, NULL}
  };

success = StartServiceCtrlDispatcher(serviceTable);
  if(!success)
    ErrorHandler("In StartServiceCtrlDispatcher",GetLastError());
}