#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <process.h>
#include <tchar.h>
#include "service.h"

Include dependency graph for service.c:

Functions
VOID WINAPI	service_ctrl (DWORD dwCtrlCode)

VOID WINAPI	service_main (DWORD dwArgc, LPTSTR *lpszArgv)

VOID	CmdInstallService ()

VOID	CmdRemoveService ()

VOID	CmdDebugService (int argc, char **argv)

BOOL WINAPI	ControlHandler (DWORD dwCtrlType)

LPTSTR	GetLastErrorText (LPTSTR lpszBuf, DWORD dwSize)

void __cdecl	main (int argc, char **argv)

BOOL	ReportStatusToSCMgr (DWORD dwCurrentState, DWORD dwWin32ExitCode, DWORD dwWaitHint)

VOID	AddToMessageLog (LPTSTR lpszMsg)

Variables
SERVICE_STATUS	ssStatus

SERVICE_STATUS_HANDLE	sshStatusHandle

DWORD	dwErr = 0

BOOL	bDebug = FALSE

TCHAR	szErr [256]

Function Documentation

◆ AddToMessageLog()

VOID AddToMessageLog ( LPTSTR lpszMsg )

Definition at line 289 of file service.c.

{
   TCHAR szMsg [(sizeof(SZSERVICENAME) / sizeof(TCHAR)) + 100 ];
   HANDLE  hEventSource;
   LPTSTR  lpszStrings[2];
 
   if ( !bDebug )
   {
      dwErr = GetLastError();
 
      // Use event logging to log the error.
      //
      hEventSource = RegisterEventSource(NULL, TEXT(SZSERVICENAME));
 
#ifndef __REACTOS__
      _stprintf_s(szMsg,(sizeof(SZSERVICENAME) / sizeof(TCHAR)) + 100, TEXT("%s error: %d"), TEXT(SZSERVICENAME), dwErr);
#else
      _sntprintf(szMsg,(sizeof(SZSERVICENAME) / sizeof(TCHAR)) + 100, TEXT("%s error: %d"), TEXT(SZSERVICENAME), dwErr);
#endif
      lpszStrings[0] = szMsg;
      lpszStrings[1] = lpszMsg;
 
      if (hEventSource != NULL)
      {
         ReportEvent(hEventSource, // handle of event source
                     EVENTLOG_ERROR_TYPE,  // event type
                     0,                    // event category
                     0,                    // event ID
                     NULL,                 // current user's SID
                     2,                    // strings in lpszStrings
                     0,                    // no bytes of raw data
                     lpszStrings,          // array of error strings
                     NULL);                // no raw data
 
         (VOID) DeregisterEventSource(hEventSource);
      }
   }
}

Referenced by main(), and ReportStatusToSCMgr().

◆ CmdDebugService()

void CmdDebugService	(	int	argc,
		char **	argv
	)

Definition at line 497 of file service.c.

{
   DWORD dwArgc;
   LPTSTR *lpszArgv;
 
#ifdef UNICODE
   lpszArgv = CommandLineToArgvW(GetCommandLineW(), &(dwArgc) );
   if (NULL == lpszArgv)
   {
       // CommandLineToArvW failed!!
       _tprintf(TEXT("CmdDebugService CommandLineToArgvW returned NULL\n"));
       return;
   }
#else
   dwArgc   = (DWORD) argc;
   lpszArgv = argv;
#endif
 
   _tprintf(TEXT("Debugging %s.\n"), TEXT(SZSERVICEDISPLAYNAME));
 
   SetConsoleCtrlHandler( ControlHandler, TRUE );
 
   ServiceStart( dwArgc, lpszArgv );
 
#ifdef UNICODE
// Must free memory allocated for arguments
 
   GlobalFree(lpszArgv);
#endif // UNICODE
 
}

Referenced by main().

◆ CmdInstallService()

void CmdInstallService ( )

Definition at line 350 of file service.c.

{
   SC_HANDLE   schService;
   SC_HANDLE   schSCManager;
 
   TCHAR szPath[512];
 
   if ( GetModuleFileName( NULL, szPath, 512 ) == 0 )
   {
      _tprintf(TEXT("Unable to install %s - %s\n"), TEXT(SZSERVICEDISPLAYNAME), GetLastErrorText(szErr, 256));
      return;
   }
 
   schSCManager = OpenSCManager(
                               NULL,                   // machine (NULL == local)
                               NULL,                   // database (NULL == default)
                               SC_MANAGER_CONNECT | SC_MANAGER_CREATE_SERVICE  // access required
                               );
   if ( schSCManager )
   {
      schService = CreateService(
                                schSCManager,               // SCManager database
                                TEXT(SZSERVICENAME),        // name of service
                                TEXT(SZSERVICEDISPLAYNAME), // name to display
                                SERVICE_QUERY_STATUS,       // desired access
                                SERVICE_WIN32_OWN_PROCESS,  // service type
                                SERVICE_AUTO_START,         // start type
                                SERVICE_ERROR_NORMAL,       // error control type
                                szPath,                     // service's binary
                                NULL,                       // no load ordering group
                                NULL,                       // no tag identifier
                                TEXT(SZDEPENDENCIES),       // dependencies
                                NULL,                       // LocalSystem account
                                NULL);                      // no password
 
      if ( schService )
      {
         _tprintf(TEXT("%s installed.\n"), TEXT(SZSERVICEDISPLAYNAME) );
         CloseServiceHandle(schService);
      }
      else
      {
         _tprintf(TEXT("CreateService failed - %s\n"), GetLastErrorText(szErr, 256));
      }
 
      CloseServiceHandle(schSCManager);
   }
   else
      _tprintf(TEXT("OpenSCManager failed - %s\n"), GetLastErrorText(szErr,256));
}

