• News
• Services
• Online services
• Applications
• Portfolio
• Forum
• Enter

Writing Tools for Windows in C++

This article is designed for people who have knowledge of programming pochatkvi

Services in Windows programs running in background, regardless of the user and usually does not interact with the user. Almost any console application can be running as a service. You need only to register it as a service. How it works (if I'm wrong please correct me somewhere), so the program starts up and begins to perform his job after work finished - service shutdown, also service must respond to signals operating system. Most services are constantly doing "hanging" in memory and periodically perform some work (eg every 5 minutes. Archive logs). In response to signals (such as stop, pause ...) the program must register the callback function. This is the main problem of the OOP for writing services as a regular class method can not register a callback function for the response to the alarm system. However, you can register the static method of class. This work established class cWinService now all the power of OOP can be used in your programming services. You have to follow your class to class and override cWinService several functions srvInit (), srvProcess (), srvStop () and your service ready to go.

For example, we will service ProcessKiller which hangs in memory and kills some process if given a start up (not all processes can be killed with user rights, as well as the service runs on as a system, it can almost all)

All source you can download with this link

process_killer.cpp

#include "stdafx.h"

#include <cProcessKiller.h>



// головна функція сервіса

int _tmain(int argc, _TCHAR* argv[])

{

  // create item of class was 

  // cProcessKiller inherited from cWinService

	cProcessKiller *killer = new cProcessKiller;

  // set global variable Service Instance

	cProcessKiller::setServiceInstance(killer);

  // run main service process

	cProcessKiller::ServiceProcess(argc, argv);

	return 0;

}

What's under the hood (comments in code)

cProcessKiller.h

#ifndef cProcessKiller_H

#define cProcessKiller_H



#include "cWinService.h"

// specific headers and constants

#include 

#include 



#define TA_FAILED 0

#define TA_SUCCESS_CLEAN 1

#define TA_SUCCESS_KILL 2

#define TA_SUCCESS_16 3



// full path to log folder

#define ZK_PATH_TO_LOG "d:\tmp\logs\";

// system service name 

#define ZK_SERVICE_NAME L"ZombieKiller";

// display service name (Win + R -> services.msc)

#define ZK_SERVICE_DISPLAY_NAME L"Zombie killer";



// inherit out class from cWinService

class cProcessKiller: public cWinService {

public:

	cProcessKiller();

	~cProcessKiller();



protected:

  // override virtual function of parent

	bool srvInit();

	bool srvProcess();

	bool srvStop();



	const char* getPathToLog();

	const LPWSTR getServiceNameL();

	const LPWSTR getServiceDNameL();

  

private:

// methods specific for task

	bool stopService();

	BOOL WaitForServiceToReachState(SC_HANDLE hService, DWORD dwDesiredState, SERVICE_STATUS* pss, DWORD dwMilliseconds);

	DWORD FindProcessId(const std::wstring& processName);

	DWORD WINAPI TerminateApp( DWORD dwPID, DWORD dwTimeout );

	static BOOL CALLBACK TerminateAppEnum(HWND hwnd, LPARAM lParam);

};

#endif

cProcessKiller.cpp

#include "stdafx.h"

#include "cProcessKiller.h"



cProcessKiller::cProcessKiller() {

	char* FullPath = getFullLogPath();

	

	Logger.setFileName(FullPath);

	Logger.setLogLevel(llDebug);

	Logger.setCode("cProcessKiller");



	delete FullPath;	

}



cProcessKiller::~cProcessKiller() {



}



// this methods is answer on virtual static function restriction

// if you know better way please give me

const LPWSTR cProcessKiller::getServiceNameL() {

	return ZK_SERVICE_NAME;

}



const LPWSTR cProcessKiller::getServiceDNameL() {

	return ZK_SERVICE_DISPLAY_NAME;

}



const char* cProcessKiller::getPathToLog() {

	return ZK_PATH_TO_LOG;

}



// in this service we no need any inticialization

// so we just return success

bool cProcessKiller::srvInit() {

	return true;

}



// "working horse" of you service

bool cProcessKiller::srvProcess() {

	return stopService();

}



// response on Windows stop request

// in this service we no need any work for stoping

// so just return success

bool cProcessKiller::srvStop() {

	return true;

}





// specific functions

bool cProcessKiller::stopService() {

	//Author: Janne Colliander

	

	bool res = true;



	DWORD dwResult = 0;



	SC_HANDLE hSCM = NULL; 

	SC_HANDLE hService = NULL;



	hSCM = ::OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS);

	try {

		do {

			if (hSCM == NULL) {

				dwResult = GetLastError();

				Logger.writeLogHead(llError) << "OpenSCManager fail " << (int)dwResult << EndOfLine;

				break;

			}



			// Open the service 

			hService = ::OpenService(hSCM, L"Device Lock", SC_MANAGER_ALL_ACCESS/*SERVICE_STOP | SERVICE_QUERY_STATUS */);

		

			if (hService == NULL) {

				dwResult = GetLastError(); 

				Logger.writeLogHead(llError) << "OpenService fail " << (int)dwResult << EndOfLine;

				break;

			}



			//Ask the service to stop 



			SERVICE_STATUS ss;



			if(!::ControlService(hService, SERVICE_CONTROL_STOP, &ss )) {

				dwResult = GetLastError(); 



				if (dwResult != ERROR_SERVICE_NOT_ACTIVE) {

					Logger.writeLogHead(llError) << "ControlService fail " << (int)dwResult << EndOfLine;

					//break;

				}

			}





			// Wait until it stopped (or timeout expired)



			if(WaitForServiceToReachState(hService, SERVICE_STOPPED, &ss, INFINITE)) {

				Logger.writeLogHead(llError) << "WaitForServiceToReachState finish successful " << EndOfLine;

				break;

			} else {

				dwResult = GetLastError();

				Logger.writeLogHead(llError) << "WaitForServiceToReachState fail " << (int)dwResult << EndOfLine;

			}//*/



			if (DeleteService(hService)) {

				Logger.writeLogHead(llError) << "DeleteService finish successful " << EndOfLine;

				//break;

			} else {

				Logger.writeLogHead(llError) << "DeleteService fail " << (int)GetLastError() << EndOfLine;

				//break;

			}



			DWORD ProcessID = FindProcessId(L"DLService_x64.exe");

			if (ProcessID) {

				DWORD KillRes = TerminateApp(ProcessID, 3000);

				if ((KillRes == TA_SUCCESS_KILL) || (KillRes == TA_SUCCESS_CLEAN)) {

					Logger.writeLogHead(llError) << "Kill DLService_x64.exe process )" << EndOfLine;

					break;

				} else {

					Logger.writeLogHead(llError) << "Can't kill DLService_x64.exe process (" << EndOfLine;

					break;

				}

			} else {

				Logger.writeLogHead(llError) << "Can't foudn DLService_x64.exe process" << EndOfLine;

				break;

			}

		} 

		while(0);

	} catch(char* err) {

		res = false;

		Logger.writeLogHead(llError) << "stopService fail " << err << EndOfLine;

	}



	// Cleanup 



	if (hService != NULL) {

		::CloseServiceHandle(hService);

	}



	if (hSCM != NULL) {

		::CloseServiceHandle(hSCM);

	}



	// Return 

	return res;

}



