/*

 * Windows Service related function definitions

 * By Raju Krishnappa(raju_krishnappa@yahoo.com)

 *

 */

#ifdef WIN32

#include <net-snmp/net-snmp-config.h>

#include <windows.h>

#include <tchar.h>

#include <stdio.h>		/* sprintf */

#include <process.h>		/* beginthreadex  */

#include <net-snmp/library/winservice.h>

#ifdef mingw32 /* MinGW doesn't fully support exception handling. */

#define TRY if(1)

#define LEAVE goto labelFIN

#define FINALLY do { \

labelFIN: \

	; \

} while(0); if(1)

#else

#define TRY __try

#define LEAVE __leave

#define FINALLY __finally

#endif /* mingw32 */

#define CountOf(arr) ( sizeof(arr) / sizeof(arr[0]) )

#if defined(WIN32) && defined(HAVE_WIN32_PLATFORM_SDK) && !defined(mingw32)

#pragma comment(lib, "iphlpapi.lib")

#endif

#if defined(WIN32) && !defined(mingw32)

#ifdef USING_WINEXTDLL_MODULE

#pragma comment(lib, "snmpapi.lib")

#pragma comment(lib, "mgmtapi.lib")

#endif

#endif

    /*

     * External global variables used here

     */

    /*

     * Application Name 

     * This should be declared by the application, which wants to register as

     * windows service

     */

extern LPTSTR app_name_long;

    /*

     * Declare global variable

     */

    /*

     * Flag to indicate whether process is running as Service 

     */

BOOL g_fRunningAsService = FALSE;

    /*

     * Variable to maintain Current Service status 

     */

static SERVICE_STATUS ServiceStatus;

    /*

     * Service Handle 

     */

static SERVICE_STATUS_HANDLE hServiceStatus = 0L;

    /*

     * Service Table Entry 

     */

SERVICE_TABLE_ENTRY ServiceTableEntry[] = {

  {NULL, ServiceMain},		/* Service Main function */

  {NULL, NULL}

};

    /*

     * Handle to Thread, to implement Pause, Resume and Stop functions

     */

static HANDLE hServiceThread = NULL;	/* Thread Handle */

    /*

     * Holds calling partys Function Entry point, that should start

     * when entering service mode

     */

static INT (*ServiceEntryPoint) (INT Argc, LPTSTR Argv[]) = 0L;

    /*

     * To hold Stop Function address, to be called when STOP request

     * received from the SCM

     */

static VOID (*StopFunction) (VOID) = 0L;

    /*

     * To update windows service status to SCM 

     */

static BOOL UpdateServiceStatus (DWORD dwStatus, DWORD dwErrorCode,

				 DWORD dwWaitHint);

    /*

     * To Report current service status to SCM 

     */

static BOOL ReportCurrentServiceStatus (VOID);

VOID

ProcessError (WORD eventLogType, LPCTSTR pszMessage, int useGetLastError, int quiet);

    /*

     * To register as Windows Service with SCM(Service Control Manager)

     * Input - Service Name, Service Display Name,Service Description and

     * Service startup arguments

     */

int

RegisterService (LPCTSTR lpszServiceName, LPCTSTR lpszServiceDisplayName,

		 LPCTSTR lpszServiceDescription,

		 InputParams * StartUpArg, int quiet) /* Startup argument to the service */

