Diff for /libraries/liblutil/ntservice.c between versions 1.2 and 1.3

version 1.2, 1999/06/17 01:54:27 version 1.3, 1999/06/18 19:29:02
Line 10 Line 10
 #include <ac/string.h>  #include <ac/string.h>
   
 #include "ldap_defaults.h"  #include "ldap_defaults.h"
 //#include "slap.h"  
   
 #include "slapdmsg.h"  #include "slapdmsg.h"
   
 #define SCM_NOTIFICATION_INTERVAL       5000  #define SCM_NOTIFICATION_INTERVAL       5000
 #define THIRTY_SECONDS                          (30 * 1000)  #define THIRTY_SECONDS                          (30 * 1000)
   
 int       is_NT_Service = 1;    // assume this is an NT service until determined that   int       is_NT_Service = 1;    /* assume this is an NT service until determined that */
                                                                         // startup was from the command line                                                          /* startup was from the command line */
   
 SERVICE_STATUS                  SLAPDServiceStatus;  SERVICE_STATUS                  SLAPDServiceStatus;
 SERVICE_STATUS_HANDLE   hSLAPDServiceStatus;  SERVICE_STATUS_HANDLE   hSLAPDServiceStatus;
Line 28  ldap_pvt_thread_t  start_status_tid, sto Line 27  ldap_pvt_thread_t  start_status_tid, sto
   
 void (*stopfunc)(int);  void (*stopfunc)(int);
   
 // in main.c  /* in main.c */
 void WINAPI ServiceMain( DWORD argc, LPTSTR *argv );  void WINAPI ServiceMain( DWORD argc, LPTSTR *argv );
   
   
 // in wsa_err.c  /* in wsa_err.c */
 char *WSAGetLastErrorString( void );  char *WSAGetLastErrorString( void );
   
 // in nt_err.c  /* in nt_err.c */
 char *GetLastErrorString( void );  char *GetLastErrorString( void );
   
 int srv_install(LPCTSTR lpszServiceName, LPCTSTR lpszBinaryPathName)  int srv_install(LPCTSTR lpszServiceName, LPCTSTR lpszBinaryPathName)
