C++ CNTService类代码示例

int main(int argc, char* argv[])
{
   int iCode = 1;
   BOOL bRun = FALSE;
   CNTService ntService (SHTTPD_SERVICE_NAME);

   if (ntService.IsInstalled()) {
       // uninstall or run
       bRun = TRUE;
       if (argc > 1)
           if (_stricmp(argv[1], "-u") == 0) {
               bRun = FALSE;
               if (ntService.Uninstall())
                   iCode = 0;
           }
   } else {
       // install before run
       if (ntService.Install()) bRun = TRUE;
   }

   if (bRun) {
       if (ntService.StartService())
           iCode = 0;
       else if (GetLastError() == ERROR_FAILED_SERVICE_CONTROLLER_CONNECT) {
           printf("Service installed; to start it, type this command: net start %s\n\n",
                   ntService.m_szServiceName );
           iCode = 0;
       }
   }

   return iCode;
}

/*
* CNTService::Handler --> Service Handler Function
* Function that processes command messages from the service manager. 
*/
void CNTService::Handler (DWORD dwOpcode) {
    Log("Entering CNTService::Handler\n");
    CNTService *pService = m_pThis;
    BOOL err;

    if ((dwOpcode == SERVICE_CONTROL_STOP) || (dwOpcode == SERVICE_CONTROL_SHUTDOWN)) {
        // Stop the web server when you recieve the stop command
        StopGemfireServer();

        SC_HANDLE hSCM =::OpenSCManagerA (NULL, NULL, SC_MANAGER_ALL_ACCESS);
        if (!hSCM)
            return;

        SC_HANDLE hService =::OpenServiceA (hSCM, (LPCSTR) pService->m_szServiceName, SC_MANAGER_ALL_ACCESS);
        if (hService){
            pService->SetStatus (SERVICE_STOP_PENDING);
            pService->m_bIsRunning = FALSE;
            err = ControlService (hService, SERVICE_CONTROL_STOP, &pService->m_Status);
            pService->SetStatus (SERVICE_CONTROL_STOP);
            CloseServiceHandle (hService);
            CloseServiceHandle (hSCM);
        }
    }
    ::SetServiceStatus (pService->m_hServiceStatus, &pService->m_Status);
    Log("Exiting CNTService::Handler\n");
}

void CNTService::Handler(DWORD dwOpcode)
{
    CNTService* pService = m_pThis;
    
    if ((dwOpcode == SERVICE_CONTROL_STOP) ||
        (dwOpcode == SERVICE_CONTROL_SHUTDOWN))
    {
        pService->SetStatus(SERVICE_STOP_PENDING);
        pService->m_bIsRunning = FALSE; // SERVICE_STOPPED set when Run returns in ServiceMain (above)
    }
    ::SetServiceStatus(pService->m_hServiceStatus, &pService->m_Status);
}

void CNTService::ServiceMain(DWORD dwArgc, LPTSTR* lpszArgv)
{
    CNTService* pService = m_pThis;
    
    pService->m_Status.dwCurrentState = SERVICE_START_PENDING;
    pService->m_hServiceStatus = RegisterServiceCtrlHandler(pService->m_szServiceName, Handler);
    if (pService->m_hServiceStatus != NULL) {
        if (pService->Initialize()) {
            pService->m_bIsRunning = TRUE;
            pService->m_Status.dwWin32ExitCode = 0;
            pService->m_Status.dwCheckPoint = 0;
            pService->m_Status.dwWaitHint = 0;
            pService->Run();
        }
        pService->SetStatus(SERVICE_STOPPED);
    }
}