{

  TCHAR szServicePath[MAX_PATH];	/* To hold module File name */

  TCHAR MsgErrorString[MAX_STR_SIZE];	/* Message or Error string */

  TCHAR szServiceCommand[MAX_PATH + 9];	/* Command to execute */

  SC_HANDLE hSCManager = NULL;

  SC_HANDLE hService = NULL;

  TCHAR szRegAppLogKey[] =

    _T("SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\");

  TCHAR szRegKey[512];

  HKEY hKey = NULL;		/* Key to registry entry */

  HKEY hParamKey = NULL;	/* To store startup parameters */

  DWORD dwData;			/* Type of logging supported */

  DWORD i, j;			/* Loop variables */

  int exitStatus = 0;

  GetModuleFileName (NULL, szServicePath, MAX_PATH);

  TRY

  {

    /*

     * Open Service Control Manager handle 

     */

    hSCManager = OpenSCManager (NULL, NULL, SC_MANAGER_CREATE_SERVICE);

    if (hSCManager == NULL)

      {

        ProcessError (EVENTLOG_ERROR_TYPE, _T ("Can't open SCM (Service Control Manager)"), 1, quiet);

        exitStatus = SERVICE_ERROR_SCM_OPEN;

	LEAVE;

      }

    /*

     * Generate the command to be executed by the SCM 

     */

    _sntprintf(szServiceCommand, CountOf(szServiceCommand), _T("\"%s\" %s"),

               szServicePath, _T("-service"));

    /*

     * Create the desired service 

     */

    hService = CreateService (hSCManager, lpszServiceName, lpszServiceDisplayName,

			SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,

			SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, szServiceCommand,

			      NULL,	/* load-order group */

			      NULL,	/* group member tag */

			      NULL,	/* dependencies */

			      NULL,	/* account */

			      NULL);	/* password */

    if (hService == NULL)

      {

	_sntprintf (MsgErrorString, CountOf(MsgErrorString), _T("%s %s"),

		   _T ("Can't create service"), lpszServiceDisplayName);

        ProcessError (EVENTLOG_ERROR_TYPE, MsgErrorString, 1, quiet);

        exitStatus = SERVICE_ERROR_CREATE_SERVICE;

	LEAVE;

      }

    /*

     * Create registry entries for the event log 

     */

    /*

     * Create registry Application event log key 

     */

    _tcscpy (szRegKey, szRegAppLogKey);

    _tcscat (szRegKey, lpszServiceName);

    /*

     * Create registry key 

     */

    if (RegCreateKey (HKEY_LOCAL_MACHINE, szRegKey, &hKey) != ERROR_SUCCESS)

      {

	_sntprintf (MsgErrorString, CountOf(MsgErrorString), _T("%s %s"),

		   _T ("is unable to create registry entries"), lpszServiceDisplayName);

        ProcessError (EVENTLOG_ERROR_TYPE, MsgErrorString, 1, quiet);

        exitStatus = SERVICE_ERROR_CREATE_REGISTRY_ENTRIES;

	LEAVE;

      }

    /*

     * Add Event ID message file name to the 'EventMessageFile' subkey 

     */

    RegSetValueEx (hKey, _T("EventMessageFile"), 0, REG_EXPAND_SZ,

		   (CONST BYTE *) szServicePath,

		   _tcslen (szServicePath) + sizeof (TCHAR));

    /*

     * Set the supported types flags. 

     */

    dwData = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE;

    RegSetValueEx (hKey, _T("TypesSupported"), 0, REG_DWORD,

		   (CONST BYTE *) & dwData, sizeof (DWORD));

    /*

     * Close Registry key 

     */

    RegCloseKey (hKey);

    /*

     * Set Service Description String  and save startup parameters if present

     */

    if (lpszServiceDescription != NULL || StartUpArg->Argc > 2)

      {

	/*

	 * Create Registry Key path 

	 */

	_tcscpy (szRegKey, _T ("SYSTEM\\CurrentControlSet\\Services\\"));

	_tcscat (szRegKey, app_name_long);

	hKey = NULL;

	/*

	 * Open Registry key using Create and Set access. 

	 */

	if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, szRegKey, 0, KEY_WRITE,

			  &hKey) != ERROR_SUCCESS)

	  {

	    _sntprintf (MsgErrorString, CountOf(MsgErrorString), _T("%s %s"),

		       _T ("is unable to create registry entries"),

		       lpszServiceDisplayName);

            ProcessError (EVENTLOG_ERROR_TYPE, MsgErrorString, 1, quiet);

            exitStatus = SERVICE_ERROR_CREATE_REGISTRY_ENTRIES;

	    LEAVE;

	  }

	/*

	 * Create description subkey and the set value 

	 */

	if (lpszServiceDescription != NULL)

	  {

	    if (RegSetValueEx (hKey, _T("Description"), 0, REG_SZ,

			       (CONST BYTE *) lpszServiceDescription,

			       _tcslen (lpszServiceDescription) +

			       sizeof (TCHAR)) != ERROR_SUCCESS)

	      {

		_sntprintf (MsgErrorString, CountOf(MsgErrorString), _T("%s %s"),

			   _T ("is unable to create registry entries"),

			   lpszServiceDisplayName);

                ProcessError (EVENTLOG_ERROR_TYPE, MsgErrorString, 1, quiet);

                exitStatus = SERVICE_ERROR_CREATE_REGISTRY_ENTRIES;

		LEAVE;

	      };

	  }

	/*

	 * Save startup arguments if they are present 

	 */

	if (StartUpArg->Argc > 2)

	  {

	    /*

	     * Create Subkey parameters 

	     */

	    if (RegCreateKeyEx

		(hKey, _T("Parameters"), 0, NULL,

		 REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL,

		 &hParamKey, NULL) != ERROR_SUCCESS)

	      {

		_sntprintf (MsgErrorString, CountOf(MsgErrorString), _T("%s %s"),

			   _T ("is unable to create registry entries"),

			   lpszServiceDisplayName);

                ProcessError (EVENTLOG_ERROR_TYPE, MsgErrorString, 1, quiet);

                exitStatus = SERVICE_ERROR_CREATE_REGISTRY_ENTRIES;

                LEAVE;

	      }

	    /*

	     * Save parameters 

	     */

	    /*

	     * Loop through arguments 

	     */

            if (quiet) /* Make sure we don't store -quiet arg */

              i = 3;

            else

              i = 2;

	    for (j = 1; i < StartUpArg->Argc; i++, j++)

	      {

		_sntprintf (szRegKey, CountOf(szRegKey), _T("%s%d"), _T ("Param"), j);

		/*

		 * Create registry key 

		 */

		if (RegSetValueEx

		    (hParamKey, szRegKey, 0, REG_SZ,

		     (CONST BYTE *) StartUpArg->Argv[i],

		     _tcslen (StartUpArg->Argv[i]) +

		     sizeof (TCHAR)) != ERROR_SUCCESS)

		  {

		    _sntprintf (MsgErrorString, CountOf(MsgErrorString), _T("%s %s"),

			       _T ("is unable to create registry entries"),

			       lpszServiceDisplayName);

                    ProcessError (EVENTLOG_ERROR_TYPE, MsgErrorString, 1, quiet);

                    exitStatus = SERVICE_ERROR_CREATE_REGISTRY_ENTRIES;

		    LEAVE;

		  };

	      }

	  }

	/*

	 * Everything is set, delete hKey 

	 */

	RegCloseKey (hParamKey);

	RegCloseKey (hKey);

      }

    /*

     * Ready to log messages 

     */

    /*

     * Successfully registered as service 

     */

    _sntprintf (MsgErrorString, CountOf(MsgErrorString), _T("%s %s"), lpszServiceName,

	       _T ("successfully registered as a service"));

    /*

     * Log message to eventlog 

     */

    ProcessError (EVENTLOG_INFORMATION_TYPE, MsgErrorString, 0, quiet);

  }

  FINALLY

  {

    if (hSCManager)

      CloseServiceHandle (hSCManager);

    if (hService)

      CloseServiceHandle (hService);

    if (hKey)

      RegCloseKey (hKey);

    if (hParamKey)

      RegCloseKey (hParamKey);

  }

  return (exitStatus);

}

    /*

     * Unregister the service with the  Windows SCM 

     * Input - ServiceName

     */