Line 64  int srv_install(LPCTSTR lpszServiceName, Line 63  int srv_install(LPCTSTR lpszServiceName,
   
                         sprintf( regpath, "SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\%s",                          sprintf( regpath, "SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\%s",
                                 lpszServiceName );                                  lpszServiceName );
                         // Create the registry key for event logging to the Windows NT event log.                          /* Create the registry key for event logging to the Windows NT event log. */
                         if ( RegCreateKeyEx(HKEY_LOCAL_MACHINE,                           if ( RegCreateKeyEx(HKEY_LOCAL_MACHINE, 
                                 regpath, 0,                                   regpath, 0, 
                                 "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey,                                   "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, 
Line 150  static void *start_status_routine( void Line 149  static void *start_status_routine( void
                 {                  {
                         case WAIT_ABANDONED:                          case WAIT_ABANDONED:
                         case WAIT_OBJECT_0:                          case WAIT_OBJECT_0:
                                 // the object that we were waiting for has been destroyed (ABANDONED) or                                  /* the object that we were waiting for has been destroyed (ABANDONED) or
                                 // signalled (TIMEOUT_0). We can assume that the startup process is                                   * signalled (TIMEOUT_0). We can assume that the startup process is
                                 // complete and tell the Service Control Manager that we are now runnng                                   * complete and tell the Service Control Manager that we are now runnng */
                                 SLAPDServiceStatus.dwCurrentState       = SERVICE_RUNNING;                                  SLAPDServiceStatus.dwCurrentState       = SERVICE_RUNNING;
                                 SLAPDServiceStatus.dwWin32ExitCode      = NO_ERROR;                                  SLAPDServiceStatus.dwWin32ExitCode      = NO_ERROR;
                                 SLAPDServiceStatus.dwCheckPoint++;                                  SLAPDServiceStatus.dwCheckPoint++;
Line 161  static void *start_status_routine( void Line 160  static void *start_status_routine( void
                                 done = 1;                                  done = 1;
                                 break;                                  break;
                         case WAIT_TIMEOUT:                          case WAIT_TIMEOUT:
                                 // We've waited for the required time, so send an update to the Service Control                                   /* We've waited for the required time, so send an update to the Service Control 
                                 // Manager saying to wait again.                                   * Manager saying to wait again. */
                                 SLAPDServiceStatus.dwCheckPoint++;                                  SLAPDServiceStatus.dwCheckPoint++;
                                 SLAPDServiceStatus.dwWaitHint = SCM_NOTIFICATION_INTERVAL * 2;                                  SLAPDServiceStatus.dwWaitHint = SCM_NOTIFICATION_INTERVAL * 2;
                                 SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);                                  SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);
                                 break;                                  break;
                         case WAIT_FAILED:                          case WAIT_FAILED:
                                 // theres been some proble with WaitForSingleObject so tell the Service                                  /* theres been some proble with WaitForSingleObject so tell the Service
                                 // Control Manager to wait 30 seconds before deploying its assasin and                                    * Control Manager to wait 30 seconds before deploying its assasin and 
                                 // then leave the thread.                                   * then leave the thread. */
                                 SLAPDServiceStatus.dwCheckPoint++;                                  SLAPDServiceStatus.dwCheckPoint++;
                                 SLAPDServiceStatus.dwWaitHint = THIRTY_SECONDS;                                  SLAPDServiceStatus.dwWaitHint = THIRTY_SECONDS;
                                 SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);                                  SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);
Line 196  static void *stop_status_routine( void * Line 195  static void *stop_status_routine( void *
                 {                  {
                         case WAIT_ABANDONED:                          case WAIT_ABANDONED:
                         case WAIT_OBJECT_0:                          case WAIT_OBJECT_0:
                                 // the object that we were waiting for has been destroyed (ABANDONED) or                                  /* the object that we were waiting for has been destroyed (ABANDONED) or
                                 // signalled (TIMEOUT_0). The shutting down process is therefore complete                                    * signalled (TIMEOUT_0). The shutting down process is therefore complete 
                                 // and the final SERVICE_STOPPED message will be sent to the service control                                   * and the final SERVICE_STOPPED message will be sent to the service control
                                 // manager prior to the process terminating.                                   * manager prior to the process terminating. */
                                 done = 1;                                  done = 1;
                                 break;                                  break;
                         case WAIT_TIMEOUT:                          case WAIT_TIMEOUT:
                                 // We've waited for the required time, so send an update to the Service Control                                   /* We've waited for the required time, so send an update to the Service Control 
                                 // Manager saying to wait again.                                   * Manager saying to wait again. */
                                 SLAPDServiceStatus.dwCheckPoint++;                                  SLAPDServiceStatus.dwCheckPoint++;
                                 SLAPDServiceStatus.dwWaitHint = SCM_NOTIFICATION_INTERVAL * 2;                                  SLAPDServiceStatus.dwWaitHint = SCM_NOTIFICATION_INTERVAL * 2;
                                 SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);                                  SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);
                                 break;                                  break;
                         case WAIT_FAILED:                          case WAIT_FAILED:
                                 // theres been some proble with WaitForSingleObject so tell the Service                                  /* theres been some proble with WaitForSingleObject so tell the Service
                                 // Control Manager to wait 30 seconds before deploying its assasin and                                    * Control Manager to wait 30 seconds before deploying its assasin and 
                                 // then leave the thread.                                   * then leave the thread. */
                                 SLAPDServiceStatus.dwCheckPoint++;                                  SLAPDServiceStatus.dwCheckPoint++;
                                 SLAPDServiceStatus.dwWaitHint = THIRTY_SECONDS;                                  SLAPDServiceStatus.dwWaitHint = THIRTY_SECONDS;
                                 SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);                                  SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);
Line 242  void WINAPI SLAPDServiceCtrlHandler( IN Line 241  void WINAPI SLAPDServiceCtrlHandler( IN
                 ldap_pvt_thread_cond_init( &stopped_event );                  ldap_pvt_thread_cond_init( &stopped_event );
                 if ( stopped_event == NULL )                  if ( stopped_event == NULL )
                 {                  {
                         // the event was not created. We will ask the service control manager for 30                          /* the event was not created. We will ask the service control manager for 30
                         // seconds to shutdown                           * seconds to shutdown */
                         SLAPDServiceStatus.dwCheckPoint++;                          SLAPDServiceStatus.dwCheckPoint++;
                         SLAPDServiceStatus.dwWaitHint           = THIRTY_SECONDS;                          SLAPDServiceStatus.dwWaitHint           = THIRTY_SECONDS;
                         SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);                          SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);
                 }                  }
                 else                  else
                 {                  {
                         // start a thread to report the progress to the service control manager                           /* start a thread to report the progress to the service control manager 
                         // until the stopped_event is fired.                           * until the stopped_event is fired. */
                         if ( ldap_pvt_thread_create( &stop_status_tid, 0, stop_status_routine, NULL ) == 0 )                          if ( ldap_pvt_thread_create( &stop_status_tid, 0, stop_status_routine, NULL ) == 0 )
                         {                          {
                                                                   
                         }                          }
                         else {                          else {
                                 // failed to create the thread that tells the Service Control Manager that the                                  /* failed to create the thread that tells the Service Control Manager that the
                                 // service stopping is proceeding.                                    * service stopping is proceeding. 
                                 // tell the Service Control Manager to wait another 30 seconds before deploying its                                   * tell the Service Control Manager to wait another 30 seconds before deploying its
                                 // assasin.                                   * assasin.  */
                                 SLAPDServiceStatus.dwCheckPoint++;                                  SLAPDServiceStatus.dwCheckPoint++;
                                 SLAPDServiceStatus.dwWaitHint = THIRTY_SECONDS;                                  SLAPDServiceStatus.dwWaitHint = THIRTY_SECONDS;
                                 SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);                                  SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);
Line 276  void WINAPI SLAPDServiceCtrlHandler( IN Line 275  void WINAPI SLAPDServiceCtrlHandler( IN
         return;          return;
 }  }
   
   
 void *getRegParam( char *svc, char *value )  void *getRegParam( char *svc, char *value )
 {  {
         HANDLE hkey;          HKEY hkey;
         char path[255];          char path[255];
         int i = 0, rc;  
         char vName[256];  
         DWORD vNameLen = 255;  
         DWORD vType;          DWORD vType;
         static char vValue[1024];          static char vValue[1024];
         DWORD valLen = 1024;          DWORD valLen = sizeof( vValue );
   
         if ( svc != NULL )          if ( svc != NULL )
                 sprintf ( path, "SOFTWARE\\OpenLDAP\\%s\\Parameters", svc );                  sprintf ( path, "SOFTWARE\\OpenLDAP\\%s\\Parameters", svc );
         else          else
                 strcpy (path, "SOFTWARE\\OpenLDAP\\Parameters" );                  strcpy (path, "SOFTWARE\\OpenLDAP\\Parameters" );
           
         if( (rc = RegOpenKeyEx( HKEY_LOCAL_MACHINE,          if ( RegOpenKeyEx( HKEY_LOCAL_MACHINE, path, 0, KEY_READ, &hkey ) != ERROR_SUCCESS )
                 path, 0, KEY_READ, &hkey )) != ERROR_SUCCESS )  
         {          {
                 //Debug( LDAP_DEBUG_ANY, "%s\n", GetLastErrorString(), 0, 0 );                  /*Debug( LDAP_DEBUG_ANY, "RegOpenKeyEx() %s\n", GetLastErrorString(), 0, 0); */
                 return NULL;                  return NULL;
         }          }
   
         while ( !RegEnumValue( hkey, i, vName, &vNameLen, NULL,          if ( RegQueryValueEx( hkey, value, NULL, &vType, vValue, &valLen ) != ERROR_SUCCESS )
                 &vType, vValue, &valLen ) )  
         {          {
                 if ( !strcasecmp( value, vName ) )                  /*Debug( LDAP_DEBUG_ANY, "RegQueryValueEx() %s\n", GetLastErrorString(), 0, 0 );*/
                 {                  RegCloseKey( hkey );
                         switch ( vType )                  return NULL;
                         {          }
                         case REG_BINARY:          RegCloseKey( hkey );
                         case REG_DWORD:          
                                 return (void*)&vValue;          switch ( vType )
                         case REG_SZ:          {
                                 return (void*)strdup( vValue );          case REG_BINARY:
                         }          case REG_DWORD:
                 }                  return (void*)&vValue;
                 i++;          case REG_SZ:
                 vNameLen = 255;                  return (void*)&vValue;
                 valLen = 1024;  
         }          }
         return (void*)NULL;          return (void*)NULL;
 }  }
Line 374  void CommenceStartupProcessing( LPCTSTR Line 366  void CommenceStartupProcessing( LPCTSTR
   
         SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);          SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);
   
         // start up a thread to keep sending SERVICE_START_PENDING to the Service Control Manager          /* start up a thread to keep sending SERVICE_START_PENDING to the Service Control Manager
         // until the slapd listener is completed and listening. Only then should we send            * until the slapd listener is completed and listening. Only then should we send 
         // SERVICE_RUNNING to the Service Control Manager.           * SERVICE_RUNNING to the Service Control Manager. */
         ldap_pvt_thread_cond_init( &started_event );          ldap_pvt_thread_cond_init( &started_event );
         if ( started_event == NULL)          if ( started_event == NULL)
         {          {
                 // failed to create the event to determine when the startup process is complete so                  /* failed to create the event to determine when the startup process is complete so
                 // tell the Service Control Manager to wait another 30 seconds before deploying its                   * tell the Service Control Manager to wait another 30 seconds before deploying its
                 // assasin                   * assasin  */
                 SLAPDServiceStatus.dwCheckPoint++;                  SLAPDServiceStatus.dwCheckPoint++;
                 SLAPDServiceStatus.dwWaitHint = THIRTY_SECONDS;                  SLAPDServiceStatus.dwWaitHint = THIRTY_SECONDS;
                 SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);                  SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);
         }          }
         else          else
         {          {
                 // start a thread to report the progress to the service control manager                   /* start a thread to report the progress to the service control manager 
                 // until the started_event is fired.                   * until the started_event is fired.  */
                 if ( ldap_pvt_thread_create( &start_status_tid, 0, start_status_routine, NULL ) == 0 )                  if ( ldap_pvt_thread_create( &start_status_tid, 0, start_status_routine, NULL ) == 0 )
                 {                  {
                                                   
                 }                  }
                 else {                  else {
                         // failed to create the thread that tells the Service Control Manager that the                          /* failed to create the thread that tells the Service Control Manager that the
                         // service startup is proceeding.                            * service startup is proceeding. 
                         // tell the Service Control Manager to wait another 30 seconds before deploying its                           * tell the Service Control Manager to wait another 30 seconds before deploying its
                         // assasin.                           * assasin.  */
                         SLAPDServiceStatus.dwCheckPoint++;                          SLAPDServiceStatus.dwCheckPoint++;
                         SLAPDServiceStatus.dwWaitHint = THIRTY_SECONDS;                          SLAPDServiceStatus.dwWaitHint = THIRTY_SECONDS;
                         SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);                          SetServiceStatus(hSLAPDServiceStatus, &SLAPDServiceStatus);
Line 411  void ReportSlapdShutdownComplete(  ) Line 403  void ReportSlapdShutdownComplete(  )
 {  {
         if ( is_NT_Service )          if ( is_NT_Service )
         {          {
                 // stop sending SERVICE_STOP_PENDING messages to the Service Control Manager                  /* stop sending SERVICE_STOP_PENDING messages to the Service Control Manager */
                 ldap_pvt_thread_cond_signal( &stopped_event );                  ldap_pvt_thread_cond_signal( &stopped_event );
                 ldap_pvt_thread_cond_destroy( &stopped_event );                  ldap_pvt_thread_cond_destroy( &stopped_event );
   
                 // wait for the thread sending the SERVICE_STOP_PENDING messages to the Service Control Manager to die.                  /* wait for the thread sending the SERVICE_STOP_PENDING messages to the Service Control Manager to die.
                 // if the wait fails then put ourselves to sleep for half the Service Control Manager update interval                   * if the wait fails then put ourselves to sleep for half the Service Control Manager update interval */
                 if (ldap_pvt_thread_join( stop_status_tid, (void *) NULL ) == -1)                  if (ldap_pvt_thread_join( stop_status_tid, (void *) NULL ) == -1)
                         ldap_pvt_thread_sleep( SCM_NOTIFICATION_INTERVAL / 2 );                          ldap_pvt_thread_sleep( SCM_NOTIFICATION_INTERVAL / 2 );
   

Removed from v.1.2  
changed lines
  Added in v.1.3


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org