void CNTService::ServiceMain(DWORD dwArgc, LPTSTR* lpszArgv)
{
    // Get a pointer to the C++ object
    CNTService* pService = m_pThis;

    pService->DebugMsg("Entering CNTService::ServiceMain()");
    // Register the control request handler
    pService->m_Status.dwCurrentState = SERVICE_START_PENDING;
    pService->m_hServiceStatus = RegisterServiceCtrlHandlerA(pService->m_szServiceName,
                                                           Handler);
    if (pService->m_hServiceStatus == NULL) {
        pService->LogEvent(EVENTLOG_ERROR_TYPE, EVMSG_CTRLHANDLERNOTINSTALLED);
        return;
    }

    // Start the initialisation
    if (pService->Initialize()) {

        // Do the real work. 
        // When the Run function returns, the service has stopped.
        pService->m_bIsRunning = TRUE;
        pService->m_Status.dwWin32ExitCode = 0;
        pService->m_Status.dwCheckPoint = 0;
        pService->m_Status.dwWaitHint = 0;
        pService->Run();
    }

    // Tell the service manager we are stopped
    pService->SetStatus(SERVICE_STOPPED);

    pService->DebugMsg("Leaving CNTService::ServiceMain()");
}

void CNTService::ServiceMain(DWORD dwArgc, LPTSTR* lpszArgv)
{
    // Get a pointer to the C++ object
    CNTService* pService = m_pThis;
    
    pService->DebugMsg(_("Entering CNTService::ServiceMain()"));

    // Register the control request handler
    pService->m_Status.dwCurrentState = SERVICE_START_PENDING;
    pService->m_hServiceStatus = RegisterServiceCtrlHandler(pService->m_szServiceName,
                                                           Handler);
    if ( pService->m_hServiceStatus == NULL ) {
        pService->LogEvent(EVENTLOG_ERROR_TYPE, EVMSG_CTRLHANDLERNOTINSTALLED);
        return;
    }

    // Start the initialisation
    if ( pService->Initialize() )  {
        // Do the real work. 
        // When the Run function returns, the service has stopped.
        pService->m_bIsRunning = true;
        pService->m_Status.dwWin32ExitCode = 0;
        pService->m_Status.dwCheckPoint = 0;
        pService->m_Status.dwWaitHint = 0;
        pService->Run();
    }


	// Now wait for threads to exit.
	DWORD dwWaitRes;
    if ( ( dwWaitRes = WaitForMultipleObjects( MAX_THREADS, ghThreads, TRUE, 3000 ) )
					== WAIT_OBJECT_0 ) {
		// This is OK! Nothing more to do.....
		;
	}
    else if ( ( dwWaitRes == WAIT_FAILED ) || ( dwWaitRes == WAIT_ABANDONED ) ) {
		// We failed to kill the threads we have to
		// abort anyway but we tell the world that we do so....
		pService->DebugMsg(_("Failed to terminate all threads in CNTService::ServiceMain()"));
	}    

	// close the event handle and the thread handle
	CloseHandle( ghStopEvent );
	for (int i=0; i<MAX_THREADS; i++ ) {
		if ( ghThreads[i] ) {
			CloseHandle( ghThreads[i] );	 
		}
	}

    // Tell the service manager we are stopped
    pService->SetStatus( SERVICE_STOPPED );

    pService->DebugMsg(_("Leaving CNTService::ServiceMain()"));
}

// static member function (callback)
void CNTService::ServiceMain(DWORD dwArgc, LPTSTR* lpszArgv)
{
#ifdef _DEBUG
    cout << "in NTService ServiceMain" << endl;
#endif
    // Get a pointer to the C++ object
    CNTService* pService = m_pThis;
    
    // Register the control request handler
    pService->m_Status.dwCurrentState = SERVICE_START_PENDING;
    pService->m_hServiceStatus = RegisterServiceCtrlHandler(pService->m_szServiceName,
                                                           Handler);
    if (pService->m_hServiceStatus == NULL) {
        pService->LogEvent(EVENTLOG_ERROR_TYPE, EVMSG_CTRLHANDLERNOTINSTALLED);
#ifdef _DEBUG
    cout << "NTService:could not register control request handler" << endl;
#endif
        return;
    }

    // Start the initialisation
    if (pService->Initialize()) {

#ifdef _DEBUG
    cout << "NTService: Initialization was successful - ready to go" << endl;
#endif
        // Do the real work. 
        // When the Run function returns, the service has stopped.
        pService->m_bIsRunning = TRUE;
        pService->m_Status.dwWin32ExitCode = 0;
        pService->m_Status.dwCheckPoint = 0;
        pService->m_Status.dwWaitHint = 0;
        pService->Run();
    }

#ifdef _DEBUG
    cout << "NTService: Initialize failed!" << endl;
#endif

    // Tell the service manager we are stopped
    pService->SetStatus(SERVICE_STOPPED);

}