Referenced by main().

◆ CmdRemoveService()

void CmdRemoveService ( )

Definition at line 416 of file service.c.

{
   SC_HANDLE   schService;
   SC_HANDLE   schSCManager;
 
   schSCManager = OpenSCManager(
                               NULL,                   // machine (NULL == local)
                               NULL,                   // database (NULL == default)
                               SC_MANAGER_CONNECT   // access required
                               );
   if ( schSCManager )
   {
      schService = OpenService(schSCManager, TEXT(SZSERVICENAME), DELETE | SERVICE_STOP | SERVICE_QUERY_STATUS);
 
      if (schService)
      {
         // try to stop the service
         if ( ControlService( schService, SERVICE_CONTROL_STOP, &ssStatus ) )
         {
            _tprintf(TEXT("Stopping %s."), TEXT(SZSERVICEDISPLAYNAME));
            Sleep( 1000 );
 
            while ( QueryServiceStatus( schService, &ssStatus ) )
            {
               if ( ssStatus.dwCurrentState == SERVICE_STOP_PENDING )
               {
                  _tprintf(TEXT("."));
                  Sleep( 1000 );
               }
               else
                  break;
            }
 
            if ( ssStatus.dwCurrentState == SERVICE_STOPPED )
               _tprintf(TEXT("\n%s stopped.\n"), TEXT(SZSERVICEDISPLAYNAME) );
            else
               _tprintf(TEXT("\n%s failed to stop.\n"), TEXT(SZSERVICEDISPLAYNAME) );
 
         }
 
         // now remove the service
         if ( DeleteService(schService) )
            _tprintf(TEXT("%s removed.\n"), TEXT(SZSERVICEDISPLAYNAME) );
         else
            _tprintf(TEXT("DeleteService failed - %s\n"), GetLastErrorText(szErr,256));
 
 
         CloseServiceHandle(schService);
      }
      else
         _tprintf(TEXT("OpenService failed - %s\n"), GetLastErrorText(szErr,256));
 
      CloseServiceHandle(schSCManager);
   }
   else
      _tprintf(TEXT("OpenSCManager failed - %s\n"), GetLastErrorText(szErr,256));
}

Referenced by main().

◆ ControlHandler()

BOOL WINAPI ControlHandler ( DWORD dwCtrlType )

Definition at line 544 of file service.c.

{
   switch ( dwCtrlType )
   {
   case CTRL_BREAK_EVENT:  // use Ctrl+C or Ctrl+Break to simulate
   case CTRL_C_EVENT:      // SERVICE_CONTROL_STOP in debug mode
      _tprintf(TEXT("Stopping %s.\n"), TEXT(SZSERVICEDISPLAYNAME));
      ServiceStop();
      return TRUE;
      break;
 
   }
   return FALSE;
}

Referenced by CmdDebugService().

◆ GetLastErrorText()

LPTSTR GetLastErrorText	(	LPTSTR	lpszBuf,
		DWORD	dwSize
	)

Definition at line 573 of file service.c.

{
   DWORD dwRet;
   LPTSTR lpszTemp = NULL;
 
   dwRet = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |FORMAT_MESSAGE_ARGUMENT_ARRAY,
                          NULL,
                          GetLastError(),
                          LANG_NEUTRAL,
                          (LPTSTR)&lpszTemp,
                          0,
                          NULL );
 
   // supplied buffer is not long enough
   if ( !dwRet || ( (long)dwSize < (long)dwRet+14 ) )
      lpszBuf[0] = TEXT('\0');
   else
   {
       if (NULL != lpszTemp)
       {
           lpszTemp[lstrlen(lpszTemp)-2] = TEXT('\0');  //remove cr and newline character
#ifndef __REACTOS__
           _stprintf_s( lpszBuf, dwSize, TEXT("%s (0x%x)"), lpszTemp, GetLastError() );
#else
           _sntprintf( lpszBuf, dwSize, TEXT("%s (0x%x)"), lpszTemp, GetLastError() );
#endif
       }
   }
 
   if ( NULL != lpszTemp )
      LocalFree((HLOCAL) lpszTemp );
 
   return lpszBuf;
}

Referenced by CmdInstallService(), and CmdRemoveService().

◆ main()