BOOL cProcessKiller::WaitForServiceToReachState(SC_HANDLE hService, DWORD dwDesiredState,

                                 SERVICE_STATUS* pss, DWORD dwMilliseconds) {

	// http://www.microsoft.com/msj/0298/service.aspx

	// http://www.microsoft.com/msj/0298/servicetextfigs.htm#fig7

 

    DWORD dwLastState, dwLastCheckPoint;

    BOOL  fFirstTime = TRUE; // Don't compare state & checkpoint the first time through

    BOOL  fServiceOk = TRUE;

    DWORD dwTimeout = GetTickCount() + dwMilliseconds;

 

    // Loop until the service reaches the desired state,

    // an error occurs, or we timeout

    while  (TRUE) {

       // Get current state of service

       fServiceOk = ::QueryServiceStatus(hService, pss);

 

       // If we can't query the service, we're done

       if (!fServiceOk) break;

 

       // If the service reaches the desired state, we're done

       if (pss->dwCurrentState == dwDesiredState) break;

 

       // If we timed-out, we're done

       if ((dwMilliseconds != INFINITE) && (dwTimeout > GetTickCount())) {

          SetLastError(ERROR_TIMEOUT); 

          break;

       }

 

       // If this is our first time, save the service's state & checkpoint

       if (fFirstTime) {

          dwLastState = pss->dwCurrentState;

          dwLastCheckPoint = pss->dwCheckPoint;

          fFirstTime = FALSE;

       } else {

          // If not first time & state has changed, save state & checkpoint

          if (dwLastState != pss->dwCurrentState) {

             dwLastState = pss->dwCurrentState;

             dwLastCheckPoint = pss->dwCheckPoint;

          } else {

             // State hasn't change, check that checkpoint is increasing

             if (pss->dwCheckPoint > dwLastCheckPoint) {

                // Checkpoint has increased, save checkpoint

                dwLastCheckPoint = pss->dwCheckPoint;

             } else {

                // Checkpoint hasn't increased, service failed, we're done!

                fServiceOk = FALSE; 

                break;

             }

          }

       }

       // We're not done, wait the specified period of time

       Sleep(pss->dwWaitHint);

    }

 

    // Note: The last SERVICE_STATUS is returned to the caller so

    // that the caller can check the service state and error codes.

    return(fServiceOk);

 }



