window服务编程

window下编写服务程序样例。

#pragma once
#include <windows.h>
#include <stdio.h>
#include <iostream>
#include <tchar.h>
#include <comutil.h>

#define SLEEP_TIME 5000
#define LOGFILE "d:\\ITXBaseProviderService.txt"

using namespace std;
char    * ServiceName="ITXBaseProviderService";

enum EnumRunState
{
     None=0,
     Running=1,
     Stoped=2,
     Pause=3,
};

EnumRunState RunState;

int WriteToLog(char* str)
{
    FILE* log;
    log=fopen(LOGFILE,"a+");
    if(log==NULL)  return 0;
    fprintf(log,"%s\n",str);
    fclose(log);
    return 1;
}

//定义变量和方法
SERVICE_STATUS ServiceStatus;
SERVICE_STATUS_HANDLE hStatus;
HANDLE terminateEvent; //事件
HANDLE threadHandle;   //线程

VOID terminate(DWORD error);
void ServiceMain(int argc,char** argv);
void ControlHandler(DWORD request);
int InitService();
//
BOOL RunService(char * sSvcName);
VOID ResumeService();
VOID PauseService();
VOID StopService();
//
BOOL SendStatusToSCM (DWORD dwCurrentState,
   DWORD dwWin32ExitCode, 
   DWORD dwServiceSpecificExitCode,
   DWORD dwCheckPoint,
   DWORD dwWaitHint);
//
void InstallService();
void UninstallService();
//
DWORD WINAPI ServiceThread(LPDWORD param);

//安装入口点
void main(int argc, char* argv[])
{
    SERVICE_TABLE_ENTRY ServiceTable[2];
    //设置服务名称和服务入口函数  
    ServiceTable[0].lpServiceName = ServiceName;
    ServiceTable[0].lpServiceProc = (LPSERVICE_MAIN_FUNCTION)ServiceMain;
    ServiceTable[1].lpServiceName = NULL;
    ServiceTable[1].lpServiceProc = NULL;

    //引数 
    if(argc<=1)
    {
          cout<<"使用方法:"<<endl;
          cout<<"\"install\""; 
          cout<<"or";
          cout<<"\"uninstall\"";
          cout<<"\"exec \""; 
          cout<<" parameter required in the command line"<<endl;      
    } 
    if(argc>1)
    {
          if(_stricmp("install",argv[1])==0)
          {   //install(InstallService)
              InstallService(); 
              cout<<"installService Succed!"<<endl;
          }         
          else if(_stricmp("uninstall",argv[1])==0)
          {   //uninstall(UninstallService) 
              UninstallService(); 
              cout<<"UninstallService Succed!"<<endl;
          }       
          else if(_stricmp("exec",argv[1])==0)
          {   //exec(ServiceMain)
              RunService(ServiceName);         
          } 
          else
          {    //usage(使用方法)表示
               cout<<"使用方法 :"<<endl;
               //"install"
               cout<<"\"install\""; 
               //"or"
               cout<<"or";
               //"uninstall"
               cout<<"\"uninstall\"";
               //"exec"
               cout<<"\"exec \""; 
               //"or"
               cout<<"or";
               cout<<" parameter required in the command line"<<endl;
          }
    }
     //-------------------------------------------------
     //启动服务的控制分派机线程(启动并执行一个新线程)
     StartServiceCtrlDispatcher(ServiceTable);
}


//服务入口点(主线程)
void ServiceMain(int argc,char** argv)
{
    int success;
    //开始服务
    RunService(ServiceName);

    //注册服务控制处理函数
   hStatus = RegisterServiceCtrlHandler(ServiceName,(LPHANDLER_FUNCTION)ControlHandler);   
   if(!hStatus)
   {    
       WriteToLog("ServiceMain函数中注册服务控制处理函数失败!\n");
       return;
   }
    //向SCM报告工作状态
    RunState=EnumRunState::Running;
    ServiceStatus.dwCurrentState=SERVICE_RUNNING;
    ServiceStatus.dwServiceType=SERVICE_WIN32;
    ServiceStatus.dwControlsAccepted = 
            SERVICE_ACCEPT_STOP |
            SERVICE_ACCEPT_PAUSE_CONTINUE |
            SERVICE_ACCEPT_SHUTDOWN;
    /*SetServiceStatus(hStatus,&ServiceStatus);*/
    
   ////启动工作循环(这个模块在另外一个线程中执行)
   //while(RunState==EnumRunState::Running)
   //{
      //  WriteToLog("ServiceMain函数写日志\n");
   //     Sleep(500);
   //}
   //创建一个终结事件
   terminateEvent = CreateEvent (0,TRUE,FALSE,0);
   if (!terminateEvent)
   {
       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);
   WriteToLog("ServiceMain函数执行完毕!");
}