int

UnregisterService (LPCTSTR lpszServiceName, int quiet)

{

  TCHAR MsgErrorString[MAX_STR_SIZE];	/* Message or Error string */

  SC_HANDLE hSCManager = NULL;	/* SCM handle */

  SC_HANDLE hService = NULL;	/* Service Handle */

  SERVICE_STATUS sStatus;

  TCHAR szRegAppLogKey[] =

    _T("SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\");

  TCHAR szRegKey[512];

  int exitStatus = 0;

/*  HKEY hKey = NULL;		?* Key to registry entry */

  TRY

  {

    /*

     * Open Service Control Manager 

     */

    hSCManager = OpenSCManager (NULL, NULL, SC_MANAGER_CREATE_SERVICE);

    if (hSCManager == NULL)

      {

        ProcessError (EVENTLOG_ERROR_TYPE, _T ("Can't open SCM (Service Control Manager)"), 1, quiet);

        exitStatus = SERVICE_ERROR_SCM_OPEN;       

	LEAVE;

      }

    /*

     * Open registered service 

     */

    hService = OpenService (hSCManager, lpszServiceName, SERVICE_ALL_ACCESS);

    if (hService == NULL)

      {

	_sntprintf (MsgErrorString, CountOf(MsgErrorString), _T("%s %s"), _T ("Can't open service"),

		   lpszServiceName);

        ProcessError (EVENTLOG_ERROR_TYPE, MsgErrorString, 1, quiet);

        exitStatus = SERVICE_ERROR_OPEN_SERVICE;       

	LEAVE;

      }

    /*

     * Query service status 

     * If running stop before deleting 

     */

    if (QueryServiceStatus (hService, &sStatus))

      {

	if (sStatus.dwCurrentState == SERVICE_RUNNING

	    || sStatus.dwCurrentState == SERVICE_PAUSED)

	  {

	    ControlService (hService, SERVICE_CONTROL_STOP, &sStatus);

	  }

      };

    /*

     * Delete the service  

     */

    if (DeleteService (hService) == FALSE)

      {

	_sntprintf (MsgErrorString, CountOf(MsgErrorString), _T("%s %s"), _T ("Can't delete service"),

		   lpszServiceName);

	/*

	 * Log message to eventlog 

	 */

        ProcessError (EVENTLOG_ERROR_TYPE, MsgErrorString, 0, quiet);

	LEAVE;

      }

    /*

     * Log "Service deleted successfully " message to eventlog

     */

    _sntprintf (MsgErrorString, CountOf(MsgErrorString), _T("%s %s"), lpszServiceName, _T ("service deleted"));

    ProcessError (EVENTLOG_INFORMATION_TYPE, MsgErrorString, 0, quiet);

    /*

     * Delete registry entries for EventLog 

     */

    _tcscpy (szRegKey, szRegAppLogKey);

    _tcscat (szRegKey, lpszServiceName);

    RegDeleteKey (HKEY_LOCAL_MACHINE, szRegKey);

  }

  /*

   * Delete the handles 

   */

  FINALLY

  {

    if (hService)

      CloseServiceHandle (hService);

    if (hSCManager)

      CloseServiceHandle (hSCManager);

  }

  return (exitStatus);

}

    /*

     * Write a message to the Windows event log.

     */

VOID

WriteToEventLog (WORD wType, LPCTSTR pszFormat, ...)

{

  TCHAR szMessage[512];

  LPCTSTR LogStr[1];

  va_list ArgList;

  HANDLE hEventSource = NULL;

  va_start (ArgList, pszFormat);

  _vsntprintf (szMessage, CountOf(szMessage), pszFormat, ArgList);

  va_end (ArgList);

  LogStr[0] = szMessage;

  hEventSource = RegisterEventSource (NULL, app_name_long);

  if (hEventSource == NULL)

    return;

  ReportEvent (hEventSource, wType, 0,

	       DISPLAY_MSG,

	       NULL, 1, 0, LogStr, NULL);

  DeregisterEventSource (hEventSource);

}

    /*

     * Pre-process the second command-line argument from the user. 

     *     Service related options are:

     *     -register       - registers the service

     *     -unregister     - unregisters the service

     *     -service        - run as service

     *     other command-line arguments are ignored here.

     *

     * Return: Type indicating the option specified

     */

INT

ParseCmdLineForServiceOption (int argc, TCHAR * argv[], int *quiet)

{

  int nReturn = RUN_AS_CONSOLE;	/* default is to run as a console application */

  if (argc >= 2)

    {

      /*

       * second argument present 

       */

      if (lstrcmpi (_T ("-register"), argv[1]) == 0)

	{

	  nReturn = REGISTER_SERVICE;

	}

      else if (lstrcmpi (_T ("-unregister"), argv[1]) == 0)

	{

	  nReturn = UN_REGISTER_SERVICE;

	}

      else if (lstrcmpi (_T ("-service"), argv[1]) == 0)

	{

	  nReturn = RUN_AS_SERVICE;

	}

    }

  if (argc >= 3)

  {

    /*

     * third argument present 

     */

    if (lstrcmpi (_T ("-quiet"), argv[2]) == 0)

    {

      *quiet = 1;	

    }

  }

  return nReturn;

}

    /*

     * Write error message to event log, console or pop-up window.

     *

     * If useGetLastError is 1, the last error returned from GetLastError()

     * is appended to pszMessage, separated by a ": ".

     *

     * eventLogType:                 MessageBox equivalent:

     * 

     * EVENTLOG_INFORMATION_TYPE     MB_ICONASTERISK

     * EVENTLOG_WARNING_TYPE         MB_ICONEXCLAMATION

     * EVENTLOG_ERROR_TYPE           MB_ICONSTOP

     * 

     */

VOID

ProcessError (WORD eventLogType, LPCTSTR pszMessage, int useGetLastError, int quiet)

{

  HANDLE hEventSource = NULL;

  TCHAR pszMessageFull[MAX_STR_SIZE]; /* Combined pszMessage and GetLastError */

  /*

   * If useGetLastError enabled, generate text from GetLastError() and append to

   * pszMessageFull

   */

  if (useGetLastError) {

  LPTSTR pErrorMsgTemp = NULL;

  FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER |

		 FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError (),

		 MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),

        (LPTSTR) & pErrorMsgTemp, 0, NULL);

    _sntprintf (pszMessageFull, CountOf(pszMessageFull), _T("%s: %s"), pszMessage, pErrorMsgTemp);

    if (pErrorMsgTemp) {

      LocalFree (pErrorMsgTemp);

      pErrorMsgTemp = NULL;

    }

  }

  else {

    _sntprintf (pszMessageFull, CountOf(pszMessageFull), _T("%s"), pszMessage);

  }

  hEventSource = RegisterEventSource (NULL, app_name_long);

  if (hEventSource != NULL) {

    LPCTSTR LogStr[1];

    LogStr[0] = pszMessageFull;

    if (ReportEvent (hEventSource, 

          eventLogType, 

          0,

          DISPLAY_MSG,	/* just output the text to the event log */

          NULL, 

          1, 

          0, 

          LogStr, 

          NULL)) {

    }

    else {

      LPTSTR pErrorMsgTemp = NULL;

      FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER |

          FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError (),

          MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),

          (LPTSTR) & pErrorMsgTemp, 0, NULL);

      _ftprintf(stderr,_T("Could NOT lot to Event Log.  Error returned from ReportEvent(): %s\n"),pErrorMsgTemp);

      if (pErrorMsgTemp) {

        LocalFree (pErrorMsgTemp);

        pErrorMsgTemp = NULL;

      }

    }

    DeregisterEventSource (hEventSource);

    }

      if (quiet) {

    _ftprintf(stderr,_T("%s\n"),pszMessageFull);

      }

      else {

    switch (eventLogType) {

      case EVENTLOG_INFORMATION_TYPE:

        MessageBox (NULL, pszMessageFull, app_name_long, MB_ICONASTERISK);

        break;

      case EVENTLOG_WARNING_TYPE:

        MessageBox (NULL, pszMessageFull, app_name_long, MB_ICONEXCLAMATION);

        break;

      case EVENTLOG_ERROR_TYPE:

        MessageBox (NULL, pszMessageFull, app_name_long, MB_ICONSTOP);

        break;

      default:

        MessageBox (NULL, pszMessageFull, app_name_long, EVENTLOG_WARNING_TYPE);

        break;

      }

    }

}

    /*

     * Update current service status.

     * Sends the current service status to the SCM. Also updates

     * the global service status structure.

     */