DWORD cProcessKiller::FindProcessId(const std::wstring& processName)

{

	PROCESSENTRY32 processInfo;

	processInfo.dwSize = sizeof(processInfo);



	HANDLE processesSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);

	if ( processesSnapshot == INVALID_HANDLE_VALUE )

		return 0;



	Process32First(processesSnapshot, &processInfo);

	if ( !processName.compare(processInfo.szExeFile) )

	{

		CloseHandle(processesSnapshot);

		return processInfo.th32ProcessID;

	}



	while ( Process32Next(processesSnapshot, &processInfo) )

	{

		if ( !processName.compare(processInfo.szExeFile) )

		{

			CloseHandle(processesSnapshot);

			return processInfo.th32ProcessID;

		}

	}

	

	CloseHandle(processesSnapshot);

	return 0;

}



DWORD WINAPI cProcessKiller::TerminateApp( DWORD dwPID, DWORD dwTimeout )

   {

      HANDLE   hProc ;

      DWORD   dwRet ;



      // If we can't open the process with PROCESS_TERMINATE rights,

      // then we give up immediately.

      hProc = OpenProcess(SYNCHRONIZE|PROCESS_TERMINATE, FALSE, dwPID);



      if(hProc == NULL)

      {

         return TA_FAILED ;

      }



      // TerminateAppEnum() posts WM_CLOSE to all windows whose PID

      // matches your process's.

      EnumWindows((WNDENUMPROC)cProcessKiller::TerminateAppEnum, (LPARAM) dwPID) ;



      // Wait on the handle. If it signals, great. If it times out,

      // then you kill it.

      if(WaitForSingleObject(hProc, dwTimeout)!=WAIT_OBJECT_0)

         dwRet=(TerminateProcess(hProc,0)?TA_SUCCESS_KILL:TA_FAILED);

      else

         dwRet = TA_SUCCESS_CLEAN ;



      CloseHandle(hProc) ;



      return dwRet ;

   }



BOOL CALLBACK cProcessKiller::TerminateAppEnum( HWND hwnd, 

        LPARAM lParam )

    {

        DWORD dwID ;



        GetWindowThreadProcessId(hwnd, &dwID) ;



        if(dwID == (DWORD)lParam)

        {

            PostMessage(hwnd, WM_CLOSE, 0, 0) ;

        }



        return TRUE ;

    }

cWinService.h

#ifndef cWinService_H

#define cWinService_H



#include <cLog.h>