//服务控制台命令处理函数
void ControlHandler(DWORD request)
{
   DWORD  currentState = 0;
   BOOL success; 
   WriteToLog("ControlHandler:"+request);
   switch(request)
   { 
       case SERVICE_CONTROL_STOP:
            RunState=EnumRunState::Stoped;
            currentState = SERVICE_STOP_PENDING;
            ServiceStatus.dwCurrentState=currentState;
            SetServiceStatus(hStatus,&ServiceStatus);           
            StopService();
            return;
       case SERVICE_CONTROL_PAUSE:  
             RunState=EnumRunState::Pause;
             currentState = SERVICE_PAUSED;
             ServiceStatus.dwCurrentState=currentState;
             SetServiceStatus(hStatus,&ServiceStatus);
             PauseService();
            break;
       case SERVICE_CONTROL_CONTINUE:   
           RunState=EnumRunState::Running;
             currentState = SERVICE_RUNNING;
             ServiceStatus.dwCurrentState=currentState;
             SetServiceStatus(hStatus,&ServiceStatus);
             ResumeService();
            break;
       case SERVICE_CONTROL_INTERROGATE:
            // it will fall to bottom and send status
            break;
        
        // Do nothing in a shutdown. Could do cleanup
        // here but it must be very quick.
       case SERVICE_CONTROL_SHUTDOWN:
            // Do nothing on shutdown          
            return;
       default:
            break;
   }   
   //ServiceStatus.dwCurrentState=currentState;
   //SetServiceStatus(hStatus,&ServiceStatus);
}

//初始化服务(开始服务时执行)
int InitService()
{
   int result;
   //写日志信息
   result=WriteToLog("Monitoring started."); 
   //开始一个线程 Start the service's thread
   DWORD id;   
   threadHandle = CreateThread(0, 0,(LPTHREAD_START_ROUTINE)ServiceThread,0, 0, &id);   
   if (threadHandle==0)
   {
       result=0;
   }
   else
   {        
       result=1;
   }
   //
   WriteToLog("InitService一个线程开始了!");
   return result;
}

DWORD WINAPI ServiceThread(LPDWORD param)
{ 
   //线程操作
    while(RunState==EnumRunState::Running)
    {
        WriteToLog("线程中写日志\n");
        Sleep(500);
    }
   WriteToLog("线程操作ServiceThread完成!");
   return 0;
}

//
BOOL RunService(char * sSvcName)
{   
   SC_HANDLE schSCManager;
   SC_HANDLE scHandle;
   BOOL boolRet;

   // open to SCM   
   schSCManager = OpenSCManager(
        0,  
        0,  
        SC_MANAGER_ALL_ACCESS 
    );

   //Open
   scHandle = OpenService(
        schSCManager,              
        sSvcName, 
        SERVICE_ALL_ACCESS  
        );
   
   //start 
   boolRet = StartService(
        scHandle,          
        0,        
        NULL); 
   
   return boolRet;
}


VOID ResumeService()
{
   //pauseService=FALSE;
   //ResumeThread(threadHandle);
   return;
}
VOID PauseService()
{
   //pauseService = TRUE;
   //SuspendThread(threadHandle);
   return;
}
VOID StopService() 
{
    RunState=EnumRunState::Stoped;//=FALSE;
   // Set the event that is holding ServiceMain
   // so that ServiceMain can return
   SetEvent(terminateEvent);
}
//安装/反安装函数
void InstallService()
{ 
     SC_HANDLE schService; 
     SC_HANDLE schSCManager; 
     char szPath[512];
     string userName = "NT AUTHORITY\\NetworkService";
     
     //Install Starting... 
     //获取模块文件路径名称
     if(!GetModuleFileName(NULL,szPath,512)) 
     {  
         return;  
     }
     
     // open to SCM　
     schSCManager = OpenSCManager( 
                                0,  // pointer to machine name string
                                0,  // pointer to database name string
                                SC_MANAGER_CREATE_SERVICE // type of access
                                );
     if (!schSCManager)
     {
         WriteToLog("OpenScManagerErrorID:" + GetLastError());  
         return;
     }
     // Install 新服务
     schService = CreateService(
            schSCManager, // handle to service control manager database
            ServiceName, // pointer to name of service to start
            ServiceName, // pointer to display name     
            SERVICE_ALL_ACCESS,// type of access to service
            SERVICE_WIN32_OWN_PROCESS,// type of service
            SERVICE_DEMAND_START,// when to start service
            SERVICE_ERROR_NORMAL,// severity if service fails to start
            szPath,       // pointer to name of binary file
            NULL,         // pointer to name of load ordering group
            NULL,         // pointer to variable to get tag identifier
            NULL,         // pointer to array of dependency names
            userName.c_str(),         // pointer to account name of service
            NULL          // pointer to password for service account
            );

     if (!schService)
     {  
         WriteToLog("CreateServiceErrorID:"+GetLastError()); 
          return;
     }
     else
     {
         WriteToLog("Service installed\n"); 
     }   

     CloseServiceHandle(schService);
     CloseServiceHandle(schSCManager);   
     WriteToLog("Install Ending...\n"); 
}