static BOOL

UpdateServiceStatus (DWORD dwStatus, DWORD dwErrorCode, DWORD dwWaitHint)

{

  static DWORD dwCheckpoint = 1;

  DWORD dwControls = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_PAUSE_CONTINUE;

  if (g_fRunningAsService == FALSE)

    return FALSE;

  ZeroMemory (&ServiceStatus, sizeof (ServiceStatus));

  ServiceStatus.dwServiceType = SERVICE_WIN32;

  ServiceStatus.dwCurrentState = dwStatus;

  ServiceStatus.dwWaitHint = dwWaitHint;

  if (dwErrorCode)

    {

      ServiceStatus.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR;

      ServiceStatus.dwServiceSpecificExitCode = dwErrorCode;

    }

  /*

   * special cases that depend on the new state 

   */

  switch (dwStatus)

    {

    case SERVICE_START_PENDING:

      dwControls = 0;

      break;

    case SERVICE_RUNNING:

    case SERVICE_STOPPED:

      dwCheckpoint = 0;

      break;

    }

  ServiceStatus.dwCheckPoint = dwCheckpoint++;

  ServiceStatus.dwControlsAccepted = dwControls;

  return ReportCurrentServiceStatus ();

}

    /*

     * Reports current service status to SCM

     */

static BOOL