#include <windows.h>

#include <tchar.h>

#include <strsafe.h>



#define SERVICE_INSTANCE_EXP_1 "ServiceInstance not incialized"



#define WS_PATH_TO_LOG "";

#define WS_SERVICE_NAME L"ServiceInstance";

#define WS_SERVICE_DISPLAY_NAME L"Service instance";





class cWinService {

public:

	static void setServiceInstance(cWinService* Instance);

	static void ServiceProcess(int argc, TCHAR *argv[]);



protected:

	cWinService();

	~cWinService();



	virtual const char* getPathToLog();

	virtual const LPWSTR getServiceNameL();

	virtual const LPWSTR getServiceDNameL();

	SERVICE_STATUS  getStatus(); 



	// child class must override this methods

	virtual bool srvInit();

	virtual bool srvProcess();

	//bool srvStart();

	virtual bool srvStop();

	virtual bool srvPause();

	virtual bool srvContinue();



	//static cWinService* getServiceInstance();

	//static void freeServiceInstance();

	void InstallService();

	static void MainProcess();



	int ACCEPTED_CONTROL;

	int SLEEP_TIME;



	cLog Logger;

	char* getFullLogPath();



	LPWSTR ServiceName;

	LPWSTR ServiceDisplayName;



	static cWinService* ServiceInstance;

private:

	static VOID SvcReportEvent(LPTSTR szFunction, int EventID);

	static VOID WINAPI SvcCtrlHandler(DWORD dwCtrl);

	VOID ReportSvcStatus(DWORD dwCurrentState, DWORD dwWin32ExitCode, DWORD dwWaitHint);



	SERVICE_STATUS          gSvcStatus; 

	SERVICE_STATUS_HANDLE   gSvcStatusHandle;	

};

#endif

cWinService.cpp

#include "stdafx.h"

#include "cWinService.h"





cWinService::cWinService() {

	ServiceName = WS_SERVICE_NAME;

	ServiceDisplayName = WS_SERVICE_DISPLAY_NAME;



	ACCEPTED_CONTROL = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;

	SLEEP_TIME = 5000;



	char* FullPath = getFullLogPath();

	

	Logger.setFileName(FullPath);

	Logger.setLogLevel(llDebug);

	Logger.setCode("cWinService");



	delete FullPath;

}



cWinService::~cWinService() {

	

}



char* cWinService::getFullLogPath() {

	char buffer[250];

	int Ln = 250 + 4;

	char* FullPath = new char[Ln];

	strcpy_s(FullPath, Ln, getPathToLog());



	char* psz = new char [wcslen(getServiceNameL()) + 1];

	wsprintfA(psz, "%S", getServiceNameL());

	concat(FullPath, Ln, psz);

	delete psz;



	time_t rawtime;

	struct tm * timeinfo;

	time(&rawtime);

	timeinfo = localtime(&rawtime);

	strftime(buffer, 30, "_%Y%m%d.log", timeinfo);

	

	concat(FullPath, Ln, buffer);



	return FullPath;

}



const char* cWinService::getPathToLog() {

	return WS_PATH_TO_LOG;

}



const LPWSTR cWinService::getServiceNameL() {

	return WS_SERVICE_NAME;

}



const LPWSTR cWinService::getServiceDNameL() {

	return WS_SERVICE_DISPLAY_NAME;

}



SERVICE_STATUS cWinService::getStatus() {

	Logger.writeLogHead(llDebug) << "invoke cWinService::getStatus " << (int)gSvcStatus.dwCurrentState << EndOfLine;

	return gSvcStatus;

}



bool cWinService::srvInit() {

	Logger.writeLogHead(llDebug) << "invoke cWinService::srvInit" << EndOfLine;

	return true;

}



bool cWinService::srvProcess() {

	Logger.writeLogHead(llDebug) << "invoke cWinService::srvProcess" << EndOfLine;

	return true;

}



/*bool cWinService::srvStart() {

	Logger.writeLogHead(llDebug) << "invoke cWinService::srvStart" << EndOfLine;

	return false;

}*/



