← Back to branch summary

~ubuntu-branches/ubuntu/feisty/fpc/feisty

« back to all changes in this revision

Viewing changes to packages/extra/winunits/jwawinsvc.pas

  • Committer: Bazaar Package Importer
  • Author(s): Torsten Werner
  • Date: 2007-01-27 20:08:50 UTC
  • mfrom: (1.2.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20070127200850-9mrptaqqjsx9nwa7
Tags: 2.0.4-5
* Fixed Build-Depends.
* Add myself to Uploaders in debian/control.
* Make sure that the sources are really patched before building them.
* Build unit 'libc' on powerpc too.

Show diffs side-by-side

added added

removed removed

Lines of Context:
packages/extra/winunits/jwawinsvc.pas
1
 
{******************************************************************************}
2
 
{                                                                              }
3
 
{ Services API interface Unit for Object Pascal                                }
4
 
{                                                                              }
5
 
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
6
 
{ Corporation. All Rights Reserved.                                            }
7
 
{                                                                              }
8
 
{ The original file is: winsvc.h, released June 2000. The original Pascal      }
9
 
{ code is: WinSvc.pas, released December 2000. The initial developer of the    }
10
 
{ Pascal code is Marcel van Brakel (brakelm att chello dott nl).               }
11
 
{                                                                              }
12
 
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
13
 
{ Marcel van Brakel. All Rights Reserved.                                      }
14
 
{                                                                              }
15
 
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
16
 
{                                                                              }
17
 
{ You may retrieve the latest version of this file at the Project JEDI         }
18
 
{ APILIB home page, located at http://jedi-apilib.sourceforge.net              }
19
 
{                                                                              }
20
 
{ The contents of this file are used with permission, subject to the Mozilla   }
21
 
{ Public License Version 1.1 (the "License"); you may not use this file except }
22
 
{ in compliance with the License. You may obtain a copy of the License at      }
23
 
{ http://www.mozilla.org/MPL/MPL-1.1.html                                      }
24
 
{                                                                              }
25
 
{ Software distributed under the License is distributed on an "AS IS" basis,   }
26
 
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
27
 
{ the specific language governing rights and limitations under the License.    }
28
 
{                                                                              }
29
 
{ Alternatively, the contents of this file may be used under the terms of the  }
30
 
{ GNU Lesser General Public License (the  "LGPL License"), in which case the   }
31
 
{ provisions of the LGPL License are applicable instead of those above.        }
32
 
{ If you wish to allow use of your version of this file only under the terms   }
33
 
{ of the LGPL License and not to allow others to use your version of this file }
34
 
{ under the MPL, indicate your decision by deleting  the provisions above and  }
35
 
{ replace  them with the notice and other provisions required by the LGPL      }
36
 
{ License.  If you do not delete the provisions above, a recipient may use     }
37
 
{ your version of this file under either the MPL or the LGPL License.          }
38
 
{                                                                              }
39
 
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
40
 
{                                                                              }
41
 
{******************************************************************************}
42
 
 
43
 
// $Id: jwawinsvc.pas,v 1.1 2005/04/04 07:56:11 marco Exp $
44
 
 
45
 
unit JwaWinSvc;
46
 
 
47
 
{$WEAKPACKAGEUNIT}
48
 
 
49
 
{$HPPEMIT ''}
50
 
{$HPPEMIT '#include "WinSvc.h"'}
51
 
{$HPPEMIT ''}
52
 
 
53
 
{$I jediapilib.inc}
54
 
 
55
 
interface
56
 
 
57
 
uses
58
 
  JwaWinNT, JwaWinType;
59
 
 
60
 
//
61
 
// Service database names
62
 
//
63
 
 
64
 
const
65
 
  SERVICES_ACTIVE_DATABASEW = 'ServicesActive';
66
 
  {$EXTERNALSYM SERVICES_ACTIVE_DATABASEW}
67
 
  SERVICES_FAILED_DATABASEW = 'ServicesFailed';
68
 
  {$EXTERNALSYM SERVICES_FAILED_DATABASEW}
69
 
 
70
 
  SERVICES_ACTIVE_DATABASEA = 'ServicesActive';
71
 
  {$EXTERNALSYM SERVICES_ACTIVE_DATABASEA}
72
 
  SERVICES_FAILED_DATABASEA = 'ServicesFailed';
73
 
  {$EXTERNALSYM SERVICES_FAILED_DATABASEA}
74
 
 
75
 
//
76
 
// Character to designate that a name is a group
77
 
//
78
 
 
79
 
  SC_GROUP_IDENTIFIERW = '+';
80
 
  {$EXTERNALSYM SC_GROUP_IDENTIFIERW}
81
 
  SC_GROUP_IDENTIFIERA = '+';
82
 
  {$EXTERNALSYM SC_GROUP_IDENTIFIERA}
83
 
 
84
 
  {$IFDEF UNICODE}
85
 
 
86
 
  SERVICES_ACTIVE_DATABASE = SERVICES_ACTIVE_DATABASEW;
87
 
  {$EXTERNALSYM SERVICES_ACTIVE_DATABASE}
88
 
  SERVICES_FAILED_DATABASE = SERVICES_FAILED_DATABASEW;
89
 
  {$EXTERNALSYM SERVICES_FAILED_DATABASE}
90
 
 
91
 
  SC_GROUP_IDENTIFIER = SC_GROUP_IDENTIFIERW;
92
 
  {$EXTERNALSYM SC_GROUP_IDENTIFIER}
93
 
 
94
 
  {$ELSE}
95
 
 
96
 
  SERVICES_ACTIVE_DATABASE = SERVICES_ACTIVE_DATABASEA;
97
 
  {$EXTERNALSYM SERVICES_ACTIVE_DATABASE}
98
 
  SERVICES_FAILED_DATABASE = SERVICES_FAILED_DATABASEA;
99
 
  {$EXTERNALSYM SERVICES_FAILED_DATABASE}
100
 
 
101
 
  SC_GROUP_IDENTIFIER = SC_GROUP_IDENTIFIERA;
102
 
  {$EXTERNALSYM SC_GROUP_IDENTIFIER}
103
 
 
104
 
  {$ENDIF UNICODE}
105
 
 
106
 
//
107
 
// Value to indicate no change to an optional parameter
108
 
//
109
 
 
110
 
  SERVICE_NO_CHANGE = $ffffffff;
111
 
  {$EXTERNALSYM SERVICE_NO_CHANGE}
112
 
 
113
 
//
114
 
// Service State -- for Enum Requests (Bit Mask)
115
 
//
116
 
 
117
 
  SERVICE_ACTIVE    = $00000001;
118
 
  {$EXTERNALSYM SERVICE_ACTIVE}
119
 
  SERVICE_INACTIVE  = $00000002;
120
 
  {$EXTERNALSYM SERVICE_INACTIVE}
121
 
  SERVICE_STATE_ALL = SERVICE_ACTIVE or SERVICE_INACTIVE;
122
 
  {$EXTERNALSYM SERVICE_STATE_ALL}
123
 
 
124
 
//
125
 
// Controls
126
 
//
127
 
 
128
 
  SERVICE_CONTROL_STOP                  = $00000001;
129
 
  {$EXTERNALSYM SERVICE_CONTROL_STOP}
130
 
  SERVICE_CONTROL_PAUSE                 = $00000002;
131
 
  {$EXTERNALSYM SERVICE_CONTROL_PAUSE}
132
 
  SERVICE_CONTROL_CONTINUE              = $00000003;
133
 
  {$EXTERNALSYM SERVICE_CONTROL_CONTINUE}
134
 
  SERVICE_CONTROL_INTERROGATE           = $00000004;
135
 
  {$EXTERNALSYM SERVICE_CONTROL_INTERROGATE}
136
 
  SERVICE_CONTROL_SHUTDOWN              = $00000005;
137
 
  {$EXTERNALSYM SERVICE_CONTROL_SHUTDOWN}
138
 
  SERVICE_CONTROL_PARAMCHANGE           = $00000006;
139
 
  {$EXTERNALSYM SERVICE_CONTROL_PARAMCHANGE}
140
 
  SERVICE_CONTROL_NETBINDADD            = $00000007;
141
 
  {$EXTERNALSYM SERVICE_CONTROL_NETBINDADD}
142
 
  SERVICE_CONTROL_NETBINDREMOVE         = $00000008;
143
 
  {$EXTERNALSYM SERVICE_CONTROL_NETBINDREMOVE}
144
 
  SERVICE_CONTROL_NETBINDENABLE         = $00000009;
145
 
  {$EXTERNALSYM SERVICE_CONTROL_NETBINDENABLE}
146
 
  SERVICE_CONTROL_NETBINDDISABLE        = $0000000A;
147
 
  {$EXTERNALSYM SERVICE_CONTROL_NETBINDDISABLE}
148
 
  SERVICE_CONTROL_DEVICEEVENT           = $0000000B;
149
 
  {$EXTERNALSYM SERVICE_CONTROL_DEVICEEVENT}
150
 
  SERVICE_CONTROL_HARDWAREPROFILECHANGE = $0000000C;
151
 
  {$EXTERNALSYM SERVICE_CONTROL_HARDWAREPROFILECHANGE}
152
 
  SERVICE_CONTROL_POWEREVENT            = $0000000D;
153
 
  {$EXTERNALSYM SERVICE_CONTROL_POWEREVENT}
154
 
  SERVICE_CONTROL_SESSIONCHANGE         = $0000000E;
155
 
  {$EXTERNALSYM SERVICE_CONTROL_SESSIONCHANGE}
156
 
 
157
 
//
158
 
// Service State -- for CurrentState
159
 
//
160
 
 
161
 
  SERVICE_STOPPED          = $00000001;
162
 
  {$EXTERNALSYM SERVICE_STOPPED}
163
 
  SERVICE_START_PENDING    = $00000002;
164
 
  {$EXTERNALSYM SERVICE_START_PENDING}
165
 
  SERVICE_STOP_PENDING     = $00000003;
166
 
  {$EXTERNALSYM SERVICE_STOP_PENDING}
167
 
  SERVICE_RUNNING          = $00000004;
168
 
  {$EXTERNALSYM SERVICE_RUNNING}
169
 
  SERVICE_CONTINUE_PENDING = $00000005;
170
 
  {$EXTERNALSYM SERVICE_CONTINUE_PENDING}
171
 
  SERVICE_PAUSE_PENDING    = $00000006;
172
 
  {$EXTERNALSYM SERVICE_PAUSE_PENDING}
173
 
  SERVICE_PAUSED           = $00000007;
174
 
  {$EXTERNALSYM SERVICE_PAUSED}
175
 
 
176
 
//
177
 
// Controls Accepted  (Bit Mask)
178
 
//
179
 
 
180
 
  SERVICE_ACCEPT_STOP                  = $00000001;
181
 
  {$EXTERNALSYM SERVICE_ACCEPT_STOP}
182
 
  SERVICE_ACCEPT_PAUSE_CONTINUE        = $00000002;
183
 
  {$EXTERNALSYM SERVICE_ACCEPT_PAUSE_CONTINUE}
184
 
  SERVICE_ACCEPT_SHUTDOWN              = $00000004;
185
 
  {$EXTERNALSYM SERVICE_ACCEPT_SHUTDOWN}
186
 
  SERVICE_ACCEPT_PARAMCHANGE           = $00000008;
187
 
  {$EXTERNALSYM SERVICE_ACCEPT_PARAMCHANGE}
188
 
  SERVICE_ACCEPT_NETBINDCHANGE         = $00000010;
189
 
  {$EXTERNALSYM SERVICE_ACCEPT_NETBINDCHANGE}
190
 
  SERVICE_ACCEPT_HARDWAREPROFILECHANGE = $00000020;
191
 
  {$EXTERNALSYM SERVICE_ACCEPT_HARDWAREPROFILECHANGE}
192
 
  SERVICE_ACCEPT_POWEREVENT            = $00000040;
193
 
  {$EXTERNALSYM SERVICE_ACCEPT_POWEREVENT}
194
 
  SERVICE_ACCEPT_SESSIONCHANGE         = $00000080;
195
 
  {$EXTERNALSYM SERVICE_ACCEPT_SESSIONCHANGE}
196
 
 
197
 
//
198
 
// Service Control Manager object specific access types
199
 
//
200
 
 
201
 
  SC_MANAGER_CONNECT            = $0001;
202
 
  {$EXTERNALSYM SC_MANAGER_CONNECT}
203
 
  SC_MANAGER_CREATE_SERVICE     = $0002;
204
 
  {$EXTERNALSYM SC_MANAGER_CREATE_SERVICE}
205
 
  SC_MANAGER_ENUMERATE_SERVICE  = $0004;
206
 
  {$EXTERNALSYM SC_MANAGER_ENUMERATE_SERVICE}
207
 
  SC_MANAGER_LOCK               = $0008;
208
 
  {$EXTERNALSYM SC_MANAGER_LOCK}
209
 
  SC_MANAGER_QUERY_LOCK_STATUS  = $0010;
210
 
  {$EXTERNALSYM SC_MANAGER_QUERY_LOCK_STATUS}
211
 
  SC_MANAGER_MODIFY_BOOT_CONFIG = $0020;
212
 
  {$EXTERNALSYM SC_MANAGER_MODIFY_BOOT_CONFIG}
213
 
 
214
 
  SC_MANAGER_ALL_ACCESS         = STANDARD_RIGHTS_REQUIRED or
215
 
                                  SC_MANAGER_CONNECT or
216
 
                                  SC_MANAGER_CREATE_SERVICE or
217
 
                                  SC_MANAGER_ENUMERATE_SERVICE or
218
 
                                  SC_MANAGER_LOCK or
219
 
                                  SC_MANAGER_QUERY_LOCK_STATUS or
220
 
                                  SC_MANAGER_MODIFY_BOOT_CONFIG;
221
 
  {$EXTERNALSYM SC_MANAGER_ALL_ACCESS}
222
 
 
223
 
//
224
 
// Service object specific access type
225
 
//
226
 
 
227
 
  SERVICE_QUERY_CONFIG         = $0001;
228
 
  {$EXTERNALSYM SERVICE_QUERY_CONFIG}
229
 
  SERVICE_CHANGE_CONFIG        = $0002;
230
 
  {$EXTERNALSYM SERVICE_CHANGE_CONFIG}
231
 
  SERVICE_QUERY_STATUS         = $0004;
232
 
  {$EXTERNALSYM SERVICE_QUERY_STATUS}
233
 
  SERVICE_ENUMERATE_DEPENDENTS = $0008;
234
 
  {$EXTERNALSYM SERVICE_ENUMERATE_DEPENDENTS}
235
 
  SERVICE_START                = $0010;
236
 
  {$EXTERNALSYM SERVICE_START}
237
 
  SERVICE_STOP                 = $0020;
238
 
  {$EXTERNALSYM SERVICE_STOP}
239
 
  SERVICE_PAUSE_CONTINUE       = $0040;
240
 
  {$EXTERNALSYM SERVICE_PAUSE_CONTINUE}
241
 
  SERVICE_INTERROGATE          = $0080;
242
 
  {$EXTERNALSYM SERVICE_INTERROGATE}
243
 
  SERVICE_USER_DEFINED_CONTROL = $0100;
244
 
  {$EXTERNALSYM SERVICE_USER_DEFINED_CONTROL}
245
 
 
246
 
  SERVICE_ALL_ACCESS           = STANDARD_RIGHTS_REQUIRED or
247
 
                                 SERVICE_QUERY_CONFIG or
248
 
                                 SERVICE_CHANGE_CONFIG or
249
 
                                 SERVICE_QUERY_STATUS or
250
 
                                 SERVICE_ENUMERATE_DEPENDENTS or
251
 
                                 SERVICE_START or
252
 
                                 SERVICE_STOP or
253
 
                                 SERVICE_PAUSE_CONTINUE or
254
 
                                 SERVICE_INTERROGATE or
255
 
                                 SERVICE_USER_DEFINED_CONTROL;
256
 
  {$EXTERNALSYM SERVICE_ALL_ACCESS}
257
 
 
258
 
//
259
 
// Service flags for QueryServiceStatusEx
260
 
//
261
 
 
262
 
  SERVICE_RUNS_IN_SYSTEM_PROCESS = $00000001;
263
 
  {$EXTERNALSYM SERVICE_RUNS_IN_SYSTEM_PROCESS}
264
 
 
265
 
//
266
 
// Info levels for ChangeServiceConfig2 and QueryServiceConfig2
267
 
//
268
 
 
269
 
  SERVICE_CONFIG_DESCRIPTION     = 1;
270
 
  {$EXTERNALSYM SERVICE_CONFIG_DESCRIPTION}
271
 
  SERVICE_CONFIG_FAILURE_ACTIONS = 2;
272
 
  {$EXTERNALSYM SERVICE_CONFIG_FAILURE_ACTIONS}
273
 
 
274
 
//
275
 
// Service description string
276
 
//
277
 
 
278
 
type
279
 
  LPSERVICE_DESCRIPTIONA = ^SERVICE_DESCRIPTIONA;
280
 
  {$EXTERNALSYM LPSERVICE_DESCRIPTIONA}
281
 
  _SERVICE_DESCRIPTIONA = record
282
 
    lpDescription: LPSTR;
283
 
  end;
284
 
  {$EXTERNALSYM _SERVICE_DESCRIPTIONA}
285
 
  SERVICE_DESCRIPTIONA = _SERVICE_DESCRIPTIONA;
286
 
  {$EXTERNALSYM SERVICE_DESCRIPTIONA}
287
 
  TServiceDescriptionA = SERVICE_DESCRIPTIONA;
288
 
  PServiceDescriptionA = LPSERVICE_DESCRIPTIONA;
289
 
 
290
 
//
291
 
// Service description string
292
 
//
293
 
 
294
 
  LPSERVICE_DESCRIPTIONW = ^SERVICE_DESCRIPTIONW;
295
 
  {$EXTERNALSYM LPSERVICE_DESCRIPTIONW}
296
 
  _SERVICE_DESCRIPTIONW = record
297
 
    lpDescription: LPWSTR;
298
 
  end;
299
 
  {$EXTERNALSYM _SERVICE_DESCRIPTIONW}
300
 
  SERVICE_DESCRIPTIONW = _SERVICE_DESCRIPTIONW;
301
 
  {$EXTERNALSYM SERVICE_DESCRIPTIONW}
302
 
  TServiceDescriptionW = SERVICE_DESCRIPTIONW;
303
 
  PServiceDescriptionW = LPSERVICE_DESCRIPTIONW;
304
 
 
305
 
  {$IFDEF UNICODE}
306
 
  SERVICE_DESCRIPTION = SERVICE_DESCRIPTIONW;
307
 
  {$EXTERNALSYM SERVICE_DESCRIPTION}
308
 
  LPSERVICE_DESCRIPTION = LPSERVICE_DESCRIPTIONW;
309
 
  {$EXTERNALSYM LPSERVICE_DESCRIPTION}
310
 
  TServiceDescription = TServiceDescriptionW;
311
 
  PServiceDescription = PServiceDescriptionW;
312
 
  {$ELSE}
313
 
  SERVICE_DESCRIPTION = SERVICE_DESCRIPTIONA;
314
 
  {$EXTERNALSYM SERVICE_DESCRIPTION}
315
 
  LPSERVICE_DESCRIPTION = LPSERVICE_DESCRIPTIONA;
316
 
  {$EXTERNALSYM LPSERVICE_DESCRIPTION}
317
 
  TServiceDescription = TServiceDescriptionA;
318
 
  PServiceDescription = PServiceDescriptionA;
319
 
  {$ENDIF UNICODE}
320
 
 
321
 
//
322
 
// Actions to take on service failure
323
 
//
324
 
 
325
 
  _SC_ACTION_TYPE = (SC_ACTION_NONE, SC_ACTION_RESTART, SC_ACTION_REBOOT,
326
 
    SC_ACTION_RUN_COMMAND);
327
 
  {$EXTERNALSYM _SC_ACTION_TYPE}
328
 
  SC_ACTION_TYPE = _SC_ACTION_TYPE;
329
 
  {$EXTERNALSYM SC_ACTION_TYPE}
330
 
  TScActionType = _SC_ACTION_TYPE;
331
 
 
332
 
  LPSC_ACTION = ^SC_ACTION;
333
 
  {$EXTERNALSYM LPSC_ACTION}
334
 
  _SC_ACTION = record
335
 
    Type_: SC_ACTION_TYPE;
336
 
    Delay: DWORD;
337
 
  end;
338
 
  {$EXTERNALSYM _SC_ACTION}
339
 
  SC_ACTION = _SC_ACTION;
340
 
  {$EXTERNALSYM SC_ACTION}
341
 
  TScAction = SC_ACTION;
342
 
  PScAction = LPSC_ACTION;
343
 
 
344
 
  LPSERVICE_FAILURE_ACTIONSA = ^SERVICE_FAILURE_ACTIONSA;
345
 
  {$EXTERNALSYM LPSERVICE_FAILURE_ACTIONSA}
346
 
  _SERVICE_FAILURE_ACTIONSA = record
347
 
    dwResetPeriod: DWORD;
348
 
    lpRebootMsg: LPSTR;
349
 
    lpCommand: LPSTR;
350
 
    cActions: DWORD;
351
 
    lpsaActions: LPSC_ACTION;
352
 
  end;
353
 
  {$EXTERNALSYM _SERVICE_FAILURE_ACTIONSA}
354
 
  SERVICE_FAILURE_ACTIONSA = _SERVICE_FAILURE_ACTIONSA;
355
 
  {$EXTERNALSYM SERVICE_FAILURE_ACTIONSA}
356
 
  TServiceFailureActionsA = SERVICE_FAILURE_ACTIONSA;
357
 
  PServiceFailureActionsA = LPSERVICE_FAILURE_ACTIONSA;
358
 
 
359
 
  LPSERVICE_FAILURE_ACTIONSW = ^SERVICE_FAILURE_ACTIONSW;
360
 
  {$EXTERNALSYM LPSERVICE_FAILURE_ACTIONSW}
361
 
  _SERVICE_FAILURE_ACTIONSW = record
362
 
    dwResetPeriod: DWORD;
363
 
    lpRebootMsg: LPWSTR;
364
 
    lpCommand: LPWSTR;
365
 
    cActions: DWORD;
366
 
    lpsaActions: LPSC_ACTION;
367
 
  end;
368
 
  {$EXTERNALSYM _SERVICE_FAILURE_ACTIONSW}
369
 
  SERVICE_FAILURE_ACTIONSW = _SERVICE_FAILURE_ACTIONSW;
370
 
  {$EXTERNALSYM SERVICE_FAILURE_ACTIONSW}
371
 
  TServiceFailureActionsW = SERVICE_FAILURE_ACTIONSW;
372
 
  PServiceFailureActionsW = LPSERVICE_FAILURE_ACTIONSW;
373
 
 
374
 
  {$IFDEF UNICODE}
375
 
  SERVICE_FAILURE_ACTIONS = SERVICE_FAILURE_ACTIONSW;
376
 
  {$EXTERNALSYM SERVICE_FAILURE_ACTIONS}
377
 
  LPSERVICE_FAILURE_ACTIONS = LPSERVICE_FAILURE_ACTIONSW;
378
 
  {$EXTERNALSYM LPSERVICE_FAILURE_ACTIONS}
379
 
  TServiceFailureActions = TServiceFailureActionsW;
380
 
  PServiceFailureActions = PServiceFailureActionsW;
381
 
  {$ELSE}
382
 
  SERVICE_FAILURE_ACTIONS = SERVICE_FAILURE_ACTIONSA;
383
 
  {$EXTERNALSYM SERVICE_FAILURE_ACTIONS}
384
 
  LPSERVICE_FAILURE_ACTIONS = LPSERVICE_FAILURE_ACTIONSA;
385
 
  {$EXTERNALSYM LPSERVICE_FAILURE_ACTIONS}
386
 
  TServiceFailureActions = TServiceFailureActionsA;
387
 
  PServiceFailureActions = PServiceFailureActionsA;
388
 
  {$ENDIF UNICODE}
389
 
 
390
 
//
391
 
// Handle Types
392
 
//
393
 
 
394
 
  SC_HANDLE = HANDLE;
395
 
  {$EXTERNALSYM SC_HANDLE}
396
 
  LPSC_HANDLE = ^SC_HANDLE;
397
 
  {$EXTERNALSYM LPSC_HANDLE}
398
 
 
399
 
  SERVICE_STATUS_HANDLE = HANDLE;
400
 
  {$EXTERNALSYM SERVICE_STATUS_HANDLE}
401
 
 
402
 
//
403
 
// Info levels for QueryServiceStatusEx
404
 
//
405
 
 
406
 
  _SC_STATUS_TYPE = (SC_STATUS_PROCESS_INFO);
407
 
  {$EXTERNALSYM _SC_STATUS_TYPE}
408
 
  SC_STATUS_TYPE = _SC_STATUS_TYPE;
409
 
  {$EXTERNALSYM SC_STATUS_TYPE}
410
 
 
411
 
//
412
 
// Info levels for EnumServicesStatusEx
413
 
//
414
 
 
415
 
  _SC_ENUM_TYPE = (SC_ENUM_PROCESS_INFO);
416
 
  {$EXTERNALSYM _SC_ENUM_TYPE}
417
 
  SC_ENUM_TYPE = _SC_ENUM_TYPE;
418
 
  {$EXTERNALSYM SC_ENUM_TYPE}
419
 
 
420
 
//
421
 
// Service Status Structures
422
 
//
423
 
 
424
 
  LPSERVICE_STATUS = ^SERVICE_STATUS;
425
 
  {$EXTERNALSYM LPSERVICE_STATUS}
426
 
  _SERVICE_STATUS = record
427
 
    dwServiceType: DWORD;
428
 
    dwCurrentState: DWORD;
429
 
    dwControlsAccepted: DWORD;
430
 
    dwWin32ExitCode: DWORD;
431
 
    dwServiceSpecificExitCode: DWORD;
432
 
    dwCheckPoint: DWORD;
433
 
    dwWaitHint: DWORD;
434
 
  end;
435
 
  {$EXTERNALSYM _SERVICE_STATUS}
436
 
  SERVICE_STATUS = _SERVICE_STATUS;
437
 
  {$EXTERNALSYM SERVICE_STATUS}
438
 
  TServiceStatus = SERVICE_STATUS;
439
 
  PServiceStatus = LPSERVICE_STATUS;
440
 
 
441
 
  LPSERVICE_STATUS_PROCESS = ^SERVICE_STATUS_PROCESS;
442
 
  {$EXTERNALSYM LPSERVICE_STATUS_PROCESS}
443
 
  _SERVICE_STATUS_PROCESS = record
444
 
    dwServiceType: DWORD;
445
 
    dwCurrentState: DWORD;
446
 
    dwControlsAccepted: DWORD;
447
 
    dwWin32ExitCode: DWORD;
448
 
    dwServiceSpecificExitCode: DWORD;
449
 
    dwCheckPoint: DWORD;
450
 
    dwWaitHint: DWORD;
451
 
    dwProcessId: DWORD;
452
 
    dwServiceFlags: DWORD;
453
 
  end;
454
 
  {$EXTERNALSYM _SERVICE_STATUS_PROCESS}
455
 
  SERVICE_STATUS_PROCESS = _SERVICE_STATUS_PROCESS;
456
 
  {$EXTERNALSYM SERVICE_STATUS_PROCESS}
457
 
  TServiceStatusProcess = SERVICE_STATUS_PROCESS;
458
 
  PServiceStatusProcess = LPSERVICE_STATUS_PROCESS;
459
 
 
460
 
//
461
 
// Service Status Enumeration Structure
462
 
//
463
 
 
464
 
  LPENUM_SERVICE_STATUSA = ^ENUM_SERVICE_STATUSA;
465
 
  {$EXTERNALSYM LPENUM_SERVICE_STATUSA}
466
 
  _ENUM_SERVICE_STATUSA = record
467
 
    lpServiceName: LPSTR;
468
 
    lpDisplayName: LPSTR;
469
 
    ServiceStatus: SERVICE_STATUS;
470
 
  end;
471
 
  {$EXTERNALSYM _ENUM_SERVICE_STATUSA}
472
 
  ENUM_SERVICE_STATUSA = _ENUM_SERVICE_STATUSA;
473
 
  {$EXTERNALSYM ENUM_SERVICE_STATUSA}
474
 
  TEnumServiceStatusA = ENUM_SERVICE_STATUSA;
475
 
  PEnumServiceStatusA = LPENUM_SERVICE_STATUSA;
476
 
 
477
 
  LPENUM_SERVICE_STATUSW = ^ENUM_SERVICE_STATUSW;
478
 
  {$EXTERNALSYM LPENUM_SERVICE_STATUSW}
479
 
  _ENUM_SERVICE_STATUSW = record
480
 
    lpServiceName: LPWSTR;
481
 
    lpDisplayName: LPWSTR;
482
 
    ServiceStatus: SERVICE_STATUS;
483
 
  end;
484
 
  {$EXTERNALSYM _ENUM_SERVICE_STATUSW}
485
 
  ENUM_SERVICE_STATUSW = _ENUM_SERVICE_STATUSW;
486
 
  {$EXTERNALSYM ENUM_SERVICE_STATUSW}
487
 
  TEnumServiceStatusW = ENUM_SERVICE_STATUSW;
488
 
  PEnumServiceStatusW = LPENUM_SERVICE_STATUSW;
489
 
 
490
 
  {$IFDEF UNICODE}
491
 
  ENUM_SERVICE_STATUS = ENUM_SERVICE_STATUSW;
492
 
  {$EXTERNALSYM ENUM_SERVICE_STATUS}
493
 
  LPENUM_SERVICE_STATUS = LPENUM_SERVICE_STATUSW;
494
 
  {$EXTERNALSYM LPENUM_SERVICE_STATUS}
495
 
  TEnumServiceStatus = TEnumServiceStatusW;
496
 
  PEnumServiceStatus = PEnumServiceStatusW;
497
 
  {$ELSE}
498
 
  ENUM_SERVICE_STATUS = ENUM_SERVICE_STATUSA;
499
 
  {$EXTERNALSYM ENUM_SERVICE_STATUS}
500
 
  LPENUM_SERVICE_STATUS = LPENUM_SERVICE_STATUSA;
501
 
  {$EXTERNALSYM LPENUM_SERVICE_STATUS}
502
 
  TEnumServiceStatus = TEnumServiceStatusA;
503
 
  PEnumServiceStatus = PEnumServiceStatusA;
504
 
  {$ENDIF UNICODE}
505
 
 
506
 
  LPENUM_SERVICE_STATUS_PROCESSA = ^ENUM_SERVICE_STATUS_PROCESSA;
507
 
  {$EXTERNALSYM LPENUM_SERVICE_STATUS_PROCESSA}
508
 
  _ENUM_SERVICE_STATUS_PROCESSA = record
509
 
    lpServiceName: LPSTR;
510
 
    lpDisplayName: LPSTR;
511
 
    ServiceStatusProcess: SERVICE_STATUS_PROCESS;
512
 
  end;
513
 
  {$EXTERNALSYM _ENUM_SERVICE_STATUS_PROCESSA}
514
 
  ENUM_SERVICE_STATUS_PROCESSA = _ENUM_SERVICE_STATUS_PROCESSA;
515
 
  {$EXTERNALSYM ENUM_SERVICE_STATUS_PROCESSA}
516
 
  TEnumServiceStatusProcessA = ENUM_SERVICE_STATUS_PROCESSA;
517
 
  PEnumServiceStatusProcessA = LPENUM_SERVICE_STATUS_PROCESSA;
518
 
 
519
 
  LPENUM_SERVICE_STATUS_PROCESSW = ^ENUM_SERVICE_STATUS_PROCESSW;
520
 
  {$EXTERNALSYM LPENUM_SERVICE_STATUS_PROCESSW}
521
 
  _ENUM_SERVICE_STATUS_PROCESSW = record
522
 
    lpServiceName: LPWSTR;
523
 
    lpDisplayName: LPWSTR;
524
 
    ServiceStatusProcess: SERVICE_STATUS_PROCESS;
525
 
  end;
526
 
  {$EXTERNALSYM _ENUM_SERVICE_STATUS_PROCESSW}
527
 
  ENUM_SERVICE_STATUS_PROCESSW = _ENUM_SERVICE_STATUS_PROCESSW;
528
 
  {$EXTERNALSYM ENUM_SERVICE_STATUS_PROCESSW}
529
 
  TEnumServiceStatusProcessW = ENUM_SERVICE_STATUS_PROCESSW;
530
 
  PEnumServiceStatusProcessW = LPENUM_SERVICE_STATUS_PROCESSW;
531
 
 
532
 
  {$IFDEF UNICODE}
533
 
  ENUM_SERVICE_STATUS_PROCESS = ENUM_SERVICE_STATUS_PROCESSW;
534
 
  {$EXTERNALSYM ENUM_SERVICE_STATUS_PROCESS}
535
 
  LPENUM_SERVICE_STATUS_PROCESS = LPENUM_SERVICE_STATUS_PROCESSW;
536
 
  {$EXTERNALSYM LPENUM_SERVICE_STATUS_PROCESS}
537
 
  TEnumServiceStatusProcess = TEnumServiceStatusProcessW;
538
 
  PEnumServiceStatusProcess = PEnumServiceStatusProcessW;
539
 
  {$ELSE}
540
 
  ENUM_SERVICE_STATUS_PROCESS = ENUM_SERVICE_STATUS_PROCESSA;
541
 
  {$EXTERNALSYM ENUM_SERVICE_STATUS_PROCESS}
542
 
  LPENUM_SERVICE_STATUS_PROCESS = LPENUM_SERVICE_STATUS_PROCESSA;
543
 
  {$EXTERNALSYM LPENUM_SERVICE_STATUS_PROCESS}
544
 
  TEnumServiceStatusProcess = TEnumServiceStatusProcessA;
545
 
  PEnumServiceStatusProcess = PEnumServiceStatusProcessA;
546
 
  {$ENDIF UNICODE}
547
 
 
548
 
//
549
 
// Structures for the Lock API functions
550
 
//
551
 
 
552
 
  SC_LOCK = LPVOID;
553
 
  {$EXTERNALSYM SC_LOCK}
554
 
 
555
 
  LPQUERY_SERVICE_LOCK_STATUSA = ^QUERY_SERVICE_LOCK_STATUSA;
556
 
  {$EXTERNALSYM LPQUERY_SERVICE_LOCK_STATUSA}
557
 
  _QUERY_SERVICE_LOCK_STATUSA = record
558
 
    fIsLocked: DWORD;
559
 
    lpLockOwner: LPSTR;
560
 
    dwLockDuration: DWORD;
561
 
  end;
562
 
  {$EXTERNALSYM _QUERY_SERVICE_LOCK_STATUSA}
563
 
  QUERY_SERVICE_LOCK_STATUSA = _QUERY_SERVICE_LOCK_STATUSA;
564
 
  {$EXTERNALSYM QUERY_SERVICE_LOCK_STATUSA}
565
 
  TQueryServiceLockStatusA = QUERY_SERVICE_LOCK_STATUSA;
566
 
  PQueryServiceLockStatusA = LPQUERY_SERVICE_LOCK_STATUSA;
567
 
 
568
 
  LPQUERY_SERVICE_LOCK_STATUSW = ^QUERY_SERVICE_LOCK_STATUSW;
569
 
  {$EXTERNALSYM LPQUERY_SERVICE_LOCK_STATUSW}
570
 
  _QUERY_SERVICE_LOCK_STATUSW = record
571
 
    fIsLocked: DWORD;
572
 
    lpLockOwner: LPWSTR;
573
 
    dwLockDuration: DWORD;
574
 
  end;
575
 
  {$EXTERNALSYM _QUERY_SERVICE_LOCK_STATUSW}
576
 
  QUERY_SERVICE_LOCK_STATUSW = _QUERY_SERVICE_LOCK_STATUSW;
577
 
  {$EXTERNALSYM QUERY_SERVICE_LOCK_STATUSW}
578
 
  TQueryServiceLockStatusW = QUERY_SERVICE_LOCK_STATUSW;
579
 
  PQueryServiceLockStatusW = LPQUERY_SERVICE_LOCK_STATUSW;
580
 
 
581
 
  {$IFDEF UNICODE}
582
 
  QUERY_SERVICE_LOCK_STATUS = QUERY_SERVICE_LOCK_STATUSW;
583
 
  {$EXTERNALSYM QUERY_SERVICE_LOCK_STATUS}
584
 
  LPQUERY_SERVICE_LOCK_STATUS = LPQUERY_SERVICE_LOCK_STATUSW;
585
 
  {$EXTERNALSYM LPQUERY_SERVICE_LOCK_STATUS}
586
 
  TQueryServiceLockStatus = TQueryServiceLockStatusW;
587
 
  PQueryServiceLockStatus = PQueryServiceLockStatusW;
588
 
  {$ELSE}
589
 
  QUERY_SERVICE_LOCK_STATUS = QUERY_SERVICE_LOCK_STATUSA;
590
 
  {$EXTERNALSYM QUERY_SERVICE_LOCK_STATUS}
591
 
  LPQUERY_SERVICE_LOCK_STATUS = LPQUERY_SERVICE_LOCK_STATUSA;
592
 
  {$EXTERNALSYM LPQUERY_SERVICE_LOCK_STATUS}
593
 
  TQueryServiceLockStatus = TQueryServiceLockStatusA;
594
 
  PQueryServiceLockStatus = PQueryServiceLockStatusA;
595
 
  {$ENDIF UNICODE}
596
 
 
597
 
//
598
 
// Query Service Configuration Structure
599
 
//
600
 
 
601
 
  LPQUERY_SERVICE_CONFIGA = ^QUERY_SERVICE_CONFIGA;
602
 
  {$EXTERNALSYM LPQUERY_SERVICE_CONFIGA}
603
 
  _QUERY_SERVICE_CONFIGA = record
604
 
    dwServiceType: DWORD;
605
 
    dwStartType: DWORD;
606
 
    dwErrorControl: DWORD;
607
 
    lpBinaryPathName: LPSTR;
608
 
    lpLoadOrderGroup: LPSTR;
609
 
    dwTagId: DWORD;
610
 
    lpDependencies: LPSTR;
611
 
    lpServiceStartName: LPSTR;
612
 
    lpDisplayName: LPSTR;
613
 
  end;
614
 
  {$EXTERNALSYM _QUERY_SERVICE_CONFIGA}
615
 
  QUERY_SERVICE_CONFIGA = _QUERY_SERVICE_CONFIGA;
616
 
  {$EXTERNALSYM QUERY_SERVICE_CONFIGA}
617
 
  TQueryServiceConfigA = QUERY_SERVICE_CONFIGA;
618
 
  PQueryServiceConfigA = LPQUERY_SERVICE_CONFIGA;
619
 
 
620
 
  LPQUERY_SERVICE_CONFIGW = ^QUERY_SERVICE_CONFIGW;
621
 
  {$EXTERNALSYM LPQUERY_SERVICE_CONFIGW}
622
 
  _QUERY_SERVICE_CONFIGW = record
623
 
    dwServiceType: DWORD;
624
 
    dwStartType: DWORD;
625
 
    dwErrorControl: DWORD;
626
 
    lpBinaryPathName: LPWSTR;
627
 
    lpLoadOrderGroup: LPWSTR;
628
 
    dwTagId: DWORD;
629
 
    lpDependencies: LPWSTR;
630
 
    lpServiceStartName: LPWSTR;
631
 
    lpDisplayName: LPWSTR;
632
 
  end;
633
 
  {$EXTERNALSYM _QUERY_SERVICE_CONFIGW}
634
 
  QUERY_SERVICE_CONFIGW = _QUERY_SERVICE_CONFIGW;
635
 
  {$EXTERNALSYM QUERY_SERVICE_CONFIGW}
636
 
  TQueryServiceConfigW = QUERY_SERVICE_CONFIGW;
637
 
  PQueryServiceConfigW = LPQUERY_SERVICE_CONFIGW;
638
 
 
639
 
  {$IFDEF UNICODE}
640
 
  QUERY_SERVICE_CONFIG = QUERY_SERVICE_CONFIGW;
641
 
  {$EXTERNALSYM QUERY_SERVICE_CONFIG}
642
 
  LPQUERY_SERVICE_CONFIG = LPQUERY_SERVICE_CONFIGW;
643
 
  {$EXTERNALSYM LPQUERY_SERVICE_CONFIG}
644
 
  TQueryServiceConfig = TQueryServiceConfigW;
645
 
  PQueryServiceConfig = PQueryServiceConfigW;
646
 
  {$ELSE}
647
 
  QUERY_SERVICE_CONFIG = QUERY_SERVICE_CONFIGA;
648
 
  {$EXTERNALSYM QUERY_SERVICE_CONFIG}
649
 
  LPQUERY_SERVICE_CONFIG = LPQUERY_SERVICE_CONFIGA;
650
 
  {$EXTERNALSYM LPQUERY_SERVICE_CONFIG}
651
 
  TQueryServiceConfig = TQueryServiceConfigA;
652
 
  PQueryServiceConfig = PQueryServiceConfigA;
653
 
  {$ENDIF UNICODE}
654
 
 
655
 
//
656
 
// Function Prototype for the Service Main Function
657
 
//
658
 
 
659
 
type
660
 
  LPSERVICE_MAIN_FUNCTIONW = procedure(dwNumServicesArgs: DWORD;
661
 
    lpServiceArgVectors: LPWSTR); stdcall;
662
 
  {$EXTERNALSYM LPSERVICE_MAIN_FUNCTIONW}
663
 
  LPSERVICE_MAIN_FUNCTIONA = procedure(dwNumServicesArgs: DWORD;
664
 
    lpServiceArgVectors: LPSTR); stdcall;
665
 
  {$EXTERNALSYM LPSERVICE_MAIN_FUNCTIONA}
666
 
 
667
 
  TServiceMainFunctionA = LPSERVICE_MAIN_FUNCTIONA;
668
 
  TServiceMainFunctionW = LPSERVICE_MAIN_FUNCTIONW;
669
 
 
670
 
  {$IFDEF UNICODE}
671
 
  LPSERVICE_MAIN_FUNCTION = LPSERVICE_MAIN_FUNCTIONW;
672
 
  {$EXTERNALSYM LPSERVICE_MAIN_FUNCTION}
673
 
  TServiceMainFunction = LPSERVICE_MAIN_FUNCTIONW;
674
 
  {$ELSE}
675
 
  LPSERVICE_MAIN_FUNCTION = LPSERVICE_MAIN_FUNCTIONA;
676
 
  {$EXTERNALSYM LPSERVICE_MAIN_FUNCTION}
677
 
  TServiceMainFunction = LPSERVICE_MAIN_FUNCTIONA;
678
 
  {$ENDIF UNICODE}
679
 
 
680
 
//
681
 
// Service Start Table
682
 
//
683
 
 
684
 
  LPSERVICE_TABLE_ENTRYA = ^SERVICE_TABLE_ENTRYA;
685
 
  {$EXTERNALSYM LPSERVICE_TABLE_ENTRYA}
686
 
  _SERVICE_TABLE_ENTRYA = record
687
 
    lpServiceName: LPSTR;
688
 
    lpServiceProc: LPSERVICE_MAIN_FUNCTIONA;
689
 
  end;
690
 
  {$EXTERNALSYM _SERVICE_TABLE_ENTRYA}
691
 
  SERVICE_TABLE_ENTRYA = _SERVICE_TABLE_ENTRYA;
692
 
  {$EXTERNALSYM SERVICE_TABLE_ENTRYA}
693
 
  TServiceTableEntryA = SERVICE_TABLE_ENTRYA;
694
 
  PServiceTableEntryA = LPSERVICE_TABLE_ENTRYA;
695
 
 
696
 
  LPSERVICE_TABLE_ENTRYW = ^SERVICE_TABLE_ENTRYW;
697
 
  {$EXTERNALSYM LPSERVICE_TABLE_ENTRYW}
698
 
  _SERVICE_TABLE_ENTRYW = record
699
 
    lpServiceName: LPWSTR;
700
 
    lpServiceProc: LPSERVICE_MAIN_FUNCTIONW;
701
 
  end;
702
 
  {$EXTERNALSYM _SERVICE_TABLE_ENTRYW}
703
 
  SERVICE_TABLE_ENTRYW = _SERVICE_TABLE_ENTRYW;
704
 
  {$EXTERNALSYM SERVICE_TABLE_ENTRYW}
705
 
  TServiceTableEntryW = SERVICE_TABLE_ENTRYW;
706
 
  PServiceTableEntryW = LPSERVICE_TABLE_ENTRYW;
707
 
 
708
 
  {$IFDEF UNICODE}
709
 
  SERVICE_TABLE_ENTRY = SERVICE_TABLE_ENTRYW;
710
 
  LPSERVICE_TABLE_ENTRY = LPSERVICE_TABLE_ENTRYW;
711
 
  TServiceTableEntry = TServiceTableEntryW;
712
 
  PServiceTableEntry = PServiceTableEntryW;
713
 
  {$ELSE}
714
 
  SERVICE_TABLE_ENTRY = SERVICE_TABLE_ENTRYA;
715
 
  LPSERVICE_TABLE_ENTRY = LPSERVICE_TABLE_ENTRYA;
716
 
  TServiceTableEntry = TServiceTableEntryA;
717
 
  PServiceTableEntry = PServiceTableEntryA;
718
 
  {$ENDIF UNICODE}
719
 
 
720
 
//
721
 
// Prototype for the Service Control Handler Function
722
 
//
723
 
 
724
 
  LPHANDLER_FUNCTION = procedure(dwControl: DWORD); stdcall;
725
 
  {$EXTERNALSYM LPHANDLER_FUNCTION}
726
 
  THandlerFunction = LPHANDLER_FUNCTION;
727
 
 
728
 
  LPHANDLER_FUNCTION_EX = function(dwControl, dwEventType: DWORD;
729
 
    lpEventData, lpContext: LPVOID): DWORD; stdcall;
730
 
  {$EXTERNALSYM LPHANDLER_FUNCTION_EX}
731
 
  THandlerFunctionEx = LPHANDLER_FUNCTION_EX;
732
 
 
733
 
///////////////////////////////////////////////////////////////////////////
734
 
// API Function Prototypes
735
 
///////////////////////////////////////////////////////////////////////////
736
 
 
737
 
function ChangeServiceConfigA(hService: SC_HANDLE; dwServiceType, dwStartType,
738
 
  dwErrorControl: DWORD; lpBinaryPathName, lpLoadOrderGroup: LPCSTR;
739
 
  lpdwTagId: LPDWORD; lpDependencies, lpServiceStartName, lpPassword,
740
 
  lpDisplayName: LPCSTR): BOOL; stdcall;
741
 
{$EXTERNALSYM ChangeServiceConfigA}
742
 
function ChangeServiceConfigW(hService: SC_HANDLE; dwServiceType, dwStartType,
743
 
  dwErrorControl: DWORD; lpBinaryPathName, lpLoadOrderGroup: LPCWSTR;
744
 
  lpdwTagId: LPDWORD; lpDependencies, lpServiceStartName, lpPassword,
745
 
  lpDisplayName: LPCWSTR): BOOL; stdcall;
746
 
{$EXTERNALSYM ChangeServiceConfigW}
747
 
function ChangeServiceConfig(hService: SC_HANDLE; dwServiceType, dwStartType,
748
 
  dwErrorControl: DWORD; lpBinaryPathName, lpLoadOrderGroup: LPCTSTR;
749
 
  lpdwTagId: LPDWORD; lpDependencies, lpServiceStartName, lpPassword,
750
 
  lpDisplayName: LPCTSTR): BOOL; stdcall;
751
 
{$EXTERNALSYM ChangeServiceConfig}
752
 
 
753
 
function ChangeServiceConfig2A(hService: SC_HANDLE; dwInfoLevel: DWORD;
754
 
  lpInfo: LPVOID): BOOL; stdcall;
755
 
{$EXTERNALSYM ChangeServiceConfig2A}
756
 
function ChangeServiceConfig2W(hService: SC_HANDLE; dwInfoLevel: DWORD;
757
 
  lpInfo: LPVOID): BOOL; stdcall;
758
 
{$EXTERNALSYM ChangeServiceConfig2W}
759
 
function ChangeServiceConfig2(hService: SC_HANDLE; dwInfoLevel: DWORD;
760
 
  lpInfo: LPVOID): BOOL; stdcall;
761
 
{$EXTERNALSYM ChangeServiceConfig2}
762
 
 
763
 
function CloseServiceHandle(hSCObject: SC_HANDLE): BOOL; stdcall;
764
 
{$EXTERNALSYM CloseServiceHandle}
765
 
 
766
 
function ControlService(hService: SC_HANDLE; dwControl: DWORD;
767
 
  var lpServiceStatus: SERVICE_STATUS): BOOL; stdcall;
768
 
{$EXTERNALSYM ControlService}
769
 
 
770
 
function CreateServiceA(hSCManager: SC_HANDLE; lpServiceName, lpDisplayName: LPCSTR;
771
 
  dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD;
772
 
  lpBinaryPathName, lpLoadOrderGroup: LPCSTR; lpdwTagId: LPDWORD;
773
 
  lpDependencies, lpServiceStartName, lpPassword: LPCSTR): SC_HANDLE; stdcall;
774
 
{$EXTERNALSYM CreateServiceA}
775
 
function CreateServiceW(hSCManager: SC_HANDLE; lpServiceName, lpDisplayName: LPCWSTR;
776
 
  dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD;
777
 
  lpBinaryPathName, lpLoadOrderGroup: LPCWSTR; lpdwTagId: LPDWORD;
778
 
  lpDependencies, lpServiceStartName, lpPassword: LPCWSTR): SC_HANDLE; stdcall;
779
 
{$EXTERNALSYM CreateServiceW}
780
 
function CreateService(hSCManager: SC_HANDLE; lpServiceName, lpDisplayName: LPCTSTR;
781
 
  dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD;
782
 
  lpBinaryPathName, lpLoadOrderGroup: LPCTSTR; lpdwTagId: LPDWORD;
783
 
  lpDependencies, lpServiceStartName, lpPassword: LPCTSTR): SC_HANDLE; stdcall;
784
 
{$EXTERNALSYM CreateService}
785
 
 
786
 
function DeleteService(hService: SC_HANDLE): BOOL; stdcall;
787
 
{$EXTERNALSYM DeleteService}
788
 
 
789
 
function EnumDependentServicesA(hService: SC_HANDLE; dwServiceState: DWORD;
790
 
  lpServices: LPENUM_SERVICE_STATUSA; cbBufSize: DWORD; var pcbBytesNeeded,
791
 
  lpServicesReturned: DWORD): BOOL; stdcall;
792
 
{$EXTERNALSYM EnumDependentServicesA}
793
 
function EnumDependentServicesW(hService: SC_HANDLE; dwServiceState: DWORD;
794
 
  lpServices: LPENUM_SERVICE_STATUSW; cbBufSize: DWORD; var pcbBytesNeeded,
795
 
  lpServicesReturned: DWORD): BOOL; stdcall;
796
 
{$EXTERNALSYM EnumDependentServicesW}
797
 
function EnumDependentServices(hService: SC_HANDLE; dwServiceState: DWORD;
798
 
  lpServices: LPENUM_SERVICE_STATUS; cbBufSize: DWORD; var pcbBytesNeeded,
799
 
  lpServicesReturned: DWORD): BOOL; stdcall;
800
 
{$EXTERNALSYM EnumDependentServices}
801
 
 
802
 
function EnumServicesStatusA(hSCManager: SC_HANDLE; dwServiceType: DWORD;
803
 
  dwServiceState: DWORD; lpServices: LPENUM_SERVICE_STATUSA; cbBufSize: DWORD;
804
 
  var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD): BOOL; stdcall;
805
 
{$EXTERNALSYM EnumServicesStatusA}
806
 
function EnumServicesStatusW(hSCManager: SC_HANDLE; dwServiceType: DWORD;
807
 
  dwServiceState: DWORD; lpServices: LPENUM_SERVICE_STATUSW; cbBufSize: DWORD;
808
 
  var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD): BOOL; stdcall;
809
 
{$EXTERNALSYM EnumServicesStatusW}
810
 
function EnumServicesStatus(hSCManager: SC_HANDLE; dwServiceType: DWORD;
811
 
  dwServiceState: DWORD; lpServices: LPENUM_SERVICE_STATUS; cbBufSize: DWORD;
812
 
  var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD): BOOL; stdcall;
813
 
{$EXTERNALSYM EnumServicesStatus}
814
 
 
815
 
function EnumServicesStatusExA(hSCManager: SC_HANDLE; InfoLevel: SC_ENUM_TYPE;
816
 
  dwServiceType: DWORD; dwServiceState: DWORD; lpServices: LPBYTE;
817
 
  cbBufSize: DWORD; var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD;
818
 
  pszGroupName: LPCSTR): BOOL; stdcall;
819
 
{$EXTERNALSYM EnumServicesStatusExA}
820
 
function EnumServicesStatusExW(hSCManager: SC_HANDLE; InfoLevel: SC_ENUM_TYPE;
821
 
  dwServiceType: DWORD; dwServiceState: DWORD; lpServices: LPBYTE;
822
 
  cbBufSize: DWORD; var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD;
823
 
  pszGroupName: LPCWSTR): BOOL; stdcall;
824
 
{$EXTERNALSYM EnumServicesStatusExW}
825
 
function EnumServicesStatusEx(hSCManager: SC_HANDLE; InfoLevel: SC_ENUM_TYPE;
826
 
  dwServiceType: DWORD; dwServiceState: DWORD; lpServices: LPBYTE;
827
 
  cbBufSize: DWORD; var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD;
828
 
  pszGroupName: LPCTSTR): BOOL; stdcall;
829
 
{$EXTERNALSYM EnumServicesStatusEx}
830
 
 
831
 
function GetServiceKeyNameA(hSCManager: SC_HANDLE; lpDisplayName: LPCSTR;
832
 
  lpServiceName: LPSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
833
 
{$EXTERNALSYM GetServiceKeyNameA}
834
 
function GetServiceKeyNameW(hSCManager: SC_HANDLE; lpDisplayName: LPCWSTR;
835
 
  lpServiceName: LPWSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
836
 
{$EXTERNALSYM GetServiceKeyNameW}
837
 
function GetServiceKeyName(hSCManager: SC_HANDLE; lpDisplayName: LPCTSTR;
838
 
  lpServiceName: LPTSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
839
 
{$EXTERNALSYM GetServiceKeyName}
840
 
 
841
 
function GetServiceDisplayNameA(hSCManager: SC_HANDLE; lpServiceName: LPCSTR;
842
 
  lpDisplayName: LPSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
843
 
{$EXTERNALSYM GetServiceDisplayNameA}
844
 
function GetServiceDisplayNameW(hSCManager: SC_HANDLE; lpServiceName: LPCWSTR;
845
 
  lpDisplayName: LPWSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
846
 
{$EXTERNALSYM GetServiceDisplayNameW}
847
 
function GetServiceDisplayName(hSCManager: SC_HANDLE; lpServiceName: LPCTSTR;
848
 
  lpDisplayName: LPTSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
849
 
{$EXTERNALSYM GetServiceDisplayName}
850
 
 
851
 
function LockServiceDatabase(hSCManager: SC_HANDLE): SC_LOCK; stdcall;
852
 
{$EXTERNALSYM LockServiceDatabase}
853
 
 
854
 
function NotifyBootConfigStatus(BootAcceptable: BOOL): BOOL; stdcall;
855
 
{$EXTERNALSYM NotifyBootConfigStatus}
856
 
 
857
 
function OpenSCManagerA(lpMachineName: LPCSTR; lpDatabaseName: LPCSTR;
858
 
  dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
859
 
{$EXTERNALSYM OpenSCManagerA}
860
 
function OpenSCManagerW(lpMachineName: LPCWSTR; lpDatabaseName: LPCWSTR;
861
 
  dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
862
 
{$EXTERNALSYM OpenSCManagerW}
863
 
function OpenSCManager(lpMachineName: LPCTSTR; lpDatabaseName: LPCTSTR;
864
 
  dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
865
 
{$EXTERNALSYM OpenSCManager}
866
 
 
867
 
function OpenServiceA(hSCManager: SC_HANDLE; lpServiceName: LPCSTR;
868
 
  dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
869
 
{$EXTERNALSYM OpenServiceA}
870
 
function OpenServiceW(hSCManager: SC_HANDLE; lpServiceName: LPCWSTR;
871
 
  dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
872
 
{$EXTERNALSYM OpenServiceW}
873
 
function OpenService(hSCManager: SC_HANDLE; lpServiceName: LPCTSTR;
874
 
  dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
875
 
{$EXTERNALSYM OpenService}
876
 
 
877
 
function QueryServiceConfigA(hService: SC_HANDLE;
878
 
  lpServiceConfig: LPQUERY_SERVICE_CONFIGA; cbBufSize: DWORD;
879
 
  var pcbBytesNeeded: DWORD): BOOL; stdcall;
880
 
{$EXTERNALSYM QueryServiceConfigA}
881
 
function QueryServiceConfigW(hService: SC_HANDLE;
882
 
  lpServiceConfig: LPQUERY_SERVICE_CONFIGW; cbBufSize: DWORD;
883
 
  var pcbBytesNeeded: DWORD): BOOL; stdcall;
884
 
{$EXTERNALSYM QueryServiceConfigW}
885
 
function QueryServiceConfig(hService: SC_HANDLE;
886
 
  lpServiceConfig: LPQUERY_SERVICE_CONFIG; cbBufSize: DWORD;
887
 
  var pcbBytesNeeded: DWORD): BOOL; stdcall;
888
 
{$EXTERNALSYM QueryServiceConfig}
889
 
 
890
 
function QueryServiceConfig2A(hService: SC_HANDLE; dwInfoLevel: DWORD;
891
 
  lpBuffer: LPBYTE; cbBufSize: DWORD; var pcbBytesNeeded: DWORD): BOOL; stdcall;
892
 
{$EXTERNALSYM QueryServiceConfig2A}
893
 
function QueryServiceConfig2W(hService: SC_HANDLE; dwInfoLevel: DWORD;
894
 
  lpBuffer: LPBYTE; cbBufSize: DWORD; var pcbBytesNeeded: DWORD): BOOL; stdcall;
895
 
{$EXTERNALSYM QueryServiceConfig2W}
896
 
function QueryServiceConfig2(hService: SC_HANDLE; dwInfoLevel: DWORD;
897
 
  lpBuffer: LPBYTE; cbBufSize: DWORD; var pcbBytesNeeded: DWORD): BOOL; stdcall;
898
 
{$EXTERNALSYM QueryServiceConfig2}
899
 
 
900
 
function QueryServiceLockStatusA(hSCManager: SC_HANDLE;
901
 
  lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSA; cbBufSize: DWORD;
902
 
  var pcbBytesNeeded: DWORD): BOOL; stdcall;
903
 
{$EXTERNALSYM QueryServiceLockStatusA}
904
 
function QueryServiceLockStatusW(hSCManager: SC_HANDLE;
905
 
  lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSW; cbBufSize: DWORD;
906
 
  var pcbBytesNeeded: DWORD): BOOL; stdcall;
907
 
{$EXTERNALSYM QueryServiceLockStatusW}
908
 
function QueryServiceLockStatus(hSCManager: SC_HANDLE;
909
 
  lpLockStatus: LPQUERY_SERVICE_LOCK_STATUS; cbBufSize: DWORD;
910
 
  var pcbBytesNeeded: DWORD): BOOL; stdcall;
911
 
{$EXTERNALSYM QueryServiceLockStatus}
912
 
 
913
 
function QueryServiceObjectSecurity(hService: SC_HANDLE;
914
 
  dwSecurityInformation: SECURITY_INFORMATION;
915
 
  var lpSecurityDescriptor: SECURITY_DESCRIPTOR; cbBufSize: DWORD;
916
 
  var pcbBytesNeeded: DWORD): BOOL; stdcall;
917
 
{$EXTERNALSYM QueryServiceObjectSecurity}
918
 
 
919
 
function QueryServiceStatus(hService: SC_HANDLE;
920
 
  var lpServiceStatus: SERVICE_STATUS): BOOL; stdcall;
921
 
{$EXTERNALSYM QueryServiceStatus}
922
 
 
923
 
function QueryServiceStatusEx(hService: SC_HANDLE; InfoLevel: SC_STATUS_TYPE;
924
 
  lpBuffer: LPBYTE; cbBufSize: DWORD; var pcbBytesNeeded: DWORD): BOOL; stdcall;
925
 
{$EXTERNALSYM QueryServiceStatusEx}
926
 
 
927
 
function RegisterServiceCtrlHandlerA(lpServiceName: LPCSTR;
928
 
  lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE; stdcall;
929
 
{$EXTERNALSYM RegisterServiceCtrlHandlerA}
930
 
function RegisterServiceCtrlHandlerW(lpServiceName: LPCWSTR;
931
 
  lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE; stdcall;
932
 
{$EXTERNALSYM RegisterServiceCtrlHandlerW}
933
 
function RegisterServiceCtrlHandler(lpServiceName: LPCTSTR;
934
 
  lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE; stdcall;
935
 
{$EXTERNALSYM RegisterServiceCtrlHandler}
936
 
 
937
 
function RegisterServiceCtrlHandlerExA(lpServiceName: LPCSTR;
938
 
  lpHandlerProc: LPHANDLER_FUNCTION_EX; lpContext: LPVOID): SERVICE_STATUS_HANDLE; stdcall;
939
 
{$EXTERNALSYM RegisterServiceCtrlHandlerExA}
940
 
function RegisterServiceCtrlHandlerExW(lpServiceName: LPCWSTR;
941
 
  lpHandlerProc: LPHANDLER_FUNCTION_EX; lpContext: LPVOID): SERVICE_STATUS_HANDLE; stdcall;
942
 
{$EXTERNALSYM RegisterServiceCtrlHandlerExW}
943
 
function RegisterServiceCtrlHandlerEx(lpServiceName: LPCTSTR;
944
 
  lpHandlerProc: LPHANDLER_FUNCTION_EX; lpContext: LPVOID): SERVICE_STATUS_HANDLE; stdcall;
945
 
{$EXTERNALSYM RegisterServiceCtrlHandlerEx}
946
 
 
947
 
// 9/4/2002 Changed last parameter from const to pointer - reported by James Ots.
948
 
 
949
 
function SetServiceObjectSecurity(hService: SC_HANDLE;
950
 
  dwSecurityInformation: SECURITY_INFORMATION;
951
 
  lpSecurityDescriptor: PSECURITY_DESCRIPTOR): BOOL; stdcall;
952
 
{$EXTERNALSYM SetServiceObjectSecurity}
953
 
 
954
 
function SetServiceStatus(hServiceStatus: SERVICE_STATUS_HANDLE;
955
 
  const lpServiceStatus: SERVICE_STATUS): BOOL; stdcall;
956
 
{$EXTERNALSYM SetServiceStatus}
957
 
 
958
 
function StartServiceCtrlDispatcherA(lpServiceStartTable: LPSERVICE_TABLE_ENTRYA): BOOL; stdcall;
959
 
{$EXTERNALSYM StartServiceCtrlDispatcherA}
960
 
function StartServiceCtrlDispatcherW(lpServiceStartTable: LPSERVICE_TABLE_ENTRYW): BOOL; stdcall;
961
 
{$EXTERNALSYM StartServiceCtrlDispatcherW}
962
 
function StartServiceCtrlDispatcher(lpServiceStartTable: LPSERVICE_TABLE_ENTRY): BOOL; stdcall;
963
 
{$EXTERNALSYM StartServiceCtrlDispatcher}
964
 
 
965
 
function StartServiceA(hService: SC_HANDLE; dwNumServiceArgs: DWORD;
966
 
  lpServiceArgVectors: LPCSTR): BOOL; stdcall;
967
 
{$EXTERNALSYM StartServiceA}
968
 
function StartServiceW(hService: SC_HANDLE; dwNumServiceArgs: DWORD;
969
 
  lpServiceArgVectors: LPCWSTR): BOOL; stdcall;
970
 
{$EXTERNALSYM StartServiceW}
971
 
function StartService(hService: SC_HANDLE; dwNumServiceArgs: DWORD;
972
 
  lpServiceArgVectors: LPCTSTR): BOOL; stdcall;
973
 
{$EXTERNALSYM StartService}
974
 
 
975
 
function UnlockServiceDatabase(ScLock: SC_LOCK): BOOL; stdcall;
976
 
{$EXTERNALSYM UnlockServiceDatabase}
977
 
 
978
 
implementation
979
 
 
980
 
const
981
 
  advapi32 = 'advapi32.dll';
982
 
  {$IFDEF UNICODE}
983
 
  AWSuffix = 'W';
984
 
  {$ELSE}
985
 
  AWSuffix = 'A';
986
 
  {$ENDIF UNICODE}
987
 
 
988
 
{$IFDEF DYNAMIC_LINK}
989
 
 
990
 
var
991
 
  _ChangeServiceConfigA: Pointer;
992
 
 
993
 
function ChangeServiceConfigA;
994
 
begin
995
 
  GetProcedureAddress(_ChangeServiceConfigA, advapi32, 'ChangeServiceConfigA');
996
 
  asm
997
 
        MOV     ESP, EBP
998
 
        POP     EBP
999
 
        JMP     [_ChangeServiceConfigA]
1000
 
  end;
1001
 
end;
1002
 
 
1003
 
var
1004
 
  _ChangeServiceConfigW: Pointer;
1005
 
 
1006
 
function ChangeServiceConfigW;
1007
 
begin
1008
 
  GetProcedureAddress(_ChangeServiceConfigW, advapi32, 'ChangeServiceConfigW');
1009
 
  asm
1010
 
        MOV     ESP, EBP
1011
 
        POP     EBP
1012
 
        JMP     [_ChangeServiceConfigW]
1013
 
  end;
1014
 
end;
1015
 
 
1016
 
var
1017
 
  _ChangeServiceConfig: Pointer;
1018
 
 
1019
 
function ChangeServiceConfig;
1020
 
begin
1021
 
  GetProcedureAddress(_ChangeServiceConfig, advapi32, 'ChangeServiceConfig' + AWSuffix);
1022
 
  asm
1023
 
        MOV     ESP, EBP
1024
 
        POP     EBP
1025
 
        JMP     [_ChangeServiceConfig]
1026
 
  end;
1027
 
end;
1028
 
 
1029
 
var
1030
 
  _ChangeServiceConfig2A: Pointer;
1031
 
 
1032
 
function ChangeServiceConfig2A;
1033
 
begin
1034
 
  GetProcedureAddress(_ChangeServiceConfig2A, advapi32, 'ChangeServiceConfig2A');
1035
 
  asm
1036
 
        MOV     ESP, EBP
1037
 
        POP     EBP
1038
 
        JMP     [_ChangeServiceConfig2A]
1039
 
  end;
1040
 
end;
1041
 
 
1042
 
var
1043
 
  _ChangeServiceConfig2W: Pointer;
1044
 
 
1045
 
function ChangeServiceConfig2W;
1046
 
begin
1047
 
  GetProcedureAddress(_ChangeServiceConfig2W, advapi32, 'ChangeServiceConfig2W');
1048
 
  asm
1049
 
        MOV     ESP, EBP
1050
 
        POP     EBP
1051
 
        JMP     [_ChangeServiceConfig2W]
1052
 
  end;
1053
 
end;
1054
 
 
1055
 
var
1056
 
  _ChangeServiceConfig2: Pointer;
1057
 
 
1058
 
function ChangeServiceConfig2;
1059
 
begin
1060
 
  GetProcedureAddress(_ChangeServiceConfig2, advapi32, 'ChangeServiceConfig2' + AWSuffix);
1061
 
  asm
1062
 
        MOV     ESP, EBP
1063
 
        POP     EBP
1064
 
        JMP     [_ChangeServiceConfig2]
1065
 
  end;
1066
 
end;
1067
 
 
1068
 
var
1069
 
  _CloseServiceHandle: Pointer;
1070
 
 
1071
 
function CloseServiceHandle;
1072
 
begin
1073
 
  GetProcedureAddress(_CloseServiceHandle, advapi32, 'CloseServiceHandle');
1074
 
  asm
1075
 
        MOV     ESP, EBP
1076
 
        POP     EBP
1077
 
        JMP     [_CloseServiceHandle]
1078
 
  end;
1079
 
end;
1080
 
 
1081
 
var
1082
 
  _ControlService: Pointer;
1083
 
 
1084
 
function ControlService;
1085
 
begin
1086
 
  GetProcedureAddress(_ControlService, advapi32, 'ControlService');
1087
 
  asm
1088
 
        MOV     ESP, EBP
1089
 
        POP     EBP
1090
 
        JMP     [_ControlService]
1091
 
  end;
1092
 
end;
1093
 
 
1094
 
var
1095
 
  _CreateServiceA: Pointer;
1096
 
 
1097
 
function CreateServiceA;
1098
 
begin
1099
 
  GetProcedureAddress(_CreateServiceA, advapi32, 'CreateServiceA');
1100
 
  asm
1101
 
        MOV     ESP, EBP
1102
 
        POP     EBP
1103
 
        JMP     [_CreateServiceA]
1104
 
  end;
1105
 
end;
1106
 
 
1107
 
var
1108
 
  _CreateServiceW: Pointer;
1109
 
 
1110
 
function CreateServiceW;
1111
 
begin
1112
 
  GetProcedureAddress(_CreateServiceW, advapi32, 'CreateServiceW');
1113
 
  asm
1114
 
        MOV     ESP, EBP
1115
 
        POP     EBP
1116
 
        JMP     [_CreateServiceW]
1117
 
  end;
1118
 
end;
1119
 
 
1120
 
var
1121
 
  _CreateService: Pointer;
1122
 
 
1123
 
function CreateService;
1124
 
begin
1125
 
  GetProcedureAddress(_CreateService, advapi32, 'CreateService' + AWSuffix);
1126
 
  asm
1127
 
        MOV     ESP, EBP
1128
 
        POP     EBP
1129
 
        JMP     [_CreateService]
1130
 
  end;
1131
 
end;
1132
 
 
1133
 
var
1134
 
  _DeleteService: Pointer;
1135
 
 
1136
 
function DeleteService;
1137
 
begin
1138
 
  GetProcedureAddress(_DeleteService, advapi32, 'DeleteService');
1139
 
  asm
1140
 
        MOV     ESP, EBP
1141
 
        POP     EBP
1142
 
        JMP     [_DeleteService]
1143
 
  end;
1144
 
end;
1145
 
 
1146
 
var
1147
 
  _EnumDependentServicesA: Pointer;
1148
 
 
1149
 
function EnumDependentServicesA;
1150
 
begin
1151
 
  GetProcedureAddress(_EnumDependentServicesA, advapi32, 'EnumDependentServicesA');
1152
 
  asm
1153
 
        MOV     ESP, EBP
1154
 
        POP     EBP
1155
 
        JMP     [_EnumDependentServicesA]
1156
 
  end;
1157
 
end;
1158
 
 
1159
 
var
1160
 
  _EnumDependentServicesW: Pointer;
1161
 
 
1162
 
function EnumDependentServicesW;
1163
 
begin
1164
 
  GetProcedureAddress(_EnumDependentServicesW, advapi32, 'EnumDependentServicesW');
1165
 
  asm
1166
 
        MOV     ESP, EBP
1167
 
        POP     EBP
1168
 
        JMP     [_EnumDependentServicesW]
1169
 
  end;
1170
 
end;
1171
 
 
1172
 
var
1173
 
  _EnumDependentServices: Pointer;
1174
 
 
1175
 
function EnumDependentServices;
1176
 
begin
1177
 
  GetProcedureAddress(_EnumDependentServices, advapi32, 'EnumDependentServices' + AWSuffix);
1178
 
  asm
1179
 
        MOV     ESP, EBP
1180
 
        POP     EBP
1181
 
        JMP     [_EnumDependentServices]
1182
 
  end;
1183
 
end;
1184
 
 
1185
 
var
1186
 
  _EnumServicesStatusA: Pointer;
1187
 
 
1188
 
function EnumServicesStatusA;
1189
 
begin
1190
 
  GetProcedureAddress(_EnumServicesStatusA, advapi32, 'EnumServicesStatusA');
1191
 
  asm
1192
 
        MOV     ESP, EBP
1193
 
        POP     EBP
1194
 
        JMP     [_EnumServicesStatusA]
1195
 
  end;
1196
 
end;
1197
 
 
1198
 
var
1199
 
  _EnumServicesStatusW: Pointer;
1200
 
 
1201
 
function EnumServicesStatusW;
1202
 
begin
1203
 
  GetProcedureAddress(_EnumServicesStatusW, advapi32, 'EnumServicesStatusW');
1204
 
  asm
1205
 
        MOV     ESP, EBP
1206
 
        POP     EBP
1207
 
        JMP     [_EnumServicesStatusW]
1208
 
  end;
1209
 
end;
1210
 
 
1211
 
var
1212
 
  _EnumServicesStatus: Pointer;
1213
 
 
1214
 
function EnumServicesStatus;
1215
 
begin
1216
 
  GetProcedureAddress(_EnumServicesStatus, advapi32, 'EnumServicesStatus' + AWSuffix);
1217
 
  asm
1218
 
        MOV     ESP, EBP
1219
 
        POP     EBP
1220
 
        JMP     [_EnumServicesStatus]
1221
 
  end;
1222
 
end;
1223
 
 
1224
 
var
1225
 
  _EnumServicesStatusExA: Pointer;
1226
 
 
1227
 
function EnumServicesStatusExA;
1228
 
begin
1229
 
  GetProcedureAddress(_EnumServicesStatusExA, advapi32, 'EnumServicesStatusExA');
1230
 
  asm
1231
 
        MOV     ESP, EBP
1232
 
        POP     EBP
1233
 
        JMP     [_EnumServicesStatusExA]
1234
 
  end;
1235
 
end;
1236
 
 
1237
 
var
1238
 
  _EnumServicesStatusExW: Pointer;
1239
 
 
1240
 
function EnumServicesStatusExW;
1241
 
begin
1242
 
  GetProcedureAddress(_EnumServicesStatusExW, advapi32, 'EnumServicesStatusExW');
1243
 
  asm
1244
 
        MOV     ESP, EBP
1245
 
        POP     EBP
1246
 
        JMP     [_EnumServicesStatusExW]
1247
 
  end;
1248
 
end;
1249
 
 
1250
 
var
1251
 
  _EnumServicesStatusEx: Pointer;
1252
 
 
1253
 
function EnumServicesStatusEx;
1254
 
begin
1255
 
  GetProcedureAddress(_EnumServicesStatusEx, advapi32, 'EnumServicesStatusEx' + AWSuffix);
1256
 
  asm
1257
 
        MOV     ESP, EBP
1258
 
        POP     EBP
1259
 
        JMP     [_EnumServicesStatusEx]
1260
 
  end;
1261
 
end;
1262
 
 
1263
 
var
1264
 
  _GetServiceKeyNameA: Pointer;
1265
 
 
1266
 
function GetServiceKeyNameA;
1267
 
begin
1268
 
  GetProcedureAddress(_GetServiceKeyNameA, advapi32, 'GetServiceKeyNameA');
1269
 
  asm
1270
 
        MOV     ESP, EBP
1271
 
        POP     EBP
1272
 
        JMP     [_GetServiceKeyNameA]
1273
 
  end;
1274
 
end;
1275
 
 
1276
 
var
1277
 
  _GetServiceKeyNameW: Pointer;
1278
 
 
1279
 
function GetServiceKeyNameW;
1280
 
begin
1281
 
  GetProcedureAddress(_GetServiceKeyNameW, advapi32, 'GetServiceKeyNameW');
1282
 
  asm
1283
 
        MOV     ESP, EBP
1284
 
        POP     EBP
1285
 
        JMP     [_GetServiceKeyNameW]
1286
 
  end;
1287
 
end;
1288
 
 
1289
 
var
1290
 
  _GetServiceKeyName: Pointer;
1291
 
 
1292
 
function GetServiceKeyName;
1293
 
begin
1294
 
  GetProcedureAddress(_GetServiceKeyName, advapi32, 'GetServiceKeyName' + AWSuffix);
1295
 
  asm
1296
 
        MOV     ESP, EBP
1297
 
        POP     EBP
1298
 
        JMP     [_GetServiceKeyName]
1299
 
  end;
1300
 
end;
1301
 
 
1302
 
var
1303
 
  _GetServiceDisplayNameA: Pointer;
1304
 
 
1305
 
function GetServiceDisplayNameA;
1306
 
begin
1307
 
  GetProcedureAddress(_GetServiceDisplayNameA, advapi32, 'GetServiceDisplayNameA');
1308
 
  asm
1309
 
        MOV     ESP, EBP
1310
 
        POP     EBP
1311
 
        JMP     [_GetServiceDisplayNameA]
1312
 
  end;
1313
 
end;
1314
 
 
1315
 
var
1316
 
  _GetServiceDisplayNameW: Pointer;
1317
 
 
1318
 
function GetServiceDisplayNameW;
1319
 
begin
1320
 
  GetProcedureAddress(_GetServiceDisplayNameW, advapi32, 'GetServiceDisplayNameW');
1321
 
  asm
1322
 
        MOV     ESP, EBP
1323
 
        POP     EBP
1324
 
        JMP     [_GetServiceDisplayNameW]
1325
 
  end;
1326
 
end;
1327
 
 
1328
 
var
1329
 
  _GetServiceDisplayName: Pointer;
1330
 
 
1331
 
function GetServiceDisplayName;
1332
 
begin
1333
 
  GetProcedureAddress(_GetServiceDisplayName, advapi32, 'GetServiceDisplayName' + AWSuffix);
1334
 
  asm
1335
 
        MOV     ESP, EBP
1336
 
        POP     EBP
1337
 
        JMP     [_GetServiceDisplayName]
1338
 
  end;
1339
 
end;
1340
 
 
1341
 
var
1342
 
  _LockServiceDatabase: Pointer;
1343
 
 
1344
 
function LockServiceDatabase;
1345
 
begin
1346
 
  GetProcedureAddress(_LockServiceDatabase, advapi32, 'LockServiceDatabase');
1347
 
  asm
1348
 
        MOV     ESP, EBP
1349
 
        POP     EBP
1350
 
        JMP     [_LockServiceDatabase]
1351
 
  end;
1352
 
end;
1353
 
 
1354
 
var
1355
 
  _NotifyBootConfigStatus: Pointer;
1356
 
 
1357
 
function NotifyBootConfigStatus;
1358
 
begin
1359
 
  GetProcedureAddress(_NotifyBootConfigStatus, advapi32, 'NotifyBootConfigStatus');
1360
 
  asm
1361
 
        MOV     ESP, EBP
1362
 
        POP     EBP
1363
 
        JMP     [_NotifyBootConfigStatus]
1364
 
  end;
1365
 
end;
1366
 
 
1367
 
var
1368
 
  _OpenSCManagerA: Pointer;
1369
 
 
1370
 
function OpenSCManagerA;
1371
 
begin
1372
 
  GetProcedureAddress(_OpenSCManagerA, advapi32, 'OpenSCManagerA');
1373
 
  asm
1374
 
        MOV     ESP, EBP
1375
 
        POP     EBP
1376
 
        JMP     [_OpenSCManagerA]
1377
 
  end;
1378
 
end;
1379
 
 
1380
 
var
1381
 
  _OpenSCManagerW: Pointer;
1382
 
 
1383
 
function OpenSCManagerW;
1384
 
begin
1385
 
  GetProcedureAddress(_OpenSCManagerW, advapi32, 'OpenSCManagerW');
1386
 
  asm
1387
 
        MOV     ESP, EBP
1388
 
        POP     EBP
1389
 
        JMP     [_OpenSCManagerW]
1390
 
  end;
1391
 
end;
1392
 
 
1393
 
var
1394
 
  _OpenSCManager: Pointer;
1395
 
 
1396
 
function OpenSCManager;
1397
 
begin
1398
 
  GetProcedureAddress(_OpenSCManager, advapi32, 'OpenSCManager' + AWSuffix);
1399
 
  asm
1400
 
        MOV     ESP, EBP
1401
 
        POP     EBP
1402
 
        JMP     [_OpenSCManager]
1403
 
  end;
1404
 
end;
1405
 
 
1406
 
var
1407
 
  _OpenServiceA: Pointer;
1408
 
 
1409
 
function OpenServiceA;
1410
 
begin
1411
 
  GetProcedureAddress(_OpenServiceA, advapi32, 'OpenServiceA');
1412
 
  asm
1413
 
        MOV     ESP, EBP
1414
 
        POP     EBP
1415
 
        JMP     [_OpenServiceA]
1416
 
  end;
1417
 
end;
1418
 
 
1419
 
var
1420
 
  _OpenServiceW: Pointer;
1421
 
 
1422
 
function OpenServiceW;
1423
 
begin
1424
 
  GetProcedureAddress(_OpenServiceW, advapi32, 'OpenServiceW');
1425
 
  asm
1426
 
        MOV     ESP, EBP
1427
 
        POP     EBP
1428
 
        JMP     [_OpenServiceW]
1429
 
  end;
1430
 
end;
1431
 
 
1432
 
var
1433
 
  _OpenService: Pointer;
1434
 
 
1435
 
function OpenService;
1436
 
begin
1437
 
  GetProcedureAddress(_OpenService, advapi32, 'OpenService' + AWSuffix);
1438
 
  asm
1439
 
        MOV     ESP, EBP
1440
 
        POP     EBP
1441
 
        JMP     [_OpenService]
1442
 
  end;
1443
 
end;
1444
 
 
1445
 
var
1446
 
  _QueryServiceConfigA: Pointer;
1447
 
 
1448
 
function QueryServiceConfigA;
1449
 
begin
1450
 
  GetProcedureAddress(_QueryServiceConfigA, advapi32, 'QueryServiceConfigA');
1451
 
  asm
1452
 
        MOV     ESP, EBP
1453
 
        POP     EBP
1454
 
        JMP     [_QueryServiceConfigA]
1455
 
  end;
1456
 
end;
1457
 
 
1458
 
var
1459
 
  _QueryServiceConfigW: Pointer;
1460
 
 
1461
 
function QueryServiceConfigW;
1462
 
begin
1463
 
  GetProcedureAddress(_QueryServiceConfigW, advapi32, 'QueryServiceConfigW');
1464
 
  asm
1465
 
        MOV     ESP, EBP
1466
 
        POP     EBP
1467
 
        JMP     [_QueryServiceConfigW]
1468
 
  end;
1469
 
end;
1470
 
 
1471
 
var
1472
 
  _QueryServiceConfig: Pointer;
1473
 
 
1474
 
function QueryServiceConfig;
1475
 
begin
1476
 
  GetProcedureAddress(_QueryServiceConfig, advapi32, 'QueryServiceConfig' + AWSuffix);
1477
 
  asm
1478
 
        MOV     ESP, EBP
1479
 
        POP     EBP
1480
 
        JMP     [_QueryServiceConfig]
1481
 
  end;
1482
 
end;
1483
 
 
1484
 
var
1485
 
  _QueryServiceConfig2A: Pointer;
1486
 
 
1487
 
function QueryServiceConfig2A;
1488
 
begin
1489
 
  GetProcedureAddress(_QueryServiceConfig2A, advapi32, 'QueryServiceConfig2A');
1490
 
  asm
1491
 
        MOV     ESP, EBP
1492
 
        POP     EBP
1493
 
        JMP     [_QueryServiceConfig2A]
1494
 
  end;
1495
 
end;
1496
 
 
1497
 
var
1498
 
  _QueryServiceConfig2W: Pointer;
1499
 
 
1500
 
function QueryServiceConfig2W;
1501
 
begin
1502
 
  GetProcedureAddress(_QueryServiceConfig2W, advapi32, 'QueryServiceConfig2W');
1503
 
  asm
1504
 
        MOV     ESP, EBP
1505
 
        POP     EBP
1506
 
        JMP     [_QueryServiceConfig2W]
1507
 
  end;
1508
 
end;
1509
 
 
1510
 
var
1511
 
  _QueryServiceConfig2: Pointer;
1512
 
 
1513
 
function QueryServiceConfig2;
1514
 
begin
1515
 
  GetProcedureAddress(_QueryServiceConfig2, advapi32, 'QueryServiceConfig2' + AWSuffix);
1516
 
  asm
1517
 
        MOV     ESP, EBP
1518
 
        POP     EBP
1519
 
        JMP     [_QueryServiceConfig2]
1520
 
  end;
1521
 
end;
1522
 
 
1523
 
var
1524
 
  _QueryServiceLockStatusA: Pointer;
1525
 
 
1526
 
function QueryServiceLockStatusA;
1527
 
begin
1528
 
  GetProcedureAddress(_QueryServiceLockStatusA, advapi32, 'QueryServiceLockStatusA');
1529
 
  asm
1530
 
        MOV     ESP, EBP
1531
 
        POP     EBP
1532
 
        JMP     [_QueryServiceLockStatusA]
1533
 
  end;
1534
 
end;
1535
 
 
1536
 
var
1537
 
  _QueryServiceLockStatusW: Pointer;
1538
 
 
1539
 
function QueryServiceLockStatusW;
1540
 
begin
1541
 
  GetProcedureAddress(_QueryServiceLockStatusW, advapi32, 'QueryServiceLockStatusW');
1542
 
  asm
1543
 
        MOV     ESP, EBP
1544
 
        POP     EBP
1545
 
        JMP     [_QueryServiceLockStatusW]
1546
 
  end;
1547
 
end;
1548
 
 
1549
 
var
1550
 
  _QueryServiceLockStatus: Pointer;
1551
 
 
1552
 
function QueryServiceLockStatus;
1553
 
begin
1554
 
  GetProcedureAddress(_QueryServiceLockStatus, advapi32, 'QueryServiceLockStatus' + AWSuffix);
1555
 
  asm
1556
 
        MOV     ESP, EBP
1557
 
        POP     EBP
1558
 
        JMP     [_QueryServiceLockStatus]
1559
 
  end;
1560
 
end;
1561
 
 
1562
 
var
1563
 
  _QueryServiceObjectSecurity: Pointer;
1564
 
 
1565
 
function QueryServiceObjectSecurity;
1566
 
begin
1567
 
  GetProcedureAddress(_QueryServiceObjectSecurity, advapi32, 'QueryServiceObjectSecurity');
1568
 
  asm
1569
 
        MOV     ESP, EBP
1570
 
        POP     EBP
1571
 
        JMP     [_QueryServiceObjectSecurity]
1572
 
  end;
1573
 
end;
1574
 
 
1575
 
var
1576
 
  _QueryServiceStatus: Pointer;
1577
 
 
1578
 
function QueryServiceStatus;
1579
 
begin
1580
 
  GetProcedureAddress(_QueryServiceStatus, advapi32, 'QueryServiceStatus');
1581
 
  asm
1582
 
        MOV     ESP, EBP
1583
 
        POP     EBP
1584
 
        JMP     [_QueryServiceStatus]
1585
 
  end;
1586
 
end;
1587
 
 
1588
 
var
1589
 
  _QueryServiceStatusEx: Pointer;
1590
 
 
1591
 
function QueryServiceStatusEx;
1592
 
begin
1593
 
  GetProcedureAddress(_QueryServiceStatusEx, advapi32, 'QueryServiceStatusEx');
1594
 
  asm
1595
 
        MOV     ESP, EBP
1596
 
        POP     EBP
1597
 
        JMP     [_QueryServiceStatusEx]
1598
 
  end;
1599
 
end;
1600
 
 
1601
 
var
1602
 
  _RegisterServiceCtrlHandlerA: Pointer;
1603
 
 
1604
 
function RegisterServiceCtrlHandlerA;
1605
 
begin
1606
 
  GetProcedureAddress(_RegisterServiceCtrlHandlerA, advapi32, 'RegisterServiceCtrlHandlerA');
1607
 
  asm
1608
 
        MOV     ESP, EBP
1609
 
        POP     EBP
1610
 
        JMP     [_RegisterServiceCtrlHandlerA]
1611
 
  end;
1612
 
end;
1613
 
 
1614
 
var
1615
 
  _RegisterServiceCtrlHandlerW: Pointer;
1616
 
 
1617
 
function RegisterServiceCtrlHandlerW;
1618
 
begin
1619
 
  GetProcedureAddress(_RegisterServiceCtrlHandlerW, advapi32, 'RegisterServiceCtrlHandlerW');
1620
 
  asm
1621
 
        MOV     ESP, EBP
1622
 
        POP     EBP
1623
 
        JMP     [_RegisterServiceCtrlHandlerW]
1624
 
  end;
1625
 
end;
1626
 
 
1627
 
var
1628
 
  _RegisterServiceCtrlHandler: Pointer;
1629
 
 
1630
 
function RegisterServiceCtrlHandler;
1631
 
begin
1632
 
  GetProcedureAddress(_RegisterServiceCtrlHandler, advapi32, 'RegisterServiceCtrlHandler' + AWSuffix);
1633
 
  asm
1634
 
        MOV     ESP, EBP
1635
 
        POP     EBP
1636
 
        JMP     [_RegisterServiceCtrlHandler]
1637
 
  end;
1638
 
end;
1639
 
 
1640
 
var
1641
 
  _RegisterServiceCtrlHandlerExA: Pointer;
1642
 
 
1643
 
function RegisterServiceCtrlHandlerExA;
1644
 
begin
1645
 
  GetProcedureAddress(_RegisterServiceCtrlHandlerExA, advapi32, 'RegisterServiceCtrlHandlerExA');
1646
 
  asm
1647
 
        MOV     ESP, EBP
1648
 
        POP     EBP
1649
 
        JMP     [_RegisterServiceCtrlHandlerExA]
1650
 
  end;
1651
 
end;
1652
 
 
1653
 
var
1654
 
  _RegisterServiceCtrlHandlerExW: Pointer;
1655
 
 
1656
 
function RegisterServiceCtrlHandlerExW;
1657
 
begin
1658
 
  GetProcedureAddress(_RegisterServiceCtrlHandlerExW, advapi32, 'RegisterServiceCtrlHandlerExW');
1659
 
  asm
1660
 
        MOV     ESP, EBP
1661
 
        POP     EBP
1662
 
        JMP     [_RegisterServiceCtrlHandlerExW]
1663
 
  end;
1664
 
end;
1665
 
 
1666
 
var
1667
 
  _RegisterServiceCtrlHandlerEx: Pointer;
1668
 
 
1669
 
function RegisterServiceCtrlHandlerEx;
1670
 
begin
1671
 
  GetProcedureAddress(_RegisterServiceCtrlHandlerEx, advapi32, 'RegisterServiceCtrlHandlerEx' + AWSuffix);
1672
 
  asm
1673
 
        MOV     ESP, EBP
1674
 
        POP     EBP
1675
 
        JMP     [_RegisterServiceCtrlHandlerEx]
1676
 
  end;
1677
 
end;
1678
 
 
1679
 
var
1680
 
  _SetServiceObjectSecurity: Pointer;
1681
 
 
1682
 
function SetServiceObjectSecurity;
1683
 
begin
1684
 
  GetProcedureAddress(_SetServiceObjectSecurity, advapi32, 'SetServiceObjectSecurity');
1685
 
  asm
1686
 
        MOV     ESP, EBP
1687
 
        POP     EBP
1688
 
        JMP     [_SetServiceObjectSecurity]
1689
 
  end;
1690
 
end;
1691
 
 
1692
 
var
1693
 
  _SetServiceStatus: Pointer;
1694
 
 
1695
 
function SetServiceStatus;
1696
 
begin
1697
 
  GetProcedureAddress(_SetServiceStatus, advapi32, 'SetServiceStatus');
1698
 
  asm
1699
 
        MOV     ESP, EBP
1700
 
        POP     EBP
1701
 
        JMP     [_SetServiceStatus]
1702
 
  end;
1703
 
end;
1704
 
 
1705
 
var
1706
 
  _StartServiceCtrlDispatcherA: Pointer;
1707
 
 
1708
 
function StartServiceCtrlDispatcherA;
1709
 
begin
1710
 
  GetProcedureAddress(_StartServiceCtrlDispatcherA, advapi32, 'StartServiceCtrlDispatcherA');
1711
 
  asm
1712
 
        MOV     ESP, EBP
1713
 
        POP     EBP
1714
 
        JMP     [_StartServiceCtrlDispatcherA]
1715
 
  end;
1716
 
end;
1717
 
 
1718
 
var
1719
 
  _StartServiceCtrlDispatcherW: Pointer;
1720
 
 
1721
 
function StartServiceCtrlDispatcherW;
1722
 
begin
1723
 
  GetProcedureAddress(_StartServiceCtrlDispatcherW, advapi32, 'StartServiceCtrlDispatcherW');
1724
 
  asm
1725
 
        MOV     ESP, EBP
1726
 
        POP     EBP
1727
 
        JMP     [_StartServiceCtrlDispatcherW]
1728
 
  end;
1729
 
end;
1730
 
 
1731
 
var
1732
 
  _StartServiceCtrlDispatcher: Pointer;
1733
 
 
1734
 
function StartServiceCtrlDispatcher;
1735
 
begin
1736
 
  GetProcedureAddress(_StartServiceCtrlDispatcher, advapi32, 'StartServiceCtrlDispatcher' + AWSuffix);
1737
 
  asm
1738
 
        MOV     ESP, EBP
1739
 
        POP     EBP
1740
 
        JMP     [_StartServiceCtrlDispatcher]
1741
 
  end;
1742
 
end;
1743
 
 
1744
 
var
1745
 
  _StartServiceA: Pointer;
1746
 
 
1747
 
function StartServiceA;
1748
 
begin
1749
 
  GetProcedureAddress(_StartServiceA, advapi32, 'StartServiceA');
1750
 
  asm
1751
 
        MOV     ESP, EBP
1752
 
        POP     EBP
1753
 
        JMP     [_StartServiceA]
1754
 
  end;
1755
 
end;
1756
 
 
1757
 
var
1758
 
  _StartServiceW: Pointer;
1759
 
 
1760
 
function StartServiceW;
1761
 
begin
1762
 
  GetProcedureAddress(_StartServiceW, advapi32, 'StartServiceW');
1763
 
  asm
1764
 
        MOV     ESP, EBP
1765
 
        POP     EBP
1766
 
        JMP     [_StartServiceW]
1767
 
  end;
1768
 
end;
1769
 
 
1770
 
var
1771
 
  _StartService: Pointer;
1772
 
 
1773
 
function StartService;
1774
 
begin
1775
 
  GetProcedureAddress(_StartService, advapi32, 'StartService' + AWSuffix);
1776
 
  asm
1777
 
        MOV     ESP, EBP
1778
 
        POP     EBP
1779
 
        JMP     [_StartService]
1780
 
  end;
1781
 
end;
1782
 
 
1783
 
var
1784
 
  _UnlockServiceDatabase: Pointer;
1785
 
 
1786
 
function UnlockServiceDatabase;
1787
 
begin
1788
 
  GetProcedureAddress(_UnlockServiceDatabase, advapi32, 'UnlockServiceDatabase');
1789
 
  asm
1790
 
        MOV     ESP, EBP
1791
 
        POP     EBP
1792
 
        JMP     [_UnlockServiceDatabase]
1793
 
  end;
1794
 
end;
1795
 
 
1796
 
{$ELSE}
1797
 
 
1798
 
function ChangeServiceConfigA; external advapi32 name 'ChangeServiceConfigA';
1799
 
function ChangeServiceConfigW; external advapi32 name 'ChangeServiceConfigW';
1800
 
function ChangeServiceConfig; external advapi32 name 'ChangeServiceConfig' + AWSuffix;
1801
 
function ChangeServiceConfig2A; external advapi32 name 'ChangeServiceConfig2A';
1802
 
function ChangeServiceConfig2W; external advapi32 name 'ChangeServiceConfig2W';
1803
 
function ChangeServiceConfig2; external advapi32 name 'ChangeServiceConfig2' + AWSuffix;
1804
 
function CloseServiceHandle; external advapi32 name 'CloseServiceHandle';
1805
 
function ControlService; external advapi32 name 'ControlService';
1806
 
function CreateServiceA; external advapi32 name 'CreateServiceA';
1807
 
function CreateServiceW; external advapi32 name 'CreateServiceW';
1808
 
function CreateService; external advapi32 name 'CreateService' + AWSuffix;
1809
 
function DeleteService; external advapi32 name 'DeleteService';
1810
 
function EnumDependentServicesA; external advapi32 name 'EnumDependentServicesA';
1811
 
function EnumDependentServicesW; external advapi32 name 'EnumDependentServicesW';
1812
 
function EnumDependentServices; external advapi32 name 'EnumDependentServices' + AWSuffix;
1813
 
function EnumServicesStatusA; external advapi32 name 'EnumServicesStatusA';
1814
 
function EnumServicesStatusW; external advapi32 name 'EnumServicesStatusW';
1815
 
function EnumServicesStatus; external advapi32 name 'EnumServicesStatus' + AWSuffix;
1816
 
function EnumServicesStatusExA; external advapi32 name 'EnumServicesStatusExA';
1817
 
function EnumServicesStatusExW; external advapi32 name 'EnumServicesStatusExW';
1818
 
function EnumServicesStatusEx; external advapi32 name 'EnumServicesStatusEx' + AWSuffix;
1819
 
function GetServiceKeyNameA; external advapi32 name 'GetServiceKeyNameA';
1820
 
function GetServiceKeyNameW; external advapi32 name 'GetServiceKeyNameW';
1821
 
function GetServiceKeyName; external advapi32 name 'GetServiceKeyName' + AWSuffix;
1822
 
function GetServiceDisplayNameA; external advapi32 name 'GetServiceDisplayNameA';
1823
 
function GetServiceDisplayNameW; external advapi32 name 'GetServiceDisplayNameW';
1824
 
function GetServiceDisplayName; external advapi32 name 'GetServiceDisplayName' + AWSuffix;
1825
 
function LockServiceDatabase; external advapi32 name 'LockServiceDatabase';
1826
 
function NotifyBootConfigStatus; external advapi32 name 'NotifyBootConfigStatus';
1827
 
function OpenSCManagerA; external advapi32 name 'OpenSCManagerA';
1828
 
function OpenSCManagerW; external advapi32 name 'OpenSCManagerW';
1829
 
function OpenSCManager; external advapi32 name 'OpenSCManager' + AWSuffix;
1830
 
function OpenServiceA; external advapi32 name 'OpenServiceA';
1831
 
function OpenServiceW; external advapi32 name 'OpenServiceW';
1832
 
function OpenService; external advapi32 name 'OpenService' + AWSuffix;
1833
 
function QueryServiceConfigA; external advapi32 name 'QueryServiceConfigA';
1834
 
function QueryServiceConfigW; external advapi32 name 'QueryServiceConfigW';
1835
 
function QueryServiceConfig; external advapi32 name 'QueryServiceConfig' + AWSuffix;
1836
 
function QueryServiceConfig2A; external advapi32 name 'QueryServiceConfig2A';
1837
 
function QueryServiceConfig2W; external advapi32 name 'QueryServiceConfig2W';
1838
 
function QueryServiceConfig2; external advapi32 name 'QueryServiceConfig2' + AWSuffix;
1839
 
function QueryServiceLockStatusA; external advapi32 name 'QueryServiceLockStatusA';
1840
 
function QueryServiceLockStatusW; external advapi32 name 'QueryServiceLockStatusW';
1841
 
function QueryServiceLockStatus; external advapi32 name 'QueryServiceLockStatus' + AWSuffix;
1842
 
function QueryServiceObjectSecurity; external advapi32 name 'QueryServiceObjectSecurity';
1843
 
function QueryServiceStatus; external advapi32 name 'QueryServiceStatus';
1844
 
function QueryServiceStatusEx; external advapi32 name 'QueryServiceStatusEx';
1845
 
function RegisterServiceCtrlHandlerA; external advapi32 name 'RegisterServiceCtrlHandlerA';
1846
 
function RegisterServiceCtrlHandlerW; external advapi32 name 'RegisterServiceCtrlHandlerW';
1847
 
function RegisterServiceCtrlHandler; external advapi32 name 'RegisterServiceCtrlHandler' + AWSuffix;
1848
 
function RegisterServiceCtrlHandlerExA; external advapi32 name 'RegisterServiceCtrlHandlerExA';
1849
 
function RegisterServiceCtrlHandlerExW; external advapi32 name 'RegisterServiceCtrlHandlerExW';
1850
 
function RegisterServiceCtrlHandlerEx; external advapi32 name 'RegisterServiceCtrlHandlerEx' + AWSuffix;
1851
 
function SetServiceObjectSecurity; external advapi32 name 'SetServiceObjectSecurity';
1852
 
function SetServiceStatus; external advapi32 name 'SetServiceStatus';
1853
 
function StartServiceCtrlDispatcherA; external advapi32 name 'StartServiceCtrlDispatcherA';
1854
 
function StartServiceCtrlDispatcherW; external advapi32 name 'StartServiceCtrlDispatcherW';
1855
 
function StartServiceCtrlDispatcher; external advapi32 name 'StartServiceCtrlDispatcher' + AWSuffix;
1856
 
function StartServiceA; external advapi32 name 'StartServiceA';
1857
 
function StartServiceW; external advapi32 name 'StartServiceW';
1858
 
function StartService; external advapi32 name 'StartService' + AWSuffix;
1859
 
function UnlockServiceDatabase; external advapi32 name 'UnlockServiceDatabase';
1860
 
 
1861
 
{$ENDIF DYNAMIC_LINK}
1862
 
 
1863
 
end.
 
1
{******************************************************************************}
 
2
{                                                                              }
 
3
{ Services API interface Unit for Object Pascal                                }
 
4
{                                                                              }
 
5
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
 
6
{ Corporation. All Rights Reserved.                                            }
 
7
{                                                                              }
 
8
{ The original file is: winsvc.h, released June 2000. The original Pascal      }
 
9
{ code is: WinSvc.pas, released December 2000. The initial developer of the    }
 
10
{ Pascal code is Marcel van Brakel (brakelm att chello dott nl).               }
 
11
{                                                                              }
 
12
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
 
13
{ Marcel van Brakel. All Rights Reserved.                                      }
 
14
{                                                                              }
 
15
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
 
16
{                                                                              }
 
17
{ You may retrieve the latest version of this file at the Project JEDI         }
 
18
{ APILIB home page, located at http://jedi-apilib.sourceforge.net              }
 
19
{                                                                              }
 
20
{ The contents of this file are used with permission, subject to the Mozilla   }
 
21
{ Public License Version 1.1 (the "License"); you may not use this file except }
 
22
{ in compliance with the License. You may obtain a copy of the License at      }
 
23
{ http://www.mozilla.org/MPL/MPL-1.1.html                                      }
 
24
{                                                                              }
 
25
{ Software distributed under the License is distributed on an "AS IS" basis,   }
 
26
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
 
27
{ the specific language governing rights and limitations under the License.    }
 
28
{                                                                              }
 
29
{ Alternatively, the contents of this file may be used under the terms of the  }
 
30
{ GNU Lesser General Public License (the  "LGPL License"), in which case the   }
 
31
{ provisions of the LGPL License are applicable instead of those above.        }
 
32
{ If you wish to allow use of your version of this file only under the terms   }
 
33
{ of the LGPL License and not to allow others to use your version of this file }
 
34
{ under the MPL, indicate your decision by deleting  the provisions above and  }
 
35
{ replace  them with the notice and other provisions required by the LGPL      }
 
36
{ License.  If you do not delete the provisions above, a recipient may use     }
 
37
{ your version of this file under either the MPL or the LGPL License.          }
 
38
{                                                                              }
 
39
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
 
40
{                                                                              }
 
41
{******************************************************************************}
 
42
 
 
43
 
 
44
unit JwaWinSvc;
 
45
 
 
46
{$WEAKPACKAGEUNIT}
 
47
 
 
48
{$HPPEMIT ''}
 
49
{$HPPEMIT '#include "WinSvc.h"'}
 
50
{$HPPEMIT ''}
 
51
 
 
52
{$I jediapilib.inc}
 
53
 
 
54
interface
 
55
 
 
56
uses
 
57
  JwaWinNT, JwaWinType;
 
58
 
 
59
//
 
60
// Service database names
 
61
//
 
62
 
 
63
const
 
64
  SERVICES_ACTIVE_DATABASEW = 'ServicesActive';
 
65
  {$EXTERNALSYM SERVICES_ACTIVE_DATABASEW}
 
66
  SERVICES_FAILED_DATABASEW = 'ServicesFailed';
 
67
  {$EXTERNALSYM SERVICES_FAILED_DATABASEW}
 
68
 
 
69
  SERVICES_ACTIVE_DATABASEA = 'ServicesActive';
 
70
  {$EXTERNALSYM SERVICES_ACTIVE_DATABASEA}
 
71
  SERVICES_FAILED_DATABASEA = 'ServicesFailed';
 
72
  {$EXTERNALSYM SERVICES_FAILED_DATABASEA}
 
73
 
 
74
//
 
75
// Character to designate that a name is a group
 
76
//
 
77
 
 
78
  SC_GROUP_IDENTIFIERW = '+';
 
79
  {$EXTERNALSYM SC_GROUP_IDENTIFIERW}
 
80
  SC_GROUP_IDENTIFIERA = '+';
 
81
  {$EXTERNALSYM SC_GROUP_IDENTIFIERA}
 
82
 
 
83
  {$IFDEF UNICODE}
 
84
 
 
85
  SERVICES_ACTIVE_DATABASE = SERVICES_ACTIVE_DATABASEW;
 
86
  {$EXTERNALSYM SERVICES_ACTIVE_DATABASE}
 
87
  SERVICES_FAILED_DATABASE = SERVICES_FAILED_DATABASEW;
 
88
  {$EXTERNALSYM SERVICES_FAILED_DATABASE}
 
89
 
 
90
  SC_GROUP_IDENTIFIER = SC_GROUP_IDENTIFIERW;
 
91
  {$EXTERNALSYM SC_GROUP_IDENTIFIER}
 
92
 
 
93
  {$ELSE}
 
94
 
 
95
  SERVICES_ACTIVE_DATABASE = SERVICES_ACTIVE_DATABASEA;
 
96
  {$EXTERNALSYM SERVICES_ACTIVE_DATABASE}
 
97
  SERVICES_FAILED_DATABASE = SERVICES_FAILED_DATABASEA;
 
98
  {$EXTERNALSYM SERVICES_FAILED_DATABASE}
 
99
 
 
100
  SC_GROUP_IDENTIFIER = SC_GROUP_IDENTIFIERA;
 
101
  {$EXTERNALSYM SC_GROUP_IDENTIFIER}
 
102
 
 
103
  {$ENDIF UNICODE}
 
104
 
 
105
//
 
106
// Value to indicate no change to an optional parameter
 
107
//
 
108
 
 
109
  SERVICE_NO_CHANGE = $ffffffff;
 
110
  {$EXTERNALSYM SERVICE_NO_CHANGE}
 
111
 
 
112
//
 
113
// Service State -- for Enum Requests (Bit Mask)
 
114
//
 
115
 
 
116
  SERVICE_ACTIVE    = $00000001;
 
117
  {$EXTERNALSYM SERVICE_ACTIVE}
 
118
  SERVICE_INACTIVE  = $00000002;
 
119
  {$EXTERNALSYM SERVICE_INACTIVE}
 
120
  SERVICE_STATE_ALL = SERVICE_ACTIVE or SERVICE_INACTIVE;
 
121
  {$EXTERNALSYM SERVICE_STATE_ALL}
 
122
 
 
123
//
 
124
// Controls
 
125
//
 
126
 
 
127
  SERVICE_CONTROL_STOP                  = $00000001;
 
128
  {$EXTERNALSYM SERVICE_CONTROL_STOP}
 
129
  SERVICE_CONTROL_PAUSE                 = $00000002;
 
130
  {$EXTERNALSYM SERVICE_CONTROL_PAUSE}
 
131
  SERVICE_CONTROL_CONTINUE              = $00000003;
 
132
  {$EXTERNALSYM SERVICE_CONTROL_CONTINUE}
 
133
  SERVICE_CONTROL_INTERROGATE           = $00000004;
 
134
  {$EXTERNALSYM SERVICE_CONTROL_INTERROGATE}
 
135
  SERVICE_CONTROL_SHUTDOWN              = $00000005;
 
136
  {$EXTERNALSYM SERVICE_CONTROL_SHUTDOWN}
 
137
  SERVICE_CONTROL_PARAMCHANGE           = $00000006;
 
138
  {$EXTERNALSYM SERVICE_CONTROL_PARAMCHANGE}
 
139
  SERVICE_CONTROL_NETBINDADD            = $00000007;
 
140
  {$EXTERNALSYM SERVICE_CONTROL_NETBINDADD}
 
141
  SERVICE_CONTROL_NETBINDREMOVE         = $00000008;
 
142
  {$EXTERNALSYM SERVICE_CONTROL_NETBINDREMOVE}
 
143
  SERVICE_CONTROL_NETBINDENABLE         = $00000009;
 
144
  {$EXTERNALSYM SERVICE_CONTROL_NETBINDENABLE}
 
145
  SERVICE_CONTROL_NETBINDDISABLE        = $0000000A;
 
146
  {$EXTERNALSYM SERVICE_CONTROL_NETBINDDISABLE}
 
147
  SERVICE_CONTROL_DEVICEEVENT           = $0000000B;
 
148
  {$EXTERNALSYM SERVICE_CONTROL_DEVICEEVENT}
 
149
  SERVICE_CONTROL_HARDWAREPROFILECHANGE = $0000000C;
 
150
  {$EXTERNALSYM SERVICE_CONTROL_HARDWAREPROFILECHANGE}
 
151
  SERVICE_CONTROL_POWEREVENT            = $0000000D;
 
152
  {$EXTERNALSYM SERVICE_CONTROL_POWEREVENT}
 
153
  SERVICE_CONTROL_SESSIONCHANGE         = $0000000E;
 
154
  {$EXTERNALSYM SERVICE_CONTROL_SESSIONCHANGE}
 
155
 
 
156
//
 
157
// Service State -- for CurrentState
 
158
//
 
159
 
 
160
  SERVICE_STOPPED          = $00000001;
 
161
  {$EXTERNALSYM SERVICE_STOPPED}
 
162
  SERVICE_START_PENDING    = $00000002;
 
163
  {$EXTERNALSYM SERVICE_START_PENDING}
 
164
  SERVICE_STOP_PENDING     = $00000003;
 
165
  {$EXTERNALSYM SERVICE_STOP_PENDING}
 
166
  SERVICE_RUNNING          = $00000004;
 
167
  {$EXTERNALSYM SERVICE_RUNNING}
 
168
  SERVICE_CONTINUE_PENDING = $00000005;
 
169
  {$EXTERNALSYM SERVICE_CONTINUE_PENDING}
 
170
  SERVICE_PAUSE_PENDING    = $00000006;
 
171
  {$EXTERNALSYM SERVICE_PAUSE_PENDING}
 
172
  SERVICE_PAUSED           = $00000007;
 
173
  {$EXTERNALSYM SERVICE_PAUSED}
 
174
 
 
175
//
 
176
// Controls Accepted  (Bit Mask)
 
177
//
 
178
 
 
179
  SERVICE_ACCEPT_STOP                  = $00000001;
 
180
  {$EXTERNALSYM SERVICE_ACCEPT_STOP}
 
181
  SERVICE_ACCEPT_PAUSE_CONTINUE        = $00000002;
 
182
  {$EXTERNALSYM SERVICE_ACCEPT_PAUSE_CONTINUE}
 
183
  SERVICE_ACCEPT_SHUTDOWN              = $00000004;
 
184
  {$EXTERNALSYM SERVICE_ACCEPT_SHUTDOWN}
 
185
  SERVICE_ACCEPT_PARAMCHANGE           = $00000008;
 
186
  {$EXTERNALSYM SERVICE_ACCEPT_PARAMCHANGE}
 
187
  SERVICE_ACCEPT_NETBINDCHANGE         = $00000010;
 
188
  {$EXTERNALSYM SERVICE_ACCEPT_NETBINDCHANGE}
 
189
  SERVICE_ACCEPT_HARDWAREPROFILECHANGE = $00000020;
 
190
  {$EXTERNALSYM SERVICE_ACCEPT_HARDWAREPROFILECHANGE}
 
191
  SERVICE_ACCEPT_POWEREVENT            = $00000040;
 
192
  {$EXTERNALSYM SERVICE_ACCEPT_POWEREVENT}
 
193
  SERVICE_ACCEPT_SESSIONCHANGE         = $00000080;
 
194
  {$EXTERNALSYM SERVICE_ACCEPT_SESSIONCHANGE}
 
195
 
 
196
//
 
197
// Service Control Manager object specific access types
 
198
//
 
199
 
 
200
  SC_MANAGER_CONNECT            = $0001;
 
201
  {$EXTERNALSYM SC_MANAGER_CONNECT}
 
202
  SC_MANAGER_CREATE_SERVICE     = $0002;
 
203
  {$EXTERNALSYM SC_MANAGER_CREATE_SERVICE}
 
204
  SC_MANAGER_ENUMERATE_SERVICE  = $0004;
 
205
  {$EXTERNALSYM SC_MANAGER_ENUMERATE_SERVICE}
 
206
  SC_MANAGER_LOCK               = $0008;
 
207
  {$EXTERNALSYM SC_MANAGER_LOCK}
 
208
  SC_MANAGER_QUERY_LOCK_STATUS  = $0010;
 
209
  {$EXTERNALSYM SC_MANAGER_QUERY_LOCK_STATUS}
 
210
  SC_MANAGER_MODIFY_BOOT_CONFIG = $0020;
 
211
  {$EXTERNALSYM SC_MANAGER_MODIFY_BOOT_CONFIG}
 
212
 
 
213
  SC_MANAGER_ALL_ACCESS         = STANDARD_RIGHTS_REQUIRED or
 
214
                                  SC_MANAGER_CONNECT or
 
215
                                  SC_MANAGER_CREATE_SERVICE or
 
216
                                  SC_MANAGER_ENUMERATE_SERVICE or
 
217
                                  SC_MANAGER_LOCK or
 
218
                                  SC_MANAGER_QUERY_LOCK_STATUS or
 
219
                                  SC_MANAGER_MODIFY_BOOT_CONFIG;
 
220
  {$EXTERNALSYM SC_MANAGER_ALL_ACCESS}
 
221
 
 
222
//
 
223
// Service object specific access type
 
224
//
 
225
 
 
226
  SERVICE_QUERY_CONFIG         = $0001;
 
227
  {$EXTERNALSYM SERVICE_QUERY_CONFIG}
 
228
  SERVICE_CHANGE_CONFIG        = $0002;
 
229
  {$EXTERNALSYM SERVICE_CHANGE_CONFIG}
 
230
  SERVICE_QUERY_STATUS         = $0004;
 
231
  {$EXTERNALSYM SERVICE_QUERY_STATUS}
 
232
  SERVICE_ENUMERATE_DEPENDENTS = $0008;
 
233
  {$EXTERNALSYM SERVICE_ENUMERATE_DEPENDENTS}
 
234
  SERVICE_START                = $0010;
 
235
  {$EXTERNALSYM SERVICE_START}
 
236
  SERVICE_STOP                 = $0020;
 
237
  {$EXTERNALSYM SERVICE_STOP}
 
238
  SERVICE_PAUSE_CONTINUE       = $0040;
 
239
  {$EXTERNALSYM SERVICE_PAUSE_CONTINUE}
 
240
  SERVICE_INTERROGATE          = $0080;
 
241
  {$EXTERNALSYM SERVICE_INTERROGATE}
 
242
  SERVICE_USER_DEFINED_CONTROL = $0100;
 
243
  {$EXTERNALSYM SERVICE_USER_DEFINED_CONTROL}
 
244
 
 
245
  SERVICE_ALL_ACCESS           = STANDARD_RIGHTS_REQUIRED or
 
246
                                 SERVICE_QUERY_CONFIG or
 
247
                                 SERVICE_CHANGE_CONFIG or
 
248
                                 SERVICE_QUERY_STATUS or
 
249
                                 SERVICE_ENUMERATE_DEPENDENTS or
 
250
                                 SERVICE_START or
 
251
                                 SERVICE_STOP or
 
252
                                 SERVICE_PAUSE_CONTINUE or
 
253
                                 SERVICE_INTERROGATE or
 
254
                                 SERVICE_USER_DEFINED_CONTROL;
 
255
  {$EXTERNALSYM SERVICE_ALL_ACCESS}
 
256
 
 
257
//
 
258
// Service flags for QueryServiceStatusEx
 
259
//
 
260
 
 
261
  SERVICE_RUNS_IN_SYSTEM_PROCESS = $00000001;
 
262
  {$EXTERNALSYM SERVICE_RUNS_IN_SYSTEM_PROCESS}
 
263
 
 
264
//
 
265
// Info levels for ChangeServiceConfig2 and QueryServiceConfig2
 
266
//
 
267
 
 
268
  SERVICE_CONFIG_DESCRIPTION     = 1;
 
269
  {$EXTERNALSYM SERVICE_CONFIG_DESCRIPTION}
 
270
  SERVICE_CONFIG_FAILURE_ACTIONS = 2;
 
271
  {$EXTERNALSYM SERVICE_CONFIG_FAILURE_ACTIONS}
 
272
 
 
273
//
 
274
// Service description string
 
275
//
 
276
 
 
277
type
 
278
  LPSERVICE_DESCRIPTIONA = ^SERVICE_DESCRIPTIONA;
 
279
  {$EXTERNALSYM LPSERVICE_DESCRIPTIONA}
 
280
  _SERVICE_DESCRIPTIONA = record
 
281
    lpDescription: LPSTR;
 
282
  end;
 
283
  {$EXTERNALSYM _SERVICE_DESCRIPTIONA}
 
284
  SERVICE_DESCRIPTIONA = _SERVICE_DESCRIPTIONA;
 
285
  {$EXTERNALSYM SERVICE_DESCRIPTIONA}
 
286
  TServiceDescriptionA = SERVICE_DESCRIPTIONA;
 
287
  PServiceDescriptionA = LPSERVICE_DESCRIPTIONA;
 
288
 
 
289
//
 
290
// Service description string
 
291
//
 
292
 
 
293
  LPSERVICE_DESCRIPTIONW = ^SERVICE_DESCRIPTIONW;
 
294
  {$EXTERNALSYM LPSERVICE_DESCRIPTIONW}
 
295
  _SERVICE_DESCRIPTIONW = record
 
296
    lpDescription: LPWSTR;
 
297
  end;
 
298
  {$EXTERNALSYM _SERVICE_DESCRIPTIONW}
 
299
  SERVICE_DESCRIPTIONW = _SERVICE_DESCRIPTIONW;
 
300
  {$EXTERNALSYM SERVICE_DESCRIPTIONW}
 
301
  TServiceDescriptionW = SERVICE_DESCRIPTIONW;
 
302
  PServiceDescriptionW = LPSERVICE_DESCRIPTIONW;
 
303
 
 
304
  {$IFDEF UNICODE}
 
305
  SERVICE_DESCRIPTION = SERVICE_DESCRIPTIONW;
 
306
  {$EXTERNALSYM SERVICE_DESCRIPTION}
 
307
  LPSERVICE_DESCRIPTION = LPSERVICE_DESCRIPTIONW;
 
308
  {$EXTERNALSYM LPSERVICE_DESCRIPTION}
 
309
  TServiceDescription = TServiceDescriptionW;
 
310
  PServiceDescription = PServiceDescriptionW;
 
311
  {$ELSE}
 
312
  SERVICE_DESCRIPTION = SERVICE_DESCRIPTIONA;
 
313
  {$EXTERNALSYM SERVICE_DESCRIPTION}
 
314
  LPSERVICE_DESCRIPTION = LPSERVICE_DESCRIPTIONA;
 
315
  {$EXTERNALSYM LPSERVICE_DESCRIPTION}
 
316
  TServiceDescription = TServiceDescriptionA;
 
317
  PServiceDescription = PServiceDescriptionA;
 
318
  {$ENDIF UNICODE}
 
319
 
 
320
//
 
321
// Actions to take on service failure
 
322
//
 
323
 
 
324
  _SC_ACTION_TYPE = (SC_ACTION_NONE, SC_ACTION_RESTART, SC_ACTION_REBOOT,
 
325
    SC_ACTION_RUN_COMMAND);
 
326
  {$EXTERNALSYM _SC_ACTION_TYPE}
 
327
  SC_ACTION_TYPE = _SC_ACTION_TYPE;
 
328
  {$EXTERNALSYM SC_ACTION_TYPE}
 
329
  TScActionType = _SC_ACTION_TYPE;
 
330
 
 
331
  LPSC_ACTION = ^SC_ACTION;
 
332
  {$EXTERNALSYM LPSC_ACTION}
 
333
  _SC_ACTION = record
 
334
    Type_: SC_ACTION_TYPE;
 
335
    Delay: DWORD;
 
336
  end;
 
337
  {$EXTERNALSYM _SC_ACTION}
 
338
  SC_ACTION = _SC_ACTION;
 
339
  {$EXTERNALSYM SC_ACTION}
 
340
  TScAction = SC_ACTION;
 
341
  PScAction = LPSC_ACTION;
 
342
 
 
343
  LPSERVICE_FAILURE_ACTIONSA = ^SERVICE_FAILURE_ACTIONSA;
 
344
  {$EXTERNALSYM LPSERVICE_FAILURE_ACTIONSA}
 
345
  _SERVICE_FAILURE_ACTIONSA = record
 
346
    dwResetPeriod: DWORD;
 
347
    lpRebootMsg: LPSTR;
 
348
    lpCommand: LPSTR;
 
349
    cActions: DWORD;
 
350
    lpsaActions: LPSC_ACTION;
 
351
  end;
 
352
  {$EXTERNALSYM _SERVICE_FAILURE_ACTIONSA}
 
353
  SERVICE_FAILURE_ACTIONSA = _SERVICE_FAILURE_ACTIONSA;
 
354
  {$EXTERNALSYM SERVICE_FAILURE_ACTIONSA}
 
355
  TServiceFailureActionsA = SERVICE_FAILURE_ACTIONSA;
 
356
  PServiceFailureActionsA = LPSERVICE_FAILURE_ACTIONSA;
 
357
 
 
358
  LPSERVICE_FAILURE_ACTIONSW = ^SERVICE_FAILURE_ACTIONSW;
 
359
  {$EXTERNALSYM LPSERVICE_FAILURE_ACTIONSW}
 
360
  _SERVICE_FAILURE_ACTIONSW = record
 
361
    dwResetPeriod: DWORD;
 
362
    lpRebootMsg: LPWSTR;
 
363
    lpCommand: LPWSTR;
 
364
    cActions: DWORD;
 
365
    lpsaActions: LPSC_ACTION;
 
366
  end;
 
367
  {$EXTERNALSYM _SERVICE_FAILURE_ACTIONSW}
 
368
  SERVICE_FAILURE_ACTIONSW = _SERVICE_FAILURE_ACTIONSW;
 
369
  {$EXTERNALSYM SERVICE_FAILURE_ACTIONSW}
 
370
  TServiceFailureActionsW = SERVICE_FAILURE_ACTIONSW;
 
371
  PServiceFailureActionsW = LPSERVICE_FAILURE_ACTIONSW;
 
372
 
 
373
  {$IFDEF UNICODE}
 
374
  SERVICE_FAILURE_ACTIONS = SERVICE_FAILURE_ACTIONSW;
 
375
  {$EXTERNALSYM SERVICE_FAILURE_ACTIONS}
 
376
  LPSERVICE_FAILURE_ACTIONS = LPSERVICE_FAILURE_ACTIONSW;
 
377
  {$EXTERNALSYM LPSERVICE_FAILURE_ACTIONS}
 
378
  TServiceFailureActions = TServiceFailureActionsW;
 
379
  PServiceFailureActions = PServiceFailureActionsW;
 
380
  {$ELSE}
 
381
  SERVICE_FAILURE_ACTIONS = SERVICE_FAILURE_ACTIONSA;
 
382
  {$EXTERNALSYM SERVICE_FAILURE_ACTIONS}
 
383
  LPSERVICE_FAILURE_ACTIONS = LPSERVICE_FAILURE_ACTIONSA;
 
384
  {$EXTERNALSYM LPSERVICE_FAILURE_ACTIONS}
 
385
  TServiceFailureActions = TServiceFailureActionsA;
 
386
  PServiceFailureActions = PServiceFailureActionsA;
 
387
  {$ENDIF UNICODE}
 
388
 
 
389
//
 
390
// Handle Types
 
391
//
 
392
 
 
393
  SC_HANDLE = HANDLE;
 
394
  {$EXTERNALSYM SC_HANDLE}
 
395
  LPSC_HANDLE = ^SC_HANDLE;
 
396
  {$EXTERNALSYM LPSC_HANDLE}
 
397
 
 
398
  SERVICE_STATUS_HANDLE = HANDLE;
 
399
  {$EXTERNALSYM SERVICE_STATUS_HANDLE}
 
400
 
 
401
//
 
402
// Info levels for QueryServiceStatusEx
 
403
//
 
404
 
 
405
  _SC_STATUS_TYPE = (SC_STATUS_PROCESS_INFO);
 
406
  {$EXTERNALSYM _SC_STATUS_TYPE}
 
407
  SC_STATUS_TYPE = _SC_STATUS_TYPE;
 
408
  {$EXTERNALSYM SC_STATUS_TYPE}
 
409
 
 
410
//
 
411
// Info levels for EnumServicesStatusEx
 
412
//
 
413
 
 
414
  _SC_ENUM_TYPE = (SC_ENUM_PROCESS_INFO);
 
415
  {$EXTERNALSYM _SC_ENUM_TYPE}
 
416
  SC_ENUM_TYPE = _SC_ENUM_TYPE;
 
417
  {$EXTERNALSYM SC_ENUM_TYPE}
 
418
 
 
419
//
 
420
// Service Status Structures
 
421
//
 
422
 
 
423
  LPSERVICE_STATUS = ^SERVICE_STATUS;
 
424
  {$EXTERNALSYM LPSERVICE_STATUS}
 
425
  _SERVICE_STATUS = record
 
426
    dwServiceType: DWORD;
 
427
    dwCurrentState: DWORD;
 
428
    dwControlsAccepted: DWORD;
 
429
    dwWin32ExitCode: DWORD;
 
430
    dwServiceSpecificExitCode: DWORD;
 
431
    dwCheckPoint: DWORD;
 
432
    dwWaitHint: DWORD;
 
433
  end;
 
434
  {$EXTERNALSYM _SERVICE_STATUS}
 
435
  SERVICE_STATUS = _SERVICE_STATUS;
 
436
  {$EXTERNALSYM SERVICE_STATUS}
 
437
  TServiceStatus = SERVICE_STATUS;
 
438
  PServiceStatus = LPSERVICE_STATUS;
 
439
 
 
440
  LPSERVICE_STATUS_PROCESS = ^SERVICE_STATUS_PROCESS;
 
441
  {$EXTERNALSYM LPSERVICE_STATUS_PROCESS}
 
442
  _SERVICE_STATUS_PROCESS = record
 
443
    dwServiceType: DWORD;
 
444
    dwCurrentState: DWORD;
 
445
    dwControlsAccepted: DWORD;
 
446
    dwWin32ExitCode: DWORD;
 
447
    dwServiceSpecificExitCode: DWORD;
 
448
    dwCheckPoint: DWORD;
 
449
    dwWaitHint: DWORD;
 
450
    dwProcessId: DWORD;
 
451
    dwServiceFlags: DWORD;
 
452
  end;
 
453
  {$EXTERNALSYM _SERVICE_STATUS_PROCESS}
 
454
  SERVICE_STATUS_PROCESS = _SERVICE_STATUS_PROCESS;
 
455
  {$EXTERNALSYM SERVICE_STATUS_PROCESS}
 
456
  TServiceStatusProcess = SERVICE_STATUS_PROCESS;
 
457
  PServiceStatusProcess = LPSERVICE_STATUS_PROCESS;
 
458
 
 
459
//
 
460
// Service Status Enumeration Structure
 
461
//
 
462
 
 
463
  LPENUM_SERVICE_STATUSA = ^ENUM_SERVICE_STATUSA;
 
464
  {$EXTERNALSYM LPENUM_SERVICE_STATUSA}
 
465
  _ENUM_SERVICE_STATUSA = record
 
466
    lpServiceName: LPSTR;
 
467
    lpDisplayName: LPSTR;
 
468
    ServiceStatus: SERVICE_STATUS;
 
469
  end;
 
470
  {$EXTERNALSYM _ENUM_SERVICE_STATUSA}
 
471
  ENUM_SERVICE_STATUSA = _ENUM_SERVICE_STATUSA;
 
472
  {$EXTERNALSYM ENUM_SERVICE_STATUSA}
 
473
  TEnumServiceStatusA = ENUM_SERVICE_STATUSA;
 
474
  PEnumServiceStatusA = LPENUM_SERVICE_STATUSA;
 
475
 
 
476
  LPENUM_SERVICE_STATUSW = ^ENUM_SERVICE_STATUSW;
 
477
  {$EXTERNALSYM LPENUM_SERVICE_STATUSW}
 
478
  _ENUM_SERVICE_STATUSW = record
 
479
    lpServiceName: LPWSTR;
 
480
    lpDisplayName: LPWSTR;
 
481
    ServiceStatus: SERVICE_STATUS;
 
482
  end;
 
483
  {$EXTERNALSYM _ENUM_SERVICE_STATUSW}
 
484
  ENUM_SERVICE_STATUSW = _ENUM_SERVICE_STATUSW;
 
485
  {$EXTERNALSYM ENUM_SERVICE_STATUSW}
 
486
  TEnumServiceStatusW = ENUM_SERVICE_STATUSW;
 
487
  PEnumServiceStatusW = LPENUM_SERVICE_STATUSW;
 
488
 
 
489
  {$IFDEF UNICODE}
 
490
  ENUM_SERVICE_STATUS = ENUM_SERVICE_STATUSW;
 
491
  {$EXTERNALSYM ENUM_SERVICE_STATUS}
 
492
  LPENUM_SERVICE_STATUS = LPENUM_SERVICE_STATUSW;
 
493
  {$EXTERNALSYM LPENUM_SERVICE_STATUS}
 
494
  TEnumServiceStatus = TEnumServiceStatusW;
 
495
  PEnumServiceStatus = PEnumServiceStatusW;
 
496
  {$ELSE}
 
497
  ENUM_SERVICE_STATUS = ENUM_SERVICE_STATUSA;
 
498
  {$EXTERNALSYM ENUM_SERVICE_STATUS}
 
499
  LPENUM_SERVICE_STATUS = LPENUM_SERVICE_STATUSA;
 
500
  {$EXTERNALSYM LPENUM_SERVICE_STATUS}
 
501
  TEnumServiceStatus = TEnumServiceStatusA;
 
502
  PEnumServiceStatus = PEnumServiceStatusA;
 
503
  {$ENDIF UNICODE}
 
504
 
 
505
  LPENUM_SERVICE_STATUS_PROCESSA = ^ENUM_SERVICE_STATUS_PROCESSA;
 
506
  {$EXTERNALSYM LPENUM_SERVICE_STATUS_PROCESSA}
 
507
  _ENUM_SERVICE_STATUS_PROCESSA = record
 
508
    lpServiceName: LPSTR;
 
509
    lpDisplayName: LPSTR;
 
510
    ServiceStatusProcess: SERVICE_STATUS_PROCESS;
 
511
  end;
 
512
  {$EXTERNALSYM _ENUM_SERVICE_STATUS_PROCESSA}
 
513
  ENUM_SERVICE_STATUS_PROCESSA = _ENUM_SERVICE_STATUS_PROCESSA;
 
514
  {$EXTERNALSYM ENUM_SERVICE_STATUS_PROCESSA}
 
515
  TEnumServiceStatusProcessA = ENUM_SERVICE_STATUS_PROCESSA;
 
516
  PEnumServiceStatusProcessA = LPENUM_SERVICE_STATUS_PROCESSA;
 
517
 
 
518
  LPENUM_SERVICE_STATUS_PROCESSW = ^ENUM_SERVICE_STATUS_PROCESSW;
 
519
  {$EXTERNALSYM LPENUM_SERVICE_STATUS_PROCESSW}
 
520
  _ENUM_SERVICE_STATUS_PROCESSW = record
 
521
    lpServiceName: LPWSTR;
 
522
    lpDisplayName: LPWSTR;
 
523
    ServiceStatusProcess: SERVICE_STATUS_PROCESS;
 
524
  end;
 
525
  {$EXTERNALSYM _ENUM_SERVICE_STATUS_PROCESSW}
 
526
  ENUM_SERVICE_STATUS_PROCESSW = _ENUM_SERVICE_STATUS_PROCESSW;
 
527
  {$EXTERNALSYM ENUM_SERVICE_STATUS_PROCESSW}
 
528
  TEnumServiceStatusProcessW = ENUM_SERVICE_STATUS_PROCESSW;
 
529
  PEnumServiceStatusProcessW = LPENUM_SERVICE_STATUS_PROCESSW;
 
530
 
 
531
  {$IFDEF UNICODE}
 
532
  ENUM_SERVICE_STATUS_PROCESS = ENUM_SERVICE_STATUS_PROCESSW;
 
533
  {$EXTERNALSYM ENUM_SERVICE_STATUS_PROCESS}
 
534
  LPENUM_SERVICE_STATUS_PROCESS = LPENUM_SERVICE_STATUS_PROCESSW;
 
535
  {$EXTERNALSYM LPENUM_SERVICE_STATUS_PROCESS}
 
536
  TEnumServiceStatusProcess = TEnumServiceStatusProcessW;
 
537
  PEnumServiceStatusProcess = PEnumServiceStatusProcessW;
 
538
  {$ELSE}
 
539
  ENUM_SERVICE_STATUS_PROCESS = ENUM_SERVICE_STATUS_PROCESSA;
 
540
  {$EXTERNALSYM ENUM_SERVICE_STATUS_PROCESS}
 
541
  LPENUM_SERVICE_STATUS_PROCESS = LPENUM_SERVICE_STATUS_PROCESSA;
 
542
  {$EXTERNALSYM LPENUM_SERVICE_STATUS_PROCESS}
 
543
  TEnumServiceStatusProcess = TEnumServiceStatusProcessA;
 
544
  PEnumServiceStatusProcess = PEnumServiceStatusProcessA;
 
545
  {$ENDIF UNICODE}
 
546
 
 
547
//
 
548
// Structures for the Lock API functions
 
549
//
 
550
 
 
551
  SC_LOCK = LPVOID;
 
552
  {$EXTERNALSYM SC_LOCK}
 
553
 
 
554
  LPQUERY_SERVICE_LOCK_STATUSA = ^QUERY_SERVICE_LOCK_STATUSA;
 
555
  {$EXTERNALSYM LPQUERY_SERVICE_LOCK_STATUSA}
 
556
  _QUERY_SERVICE_LOCK_STATUSA = record
 
557
    fIsLocked: DWORD;
 
558
    lpLockOwner: LPSTR;
 
559
    dwLockDuration: DWORD;
 
560
  end;
 
561
  {$EXTERNALSYM _QUERY_SERVICE_LOCK_STATUSA}
 
562
  QUERY_SERVICE_LOCK_STATUSA = _QUERY_SERVICE_LOCK_STATUSA;
 
563
  {$EXTERNALSYM QUERY_SERVICE_LOCK_STATUSA}
 
564
  TQueryServiceLockStatusA = QUERY_SERVICE_LOCK_STATUSA;
 
565
  PQueryServiceLockStatusA = LPQUERY_SERVICE_LOCK_STATUSA;
 
566
 
 
567
  LPQUERY_SERVICE_LOCK_STATUSW = ^QUERY_SERVICE_LOCK_STATUSW;
 
568
  {$EXTERNALSYM LPQUERY_SERVICE_LOCK_STATUSW}
 
569
  _QUERY_SERVICE_LOCK_STATUSW = record
 
570
    fIsLocked: DWORD;
 
571
    lpLockOwner: LPWSTR;
 
572
    dwLockDuration: DWORD;
 
573
  end;
 
574
  {$EXTERNALSYM _QUERY_SERVICE_LOCK_STATUSW}
 
575
  QUERY_SERVICE_LOCK_STATUSW = _QUERY_SERVICE_LOCK_STATUSW;
 
576
  {$EXTERNALSYM QUERY_SERVICE_LOCK_STATUSW}
 
577
  TQueryServiceLockStatusW = QUERY_SERVICE_LOCK_STATUSW;
 
578
  PQueryServiceLockStatusW = LPQUERY_SERVICE_LOCK_STATUSW;
 
579
 
 
580
  {$IFDEF UNICODE}
 
581
  QUERY_SERVICE_LOCK_STATUS = QUERY_SERVICE_LOCK_STATUSW;
 
582
  {$EXTERNALSYM QUERY_SERVICE_LOCK_STATUS}
 
583
  LPQUERY_SERVICE_LOCK_STATUS = LPQUERY_SERVICE_LOCK_STATUSW;
 
584
  {$EXTERNALSYM LPQUERY_SERVICE_LOCK_STATUS}
 
585
  TQueryServiceLockStatus = TQueryServiceLockStatusW;
 
586
  PQueryServiceLockStatus = PQueryServiceLockStatusW;
 
587
  {$ELSE}
 
588
  QUERY_SERVICE_LOCK_STATUS = QUERY_SERVICE_LOCK_STATUSA;
 
589
  {$EXTERNALSYM QUERY_SERVICE_LOCK_STATUS}
 
590
  LPQUERY_SERVICE_LOCK_STATUS = LPQUERY_SERVICE_LOCK_STATUSA;
 
591
  {$EXTERNALSYM LPQUERY_SERVICE_LOCK_STATUS}
 
592
  TQueryServiceLockStatus = TQueryServiceLockStatusA;
 
593
  PQueryServiceLockStatus = PQueryServiceLockStatusA;
 
594
  {$ENDIF UNICODE}
 
595
 
 
596
//
 
597
// Query Service Configuration Structure
 
598
//
 
599
 
 
600
  LPQUERY_SERVICE_CONFIGA = ^QUERY_SERVICE_CONFIGA;
 
601
  {$EXTERNALSYM LPQUERY_SERVICE_CONFIGA}
 
602
  _QUERY_SERVICE_CONFIGA = record
 
603
    dwServiceType: DWORD;
 
604
    dwStartType: DWORD;
 
605
    dwErrorControl: DWORD;
 
606
    lpBinaryPathName: LPSTR;
 
607
    lpLoadOrderGroup: LPSTR;
 
608
    dwTagId: DWORD;
 
609
    lpDependencies: LPSTR;
 
610
    lpServiceStartName: LPSTR;
 
611
    lpDisplayName: LPSTR;
 
612
  end;
 
613
  {$EXTERNALSYM _QUERY_SERVICE_CONFIGA}
 
614
  QUERY_SERVICE_CONFIGA = _QUERY_SERVICE_CONFIGA;
 
615
  {$EXTERNALSYM QUERY_SERVICE_CONFIGA}
 
616
  TQueryServiceConfigA = QUERY_SERVICE_CONFIGA;
 
617
  PQueryServiceConfigA = LPQUERY_SERVICE_CONFIGA;
 
618
 
 
619
  LPQUERY_SERVICE_CONFIGW = ^QUERY_SERVICE_CONFIGW;
 
620
  {$EXTERNALSYM LPQUERY_SERVICE_CONFIGW}
 
621
  _QUERY_SERVICE_CONFIGW = record
 
622
    dwServiceType: DWORD;
 
623
    dwStartType: DWORD;
 
624
    dwErrorControl: DWORD;
 
625
    lpBinaryPathName: LPWSTR;
 
626
    lpLoadOrderGroup: LPWSTR;
 
627
    dwTagId: DWORD;
 
628
    lpDependencies: LPWSTR;
 
629
    lpServiceStartName: LPWSTR;
 
630
    lpDisplayName: LPWSTR;
 
631
  end;
 
632
  {$EXTERNALSYM _QUERY_SERVICE_CONFIGW}
 
633
  QUERY_SERVICE_CONFIGW = _QUERY_SERVICE_CONFIGW;
 
634
  {$EXTERNALSYM QUERY_SERVICE_CONFIGW}
 
635
  TQueryServiceConfigW = QUERY_SERVICE_CONFIGW;
 
636
  PQueryServiceConfigW = LPQUERY_SERVICE_CONFIGW;
 
637
 
 
638
  {$IFDEF UNICODE}
 
639
  QUERY_SERVICE_CONFIG = QUERY_SERVICE_CONFIGW;
 
640
  {$EXTERNALSYM QUERY_SERVICE_CONFIG}
 
641
  LPQUERY_SERVICE_CONFIG = LPQUERY_SERVICE_CONFIGW;
 
642
  {$EXTERNALSYM LPQUERY_SERVICE_CONFIG}
 
643
  TQueryServiceConfig = TQueryServiceConfigW;
 
644
  PQueryServiceConfig = PQueryServiceConfigW;
 
645
  {$ELSE}
 
646
  QUERY_SERVICE_CONFIG = QUERY_SERVICE_CONFIGA;
 
647
  {$EXTERNALSYM QUERY_SERVICE_CONFIG}
 
648
  LPQUERY_SERVICE_CONFIG = LPQUERY_SERVICE_CONFIGA;
 
649
  {$EXTERNALSYM LPQUERY_SERVICE_CONFIG}
 
650
  TQueryServiceConfig = TQueryServiceConfigA;
 
651
  PQueryServiceConfig = PQueryServiceConfigA;
 
652
  {$ENDIF UNICODE}
 
653
 
 
654
//
 
655
// Function Prototype for the Service Main Function
 
656
//
 
657
 
 
658
type
 
659
  LPSERVICE_MAIN_FUNCTIONW = procedure(dwNumServicesArgs: DWORD;
 
660
    lpServiceArgVectors: LPWSTR); stdcall;
 
661
  {$EXTERNALSYM LPSERVICE_MAIN_FUNCTIONW}
 
662
  LPSERVICE_MAIN_FUNCTIONA = procedure(dwNumServicesArgs: DWORD;
 
663
    lpServiceArgVectors: LPSTR); stdcall;
 
664
  {$EXTERNALSYM LPSERVICE_MAIN_FUNCTIONA}
 
665
 
 
666
  TServiceMainFunctionA = LPSERVICE_MAIN_FUNCTIONA;
 
667
  TServiceMainFunctionW = LPSERVICE_MAIN_FUNCTIONW;
 
668
 
 
669
  {$IFDEF UNICODE}
 
670
  LPSERVICE_MAIN_FUNCTION = LPSERVICE_MAIN_FUNCTIONW;
 
671
  {$EXTERNALSYM LPSERVICE_MAIN_FUNCTION}
 
672
  TServiceMainFunction = LPSERVICE_MAIN_FUNCTIONW;
 
673
  {$ELSE}
 
674
  LPSERVICE_MAIN_FUNCTION = LPSERVICE_MAIN_FUNCTIONA;
 
675
  {$EXTERNALSYM LPSERVICE_MAIN_FUNCTION}
 
676
  TServiceMainFunction = LPSERVICE_MAIN_FUNCTIONA;
 
677
  {$ENDIF UNICODE}
 
678
 
 
679
//
 
680
// Service Start Table
 
681
//
 
682
 
 
683
  LPSERVICE_TABLE_ENTRYA = ^SERVICE_TABLE_ENTRYA;
 
684
  {$EXTERNALSYM LPSERVICE_TABLE_ENTRYA}
 
685
  _SERVICE_TABLE_ENTRYA = record
 
686
    lpServiceName: LPSTR;
 
687
    lpServiceProc: LPSERVICE_MAIN_FUNCTIONA;
 
688
  end;
 
689
  {$EXTERNALSYM _SERVICE_TABLE_ENTRYA}
 
690
  SERVICE_TABLE_ENTRYA = _SERVICE_TABLE_ENTRYA;
 
691
  {$EXTERNALSYM SERVICE_TABLE_ENTRYA}
 
692
  TServiceTableEntryA = SERVICE_TABLE_ENTRYA;
 
693
  PServiceTableEntryA = LPSERVICE_TABLE_ENTRYA;
 
694
 
 
695
  LPSERVICE_TABLE_ENTRYW = ^SERVICE_TABLE_ENTRYW;
 
696
  {$EXTERNALSYM LPSERVICE_TABLE_ENTRYW}
 
697
  _SERVICE_TABLE_ENTRYW = record
 
698
    lpServiceName: LPWSTR;
 
699
    lpServiceProc: LPSERVICE_MAIN_FUNCTIONW;
 
700
  end;
 
701
  {$EXTERNALSYM _SERVICE_TABLE_ENTRYW}
 
702
  SERVICE_TABLE_ENTRYW = _SERVICE_TABLE_ENTRYW;
 
703
  {$EXTERNALSYM SERVICE_TABLE_ENTRYW}
 
704
  TServiceTableEntryW = SERVICE_TABLE_ENTRYW;
 
705
  PServiceTableEntryW = LPSERVICE_TABLE_ENTRYW;
 
706
 
 
707
  {$IFDEF UNICODE}
 
708
  SERVICE_TABLE_ENTRY = SERVICE_TABLE_ENTRYW;
 
709
  LPSERVICE_TABLE_ENTRY = LPSERVICE_TABLE_ENTRYW;
 
710
  TServiceTableEntry = TServiceTableEntryW;
 
711
  PServiceTableEntry = PServiceTableEntryW;
 
712
  {$ELSE}
 
713
  SERVICE_TABLE_ENTRY = SERVICE_TABLE_ENTRYA;
 
714
  LPSERVICE_TABLE_ENTRY = LPSERVICE_TABLE_ENTRYA;
 
715
  TServiceTableEntry = TServiceTableEntryA;
 
716
  PServiceTableEntry = PServiceTableEntryA;
 
717
  {$ENDIF UNICODE}
 
718
 
 
719
//
 
720
// Prototype for the Service Control Handler Function
 
721
//
 
722
 
 
723
  LPHANDLER_FUNCTION = procedure(dwControl: DWORD); stdcall;
 
724
  {$EXTERNALSYM LPHANDLER_FUNCTION}
 
725
  THandlerFunction = LPHANDLER_FUNCTION;
 
726
 
 
727
  LPHANDLER_FUNCTION_EX = function(dwControl, dwEventType: DWORD;
 
728
    lpEventData, lpContext: LPVOID): DWORD; stdcall;
 
729
  {$EXTERNALSYM LPHANDLER_FUNCTION_EX}
 
730
  THandlerFunctionEx = LPHANDLER_FUNCTION_EX;
 
731
 
 
732
///////////////////////////////////////////////////////////////////////////
 
733
// API Function Prototypes
 
734
///////////////////////////////////////////////////////////////////////////
 
735
 
 
736
function ChangeServiceConfigA(hService: SC_HANDLE; dwServiceType, dwStartType,
 
737
  dwErrorControl: DWORD; lpBinaryPathName, lpLoadOrderGroup: LPCSTR;
 
738
  lpdwTagId: LPDWORD; lpDependencies, lpServiceStartName, lpPassword,
 
739
  lpDisplayName: LPCSTR): BOOL; stdcall;
 
740
{$EXTERNALSYM ChangeServiceConfigA}
 
741
function ChangeServiceConfigW(hService: SC_HANDLE; dwServiceType, dwStartType,
 
742
  dwErrorControl: DWORD; lpBinaryPathName, lpLoadOrderGroup: LPCWSTR;
 
743
  lpdwTagId: LPDWORD; lpDependencies, lpServiceStartName, lpPassword,
 
744
  lpDisplayName: LPCWSTR): BOOL; stdcall;
 
745
{$EXTERNALSYM ChangeServiceConfigW}
 
746
function ChangeServiceConfig(hService: SC_HANDLE; dwServiceType, dwStartType,
 
747
  dwErrorControl: DWORD; lpBinaryPathName, lpLoadOrderGroup: LPCTSTR;
 
748
  lpdwTagId: LPDWORD; lpDependencies, lpServiceStartName, lpPassword,
 
749
  lpDisplayName: LPCTSTR): BOOL; stdcall;
 
750
{$EXTERNALSYM ChangeServiceConfig}
 
751
 
 
752
function ChangeServiceConfig2A(hService: SC_HANDLE; dwInfoLevel: DWORD;
 
753
  lpInfo: LPVOID): BOOL; stdcall;
 
754
{$EXTERNALSYM ChangeServiceConfig2A}
 
755
function ChangeServiceConfig2W(hService: SC_HANDLE; dwInfoLevel: DWORD;
 
756
  lpInfo: LPVOID): BOOL; stdcall;
 
757
{$EXTERNALSYM ChangeServiceConfig2W}
 
758
function ChangeServiceConfig2(hService: SC_HANDLE; dwInfoLevel: DWORD;
 
759
  lpInfo: LPVOID): BOOL; stdcall;
 
760
{$EXTERNALSYM ChangeServiceConfig2}
 
761
 
 
762
function CloseServiceHandle(hSCObject: SC_HANDLE): BOOL; stdcall;
 
763
{$EXTERNALSYM CloseServiceHandle}
 
764
 
 
765
function ControlService(hService: SC_HANDLE; dwControl: DWORD;
 
766
  var lpServiceStatus: SERVICE_STATUS): BOOL; stdcall;
 
767
{$EXTERNALSYM ControlService}
 
768
 
 
769
function CreateServiceA(hSCManager: SC_HANDLE; lpServiceName, lpDisplayName: LPCSTR;
 
770
  dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD;
 
771
  lpBinaryPathName, lpLoadOrderGroup: LPCSTR; lpdwTagId: LPDWORD;
 
772
  lpDependencies, lpServiceStartName, lpPassword: LPCSTR): SC_HANDLE; stdcall;
 
773
{$EXTERNALSYM CreateServiceA}
 
774
function CreateServiceW(hSCManager: SC_HANDLE; lpServiceName, lpDisplayName: LPCWSTR;
 
775
  dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD;
 
776
  lpBinaryPathName, lpLoadOrderGroup: LPCWSTR; lpdwTagId: LPDWORD;
 
777
  lpDependencies, lpServiceStartName, lpPassword: LPCWSTR): SC_HANDLE; stdcall;
 
778
{$EXTERNALSYM CreateServiceW}
 
779
function CreateService(hSCManager: SC_HANDLE; lpServiceName, lpDisplayName: LPCTSTR;
 
780
  dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD;
 
781
  lpBinaryPathName, lpLoadOrderGroup: LPCTSTR; lpdwTagId: LPDWORD;
 
782
  lpDependencies, lpServiceStartName, lpPassword: LPCTSTR): SC_HANDLE; stdcall;
 
783
{$EXTERNALSYM CreateService}
 
784
 
 
785
function DeleteService(hService: SC_HANDLE): BOOL; stdcall;
 
786
{$EXTERNALSYM DeleteService}
 
787
 
 
788
function EnumDependentServicesA(hService: SC_HANDLE; dwServiceState: DWORD;
 
789
  lpServices: LPENUM_SERVICE_STATUSA; cbBufSize: DWORD; var pcbBytesNeeded,
 
790
  lpServicesReturned: DWORD): BOOL; stdcall;
 
791
{$EXTERNALSYM EnumDependentServicesA}
 
792
function EnumDependentServicesW(hService: SC_HANDLE; dwServiceState: DWORD;
 
793
  lpServices: LPENUM_SERVICE_STATUSW; cbBufSize: DWORD; var pcbBytesNeeded,
 
794
  lpServicesReturned: DWORD): BOOL; stdcall;
 
795
{$EXTERNALSYM EnumDependentServicesW}
 
796
function EnumDependentServices(hService: SC_HANDLE; dwServiceState: DWORD;
 
797
  lpServices: LPENUM_SERVICE_STATUS; cbBufSize: DWORD; var pcbBytesNeeded,
 
798
  lpServicesReturned: DWORD): BOOL; stdcall;
 
799
{$EXTERNALSYM EnumDependentServices}
 
800
 
 
801
function EnumServicesStatusA(hSCManager: SC_HANDLE; dwServiceType: DWORD;
 
802
  dwServiceState: DWORD; lpServices: LPENUM_SERVICE_STATUSA; cbBufSize: DWORD;
 
803
  var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD): BOOL; stdcall;
 
804
{$EXTERNALSYM EnumServicesStatusA}
 
805
function EnumServicesStatusW(hSCManager: SC_HANDLE; dwServiceType: DWORD;
 
806
  dwServiceState: DWORD; lpServices: LPENUM_SERVICE_STATUSW; cbBufSize: DWORD;
 
807
  var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD): BOOL; stdcall;
 
808
{$EXTERNALSYM EnumServicesStatusW}
 
809
function EnumServicesStatus(hSCManager: SC_HANDLE; dwServiceType: DWORD;
 
810
  dwServiceState: DWORD; lpServices: LPENUM_SERVICE_STATUS; cbBufSize: DWORD;
 
811
  var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD): BOOL; stdcall;
 
812
{$EXTERNALSYM EnumServicesStatus}
 
813
 
 
814
function EnumServicesStatusExA(hSCManager: SC_HANDLE; InfoLevel: SC_ENUM_TYPE;
 
815
  dwServiceType: DWORD; dwServiceState: DWORD; lpServices: LPBYTE;
 
816
  cbBufSize: DWORD; var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD;
 
817
  pszGroupName: LPCSTR): BOOL; stdcall;
 
818
{$EXTERNALSYM EnumServicesStatusExA}
 
819
function EnumServicesStatusExW(hSCManager: SC_HANDLE; InfoLevel: SC_ENUM_TYPE;
 
820
  dwServiceType: DWORD; dwServiceState: DWORD; lpServices: LPBYTE;
 
821
  cbBufSize: DWORD; var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD;
 
822
  pszGroupName: LPCWSTR): BOOL; stdcall;
 
823
{$EXTERNALSYM EnumServicesStatusExW}
 
824
function EnumServicesStatusEx(hSCManager: SC_HANDLE; InfoLevel: SC_ENUM_TYPE;
 
825
  dwServiceType: DWORD; dwServiceState: DWORD; lpServices: LPBYTE;
 
826
  cbBufSize: DWORD; var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD;
 
827
  pszGroupName: LPCTSTR): BOOL; stdcall;
 
828
{$EXTERNALSYM EnumServicesStatusEx}
 
829
 
 
830
function GetServiceKeyNameA(hSCManager: SC_HANDLE; lpDisplayName: LPCSTR;
 
831
  lpServiceName: LPSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
 
832
{$EXTERNALSYM GetServiceKeyNameA}
 
833
function GetServiceKeyNameW(hSCManager: SC_HANDLE; lpDisplayName: LPCWSTR;
 
834
  lpServiceName: LPWSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
 
835
{$EXTERNALSYM GetServiceKeyNameW}
 
836
function GetServiceKeyName(hSCManager: SC_HANDLE; lpDisplayName: LPCTSTR;
 
837
  lpServiceName: LPTSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
 
838
{$EXTERNALSYM GetServiceKeyName}
 
839
 
 
840
function GetServiceDisplayNameA(hSCManager: SC_HANDLE; lpServiceName: LPCSTR;
 
841
  lpDisplayName: LPSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
 
842
{$EXTERNALSYM GetServiceDisplayNameA}
 
843
function GetServiceDisplayNameW(hSCManager: SC_HANDLE; lpServiceName: LPCWSTR;
 
844
  lpDisplayName: LPWSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
 
845
{$EXTERNALSYM GetServiceDisplayNameW}
 
846
function GetServiceDisplayName(hSCManager: SC_HANDLE; lpServiceName: LPCTSTR;
 
847
  lpDisplayName: LPTSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
 
848
{$EXTERNALSYM GetServiceDisplayName}
 
849
 
 
850
function LockServiceDatabase(hSCManager: SC_HANDLE): SC_LOCK; stdcall;
 
851
{$EXTERNALSYM LockServiceDatabase}
 
852
 
 
853
function NotifyBootConfigStatus(BootAcceptable: BOOL): BOOL; stdcall;
 
854
{$EXTERNALSYM NotifyBootConfigStatus}
 
855
 
 
856
function OpenSCManagerA(lpMachineName: LPCSTR; lpDatabaseName: LPCSTR;
 
857
  dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
 
858
{$EXTERNALSYM OpenSCManagerA}
 
859
function OpenSCManagerW(lpMachineName: LPCWSTR; lpDatabaseName: LPCWSTR;
 
860
  dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
 
861
{$EXTERNALSYM OpenSCManagerW}
 
862
function OpenSCManager(lpMachineName: LPCTSTR; lpDatabaseName: LPCTSTR;
 
863
  dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
 
864
{$EXTERNALSYM OpenSCManager}
 
865
 
 
866
function OpenServiceA(hSCManager: SC_HANDLE; lpServiceName: LPCSTR;
 
867
  dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
 
868
{$EXTERNALSYM OpenServiceA}
 
869
function OpenServiceW(hSCManager: SC_HANDLE; lpServiceName: LPCWSTR;
 
870
  dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
 
871
{$EXTERNALSYM OpenServiceW}
 
872
function OpenService(hSCManager: SC_HANDLE; lpServiceName: LPCTSTR;
 
873
  dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
 
874
{$EXTERNALSYM OpenService}
 
875
 
 
876
function QueryServiceConfigA(hService: SC_HANDLE;
 
877
  lpServiceConfig: LPQUERY_SERVICE_CONFIGA; cbBufSize: DWORD;
 
878
  var pcbBytesNeeded: DWORD): BOOL; stdcall;
 
879
{$EXTERNALSYM QueryServiceConfigA}
 
880
function QueryServiceConfigW(hService: SC_HANDLE;
 
881
  lpServiceConfig: LPQUERY_SERVICE_CONFIGW; cbBufSize: DWORD;
 
882
  var pcbBytesNeeded: DWORD): BOOL; stdcall;
 
883
{$EXTERNALSYM QueryServiceConfigW}
 
884
function QueryServiceConfig(hService: SC_HANDLE;
 
885
  lpServiceConfig: LPQUERY_SERVICE_CONFIG; cbBufSize: DWORD;
 
886
  var pcbBytesNeeded: DWORD): BOOL; stdcall;
 
887
{$EXTERNALSYM QueryServiceConfig}
 
888
 
 
889
function QueryServiceConfig2A(hService: SC_HANDLE; dwInfoLevel: DWORD;
 
890
  lpBuffer: LPBYTE; cbBufSize: DWORD; var pcbBytesNeeded: DWORD): BOOL; stdcall;
 
891
{$EXTERNALSYM QueryServiceConfig2A}
 
892
function QueryServiceConfig2W(hService: SC_HANDLE; dwInfoLevel: DWORD;
 
893
  lpBuffer: LPBYTE; cbBufSize: DWORD; var pcbBytesNeeded: DWORD): BOOL; stdcall;
 
894
{$EXTERNALSYM QueryServiceConfig2W}
 
895
function QueryServiceConfig2(hService: SC_HANDLE; dwInfoLevel: DWORD;
 
896
  lpBuffer: LPBYTE; cbBufSize: DWORD; var pcbBytesNeeded: DWORD): BOOL; stdcall;
 
897
{$EXTERNALSYM QueryServiceConfig2}
 
898
 
 
899
function QueryServiceLockStatusA(hSCManager: SC_HANDLE;
 
900
  lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSA; cbBufSize: DWORD;
 
901
  var pcbBytesNeeded: DWORD): BOOL; stdcall;
 
902
{$EXTERNALSYM QueryServiceLockStatusA}
 
903
function QueryServiceLockStatusW(hSCManager: SC_HANDLE;
 
904
  lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSW; cbBufSize: DWORD;
 
905
  var pcbBytesNeeded: DWORD): BOOL; stdcall;
 
906
{$EXTERNALSYM QueryServiceLockStatusW}
 
907
function QueryServiceLockStatus(hSCManager: SC_HANDLE;
 
908
  lpLockStatus: LPQUERY_SERVICE_LOCK_STATUS; cbBufSize: DWORD;
 
909
  var pcbBytesNeeded: DWORD): BOOL; stdcall;
 
910
{$EXTERNALSYM QueryServiceLockStatus}
 
911
 
 
912
function QueryServiceObjectSecurity(hService: SC_HANDLE;
 
913
  dwSecurityInformation: SECURITY_INFORMATION;
 
914
  var lpSecurityDescriptor: SECURITY_DESCRIPTOR; cbBufSize: DWORD;
 
915
  var pcbBytesNeeded: DWORD): BOOL; stdcall;
 
916
{$EXTERNALSYM QueryServiceObjectSecurity}
 
917
 
 
918
function QueryServiceStatus(hService: SC_HANDLE;
 
919
  var lpServiceStatus: SERVICE_STATUS): BOOL; stdcall;
 
920
{$EXTERNALSYM QueryServiceStatus}
 
921
 
 
922
function QueryServiceStatusEx(hService: SC_HANDLE; InfoLevel: SC_STATUS_TYPE;
 
923
  lpBuffer: LPBYTE; cbBufSize: DWORD; var pcbBytesNeeded: DWORD): BOOL; stdcall;
 
924
{$EXTERNALSYM QueryServiceStatusEx}
 
925
 
 
926
function RegisterServiceCtrlHandlerA(lpServiceName: LPCSTR;
 
927
  lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE; stdcall;
 
928
{$EXTERNALSYM RegisterServiceCtrlHandlerA}
 
929
function RegisterServiceCtrlHandlerW(lpServiceName: LPCWSTR;
 
930
  lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE; stdcall;
 
931
{$EXTERNALSYM RegisterServiceCtrlHandlerW}
 
932
function RegisterServiceCtrlHandler(lpServiceName: LPCTSTR;
 
933
  lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE; stdcall;
 
934
{$EXTERNALSYM RegisterServiceCtrlHandler}
 
935
 
 
936
function RegisterServiceCtrlHandlerExA(lpServiceName: LPCSTR;
 
937
  lpHandlerProc: LPHANDLER_FUNCTION_EX; lpContext: LPVOID): SERVICE_STATUS_HANDLE; stdcall;
 
938
{$EXTERNALSYM RegisterServiceCtrlHandlerExA}
 
939
function RegisterServiceCtrlHandlerExW(lpServiceName: LPCWSTR;
 
940
  lpHandlerProc: LPHANDLER_FUNCTION_EX; lpContext: LPVOID): SERVICE_STATUS_HANDLE; stdcall;
 
941
{$EXTERNALSYM RegisterServiceCtrlHandlerExW}
 
942
function RegisterServiceCtrlHandlerEx(lpServiceName: LPCTSTR;
 
943
  lpHandlerProc: LPHANDLER_FUNCTION_EX; lpContext: LPVOID): SERVICE_STATUS_HANDLE; stdcall;
 
944
{$EXTERNALSYM RegisterServiceCtrlHandlerEx}
 
945
 
 
946
// 9/4/2002 Changed last parameter from const to pointer - reported by James Ots.
 
947
 
 
948
function SetServiceObjectSecurity(hService: SC_HANDLE;
 
949
  dwSecurityInformation: SECURITY_INFORMATION;
 
950
  lpSecurityDescriptor: PSECURITY_DESCRIPTOR): BOOL; stdcall;
 
951
{$EXTERNALSYM SetServiceObjectSecurity}
 
952
 
 
953
function SetServiceStatus(hServiceStatus: SERVICE_STATUS_HANDLE;
 
954
  const lpServiceStatus: SERVICE_STATUS): BOOL; stdcall;
 
955
{$EXTERNALSYM SetServiceStatus}
 
956
 
 
957
function StartServiceCtrlDispatcherA(lpServiceStartTable: LPSERVICE_TABLE_ENTRYA): BOOL; stdcall;
 
958
{$EXTERNALSYM StartServiceCtrlDispatcherA}
 
959
function StartServiceCtrlDispatcherW(lpServiceStartTable: LPSERVICE_TABLE_ENTRYW): BOOL; stdcall;
 
960
{$EXTERNALSYM StartServiceCtrlDispatcherW}
 
961
function StartServiceCtrlDispatcher(lpServiceStartTable: LPSERVICE_TABLE_ENTRY): BOOL; stdcall;
 
962
{$EXTERNALSYM StartServiceCtrlDispatcher}
 
963
 
 
964
function StartServiceA(hService: SC_HANDLE; dwNumServiceArgs: DWORD;
 
965
  lpServiceArgVectors: LPCSTR): BOOL; stdcall;
 
966
{$EXTERNALSYM StartServiceA}
 
967
function StartServiceW(hService: SC_HANDLE; dwNumServiceArgs: DWORD;
 
968
  lpServiceArgVectors: LPCWSTR): BOOL; stdcall;
 
969
{$EXTERNALSYM StartServiceW}
 
970
function StartService(hService: SC_HANDLE; dwNumServiceArgs: DWORD;
 
971
  lpServiceArgVectors: LPCTSTR): BOOL; stdcall;
 
972
{$EXTERNALSYM StartService}
 
973
 
 
974
function UnlockServiceDatabase(ScLock: SC_LOCK): BOOL; stdcall;
 
975
{$EXTERNALSYM UnlockServiceDatabase}
 
976
 
 
977
implementation
 
978
 
 
979
const
 
980
  advapi32 = 'advapi32.dll';
 
981
  {$IFDEF UNICODE}
 
982
  AWSuffix = 'W';
 
983
  {$ELSE}
 
984
  AWSuffix = 'A';
 
985
  {$ENDIF UNICODE}
 
986
 
 
987
{$IFDEF DYNAMIC_LINK}
 
988
 
 
989
var
 
990
  _ChangeServiceConfigA: Pointer;
 
991
 
 
992
function ChangeServiceConfigA;
 
993
begin
 
994
  GetProcedureAddress(_ChangeServiceConfigA, advapi32, 'ChangeServiceConfigA');
 
995
  asm
 
996
        MOV     ESP, EBP
 
997
        POP     EBP
 
998
        JMP     [_ChangeServiceConfigA]
 
999
  end;
 
1000
end;
 
1001
 
 
1002
var
 
1003
  _ChangeServiceConfigW: Pointer;
 
1004
 
 
1005
function ChangeServiceConfigW;
 
1006
begin
 
1007
  GetProcedureAddress(_ChangeServiceConfigW, advapi32, 'ChangeServiceConfigW');
 
1008
  asm
 
1009
        MOV     ESP, EBP
 
1010
        POP     EBP
 
1011
        JMP     [_ChangeServiceConfigW]
 
1012
  end;
 
1013
end;
 
1014
 
 
1015
var
 
1016
  _ChangeServiceConfig: Pointer;
 
1017
 
 
1018
function ChangeServiceConfig;
 
1019
begin
 
1020
  GetProcedureAddress(_ChangeServiceConfig, advapi32, 'ChangeServiceConfig' + AWSuffix);
 
1021
  asm
 
1022
        MOV     ESP, EBP
 
1023
        POP     EBP
 
1024
        JMP     [_ChangeServiceConfig]
 
1025
  end;
 
1026
end;
 
1027
 
 
1028
var
 
1029
  _ChangeServiceConfig2A: Pointer;
 
1030
 
 
1031
function ChangeServiceConfig2A;
 
1032
begin
 
1033
  GetProcedureAddress(_ChangeServiceConfig2A, advapi32, 'ChangeServiceConfig2A');
 
1034
  asm
 
1035
        MOV     ESP, EBP
 
1036
        POP     EBP
 
1037
        JMP     [_ChangeServiceConfig2A]
 
1038
  end;
 
1039
end;
 
1040
 
 
1041
var
 
1042
  _ChangeServiceConfig2W: Pointer;
 
1043
 
 
1044
function ChangeServiceConfig2W;
 
1045
begin
 
1046
  GetProcedureAddress(_ChangeServiceConfig2W, advapi32, 'ChangeServiceConfig2W');
 
1047
  asm
 
1048
        MOV     ESP, EBP
 
1049
        POP     EBP
 
1050
        JMP     [_ChangeServiceConfig2W]
 
1051
  end;
 
1052
end;
 
1053
 
 
1054
var
 
1055
  _ChangeServiceConfig2: Pointer;
 
1056
 
 
1057
function ChangeServiceConfig2;
 
1058
begin
 
1059
  GetProcedureAddress(_ChangeServiceConfig2, advapi32, 'ChangeServiceConfig2' + AWSuffix);
 
1060
  asm
 
1061
        MOV     ESP, EBP
 
1062
        POP     EBP
 
1063
        JMP     [_ChangeServiceConfig2]
 
1064
  end;
 
1065
end;
 
1066
 
 
1067
var
 
1068
  _CloseServiceHandle: Pointer;
 
1069
 
 
1070
function CloseServiceHandle;
 
1071
begin
 
1072
  GetProcedureAddress(_CloseServiceHandle, advapi32, 'CloseServiceHandle');
 
1073
  asm
 
1074
        MOV     ESP, EBP
 
1075
        POP     EBP
 
1076
        JMP     [_CloseServiceHandle]
 
1077
  end;
 
1078
end;
 
1079
 
 
1080
var
 
1081
  _ControlService: Pointer;
 
1082
 
 
1083
function ControlService;
 
1084
begin
 
1085
  GetProcedureAddress(_ControlService, advapi32, 'ControlService');
 
1086
  asm
 
1087
        MOV     ESP, EBP
 
1088
        POP     EBP
 
1089
        JMP     [_ControlService]
 
1090
  end;
 
1091
end;
 
1092
 
 
1093
var
 
1094
  _CreateServiceA: Pointer;
 
1095
 
 
1096
function CreateServiceA;
 
1097
begin
 
1098
  GetProcedureAddress(_CreateServiceA, advapi32, 'CreateServiceA');
 
1099
  asm
 
1100
        MOV     ESP, EBP
 
1101
        POP     EBP
 
1102
        JMP     [_CreateServiceA]
 
1103
  end;
 
1104
end;
 
1105
 
 
1106
var
 
1107
  _CreateServiceW: Pointer;
 
1108
 
 
1109
function CreateServiceW;
 
1110
begin
 
1111
  GetProcedureAddress(_CreateServiceW, advapi32, 'CreateServiceW');
 
1112
  asm
 
1113
        MOV     ESP, EBP
 
1114
        POP     EBP
 
1115
        JMP     [_CreateServiceW]
 
1116
  end;
 
1117
end;
 
1118
 
 
1119
var
 
1120
  _CreateService: Pointer;
 
1121
 
 
1122
function CreateService;
 
1123
begin
 
1124
  GetProcedureAddress(_CreateService, advapi32, 'CreateService' + AWSuffix);
 
1125
  asm
 
1126
        MOV     ESP, EBP
 
1127
        POP     EBP
 
1128
        JMP     [_CreateService]
 
1129
  end;
 
1130
end;
 
1131
 
 
1132
var
 
1133
  _DeleteService: Pointer;
 
1134
 
 
1135
function DeleteService;
 
1136
begin
 
1137
  GetProcedureAddress(_DeleteService, advapi32, 'DeleteService');
 
1138
  asm
 
1139
        MOV     ESP, EBP
 
1140
        POP     EBP
 
1141
        JMP     [_DeleteService]
 
1142
  end;
 
1143
end;
 
1144
 
 
1145
var
 
1146
  _EnumDependentServicesA: Pointer;
 
1147
 
 
1148
function EnumDependentServicesA;
 
1149
begin
 
1150
  GetProcedureAddress(_EnumDependentServicesA, advapi32, 'EnumDependentServicesA');
 
1151
  asm
 
1152
        MOV     ESP, EBP
 
1153
        POP     EBP
 
1154
        JMP     [_EnumDependentServicesA]
 
1155
  end;
 
1156
end;
 
1157
 
 
1158
var
 
1159
  _EnumDependentServicesW: Pointer;
 
1160
 
 
1161
function EnumDependentServicesW;
 
1162
begin
 
1163
  GetProcedureAddress(_EnumDependentServicesW, advapi32, 'EnumDependentServicesW');
 
1164
  asm
 
1165
        MOV     ESP, EBP
 
1166
        POP     EBP
 
1167
        JMP     [_EnumDependentServicesW]
 
1168
  end;
 
1169
end;
 
1170
 
 
1171
var
 
1172
  _EnumDependentServices: Pointer;
 
1173
 
 
1174
function EnumDependentServices;
 
1175
begin
 
1176
  GetProcedureAddress(_EnumDependentServices, advapi32, 'EnumDependentServices' + AWSuffix);
 
1177
  asm
 
1178
        MOV     ESP, EBP
 
1179
        POP     EBP
 
1180
        JMP     [_EnumDependentServices]
 
1181
  end;
 
1182
end;
 
1183
 
 
1184
var
 
1185
  _EnumServicesStatusA: Pointer;
 
1186
 
 
1187
function EnumServicesStatusA;
 
1188
begin
 
1189
  GetProcedureAddress(_EnumServicesStatusA, advapi32, 'EnumServicesStatusA');
 
1190
  asm
 
1191
        MOV     ESP, EBP
 
1192
        POP     EBP
 
1193
        JMP     [_EnumServicesStatusA]
 
1194
  end;
 
1195
end;
 
1196
 
 
1197
var
 
1198
  _EnumServicesStatusW: Pointer;
 
1199
 
 
1200
function EnumServicesStatusW;
 
1201
begin
 
1202
  GetProcedureAddress(_EnumServicesStatusW, advapi32, 'EnumServicesStatusW');
 
1203
  asm
 
1204
        MOV     ESP, EBP
 
1205
        POP     EBP
 
1206
        JMP     [_EnumServicesStatusW]
 
1207
  end;
 
1208
end;
 
1209
 
 
1210
var
 
1211
  _EnumServicesStatus: Pointer;
 
1212
 
 
1213
function EnumServicesStatus;
 
1214
begin
 
1215
  GetProcedureAddress(_EnumServicesStatus, advapi32, 'EnumServicesStatus' + AWSuffix);
 
1216
  asm
 
1217
        MOV     ESP, EBP
 
1218
        POP     EBP
 
1219
        JMP     [_EnumServicesStatus]
 
1220
  end;
 
1221
end;
 
1222
 
 
1223
var
 
1224
  _EnumServicesStatusExA: Pointer;
 
1225
 
 
1226
function EnumServicesStatusExA;
 
1227
begin
 
1228
  GetProcedureAddress(_EnumServicesStatusExA, advapi32, 'EnumServicesStatusExA');
 
1229
  asm
 
1230
        MOV     ESP, EBP
 
1231
        POP     EBP
 
1232
        JMP     [_EnumServicesStatusExA]
 
1233
  end;
 
1234
end;
 
1235
 
 
1236
var
 
1237
  _EnumServicesStatusExW: Pointer;
 
1238
 
 
1239
function EnumServicesStatusExW;
 
1240
begin
 
1241
  GetProcedureAddress(_EnumServicesStatusExW, advapi32, 'EnumServicesStatusExW');
 
1242
  asm
 
1243
        MOV     ESP, EBP
 
1244
        POP     EBP
 
1245
        JMP     [_EnumServicesStatusExW]
 
1246
  end;
 
1247
end;
 
1248
 
 
1249
var
 
1250
  _EnumServicesStatusEx: Pointer;
 
1251
 
 
1252
function EnumServicesStatusEx;
 
1253
begin
 
1254
  GetProcedureAddress(_EnumServicesStatusEx, advapi32, 'EnumServicesStatusEx' + AWSuffix);
 
1255
  asm
 
1256
        MOV     ESP, EBP
 
1257
        POP     EBP
 
1258
        JMP     [_EnumServicesStatusEx]
 
1259
  end;
 
1260
end;
 
1261
 
 
1262
var
 
1263
  _GetServiceKeyNameA: Pointer;
 
1264
 
 
1265
function GetServiceKeyNameA;
 
1266
begin
 
1267
  GetProcedureAddress(_GetServiceKeyNameA, advapi32, 'GetServiceKeyNameA');
 
1268
  asm
 
1269
        MOV     ESP, EBP
 
1270
        POP     EBP
 
1271
        JMP     [_GetServiceKeyNameA]
 
1272
  end;
 
1273
end;
 
1274
 
 
1275
var
 
1276
  _GetServiceKeyNameW: Pointer;
 
1277
 
 
1278
function GetServiceKeyNameW;
 
1279
begin
 
1280
  GetProcedureAddress(_GetServiceKeyNameW, advapi32, 'GetServiceKeyNameW');
 
1281
  asm
 
1282
        MOV     ESP, EBP
 
1283
        POP     EBP
 
1284
        JMP     [_GetServiceKeyNameW]
 
1285
  end;
 
1286
end;
 
1287
 
 
1288
var
 
1289
  _GetServiceKeyName: Pointer;
 
1290
 
 
1291
function GetServiceKeyName;
 
1292
begin
 
1293
  GetProcedureAddress(_GetServiceKeyName, advapi32, 'GetServiceKeyName' + AWSuffix);
 
1294
  asm
 
1295
        MOV     ESP, EBP
 
1296
        POP     EBP
 
1297
        JMP     [_GetServiceKeyName]
 
1298
  end;
 
1299
end;
 
1300
 
 
1301
var
 
1302
  _GetServiceDisplayNameA: Pointer;
 
1303
 
 
1304
function GetServiceDisplayNameA;
 
1305
begin
 
1306
  GetProcedureAddress(_GetServiceDisplayNameA, advapi32, 'GetServiceDisplayNameA');
 
1307
  asm
 
1308
        MOV     ESP, EBP
 
1309
        POP     EBP
 
1310
        JMP     [_GetServiceDisplayNameA]
 
1311
  end;
 
1312
end;
 
1313
 
 
1314
var
 
1315
  _GetServiceDisplayNameW: Pointer;
 
1316
 
 
1317
function GetServiceDisplayNameW;
 
1318
begin
 
1319
  GetProcedureAddress(_GetServiceDisplayNameW, advapi32, 'GetServiceDisplayNameW');
 
1320
  asm
 
1321
        MOV     ESP, EBP
 
1322
        POP     EBP
 
1323
        JMP     [_GetServiceDisplayNameW]
 
1324
  end;
 
1325
end;
 
1326
 
 
1327
var
 
1328
  _GetServiceDisplayName: Pointer;
 
1329
 
 
1330
function GetServiceDisplayName;
 
1331
begin
 
1332
  GetProcedureAddress(_GetServiceDisplayName, advapi32, 'GetServiceDisplayName' + AWSuffix);
 
1333
  asm
 
1334
        MOV     ESP, EBP
 
1335
        POP     EBP
 
1336
        JMP     [_GetServiceDisplayName]
 
1337
  end;
 
1338
end;
 
1339
 
 
1340
var
 
1341
  _LockServiceDatabase: Pointer;
 
1342
 
 
1343
function LockServiceDatabase;
 
1344
begin
 
1345
  GetProcedureAddress(_LockServiceDatabase, advapi32, 'LockServiceDatabase');
 
1346
  asm
 
1347
        MOV     ESP, EBP
 
1348
        POP     EBP
 
1349
        JMP     [_LockServiceDatabase]
 
1350
  end;
 
1351
end;
 
1352
 
 
1353
var
 
1354
  _NotifyBootConfigStatus: Pointer;
 
1355
 
 
1356
function NotifyBootConfigStatus;
 
1357
begin
 
1358
  GetProcedureAddress(_NotifyBootConfigStatus, advapi32, 'NotifyBootConfigStatus');
 
1359
  asm
 
1360
        MOV     ESP, EBP
 
1361
        POP     EBP
 
1362
        JMP     [_NotifyBootConfigStatus]
 
1363
  end;
 
1364
end;
 
1365
 
 
1366
var
 
1367
  _OpenSCManagerA: Pointer;
 
1368
 
 
1369
function OpenSCManagerA;
 
1370
begin
 
1371
  GetProcedureAddress(_OpenSCManagerA, advapi32, 'OpenSCManagerA');
 
1372
  asm
 
1373
        MOV     ESP, EBP
 
1374
        POP     EBP
 
1375
        JMP     [_OpenSCManagerA]
 
1376
  end;
 
1377
end;
 
1378
 
 
1379
var
 
1380
  _OpenSCManagerW: Pointer;
 
1381
 
 
1382
function OpenSCManagerW;
 
1383
begin
 
1384
  GetProcedureAddress(_OpenSCManagerW, advapi32, 'OpenSCManagerW');
 
1385
  asm
 
1386
        MOV     ESP, EBP
 
1387
        POP     EBP
 
1388
        JMP     [_OpenSCManagerW]
 
1389
  end;
 
1390
end;
 
1391
 
 
1392
var
 
1393
  _OpenSCManager: Pointer;
 
1394
 
 
1395
function OpenSCManager;
 
1396
begin
 
1397
  GetProcedureAddress(_OpenSCManager, advapi32, 'OpenSCManager' + AWSuffix);
 
1398
  asm
 
1399
        MOV     ESP, EBP
 
1400
        POP     EBP
 
1401
        JMP     [_OpenSCManager]
 
1402
  end;
 
1403
end;
 
1404
 
 
1405
var
 
1406
  _OpenServiceA: Pointer;
 
1407
 
 
1408
function OpenServiceA;
 
1409
begin
 
1410
  GetProcedureAddress(_OpenServiceA, advapi32, 'OpenServiceA');
 
1411
  asm
 
1412
        MOV     ESP, EBP
 
1413
        POP     EBP
 
1414
        JMP     [_OpenServiceA]
 
1415
  end;
 
1416
end;
 
1417
 
 
1418
var
 
1419
  _OpenServiceW: Pointer;
 
1420
 
 
1421
function OpenServiceW;
 
1422
begin
 
1423
  GetProcedureAddress(_OpenServiceW, advapi32, 'OpenServiceW');
 
1424
  asm
 
1425
        MOV     ESP, EBP
 
1426
        POP     EBP
 
1427
        JMP     [_OpenServiceW]
 
1428
  end;
 
1429
end;
 
1430
 
 
1431
var
 
1432
  _OpenService: Pointer;
 
1433
 
 
1434
function OpenService;
 
1435
begin
 
1436
  GetProcedureAddress(_OpenService, advapi32, 'OpenService' + AWSuffix);
 
1437
  asm
 
1438
        MOV     ESP, EBP
 
1439
        POP     EBP
 
1440
        JMP     [_OpenService]
 
1441
  end;
 
1442
end;
 
1443
 
 
1444
var
 
1445
  _QueryServiceConfigA: Pointer;
 
1446
 
 
1447
function QueryServiceConfigA;
 
1448
begin
 
1449
  GetProcedureAddress(_QueryServiceConfigA, advapi32, 'QueryServiceConfigA');
 
1450
  asm
 
1451
        MOV     ESP, EBP
 
1452
        POP     EBP
 
1453
        JMP     [_QueryServiceConfigA]
 
1454
  end;
 
1455
end;
 
1456
 
 
1457
var
 
1458
  _QueryServiceConfigW: Pointer;
 
1459
 
 
1460
function QueryServiceConfigW;
 
1461
begin
 
1462
  GetProcedureAddress(_QueryServiceConfigW, advapi32, 'QueryServiceConfigW');
 
1463
  asm
 
1464
        MOV     ESP, EBP
 
1465
        POP     EBP
 
1466
        JMP     [_QueryServiceConfigW]
 
1467
  end;
 
1468
end;
 
1469
 
 
1470
var
 
1471
  _QueryServiceConfig: Pointer;
 
1472
 
 
1473
function QueryServiceConfig;
 
1474
begin
 
1475
  GetProcedureAddress(_QueryServiceConfig, advapi32, 'QueryServiceConfig' + AWSuffix);
 
1476
  asm
 
1477
        MOV     ESP, EBP
 
1478
        POP     EBP
 
1479
        JMP     [_QueryServiceConfig]
 
1480
  end;
 
1481
end;
 
1482
 
 
1483
var
 
1484
  _QueryServiceConfig2A: Pointer;
 
1485
 
 
1486
function QueryServiceConfig2A;
 
1487
begin
 
1488
  GetProcedureAddress(_QueryServiceConfig2A, advapi32, 'QueryServiceConfig2A');
 
1489
  asm
 
1490
        MOV     ESP, EBP
 
1491
        POP     EBP
 
1492
        JMP     [_QueryServiceConfig2A]
 
1493
  end;
 
1494
end;
 
1495
 
 
1496
var
 
1497
  _QueryServiceConfig2W: Pointer;
 
1498
 
 
1499
function QueryServiceConfig2W;
 
1500
begin
 
1501
  GetProcedureAddress(_QueryServiceConfig2W, advapi32, 'QueryServiceConfig2W');
 
1502
  asm
 
1503
        MOV     ESP, EBP
 
1504
        POP     EBP
 
1505
        JMP     [_QueryServiceConfig2W]
 
1506
  end;
 
1507
end;
 
1508
 
 
1509
var
 
1510
  _QueryServiceConfig2: Pointer;
 
1511
 
 
1512
function QueryServiceConfig2;
 
1513
begin
 
1514
  GetProcedureAddress(_QueryServiceConfig2, advapi32, 'QueryServiceConfig2' + AWSuffix);
 
1515
  asm
 
1516
        MOV     ESP, EBP
 
1517
        POP     EBP
 
1518
        JMP     [_QueryServiceConfig2]
 
1519
  end;
 
1520
end;
 
1521
 
 
1522
var
 
1523
  _QueryServiceLockStatusA: Pointer;
 
1524
 
 
1525
function QueryServiceLockStatusA;
 
1526
begin
 
1527
  GetProcedureAddress(_QueryServiceLockStatusA, advapi32, 'QueryServiceLockStatusA');
 
1528
  asm
 
1529
        MOV     ESP, EBP
 
1530
        POP     EBP
 
1531
        JMP     [_QueryServiceLockStatusA]
 
1532
  end;
 
1533
end;
 
1534
 
 
1535
var
 
1536
  _QueryServiceLockStatusW: Pointer;
 
1537
 
 
1538
function QueryServiceLockStatusW;
 
1539
begin
 
1540
  GetProcedureAddress(_QueryServiceLockStatusW, advapi32, 'QueryServiceLockStatusW');
 
1541
  asm
 
1542
        MOV     ESP, EBP
 
1543
        POP     EBP
 
1544
        JMP     [_QueryServiceLockStatusW]
 
1545
  end;
 
1546
end;
 
1547
 
 
1548
var
 
1549
  _QueryServiceLockStatus: Pointer;
 
1550
 
 
1551
function QueryServiceLockStatus;
 
1552
begin
 
1553
  GetProcedureAddress(_QueryServiceLockStatus, advapi32, 'QueryServiceLockStatus' + AWSuffix);
 
1554
  asm
 
1555
        MOV     ESP, EBP
 
1556
        POP     EBP
 
1557
        JMP     [_QueryServiceLockStatus]
 
1558
  end;
 
1559
end;
 
1560
 
 
1561
var
 
1562
  _QueryServiceObjectSecurity: Pointer;
 
1563
 
 
1564
function QueryServiceObjectSecurity;
 
1565
begin
 
1566
  GetProcedureAddress(_QueryServiceObjectSecurity, advapi32, 'QueryServiceObjectSecurity');
 
1567
  asm
 
1568
        MOV     ESP, EBP
 
1569
        POP     EBP
 
1570
        JMP     [_QueryServiceObjectSecurity]
 
1571
  end;
 
1572
end;
 
1573
 
 
1574
var
 
1575
  _QueryServiceStatus: Pointer;
 
1576
 
 
1577
function QueryServiceStatus;
 
1578
begin
 
1579
  GetProcedureAddress(_QueryServiceStatus, advapi32, 'QueryServiceStatus');
 
1580
  asm
 
1581
        MOV     ESP, EBP
 
1582
        POP     EBP
 
1583
        JMP     [_QueryServiceStatus]
 
1584
  end;
 
1585
end;
 
1586
 
 
1587
var
 
1588
  _QueryServiceStatusEx: Pointer;
 
1589
 
 
1590
function QueryServiceStatusEx;
 
1591
begin
 
1592
  GetProcedureAddress(_QueryServiceStatusEx, advapi32, 'QueryServiceStatusEx');
 
1593
  asm
 
1594
        MOV     ESP, EBP
 
1595
        POP     EBP
 
1596
        JMP     [_QueryServiceStatusEx]
 
1597
  end;
 
1598
end;
 
1599
 
 
1600
var
 
1601
  _RegisterServiceCtrlHandlerA: Pointer;
 
1602
 
 
1603
function RegisterServiceCtrlHandlerA;
 
1604
begin
 
1605
  GetProcedureAddress(_RegisterServiceCtrlHandlerA, advapi32, 'RegisterServiceCtrlHandlerA');
 
1606
  asm
 
1607
        MOV     ESP, EBP
 
1608
        POP     EBP
 
1609
        JMP     [_RegisterServiceCtrlHandlerA]
 
1610
  end;
 
1611
end;
 
1612
 
 
1613
var
 
1614
  _RegisterServiceCtrlHandlerW: Pointer;
 
1615
 
 
1616
function RegisterServiceCtrlHandlerW;
 
1617
begin
 
1618
  GetProcedureAddress(_RegisterServiceCtrlHandlerW, advapi32, 'RegisterServiceCtrlHandlerW');
 
1619
  asm
 
1620
        MOV     ESP, EBP
 
1621
        POP     EBP
 
1622
        JMP     [_RegisterServiceCtrlHandlerW]
 
1623
  end;
 
1624
end;
 
1625
 
 
1626
var
 
1627
  _RegisterServiceCtrlHandler: Pointer;
 
1628
 
 
1629
function RegisterServiceCtrlHandler;
 
1630
begin
 
1631
  GetProcedureAddress(_RegisterServiceCtrlHandler, advapi32, 'RegisterServiceCtrlHandler' + AWSuffix);
 
1632
  asm
 
1633
        MOV     ESP, EBP
 
1634
        POP     EBP
 
1635
        JMP     [_RegisterServiceCtrlHandler]
 
1636
  end;
 
1637
end;
 
1638
 
 
1639
var
 
1640
  _RegisterServiceCtrlHandlerExA: Pointer;
 
1641
 
 
1642
function RegisterServiceCtrlHandlerExA;
 
1643
begin
 
1644
  GetProcedureAddress(_RegisterServiceCtrlHandlerExA, advapi32, 'RegisterServiceCtrlHandlerExA');
 
1645
  asm
 
1646
        MOV     ESP, EBP
 
1647
        POP     EBP
 
1648
        JMP     [_RegisterServiceCtrlHandlerExA]
 
1649
  end;
 
1650
end;
 
1651
 
 
1652
var
 
1653
  _RegisterServiceCtrlHandlerExW: Pointer;
 
1654
 
 
1655
function RegisterServiceCtrlHandlerExW;
 
1656
begin
 
1657
  GetProcedureAddress(_RegisterServiceCtrlHandlerExW, advapi32, 'RegisterServiceCtrlHandlerExW');
 
1658
  asm
 
1659
        MOV     ESP, EBP
 
1660
        POP     EBP
 
1661
        JMP     [_RegisterServiceCtrlHandlerExW]
 
1662
  end;
 
1663
end;
 
1664
 
 
1665
var
 
1666
  _RegisterServiceCtrlHandlerEx: Pointer;
 
1667
 
 
1668
function RegisterServiceCtrlHandlerEx;
 
1669
begin
 
1670
  GetProcedureAddress(_RegisterServiceCtrlHandlerEx, advapi32, 'RegisterServiceCtrlHandlerEx' + AWSuffix);
 
1671
  asm
 
1672
        MOV     ESP, EBP
 
1673
        POP     EBP
 
1674
        JMP     [_RegisterServiceCtrlHandlerEx]
 
1675
  end;
 
1676
end;
 
1677
 
 
1678
var
 
1679
  _SetServiceObjectSecurity: Pointer;
 
1680
 
 
1681
function SetServiceObjectSecurity;
 
1682
begin
 
1683
  GetProcedureAddress(_SetServiceObjectSecurity, advapi32, 'SetServiceObjectSecurity');
 
1684
  asm
 
1685
        MOV     ESP, EBP
 
1686
        POP     EBP
 
1687
        JMP     [_SetServiceObjectSecurity]
 
1688
  end;
 
1689
end;
 
1690
 
 
1691
var
 
1692
  _SetServiceStatus: Pointer;
 
1693
 
 
1694
function SetServiceStatus;
 
1695
begin
 
1696
  GetProcedureAddress(_SetServiceStatus, advapi32, 'SetServiceStatus');
 
1697
  asm
 
1698
        MOV     ESP, EBP
 
1699
        POP     EBP
 
1700
        JMP     [_SetServiceStatus]
 
1701
  end;
 
1702
end;
 
1703
 
 
1704
var
 
1705
  _StartServiceCtrlDispatcherA: Pointer;
 
1706
 
 
1707
function StartServiceCtrlDispatcherA;
 
1708
begin
 
1709
  GetProcedureAddress(_StartServiceCtrlDispatcherA, advapi32, 'StartServiceCtrlDispatcherA');
 
1710
  asm
 
1711
        MOV     ESP, EBP
 
1712
        POP     EBP
 
1713
        JMP     [_StartServiceCtrlDispatcherA]
 
1714
  end;
 
1715
end;
 
1716
 
 
1717
var
 
1718
  _StartServiceCtrlDispatcherW: Pointer;
 
1719
 
 
1720
function StartServiceCtrlDispatcherW;
 
1721
begin
 
1722
  GetProcedureAddress(_StartServiceCtrlDispatcherW, advapi32, 'StartServiceCtrlDispatcherW');
 
1723
  asm
 
1724
        MOV     ESP, EBP
 
1725
        POP     EBP
 
1726
        JMP     [_StartServiceCtrlDispatcherW]
 
1727
  end;
 
1728
end;
 
1729
 
 
1730
var
 
1731
  _StartServiceCtrlDispatcher: Pointer;
 
1732
 
 
1733
function StartServiceCtrlDispatcher;
 
1734
begin
 
1735
  GetProcedureAddress(_StartServiceCtrlDispatcher, advapi32, 'StartServiceCtrlDispatcher' + AWSuffix);
 
1736
  asm
 
1737
        MOV     ESP, EBP
 
1738
        POP     EBP
 
1739
        JMP     [_StartServiceCtrlDispatcher]
 
1740
  end;
 
1741
end;
 
1742
 
 
1743
var
 
1744
  _StartServiceA: Pointer;
 
1745
 
 
1746
function StartServiceA;
 
1747
begin
 
1748
  GetProcedureAddress(_StartServiceA, advapi32, 'StartServiceA');
 
1749
  asm
 
1750
        MOV     ESP, EBP
 
1751
        POP     EBP
 
1752
        JMP     [_StartServiceA]
 
1753
  end;
 
1754
end;
 
1755
 
 
1756
var
 
1757
  _StartServiceW: Pointer;
 
1758
 
 
1759
function StartServiceW;
 
1760
begin
 
1761
  GetProcedureAddress(_StartServiceW, advapi32, 'StartServiceW');
 
1762
  asm
 
1763
        MOV     ESP, EBP
 
1764
        POP     EBP
 
1765
        JMP     [_StartServiceW]
 
1766
  end;
 
1767
end;
 
1768
 
 
1769
var
 
1770
  _StartService: Pointer;
 
1771
 
 
1772
function StartService;
 
1773
begin
 
1774
  GetProcedureAddress(_StartService, advapi32, 'StartService' + AWSuffix);
 
1775
  asm
 
1776
        MOV     ESP, EBP
 
1777
        POP     EBP
 
1778
        JMP     [_StartService]
 
1779
  end;
 
1780
end;
 
1781
 
 
1782
var
 
1783
  _UnlockServiceDatabase: Pointer;
 
1784
 
 
1785
function UnlockServiceDatabase;
 
1786
begin
 
1787
  GetProcedureAddress(_UnlockServiceDatabase, advapi32, 'UnlockServiceDatabase');
 
1788
  asm
 
1789
        MOV     ESP, EBP
 
1790
        POP     EBP
 
1791
        JMP     [_UnlockServiceDatabase]
 
1792
  end;
 
1793
end;
 
1794
 
 
1795
{$ELSE}
 
1796
 
 
1797
function ChangeServiceConfigA; external advapi32 name 'ChangeServiceConfigA';
 
1798
function ChangeServiceConfigW; external advapi32 name 'ChangeServiceConfigW';
 
1799
function ChangeServiceConfig; external advapi32 name 'ChangeServiceConfig' + AWSuffix;
 
1800
function ChangeServiceConfig2A; external advapi32 name 'ChangeServiceConfig2A';
 
1801
function ChangeServiceConfig2W; external advapi32 name 'ChangeServiceConfig2W';
 
1802
function ChangeServiceConfig2; external advapi32 name 'ChangeServiceConfig2' + AWSuffix;
 
1803
function CloseServiceHandle; external advapi32 name 'CloseServiceHandle';
 
1804
function ControlService; external advapi32 name 'ControlService';
 
1805
function CreateServiceA; external advapi32 name 'CreateServiceA';
 
1806
function CreateServiceW; external advapi32 name 'CreateServiceW';
 
1807
function CreateService; external advapi32 name 'CreateService' + AWSuffix;
 
1808
function DeleteService; external advapi32 name 'DeleteService';
 
1809
function EnumDependentServicesA; external advapi32 name 'EnumDependentServicesA';
 
1810
function EnumDependentServicesW; external advapi32 name 'EnumDependentServicesW';
 
1811
function EnumDependentServices; external advapi32 name 'EnumDependentServices' + AWSuffix;
 
1812
function EnumServicesStatusA; external advapi32 name 'EnumServicesStatusA';
 
1813
function EnumServicesStatusW; external advapi32 name 'EnumServicesStatusW';
 
1814
function EnumServicesStatus; external advapi32 name 'EnumServicesStatus' + AWSuffix;
 
1815
function EnumServicesStatusExA; external advapi32 name 'EnumServicesStatusExA';
 
1816
function EnumServicesStatusExW; external advapi32 name 'EnumServicesStatusExW';
 
1817
function EnumServicesStatusEx; external advapi32 name 'EnumServicesStatusEx' + AWSuffix;
 
1818
function GetServiceKeyNameA; external advapi32 name 'GetServiceKeyNameA';
 
1819
function GetServiceKeyNameW; external advapi32 name 'GetServiceKeyNameW';
 
1820
function GetServiceKeyName; external advapi32 name 'GetServiceKeyName' + AWSuffix;
 
1821
function GetServiceDisplayNameA; external advapi32 name 'GetServiceDisplayNameA';
 
1822
function GetServiceDisplayNameW; external advapi32 name 'GetServiceDisplayNameW';
 
1823
function GetServiceDisplayName; external advapi32 name 'GetServiceDisplayName' + AWSuffix;
 
1824
function LockServiceDatabase; external advapi32 name 'LockServiceDatabase';
 
1825
function NotifyBootConfigStatus; external advapi32 name 'NotifyBootConfigStatus';
 
1826
function OpenSCManagerA; external advapi32 name 'OpenSCManagerA';
 
1827
function OpenSCManagerW; external advapi32 name 'OpenSCManagerW';
 
1828
function OpenSCManager; external advapi32 name 'OpenSCManager' + AWSuffix;
 
1829
function OpenServiceA; external advapi32 name 'OpenServiceA';
 
1830
function OpenServiceW; external advapi32 name 'OpenServiceW';
 
1831
function OpenService; external advapi32 name 'OpenService' + AWSuffix;
 
1832
function QueryServiceConfigA; external advapi32 name 'QueryServiceConfigA';
 
1833
function QueryServiceConfigW; external advapi32 name 'QueryServiceConfigW';
 
1834
function QueryServiceConfig; external advapi32 name 'QueryServiceConfig' + AWSuffix;
 
1835
function QueryServiceConfig2A; external advapi32 name 'QueryServiceConfig2A';
 
1836
function QueryServiceConfig2W; external advapi32 name 'QueryServiceConfig2W';
 
1837
function QueryServiceConfig2; external advapi32 name 'QueryServiceConfig2' + AWSuffix;
 
1838
function QueryServiceLockStatusA; external advapi32 name 'QueryServiceLockStatusA';
 
1839
function QueryServiceLockStatusW; external advapi32 name 'QueryServiceLockStatusW';
 
1840
function QueryServiceLockStatus; external advapi32 name 'QueryServiceLockStatus' + AWSuffix;
 
1841
function QueryServiceObjectSecurity; external advapi32 name 'QueryServiceObjectSecurity';
 
1842
function QueryServiceStatus; external advapi32 name 'QueryServiceStatus';
 
1843
function QueryServiceStatusEx; external advapi32 name 'QueryServiceStatusEx';
 
1844
function RegisterServiceCtrlHandlerA; external advapi32 name 'RegisterServiceCtrlHandlerA';
 
1845
function RegisterServiceCtrlHandlerW; external advapi32 name 'RegisterServiceCtrlHandlerW';
 
1846
function RegisterServiceCtrlHandler; external advapi32 name 'RegisterServiceCtrlHandler' + AWSuffix;
 
1847
function RegisterServiceCtrlHandlerExA; external advapi32 name 'RegisterServiceCtrlHandlerExA';
 
1848
function RegisterServiceCtrlHandlerExW; external advapi32 name 'RegisterServiceCtrlHandlerExW';
 
1849
function RegisterServiceCtrlHandlerEx; external advapi32 name 'RegisterServiceCtrlHandlerEx' + AWSuffix;
 
1850
function SetServiceObjectSecurity; external advapi32 name 'SetServiceObjectSecurity';
 
1851
function SetServiceStatus; external advapi32 name 'SetServiceStatus';
 
1852
function StartServiceCtrlDispatcherA; external advapi32 name 'StartServiceCtrlDispatcherA';
 
1853
function StartServiceCtrlDispatcherW; external advapi32 name 'StartServiceCtrlDispatcherW';
 
1854
function StartServiceCtrlDispatcher; external advapi32 name 'StartServiceCtrlDispatcher' + AWSuffix;
 
1855
function StartServiceA; external advapi32 name 'StartServiceA';
 
1856
function StartServiceW; external advapi32 name 'StartServiceW';
 
1857
function StartService; external advapi32 name 'StartService' + AWSuffix;
 
1858
function UnlockServiceDatabase; external advapi32 name 'UnlockServiceDatabase';
 
1859
 
 
1860
{$ENDIF DYNAMIC_LINK}
 
1861
 
 
1862
end.