ReportCurrentServiceStatus ()

{

  return SetServiceStatus (hServiceStatus, &ServiceStatus);

}

    /*

     * ServiceMain function.

     */

VOID WINAPI

ServiceMain (DWORD argc, LPTSTR argv[])

{

  SECURITY_ATTRIBUTES SecurityAttributes;

  unsigned threadId;

  /*

   * Input arguments

   */

  DWORD ArgCount = 0;

  LPTSTR *ArgArray = NULL;

  TCHAR szRegKey[512];

  HKEY hParamKey = NULL;

  DWORD TotalParams = 0;

  DWORD i;

  InputParams ThreadInputParams;

  /*

   * Build the Input parameters to pass to worker thread 

   */

  /*

   * SCM sends Service Name as first arg, increment to point

   * arguments user specified while starting control agent

   */

  /*

   * Read registry parameter 

   */

  ArgCount = 1;

  /*

   * Create registry key path 

   */

  _sntprintf (szRegKey, CountOf(szRegKey), _T("%s%s\\%s"),

	     _T ("SYSTEM\\CurrentControlSet\\Services\\"), app_name_long,

	     _T("Parameters"));

  if (RegOpenKeyEx

      (HKEY_LOCAL_MACHINE, szRegKey, 0, KEY_ALL_ACCESS, &hParamKey) == ERROR_SUCCESS)

    {

      /*

       * Read startup configuration information 

       */

      /*

       * Find number of subkeys inside parameters 

       */

      if (RegQueryInfoKey (hParamKey, NULL, NULL, 0,

	   NULL, NULL, NULL, &TotalParams,

	   NULL, NULL, NULL, NULL) == ERROR_SUCCESS)

	{

	  if (TotalParams != 0)

	    {

	      ArgCount += TotalParams;

	      /*

	       * Allocate memory to hold strings 

	       */

	      ArgArray = calloc(ArgCount, sizeof(ArgArray[0]));

              if (ArgArray == 0)

                {

                  WriteToEventLog (EVENTLOG_ERROR_TYPE,

		       _T ("Resource failure"));

                  return;

                }

	      /*

	       * Copy first argument 

	       */

	      ArgArray[0] = _tcsdup (argv[0]);

	      for (i = 1; i <= TotalParams; i++)

		{

                  DWORD dwErrorcode;

                  DWORD nSize;

                  DWORD nRegkeyType;

                  TCHAR *szValue;

		  /*

		   * Create Subkey value name 

		   */

		  _sntprintf (szRegKey, CountOf(szRegKey), _T("%s%d"), _T("Param"), i);

		  /*

		   * Query subkey.

		   */

		  nSize = 0;

		  dwErrorcode = RegQueryValueEx(hParamKey, szRegKey, NULL,

                                                &nRegkeyType, NULL, &nSize);

                  if (dwErrorcode == ERROR_SUCCESS) {

                    if (nRegkeyType == REG_SZ || nRegkeyType == REG_EXPAND_SZ) {

                      szValue = malloc(nSize + sizeof(szValue[0]));

                      if (szValue) {

		        dwErrorcode = RegQueryValueEx(hParamKey, szRegKey, NULL,

                                                      &nRegkeyType, (LPBYTE)szValue, &nSize);

                        if (dwErrorcode == ERROR_SUCCESS) {

                          szValue[nSize] = 0;

                          ArgArray[i] = szValue;

                        } else {

                          free(szValue);

                          WriteToEventLog(EVENTLOG_ERROR_TYPE, _T("Querying registry key %s failed: error code %ld"), szRegKey, dwErrorcode);

                        }

                      } else

                        WriteToEventLog(EVENTLOG_ERROR_TYPE, _T("Querying registry key %s failed: out of memory"), szRegKey);

                    } else

                      WriteToEventLog(EVENTLOG_ERROR_TYPE, _T("Type %ld of registry key %s is incorrect"), nRegkeyType, szRegKey);

                  } else

                    WriteToEventLog(EVENTLOG_ERROR_TYPE, _T("Querying registry key %s failed: error code %ld"), szRegKey, dwErrorcode);

                  if (!ArgArray[i]) {

                    TotalParams = ArgCount = i;

                    break;

                  }

		}

	    }

	}

      RegCloseKey (hParamKey);

    }

  if (ArgCount == 1)

    {

      /*

       * No startup args are given 

       */

      ThreadInputParams.Argc = argc;

      ThreadInputParams.Argv = argv;

    }

  else

    {

      ThreadInputParams.Argc = ArgCount;

      ThreadInputParams.Argv = ArgArray;

    }

  /*

   * Register Service Control Handler 

   */

  hServiceStatus = RegisterServiceCtrlHandler (app_name_long, ControlHandler);

  if (hServiceStatus == 0)

    {

      WriteToEventLog (EVENTLOG_ERROR_TYPE,

		       _T ("RegisterServiceCtrlHandler failed"));

      return;

    }

  /*

   * Update the service status to START_PENDING.

   */

  UpdateServiceStatus (SERVICE_START_PENDING, NO_ERROR, SCM_WAIT_INTERVAL);

  /*

   * Start the worker thread, which does the majority of the work .

   */

  TRY

  {

    if (SetSimpleSecurityAttributes (&SecurityAttributes) == FALSE)

      {

	WriteToEventLog (EVENTLOG_ERROR_TYPE,

			 _T ("Couldn't init security attributes"));

	LEAVE;

      }

    hServiceThread =

      (void *) _beginthreadex (&SecurityAttributes, 0,

			       ThreadFunction,

			       (void *) &ThreadInputParams, 0, &threadId);

    if (hServiceThread == NULL)

      {

	WriteToEventLog (EVENTLOG_ERROR_TYPE, _T ("Couldn't start worker thread"));

	LEAVE;

      }

    /*

     * Set service status to SERVICE_RUNNING.

     */

    UpdateServiceStatus (SERVICE_RUNNING, NO_ERROR, SCM_WAIT_INTERVAL);

    /*

     * Wait until the worker thread finishes.

     */

    WaitForSingleObject (hServiceThread, INFINITE);

  }

  FINALLY

  {

    /*

     * Release resources 

     */

    UpdateServiceStatus (SERVICE_STOPPED, NO_ERROR, SCM_WAIT_INTERVAL);

    if (hServiceThread)

      CloseHandle (hServiceThread);

    FreeSecurityAttributes (&SecurityAttributes);

    /*

     * Free allocated argument list 

     */

    if (ArgCount > 1 && ArgArray != NULL)

      {

	/*

	 * Free all strings 

	 */

	for (i = 0; i < ArgCount; i++)

	  {

	    free (ArgArray[i]);

	  }