// static member function (callback) to handle commands from the
// service control manager
void CNTService::Handler(DWORD dwOpcode)
{
    // Get a pointer to the object
    CNTService* pService = m_pThis;
    
    pService->DebugMsg("CNTService::Handler(%lu)", dwOpcode);
    switch (dwOpcode) {
    case SERVICE_CONTROL_STOP: // 1
        pService->SetStatus(SERVICE_STOP_PENDING);
        pService->OnStop();
        pService->m_bIsRunning = FALSE;
        pService->LogEvent(EVENTLOG_INFORMATION_TYPE, EVMSG_STOPPED);
        break;

    case SERVICE_CONTROL_PAUSE: // 2
        pService->OnPause();
        break;

    case SERVICE_CONTROL_CONTINUE: // 3
        pService->OnContinue();
        break;

    case SERVICE_CONTROL_INTERROGATE: // 4
        pService->OnInterrogate();
        break;

    case SERVICE_CONTROL_SHUTDOWN: // 5
        pService->OnShutdown();
        break;

    default:
        if (dwOpcode >= SERVICE_CONTROL_USER) {
            if (!pService->OnUserControl(dwOpcode)) {
                pService->LogEvent(EVENTLOG_ERROR_TYPE, EVMSG_BADREQUEST);
            }
        } else {
            pService->LogEvent(EVENTLOG_ERROR_TYPE, EVMSG_BADREQUEST);
        }
        break;
    }

    // Report current status
    pService->DebugMsg("Updating status (%lu, %lu)",
                       pService->m_hServiceStatus,
                       pService->m_Status.dwCurrentState);
    ::SetServiceStatus(pService->m_hServiceStatus, &pService->m_Status);
}

//	PURPOSE:  This function is called by the SCM whenever ControlService() is called on this service.  The
//		SCM does not start the service through this function.
void WINAPI CNTService::service_ctrl(DWORD dwCtrlCode) // static
{
	if ( dwCtrlCode == SERVICE_CONTROL_STOP )
		g_Service.ServiceStop();
	g_Service.SetServiceStatus(g_Service.m_sStatus.dwCurrentState, NO_ERROR, 0);
}

//	PURPOSE: is called by the SCM, and takes care of some initialization and calls ServiceStart().
void WINAPI CNTService::service_main(DWORD dwArgc, LPTSTR *lpszArgv) // static
{
	g_Service.ServiceStartMain(dwArgc, lpszArgv);
}