bool cWinService::srvStop() {

	Logger.writeLogHead(llDebug) << "invoke cWinService::srvStop" << EndOfLine;

	return true;

}



bool cWinService::srvPause() {

	Logger.writeLogHead(llDebug) << "invoke cWinService::srvPause" << EndOfLine;

	return true;

}



bool cWinService::srvContinue() {

	Logger.writeLogHead(llDebug) << "invoke cWinService::srvContinue" << EndOfLine;

	return true;

}



//

// Purpose: 

//   Logs messages to the event log

//

// Parameters:

//   szFunction - name of function that failed

// 

// Return value:

//   None

//

// Remarks:

//   The service must have an entry in the Application event log.

//

VOID cWinService::SvcReportEvent(LPTSTR szFunction, int EventID) { 

	int LastErr = GetLastError();



	if (!ServiceInstance) {

		throw SERVICE_INSTANCE_EXP_1;

	}



	HANDLE hEventSource;

    LPCTSTR lpszStrings[2];

    TCHAR Buffer[80];



	hEventSource = RegisterEventSource(NULL, ServiceInstance->getServiceNameL());



    if( NULL != hEventSource ) {

        StringCchPrintf(Buffer, 80, TEXT("%s failed with %d"), szFunction, LastErr);



        lpszStrings[0] = ServiceInstance->getServiceNameL();

        lpszStrings[1] = Buffer;



        ReportEvent(hEventSource,        // event log handle

                    EVENTLOG_ERROR_TYPE, // event type

                    0,                   // event category

                    EventID,			       // event identifier

                    NULL,                // no security identifier

                    2,                   // size of lpszStrings array

                    0,                   // no binary data

                    lpszStrings,         // array of strings

                    NULL);               // no binary data



        DeregisterEventSource(hEventSource);

    }

}



//

// Purpose: 

//   Sets the current service status and reports it to the SCM.

//

// Parameters:

//   dwCurrentState - The current state (see SERVICE_STATUS)

//   dwWin32ExitCode - The system error code

//   dwWaitHint - Estimated time for pending operation, 

//     in milliseconds

// 

// Return value:

//   None

//

VOID cWinService::ReportSvcStatus(DWORD dwCurrentState, DWORD dwWin32ExitCode, DWORD dwWaitHint) {

	Logger.writeLogHead(llDebug) << "invoke cWinService::ReportSvcStatus " << EndOfLine;



    static DWORD dwCheckPoint = 1;



    // Fill in the SERVICE_STATUS structure.



    gSvcStatus.dwCurrentState = dwCurrentState;

    gSvcStatus.dwWin32ExitCode = dwWin32ExitCode;

    gSvcStatus.dwWaitHint = dwWaitHint;



    if (dwCurrentState == SERVICE_START_PENDING) {

        gSvcStatus.dwControlsAccepted = 0;

	} else {

		gSvcStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;

	}



    if ((dwCurrentState == SERVICE_RUNNING) || (dwCurrentState == SERVICE_STOPPED)) {

        gSvcStatus.dwCheckPoint = 0;

	} else { 

		gSvcStatus.dwCheckPoint = dwCheckPoint++;

	}



    // Report the status of the service to the SCM.

    SetServiceStatus(gSvcStatusHandle, &gSvcStatus);

}





//

// Purpose: 

//   Called by SCM whenever a control code is sent to the service

//   using the ControlService function.

//

// Parameters:

//   dwCtrl - control code

// 

// Return value:

//   None

//