void __cdecl main	(	int argc	,
		char **	argv
	)

Definition at line 67 of file service.c.

{
   SERVICE_TABLE_ENTRY dispatchTable[] =
   {
      { TEXT(SZSERVICENAME), (LPSERVICE_MAIN_FUNCTION)service_main},
      { NULL, NULL}
   };
 
   if ( (argc > 1) &&
        ((*argv[1] == '-') || (*argv[1] == '/')) )
   {
      if ( _stricmp( "install", argv[1]+1 ) == 0 )
      {
         CmdInstallService();
      }
      else if ( _stricmp( "remove", argv[1]+1 ) == 0 )
      {
         CmdRemoveService();
      }
      else if ( _stricmp( "debug", argv[1]+1 ) == 0 )
      {
         bDebug = TRUE;
         CmdDebugService(argc, argv);
      }
      else
      {
         goto dispatch;
      }
      exit(0);
   }
 
   // if it doesn't match any of the above parameters
   // the service control manager may be starting the service
   // so we must call StartServiceCtrlDispatcher
   dispatch:
   // this is just to be friendly
   printf( "%s -install          to install the service\n", SZAPPNAME );
   printf( "%s -remove           to remove the service\n", SZAPPNAME );
   printf( "%s -debug <params>   to run as a console app for debugging\n", SZAPPNAME );
   printf( "\nStartServiceCtrlDispatcher being called.\n" );
   printf( "This may take several seconds.  Please wait.\n" );
 
   if (!StartServiceCtrlDispatcher(dispatchTable))
      AddToMessageLog(TEXT("StartServiceCtrlDispatcher failed."));
}

◆ ReportStatusToSCMgr()

BOOL ReportStatusToSCMgr	(	DWORD	dwCurrentState,
		DWORD	dwWin32ExitCode,
		DWORD	dwWaitHint
	)

Definition at line 240 of file service.c.

{
   static DWORD dwCheckPoint = 1;
   BOOL fResult = TRUE;
 
 
   if ( !bDebug ) // when debugging we don't report to the SCM
   {
      if (dwCurrentState == SERVICE_START_PENDING)
         ssStatus.dwControlsAccepted = 0;
      else
         ssStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
 
      ssStatus.dwCurrentState = dwCurrentState;
      ssStatus.dwWin32ExitCode = dwWin32ExitCode;
      ssStatus.dwWaitHint = dwWaitHint;
 
      if ( ( dwCurrentState == SERVICE_RUNNING ) ||
           ( dwCurrentState == SERVICE_STOPPED ) )
         ssStatus.dwCheckPoint = 0;
      else
         ssStatus.dwCheckPoint = dwCheckPoint++;
 
 
      // Report the status of the service to the service control manager.
      fResult = SetServiceStatus(sshStatusHandle, &ssStatus);
      if (!fResult)
         AddToMessageLog(TEXT("SetServiceStatus"));
   }
   return fResult;
}

Referenced by open_log_files(), service_ctrl(), service_main(), and ServiceStart().

◆ service_ctrl()

VOID WINAPI service_ctrl ( DWORD dwCtrlCode )

Definition at line 187 of file service.c.

{
   // Handle the requested control code.
   //
 
   switch (dwCtrlCode)
   {
   // Stop the service.
   //
   // SERVICE_STOP_PENDING should be reported before
   // setting the Stop Event - hServerStopEvent - in
   // ServiceStop().  This avoids a race condition
   // which may result in a 1053 - The Service did not respond...
   // error.
   case SERVICE_CONTROL_STOP:
      ReportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR, 0);
      ServiceStop();
      return;
 
      // Update the service status.
      //
   case SERVICE_CONTROL_INTERROGATE:
      break;
 
      // invalid control code
      //
   default:
      break;
 
   }
 
   ReportStatusToSCMgr(ssStatus.dwCurrentState, NO_ERROR, 0);
}

Referenced by service_main().

◆ service_main()

void WINAPI service_main	(	DWORD	dwArgc,
		LPTSTR *	lpszArgv
	)

Definition at line 132 of file service.c.

{
 
   // register our service control handler:
   //
   sshStatusHandle = RegisterServiceCtrlHandler( TEXT(SZSERVICENAME), service_ctrl);
 
   if (!sshStatusHandle)
      goto cleanup;
 
   // SERVICE_STATUS members that don't change in example
   //
   ssStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
   ssStatus.dwServiceSpecificExitCode = 0;
 
 
   // report the status to the service control manager.
   //
   if (!ReportStatusToSCMgr(
                           SERVICE_START_PENDING, // service state
                           NO_ERROR,              // exit code
                           3000))                 // wait hint
      goto cleanup;
 
   ServiceStart( dwArgc, lpszArgv );
 
   cleanup:
 
   // try to report the stopped status to the service control manager.
   //
   if (sshStatusHandle)
      (VOID)ReportStatusToSCMgr(
                               SERVICE_STOPPED,
                               dwErr,
                               0);
 
   return;
}