git.sur5r.net Git - openldap/blob - libraries/liblutil/ntservice.c

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 1998-2017 The OpenLDAP Foundation.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted only as authorized by the OpenLDAP
   9  * Public License.
  10  *
  11  * A copy of this license is available in the file LICENSE in the
  12  * top-level directory of the distribution or, alternatively, at
  13  * <http://www.OpenLDAP.org/license.html>.
  14  */
  15
  16 /*
  17  * NT Service manager utilities for OpenLDAP services
  18  */
  19
  20 #include "portable.h"
  21
  22 #ifdef HAVE_NT_SERVICE_MANAGER
  23
  24 #include <ac/stdlib.h>
  25 #include <ac/string.h>
  26
  27 #include <stdio.h>
  28
  29 #include <windows.h>
  30 #include <winsvc.h>
  31
  32 #include <ldap.h>
  33
  34 #include "ldap_pvt_thread.h"
  35
  36 #include "ldap_defaults.h"
  37
  38 #include "slapdmsg.h"
  39
  40 #define SCM_NOTIFICATION_INTERVAL       5000
  41 #define THIRTY_SECONDS                          (30 * 1000)
  42
  43 int       is_NT_Service;        /* is this is an NT service? */
  44
  45 SERVICE_STATUS                  lutil_ServiceStatus;
  46 SERVICE_STATUS_HANDLE   hlutil_ServiceStatus;
  47
  48 ldap_pvt_thread_cond_t  started_event,          stopped_event;
  49 ldap_pvt_thread_t               start_status_tid,       stop_status_tid;
  50
  51 void (*stopfunc)(int);
  52
  53 static char *GetLastErrorString( void );
  54
  55 int lutil_srv_install(LPCTSTR lpszServiceName, LPCTSTR lpszDisplayName,
  56                 LPCTSTR lpszBinaryPathName, int auto_start)
  57 {
  58         HKEY            hKey;
  59         DWORD           dwValue, dwDisposition;
  60         SC_HANDLE       schSCManager, schService;
  61         char *sp = strrchr( lpszBinaryPathName, '\\');
  62
  63         if ( sp ) sp = strchr(sp, ' ');
  64         if ( sp ) *sp = '\0';
  65         fprintf( stderr, "The install path is %s.\n", lpszBinaryPathName );
  66         if ( sp ) *sp = ' ';
  67         if ((schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_CONNECT|SC_MANAGER_CREATE_SERVICE ) ) != NULL )
  68         {
  69                 if ((schService = CreateService(
  70                                                         schSCManager,
  71                                                         lpszServiceName,
  72                                                         lpszDisplayName,
  73                                                         SERVICE_ALL_ACCESS,
  74                                                         SERVICE_WIN32_OWN_PROCESS,
  75                                                         auto_start ? SERVICE_AUTO_START : SERVICE_DEMAND_START,
  76                                                         SERVICE_ERROR_NORMAL,
  77                                                         lpszBinaryPathName,
  78                                                         NULL, NULL, NULL, NULL, NULL)) != NULL)
  79                 {
  80                         char regpath[132];
  81                         CloseServiceHandle(schService);
  82                         CloseServiceHandle(schSCManager);
  83
  84                         snprintf( regpath, sizeof regpath,
  85                                 "SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\%s",
  86                                 lpszServiceName );
  87                         /* Create the registry key for event logging to the Windows NT event log. */
  88                         if ( RegCreateKeyEx(HKEY_LOCAL_MACHINE,
  89                                 regpath, 0,
  90                                 "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey,
  91                                 &dwDisposition) != ERROR_SUCCESS)
  92                         {
  93                                 fprintf( stderr, "RegCreateKeyEx() failed. GetLastError=%lu (%s)\n", GetLastError(), GetLastErrorString() );
  94                                 RegCloseKey(hKey);
  95                                 return(0);
  96                         }
  97                         if ( sp ) *sp = '\0';
  98                         if ( RegSetValueEx(hKey, "EventMessageFile", 0, REG_EXPAND_SZ, lpszBinaryPathName, strlen(lpszBinaryPathName) + 1) != ERROR_SUCCESS)
  99                         {
 100                                 fprintf( stderr, "RegSetValueEx(EventMessageFile) failed. GetLastError=%lu (%s)\n", GetLastError(), GetLastErrorString() );
 101                                 RegCloseKey(hKey);
 102                                 return(0);
 103                         }
 104
 105                         dwValue = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE;
 106                         if ( RegSetValueEx(hKey, "TypesSupported", 0, REG_DWORD, (LPBYTE) &dwValue, sizeof(DWORD)) != ERROR_SUCCESS)
 107                         {
 108                                 fprintf( stderr, "RegCreateKeyEx(TypesSupported) failed. GetLastError=%lu (%s)\n", GetLastError(), GetLastErrorString() );
 109                                 RegCloseKey(hKey);
 110                                 return(0);
 111                         }
 112                         RegCloseKey(hKey);
 113                         return(1);
 114                 }
 115                 else
 116                 {
 117                         fprintf( stderr, "CreateService() failed. GetLastError=%lu (%s)\n", GetLastError(), GetLastErrorString() );
 118                         CloseServiceHandle(schSCManager);
 119                         return(0);
 120                 }
 121         }
 122         else
 123                 fprintf( stderr, "OpenSCManager() failed. GetLastError=%lu (%s)\n", GetLastError(), GetLastErrorString() );
 124         return(0);
 125 }
 126
 127
 128 int lutil_srv_remove(LPCTSTR lpszServiceName, LPCTSTR lpszBinaryPathName)
 129 {
 130         SC_HANDLE schSCManager, schService;
 131
 132         fprintf( stderr, "The installed path is %s.\n", lpszBinaryPathName );
 133         if ((schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT|SC_MANAGER_CREATE_SERVICE)) != NULL )
 134         {
 135                 if ((schService = OpenService(schSCManager, lpszServiceName, DELETE)) != NULL)
 136                 {
 137                         if ( DeleteService(schService) == TRUE)
 138                         {
 139                                 CloseServiceHandle(schService);
 140                                 CloseServiceHandle(schSCManager);
 141                                 return(1);
 142                         } else {
 143                                 fprintf( stderr, "DeleteService() failed. GetLastError=%lu (%s)\n", GetLastError(), GetLastErrorString() );
 144                                 fprintf( stderr, "The %s service has not been removed.\n", lpszBinaryPathName);
 145                                 CloseServiceHandle(schService);
 146                                 CloseServiceHandle(schSCManager);
 147                                 return(0);
 148                         }
 149                 } else {
 150                         fprintf( stderr, "OpenService() failed. GetLastError=%lu (%s)\n", GetLastError(), GetLastErrorString() );
 151                         CloseServiceHandle(schSCManager);
 152                         return(0);
 153                 }
 154         }
 155         else
 156                 fprintf( stderr, "OpenSCManager() failed. GetLastError=%lu (%s)\n", GetLastError(), GetLastErrorString() );
 157         return(0);
 158 }
 159
 160
 161 #if 0 /* unused */
 162 DWORD
 163 svc_installed (LPTSTR lpszServiceName, LPTSTR lpszBinaryPathName)
 164 {
 165         char buf[256];
 166         HKEY key;
 167         DWORD rc;
 168         DWORD type;
 169         long len;
 170
 171         strcpy(buf, TEXT("SYSTEM\\CurrentControlSet\\Services\\"));
 172         strcat(buf, lpszServiceName);
 173         if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, buf, 0, KEY_QUERY_VALUE, &key) != ERROR_SUCCESS)
 174                 return(-1);
 175
 176         rc = 0;
 177         if (lpszBinaryPathName) {
 178                 len = sizeof(buf);
 179                 if (RegQueryValueEx(key, "ImagePath", NULL, &type, buf, &len) == ERROR_SUCCESS) {
 180                         if (strcmp(lpszBinaryPathName, buf))
 181                                 rc = -1;
 182                 }
 183         }
 184         RegCloseKey(key);
 185         return(rc);
 186 }
 187
 188
 189 DWORD
 190 svc_running (LPTSTR lpszServiceName)
 191 {
 192         SC_HANDLE service;
 193         SC_HANDLE scm;
 194         DWORD rc;
 195         SERVICE_STATUS ss;
 196
 197         if (!(scm = OpenSCManager(NULL, NULL, GENERIC_READ)))
 198                 return(GetLastError());
 199
 200         rc = 1;
 201         service = OpenService(scm, lpszServiceName, SERVICE_QUERY_STATUS);
 202         if (service) {
 203                 if (!QueryServiceStatus(service, &ss))
 204                         rc = GetLastError();
 205                 else if (ss.dwCurrentState != SERVICE_STOPPED)
 206                         rc = 0;
 207                 CloseServiceHandle(service);
 208         }
 209         CloseServiceHandle(scm);
 210         return(rc);
 211 }
 212 #endif
 213
 214 static void *start_status_routine( void *ptr )
 215 {
 216         DWORD   wait_result;
 217         int             done = 0;
 218
 219         while ( !done )
 220         {
 221                 wait_result = WaitForSingleObject( started_event, SCM_NOTIFICATION_INTERVAL );
 222                 switch ( wait_result )
 223                 {
 224                         case WAIT_ABANDONED:
 225                         case WAIT_OBJECT_0:
 226                                 /* the object that we were waiting for has been destroyed (ABANDONED) or
 227                                  * signalled (TIMEOUT_0). We can assume that the startup process is
 228                                  * complete and tell the Service Control Manager that we are now runnng */
 229                                 lutil_ServiceStatus.dwCurrentState      = SERVICE_RUNNING;
 230                                 lutil_ServiceStatus.dwWin32ExitCode     = NO_ERROR;
 231                                 lutil_ServiceStatus.dwCheckPoint++;
 232                                 lutil_ServiceStatus.dwWaitHint          = 1000;
 233                                 SetServiceStatus(hlutil_ServiceStatus, &lutil_ServiceStatus);
 234                                 done = 1;
 235                                 break;
 236                         case WAIT_TIMEOUT:
 237                                 /* We've waited for the required time, so send an update to the Service Control
 238                                  * Manager saying to wait again. */
 239                                 lutil_ServiceStatus.dwCheckPoint++;
 240                                 lutil_ServiceStatus.dwWaitHint = SCM_NOTIFICATION_INTERVAL * 2;
 241                                 SetServiceStatus(hlutil_ServiceStatus, &lutil_ServiceStatus);
 242                                 break;
 243                         case WAIT_FAILED:
 244                                 /* theres been some problem with WaitForSingleObject so tell the Service
 245                                  * Control Manager to wait 30 seconds before deploying its assasin and
 246                                  * then leave the thread. */
 247                                 lutil_ServiceStatus.dwCheckPoint++;
 248                                 lutil_ServiceStatus.dwWaitHint = THIRTY_SECONDS;
 249                                 SetServiceStatus(hlutil_ServiceStatus, &lutil_ServiceStatus);
 250                                 done = 1;
 251                                 break;
 252                 }
 253         }
 254         ldap_pvt_thread_exit(NULL);
 255         return NULL;
 256 }
 257
 258
 259
 260 static void *stop_status_routine( void *ptr )
 261 {
 262         DWORD   wait_result;
 263         int             done = 0;
 264
 265         while ( !done )
 266         {
 267                 wait_result = WaitForSingleObject( stopped_event, SCM_NOTIFICATION_INTERVAL );
 268                 switch ( wait_result )
 269                 {
 270                         case WAIT_ABANDONED:
 271                         case WAIT_OBJECT_0:
 272                                 /* the object that we were waiting for has been destroyed (ABANDONED) or
 273                                  * signalled (TIMEOUT_0). The shutting down process is therefore complete
 274                                  * and the final SERVICE_STOPPED message will be sent to the service control
 275                                  * manager prior to the process terminating. */
 276                                 done = 1;
 277                                 break;
 278                         case WAIT_TIMEOUT:
 279                                 /* We've waited for the required time, so send an update to the Service Control
 280                                  * Manager saying to wait again. */
 281                                 lutil_ServiceStatus.dwCheckPoint++;
 282                                 lutil_ServiceStatus.dwWaitHint = SCM_NOTIFICATION_INTERVAL * 2;
 283                                 SetServiceStatus(hlutil_ServiceStatus, &lutil_ServiceStatus);
 284                                 break;
 285                         case WAIT_FAILED:
 286                                 /* theres been some problem with WaitForSingleObject so tell the Service
 287                                  * Control Manager to wait 30 seconds before deploying its assasin and
 288                                  * then leave the thread. */
 289                                 lutil_ServiceStatus.dwCheckPoint++;
 290                                 lutil_ServiceStatus.dwWaitHint = THIRTY_SECONDS;
 291                                 SetServiceStatus(hlutil_ServiceStatus, &lutil_ServiceStatus);
 292                                 done = 1;
 293                                 break;
 294                 }
 295         }
 296         ldap_pvt_thread_exit(NULL);
 297         return NULL;
 298 }
 299
 300
 301
 302 static void WINAPI lutil_ServiceCtrlHandler( IN DWORD Opcode)
 303 {
 304         switch (Opcode)
 305         {
 306         case SERVICE_CONTROL_STOP:
 307         case SERVICE_CONTROL_SHUTDOWN:
 308
 309                 lutil_ServiceStatus.dwCurrentState      = SERVICE_STOP_PENDING;
 310                 lutil_ServiceStatus.dwCheckPoint++;
 311                 lutil_ServiceStatus.dwWaitHint          = SCM_NOTIFICATION_INTERVAL * 2;
 312                 SetServiceStatus(hlutil_ServiceStatus, &lutil_ServiceStatus);
 313
 314                 ldap_pvt_thread_cond_init( &stopped_event );
 315                 if ( stopped_event == NULL )
 316                 {
 317                         /* the event was not created. We will ask the service control manager for 30
 318                          * seconds to shutdown */
 319                         lutil_ServiceStatus.dwCheckPoint++;
 320                         lutil_ServiceStatus.dwWaitHint          = THIRTY_SECONDS;
 321                         SetServiceStatus(hlutil_ServiceStatus, &lutil_ServiceStatus);
 322                 }
 323                 else
 324                 {
 325                         /* start a thread to report the progress to the service control manager
 326                          * until the stopped_event is fired. */
 327                         if ( ldap_pvt_thread_create( &stop_status_tid, 0, stop_status_routine, NULL ) == 0 )
 328                         {
 329
 330                         }
 331                         else {
 332                                 /* failed to create the thread that tells the Service Control Manager that the
 333                                  * service stopping is proceeding.
 334                                  * tell the Service Control Manager to wait another 30 seconds before deploying its
 335                                  * assasin.  */
 336                                 lutil_ServiceStatus.dwCheckPoint++;
 337                                 lutil_ServiceStatus.dwWaitHint = THIRTY_SECONDS;
 338                                 SetServiceStatus(hlutil_ServiceStatus, &lutil_ServiceStatus);
 339                         }
 340                 }
 341                 stopfunc( -1 );
 342                 break;
 343
 344         case SERVICE_CONTROL_INTERROGATE:
 345                 SetServiceStatus(hlutil_ServiceStatus, &lutil_ServiceStatus);
 346                 break;
 347         }
 348         return;
 349 }
 350
 351 void *lutil_getRegParam( char *svc, char *value )
 352 {
 353         HKEY hkey;
 354         char path[255];
 355         DWORD vType;
 356         static char vValue[1024];
 357         DWORD valLen = sizeof( vValue );
 358
 359         if ( svc != NULL )
 360                 snprintf ( path, sizeof path, "SOFTWARE\\%s", svc );
 361         else
 362                 snprintf ( path, sizeof path, "SOFTWARE\\OpenLDAP\\Parameters" );
 363
 364         if ( RegOpenKeyEx( HKEY_LOCAL_MACHINE, path, 0, KEY_READ, &hkey ) != ERROR_SUCCESS )
 365         {
 366                 return NULL;
 367         }
 368
 369         if ( RegQueryValueEx( hkey, value, NULL, &vType, vValue, &valLen ) != ERROR_SUCCESS )
 370         {
 371                 RegCloseKey( hkey );
 372                 return NULL;
 373         }
 374         RegCloseKey( hkey );
 375
 376         switch ( vType )
 377         {
 378         case REG_BINARY:
 379         case REG_DWORD:
 380                 return (void*)&vValue;
 381         case REG_SZ:
 382                 return (void*)&vValue;
 383         }
 384         return (void*)NULL;
 385 }
 386
 387 void lutil_LogStartedEvent( char *svc, int slap_debug, char *configfile, char *urls )
 388 {
 389         char *Inserts[5];
 390         WORD i = 0, j;
 391         HANDLE hEventLog;
 392
 393         hEventLog = RegisterEventSource( NULL, svc );
 394
 395         Inserts[i] = (char *)malloc( 20 );
 396         itoa( slap_debug, Inserts[i++], 10 );
 397         Inserts[i++] = strdup( configfile );
 398         Inserts[i++] = strdup( urls ? urls : "ldap:///" );
 399
 400         ReportEvent( hEventLog, EVENTLOG_INFORMATION_TYPE, 0,
 401                 MSG_SVC_STARTED, NULL, i, 0, (LPCSTR *) Inserts, NULL );
 402
 403         for ( j = 0; j < i; j++ )
 404                 ldap_memfree( Inserts[j] );
 405         DeregisterEventSource( hEventLog );
 406 }
 407
 408
 409
 410 void lutil_LogStoppedEvent( char *svc )
 411 {
 412         HANDLE hEventLog;
 413
 414         hEventLog = RegisterEventSource( NULL, svc );
 415         ReportEvent( hEventLog, EVENTLOG_INFORMATION_TYPE, 0,
 416                 MSG_SVC_STOPPED, NULL, 0, 0, NULL, NULL );
 417         DeregisterEventSource( hEventLog );
 418 }
 419
 420
 421 void lutil_CommenceStartupProcessing( char *lpszServiceName,
 422                                                            void (*stopper)(int) )
 423 {
 424         hlutil_ServiceStatus = RegisterServiceCtrlHandler( lpszServiceName, (LPHANDLER_FUNCTION)lutil_ServiceCtrlHandler);
 425
 426         stopfunc = stopper;
 427
 428         /* initialize the Service Status structure */
 429         lutil_ServiceStatus.dwServiceType                               = SERVICE_WIN32_OWN_PROCESS;
 430         lutil_ServiceStatus.dwCurrentState                              = SERVICE_START_PENDING;
 431         lutil_ServiceStatus.dwControlsAccepted                  = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
 432         lutil_ServiceStatus.dwWin32ExitCode                             = NO_ERROR;
 433         lutil_ServiceStatus.dwServiceSpecificExitCode   = 0;
 434         lutil_ServiceStatus.dwCheckPoint                                        = 1;
 435         lutil_ServiceStatus.dwWaitHint                                  = SCM_NOTIFICATION_INTERVAL * 2;
 436
 437         SetServiceStatus(hlutil_ServiceStatus, &lutil_ServiceStatus);
 438
 439         /* start up a thread to keep sending SERVICE_START_PENDING to the Service Control Manager
 440          * until the slapd listener is completed and listening. Only then should we send
 441          * SERVICE_RUNNING to the Service Control Manager. */
 442         ldap_pvt_thread_cond_init( &started_event );
 443         if ( started_event == NULL)
 444         {
 445                 /* failed to create the event to determine when the startup process is complete so
 446                  * tell the Service Control Manager to wait another 30 seconds before deploying its
 447                  * assasin  */
 448                 lutil_ServiceStatus.dwCheckPoint++;
 449                 lutil_ServiceStatus.dwWaitHint = THIRTY_SECONDS;
 450                 SetServiceStatus(hlutil_ServiceStatus, &lutil_ServiceStatus);
 451         }
 452         else
 453         {
 454                 /* start a thread to report the progress to the service control manager
 455                  * until the started_event is fired.  */
 456                 if ( ldap_pvt_thread_create( &start_status_tid, 0, start_status_routine, NULL ) == 0 )
 457                 {
 458
 459                 }
 460                 else {
 461                         /* failed to create the thread that tells the Service Control Manager that the
 462                          * service startup is proceeding.
 463                          * tell the Service Control Manager to wait another 30 seconds before deploying its
 464                          * assasin.  */
 465                         lutil_ServiceStatus.dwCheckPoint++;
 466                         lutil_ServiceStatus.dwWaitHint = THIRTY_SECONDS;
 467                         SetServiceStatus(hlutil_ServiceStatus, &lutil_ServiceStatus);
 468                 }
 469         }
 470 }
 471
 472 void lutil_ReportShutdownComplete(  )
 473 {
 474         if ( is_NT_Service )
 475         {
 476                 /* stop sending SERVICE_STOP_PENDING messages to the Service Control Manager */
 477                 ldap_pvt_thread_cond_signal( &stopped_event );
 478                 ldap_pvt_thread_cond_destroy( &stopped_event );
 479
 480                 /* wait for the thread sending the SERVICE_STOP_PENDING messages to the Service Control Manager to die.
 481                  * if the wait fails then put ourselves to sleep for half the Service Control Manager update interval */
 482                 if (ldap_pvt_thread_join( stop_status_tid, (void *) NULL ) == -1)
 483                         ldap_pvt_thread_sleep( SCM_NOTIFICATION_INTERVAL / 2 );
 484
 485                 lutil_ServiceStatus.dwCurrentState = SERVICE_STOPPED;
 486                 lutil_ServiceStatus.dwCheckPoint++;
 487                 lutil_ServiceStatus.dwWaitHint = SCM_NOTIFICATION_INTERVAL;
 488                 SetServiceStatus(hlutil_ServiceStatus, &lutil_ServiceStatus);
 489         }
 490 }
 491
 492 static char *GetErrorString( int err )
 493 {
 494         static char msgBuf[1024];
 495
 496         FormatMessage(
 497                 FORMAT_MESSAGE_FROM_SYSTEM,
 498                 NULL,
 499                 err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 500                 msgBuf, 1024, NULL );
 501
 502         return msgBuf;
 503 }
 504
 505 static char *GetLastErrorString( void )
 506 {
 507         return GetErrorString( GetLastError() );
 508 }
 509 #endif