VOID WINAPI cWinService::SvcCtrlHandler(DWORD dwCtrl) {

	// Handle the requested control code. 

	if (!ServiceInstance) {

		throw SERVICE_INSTANCE_EXP_1;

	}

	ServiceInstance->Logger.writeLogHead(llDebug) << "cWinService::SvcCtrlHandler " << (int)dwCtrl << EndOfLine;



	// TODO add all cases

	switch(dwCtrl) {

		case SERVICE_CONTROL_STOP: 

			// Signal that service try stop

			ServiceInstance->ReportSvcStatus(SERVICE_STOP_PENDING, NO_ERROR, 0);

			

			// Signal the service to stop.

			if (ServiceInstance->srvStop()) {

				ServiceInstance->gSvcStatus.dwWin32ExitCode = 0; 

				ServiceInstance->gSvcStatus.dwCurrentState = SERVICE_STOPPED; 

			} else {

				ServiceInstance->gSvcStatus.dwCurrentState = SERVICE_RUNNING;

			}

			break;



		case SERVICE_CONTROL_PAUSE: 

			// Signal that service try pause

			ServiceInstance->ReportSvcStatus(SERVICE_PAUSE_PENDING, NO_ERROR, 0);

			

			// Signal the service to pause.

			if (ServiceInstance->srvPause()) {

				ServiceInstance->gSvcStatus.dwWin32ExitCode = 0; 

				ServiceInstance->gSvcStatus.dwCurrentState = SERVICE_PAUSED;

			} else {

				ServiceInstance->gSvcStatus.dwCurrentState = SERVICE_RUNNING;

			}

			break;

 

		case SERVICE_CONTROL_CONTINUE: 

			// Signal that service try pause

			ServiceInstance->ReportSvcStatus(SERVICE_CONTINUE_PENDING, NO_ERROR, 0);

			

			// Signal the service to pause.

			if (ServiceInstance->srvContinue()) {

				ServiceInstance->gSvcStatus.dwWin32ExitCode = 0; 

				ServiceInstance->gSvcStatus.dwCurrentState = SERVICE_RUNNING;

			} else {

				ServiceInstance->gSvcStatus.dwCurrentState = SERVICE_PAUSED;

			}

			break;



		case SERVICE_CONTROL_INTERROGATE: 

			break; 

		default: 

			break;

	}

	ServiceInstance->ReportSvcStatus(ServiceInstance->gSvcStatus.dwCurrentState, NO_ERROR, 0);

}





//

// Purpose: 

//   Installs a service in the SCM database

//

// Parameters:

//   None

// 

// Return value:

//   None

//

void cWinService::InstallService() {

	SC_HANDLE schSCManager;

    SC_HANDLE schService;

    TCHAR szPath[MAX_PATH];



    if(!GetModuleFileName(NULL, szPath, MAX_PATH)) {

        printf("Cannot install service (%d)n", GetLastError());

        return;

    }



    // Get a handle to the SCM database. 

 

    schSCManager = OpenSCManager( 

        NULL,                    // local computer

        NULL,                    // ServicesActive database 

        SC_MANAGER_ALL_ACCESS);  // full access rights 

 

    if (NULL == schSCManager)  {

		int LastError = GetLastError();

        printf("OpenSCManager failed (%d)n", LastError);

		if (LastError == 5) {

			printf("please, try run with admin rightsn");

		}

        return;

    }



    // Create the service



    schService = CreateService( 

        schSCManager,			         // SCM database 

        getServiceNameL(),  // name of service 

        getServiceDNameL(), // service name to display 

        SERVICE_ALL_ACCESS,              // desired access 

        SERVICE_WIN32_OWN_PROCESS,       // service type 

        SERVICE_DEMAND_START,            // start type 

        SERVICE_ERROR_NORMAL,            // error control type 

        szPath,                          // path to service's binary 

        NULL,                            // no load ordering group 

        NULL,                            // no tag identifier 

        NULL,                            // no dependencies 

        NULL,                            // LocalSystem account 

        NULL);                           // no password 

 

    if (schService == NULL) {

        printf("CreateService failed (%d)n", GetLastError());

        CloseServiceHandle(schSCManager);

        return;

    } else {

      printf("Service installed successfullyn");

    }



    CloseServiceHandle(schService); 

    CloseServiceHandle(schSCManager);

}



/*cWinService* cWinService::getServiceInstance() {

	if (!ServiceInstance) {

		ServiceInstance = new cWinService;

	}

	return ServiceInstance;

}



void cWinService::freeServiceInstance() {

	if (ServiceInstance) {

		delete ServiceInstance;

		ServiceInstance = 0;

	}

}*/