void UninstallService()
{ 
     SC_HANDLE schService;
     SC_HANDLE schSCManager; 
     BOOL success;
     SERVICE_STATUS svcStatus;
     
     WriteToLog("Uninstall Starting...");
     
     // open to SCM　
     schSCManager = OpenSCManager(
            0,// pointer to machine name string 
            0,// pointer to database name string
            SC_MANAGER_CREATE_SERVICE // type of access
            );
     if (!schSCManager)
     {
         WriteToLog("OpenScManagerErrorID:"+GetLastError());
         return;
     }
     
     //打开一个服务
     schService = OpenService(
                  schSCManager,              // handle to service control manager database
                  ServiceName,              // pointer to name of service to start
                  SERVICE_ALL_ACCESS | DELETE// type of access to service
                  );
     if (!schService)
     {
          WriteToLog("OpenServiceErrorID:"+GetLastError());
          return;
     }
     //(if necessary)
     success = QueryServiceStatus(schService, &svcStatus);
     if (!success)
     {
         WriteToLog("In QueryServiceStatus ErrorID:"+GetLastError());
          return;
     }
     if (svcStatus.dwCurrentState != SERVICE_STOPPED)
     {
           WriteToLog("Stopping service...");
           success = ControlService(
               schService,           // handle to service
               SERVICE_CONTROL_STOP, // control code
               &svcStatus            // pointer to service status structure
           );
           if (!success)
           {
               WriteToLog("In ControlServiceErrorID:"+GetLastError());
               return;
           }
     }

     //等待
     do
     {
          QueryServiceStatus(schService,&svcStatus);      
          Sleep(500);    
      
     }while(SERVICE_STOP_PENDING==svcStatus.dwCurrentState);        
     
     if(SERVICE_STOPPED!=svcStatus.dwCurrentState)
     {
         WriteToLog("Failed to Stop Service ErrorID:"+GetLastError());  
         return;
     }
     
     //删除服务 
     success = DeleteService(schService);
     if (success)
     {
         WriteToLog("Service removed\n");
     }
     else
     {
         WriteToLog("In DeleteService ErrorID:"+GetLastError());
         return;
     }   
     //Clean up
     CloseServiceHandle(schService);
     CloseServiceHandle(schSCManager);   
     WriteToLog("Uninstal Ending...");
}

//
BOOL SendStatusToSCM (DWORD dwCurrentState,
   DWORD dwWin32ExitCode, 
   DWORD dwServiceSpecificExitCode,
   DWORD dwCheckPoint,
   DWORD dwWaitHint)
  {
       BOOL success;
       SERVICE_STATUS serviceStatus;
       
       // Fill in all of the SERVICE_STATUS fields
       serviceStatus.dwServiceType =SERVICE_WIN32_OWN_PROCESS;
       serviceStatus.dwCurrentState = dwCurrentState;
       
       // If in the process of something, then accept
       // no control events, else accept anything
       if (dwCurrentState == SERVICE_START_PENDING)
            serviceStatus.dwControlsAccepted = 0;
       else
            serviceStatus.dwControlsAccepted = 
            SERVICE_ACCEPT_STOP |
            SERVICE_ACCEPT_PAUSE_CONTINUE |
            SERVICE_ACCEPT_SHUTDOWN;
       
       // if a specific exit code is defines, set up
       // the win32 exit code properly
       if (dwServiceSpecificExitCode == 0)
            serviceStatus.dwWin32ExitCode =dwWin32ExitCode;
       else
            serviceStatus.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR;
       serviceStatus.dwServiceSpecificExitCode =dwServiceSpecificExitCode;
       
       serviceStatus.dwCheckPoint = dwCheckPoint;
       serviceStatus.dwWaitHint = dwWaitHint;
       
       // Pass the status record to the SCM
       //SERVICE_STATUS_HANDLE serviceStatusHandle;
       success = SetServiceStatus (hStatus,&serviceStatus);
       if (!success)
       {
          StopService();     
       }
       return success;
  }
//
VOID terminate(DWORD error)
{
   // if terminateEvent has been created, close it.
   if (terminateEvent)
    CloseHandle(terminateEvent);
   
   // Send a message to the scm to tell about
   // stop age
   if (hStatus)
    SendStatusToSCM(SERVICE_STOPPED, error,
    0, 0, 0);
   
   // If the thread has started kill it off
   if (threadHandle)
    CloseHandle(threadHandle);
   
   // Do not need to close serviceStatusHandle
}