// static member function (callback) to handle commands from the
// service control manager
void CNTService::Handler(DWORD dwOpcode)
{
#ifdef _DEBUG
  cout << "NTService: handling service control manager command:";
#endif
    // Get a pointer to the object
    CNTService* pService = m_pThis;
    
    switch (dwOpcode) {
    case SERVICE_CONTROL_STOP: // 1
#ifdef _DEBUG
      cout << "stop" << endl;
#endif
        pService->SetStatus(SERVICE_STOP_PENDING);
        pService->OnStop();
        pService->m_bIsRunning = FALSE;
        pService->LogEvent(EVENTLOG_INFORMATION_TYPE, EVMSG_STOPPED);
        break;

    case SERVICE_CONTROL_PAUSE: // 2
#ifdef _DEBUG
      cout << "pause" << endl;
#endif
        pService->OnPause();
        break;

    case SERVICE_CONTROL_CONTINUE: // 3
#ifdef _DEBUG
      cout << "continue" << endl;
#endif
        pService->OnContinue();
        break;

    case SERVICE_CONTROL_INTERROGATE: // 4
#ifdef _DEBUG
      cout << "interrogate" << endl;
#endif
        pService->OnInterrogate();
        break;

    case SERVICE_CONTROL_SHUTDOWN: // 5
#ifdef _DEBUG
      cout << "shutdown" << endl;
#endif
        pService->OnShutdown();
        break;

    default:
        if (dwOpcode >= SERVICE_CONTROL_USER) {
#ifdef _DEBUG
      cout << "user control" << endl;
#endif
            if (!pService->OnUserControl(dwOpcode)) {
                pService->LogEvent(EVENTLOG_ERROR_TYPE, EVMSG_BADREQUEST);
            }
        } else {
#ifdef _DEBUG
      cout << "unknown" << endl;
#endif
            pService->LogEvent(EVENTLOG_ERROR_TYPE, EVMSG_BADREQUEST);
        }
        break;
    }

    // Report current status
    ::SetServiceStatus(pService->m_hServiceStatus, &pService->m_Status);
}

/////////////////////////////////////////////////////////////////////////////////////
//
//	FUNCTION: main()
//
/////////////////////////////////////////////////////////////////////////////////////
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
	UNREFERENCED_PARAMETER(hPrevInstance);

	TCHAR	*argv[32];
	argv[0] = NULL;
	int argc = Str_ParseCmds(lpCmdLine, &argv[1], COUNTOF(argv)-1, " \t") + 1;

	if ( GRAY_GetOSInfo()->dwPlatformId != VER_PLATFORM_WIN32_NT )
	{
		// We are running Win9x - So we are not an NT service.
do_not_nt_service:
		NTWindow_Init(hInstance, lpCmdLine, nCmdShow);
		int iRet = Sphere_MainEntryPoint(argc, argv);
		NTWindow_Exit();
		TerminateProcess(GetCurrentProcess(), iRet);
		return iRet;
	}

	// We need to find out what the server name is....look it up in the .ini file
	if ( !g_Cfg.LoadIni(true) )
	{
		// Try to determine the name and path of this application.
		char szPath[_MAX_PATH];

		GetModuleFileName(NULL, szPath, sizeof(szPath));

		if ( !szPath[0] )
			return -2;

		ExtractPath(szPath);
		g_Cfg.LoadIni(false);
	}

	if ( !g_Cfg.m_fUseNTService )	// since there is no way to detect how did we start, use config for that
		goto do_not_nt_service;

	g_Service.SetServiceStatus(SERVICE_START_PENDING, NO_ERROR, 5000);

	// process the command line arguments...
	if (( argc > 1 ) && _IS_SWITCH(*argv[1]) )
	{
		if ( argv[1][1] == 'k' )		// service control
		{
			if ( argc < 3 )
			{
				printf("Use \"-k command\" with operation to proceed (install/remove)\n");
			}
			else if ( !strcmp(argv[2], "install") )
			{
				g_Service.CmdInstallService();
			}
			else if ( !strcmp(argv[2], "remove") )
			{
				g_Service.CmdRemoveService();
			}
			return 0;
		}
	}

	// If the argument does not match any of the above parameters, the Service Control Manager (SCM) may
	// be attempting to start the service, so we must call StartServiceCtrlDispatcher.
	g_Service.ReportEvent(EVENTLOG_INFORMATION_TYPE, 0, "Starting Service.");

	g_Service.CmdMainStart();
	g_Service.SetServiceStatus(SERVICE_STOPPED, NO_ERROR, 0);
	return -1;
}