void cWinService::setServiceInstance(cWinService* Instance) {

	if (Instance) {

		ServiceInstance = Instance;

	} else {

		ServiceInstance = 0;

	}

}



void cWinService::ServiceProcess(int argc, TCHAR *argv[]) {

    // If command-line parameter is "install", install the service. 

    // Otherwise, the service is probably being started by the SCM.



	if (!ServiceInstance) {

		throw SERVICE_INSTANCE_EXP_1;

	}



    if(lstrcmpi(argv[1], TEXT("install")) == 0) {

        ServiceInstance->InstallService();

        return;

    }



    // TO_DO: Add any additional services for the process to this table.

    SERVICE_TABLE_ENTRY DispatchTable[] = 

    { 

		{ ServiceInstance->getServiceNameL(), (LPSERVICE_MAIN_FUNCTION)cWinService::MainProcess}, 

        { NULL, NULL } 

    }; 

 

    // This call returns when the service has stopped. 

    // The process should simply terminate when the call returns.

    if (!StartServiceCtrlDispatcher(DispatchTable)) {

        cWinService::SvcReportEvent(TEXT("StartServiceCtrlDispatcher"), 1);

    }

}



void cWinService::MainProcess() {

	if (!ServiceInstance) {

		throw SERVICE_INSTANCE_EXP_1;

	}



	ServiceInstance->Logger.writeLogHead(llError) << "cWinService::MainProcess started" << EndOfLine;



	ServiceInstance->gSvcStatus.dwServiceType        = SERVICE_WIN32; 

  ServiceInstance->gSvcStatus.dwCurrentState       = SERVICE_START_PENDING; 

  ServiceInstance->gSvcStatus.dwControlsAccepted   = ServiceInstance->ACCEPTED_CONTROL;

  ServiceInstance->gSvcStatus.dwWin32ExitCode      = 0; 

  ServiceInstance->gSvcStatus.dwServiceSpecificExitCode = 0; 

  ServiceInstance->gSvcStatus.dwCheckPoint         = 0; 

  ServiceInstance->gSvcStatus.dwWaitHint           = 0; 

 



	ServiceInstance->gSvcStatusHandle = RegisterServiceCtrlHandler(ServiceInstance->getServiceNameL(), (LPHANDLER_FUNCTION)cWinService::SvcCtrlHandler); 

    if (!ServiceInstance->gSvcStatusHandle) { 

		ServiceInstance->Logger.writeLogHead(llError) << "Registering Control Handler failed" << EndOfLine;

        return;

    }



    // Initialize Service 

    if (!ServiceInstance->srvInit()) {

		ServiceInstance->Logger.writeLogHead(llError) << "Initialization failed" << EndOfLine;

		ServiceInstance->gSvcStatus.dwCurrentState       = SERVICE_STOPPED; 

        ServiceInstance->gSvcStatus.dwWin32ExitCode      = -1; 

        SetServiceStatus(ServiceInstance->gSvcStatusHandle, &(ServiceInstance->gSvcStatus));

        return; 

    } 

    // We report the running status to SCM. 

    ServiceInstance->gSvcStatus.dwCurrentState = SERVICE_RUNNING; 

    SetServiceStatus (ServiceInstance->gSvcStatusHandle, &(ServiceInstance->gSvcStatus));

 

    // The worker loop of a service

    while (ServiceInstance->gSvcStatus.dwCurrentState == SERVICE_RUNNING)

	{

		if (!ServiceInstance->srvProcess()) {

			ServiceInstance->gSvcStatus.dwCurrentState       = SERVICE_STOPPED; 

			ServiceInstance->gSvcStatus.dwWin32ExitCode      = -1; 

			SetServiceStatus(ServiceInstance->gSvcStatusHandle, &(ServiceInstance->gSvcStatus));

			return;

		}



		Sleep(ServiceInstance->SLEEP_TIME);

	}

}



cWinService* cWinService::ServiceInstance = 0;

Last comment

Name* E-mail

Code*