Return to winsvc.h CVS log

Up to [WindowsNT SDKs] / mstools / h

Annotation of mstools/h/winsvc.h, revision 1.1

1.1     ! root        1: /*++ BUILD Version: 0009    // Increment this if a change has global effects
        !             2: 
        !             3: Copyright (c) 1992  Microsoft Corporation
        !             4: 
        !             5: Module Name:
        !             6: 
        !             7:     winsvc.h
        !             8: 
        !             9: Abstract:
        !            10: 
        !            11:     Header file for the Service Control Manager
        !            12: 
        !            13: Author:
        !            14: 
        !            15:     Dan Lafferty (danl) 19-Jan-1992
        !            16: 
        !            17: Environment:
        !            18: 
        !            19:     User Mode - Win32
        !            20: 
        !            21: Revision History:
        !            22: 
        !            23:     19-Jan-1992 danl
        !            24:          Created
        !            25: 
        !            26: --*/
        !            27: #ifndef _WINSVC_
        !            28: #define _WINSVC_
        !            29: 
        !            30: //
        !            31: // Constants
        !            32: //
        !            33: 
        !            34: //
        !            35: // Service database names
        !            36: //
        !            37: 
        !            38: #define SERVICES_ACTIVE_DATABASEW      L"ServicesActive"
        !            39: #define SERVICES_FAILED_DATABASEW      L"ServicesFailed"
        !            40: 
        !            41: #define SERVICES_ACTIVE_DATABASEA      "ServicesActive"
        !            42: #define SERVICES_FAILED_DATABASEA      "ServicesFailed"
        !            43: 
        !            44: #ifdef UNICODE
        !            45: 
        !            46: #define SERVICES_ACTIVE_DATABASE       SERVICES_ACTIVE_DATABASEW
        !            47: #define SERVICES_FAILED_DATABASE       SERVICES_FAILED_DATABASEW
        !            48: 
        !            49: #else // ndef UNICODE
        !            50: 
        !            51: #define SERVICES_ACTIVE_DATABASE       SERVICES_ACTIVE_DATABASEA
        !            52: #define SERVICES_FAILED_DATABASE       SERVICES_FAILED_DATABASEA
        !            53: 
        !            54: #endif // ndef UNICODE
        !            55: 
        !            56: //
        !            57: // Value to indicate no change to an optional parameter
        !            58: //
        !            59: #define SERVICE_NO_CHANGE              0xffffffff
        !            60: 
        !            61: //
        !            62: // Service State -- for Enum Requests (Bit Mask)
        !            63: //
        !            64: #define SERVICE_ACTIVE                 0x00000001
        !            65: #define SERVICE_INACTIVE               0x00000002
        !            66: #define SERVICE_STATE_ALL              (SERVICE_ACTIVE   | \
        !            67:                                         SERVICE_INACTIVE)
        !            68: 
        !            69: //
        !            70: // Controls
        !            71: //
        !            72: #define SERVICE_CONTROL_STOP           0x00000001
        !            73: #define SERVICE_CONTROL_PAUSE          0x00000002
        !            74: #define SERVICE_CONTROL_CONTINUE       0x00000003
        !            75: #define SERVICE_CONTROL_INTERROGATE    0x00000004
        !            76: 
        !            77: //
        !            78: // Service State -- for CurrentState
        !            79: //
        !            80: #define SERVICE_STOPPED                0x00000001
        !            81: #define SERVICE_START_PENDING          0x00000002
        !            82: #define SERVICE_STOP_PENDING           0x00000003
        !            83: #define SERVICE_RUNNING                0x00000004
        !            84: #define SERVICE_CONTINUE_PENDING       0x00000005
        !            85: #define SERVICE_PAUSE_PENDING          0x00000006
        !            86: #define SERVICE_PAUSED                 0x00000007
        !            87: 
        !            88: //
        !            89: // Controls Accepted  (Bit Mask)
        !            90: //
        !            91: #define SERVICE_ACCEPT_STOP            0x00000001
        !            92: #define SERVICE_ACCEPT_PAUSE_CONTINUE  0x00000002
        !            93: 
        !            94: //
        !            95: // Service Control Manager object specific access types
        !            96: //
        !            97: #define SC_MANAGER_CONNECT             0x0001
        !            98: #define SC_MANAGER_CREATE_SERVICE      0x0002
        !            99: #define SC_MANAGER_ENUMERATE_SERVICE   0x0004
        !           100: #define SC_MANAGER_LOCK                0x0008
        !           101: #define SC_MANAGER_QUERY_LOCK_STATUS   0x0010
        !           102: #define SC_MANAGER_MODIFY_BOOT_CONFIG  0x0020
        !           103: 
        !           104: #define SC_MANAGER_ALL_ACCESS          (STANDARD_RIGHTS_REQUIRED      | \
        !           105:                                         SC_MANAGER_CONNECT            | \
        !           106:                                         SC_MANAGER_CREATE_SERVICE     | \
        !           107:                                         SC_MANAGER_ENUMERATE_SERVICE  | \
        !           108:                                         SC_MANAGER_LOCK               | \
        !           109:                                         SC_MANAGER_QUERY_LOCK_STATUS  | \
        !           110:                                         SC_MANAGER_MODIFY_BOOT_CONFIG)
        !           111: 
        !           112: 
        !           113: 
        !           114: //
        !           115: // Service object specific access type
        !           116: //
        !           117: #define SERVICE_QUERY_CONFIG           0x0001
        !           118: #define SERVICE_CHANGE_CONFIG          0x0002
        !           119: #define SERVICE_QUERY_STATUS           0x0004
        !           120: #define SERVICE_ENUMERATE_DEPENDENTS   0x0008
        !           121: #define SERVICE_START                  0x0010
        !           122: #define SERVICE_STOP                   0x0020
        !           123: #define SERVICE_PAUSE_CONTINUE         0x0040
        !           124: #define SERVICE_INTERROGATE            0x0080
        !           125: 
        !           126: #define SERVICE_ALL_ACCESS             (STANDARD_RIGHTS_REQUIRED     | \
        !           127:                                         SERVICE_QUERY_CONFIG         | \
        !           128:                                         SERVICE_CHANGE_CONFIG        | \
        !           129:                                         SERVICE_QUERY_STATUS         | \
        !           130:                                         SERVICE_ENUMERATE_DEPENDENTS | \
        !           131:                                         SERVICE_START                | \
        !           132:                                         SERVICE_STOP                 | \
        !           133:                                         SERVICE_PAUSE_CONTINUE       | \
        !           134:                                         SERVICE_INTERROGATE)
        !           135: 
        !           136: 
        !           137: //
        !           138: // Handle Types
        !           139: //
        !           140: 
        !           141: typedef HANDLE      SC_HANDLE;
        !           142: typedef SC_HANDLE   *LPSC_HANDLE;
        !           143: 
        !           144: typedef DWORD       SERVICE_STATUS_HANDLE;
        !           145: 
        !           146: //
        !           147: // Service Status Structure
        !           148: //
        !           149: 
        !           150: typedef struct _SERVICE_STATUS {
        !           151:     DWORD   dwServiceType;
        !           152:     DWORD   dwCurrentState;
        !           153:     DWORD   dwControlsAccepted;
        !           154:     DWORD   dwWin32ExitCode;
        !           155:     DWORD   dwServiceSpecificExitCode;
        !           156:     DWORD   dwCheckPoint;
        !           157:     DWORD   dwWaitHint;
        !           158: } SERVICE_STATUS, *LPSERVICE_STATUS;
        !           159: 
        !           160: 
        !           161: 
        !           162: //
        !           163: // Service Status Enumeration Structure
        !           164: //
        !           165: 
        !           166: typedef struct _ENUM_SERVICE_STATUSA {
        !           167:     LPSTR          lpServiceName;
        !           168:     SERVICE_STATUS ServiceStatus;
        !           169: } ENUM_SERVICE_STATUSA, *LPENUM_SERVICE_STATUSA;
        !           170: typedef struct _ENUM_SERVICE_STATUSW {
        !           171:     LPWSTR         lpServiceName;
        !           172:     SERVICE_STATUS ServiceStatus;
        !           173: } ENUM_SERVICE_STATUSW, *LPENUM_SERVICE_STATUSW;
        !           174: #ifdef UNICODE
        !           175: #define ENUM_SERVICE_STATUS ENUM_SERVICE_STATUSW
        !           176: #define LPENUM_SERVICE_STATUS LPENUM_SERVICE_STATUSW
        !           177: #else
        !           178: #define ENUM_SERVICE_STATUS ENUM_SERVICE_STATUSA
        !           179: #define LPENUM_SERVICE_STATUS LPENUM_SERVICE_STATUSA
        !           180: #endif // UNICODE
        !           181: 
        !           182: 
        !           183: //
        !           184: // Structures for the Lock API functions
        !           185: //
        !           186: 
        !           187: typedef LPVOID  SC_LOCK;
        !           188: 
        !           189: typedef struct _QUERY_SERVICE_LOCK_STATUSA {
        !           190:     DWORD   fIsLocked;
        !           191:     LPSTR   lpLockOwner;
        !           192:     DWORD   dwLockDuration;
        !           193: } QUERY_SERVICE_LOCK_STATUSA, *LPQUERY_SERVICE_LOCK_STATUSA;
        !           194: typedef struct _QUERY_SERVICE_LOCK_STATUSW {
        !           195:     DWORD   fIsLocked;
        !           196:     LPWSTR  lpLockOwner;
        !           197:     DWORD   dwLockDuration;
        !           198: } QUERY_SERVICE_LOCK_STATUSW, *LPQUERY_SERVICE_LOCK_STATUSW;
        !           199: #ifdef UNICODE
        !           200: #define QUERY_SERVICE_LOCK_STATUS QUERY_SERVICE_LOCK_STATUSW
        !           201: #define LPQUERY_SERVICE_LOCK_STATUS LPQUERY_SERVICE_LOCK_STATUSW
        !           202: #else
        !           203: #define QUERY_SERVICE_LOCK_STATUS QUERY_SERVICE_LOCK_STATUSA
        !           204: #define LPQUERY_SERVICE_LOCK_STATUS LPQUERY_SERVICE_LOCK_STATUSA
        !           205: #endif // UNICODE
        !           206: 
        !           207: 
        !           208: 
        !           209: //
        !           210: // Query Service Configuration Structure
        !           211: //
        !           212: 
        !           213: typedef struct _QUERY_SERVICE_CONFIGA {
        !           214:     DWORD   dwServiceType;
        !           215:     DWORD   dwStartType;
        !           216:     DWORD   dwErrorControl;
        !           217:     LPSTR   lpBinaryPathName;
        !           218:     LPSTR   lpLoadOrderGroup;
        !           219:     LPSTR   lpDependencies;
        !           220:     LPSTR   lpServiceStartName;
        !           221: } QUERY_SERVICE_CONFIGA, *LPQUERY_SERVICE_CONFIGA;
        !           222: typedef struct _QUERY_SERVICE_CONFIGW {
        !           223:     DWORD   dwServiceType;
        !           224:     DWORD   dwStartType;
        !           225:     DWORD   dwErrorControl;
        !           226:     LPWSTR  lpBinaryPathName;
        !           227:     LPWSTR  lpLoadOrderGroup;
        !           228:     LPWSTR  lpDependencies;
        !           229:     LPWSTR  lpServiceStartName;
        !           230: } QUERY_SERVICE_CONFIGW, *LPQUERY_SERVICE_CONFIGW;
        !           231: #ifdef UNICODE
        !           232: #define QUERY_SERVICE_CONFIG QUERY_SERVICE_CONFIGW
        !           233: #define LPQUERY_SERVICE_CONFIG LPQUERY_SERVICE_CONFIGW
        !           234: #else
        !           235: #define QUERY_SERVICE_CONFIG QUERY_SERVICE_CONFIGA
        !           236: #define LPQUERY_SERVICE_CONFIG LPQUERY_SERVICE_CONFIGA
        !           237: #endif // UNICODE
        !           238: 
        !           239: 
        !           240: 
        !           241: //
        !           242: // Function Prototype for the Service Main Function
        !           243: //
        !           244: 
        !           245: typedef VOID (*LPSERVICE_MAIN_FUNCTIONW)(
        !           246:     DWORD   dwNumServicesArgs,
        !           247:     LPWSTR  *lpServiceArgVectors
        !           248:     );
        !           249: 
        !           250: typedef VOID (*LPSERVICE_MAIN_FUNCTIONA)(
        !           251:     DWORD   dwNumServicesArgs,
        !           252:     LPSTR   *lpServiceArgVectors
        !           253:     );
        !           254: 
        !           255: #ifdef UNICODE
        !           256: #define LPSERVICE_MAIN_FUNCTION LPSERVICE_MAIN_FUNCTIONW
        !           257: #else
        !           258: #define LPSERVICE_MAIN_FUNCTION LPSERVICE_MAIN_FUNCTIONA
        !           259: #endif //UNICODE
        !           260: 
        !           261: 
        !           262: //
        !           263: // Service Start Table
        !           264: //
        !           265: 
        !           266: typedef struct _SERVICE_TABLE_ENTRYA {
        !           267:     LPSTR                       lpServiceName;
        !           268:     LPSERVICE_MAIN_FUNCTIONA    lpServiceProc;
        !           269: }SERVICE_TABLE_ENTRYA, *LPSERVICE_TABLE_ENTRYA;
        !           270: typedef struct _SERVICE_TABLE_ENTRYW {
        !           271:     LPWSTR                      lpServiceName;
        !           272:     LPSERVICE_MAIN_FUNCTIONW    lpServiceProc;
        !           273: }SERVICE_TABLE_ENTRYW, *LPSERVICE_TABLE_ENTRYW;
        !           274: #ifdef UNICODE
        !           275: #define SERVICE_TABLE_ENTRY SERVICE_TABLE_ENTRYW
        !           276: #define LPSERVICE_TABLE_ENTRY LPSERVICE_TABLE_ENTRYW
        !           277: #else
        !           278: #define SERVICE_TABLE_ENTRY SERVICE_TABLE_ENTRYA
        !           279: #define LPSERVICE_TABLE_ENTRY LPSERVICE_TABLE_ENTRYA
        !           280: #endif // UNICODE
        !           281: 
        !           282: //
        !           283: // Prototype for the Service Control Handler Function
        !           284: //
        !           285: 
        !           286: typedef VOID (*LPHANDLER_FUNCTION)(
        !           287:     DWORD    dwControl
        !           288:     );
        !           289: 
        !           290: 
        !           291: 
        !           292: ///////////////////////////////////////////////////////////////////////////
        !           293: // API Function Prototypes
        !           294: ///////////////////////////////////////////////////////////////////////////
        !           295: 
        !           296: BOOL
        !           297: WINAPI
        !           298: ChangeServiceConfigA(
        !           299:     SC_HANDLE    hService,
        !           300:     DWORD        dwServiceType,
        !           301:     DWORD        dwStartType,
        !           302:     DWORD        dwErrorControl,
        !           303:     LPCSTR     lpBinaryPathName,
        !           304:     LPCSTR     lpLoadOrderGroup,
        !           305:     LPCSTR     lpDependencies,
        !           306:     LPCSTR     lpServiceStartName,
        !           307:     LPCSTR     lpPassword
        !           308:     );
        !           309: BOOL
        !           310: WINAPI
        !           311: ChangeServiceConfigW(
        !           312:     SC_HANDLE    hService,
        !           313:     DWORD        dwServiceType,
        !           314:     DWORD        dwStartType,
        !           315:     DWORD        dwErrorControl,
        !           316:     LPCWSTR     lpBinaryPathName,
        !           317:     LPCWSTR     lpLoadOrderGroup,
        !           318:     LPCWSTR     lpDependencies,
        !           319:     LPCWSTR     lpServiceStartName,
        !           320:     LPCWSTR     lpPassword
        !           321:     );
        !           322: #ifdef UNICODE
        !           323: #define ChangeServiceConfig ChangeServiceConfigW
        !           324: #else
        !           325: #define ChangeServiceConfig ChangeServiceConfigA
        !           326: #endif // !UNICODE
        !           327: 
        !           328: BOOL
        !           329: WINAPI
        !           330: CloseServiceHandle(
        !           331:     SC_HANDLE   hSCObject
        !           332:     );
        !           333: 
        !           334: BOOL
        !           335: WINAPI
        !           336: ControlService(
        !           337:     SC_HANDLE           hService,
        !           338:     DWORD               dwControl,
        !           339:     LPSERVICE_STATUS    lpServiceStatus
        !           340:     );
        !           341: 
        !           342: SC_HANDLE
        !           343: WINAPI
        !           344: CreateServiceA(
        !           345:     SC_HANDLE    hSCManager,
        !           346:     LPCSTR     lpServiceName,
        !           347:     DWORD        dwDesiredAccess,
        !           348:     DWORD        dwServiceType,
        !           349:     DWORD        dwStartType,
        !           350:     DWORD        dwErrorControl,
        !           351:     LPCSTR     lpBinaryPathName,
        !           352:     LPCSTR     lpLoadOrderGroup,
        !           353:     LPCSTR     lpDependencies,
        !           354:     LPCSTR     lpServiceStartName,
        !           355:     LPCSTR     lpPassword
        !           356:     );
        !           357: SC_HANDLE
        !           358: WINAPI
        !           359: CreateServiceW(
        !           360:     SC_HANDLE    hSCManager,
        !           361:     LPCWSTR     lpServiceName,
        !           362:     DWORD        dwDesiredAccess,
        !           363:     DWORD        dwServiceType,
        !           364:     DWORD        dwStartType,
        !           365:     DWORD        dwErrorControl,
        !           366:     LPCWSTR     lpBinaryPathName,
        !           367:     LPCWSTR     lpLoadOrderGroup,
        !           368:     LPCWSTR     lpDependencies,
        !           369:     LPCWSTR     lpServiceStartName,
        !           370:     LPCWSTR     lpPassword
        !           371:     );
        !           372: #ifdef UNICODE
        !           373: #define CreateService CreateServiceW
        !           374: #else
        !           375: #define CreateService CreateServiceA
        !           376: #endif // !UNICODE
        !           377: 
        !           378: BOOL
        !           379: WINAPI
        !           380: DeleteService(
        !           381:     SC_HANDLE   hService
        !           382:     );
        !           383: 
        !           384: BOOL
        !           385: WINAPI
        !           386: EnumDependentServicesA(
        !           387:     SC_HANDLE               hService,
        !           388:     DWORD                   dwServiceState,
        !           389:     LPENUM_SERVICE_STATUSA  lpServices,
        !           390:     DWORD                   cbBufSize,
        !           391:     LPDWORD                 pcbBytesNeeded,
        !           392:     LPDWORD                 lpServicesReturned
        !           393:     );
        !           394: BOOL
        !           395: WINAPI
        !           396: EnumDependentServicesW(
        !           397:     SC_HANDLE               hService,
        !           398:     DWORD                   dwServiceState,
        !           399:     LPENUM_SERVICE_STATUSW  lpServices,
        !           400:     DWORD                   cbBufSize,
        !           401:     LPDWORD                 pcbBytesNeeded,
        !           402:     LPDWORD                 lpServicesReturned
        !           403:     );
        !           404: #ifdef UNICODE
        !           405: #define EnumDependentServices EnumDependentServicesW
        !           406: #else
        !           407: #define EnumDependentServices EnumDependentServicesA
        !           408: #endif // !UNICODE
        !           409: 
        !           410: BOOL
        !           411: WINAPI
        !           412: EnumServicesStatusA(
        !           413:     SC_HANDLE               hSCManager,
        !           414:     DWORD                   dwServiceType,
        !           415:     DWORD                   dwServiceState,
        !           416:     LPENUM_SERVICE_STATUSA  lpServices,
        !           417:     DWORD                   cbBufSize,
        !           418:     LPDWORD                 pcbBytesNeeded,
        !           419:     LPDWORD                 lpServicesReturned,
        !           420:     LPDWORD                 lpResumeHandle
        !           421:     );
        !           422: BOOL
        !           423: WINAPI
        !           424: EnumServicesStatusW(
        !           425:     SC_HANDLE               hSCManager,
        !           426:     DWORD                   dwServiceType,
        !           427:     DWORD                   dwServiceState,
        !           428:     LPENUM_SERVICE_STATUSW  lpServices,
        !           429:     DWORD                   cbBufSize,
        !           430:     LPDWORD                 pcbBytesNeeded,
        !           431:     LPDWORD                 lpServicesReturned,
        !           432:     LPDWORD                 lpResumeHandle
        !           433:     );
        !           434: #ifdef UNICODE
        !           435: #define EnumServicesStatus EnumServicesStatusW
        !           436: #else
        !           437: #define EnumServicesStatus EnumServicesStatusA
        !           438: #endif // !UNICODE
        !           439: 
        !           440: SC_LOCK
        !           441: WINAPI
        !           442: LockServiceDatabase(
        !           443:     SC_HANDLE   hSCManager
        !           444:     );
        !           445: 
        !           446: BOOL
        !           447: WINAPI
        !           448: NotifyBootConfigStatus(
        !           449:     BOOL     BootAcceptable
        !           450:     );
        !           451: 
        !           452: SC_HANDLE
        !           453: WINAPI
        !           454: OpenSCManagerA(
        !           455:     LPCSTR lpMachineName,
        !           456:     LPCSTR lpDatabaseName,
        !           457:     DWORD   dwDesiredAccess
        !           458:     );
        !           459: SC_HANDLE
        !           460: WINAPI
        !           461: OpenSCManagerW(
        !           462:     LPCWSTR lpMachineName,
        !           463:     LPCWSTR lpDatabaseName,
        !           464:     DWORD   dwDesiredAccess
        !           465:     );
        !           466: #ifdef UNICODE
        !           467: #define OpenSCManager OpenSCManagerW
        !           468: #else
        !           469: #define OpenSCManager OpenSCManagerA
        !           470: #endif // !UNICODE
        !           471: 
        !           472: SC_HANDLE
        !           473: WINAPI
        !           474: OpenServiceA(
        !           475:     SC_HANDLE   hSCManager,
        !           476:     LPCSTR    lpServiceName,
        !           477:     DWORD       dwDesiredAccess
        !           478:     );
        !           479: SC_HANDLE
        !           480: WINAPI
        !           481: OpenServiceW(
        !           482:     SC_HANDLE   hSCManager,
        !           483:     LPCWSTR    lpServiceName,
        !           484:     DWORD       dwDesiredAccess
        !           485:     );
        !           486: #ifdef UNICODE
        !           487: #define OpenService OpenServiceW
        !           488: #else
        !           489: #define OpenService OpenServiceA
        !           490: #endif // !UNICODE
        !           491: 
        !           492: BOOL
        !           493: WINAPI
        !           494: QueryServiceConfigA(
        !           495:     SC_HANDLE               hService,
        !           496:     LPQUERY_SERVICE_CONFIGA lpServiceConfig,
        !           497:     DWORD                   cbBufSize,
        !           498:     LPDWORD                 pcbBytesNeeded
        !           499:     );
        !           500: BOOL
        !           501: WINAPI
        !           502: QueryServiceConfigW(
        !           503:     SC_HANDLE               hService,
        !           504:     LPQUERY_SERVICE_CONFIGW lpServiceConfig,
        !           505:     DWORD                   cbBufSize,
        !           506:     LPDWORD                 pcbBytesNeeded
        !           507:     );
        !           508: #ifdef UNICODE
        !           509: #define QueryServiceConfig QueryServiceConfigW
        !           510: #else
        !           511: #define QueryServiceConfig QueryServiceConfigA
        !           512: #endif // !UNICODE
        !           513: 
        !           514: BOOL
        !           515: WINAPI
        !           516: QueryServiceLockStatusA(
        !           517:     SC_HANDLE                       hSCManager,
        !           518:     LPQUERY_SERVICE_LOCK_STATUSA    lpLockStatus,
        !           519:     DWORD                           cbBufSize,
        !           520:     LPDWORD                         pcbBytesNeeded
        !           521:     );
        !           522: BOOL
        !           523: WINAPI
        !           524: QueryServiceLockStatusW(
        !           525:     SC_HANDLE                       hSCManager,
        !           526:     LPQUERY_SERVICE_LOCK_STATUSW    lpLockStatus,
        !           527:     DWORD                           cbBufSize,
        !           528:     LPDWORD                         pcbBytesNeeded
        !           529:     );
        !           530: #ifdef UNICODE
        !           531: #define QueryServiceLockStatus QueryServiceLockStatusW
        !           532: #else
        !           533: #define QueryServiceLockStatus QueryServiceLockStatusA
        !           534: #endif // !UNICODE
        !           535: 
        !           536: BOOL
        !           537: WINAPI
        !           538: QueryServiceObjectSecurity(
        !           539:     SC_HANDLE               hService,
        !           540:     SECURITY_INFORMATION    dwSecurityInformation,
        !           541:     PSECURITY_DESCRIPTOR    lpSecurityDescriptor,
        !           542:     DWORD                   cbBufSize,
        !           543:     LPDWORD                 pcbBytesNeeded
        !           544:     );
        !           545: 
        !           546: BOOL
        !           547: WINAPI
        !           548: QueryServiceStatus(
        !           549:     SC_HANDLE           hService,
        !           550:     LPSERVICE_STATUS    lpServiceStatus
        !           551:     );
        !           552: 
        !           553: SERVICE_STATUS_HANDLE
        !           554: WINAPI
        !           555: RegisterServiceCtrlHandlerA(
        !           556:     LPCSTR             lpServiceName,
        !           557:     LPHANDLER_FUNCTION   lpHandlerProc
        !           558:     );
        !           559: SERVICE_STATUS_HANDLE
        !           560: WINAPI
        !           561: RegisterServiceCtrlHandlerW(
        !           562:     LPCWSTR             lpServiceName,
        !           563:     LPHANDLER_FUNCTION   lpHandlerProc
        !           564:     );
        !           565: #ifdef UNICODE
        !           566: #define RegisterServiceCtrlHandler RegisterServiceCtrlHandlerW
        !           567: #else
        !           568: #define RegisterServiceCtrlHandler RegisterServiceCtrlHandlerA
        !           569: #endif // !UNICODE
        !           570: 
        !           571: BOOL
        !           572: WINAPI
        !           573: SetServiceObjectSecurity(
        !           574:     SC_HANDLE               hService,
        !           575:     SECURITY_INFORMATION    dwSecurityInformation,
        !           576:     PSECURITY_DESCRIPTOR    lpSecurityDescriptor
        !           577:     );
        !           578: 
        !           579: BOOL
        !           580: WINAPI
        !           581: SetServiceStatus(
        !           582:     SERVICE_STATUS_HANDLE   hServiceStatus,
        !           583:     LPSERVICE_STATUS        lpServiceStatus
        !           584:     );
        !           585: 
        !           586: BOOL
        !           587: WINAPI
        !           588: StartServiceCtrlDispatcherA(
        !           589:     LPSERVICE_TABLE_ENTRYA    lpServiceStartTable
        !           590:     );
        !           591: BOOL
        !           592: WINAPI
        !           593: StartServiceCtrlDispatcherW(
        !           594:     LPSERVICE_TABLE_ENTRYW    lpServiceStartTable
        !           595:     );
        !           596: #ifdef UNICODE
        !           597: #define StartServiceCtrlDispatcher StartServiceCtrlDispatcherW
        !           598: #else
        !           599: #define StartServiceCtrlDispatcher StartServiceCtrlDispatcherA
        !           600: #endif // !UNICODE
        !           601: 
        !           602: 
        !           603: BOOL
        !           604: WINAPI
        !           605: StartServiceA(
        !           606:     SC_HANDLE            hService,
        !           607:     DWORD                dwNumServiceArgs,
        !           608:     LPCSTR             *lpServiceArgVectors
        !           609:     );
        !           610: BOOL
        !           611: WINAPI
        !           612: StartServiceW(
        !           613:     SC_HANDLE            hService,
        !           614:     DWORD                dwNumServiceArgs,
        !           615:     LPCWSTR             *lpServiceArgVectors
        !           616:     );
        !           617: #ifdef UNICODE
        !           618: #define StartService StartServiceW
        !           619: #else
        !           620: #define StartService StartServiceA
        !           621: #endif // !UNICODE
        !           622: 
        !           623: BOOL
        !           624: WINAPI
        !           625: UnlockServiceDatabase(
        !           626:     SC_LOCK     ScLock
        !           627:     );
        !           628: 
        !           629: 
        !           630: 
        !           631: 
        !           632: #endif // _WINSVC_

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.