release/src/router/openvpn/service-win32/service.c

   1 /*---------------------------------------------------------------------------
   2 THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
   3 ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED
   4 TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
   5 PARTICULAR PURPOSE.
   6
   7 Copyright (C) 1993 - 2000.  Microsoft Corporation.  All rights reserved.
   8
   9 MODULE:   service.c
  10
  11 PURPOSE:  Implements functions required by all Windows NT services
  12
  13 FUNCTIONS:
  14   main(int argc, char **argv);
  15   service_ctrl(DWORD dwCtrlCode);
  16   service_main(DWORD dwArgc, LPTSTR *lpszArgv);
  17   CmdInstallService();
  18   CmdRemoveService();
  19   CmdStartService();
  20   CmdDebugService(int argc, char **argv);
  21   ControlHandler ( DWORD dwCtrlType );
  22   GetLastErrorText( LPTSTR lpszBuf, DWORD dwSize );
  23
  24 ---------------------------------------------------------------------------*/
  25
  26 #include <windows.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <process.h>
  30 #include <tchar.h>
  31
  32 #include "service.h"
  33
  34 // internal variables
  35 SERVICE_STATUS          ssStatus;       // current status of the service
  36 SERVICE_STATUS_HANDLE   sshStatusHandle;
  37 DWORD                   dwErr = 0;
  38 BOOL                    bDebug = FALSE;
  39 TCHAR                   szErr[256];
  40
  41 // internal function prototypes
  42 VOID WINAPI service_ctrl(DWORD dwCtrlCode);
  43 VOID WINAPI service_main(DWORD dwArgc, LPTSTR *lpszArgv);
  44 int CmdInstallService();
  45 int CmdRemoveService();
  46 int CmdStartService();
  47 VOID CmdDebugService(int argc, char **argv);
  48 BOOL WINAPI ControlHandler ( DWORD dwCtrlType );
  49 LPTSTR GetLastErrorText( LPTSTR lpszBuf, DWORD dwSize );
  50
  51 //
  52 //  FUNCTION: main
  53 //
  54 //  PURPOSE: entrypoint for service
  55 //
  56 //  PARAMETERS:
  57 //    argc - number of command line arguments
  58 //    argv - array of command line arguments
  59 //
  60 //  RETURN VALUE:
  61 //    none
  62 //
  63 //  COMMENTS:
  64 //    main() either performs the command line task, or
  65 //    call StartServiceCtrlDispatcher to register the
  66 //    main service thread.  When the this call returns,
  67 //    the service has stopped, so exit.
  68 //
  69 int __cdecl main(int argc, char **argv)
  70 {
  71    SERVICE_TABLE_ENTRY dispatchTable[] =
  72    {
  73       { TEXT(SZSERVICENAME), (LPSERVICE_MAIN_FUNCTION)service_main},
  74       { NULL, NULL}
  75    };
  76
  77    if ( (argc > 1) &&
  78         ((*argv[1] == '-') || (*argv[1] == '/')) )
  79    {
  80       if ( _stricmp( "install", argv[1]+1 ) == 0 )
  81       {
  82          return CmdInstallService();
  83       }
  84       else if ( _stricmp( "remove", argv[1]+1 ) == 0 )
  85       {
  86          return CmdRemoveService();
  87       }
  88           else if ( _stricmp( "start", argv[1]+1 ) == 0)
  89           {
  90                   return CmdStartService();
  91       }
  92       else if ( _stricmp( "debug", argv[1]+1 ) == 0 )
  93       {
  94          bDebug = TRUE;
  95          CmdDebugService(argc, argv);
  96       }
  97       else
  98       {
  99          goto dispatch;
 100       }
 101       return 0;
 102    }
 103
 104    // if it doesn't match any of the above parameters
 105    // the service control manager may be starting the service
 106    // so we must call StartServiceCtrlDispatcher
 107    dispatch:
 108    // this is just to be friendly
 109    printf( "%s -install          to install the service\n", SZAPPNAME );
 110    printf( "%s -start                    to start the service\n", SZAPPNAME );
 111    printf( "%s -remove           to remove the service\n", SZAPPNAME );
 112    printf( "%s -debug <params>   to run as a console app for debugging\n", SZAPPNAME );
 113    printf( "\nStartServiceCtrlDispatcher being called.\n" );
 114    printf( "This may take several seconds.  Please wait.\n" );
 115
 116    if (!StartServiceCtrlDispatcher(dispatchTable))
 117       AddToMessageLog(MSG_FLAGS_ERROR, TEXT("StartServiceCtrlDispatcher failed."));
 118
 119    return 0;
 120 }
 121
 122
 123
 124 //
 125 //  FUNCTION: service_main
 126 //
 127 //  PURPOSE: To perform actual initialization of the service
 128 //
 129 //  PARAMETERS:
 130 //    dwArgc   - number of command line arguments
 131 //    lpszArgv - array of command line arguments
 132 //
 133 //  RETURN VALUE:
 134 //    none
 135 //
 136 //  COMMENTS:
 137 //    This routine performs the service initialization and then calls
 138 //    the user defined ServiceStart() routine to perform majority
 139 //    of the work.
 140 //
 141 void WINAPI service_main(DWORD dwArgc, LPTSTR *lpszArgv)
 142 {
 143
 144    // register our service control handler:
 145    //
 146    sshStatusHandle = RegisterServiceCtrlHandler( TEXT(SZSERVICENAME), service_ctrl);
 147
 148    if (!sshStatusHandle)
 149       goto cleanup;
 150
 151    // SERVICE_STATUS members that don't change in example
 152    //
 153    ssStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
 154    ssStatus.dwServiceSpecificExitCode = 0;
 155
 156
 157    // report the status to the service control manager.
 158    //
 159    if (!ReportStatusToSCMgr(
 160                            SERVICE_START_PENDING, // service state
 161                            NO_ERROR,              // exit code
 162                            3000))                 // wait hint
 163       goto cleanup;
 164
 165
 166    ServiceStart( dwArgc, lpszArgv );
 167
 168    cleanup:
 169
 170    // try to report the stopped status to the service control manager.
 171    //
 172    if (sshStatusHandle)
 173       (VOID)ReportStatusToSCMgr(
 174                                SERVICE_STOPPED,
 175                                dwErr,
 176                                0);
 177
 178    return;
 179 }
 180
 181
 182
 183 //
 184 //  FUNCTION: service_ctrl
 185 //
 186 //  PURPOSE: This function is called by the SCM whenever
 187 //           ControlService() is called on this service.
 188 //
 189 //  PARAMETERS:
 190 //    dwCtrlCode - type of control requested
 191 //
 192 //  RETURN VALUE:
 193 //    none
 194 //
 195 //  COMMENTS:
 196 //
 197 VOID WINAPI service_ctrl(DWORD dwCtrlCode)
 198 {
 199    // Handle the requested control code.
 200    //
 201    switch (dwCtrlCode)
 202    {
 203    // Stop the service.
 204    //
 205    // SERVICE_STOP_PENDING should be reported before
 206    // setting the Stop Event - hServerStopEvent - in
 207    // ServiceStop().  This avoids a race condition
 208    // which may result in a 1053 - The Service did not respond...
 209    // error.
 210    case SERVICE_CONTROL_STOP:
 211       ReportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR, 0);
 212       ServiceStop();
 213       return;
 214
 215       // Update the service status.
 216       //
 217    case SERVICE_CONTROL_INTERROGATE:
 218       break;
 219
 220       // invalid control code
 221       //
 222    default:
 223       break;
 224
 225    }
 226
 227    ReportStatusToSCMgr(ssStatus.dwCurrentState, NO_ERROR, 0);
 228 }
 229
 230
 231
 232 //
 233 //  FUNCTION: ReportStatusToSCMgr()
 234 //
 235 //  PURPOSE: Sets the current status of the service and
 236 //           reports it to the Service Control Manager
 237 //
 238 //  PARAMETERS:
 239 //    dwCurrentState - the state of the service
 240 //    dwWin32ExitCode - error code to report
 241 //    dwWaitHint - worst case estimate to next checkpoint
 242 //
 243 //  RETURN VALUE:
 244 //    TRUE  - success
 245 //    FALSE - failure
 246 //
 247 //  COMMENTS:
 248 //
 249 BOOL ReportStatusToSCMgr(DWORD dwCurrentState,
 250                          DWORD dwWin32ExitCode,
 251                          DWORD dwWaitHint)
 252 {
 253    static DWORD dwCheckPoint = 1;
 254    BOOL fResult = TRUE;
 255
 256
 257    if ( !bDebug ) // when debugging we don't report to the SCM
 258    {
 259       if (dwCurrentState == SERVICE_START_PENDING)
 260          ssStatus.dwControlsAccepted = 0;
 261       else
 262          ssStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
 263
 264       ssStatus.dwCurrentState = dwCurrentState;
 265       ssStatus.dwWin32ExitCode = dwWin32ExitCode;
 266       ssStatus.dwWaitHint = dwWaitHint;
 267
 268       if ( ( dwCurrentState == SERVICE_RUNNING ) ||
 269            ( dwCurrentState == SERVICE_STOPPED ) )
 270          ssStatus.dwCheckPoint = 0;
 271       else
 272          ssStatus.dwCheckPoint = dwCheckPoint++;
 273
 274
 275       // Report the status of the service to the service control manager.
 276       //
 277       if (!(fResult = SetServiceStatus( sshStatusHandle, &ssStatus)))
 278       {
 279          AddToMessageLog(MSG_FLAGS_ERROR, TEXT("SetServiceStatus"));
 280       }
 281    }
 282    return fResult;
 283 }
 284
 285
 286
 287 //
 288 //  FUNCTION: AddToMessageLog(LPTSTR lpszMsg)
 289 //
 290 //  PURPOSE: Allows any thread to log an error message
 291 //
 292 //  PARAMETERS:
 293 //    lpszMsg - text for message
 294 //
 295 //  RETURN VALUE:
 296 //    none
 297 //
 298 //  COMMENTS:
 299 //
 300 void AddToMessageLog(DWORD flags, LPTSTR lpszMsg)
 301 {
 302    TCHAR szMsg [(sizeof(SZSERVICENAME) / sizeof(TCHAR)) + 100 ];
 303    HANDLE  hEventSource;
 304    LPCSTR  lpszStrings[2];
 305
 306    if ( !bDebug )
 307    {
 308      if (flags & MSG_FLAGS_SYS_CODE)
 309       dwErr = GetLastError();
 310      else
 311        dwErr = 0;
 312
 313       // Use event logging to log the error.
 314       //
 315       hEventSource = RegisterEventSource(NULL, TEXT(SZSERVICENAME));
 316
 317       _stprintf(szMsg, TEXT("%s error: %d"), TEXT(SZSERVICENAME), (int)dwErr);
 318       lpszStrings[0] = szMsg;
 319       lpszStrings[1] = lpszMsg;
 320
 321       if (hEventSource != NULL)
 322       {
 323          ReportEvent(hEventSource, // handle of event source
 324                      // event type
 325                      (flags & MSG_FLAGS_ERROR)
 326                        ? EVENTLOG_ERROR_TYPE : EVENTLOG_INFORMATION_TYPE,
 327                      0,                    // event category
 328                      0,                    // event ID
 329                      NULL,                 // current user's SID
 330                      2,                    // strings in lpszStrings
 331                      0,                    // no bytes of raw data
 332                      lpszStrings,          // array of error strings
 333                      NULL);                // no raw data
 334
 335          (VOID) DeregisterEventSource(hEventSource);
 336       }
 337    }
 338 }
 339
 340 void ResetError (void)
 341 {
 342   dwErr = 0;
 343 }
 344
 345 ///////////////////////////////////////////////////////////////////
 346 //
 347 //  The following code handles service installation and removal
 348 //
 349
 350
 351 //
 352 //  FUNCTION: CmdInstallService()
 353 //
 354 //  PURPOSE: Installs the service
 355 //
 356 //  PARAMETERS:
 357 //    none
 358 //
 359 //  RETURN VALUE:
 360 //    0 if success
 361 //
 362 //  COMMENTS:
 363 //
 364 int CmdInstallService()
 365 {
 366    SC_HANDLE   schService;
 367    SC_HANDLE   schSCManager;
 368
 369    TCHAR szPath[512];
 370
 371    int ret = 0;
 372
 373    if ( GetModuleFileName( NULL, szPath, 512 ) == 0 )
 374    {
 375       _tprintf(TEXT("Unable to install %s - %s\n"), TEXT(SZSERVICEDISPLAYNAME), GetLastErrorText(szErr, 256));
 376       return 1;
 377    }
 378
 379    schSCManager = OpenSCManager(
 380                                NULL,                   // machine (NULL == local)
 381                                NULL,                   // database (NULL == default)
 382                                SC_MANAGER_CONNECT | SC_MANAGER_CREATE_SERVICE  // access required
 383                                );
 384    if ( schSCManager )
 385    {
 386       schService = CreateService(
 387                                 schSCManager,               // SCManager database
 388                                 TEXT(SZSERVICENAME),        // name of service
 389                                 TEXT(SZSERVICEDISPLAYNAME), // name to display
 390                                 SERVICE_QUERY_STATUS,         // desired access
 391                                 SERVICE_WIN32_OWN_PROCESS,  // service type
 392                                 SERVICE_DEMAND_START,        // start type -- alternative: SERVICE_AUTO_START
 393                                 SERVICE_ERROR_NORMAL,       // error control type
 394                                 szPath,                     // service's binary
 395                                 NULL,                       // no load ordering group
 396                                 NULL,                       // no tag identifier
 397                                 TEXT(SZDEPENDENCIES),       // dependencies
 398                                 NULL,                       // LocalSystem account
 399                                 NULL);                      // no password
 400
 401       if ( schService )
 402       {
 403          _tprintf(TEXT("%s installed.\n"), TEXT(SZSERVICEDISPLAYNAME) );
 404          CloseServiceHandle(schService);
 405       }
 406       else
 407       {
 408          _tprintf(TEXT("CreateService failed - %s\n"), GetLastErrorText(szErr, 256));
 409          ret = 1;
 410       }
 411
 412       CloseServiceHandle(schSCManager);
 413    }
 414    else
 415      {
 416       _tprintf(TEXT("OpenSCManager failed - %s\n"), GetLastErrorText(szErr,256));
 417        ret = 1;
 418      }
 419    return ret;
 420 }
 421
 422 //
 423 //  FUNCTION: CmdStartService()
 424 //
 425 //  PURPOSE: Start the service
 426 //
 427 //  PARAMETERS:
 428 //    none
 429 //
 430 //  RETURN VALUE:
 431 //    0 if success
 432 //
 433 //  COMMENTS:
 434
 435 int CmdStartService()
 436 {
 437   int ret = 0;
 438
 439   SC_HANDLE schSCManager;
 440   SC_HANDLE schService;
 441
 442
 443     // Open a handle to the SC Manager database.
 444     schSCManager = OpenSCManager(
 445        NULL,                    // local machine
 446        NULL,                    // ServicesActive database
 447        SC_MANAGER_ALL_ACCESS);  // full access rights
 448
 449     if (NULL == schSCManager) {
 450        _tprintf(TEXT("OpenSCManager failed - %s\n"), GetLastErrorText(szErr,256));
 451        ret = 1;
 452     }
 453
 454     schService = OpenService(
 455         schSCManager,          // SCM database
 456         SZSERVICENAME,         // service name
 457         SERVICE_ALL_ACCESS);
 458
 459     if (schService == NULL) {
 460       _tprintf(TEXT("OpenService failed - %s\n"), GetLastErrorText(szErr,256));
 461        ret = 1;
 462     }
 463
 464     if (!StartService(
 465             schService,  // handle to service
 466             0,           // number of arguments
 467             NULL) )      // no arguments
 468     {
 469       _tprintf(TEXT("StartService failed - %s\n"), GetLastErrorText(szErr,256));
 470        ret = 1;
 471     }
 472     else
 473         {
 474                 _tprintf(TEXT("Service Started\n"));
 475        ret = 0;
 476         }
 477     CloseServiceHandle(schService);
 478     CloseServiceHandle(schSCManager);
 479     return ret;
 480 }
 481
 482 //
 483 //  FUNCTION: CmdRemoveService()
 484 //
 485 //  PURPOSE: Stops and removes the service
 486 //
 487 //  PARAMETERS:
 488 //    none
 489 //
 490 //  RETURN VALUE:
 491 //    0 if success
 492 //
 493 //  COMMENTS:
 494 //
 495 int CmdRemoveService()
 496 {
 497    SC_HANDLE   schService;
 498    SC_HANDLE   schSCManager;
 499
 500    int ret = 0;
 501
 502    schSCManager = OpenSCManager(
 503                                NULL,                   // machine (NULL == local)
 504                                NULL,                   // database (NULL == default)
 505                                SC_MANAGER_CONNECT   // access required
 506                                );
 507    if ( schSCManager )
 508    {
 509       schService = OpenService(schSCManager, TEXT(SZSERVICENAME), DELETE | SERVICE_STOP | SERVICE_QUERY_STATUS);
 510
 511       if (schService)
 512       {
 513          // try to stop the service
 514          if ( ControlService( schService, SERVICE_CONTROL_STOP, &ssStatus ) )
 515          {
 516             _tprintf(TEXT("Stopping %s."), TEXT(SZSERVICEDISPLAYNAME));
 517             Sleep( 1000 );
 518
 519             while ( QueryServiceStatus( schService, &ssStatus ) )
 520             {
 521                if ( ssStatus.dwCurrentState == SERVICE_STOP_PENDING )
 522                {
 523                   _tprintf(TEXT("."));
 524                   Sleep( 1000 );
 525                }
 526                else
 527                   break;
 528             }
 529
 530             if ( ssStatus.dwCurrentState == SERVICE_STOPPED )
 531                _tprintf(TEXT("\n%s stopped.\n"), TEXT(SZSERVICEDISPLAYNAME) );
 532             else
 533               {
 534                _tprintf(TEXT("\n%s failed to stop.\n"), TEXT(SZSERVICEDISPLAYNAME) );
 535                 ret = 1;
 536               }
 537
 538          }
 539
 540          // now remove the service
 541          if ( DeleteService(schService) )
 542             _tprintf(TEXT("%s removed.\n"), TEXT(SZSERVICEDISPLAYNAME) );
 543          else
 544            {
 545             _tprintf(TEXT("DeleteService failed - %s\n"), GetLastErrorText(szErr,256));
 546              ret = 1;
 547            }
 548
 549
 550          CloseServiceHandle(schService);
 551       }
 552       else
 553         {
 554          _tprintf(TEXT("OpenService failed - %s\n"), GetLastErrorText(szErr,256));
 555           ret = 1;
 556         }
 557
 558       CloseServiceHandle(schSCManager);
 559    }
 560    else
 561      {
 562       _tprintf(TEXT("OpenSCManager failed - %s\n"), GetLastErrorText(szErr,256));
 563        ret = 1;
 564      }
 565    return ret;
 566 }
 567
 568
 569
 570
 571 ///////////////////////////////////////////////////////////////////
 572 //
 573 //  The following code is for running the service as a console app
 574 //
 575
 576
 577 //
 578 //  FUNCTION: CmdDebugService(int argc, char ** argv)
 579 //
 580 //  PURPOSE: Runs the service as a console application
 581 //
 582 //  PARAMETERS:
 583 //    argc - number of command line arguments
 584 //    argv - array of command line arguments
 585 //
 586 //  RETURN VALUE:
 587 //    none
 588 //
 589 //  COMMENTS:
 590 //
 591 void CmdDebugService(int argc, char ** argv)
 592 {
 593    DWORD dwArgc;
 594    LPTSTR *lpszArgv;
 595
 596 #ifdef UNICODE
 597    lpszArgv = CommandLineToArgvW(GetCommandLineW(), &(dwArgc) );
 598    if (NULL == lpszArgv)
 599    {
 600        // CommandLineToArvW failed!!
 601        _tprintf(TEXT("CmdDebugService CommandLineToArgvW returned NULL\n"));
 602        return;
 603    }
 604 #else
 605    dwArgc   = (DWORD) argc;
 606    lpszArgv = argv;
 607 #endif
 608
 609    _tprintf(TEXT("Debugging %s.\n"), TEXT(SZSERVICEDISPLAYNAME));
 610
 611    SetConsoleCtrlHandler( ControlHandler, TRUE );
 612
 613    ServiceStart( dwArgc, lpszArgv );
 614
 615 #ifdef UNICODE
 616 // Must free memory allocated for arguments
 617
 618    GlobalFree(lpszArgv);
 619 #endif // UNICODE
 620
 621 }
 622
 623
 624 //
 625 //  FUNCTION: ControlHandler ( DWORD dwCtrlType )
 626 //
 627 //  PURPOSE: Handled console control events
 628 //
 629 //  PARAMETERS:
 630 //    dwCtrlType - type of control event
 631 //
 632 //  RETURN VALUE:
 633 //    True - handled
 634 //    False - unhandled
 635 //
 636 //  COMMENTS:
 637 //
 638 BOOL WINAPI ControlHandler ( DWORD dwCtrlType )
 639 {
 640    switch ( dwCtrlType )
 641    {
 642    case CTRL_BREAK_EVENT:  // use Ctrl+C or Ctrl+Break to simulate
 643    case CTRL_C_EVENT:      // SERVICE_CONTROL_STOP in debug mode
 644       _tprintf(TEXT("Stopping %s.\n"), TEXT(SZSERVICEDISPLAYNAME));
 645       ServiceStop();
 646       return TRUE;
 647       break;
 648
 649    }
 650    return FALSE;
 651 }
 652
 653 //
 654 //  FUNCTION: GetLastErrorText
 655 //
 656 //  PURPOSE: copies error message text to string
 657 //
 658 //  PARAMETERS:
 659 //    lpszBuf - destination buffer
 660 //    dwSize - size of buffer
 661 //
 662 //  RETURN VALUE:
 663 //    destination buffer
 664 //
 665 //  COMMENTS:
 666 //
 667 LPTSTR GetLastErrorText( LPTSTR lpszBuf, DWORD dwSize )
 668 {
 669    DWORD dwRet;
 670    LPTSTR lpszTemp = NULL;
 671
 672    dwRet = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |FORMAT_MESSAGE_ARGUMENT_ARRAY,
 673                           NULL,
 674                           GetLastError(),
 675                           LANG_NEUTRAL,
 676                           (LPTSTR)&lpszTemp,
 677                           0,
 678                           NULL );
 679
 680    // supplied buffer is not long enough
 681    if ( !dwRet || ( (long)dwSize < (long)dwRet+14 ) )
 682       lpszBuf[0] = TEXT('\0');
 683    else
 684    {
 685       lpszTemp[lstrlen(lpszTemp)-2] = TEXT('\0');  //remove cr and newline character
 686       _stprintf( lpszBuf, TEXT("%s (0x%x)"), lpszTemp, (int)GetLastError() );
 687    }
 688
 689    if ( lpszTemp )
 690       LocalFree((HLOCAL) lpszTemp );
 691
 692    return lpszBuf;
 693 }