source: trunk/src/advapi32/ADVAPI32.CPP@ 2004

Last change on this file since 2004 was 1894, checked in by sandervl, 26 years ago

security apis forwarded to ntdll
File size: 145.1 KB
Line 
1/* $Id: ADVAPI32.CPP,v 1.9 1999-11-30 19:41:06 sandervl Exp $ */
2
3/*
4 * Win32 advanced API functions for OS/2
5 *
6 * 1998/06/12
7 *
8 * Copyright 1998 Sander van Leeuwen
9 * Copyright 1998 Patrick Haller
10 *
11 * @(#) ADVAPI32.C 1.0.1 1998/06/14 PH added stubs
12 *
13 *
14 * Project Odin Software License can be found in LICENSE.TXT
15 *
16 */
17
18
19/*****************************************************************************
20 * Includes *
21 *****************************************************************************/
22
23#include <os2win.h>
24#include <stdlib.h>
25#include <stdarg.h>
26#include <string.h>
27#include <odinwrap.h>
28#include "misc.h"
29#include "advapi32.h"
30#include "unicode.h"
31#include "winreg.h"
32
33ODINDEBUGCHANNEL(ADVAPI32-ADVAPI32)
34
35
36/*****************************************************************************
37 * Defines *
38 *****************************************************************************/
39
40 /* this define enables certain less important debug messages */
41//#define DEBUG_LOCAL 1
42
43
44/*****************************************************************************
45 * Name : SetTokenInformation
46 * Purpose : The SetTokenInformation function sets various types of
47 * information for a specified access token. The information it
48 * sets replaces existing information. The calling process must
49 * have appropriate access rights to set the information.
50 * Parameters: HANDLE hToken handle of access token
51 * TOKEN_INFORMATION_CLASS tic type of information to set
52 * LPVOID lpvInformation address of information to set
53 * DWORD cbInformation size of information buffer
54 * Variables :
55 * Result :
56 * Remark :
57 * Status : UNTESTED STUB
58 *
59 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
60 *****************************************************************************/
61
62#define TOKEN_INFORMATION_CLASS DWORD
63BOOL WIN32API SetTokenInformation(HANDLE hToken,
64 TOKEN_INFORMATION_CLASS tic,
65 LPVOID lpvInformation,
66 DWORD cbInformation)
67{
68 dprintf(("ADVAPI32: SetTokenInformation(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
69 hToken,
70 tic,
71 lpvInformation,
72 cbInformation));
73
74 return (FALSE); /* signal failure */
75}
76
77//******************************************************************************
78//******************************************************************************
79BOOL WIN32API GetUserNameA( /*PLF Wed 98-02-11 13:33:39*/
80 LPTSTR lpBuffer, /* address of name buffer */
81 LPDWORD lpcchBuffer) /* address of size of name buffer */
82
83
84 /* The GetUserName function retrieves the user name of the current
85 * thread. This is the name of the user currently logged onto the
86 * system.
87 */
88
89{
90 #define USERNAME "USER"
91 if(*lpcchBuffer < sizeof(USERNAME))
92 return FALSE;
93 strcpy(lpBuffer, USERNAME);
94 return TRUE;
95}
96//******************************************************************************
97//******************************************************************************
98BOOL WIN32API GetUserNameW( /*KSO Thu 21.05.1998 */
99 LPWSTR lpBuffer,
100 LPDWORD lpccBuffer
101 )
102{
103
104 if ( *lpccBuffer >= sizeof(USERNAME)*2 )
105 {
106 AsciiToUnicode(USERNAME, lpBuffer);
107 return TRUE;
108 }
109 return FALSE;
110}
111//******************************************************************************
112//******************************************************************************
113
114
115
116BOOL WIN32API ReportEventA( /*PLF Sat 98-03-07 00:36:43*/
117 HANDLE hEventLog,
118 WORD wType,
119 WORD wCategory,
120 DWORD dwEventID,
121 PSID lpUserSid,
122 WORD wNumStrings,
123 DWORD dwDataSize,
124 LPCSTR *lpStrings,
125 LPVOID lpRawData
126 )
127{
128 dprintf(("ReportEventA(): NIY\n"));
129 return TRUE;
130}
131
132
133BOOL WIN32API ReportEventW( /*PLF Sat 98-03-07 00:36:43*/
134 HANDLE hEventLog,
135 WORD wType,
136 WORD wCategory,
137 DWORD dwEventID,
138 PSID lpUserSid,
139 WORD wNumStrings,
140 DWORD dwDataSize,
141 LPCWSTR *lpStrings,
142 LPVOID lpRawData
143 )
144{
145 dprintf(("ReportEventW(): NIY\n"));
146 return TRUE;
147}
148
149
150/*PLF Sat 98-03-07 02:59:20*/
151HANDLE WIN32API RegisterEventSourceA(LPCSTR lpUNCServerName, LPCSTR lpSourceName)
152{
153 dprintf(("ADVAPI32: RegisterEventSourceA() NIY\n"));
154 return FALSE;
155}
156
157/*PLF Sat 98-03-07 02:59:20*/
158HANDLE WIN32API RegisterEventSourceW(LPCWSTR lpUNCServerName, LPCWSTR lpSourceName)
159{
160 dprintf(("ADVAPI32: RegisterEventSourceW() NIY\n"));
161 return FALSE;
162}
163
164
165/*PLF Sat 98-03-07 02:59:20*/
166BOOL WIN32API DeregisterEventSource(HANDLE hEventLog)
167{
168 dprintf(("DeregisterEventSource() NIY\n"));
169 return FALSE;
170}
171
172
173/*PLF Sat 98-03-07 02:59:20*/
174
175/*****************************************************************************
176 * Name : AbortSystemShutdownA
177 * Purpose : The AbortSystemShutdown function stops a system shutdown started
178 * by using the InitiateSystemShutdown function.
179 * Parameters: LPTSTR lpMachineName address of name of computer to stop shutting down
180 * Variables :
181 * Result :
182 * Remark :
183 * Status : UNTESTED STUB
184 *
185 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
186 *****************************************************************************/
187
188BOOL WIN32API AbortSystemShutdownA(LPTSTR lpMachineName)
189{
190 dprintf(("ADVAPI32: AbortSystemShutdownA(%s) not implemented.\n",
191 lpMachineName));
192
193 return (FALSE);
194}
195
196
197/*****************************************************************************
198 * Name : AbortSystemShutdownW
199 * Purpose : The AbortSystemShutdown function stops a system shutdown started
200 * by using the InitiateSystemShutdown function.
201 * Parameters: LPWSTR lpMachineName address of name of computer to stop shutting down
202 * Variables :
203 * Result :
204 * Remark :
205 * Status : UNTESTED STUB
206 *
207 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
208 *****************************************************************************/
209
210BOOL WIN32API AbortSystemShutdownW(LPWSTR lpMachineName)
211{
212 dprintf(("ADVAPI32: AbortSystemShutdownW(%s) not implemented.\n",
213 lpMachineName));
214
215 return (FALSE);
216}
217
218
219
220
221/*****************************************************************************
222 * Name : AccessCheckAndAuditAlarmA
223 * Purpose : The AccessCheckAndAuditAlarm function performs an access
224 * validation and generates corresponding audit messages. An
225 * application can also use this function to determine whether
226 * necessary privileges are held by a client process. This function
227 * is generally used by a server application impersonating a client
228 * process. Alarms are not supported in the current version of Windows NT.
229 * Parameters: LPCSTR SubsystemName address of string for subsystem name
230 * LPVOID HandleId address of handle identifier
231 * LPTSTR ObjectTypeName address of string for object type
232 * LPTSTR ObjectName address of string for object name
233 * PSECURITY_DESCRIPTOR SecurityDescriptor address of security descriptor
234 * DWORD DesiredAccess mask for requested access rights
235 * PGENERIC_MAPPING GenericMapping address of GENERIC_MAPPING
236 * BOOL ObjectCreation object-creation flag
237 * LPDWORD GrantedAccess address of mask for granted rights
238 * LPBOOL AccessStatus address of flag for results
239 * LPBOOL pfGenerateOnClose address of flag for audit generation
240 * Variables :
241 * Result :
242 * Remark :
243 * Status : UNTESTED STUB
244 *
245 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
246 *****************************************************************************/
247
248BOOL WIN32API AccessCheckAndAuditAlarmA(LPCSTR SubsystemName,
249 LPVOID HandleId,
250 LPTSTR ObjectTypeName,
251 LPTSTR ObjectName,
252 PSECURITY_DESCRIPTOR SecurityDescriptor,
253 DWORD DesiredAccess,
254 PGENERIC_MAPPING GenericMapping,
255 BOOL ObjectCreation,
256 LPDWORD GrantedAccess,
257 LPBOOL AccessStatus,
258 LPBOOL pfGenerateOnClose)
259{
260 dprintf(("ADVAPI32: AccessCheckAndAuditAlarmA(%s,%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
261 SubsystemName,
262 HandleId,
263 ObjectTypeName,
264 ObjectName,
265 SecurityDescriptor,
266 DesiredAccess,
267 GenericMapping,
268 ObjectCreation,
269 GrantedAccess,
270 AccessStatus,
271 pfGenerateOnClose));
272
273 return (FALSE);
274}
275
276
277/*****************************************************************************
278 * Name : AccessCheckAndAuditAlarmW
279 * Purpose : The AccessCheckAndAuditAlarm function performs an access
280 * validation and generates corresponding audit messages. An
281 * application can also use this function to determine whether
282 * necessary privileges are held by a client process. This function
283 * is generally used by a server application impersonating a client
284 * process. Alarms are not supported in the current version of Windows NT.
285 * Parameters: LPCSTR SubsystemName address of string for subsystem name
286 * LPVOID HandleId address of handle identifier
287 * LPTSTR ObjectTypeName address of string for object type
288 * LPTSTR ObjectName address of string for object name
289 * PSECURITY_DESCRIPTOR SecurityDescriptor address of security descriptor
290 * DWORD DesiredAccess mask for requested access rights
291 * PGENERIC_MAPPING GenericMapping address of GENERIC_MAPPING
292 * BOOL ObjectCreation object-creation flag
293 * LPDWORD GrantedAccess address of mask for granted rights
294 * LPBOOL AccessStatus address of flag for results
295 * LPBOOL pfGenerateOnClose address of flag for audit generation
296 * Variables :
297 * Result :
298 * Remark :
299 * Status : UNTESTED STUB
300 *
301 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
302 *****************************************************************************/
303
304BOOL WIN32API AccessCheckAndAuditAlarmW(LPCWSTR SubsystemName,
305 LPVOID HandleId,
306 LPWSTR ObjectTypeName,
307 LPWSTR ObjectName,
308 PSECURITY_DESCRIPTOR SecurityDescriptor,
309 DWORD DesiredAccess,
310 PGENERIC_MAPPING GenericMapping,
311 BOOL ObjectCreation,
312 LPDWORD GrantedAccess,
313 LPBOOL AccessStatus,
314 LPBOOL pfGenerateOnClose)
315{
316 dprintf(("ADVAPI32: AccessCheckAndAuditAlarmW(%s,%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
317 SubsystemName,
318 HandleId,
319 ObjectTypeName,
320 ObjectName,
321 SecurityDescriptor,
322 DesiredAccess,
323 GenericMapping,
324 ObjectCreation,
325 GrantedAccess,
326 AccessStatus,
327 pfGenerateOnClose));
328
329 return (FALSE);
330}
331
332
333/*****************************************************************************
334 * Name : AddAccessAllowedAce
335 * Purpose : The AddAccessAllowedAce function adds an access-allowed ACE to
336 * an ACL. The access is granted to a specified SID. An ACE is an
337 * access-control entry. An ACL is an access-control list. A SID is
338 * a security identifier.
339 * Parameters: PACL pAcl address of access-control list
340 * DWORD dwAceRevision ACL revision level
341 * DWORD AccessMask access mask
342 * PSID pSid address of security identifier
343 * Variables :
344 * Result :
345 * Remark :
346 * Status : UNTESTED STUB
347 *
348 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
349 *****************************************************************************/
350
351BOOL WIN32API AddAccessAllowedAce(PACL pAcl,
352 DWORD dwAceRevision,
353 DWORD AccessMask,
354 PSID pSid)
355{
356 dprintf(("ADVAPI32: AddAccessAllowedAce(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
357 pAcl,
358 dwAceRevision,
359 AccessMask,
360 pSid));
361
362 return (FALSE);
363}
364
365
366/*****************************************************************************
367 * Name : AddAccessDeniedAce
368 * Purpose : The AddAccessDeniedAce function adds an access-denied ACE to an
369 * ACL. The access is denied to a specified SID. An ACE is an
370 * access-control entry. An ACL is an access-control list. A SID
371 * is a security identifier.
372 * Parameters: PACL pAcl address of access-control list
373 * DWORD dwAceRevision ACL revision level
374 * DWORD AccessMask access mask
375 * PSID pSid address of security identifier
376 * Variables :
377 * Result :
378 * Remark :
379 * Status : UNTESTED STUB
380 *
381 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
382 *****************************************************************************/
383
384BOOL WIN32API AddAccessDeniedAce(PACL pAcl,
385 DWORD dwAceRevision,
386 DWORD AccessMask,
387 PSID pSid)
388{
389 dprintf(("ADVAPI32: AddAccessDeniedAce(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
390 pAcl,
391 dwAceRevision,
392 AccessMask,
393 pSid));
394
395 return (FALSE);
396}
397
398
399/*****************************************************************************
400 * Name : AddAce
401 * Purpose : The AddAce function adds one or more ACEs to a specified ACL.
402 * An ACE is an access-control entry. An ACL is an access-control list.
403 * Parameters: PACL pAcl address of access-control list
404 * DWORD dwAceRevision ACL revision level
405 * DWORD dwStartingAceIndex index of ACE position in ACL
406 * LPVOID pAceList address of one or more ACEs
407 * DWORD nAceListLength size of buffer for ACEs
408 * Variables :
409 * Result :
410 * Remark :
411 * Status : UNTESTED STUB
412 *
413 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
414 *****************************************************************************/
415
416BOOL WIN32API AddAce(PACL pAcl,
417 DWORD dwAceRevision,
418 DWORD dwStartingAceIndex,
419 LPVOID pAceList,
420 DWORD nAceListLength)
421{
422 dprintf(("ADVAPI32: AddAce(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
423 pAcl,
424 dwAceRevision,
425 dwStartingAceIndex,
426 pAceList,
427 nAceListLength));
428
429 return (FALSE);
430}
431
432
433/*****************************************************************************
434 * Name : AddAuditAccessAce
435 * Purpose : The AddAuditAccessAce function adds a system-audit ACE to a
436 * system ACL. The access of a specified SID is audited. An ACE is
437 * an access-control entry. An ACL is an access-control list. A SID
438 * is a security identifier.
439 * Parameters: PACL pAcl address of access-control list
440 * DWORD dwAceRevision ACL revision level
441 * DWORD dwAccessMask access mask
442 * PSID pSid address of security identifier
443 * BOOL bAuditSuccess flag for auditing successful access
444 * BOOL bAuditFailure flag for auditing unsuccessful access attempts
445 * Variables :
446 * Result :
447 * Remark :
448 * Status : UNTESTED STUB
449 *
450 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
451 *****************************************************************************/
452
453BOOL WIN32API AddAuditAccessAce(PACL pAcl,
454 DWORD dwAceRevision,
455 DWORD dwAccessMask,
456 PSID pSid,
457 BOOL bAuditSuccess,
458 BOOL bAuditFailure)
459{
460 dprintf(("ADVAPI32: AddAuditAccessAce(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
461 pAcl,
462 dwAceRevision,
463 dwAccessMask,
464 pSid,
465 bAuditSuccess,
466 bAuditFailure));
467
468 return (FALSE);
469}
470
471
472/*****************************************************************************
473 * Name : AdjustTokenGroups
474 * Purpose : The AdjustTokenGroups function adjusts groups in the specified
475 * access token. TOKEN_ADJUST_GROUPS access is required to enable
476 * or disable groups in an access token.
477 * Parameters: HANDLE TokenHandle handle of token that contains groups
478 * BOOL ResetToDefault flag for default settings
479 * PTOKEN_GROUPS NewState address of new group information
480 * DWORD BufferLength size of buffer for previous information
481 * PTOKEN_GROUPS PreviousState address of previous group information
482 * LPDWORD ReturnLength address of required buffer size
483 * Variables :
484 * Result :
485 * Remark :
486 * Status : UNTESTED STUB
487 *
488 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
489 *****************************************************************************/
490
491#define PTOKEN_GROUPS LPVOID
492BOOL WIN32API AdjustTokenGroups(HANDLE TokenHandle,
493 BOOL ResetToDefault,
494 PTOKEN_GROUPS NewState,
495 DWORD BufferLength,
496 PTOKEN_GROUPS PreviousState,
497 LPDWORD ReturnLength)
498{
499 dprintf(("ADVAPI32: AdjustTokenGroups(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
500 TokenHandle,
501 ResetToDefault,
502 NewState,
503 BufferLength,
504 PreviousState,
505 ReturnLength));
506
507 return (FALSE); /* signal failure */
508}
509
510
511
512/*****************************************************************************
513 * Name : AllocateLocallyUniqueId
514 * Purpose : The AllocateLocallyUniqueId function allocates a locally unique
515 * identifier (LUID).
516 * Parameters: PLUID Luid address of locally unique identifier
517 * Variables :
518 * Result :
519 * Remark :
520 * Status : UNTESTED STUB
521 *
522 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
523 *****************************************************************************/
524
525BOOL WIN32API AllocateLocallyUniqueId(PLUID Luid)
526{
527 dprintf(("ADVAPI32: AllocateLocallyUniqueId(%08xh) not implemented.\n",
528 Luid));
529
530 return (FALSE); /* signal failure */
531}
532
533
534/*****************************************************************************
535 * Name : AreAllAccessesGranted
536 * Purpose : The AreAllAccessesGranted function checks whether a set of
537 * requested access rights has been granted. The access rights are
538 * represented as bit flags in a 32-bit access mask.
539 * Parameters: DWORD GrantedAccess access mask for granted access rights
540 * DWORD DesiredAccess access mask for requested access rights
541 * Variables :
542 * Result :
543 * Remark :
544 * Status : UNTESTED STUB
545 *
546 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
547 *****************************************************************************/
548
549BOOL WIN32API AreAllAccessesGranted(DWORD GrantedAccess,
550 DWORD DesiredAccess)
551{
552 dprintf(("ADVAPI32: AreAllAccessesGranted(%08xh,%08xh) not implemented.\n",
553 GrantedAccess,
554 DesiredAccess));
555
556 return (TRUE); /* grant all access */
557}
558
559
560/*****************************************************************************
561 * Name : AreAnyAccessesGranted
562 * Purpose : The AreAnyAccessesGranted function tests whether any of a set of
563 * requested access rights has been granted. The access rights are
564 * represented as bit flags in a 32-bit access mask.
565 * Parameters: DWORD GrantedAccess access mask for granted access rights
566 * DWORD DesiredAccess access mask for requested access rights
567 * Variables :
568 * Result :
569 * Remark :
570 * Status : UNTESTED STUB
571 *
572 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
573 *****************************************************************************/
574
575BOOL WIN32API AreAnyAccessesGranted(DWORD GrantedAccess,
576 DWORD DesiredAccess)
577{
578 dprintf(("ADVAPI32: AreAnyAccessesGranted(%08xh,%08xh) not implemented.\n",
579 GrantedAccess,
580 DesiredAccess));
581
582 return (TRUE); /* grant all access */
583}
584
585
586/*****************************************************************************
587 * Name : BackupEventLogA
588 * Purpose : The BackupEventLog function saves the specified event log to a
589 * backup file. The function does not clear the event log.
590 * Parameters: HANDLE hEventLog handle to event log
591 * LPCSTR lpBackupFileName name of backup file
592 * Variables :
593 * Result :
594 * Remark :
595 * Status : UNTESTED STUB
596 *
597 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
598 *****************************************************************************/
599
600BOOL WIN32API BackupEventLogA(HANDLE hEventLog,
601 LPCSTR lpBackupFileName)
602{
603 dprintf(("ADVAPI32: BackupEventLogA(%08xh,%s) not implemented.\n",
604 hEventLog,
605 lpBackupFileName));
606
607 return (FALSE); /* signal failure */
608}
609
610
611/*****************************************************************************
612 * Name : BackupEventLogW
613 * Purpose : The BackupEventLog function saves the specified event log to a
614 * backup file. The function does not clear the event log.
615 * Parameters: HANDLE hEventLog handle to event log
616 * LPCWSTR lpBackupFileName name of backup file
617 * Variables :
618 * Result :
619 * Remark :
620 * Status : UNTESTED STUB
621 *
622 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
623 *****************************************************************************/
624
625BOOL WIN32API BackupEventLogW(HANDLE hEventLog,
626 LPCWSTR lpBackupFileName)
627{
628 dprintf(("ADVAPI32: BackupEventLogW() not implemented.\n",
629 hEventLog,
630 lpBackupFileName));
631
632 return (FALSE); /* signal failure */
633}
634
635
636/*****************************************************************************
637 * Name : ChangeServiceConfigA
638 * Purpose : The ChangeServiceConfig function changes the configuration
639 * parameters of a service.
640 * Parameters: SC_HANDLE hService handle of service
641 * DWORD dwServiceType type of service
642 * DWORD dwStartType when to start service
643 * DWORD dwErrorControl severity if service fails to start
644 * LPCSTR lpBinaryPathName address of service binary file name
645 * LPCSTR lpLoadOrderGroup address of load ordering group name
646 * LPDWORD lpdwTagId address of variable to get tag identifier
647 * LPCSTR lpDependencies address of array of dependency names
648 * LPCSTR lpServiceStartName address of account name of service
649 * LPCSTR lpPassword address of password for service account
650 * LPCSTR lpDisplayName address of display name
651 * Variables :
652 * Result :
653 * Remark :
654 * Status : UNTESTED STUB
655 *
656 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
657 *****************************************************************************/
658
659#define SC_HANDLE HANDLE
660BOOL WIN32API ChangeServiceConfigA(SC_HANDLE hService,
661 DWORD dwServiceType,
662 DWORD dwStartType,
663 DWORD dwErrorControl,
664 LPCSTR lpBinaryPathName,
665 LPCSTR lpLoadOrderGroup,
666 LPDWORD lpdwTagId,
667 LPCSTR lpDependencies,
668 LPCSTR lpServiceStartName,
669 LPCSTR lpPassword,
670 LPCSTR lpDisplayName)
671{
672 dprintf(("ADVAPI32: ChangeServiceConfigA(%08xh,%08xh,%08xh,%08xh,%s,%s,%08xh,%s,%s,%s,%s) not implemented.\n",
673 hService,
674 dwServiceType,
675 dwStartType,
676 dwErrorControl,
677 lpBinaryPathName,
678 lpLoadOrderGroup,
679 lpdwTagId,
680 lpDependencies,
681 lpServiceStartName,
682 lpPassword,
683 lpDisplayName));
684
685 return (FALSE); /* signal failure */
686}
687
688
689/*****************************************************************************
690 * Name : ChangeServiceConfigW
691 * Purpose : The ChangeServiceConfig function changes the configuration
692 * parameters of a service.
693 * Parameters: SC_HANDLE hService handle of service
694 * DWORD dwServiceType type of service
695 * DWORD dwStartType when to start service
696 * DWORD dwErrorControl severity if service fails to start
697 * LPCWSTR lpBinaryPathName address of service binary file name
698 * LPCWSTR lpLoadOrderGroup address of load ordering group name
699 * LPDWORD lpdwTagId address of variable to get tag identifier
700 * LPCWSTR lpDependencies address of array of dependency names
701 * LPCWSTR lpServiceStartName address of account name of service
702 * LPCWSTR lpPassword address of password for service account
703 * LPCWSTR lpDisplayName address of display name
704 * Variables :
705 * Result :
706 * Remark :
707 * Status : UNTESTED STUB
708 *
709 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
710 *****************************************************************************/
711
712BOOL WIN32API ChangeServiceConfigW(SC_HANDLE hService,
713 DWORD dwServiceType,
714 DWORD dwStartType,
715 DWORD dwErrorControl,
716 LPCWSTR lpBinaryPathName,
717 LPCWSTR lpLoadOrderGroup,
718 LPDWORD lpdwTagId,
719 LPCWSTR lpDependencies,
720 LPCWSTR lpServiceStartName,
721 LPCWSTR lpPassword,
722 LPCWSTR lpDisplayName)
723{
724 dprintf(("ADVAPI32: ChangeServiceConfigW(%08xh,%08xh,%08xh,%08xh,%s,%s,%08xh,%s,%s,%s,%s) not implemented.\n",
725 hService,
726 dwServiceType,
727 dwStartType,
728 dwErrorControl,
729 lpBinaryPathName,
730 lpLoadOrderGroup,
731 lpdwTagId,
732 lpDependencies,
733 lpServiceStartName,
734 lpPassword,
735 lpDisplayName));
736
737 return (FALSE); /* signal failure */
738}
739
740
741/*****************************************************************************
742 * Name : ClearEventLogA
743 * Purpose : The ClearEventLog function clears the specified event log, and
744 * optionally saves the current copy of the logfile to a backup file.
745 * Parameters: HANDLE hEventLog handle to event log
746 * LPCSTR lpBackupFileName name of backup file
747 * Variables :
748 * Result :
749 * Remark :
750 * Status : UNTESTED STUB
751 *
752 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
753 *****************************************************************************/
754
755BOOL WIN32API ClearEventLogA(HANDLE hEventLog,
756 LPCSTR lpBackupFileName)
757{
758 dprintf(("ADVAPI32: ClearEventLogA(%08xh,%s) not implemented.\n",
759 hEventLog,
760 lpBackupFileName));
761
762 return (FALSE); /* signal failure */
763}
764
765
766/*****************************************************************************
767 * Name : ClearEventLogW
768 * Purpose : The ClearEventLog function clears the specified event log, and
769 * optionally saves the current copy of the logfile to a backup file.
770 * Parameters: HANDLE hEventLog handle to event log
771 * LPCSTR lpBackupFileName name of backup file
772 * Variables :
773 * Result :
774 * Remark :
775 * Status : UNTESTED STUB
776 *
777 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
778 *****************************************************************************/
779
780BOOL WIN32API ClearEventLogW(HANDLE hEventLog,
781 LPCWSTR lpBackupFileName)
782{
783 dprintf(("ADVAPI32: ClearEventLogW(%08xh,%s) not implemented.\n",
784 hEventLog,
785 lpBackupFileName));
786
787 return (FALSE); /* signal failure */
788}
789
790
791/*****************************************************************************
792 * Name : CloseEventLog
793 * Purpose : The CloseEventLog function closes the specified event log.
794 * Parameters: HANDLE hEventLog handle to event log
795 * Variables :
796 * Result :
797 * Remark :
798 * Status : UNTESTED STUB
799 *
800 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
801 *****************************************************************************/
802
803BOOL WIN32API CloseEventLog(HANDLE hEventLog)
804{
805 dprintf(("ADVAPI32: CloseEventLog(%08xh) not implemented.\n",
806 hEventLog));
807
808 return (FALSE); /* signal failure */
809}
810
811
812/*****************************************************************************
813 * Name : CloseServiceHandle
814 * Purpose : The CloseServiceHandle function closes a handle to a service
815 * control manager database as returned by the OpenSCManager function,
816 * or it closes a handle to a service object as returned by either
817 * the OpenService or CreateService function.
818 * Parameters: SC_HANDLE hSCObject handle of service or service control manager database
819 * Variables :
820 * Result :
821 * Remark :
822 * Status : UNTESTED STUB
823 *
824 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
825 *****************************************************************************/
826
827BOOL WIN32API CloseServiceHandle(SC_HANDLE hSCObject)
828{
829 dprintf(("ADVAPI32: CloseServiceHandle(%08xh) not implemented.\n",
830 hSCObject));
831
832 return (FALSE); /* signal failure */
833}
834
835
836/*****************************************************************************
837 * Name : ControlService
838 * Purpose : The ControlService function sends a control code to a Win32 service.
839 * Parameters: SC_HANDLE hService handle of service
840 * DWORD dwControl control code
841 * LPSERVICE_STATUS lpServiceStatus address of service status structure
842 * Variables :
843 * Result :
844 * Remark :
845 * Status : UNTESTED STUB
846 *
847 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
848 *****************************************************************************/
849
850BOOL WIN32API ControlService(SC_HANDLE hService,
851 DWORD dwControl,
852 LPSERVICE_STATUS lpServiceStatus)
853{
854 dprintf(("ADVAPI32: ControlService(%08xh,%08xh,%08xh) not implemented.\n",
855 hService,
856 dwControl,
857 lpServiceStatus));
858
859 return (FALSE); /* signal failure */
860}
861
862
863
864/*****************************************************************************
865 * Name : CreatePrivateObjectSecurity
866 * Purpose : The CreatePrivateObjectSecurity function allocates and initializes
867 * a self-relative security descriptor for a new protected server's
868 * object. This function is called when a new protected server object is being created.
869 * Parameters: PSECURITY_DESCRIPTOR ParentDescriptor address of parent directory SD
870 * PSECURITY_DESCRIPTOR CreatorDescriptor address of creator SD
871 * PSECURITY_DESCRIPTOR *NewDescriptor address of pointer to new SD
872 * BOOL IsDirectoryObject container flag for new SD
873 * HANDLE Token handle of client's access token
874 * PGENERIC_MAPPING GenericMapping address of access-rights structure
875 * Variables :
876 * Result :
877 * Remark :
878 * Status : UNTESTED STUB
879 *
880 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
881 *****************************************************************************/
882
883BOOL WIN32API CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR ParentDescriptor,
884 PSECURITY_DESCRIPTOR CreatorDescriptor,
885 PSECURITY_DESCRIPTOR *NewDescriptor,
886 BOOL IsDirectoryObject,
887 HANDLE Token,
888 PGENERIC_MAPPING GenericMapping)
889{
890 dprintf(("ADVAPI32: CreatePrivateObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
891 ParentDescriptor,
892 CreatorDescriptor,
893 NewDescriptor,
894 IsDirectoryObject,
895 Token,
896 GenericMapping));
897
898 return (FALSE); /* signal failure */
899}
900
901
902/*****************************************************************************
903 * Name : CreateProcessAsUserA
904 * Purpose : The CreateProcessAsUser function creates a new process and its
905 * primary thread. The new process then executes a specified executable
906 * file. The CreateProcessAsUser function behaves just like the
907 * CreateProcess function, with one important difference: the
908 * created process runs in a context in which the system sees the
909 * user represented by the hToken parameter as if that user had
910 * logged on to the system and then called the CreateProcess function.
911 * Parameters: HANDLE hToken handle to a token that represents a logged-on user
912 * LPCSTR lpApplicationName pointer to name of executable module
913 * LPTSTR lpCommandLine pointer to command line string
914 * LPSECURITY_ATTRIBUTES lpProcessAttributes pointer to process security attributes
915 * LPSECURITY_ATTRIBUTES lpThreadAttributes pointer to thread security attributes
916 * BOOL bInheritHandles new process inherits handles
917 * DWORD dwCreationFlags creation flags
918 * LPVOID lpEnvironment pointer to new environment block
919 * LPCSTR lpCurrentDirectory pointer to current directory name
920 * LPSTARTUPINFO lpStartupInfo pointer to STARTUPINFO
921 * LPPROCESS_INFORMATION lpProcessInformation pointer to PROCESS_INFORMATION
922 * Variables :
923 * Result :
924 * Remark :
925 * Status : UNTESTED STUB
926 *
927 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
928 *****************************************************************************/
929
930BOOL WIN32API CreateProcessAsUserA(HANDLE hToken,
931 LPCSTR lpApplicationName,
932 LPTSTR lpCommandLine,
933 LPSECURITY_ATTRIBUTES lpProcessAttributes,
934 LPSECURITY_ATTRIBUTES lpThreadAttributes,
935 BOOL bInheritHandles,
936 DWORD dwCreationFlags,
937 LPVOID lpEnvironment,
938 LPCSTR lpCurrentDirectory,
939 LPSTARTUPINFOA lpStartupInfo,
940 LPPROCESS_INFORMATION lpProcessInformation)
941{
942 dprintf(("ADVAPI32: CreateProcessAsUserA(%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%s,%08xh,%08xh) not implemented.\n",
943 hToken,
944 lpApplicationName,
945 lpCommandLine,
946 lpProcessAttributes,
947 lpThreadAttributes,
948 bInheritHandles,
949 dwCreationFlags,
950 lpEnvironment,
951 lpCurrentDirectory,
952 lpStartupInfo,
953 lpProcessInformation));
954
955 return (FALSE); /* signal failure */
956}
957
958
959/*****************************************************************************
960 * Name : CreateProcessAsUserW
961 * Purpose : The CreateProcessAsUser function creates a new process and its
962 * primary thread. The new process then executes a specified executable
963 * file. The CreateProcessAsUser function behaves just like the
964 * CreateProcess function, with one important difference: the
965 * created process runs in a context in which the system sees the
966 * user represented by the hToken parameter as if that user had
967 * logged on to the system and then called the CreateProcess function.
968 * Parameters: HANDLE hToken handle to a token that represents a logged-on user
969 * LPCWSTR lpApplicationName pointer to name of executable module
970 * LPWSTR lpCommandLine pointer to command line string
971 * LPSECURITY_ATTRIBUTES lpProcessAttributes pointer to process security attributes
972 * LPSECURITY_ATTRIBUTES lpThreadAttributes pointer to thread security attributes
973 * BOOL bInheritHandles new process inherits handles
974 * DWORD dwCreationFlags creation flags
975 * LPVOID lpEnvironment pointer to new environment block
976 * LPCWSTR lpCurrentDirectory pointer to current directory name
977 * LPSTARTUPINFO lpStartupInfo pointer to STARTUPINFO
978 * LPPROCESS_INFORMATION lpProcessInformation pointer to PROCESS_INFORMATION
979 * Variables :
980 * Result :
981 * Remark :
982 * Status : UNTESTED STUB
983 *
984 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
985 *****************************************************************************/
986
987BOOL WIN32API CreateProcessAsUserW(HANDLE hToken,
988 LPCWSTR lpApplicationName,
989 LPWSTR lpCommandLine,
990 LPSECURITY_ATTRIBUTES lpProcessAttributes,
991 LPSECURITY_ATTRIBUTES lpThreadAttributes,
992 BOOL bInheritHandles,
993 DWORD dwCreationFlags,
994 LPVOID lpEnvironment,
995 LPCWSTR lpCurrentDirectory,
996 LPSTARTUPINFOA lpStartupInfo,
997 LPPROCESS_INFORMATION lpProcessInformation)
998{
999 dprintf(("ADVAPI32: CreateProcessAsUserW(%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%s,%08xh,%08xh) not implemented.\n",
1000 hToken,
1001 lpApplicationName,
1002 lpCommandLine,
1003 lpProcessAttributes,
1004 lpThreadAttributes,
1005 bInheritHandles,
1006 dwCreationFlags,
1007 lpEnvironment,
1008 lpCurrentDirectory,
1009 lpStartupInfo,
1010 lpProcessInformation));
1011
1012 return (FALSE); /* signal failure */
1013}
1014
1015
1016/*****************************************************************************
1017 * Name : CreateServiceA
1018 * Purpose : The CreateService function creates a service object and adds it
1019 * to the specified service control manager database.
1020 * Parameters: SC_HANDLE hSCManager handle of service control manager database
1021 * LPCSTR lpServiceName address of name of service to start
1022 * LPCSTR lpDisplayName address of display name
1023 * DWORD dwDesiredAccess type of access to service
1024 * DWORD dwServiceType type of service
1025 * DWORD dwStartType when to start service
1026 * DWORD dwErrorControl severity if service fails to start
1027 * LPCSTR lpBinaryPathName address of name of binary file
1028 * LPCSTR lpLoadOrderGroup address of name of load ordering group
1029 * LPDWORD lpdwTagId address of variable to get tag identifier
1030 * LPCSTR lpDependencies address of array of dependency names
1031 * LPCSTR lpServiceStartName address of account name of service
1032 * LPCSTR lpPassword address of password for service account
1033 * Variables :
1034 * Result :
1035 * Remark :
1036 * Status : UNTESTED STUB
1037 *
1038 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1039 *****************************************************************************/
1040
1041SC_HANDLE WIN32API CreateServiceA(SC_HANDLE hSCManager,
1042 LPCSTR lpServiceName,
1043 LPCSTR lpDisplayName,
1044 DWORD dwDesiredAccess,
1045 DWORD dwServiceType,
1046 DWORD dwStartType,
1047 DWORD dwErrorControl,
1048 LPCSTR lpBinaryPathName,
1049 LPCSTR lpLoadOrderGroup,
1050 LPDWORD lpdwTagId,
1051 LPCSTR lpDependencies,
1052 LPCSTR lpServiceStartName,
1053 LPCSTR lpPassword)
1054{
1055 dprintf(("ADVAPI32: CreateServiceA(%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%s,%s,%08xh,%s,%s,%s) not implemented.\n",
1056 hSCManager,
1057 lpServiceName,
1058 lpDisplayName,
1059 dwDesiredAccess,
1060 dwServiceType,
1061 dwStartType,
1062 dwErrorControl,
1063 lpBinaryPathName,
1064 lpLoadOrderGroup,
1065 lpdwTagId,
1066 lpDependencies,
1067 lpServiceStartName,
1068 lpPassword));
1069
1070 return (NULL); /* signal failure */
1071}
1072
1073
1074/*****************************************************************************
1075 * Name : CreateServiceW
1076 * Purpose : The CreateService function creates a service object and adds it
1077 * to the specified service control manager database.
1078 * Parameters: SC_HANDLE hSCManager handle of service control manager database
1079 * LPCWSTR lpServiceName address of name of service to start
1080 * LPCWSTR lpDisplayName address of display name
1081 * DWORD dwDesiredAccess type of access to service
1082 * DWORD dwServiceType type of service
1083 * DWORD dwStartType when to start service
1084 * DWORD dwErrorControl severity if service fails to start
1085 * LPCWSTR lpBinaryPathName address of name of binary file
1086 * LPCWSTR lpLoadOrderGroup address of name of load ordering group
1087 * LPDWORD lpdwTagId address of variable to get tag identifier
1088 * LPCWSTR lpDependencies address of array of dependency names
1089 * LPCWSTR lpServiceStartName address of account name of service
1090 * LPCWSTR lpPassword address of password for service account
1091 * Variables :
1092 * Result :
1093 * Remark :
1094 * Status : UNTESTED STUB
1095 *
1096 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1097 *****************************************************************************/
1098
1099SC_HANDLE WIN32API CreateServiceW(SC_HANDLE hSCManager,
1100 LPCWSTR lpServiceName,
1101 LPCWSTR lpDisplayName,
1102 DWORD dwDesiredAccess,
1103 DWORD dwServiceType,
1104 DWORD dwStartType,
1105 DWORD dwErrorControl,
1106 LPCWSTR lpBinaryPathName,
1107 LPCWSTR lpLoadOrderGroup,
1108 LPDWORD lpdwTagId,
1109 LPCWSTR lpDependencies,
1110 LPCWSTR lpServiceStartName,
1111 LPCWSTR lpPassword)
1112{
1113 dprintf(("ADVAPI32: CreateServiceW(%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%s,%s,%08xh,%s,%s,%s) not implemented.\n",
1114 hSCManager,
1115 lpServiceName,
1116 lpDisplayName,
1117 dwDesiredAccess,
1118 dwServiceType,
1119 dwStartType,
1120 dwErrorControl,
1121 lpBinaryPathName,
1122 lpLoadOrderGroup,
1123 lpdwTagId,
1124 lpDependencies,
1125 lpServiceStartName,
1126 lpPassword));
1127
1128 return (NULL); /* signal failure */
1129}
1130
1131
1132/*****************************************************************************
1133 * Name : DeleteAce
1134 * Purpose : The DeleteAce function deletes an ACE from an ACL.
1135 * An ACE is an access-control entry. An ACL is an access-control list.
1136 * Parameters: PACL pAcl address of access-control list
1137 * DWORD dwAceIndex index of ACE position in ACL
1138 * Variables :
1139 * Result :
1140 * Remark :
1141 * Status : UNTESTED STUB
1142 *
1143 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1144 *****************************************************************************/
1145
1146BOOL WIN32API DeleteAce(PACL pAcl,
1147 DWORD dwAceIndex)
1148{
1149 dprintf(("ADVAPI32: DeleteAce(%08xh, %08xh) not implemented.\n",
1150 pAcl,
1151 dwAceIndex));
1152
1153 return (FALSE); /* signal failure */
1154}
1155
1156
1157/*****************************************************************************
1158 * Name : DeleteService
1159 * Purpose : The DeleteService function marks the specified service for
1160 * deletion from the service control manager database.
1161 * Parameters: SC_HANDLE hService handle of service
1162 * Variables :
1163 * Result :
1164 * Remark :
1165 * Status : UNTESTED STUB
1166 *
1167 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1168 *****************************************************************************/
1169
1170BOOL WIN32API DeleteService(SC_HANDLE hService)
1171{
1172 dprintf(("ADVAPI32: DeleteService(%08xh) not implemented.\n",
1173 hService));
1174
1175 return (FALSE); /* signal failure */
1176}
1177
1178
1179/*****************************************************************************
1180 * Name : DestroyPrivateObjectSecurity
1181 * Purpose : The DestroyPrivateObjectSecurity function deletes a protected
1182 * server object's security descriptor. This security descriptor
1183 * must have been created by a call to the CreatePrivateObjectSecurity function.
1184 * Parameters: PSECURITY_DESCRIPTOR * ObjectDescriptor address of pointer to SECURITY_DESCRIPTOR
1185 * Variables :
1186 * Result :
1187 * Remark :
1188 * Status : UNTESTED STUB
1189 *
1190 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1191 *****************************************************************************/
1192
1193BOOL WIN32API DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR *ObjectDescriptor)
1194{
1195 dprintf(("ADVAPI32: DestroyPrivateObjectSecurity(%08xh) not implemented.\n",
1196 ObjectDescriptor));
1197
1198 return (FALSE); /* signal failure */
1199}
1200
1201
1202/*****************************************************************************
1203 * Name : DuplicateToken
1204 * Purpose : The DuplicateToken function creates a new access token that
1205 * duplicates one already in existence.
1206 * Parameters: HANDLE ExistingTokenHandle handle of token to duplicate
1207 * SECURITY_IMPERSONATION_LEVEL ImpersonationLevel impersonation level
1208 * PHANDLE DuplicateTokenHandle handle of duplicated token
1209 * Variables :
1210 * Result :
1211 * Remark :
1212 * Status : UNTESTED STUB
1213 *
1214 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1215 *****************************************************************************/
1216
1217BOOL WIN32API DuplicateToken(HANDLE ExistingTokenHandle,
1218 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
1219 PHANDLE DuplicateTokenHandle)
1220{
1221 dprintf(("ADVAPI32: DuplicateToken(%08x,%08xh,%08xh) not implemented.\n",
1222 ExistingTokenHandle,
1223 ImpersonationLevel,
1224 DuplicateTokenHandle));
1225
1226 return (FALSE); /* signal failure */
1227}
1228
1229
1230/*****************************************************************************
1231 * Name : EnumDependentServicesA
1232 * Purpose : The EnumDependentServices function enumerates services that
1233 * depend on another specified service; that is, the specified
1234 * service must be running before the enumerated services can run.
1235 * The name and status of each dependent service are provided.
1236 * Parameters: SC_HANDLE hService handle of service
1237 * DWORD dwServiceState state of services to enumerate
1238 * LPENUM_SERVICE_STATUS lpServices address of service status buffer
1239 * DWORD cbBufSize size of service status buffer
1240 * LPDWORD pcbBytesNeeded address of variable for bytes needed
1241 * LPDWORD lpServicesReturned address of variable for number returned
1242 * Variables :
1243 * Result :
1244 * Remark :
1245 * Status : UNTESTED STUB
1246 *
1247 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1248 *****************************************************************************/
1249
1250#define LPENUM_SERVICE_STATUS LPVOID
1251BOOL WIN32API EnumDependentServicesA(SC_HANDLE hService,
1252 DWORD dwServiceState,
1253 LPENUM_SERVICE_STATUS lpServices,
1254 DWORD cbBufSize,
1255 LPDWORD pcbBytesNeeded,
1256 LPDWORD lpServicesReturned)
1257{
1258 dprintf(("ADVAPI32: EnumDependentServicesA(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1259 hService,
1260 dwServiceState,
1261 lpServices,
1262 cbBufSize,
1263 pcbBytesNeeded,
1264 lpServicesReturned));
1265
1266 return (FALSE); /* signal failure */
1267}
1268
1269
1270/*****************************************************************************
1271 * Name : EnumDependentServicesW
1272 * Purpose : The EnumDependentServices function enumerates services that
1273 * depend on another specified service; that is, the specified
1274 * service must be running before the enumerated services can run.
1275 * The name and status of each dependent service are provided.
1276 * Parameters: SC_HANDLE hService handle of service
1277 * DWORD dwServiceState state of services to enumerate
1278 * LPENUM_SERVICE_STATUS lpServices address of service status buffer
1279 * DWORD cbBufSize size of service status buffer
1280 * LPDWORD pcbBytesNeeded address of variable for bytes needed
1281 * LPDWORD lpServicesReturned address of variable for number returned
1282 * Variables :
1283 * Result :
1284 * Remark :
1285 * Status : UNTESTED STUB
1286 *
1287 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1288 *****************************************************************************/
1289
1290BOOL WIN32API EnumDependentServicesW(SC_HANDLE hService,
1291 DWORD dwServiceState,
1292 LPENUM_SERVICE_STATUS lpServices,
1293 DWORD cbBufSize,
1294 LPDWORD pcbBytesNeeded,
1295 LPDWORD lpServicesReturned)
1296{
1297 dprintf(("ADVAPI32: EnumDependentServicesW(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1298 hService,
1299 dwServiceState,
1300 lpServices,
1301 cbBufSize,
1302 pcbBytesNeeded,
1303 lpServicesReturned));
1304
1305 return (FALSE); /* signal failure */
1306}
1307
1308
1309/*****************************************************************************
1310 * Name : EnumServicesStatusA
1311 * Purpose : The EnumServicesStatus function enumerates services in the specified
1312 * service control manager database. The name and status of each service are provided.
1313 * Parameters: SC_HANDLE hSCManager handle of service control manager database
1314 * DWORD dwServiceType type of services to enumerate
1315 * DWORD dwServiceState state of services to enumerate
1316 * LPENUM_SERVICE_STATUS lpServices address of service status buffer
1317 * DWORD cbBufSize size of service status buffer
1318 * LPDWORD pcbBytesNeeded address of variable for bytes needed
1319 * LPDWORD lpServicesReturned address of variable for number returned
1320 * LPDWORD lpResumeHandle address of variable for next entry
1321 * Variables :
1322 * Result :
1323 * Remark :
1324 * Status : UNTESTED STUB
1325 *
1326 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1327 *****************************************************************************/
1328
1329BOOL WIN32API EnumServicesStatusA(SC_HANDLE hSCManager,
1330 DWORD dwServiceType,
1331 DWORD dwServiceState,
1332 LPENUM_SERVICE_STATUS lpServices,
1333 DWORD cbBufSize,
1334 LPDWORD pcbBytesNeeded,
1335 LPDWORD lpServicesReturned,
1336 LPDWORD lpResumeHandle)
1337{
1338 dprintf(("ADVAPI32: EnumServicesStatusA(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1339 hSCManager,
1340 dwServiceType,
1341 dwServiceState,
1342 lpServices,
1343 cbBufSize,
1344 pcbBytesNeeded,
1345 lpServicesReturned,
1346 lpResumeHandle));
1347
1348 return (FALSE); /* signal failure */
1349}
1350
1351
1352/*****************************************************************************
1353 * Name : EnumServicesStatusW
1354 * Purpose : The EnumServicesStatus function enumerates services in the specified
1355 * service control manager database. The name and status of each service are provided.
1356 * Parameters: SC_HANDLE hSCManager handle of service control manager database
1357 * DWORD dwServiceType type of services to enumerate
1358 * DWORD dwServiceState state of services to enumerate
1359 * LPENUM_SERVICE_STATUS lpServices address of service status buffer
1360 * DWORD cbBufSize size of service status buffer
1361 * LPDWORD pcbBytesNeeded address of variable for bytes needed
1362 * LPDWORD lpServicesReturned address of variable for number returned
1363 * LPDWORD lpResumeHandle address of variable for next entry
1364 * Variables :
1365 * Result :
1366 * Remark :
1367 * Status : UNTESTED STUB
1368 *
1369 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1370 *****************************************************************************/
1371
1372BOOL WIN32API EnumServicesStatusW(SC_HANDLE hSCManager,
1373 DWORD dwServiceType,
1374 DWORD dwServiceState,
1375 LPENUM_SERVICE_STATUS lpServices,
1376 DWORD cbBufSize,
1377 LPDWORD pcbBytesNeeded,
1378 LPDWORD lpServicesReturned,
1379 LPDWORD lpResumeHandle)
1380{
1381 dprintf(("ADVAPI32: EnumServicesStatusW(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1382 hSCManager,
1383 dwServiceType,
1384 dwServiceState,
1385 lpServices,
1386 cbBufSize,
1387 pcbBytesNeeded,
1388 lpServicesReturned,
1389 lpResumeHandle));
1390
1391 return (FALSE); /* signal failure */
1392}
1393
1394
1395
1396/*****************************************************************************
1397 * Name : FindFirstFreeAce
1398 * Purpose : The FindFirstFreeAce function retrieves a pointer to the first
1399 * free byte in an access-control list (ACL).
1400 * Parameters: PACL pAcl address of access-control list
1401 * LPVOID *pAce address of pointer to first free byte
1402 * Variables :
1403 * Result :
1404 * Remark :
1405 * Status : UNTESTED STUB
1406 *
1407 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1408 *****************************************************************************/
1409
1410BOOL WIN32API FindFirstFreeAce(PACL pAcl,
1411 LPVOID *pAce)
1412{
1413 dprintf(("ADVAPI32: FindFirstFreeAce(%08xh, %08xh) not implemented.\n",
1414 pAcl,
1415 pAce));
1416
1417 return (FALSE); /* signal failure */
1418}
1419
1420
1421/*****************************************************************************
1422 * Name : GetAce
1423 * Purpose : The GetAce function obtains a pointer to an ACE in an ACL.
1424 * An ACE is an access control entry. An ACL is an access control list.
1425 * Parameters: PACL pAcl address of access-control list
1426 * DWORD dwAceIndex index of ACE to retrieve
1427 * LPVOID *pAce address of pointer to ACE
1428 * Variables :
1429 * Result :
1430 * Remark :
1431 * Status : UNTESTED STUB
1432 *
1433 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1434 *****************************************************************************/
1435
1436BOOL WIN32API GetAce(PACL pAcl,
1437 DWORD dwAceIndex,
1438 LPVOID *pAce)
1439{
1440 dprintf(("ADVAPI32: GetAce(%08xh,%08xh,%08xh) not implemented.\n",
1441 pAcl,
1442 dwAceIndex,
1443 pAce));
1444
1445 return (FALSE); /* signal failure */
1446}
1447
1448
1449/*****************************************************************************
1450 * Name : GetAclInformation
1451 * Purpose : The GetAclInformation function retrieves information about an
1452 * access-control list (ACL).
1453 * Parameters: PACL pAcl address of access-control list
1454 * LPVOID pAclInformation address of ACL information
1455 * DWORD nAclInformationLength size of ACL information
1456 * ACL_INFORMATION_CLASS dwAclInformationClass class of requested information
1457 * Variables :
1458 * Result :
1459 * Remark :
1460 * Status : UNTESTED STUB
1461 *
1462 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1463 *****************************************************************************/
1464
1465#define ACL_INFORMATION_CLASS DWORD
1466BOOL WIN32API GetAclInformation(PACL pAcl,
1467 LPVOID pAclInformation,
1468 DWORD nAclInformationLength,
1469 ACL_INFORMATION_CLASS dwAclInformationClass)
1470{
1471 dprintf(("ADVAPI32: GetAclInformation(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1472 pAcl,
1473 pAclInformation,
1474 nAclInformationLength,
1475 dwAclInformationClass));
1476
1477 return (FALSE); /* signal failure */
1478}
1479
1480
1481/*****************************************************************************
1482 * Name : GetKernelObjectSecurity
1483 * Purpose : The GetKernelObjectSecurity function retrieves a copy of the
1484 * security descriptor protecting a kernel object.
1485 * Parameters: HANDLE Handle handle of object to query
1486 * SECURITY_INFORMATION RequestedInformation requested information
1487 * PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
1488 * DWORD nLength size of buffer for security descriptor
1489 * LPDWORD lpnLengthNeeded address of required size of buffer
1490 * Variables :
1491 * Result :
1492 * Remark :
1493 * Status : UNTESTED STUB
1494 *
1495 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1496 *****************************************************************************/
1497
1498BOOL WIN32API GetKernelObjectSecurity(HANDLE Handle,
1499 SECURITY_INFORMATION RequestedInformation,
1500 PSECURITY_DESCRIPTOR pSecurityDescriptor,
1501 DWORD nLength,
1502 LPDWORD lpnLengthNeeded)
1503{
1504 dprintf(("ADVAPI32: GetKernelObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1505 Handle,
1506 RequestedInformation,
1507 pSecurityDescriptor,
1508 nLength,
1509 lpnLengthNeeded));
1510
1511 return (FALSE); /* signal failure */
1512}
1513
1514
1515
1516/*****************************************************************************
1517 * Name : GetNumberOfEventLogRecords
1518 * Purpose : The GetNumberOfEventLogRecords function retrieves the number of
1519 * records in the specified event log.
1520 * Parameters: HANDLE hEventLog handle to event log
1521 * LPDWORD NumberOfRecords buffer for number of records
1522 * Variables :
1523 * Result :
1524 * Remark :
1525 * Status : UNTESTED STUB
1526 *
1527 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1528 *****************************************************************************/
1529
1530BOOL WIN32API GetNumberOfEventLogRecords(HANDLE hEventLog,
1531 LPDWORD NumberOfRecords)
1532{
1533 dprintf(("ADVAPI32: GetNumberOfEventLogRecords(%08xh,%08xh) not implemented.\n",
1534 hEventLog,
1535 NumberOfRecords));
1536
1537 return (FALSE); /* signal failure */
1538}
1539
1540
1541/*****************************************************************************
1542 * Name : GetOldestEventLogRecord
1543 * Purpose : The GetOldestEventLogRecord function retrieves the absolute
1544 * record number of the oldest record in the specified event log.
1545 * Parameters: HANDLE hEventLog handle to event log
1546 * LPDWORD OldestRecord buffer for number of oldest record
1547 * Variables :
1548 * Result :
1549 * Remark :
1550 * Status : UNTESTED STUB
1551 *
1552 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1553 *****************************************************************************/
1554
1555BOOL WIN32API GetOldestEventLogRecord(HANDLE hEventLog,
1556 LPDWORD OldestRecord)
1557{
1558 dprintf(("ADVAPI32: GetOldestEventLogRecord(%08xh,%08xh) not implemented.\n",
1559 hEventLog,
1560 OldestRecord));
1561
1562 return (FALSE); /* signal failure */
1563}
1564
1565
1566/*****************************************************************************
1567 * Name : GetPrivateObjectSecurity
1568 * Purpose : The GetPrivateObjectSecurity retrieves information from a
1569 * protected server object's security descriptor.
1570 * Parameters: PSECURITY_DESCRIPTOR ObjectDescriptor address of SD to query
1571 * SECURITY_INFORMATION SecurityInformation requested information
1572 * PSECURITY_DESCRIPTOR ResultantDescriptor address of retrieved SD
1573 * DWORD DescriptorLength size of buffer for retrieved SD
1574 * LPDWORD ReturnLength address of buffer size required for SD
1575 * Variables :
1576 * Result :
1577 * Remark :
1578 * Status : UNTESTED STUB
1579 *
1580 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1581 *****************************************************************************/
1582
1583BOOL WIN32API GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR ObjectDescriptor,
1584 SECURITY_INFORMATION SecurityInformation,
1585 PSECURITY_DESCRIPTOR ResultantDescriptor,
1586 DWORD DescriptorLength,
1587 LPDWORD ReturnLength)
1588{
1589 dprintf(("ADVAPI32: GetPrivateObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1590 ObjectDescriptor,
1591 SecurityInformation,
1592 ResultantDescriptor,
1593 DescriptorLength,
1594 ReturnLength));
1595
1596 return (FALSE); /* signal failure */
1597}
1598
1599
1600/*****************************************************************************
1601 * Name : GetServiceDisplayNameA
1602 * Purpose : The GetServiceDisplayName function obtains the display name that
1603 * is associated with a particular service name. The service name
1604 * is the same as the service's registry key name.
1605 * Parameters: SC_HANDLE hSCManager handle to a service control manager database
1606 * LPCSTR lpServiceName the service name
1607 * LPTSTR lpDisplayName buffer to receive the service's display name
1608 * LPDWORD lpcchBuffer size of display name buffer and display name
1609 * Variables :
1610 * Result :
1611 * Remark :
1612 * Status : UNTESTED STUB
1613 *
1614 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1615 *****************************************************************************/
1616
1617BOOL WIN32API GetServiceDisplayNameA(SC_HANDLE hSCManager,
1618 LPCSTR lpServiceName,
1619 LPTSTR lpDisplayName,
1620 LPDWORD lpcchBuffer)
1621{
1622 dprintf(("ADVAPI32: GetServiceDisplayNameA(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1623 hSCManager,
1624 lpServiceName,
1625 lpDisplayName,
1626 lpcchBuffer));
1627
1628 return (FALSE); /* signal failure */
1629}
1630
1631
1632/*****************************************************************************
1633 * Name : GetServiceDisplayNameW
1634 * Purpose : The GetServiceDisplayName function obtains the display name that
1635 * is associated with a particular service name. The service name
1636 * is the same as the service's registry key name.
1637 * Parameters: SC_HANDLE hSCManager handle to a service control manager database
1638 * LPCWSTR lpServiceName the service name
1639 * LPWSTR lpDisplayName buffer to receive the service's display name
1640 * LPDWORD lpcchBuffer size of display name buffer and display name
1641 * Variables :
1642 * Result :
1643 * Remark :
1644 * Status : UNTESTED STUB
1645 *
1646 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1647 *****************************************************************************/
1648
1649BOOL WIN32API GetServiceDisplayNameW(SC_HANDLE hSCManager,
1650 LPCWSTR lpServiceName,
1651 LPWSTR lpDisplayName,
1652 LPDWORD lpcchBuffer)
1653{
1654 dprintf(("ADVAPI32: GetServiceDisplayNameW(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1655 hSCManager,
1656 lpServiceName,
1657 lpDisplayName,
1658 lpcchBuffer));
1659
1660 return (FALSE); /* signal failure */
1661}
1662
1663
1664/*****************************************************************************
1665 * Name : GetServiceKeyNameA
1666 * Purpose : The GetServiceKeyName function obtains the service name that is
1667 * associated with a particular service's display name. The service
1668 * name is the same as the service's registry key name.
1669 * Parameters: SC_HANDLE hSCManager handle to a service control manager database
1670 * LPCSTR lpDisplayName the service's display name
1671 * LPTSTR lpServiceName buffer to receive the service name
1672 * LPDWORD lpcchBuffer size of service name buffer and service name
1673 * Variables :
1674 * Result :
1675 * Remark :
1676 * Status : UNTESTED STUB
1677 *
1678 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1679 *****************************************************************************/
1680
1681BOOL WIN32API GetServiceKeyNameA(SC_HANDLE hSCManager,
1682 LPCSTR lpDisplayName,
1683 LPTSTR lpServiceName,
1684 LPDWORD lpcchBuffer)
1685{
1686 dprintf(("ADVAPI32: GetServiceKeyNameA(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1687 hSCManager,
1688 lpDisplayName,
1689 lpServiceName,
1690 lpcchBuffer));
1691
1692 return (FALSE); /* signal failure */
1693}
1694
1695
1696/*****************************************************************************
1697 * Name : GetServiceKeyNameW
1698 * Purpose : The GetServiceKeyName function obtains the service name that is
1699 * associated with a particular service's display name. The service
1700 * name is the same as the service's registry key name.
1701 * Parameters: SC_HANDLE hSCManager handle to a service control manager database
1702 * LPCWSTR lpDisplayName the service's display name
1703 * LPWSTR lpServiceName buffer to receive the service name
1704 * LPDWORD lpcchBuffer size of service name buffer and service name
1705 * Variables :
1706 * Result :
1707 * Remark :
1708 * Status : UNTESTED STUB
1709 *
1710 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1711 *****************************************************************************/
1712
1713BOOL WIN32API GetServiceKeyNameW(SC_HANDLE hSCManager,
1714 LPCWSTR lpDisplayName,
1715 LPWSTR lpServiceName,
1716 LPDWORD lpcchBuffer)
1717{
1718 dprintf(("ADVAPI32: GetServiceKeyNameW(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1719 hSCManager,
1720 lpDisplayName,
1721 lpServiceName,
1722 lpcchBuffer));
1723
1724 return (FALSE); /* signal failure */
1725}
1726
1727/*****************************************************************************
1728 * Name : ImpersonateLoggedOnUser
1729 * Purpose : The ImpersonateLoggedOnUser function lets the calling thread
1730 * impersonate a user. The user is represented by a token handle
1731 * obtained by calling the LogonUser function
1732 * Parameters: HANDLE hToken
1733 * Variables :
1734 * Result :
1735 * Remark :
1736 * Status : UNTESTED STUB
1737 *
1738 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1739 *****************************************************************************/
1740
1741BOOL WIN32API ImpersonateLoggedOnUser(HANDLE hToken)
1742{
1743 dprintf(("ADVAPI32: ImpersonateLoggedOnUser(%08xh) not implemented.\n",
1744 hToken));
1745
1746 return (TRUE); /* signal OK */
1747}
1748
1749
1750/*****************************************************************************
1751 * Name : ImpersonateNamedPipeClient
1752 * Purpose : The ImpersonateNamedPipeClient function impersonates a named-pipe
1753 * client application.
1754 * Parameters: HANDLE hNamedPipe handle of a named pipe
1755 * Variables :
1756 * Result :
1757 * Remark :
1758 * Status : UNTESTED STUB
1759 *
1760 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1761 *****************************************************************************/
1762
1763BOOL WIN32API ImpersonateNamedPipeClient(HANDLE hNamedPipe)
1764{
1765 dprintf(("ADVAPI32: ImpersonateNamedPipeClient(%08xh) not implemented.\n",
1766 hNamedPipe));
1767
1768 return (TRUE); /* signal OK */
1769}
1770
1771
1772
1773/*****************************************************************************
1774 * Name : InitializeAcl
1775 * Purpose : The InitializeAcl function creates a new ACL structure.
1776 * An ACL is an access-control list.
1777 * Parameters: PACL pAcl address of access-control list
1778 * DWORD nAclLength size of access-control list
1779 * DWORD dwAclRevision revision level of access-control list
1780 * Variables :
1781 * Result :
1782 * Remark :
1783 * Status : UNTESTED STUB
1784 *
1785 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1786 *****************************************************************************/
1787
1788BOOL WIN32API InitializeAcl(PACL pAcl,
1789 DWORD nAclLength,
1790 DWORD dwAclRevision)
1791{
1792 dprintf(("ADVAPI32: InitializeAcl(%08xh,%08xh,%08xh) not implemented.\n",
1793 pAcl,
1794 nAclLength,
1795 dwAclRevision));
1796
1797 return (FALSE); /* signal failure */
1798}
1799
1800
1801
1802/*****************************************************************************
1803 * Name : InitiateSystemShutdownA
1804 * Purpose : The InitiateSystemShutdown function initiates a shutdown and
1805 * optional restart of the specified computer.
1806 * Parameters: LPTSTR lpMachineName address of name of computer to shut down
1807 * LPTSTR lpMessage address of message to display in dialog box
1808 * DWORD dwTimeout time to display dialog box
1809 * BOOL bForceAppsClosed force applications with unsaved changes flag
1810 * BOOL bRebootAfterShutdown reboot flag
1811 * Variables :
1812 * Result :
1813 * Remark :
1814 * Status : UNTESTED STUB
1815 *
1816 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1817 *****************************************************************************/
1818
1819BOOL WIN32API InitiateSystemShutdownA(LPTSTR lpMachineName,
1820 LPTSTR lpMessage,
1821 DWORD dwTimeout,
1822 BOOL bForceAppsClosed,
1823 BOOL bRebootAfterShutdown)
1824{
1825 dprintf(("ADVAPI32: InitiateSystemShutdownA(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1826 lpMachineName,
1827 lpMessage,
1828 dwTimeout,
1829 bForceAppsClosed,
1830 bRebootAfterShutdown));
1831
1832 return (FALSE); /* signal failure */
1833}
1834
1835
1836/*****************************************************************************
1837 * Name : InitiateSystemShutdownW
1838 * Purpose : The InitiateSystemShutdown function initiates a shutdown and
1839 * optional restart of the specified computer.
1840 * Parameters: LPWSTR lpMachineName address of name of computer to shut down
1841 * LPWSTR lpMessage address of message to display in dialog box
1842 * DWORD dwTimeout time to display dialog box
1843 * BOOL bForceAppsClosed force applications with unsaved changes flag
1844 * BOOL bRebootAfterShutdown reboot flag
1845 * Variables :
1846 * Result :
1847 * Remark :
1848 * Status : UNTESTED STUB
1849 *
1850 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1851 *****************************************************************************/
1852
1853BOOL WIN32API InitiateSystemShutdownW(LPWSTR lpMachineName,
1854 LPWSTR lpMessage,
1855 DWORD dwTimeout,
1856 BOOL bForceAppsClosed,
1857 BOOL bRebootAfterShutdown)
1858{
1859 dprintf(("ADVAPI32: InitiateSystemShutdownW(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1860 lpMachineName,
1861 lpMessage,
1862 dwTimeout,
1863 bForceAppsClosed,
1864 bRebootAfterShutdown));
1865
1866 return (FALSE); /* signal failure */
1867}
1868
1869
1870/*****************************************************************************
1871 * Name : IsTextUnicode
1872 * Purpose : The IsTextUnicode function determines whether a buffer probably
1873 * contains a form of Unicode text. The function uses various
1874 * statistical and deterministic methods to make its determination,
1875 * under the control of flags passed via lpi. When the function
1876 * returns, the results of such tests are reported via lpi. If all
1877 * specified tests are passed, the function returns TRUE; otherwise,
1878 * it returns FALSE.
1879 * Parameters: CONST LPVOID lpBuffer pointer to an input buffer to be examined
1880 * int cb the size in bytes of the input buffer
1881 * LPINT lpi pointer to flags that condition text examination and receive results
1882 * Variables :
1883 * Result :
1884 * Remark :
1885 * Status : UNTESTED STUB
1886 *
1887 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1888 *****************************************************************************/
1889
1890DWORD WIN32API IsTextUnicode(CONST LPVOID lpBuffer,
1891 int cb,
1892 LPINT lpi)
1893{
1894 DWORD dwResult = 0;
1895
1896 dprintf(("ADVAPI32: IsTextUnicode(%08xh,%08xh,%08xh) not implemented.\n",
1897 lpBuffer,
1898 cb,
1899 lpi));
1900
1901 if (cb & 0x0001) dwResult |= IS_TEXT_UNICODE_ODD_LENGTH;
1902
1903 return (dwResult); /* signal failure */
1904}
1905
1906
1907/*****************************************************************************
1908 * Name : IsValidAcl
1909 * Purpose : The IsValidAcl function validates an access-control list (ACL).
1910 * Parameters: PACL pAcl address of access-control list
1911 * Variables :
1912 * Result :
1913 * Remark :
1914 * Status : UNTESTED STUB
1915 *
1916 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1917 *****************************************************************************/
1918
1919BOOL WIN32API IsValidAcl(PACL pAcl)
1920{
1921 dprintf(("ADVAPI32: IsValidAcl(%08xh) not implemented.\n",
1922 pAcl));
1923
1924 return (TRUE); /* signal OK */
1925}
1926
1927/*****************************************************************************
1928 * Name : LockServiceDatabase
1929 * Purpose : The LockServiceDatabase function locks a specified database.
1930 * Parameters: SC_HANDLE hSCManager handle of service control manager database
1931 * Variables :
1932 * Result :
1933 * Remark :
1934 * Status : UNTESTED STUB
1935 *
1936 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1937 *****************************************************************************/
1938
1939#define SC_LOCK DWORD
1940SC_LOCK WIN32API LockServiceDatabase(SC_HANDLE hSCManager)
1941{
1942 dprintf(("ADVAPI32: LockServiceDatabase(%08xh) not implemented.\n",
1943 hSCManager));
1944
1945 return (ERROR_ACCESS_DENIED); /* signal failure */
1946}
1947
1948
1949/*****************************************************************************
1950 * Name : LogonUserA
1951 * Purpose : The LogonUser function attempts to perform a user logon
1952 * operation. You specify the user with a user name and domain,
1953 * and authenticate the user with a clear-text password. If the
1954 * function succeeds, you receive a handle to a token that
1955 * represents the logged-on user. You can then use this token
1956 * handle to impersonate the specified user, or to create a process
1957 * running in the context of the specified user.
1958 * Parameters: LPTSTR lpszUsername string that specifies the user name
1959 * LPTSTR lpszDomain string that specifies the domain or servero
1960 * LPTSTR lpszPassword string that specifies the password
1961 * DWORD dwLogonType specifies the type of logon operation
1962 * DWORD dwLogonProvider specifies the logon provider
1963 * PHANDLE phToken pointer to variable to receive token handle
1964 * Variables :
1965 * Result :
1966 * Remark :
1967 * Status : UNTESTED STUB
1968 *
1969 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1970 *****************************************************************************/
1971
1972BOOL WIN32API LogonUserA(LPTSTR lpszUsername,
1973 LPTSTR lpszDomain,
1974 LPTSTR lpszPassword,
1975 DWORD dwLogonType,
1976 DWORD dwLogonProvider,
1977 PHANDLE phToken)
1978{
1979 dprintf(("ADVAPI32: LogonUserA(%s,%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
1980 lpszUsername,
1981 lpszDomain,
1982 lpszPassword,
1983 dwLogonType,
1984 dwLogonProvider,
1985 phToken));
1986
1987 return (TRUE); /* signal OK */
1988}
1989
1990
1991/*****************************************************************************
1992 * Name : LogonUserW
1993 * Purpose : The LogonUser function attempts to perform a user logon
1994 * operation. You specify the user with a user name and domain,
1995 * and authenticate the user with a clear-text password. If the
1996 * function succeeds, you receive a handle to a token that
1997 * represents the logged-on user. You can then use this token
1998 * handle to impersonate the specified user, or to create a process
1999 * running in the context of the specified user.
2000 * Parameters: LPWSTR lpszUsername string that specifies the user name
2001 * LPWSTR lpszDomain string that specifies the domain or servero
2002 * LPWSTR lpszPassword string that specifies the password
2003 * DWORD dwLogonType specifies the type of logon operation
2004 * DWORD dwLogonProvider specifies the logon provider
2005 * PHANDLE phToken pointer to variable to receive token handle
2006 * Variables :
2007 * Result :
2008 * Remark :
2009 * Status : UNTESTED STUB
2010 *
2011 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2012 *****************************************************************************/
2013
2014BOOL WIN32API LogonUserW(LPWSTR lpszUsername,
2015 LPWSTR lpszDomain,
2016 LPWSTR lpszPassword,
2017 DWORD dwLogonType,
2018 DWORD dwLogonProvider,
2019 PHANDLE phToken)
2020{
2021 dprintf(("ADVAPI32: LogonUserW(%s,%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
2022 lpszUsername,
2023 lpszDomain,
2024 lpszPassword,
2025 dwLogonType,
2026 dwLogonProvider,
2027 phToken));
2028
2029 return (TRUE); /* signal OK */
2030}
2031
2032
2033/*****************************************************************************
2034 * Name : LookupAccountNameA
2035 * Purpose : The LookupAccountName function accepts the name of a system and
2036 * an account as input. It retrieves a security identifier (SID)
2037 * for the account and the name of the domain on which the account was found.
2038 * Parameters: LPCSTR lpSystemName address of string for system name
2039 * LPCSTR lpAccountName address of string for account name
2040 * PSID Sid address of security identifier
2041 * LPDWORD cbSid address of size of security identifier
2042 * LPTSTR ReferencedDomainName address of string for referenced domain
2043 * LPDWORD cbReferencedDomainName address of size of domain string
2044 * PSID_NAME_USE peUse address of SID-type indicator
2045 * Variables :
2046 * Result :
2047 * Remark :
2048 * Status : UNTESTED STUB
2049 *
2050 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2051 *****************************************************************************/
2052
2053#define PSID_NAME_USE LPVOID
2054BOOL WIN32API LookupAccountNameA(LPCSTR lpSystemName,
2055 LPCSTR lpAccountName,
2056 PSID Sid,
2057 LPDWORD cbSid,
2058 LPTSTR ReferencedDomainName,
2059 LPDWORD cbReferencedDomainName,
2060 PSID_NAME_USE peUse)
2061{
2062 dprintf(("ADVAPI32: LookupAccountNameA(%s,%s,%08xh,%08xh,%s,%08xh,%08xh) not implemented.\n",
2063 lpSystemName,
2064 lpAccountName,
2065 Sid,
2066 cbSid,
2067 ReferencedDomainName,
2068 cbReferencedDomainName,
2069 peUse));
2070
2071 return (FALSE); /* signal failure */
2072}
2073
2074
2075/*****************************************************************************
2076 * Name : LookupAccountNameW
2077 * Purpose : The LookupAccountName function accepts the name of a system and
2078 * an account as input. It retrieves a security identifier (SID)
2079 * for the account and the name of the domain on which the account was found.
2080 * Parameters: LPCWSTR lpSystemName address of string for system name
2081 * LPCWSTR lpAccountName address of string for account name
2082 * PSID Sid address of security identifier
2083 * LPDWORD cbSid address of size of security identifier
2084 * LPWSTR ReferencedDomainName address of string for referenced domain
2085 * LPDWORD cbReferencedDomainName address of size of domain string
2086 * PSID_NAME_USE peUse address of SID-type indicator
2087 * Variables :
2088 * Result :
2089 * Remark :
2090 * Status : UNTESTED STUB
2091 *
2092 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2093 *****************************************************************************/
2094
2095BOOL WIN32API LookupAccountNameW(LPCWSTR lpSystemName,
2096 LPCWSTR lpAccountName,
2097 PSID Sid,
2098 LPDWORD cbSid,
2099 LPWSTR ReferencedDomainName,
2100 LPDWORD cbReferencedDomainName,
2101 PSID_NAME_USE peUse)
2102{
2103 dprintf(("ADVAPI32: LookupAccountNameW(%s,%s,%08xh,%08xh,%s,%08xh,%08xh) not implemented.\n",
2104 lpSystemName,
2105 lpAccountName,
2106 Sid,
2107 cbSid,
2108 ReferencedDomainName,
2109 cbReferencedDomainName,
2110 peUse));
2111
2112 return (FALSE); /* signal failure */
2113}
2114
2115
2116
2117/*****************************************************************************
2118 * Name : LookupPrivilegeDisplayNameA
2119 * Purpose : The LookupPrivilegeDisplayName function retrieves a displayable
2120 * name representing a specified privilege.
2121 * Parameters: LPCSTR lpSystemName address of string specifying the system
2122 * LPCSTR lpName address of string specifying the privilege
2123 * LPTSTR lpDisplayName address of string receiving the displayable name
2124 * LPDWORD cbDisplayName address of size of string for displayable name
2125 * LPDWORD lpLanguageId address of language identifier
2126 * Variables :
2127 * Result :
2128 * Remark :
2129 * Status : UNTESTED STUB
2130 *
2131 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2132 *****************************************************************************/
2133
2134BOOL WIN32API LookupPrivilegeDisplayNameA(LPCSTR lpSystemName,
2135 LPCSTR lpName,
2136 LPTSTR lpDisplayName,
2137 LPDWORD cbDisplayName,
2138 LPDWORD lpLanguageId)
2139{
2140 dprintf(("ADVAPI32: LookupPrivilegeDisplayNameA(%s,%s,%s,%08xh,%08xh) not implemented.\n",
2141 lpSystemName,
2142 lpName,
2143 lpDisplayName,
2144 cbDisplayName,
2145 lpLanguageId));
2146
2147 return (FALSE); /* signal failure */
2148}
2149
2150
2151/*****************************************************************************
2152 * Name : LookupPrivilegeDisplayNameW
2153 * Purpose : The LookupPrivilegeDisplayName function retrieves a displayable
2154 * name representing a specified privilege.
2155 * Parameters: LPCWSTR lpSystemName address of string specifying the system
2156 * LPCWSTR lpName address of string specifying the privilege
2157 * LPWSTR lpDisplayName address of string receiving the displayable name
2158 * LPDWORD cbDisplayName address of size of string for displayable name
2159 * LPDWORD lpLanguageId address of language identifier
2160 * Variables :
2161 * Result :
2162 * Remark :
2163 * Status : UNTESTED STUB
2164 *
2165 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2166 *****************************************************************************/
2167
2168BOOL WIN32API LookupPrivilegeDisplayNameW(LPCWSTR lpSystemName,
2169 LPCWSTR lpName,
2170 LPWSTR lpDisplayName,
2171 LPDWORD cbDisplayName,
2172 LPDWORD lpLanguageId)
2173{
2174 dprintf(("ADVAPI32: LookupPrivilegeDisplayNameW(%s,%s,%s,%08xh,%08xh) not implemented.\n",
2175 lpSystemName,
2176 lpName,
2177 lpDisplayName,
2178 cbDisplayName,
2179 lpLanguageId));
2180
2181 return (FALSE); /* signal failure */
2182}
2183
2184
2185/*****************************************************************************
2186 * Name : LookupPrivilegeNameA
2187 * Purpose : The LookupPrivilegeName function retrieves the name corresponding
2188 * to the privilege represented on a specific system by a specified
2189 * locally unique identifier (LUID).
2190 * Parameters: LPCSTR lpSystemName address of string specifying the system
2191 * PLUID lpLuid address of locally unique identifier
2192 * LPTSTR lpName address of string specifying the privilege
2193 * LPDWORD cbName address of size of string for displayable name
2194 * Variables :
2195 * Result :
2196 * Remark :
2197 * Status : UNTESTED STUB
2198 *
2199 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2200 *****************************************************************************/
2201
2202BOOL WIN32API LookupPrivilegeNameA(LPCSTR lpSystemName,
2203 PLUID lpLuid,
2204 LPTSTR lpName,
2205 LPDWORD cbName)
2206{
2207 dprintf(("ADVAPI32: LookupPrivilegeNameA(%s,%08xh,%s,%08xh) not implemented.\n",
2208 lpSystemName,
2209 lpLuid,
2210 lpName,
2211 cbName));
2212
2213 return (FALSE); /* signal failure */
2214}
2215
2216
2217/*****************************************************************************
2218 * Name : LookupPrivilegeNameW
2219 * Purpose : The LookupPrivilegeName function retrieves the name corresponding
2220 * to the privilege represented on a specific system by a specified
2221 * locally unique identifier (LUID).
2222 * Parameters: LPCWSTR lpSystemName address of string specifying the system
2223 * PLUID lpLuid address of locally unique identifier
2224 * LPWSTR lpName address of string specifying the privilege
2225 * LPDWORD cbName address of size of string for displayable name
2226 * Variables :
2227 * Result :
2228 * Remark :
2229 * Status : UNTESTED STUB
2230 *
2231 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2232 *****************************************************************************/
2233
2234BOOL WIN32API LookupPrivilegeNameW(LPCWSTR lpSystemName,
2235 PLUID lpLuid,
2236 LPWSTR lpName,
2237 LPDWORD cbName)
2238{
2239 dprintf(("ADVAPI32: LookupPrivilegeNameW(%s,%08xh,%s,%08xh) not implemented.\n",
2240 lpSystemName,
2241 lpLuid,
2242 lpName,
2243 cbName));
2244
2245 return (FALSE); /* signal failure */
2246}
2247
2248
2249/*****************************************************************************
2250 * Name : MakeAbsoluteSD
2251 * Purpose : The MakeAbsoluteSD function creates a security descriptor in
2252 * absolute format by using a security descriptor in self-relative
2253 * format as a template.
2254 * Parameters: PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor address self-relative SD
2255 * PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor address of absolute SD
2256 * LPDWORD lpdwAbsoluteSecurityDescriptorSize address of size of absolute SD
2257 * PACL pDacl address of discretionary ACL
2258 * LPDWORD lpdwDaclSize address of size of discretionary ACL
2259 * PACL pSacl address of system ACL
2260 * LPDWORD lpdwSaclSize address of size of system ACL
2261 * PSID pOwner address of owner SID
2262 * LPDWORD lpdwOwnerSize address of size of owner SID
2263 * PSID pPrimaryGroup address of primary-group SID
2264 * LPDWORD lpdwPrimaryGroupSize address of size of group SID
2265 * Variables :
2266 * Result :
2267 * Remark :
2268 * Status : UNTESTED STUB
2269 *
2270 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2271 *****************************************************************************/
2272
2273BOOL WIN32API MakeAbsoluteSD(PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
2274 PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
2275 LPDWORD lpdwAbsoluteSecurityDescriptorSize,
2276 PACL pDacl,
2277 LPDWORD lpdwDaclSize,
2278 PACL pSacl,
2279 LPDWORD lpdwSaclSize,
2280 PSID pOwner,
2281 LPDWORD lpdwOwnerSize,
2282 PSID pPrimaryGroup,
2283 LPDWORD lpdwPrimaryGroupSize)
2284{
2285 dprintf(("ADVAPI32: MakeAbsoluteSD(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2286 pSelfRelativeSecurityDescriptor,
2287 pAbsoluteSecurityDescriptor,
2288 lpdwAbsoluteSecurityDescriptorSize,
2289 pDacl,
2290 lpdwDaclSize,
2291 pSacl,
2292 lpdwSaclSize,
2293 pOwner,
2294 lpdwOwnerSize,
2295 pPrimaryGroup,
2296 lpdwPrimaryGroupSize));
2297
2298 return (FALSE); /* signal failure */
2299}
2300
2301
2302
2303
2304/*****************************************************************************
2305 * Name : MapGenericMask
2306 * Purpose : The MapGenericMask function maps the generic access rights in
2307 * an access mask to specific and standard access rights. The function
2308 * applies a mapping supplied in a GENERIC_MAPPING structure.
2309 * Parameters: LPDWORD AccessMask address of access mask
2310 * PGENERIC_MAPPING GenericMapping address of GENERIC_MAPPING structure
2311 * Variables :
2312 * Result :
2313 * Remark :
2314 * Status : UNTESTED STUB
2315 *
2316 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2317 *****************************************************************************/
2318
2319VOID WIN32API MapGenericMask(LPDWORD AccessMask,
2320 PGENERIC_MAPPING GenericMapping)
2321{
2322 dprintf(("ADVAPI32: MapGenericMask(%08xh,%08xh) not implemented.\n",
2323 AccessMask,
2324 GenericMapping));
2325}
2326
2327
2328
2329
2330/*****************************************************************************
2331 * Name : NotifyChangeEventLog
2332 * Purpose : The NotifyChangeEventLog function lets an application receive
2333 * notification when an event is written to the event log file
2334 * specified by hEventLog. When the event is written to the event
2335 * log file, the function causes the event object specified by
2336 * hEvent to become signaled.
2337 * Parameters: HANDLE hEventLog special default locale value to be converted
2338 * HANDLE hEvent special default locale value to be converted
2339 * Variables :
2340 * Result :
2341 * Remark :
2342 * Status : UNTESTED STUB
2343 *
2344 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2345 *****************************************************************************/
2346
2347BOOL WIN32API NotifyChangeEventLog(HANDLE hEventLog,
2348 HANDLE hEvent)
2349{
2350 dprintf(("ADVAPI32: NotifyChangeEventLog(%08xh,%08xh) not implemented.\n",
2351 hEventLog,
2352 hEvent));
2353
2354 return (FALSE); /* signal failure */
2355}
2356
2357
2358/*****************************************************************************
2359 * Name : ObjectCloseAuditAlarmA
2360 * Purpose : The ObjectCloseAuditAlarm function generates audit messages when
2361 * a handle of an object is deleted. Alarms are not supported in the
2362 * current version of Windows NT.
2363 * Parameters: LPCSTR SubsystemName address of string for subsystem name
2364 * LPVOID HandleId address of handle identifier
2365 * BOOL GenerateOnClose flag for audit generation
2366 * Variables :
2367 * Result :
2368 * Remark :
2369 * Status : UNTESTED STUB
2370 *
2371 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2372 *****************************************************************************/
2373
2374BOOL WIN32API ObjectCloseAuditAlarmA(LPCSTR SubsystemName,
2375 LPVOID HandleId,
2376 BOOL GenerateOnClose)
2377{
2378 dprintf(("ADVAPI32: ObjectCloseAuditAlarmA(%s,%08xh,%08xh) not implemented.\n",
2379 SubsystemName,
2380 HandleId,
2381 GenerateOnClose));
2382
2383 return (FALSE); /* signal failure */
2384}
2385
2386
2387/*****************************************************************************
2388 * Name : ObjectCloseAuditAlarmW
2389 * Purpose : The ObjectCloseAuditAlarm function generates audit messages when
2390 * a handle of an object is deleted. Alarms are not supported in the
2391 * current version of Windows NT.
2392 * Parameters: LPCWSTR SubsystemName address of string for subsystem name
2393 * LPVOID HandleId address of handle identifier
2394 * BOOL GenerateOnClose flag for audit generation
2395 * Variables :
2396 * Result :
2397 * Remark :
2398 * Status : UNTESTED STUB
2399 *
2400 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2401 *****************************************************************************/
2402
2403BOOL WIN32API ObjectCloseAuditAlarmW(LPCWSTR SubsystemName,
2404 LPVOID HandleId,
2405 BOOL GenerateOnClose)
2406{
2407 dprintf(("ADVAPI32: ObjectCloseAuditAlarmW(%s,%08xh,%08xh) not implemented.\n",
2408 SubsystemName,
2409 HandleId,
2410 GenerateOnClose));
2411
2412 return (FALSE); /* signal failure */
2413}
2414
2415
2416
2417/*****************************************************************************
2418 * Name : ObjectOpenAuditAlarmA
2419 * Purpose : The ObjectOpenAuditAlarm function generates audit messages when
2420 * a client application attempts to gain access to an object or to
2421 * create a new one. Alarms are not supported in the current version
2422 * of Windows NT.
2423 * Parameters: LPCSTR SubsystemName address of string for subsystem name
2424 * LPVOID HandleId address of handle identifier
2425 * LPTSTR ObjectTypeName address of string for object type
2426 * LPTSTR ObjectName address of string for object name
2427 * PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
2428 * HANDLE ClientToken handle of client's access token
2429 * DWORD DesiredAccess mask for desired access rights
2430 * DWORD GrantedAccess mask for granted access rights
2431 * PPRIVILEGE_SET Privileges address of privileges
2432 * BOOL ObjectCreation flag for object creation
2433 * BOOL AccessGranted flag for results
2434 * LPBOOL GenerateOnClose address of flag for audit generation
2435 * Variables :
2436 * Result :
2437 * Remark :
2438 * Status : UNTESTED STUB
2439 *
2440 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2441 *****************************************************************************/
2442
2443BOOL WIN32API ObjectOpenAuditAlarmA(LPCSTR SubsystemName,
2444 LPVOID HandleId,
2445 LPTSTR ObjectTypeName,
2446 LPTSTR ObjectName,
2447 PSECURITY_DESCRIPTOR pSecurityDescriptor,
2448 HANDLE ClientToken,
2449 DWORD DesiredAccess,
2450 DWORD GrantedAccess,
2451 PPRIVILEGE_SET Privileges,
2452 BOOL ObjectCreation,
2453 BOOL AccessGranted,
2454 LPBOOL GenerateOnClose)
2455{
2456 dprintf(("ADVAPI32: ObjectOpenAuditAlarmA(%s,%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2457 SubsystemName,
2458 HandleId,
2459 ObjectTypeName,
2460 ObjectName,
2461 pSecurityDescriptor,
2462 ClientToken,
2463 DesiredAccess,
2464 GrantedAccess,
2465 Privileges,
2466 ObjectCreation,
2467 AccessGranted,
2468 GenerateOnClose));
2469
2470 return (FALSE); /* signal failure */
2471}
2472
2473
2474/*****************************************************************************
2475 * Name : ObjectOpenAuditAlarmW
2476 * Purpose : The ObjectOpenAuditAlarm function generates audit messages when
2477 * a client application attempts to gain access to an object or to
2478 * create a new one. Alarms are not supported in the current version
2479 * of Windows NT.
2480 * Parameters: LPCWSTR SubsystemName address of string for subsystem name
2481 * LPVOID HandleId address of handle identifier
2482 * LPWSTR ObjectTypeName address of string for object type
2483 * LPWSTR ObjectName address of string for object name
2484 * PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
2485 * HANDLE ClientToken handle of client's access token
2486 * DWORD DesiredAccess mask for desired access rights
2487 * DWORD GrantedAccess mask for granted access rights
2488 * PPRIVILEGE_SET Privileges address of privileges
2489 * BOOL ObjectCreation flag for object creation
2490 * BOOL AccessGranted flag for results
2491 * LPBOOL GenerateOnClose address of flag for audit generation
2492 * Variables :
2493 * Result :
2494 * Remark :
2495 * Status : UNTESTED STUB
2496 *
2497 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2498 *****************************************************************************/
2499
2500BOOL WIN32API ObjectOpenAuditAlarmW(LPCWSTR SubsystemName,
2501 LPVOID HandleId,
2502 LPWSTR ObjectTypeName,
2503 LPWSTR ObjectName,
2504 PSECURITY_DESCRIPTOR pSecurityDescriptor,
2505 HANDLE ClientToken,
2506 DWORD DesiredAccess,
2507 DWORD GrantedAccess,
2508 PPRIVILEGE_SET Privileges,
2509 BOOL ObjectCreation,
2510 BOOL AccessGranted,
2511 LPBOOL GenerateOnClose)
2512{
2513 dprintf(("ADVAPI32: ObjectOpenAuditAlarmW(%s,%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2514 SubsystemName,
2515 HandleId,
2516 ObjectTypeName,
2517 ObjectName,
2518 pSecurityDescriptor,
2519 ClientToken,
2520 DesiredAccess,
2521 GrantedAccess,
2522 Privileges,
2523 ObjectCreation,
2524 AccessGranted,
2525 GenerateOnClose));
2526
2527 return (FALSE); /* signal failure */
2528}
2529
2530
2531/*****************************************************************************
2532 * Name : ObjectPrivilegeAuditAlarmA
2533 * Purpose : The ObjectPrivilegeAuditAlarm function generates audit messages
2534 * as a result of a client's attempt to perform a privileged operation
2535 * on a server application object using an already opened handle of
2536 * that object. Alarms are not supported in the current version of Windows NT.
2537 * Parameters: LPCSTR lpszSubsystem address of string for subsystem name
2538 * LPVOID lpvHandleId address of handle identifier
2539 * HANDLE hClientToken handle of client's access token
2540 * DWORD dwDesiredAccess mask for desired access rights
2541 * PPRIVILEGE_SET pps address of privileges
2542 * BOOL fAccessGranted flag for results
2543 * Variables :
2544 * Result :
2545 * Remark :
2546 * Status : UNTESTED STUB
2547 *
2548 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2549 *****************************************************************************/
2550
2551BOOL WIN32API ObjectPrivilegeAuditAlarmA(LPCSTR lpszSubsystem,
2552 LPVOID lpvHandleId,
2553 HANDLE hClientToken,
2554 DWORD dwDesiredAccess,
2555 PPRIVILEGE_SET pps,
2556 BOOL fAccessGranted)
2557{
2558 dprintf(("ADVAPI32: ObjectPrivilegeAuditAlarmA(%s,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2559 lpszSubsystem,
2560 lpvHandleId,
2561 hClientToken,
2562 dwDesiredAccess,
2563 pps,
2564 fAccessGranted));
2565
2566 return (FALSE); /* signal failure */
2567}
2568
2569
2570/*****************************************************************************
2571 * Name : ObjectPrivilegeAuditAlarmW
2572 * Purpose : The ObjectPrivilegeAuditAlarm function generates audit messages
2573 * as a result of a client's attempt to perform a privileged operation
2574 * on a server application object using an already opened handle of
2575 * that object. Alarms are not supported in the current version of Windows NT.
2576 * Parameters: LPCWSTR lpszSubsystem address of string for subsystem name
2577 * LPVOID lpvHandleId address of handle identifier
2578 * HANDLE hClientToken handle of client's access token
2579 * DWORD dwDesiredAccess mask for desired access rights
2580 * PPRIVILEGE_SET pps address of privileges
2581 * BOOL fAccessGranted flag for results
2582 * Variables :
2583 * Result :
2584 * Remark :
2585 * Status : UNTESTED STUB
2586 *
2587 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2588 *****************************************************************************/
2589
2590BOOL WIN32API ObjectPrivilegeAuditAlarmW(LPCWSTR lpszSubsystem,
2591 LPVOID lpvHandleId,
2592 HANDLE hClientToken,
2593 DWORD dwDesiredAccess,
2594 PPRIVILEGE_SET pps,
2595 BOOL fAccessGranted)
2596{
2597 dprintf(("ADVAPI32: ObjectPrivilegeAuditAlarmW(%s,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2598 lpszSubsystem,
2599 lpvHandleId,
2600 hClientToken,
2601 dwDesiredAccess,
2602 pps,
2603 fAccessGranted));
2604
2605 return (FALSE); /* signal failure */
2606}
2607
2608
2609/*****************************************************************************
2610 * Name : OpenBackupEventLogA
2611 * Purpose : The OpenBackupEventLog function opens a handle of a backup event
2612 * log. This handle can be used with the BackupEventLog function.
2613 * Parameters: LPCSTR lpszUNCServerName backup file server name
2614 * LPCSTR lpszFileName backup filename
2615 * Variables :
2616 * Result :
2617 * Remark :
2618 * Status : UNTESTED STUB
2619 *
2620 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2621 *****************************************************************************/
2622
2623HANDLE WIN32API OpenBackupEventLogA(LPCSTR lpszUNCServerName,
2624 LPCSTR lpszFileName)
2625{
2626 dprintf(("ADVAPI32: OpenBackupEventLogA(%s,%s) not implemented.\n",
2627 lpszUNCServerName,
2628 lpszFileName));
2629
2630 return (NULL); /* signal failure */
2631}
2632
2633
2634/*****************************************************************************
2635 * Name : OpenBackupEventLogW
2636 * Purpose : The OpenBackupEventLog function opens a handle of a backup event
2637 * log. This handle can be used with the BackupEventLog function.
2638 * Parameters: LPCWSTR lpszUNCServerName backup file server name
2639 * LPCWSTR lpszFileName backup filename
2640 * Variables :
2641 * Result :
2642 * Remark :
2643 * Status : UNTESTED STUB
2644 *
2645 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2646 *****************************************************************************/
2647
2648HANDLE WIN32API OpenBackupEventLogW(LPCWSTR lpszUNCServerName,
2649 LPCWSTR lpszFileName)
2650{
2651 dprintf(("ADVAPI32: OpenBackupEventLogW(%s,%s) not implemented.\n",
2652 lpszUNCServerName,
2653 lpszFileName));
2654
2655 return (NULL); /* signal failure */
2656}
2657
2658
2659/*****************************************************************************
2660 * Name : OpenEventLogA
2661 * Purpose : The OpenEventLog function opens a handle of an event log.
2662 * Parameters: LPCSTR lpszUNCServerName
2663 * LPCSTR lpszSourceName
2664 * Variables :
2665 * Result :
2666 * Remark :
2667 * Status : UNTESTED STUB
2668 *
2669 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2670 *****************************************************************************/
2671
2672HANDLE WIN32API OpenEventLogA(LPCSTR lpszUNCServerName,
2673 LPCSTR lpszSourceName)
2674{
2675 dprintf(("ADVAPI32: OpenEventLogA(%s,%s) not implemented.\n",
2676 lpszUNCServerName,
2677 lpszSourceName));
2678
2679 return (NULL); /* signal failure */
2680}
2681
2682
2683/*****************************************************************************
2684 * Name : OpenEventLogW
2685 * Purpose : The OpenEventLog function opens a handle of an event log.
2686 * Parameters: LPCWSTR lpszUNCServerName
2687 * LPCWSTR lpszSourceName
2688 * Variables :
2689 * Result :
2690 * Remark :
2691 * Status : UNTESTED STUB
2692 *
2693 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2694 *****************************************************************************/
2695
2696HANDLE WIN32API OpenEventLogW(LPCWSTR lpszUNCServerName,
2697 LPCWSTR lpszSourceName)
2698{
2699 dprintf(("ADVAPI32: OpenEventLogW(%s,%s) not implemented.\n",
2700 lpszUNCServerName,
2701 lpszSourceName));
2702
2703 return (NULL); /* signal failure */
2704}
2705
2706
2707/*****************************************************************************
2708 * Name : OpenSCManagerA
2709 * Purpose : The OpenSCManager function establishes a connection to the
2710 * service control manager on the specified computer and opens the
2711 * specified database.
2712 * Parameters: LPCSTR lpszMachineName address of machine name string
2713 * LPCSTR lpszDatabaseName address of database name string
2714 * DWORD fdwDesiredAccess type of access
2715 * Variables :
2716 * Result :
2717 * Remark :
2718 * Status : UNTESTED STUB
2719 *
2720 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2721 *****************************************************************************/
2722
2723SC_HANDLE WIN32API OpenSCManagerA(LPCSTR lpszMachineName,
2724 LPCSTR lpszDatabaseName,
2725 DWORD fdwDesiredAccess)
2726{
2727 dprintf(("ADVAPI32: OpenSCManagerA(%s,%s,%x) not implemented.\n",
2728 lpszMachineName,
2729 lpszDatabaseName,
2730 fdwDesiredAccess));
2731
2732 return (NULL); /* signal failure */
2733}
2734
2735
2736/*****************************************************************************
2737 * Name : OpenSCManagerW
2738 * Purpose : The OpenSCManager function establishes a connection to the
2739 * service control manager on the specified computer and opens the
2740 * specified database.
2741 * Parameters: LPCWSTR lpszMachineName address of machine name string
2742 * LPCWSTR lpszDatabaseName address of database name string
2743 * DWORD fdwDesiredAccess type of access
2744 * Variables :
2745 * Result :
2746 * Remark :
2747 * Status : UNTESTED STUB
2748 *
2749 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2750 *****************************************************************************/
2751
2752SC_HANDLE WIN32API OpenSCManagerW(LPCWSTR lpszMachineName,
2753 LPCWSTR lpszDatabaseName,
2754 DWORD fdwDesiredAccess)
2755{
2756 dprintf(("ADVAPI32: OpenSCManagerW(%x,%x,%x) not implemented.\n",
2757 lpszMachineName,
2758 lpszDatabaseName,
2759 fdwDesiredAccess));
2760
2761 return (NULL); /* signal failure */
2762}
2763
2764
2765/*****************************************************************************
2766 * Name : OpenServiceA
2767 * Purpose : The OpenService function opens a handle to an existing service.
2768 * Parameters: SC_HANDLE schSCManager handle of service control manager database
2769 * LPCSTR lpszServiceName address of name of service to start
2770 * DWORD fdwDesiredAccess type of access to service
2771 * Variables :
2772 * Result :
2773 * Remark :
2774 * Status : UNTESTED STUB
2775 *
2776 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2777 *****************************************************************************/
2778
2779SC_HANDLE WIN32API OpenServiceA(SC_HANDLE schSCManager,
2780 LPCSTR lpszServiceName,
2781 DWORD fdwDesiredAccess)
2782{
2783 dprintf(("ADVAPI32: OpenServiceA(%08xh,%s,%08xh) not implemented.\n",
2784 schSCManager,
2785 lpszServiceName,
2786 fdwDesiredAccess));
2787
2788 return (NULL); /* signal failure */
2789}
2790
2791
2792/*****************************************************************************
2793 * Name : OpenServiceW
2794 * Purpose : The OpenService function opens a handle to an existing service.
2795 * Parameters: SC_HANDLE schSCManager handle of service control manager database
2796 * LPCWSTR lpszServiceName address of name of service to start
2797 * DWORD fdwDesiredAccess type of access to service
2798 * Variables :
2799 * Result :
2800 * Remark :
2801 * Status : UNTESTED STUB
2802 *
2803 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2804 *****************************************************************************/
2805
2806SC_HANDLE WIN32API OpenServiceW(SC_HANDLE schSCManager,
2807 LPCWSTR lpszServiceName,
2808 DWORD fdwDesiredAccess)
2809{
2810 dprintf(("ADVAPI32: OpenServiceW(%08xh,%s,%08xh) not implemented.\n",
2811 schSCManager,
2812 lpszServiceName,
2813 fdwDesiredAccess));
2814
2815 return (NULL); /* signal failure */
2816}
2817
2818
2819/*****************************************************************************
2820 * Name : PrivilegeCheck
2821 * Purpose : The PrivilegeCheck function tests the security context represented
2822 * by a specific access token to discover whether it contains the
2823 * specified privileges. This function is typically called by a server
2824 * application to check the privileges of a client's access token.
2825 * Parameters: HANDLE hClientToken handle of client's access token
2826 * PPRIVILEGE_SET pps address of privileges
2827 * LPBOOL lpfResult address of flag for result
2828 * Variables :
2829 * Result :
2830 * Remark :
2831 * Status : UNTESTED STUB
2832 *
2833 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2834 *****************************************************************************/
2835
2836BOOL WIN32API PrivilegeCheck(HANDLE hClientToken,
2837 PPRIVILEGE_SET pps,
2838 LPBOOL lpfResult)
2839{
2840 dprintf(("ADVAPI32: PrivilegeCheck(%08xh,%08xh,%08xh) not implemented.\n",
2841 hClientToken,
2842 pps,
2843 lpfResult));
2844
2845 return (FALSE); /* signal failure */
2846}
2847
2848
2849/*****************************************************************************
2850 * Name : PrivilegedServiceAuditAlarmA
2851 * Purpose : The PrivilegedServiceAuditAlarm function generates audit messages
2852 * when an attempt is made to perform privileged system service
2853 * operations. Alarms are not supported in the current version of Windows NT.
2854 * Parameters: LPCSTR lpszSubsystem address of string for subsystem name
2855 * LPCSTR lpszService address of string for service name
2856 * HANDLE hClientToken handle of access token
2857 * PPRIVILEGE_SET pps address of privileges
2858 * BOOL fAccessGranted flag for granted access rights
2859 * Variables :
2860 * Result :
2861 * Remark :
2862 * Status : UNTESTED STUB
2863 *
2864 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2865 *****************************************************************************/
2866
2867BOOL WIN32API PrivilegedServiceAuditAlarmA(LPCSTR lpszSubsystem,
2868 LPCSTR lpszService,
2869 HANDLE hClientToken,
2870 PPRIVILEGE_SET pps,
2871 BOOL fAccessGranted)
2872{
2873 dprintf(("ADVAPI32: PrivilegedServiceAuditAlarmA(%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
2874 lpszSubsystem,
2875 lpszService,
2876 hClientToken,
2877 pps,
2878 fAccessGranted));
2879
2880 return (FALSE); /* signal failure */
2881}
2882
2883
2884/*****************************************************************************
2885 * Name : PrivilegedServiceAuditAlarmW
2886 * Purpose : The PrivilegedServiceAuditAlarm function generates audit messages
2887 * when an attempt is made to perform privileged system service
2888 * operations. Alarms are not supported in the current version of Windows NT.
2889 * Parameters: LPCWSTR lpszSubsystem address of string for subsystem name
2890 * LPCWSTR lpszService address of string for service name
2891 * HANDLE hClientToken handle of access token
2892 * PPRIVILEGE_SET pps address of privileges
2893 * BOOL fAccessGranted flag for granted access rights
2894 * Variables :
2895 * Result :
2896 * Remark :
2897 * Status : UNTESTED STUB
2898 *
2899 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2900 *****************************************************************************/
2901
2902BOOL WIN32API PrivilegedServiceAuditAlarmW(LPCWSTR lpszSubsystem,
2903 LPCWSTR lpszService,
2904 HANDLE hClientToken,
2905 PPRIVILEGE_SET pps,
2906 BOOL fAccessGranted)
2907{
2908 dprintf(("ADVAPI32: PrivilegedServiceAuditAlarmW(%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
2909 lpszSubsystem,
2910 lpszService,
2911 hClientToken,
2912 pps,
2913 fAccessGranted));
2914
2915 return (FALSE); /* signal failure */
2916}
2917
2918
2919/*****************************************************************************
2920 * Name : QueryServiceConfigA
2921 * Purpose : The QueryServiceConfig function retrieves the configuration
2922 * parameters of the specified service.
2923 * Parameters: SC_HANDLE schService handle of service
2924 * LPQUERY_SERVICE_CONFIG lpqscServConfig address of service config. structure
2925 * DWORD cbBufSize size of service configuration buffer
2926 * LPDWORD lpcbBytesNeeded address of variable for bytes needed
2927 * Variables :
2928 * Result :
2929 * Remark :
2930 * Status : UNTESTED STUB
2931 *
2932 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2933 *****************************************************************************/
2934
2935#define LPQUERY_SERVICE_CONFIG LPVOID
2936BOOL WIN32API QueryServiceConfigA(SC_HANDLE schService,
2937 LPQUERY_SERVICE_CONFIG lpqscServConfig,
2938 DWORD cbBufSize,
2939 LPDWORD lpcbBytesNeeded)
2940{
2941 dprintf(("ADVAPI32: QueryServiceConfigA(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2942 schService,
2943 lpqscServConfig,
2944 cbBufSize,
2945 lpcbBytesNeeded));
2946
2947 return (FALSE); /* signal failure */
2948}
2949
2950
2951/*****************************************************************************
2952 * Name : QueryServiceConfigW
2953 * Purpose : The QueryServiceConfig function retrieves the configuration
2954 * parameters of the specified service.
2955 * Parameters: SC_HANDLE schService handle of service
2956 * LPQUERY_SERVICE_CONFIG lpqscServConfig address of service config. structure
2957 * DWORD cbBufSize size of service configuration buffer
2958 * LPDWORD lpcbBytesNeeded address of variable for bytes needed
2959 * Variables :
2960 * Result :
2961 * Remark :
2962 * Status : UNTESTED STUB
2963 *
2964 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2965 *****************************************************************************/
2966
2967BOOL WIN32API QueryServiceConfigW(SC_HANDLE schService,
2968 LPQUERY_SERVICE_CONFIG lpqscServConfig,
2969 DWORD cbBufSize,
2970 LPDWORD lpcbBytesNeeded)
2971{
2972 dprintf(("ADVAPI32: QueryServiceConfigW(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2973 schService,
2974 lpqscServConfig,
2975 cbBufSize,
2976 lpcbBytesNeeded));
2977
2978 return (FALSE); /* signal failure */
2979}
2980
2981
2982/*****************************************************************************
2983 * Name : QueryServiceLockStatusA
2984 * Purpose : The QueryServiceLockStatus function retrieves the lock status
2985 * of the specified service control manager database.
2986 * Parameters: SC_HANDLE schSCManager handle of svc. ctrl. mgr. database
2987 * LPQUERY_SERVICE_LOCK_STATUS lpqslsLockStat address of lock status structure
2988 * DWORD cbBufSize size of service configuration buffer
2989 * LPDWORD lpcbBytesNeeded address of variable for bytes needed
2990 * Variables :
2991 * Result :
2992 * Remark :
2993 * Status : UNTESTED STUB
2994 *
2995 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2996 *****************************************************************************/
2997
2998#define LPQUERY_SERVICE_LOCK_STATUS LPVOID
2999BOOL WIN32API QueryServiceLockStatusA(SC_HANDLE schSCManager,
3000 LPQUERY_SERVICE_LOCK_STATUS lpqslsLockStat,
3001 DWORD cbBufSize,
3002 LPDWORD lpcbBytesNeeded)
3003{
3004 dprintf(("ADVAPI32: QueryServiceLockStatusA(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3005 schSCManager,
3006 lpqslsLockStat,
3007 cbBufSize,
3008 lpcbBytesNeeded));
3009
3010 return (FALSE); /* signal failure */
3011}
3012
3013
3014/*****************************************************************************
3015 * Name : QueryServiceLockStatusW
3016 * Purpose : The QueryServiceLockStatus function retrieves the lock status
3017 * of the specified service control manager database.
3018 * Parameters: SC_HANDLE schSCManager handle of svc. ctrl. mgr. database
3019 * LPQUERY_SERVICE_LOCK_STATUS lpqslsLockStat address of lock status structure
3020 * DWORD cbBufSize size of service configuration buffer
3021 * LPDWORD lpcbBytesNeeded address of variable for bytes needed
3022 * Variables :
3023 * Result :
3024 * Remark :
3025 * Status : UNTESTED STUB
3026 *
3027 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3028 *****************************************************************************/
3029
3030BOOL WIN32API QueryServiceLockStatusW(SC_HANDLE schSCManager,
3031 LPQUERY_SERVICE_LOCK_STATUS lpqslsLockStat,
3032 DWORD cbBufSize,
3033 LPDWORD lpcbBytesNeeded)
3034{
3035 dprintf(("ADVAPI32: QueryServiceLockStatusW(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3036 schSCManager,
3037 lpqslsLockStat,
3038 cbBufSize,
3039 lpcbBytesNeeded));
3040
3041 return (FALSE); /* signal failure */
3042}
3043
3044
3045/*****************************************************************************
3046 * Name : QueryServiceObjectSecurity
3047 * Purpose : The QueryServiceObjectSecurity function retrieves a copy of the
3048 * security descriptor protecting a service object.
3049 * Parameters: SC_HANDLE schService handle of service
3050 * SECURITY_INFORMATION fdwSecurityInfo type of security information requested
3051 * PSECURITY_DESCRIPTOR psdSecurityDesc address of security descriptor
3052 * DWORD cbBufSize size of security descriptor buffer
3053 * LPDWORD lpcbBytesNeeded address of variable for bytes needed
3054 * Variables :
3055 * Result :
3056 * Remark :
3057 * Status : UNTESTED STUB
3058 *
3059 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3060 *****************************************************************************/
3061
3062BOOL WIN32API QueryServiceObjectSecurity(SC_HANDLE schService,
3063 SECURITY_INFORMATION fdwSecurityInfo,
3064 PSECURITY_DESCRIPTOR psdSecurityDesc,
3065 DWORD cbBufSize,
3066 LPDWORD lpcbBytesNeeded)
3067{
3068 dprintf(("ADVAPI32: QueryServiceObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3069 schService,
3070 fdwSecurityInfo,
3071 psdSecurityDesc,
3072 cbBufSize,
3073 lpcbBytesNeeded));
3074
3075 return (FALSE); /* signal failure */
3076}
3077
3078
3079/*****************************************************************************
3080 * Name : QueryServiceStatus
3081 * Purpose : The QueryServiceStatus function retrieves the current status of
3082 * the specified service.
3083 * Parameters: SC_HANDLE schService handle of service
3084 * LPSERVICE_STATUS lpssServiceStatus address of service status structure
3085 * Variables :
3086 * Result :
3087 * Remark :
3088 * Status : UNTESTED STUB
3089 *
3090 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3091 *****************************************************************************/
3092
3093BOOL WIN32API QueryServiceStatus(SC_HANDLE schService,
3094 LPSERVICE_STATUS lpssServiceStatus)
3095{
3096 dprintf(("ADVAPI32: QueryServiceStatus(%08xh,%08xh) not implemented.\n",
3097 schService,
3098 lpssServiceStatus));
3099
3100 return (FALSE); /* signal failure */
3101}
3102
3103
3104/*****************************************************************************
3105 * Name : ReadEventLogW
3106 * Purpose : The ReadEventLog function reads a whole number of entries from
3107 * the specified event log. The function can be used to read log
3108 * entries in forward or reverse chronological order.
3109 * Parameters: HANDLE hEventLog handle of event log
3110 * DWORD dwReadFlags specifies how to read log
3111 * DWORD dwRecordOffset number of first record
3112 * LPVOID lpBuffer address of buffer for read data
3113 * DWORD nNumberOfBytesToRead number of bytes to read
3114 * DWORD *pnBytesRea number of bytes read
3115 * DWORD *pnMinNumberOfBytesNeeded number of bytes required for next record
3116 * Variables :
3117 * Result :
3118 * Remark :
3119 * Status : UNTESTED STUB
3120 *
3121 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3122 *****************************************************************************/
3123
3124BOOL WIN32API ReadEventLogW(HANDLE hEventLog,
3125 DWORD dwReadFlags,
3126 DWORD dwRecordOffset,
3127 LPVOID lpBuffer,
3128 DWORD nNumberOfBytesToRead,
3129 DWORD *pnBytesRead,
3130 DWORD *pnMinNumberOfBytesNeeded)
3131{
3132 dprintf(("ADVAPI32: ReadEventLogW(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3133 hEventLog,
3134 dwReadFlags,
3135 dwRecordOffset,
3136 lpBuffer,
3137 nNumberOfBytesToRead,
3138 pnBytesRead,
3139 pnMinNumberOfBytesNeeded));
3140
3141 return (FALSE); /* signal failure */
3142}
3143
3144
3145/*****************************************************************************
3146 * Name : ReadEventLogA
3147 * Purpose : The ReadEventLog function reads a whole number of entries from
3148 * the specified event log. The function can be used to read log
3149 * entries in forward or reverse chronological order.
3150 * Parameters: HANDLE hEventLog handle of event log
3151 * DWORD dwReadFlags specifies how to read log
3152 * DWORD dwRecordOffset number of first record
3153 * LPVOID lpBuffer address of buffer for read data
3154 * DWORD nNumberOfBytesToRead number of bytes to read
3155 * DWORD *pnBytesRea number of bytes read
3156 * DWORD *pnMinNumberOfBytesNeeded number of bytes required for next record
3157 * Variables :
3158 * Result :
3159 * Remark :
3160 * Status : UNTESTED STUB
3161 *
3162 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3163 *****************************************************************************/
3164
3165BOOL WIN32API ReadEventLogA(HANDLE hEventLog,
3166 DWORD dwReadFlags,
3167 DWORD dwRecordOffset,
3168 LPVOID lpBuffer,
3169 DWORD nNumberOfBytesToRead,
3170 DWORD *pnBytesRead,
3171 DWORD *pnMinNumberOfBytesNeeded)
3172{
3173 dprintf(("ADVAPI32: ReadEventLogA(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3174 hEventLog,
3175 dwReadFlags,
3176 dwRecordOffset,
3177 lpBuffer,
3178 nNumberOfBytesToRead,
3179 pnBytesRead,
3180 pnMinNumberOfBytesNeeded));
3181
3182 return (FALSE); /* signal failure */
3183}
3184
3185
3186/*****************************************************************************
3187 * Name : RegisterServiceCtrlHandlerA
3188 * Purpose : The RegisterServiceCtrlHandler function registers a function to
3189 * handle service control requests for a service.
3190 * Parameters: LPCSTR lpszServiceName address of name of service
3191 * LPHANDLER_FUNCTION lpHandlerProc address of handler function
3192 * Variables :
3193 * Result :
3194 * Remark :
3195 * Status : UNTESTED STUB
3196 *
3197 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3198 *****************************************************************************/
3199
3200#define SERVICE_STATUS_HANDLE DWORD
3201#define LPHANDLER_FUNCTION LPVOID
3202SERVICE_STATUS_HANDLE WIN32API RegisterServiceCtrlHandlerA(LPCSTR lpszServiceName,
3203 LPHANDLER_FUNCTION lpHandlerProc)
3204{
3205 dprintf(("ADVAPI32: RegisterServiceCtrlHandlerA(%s,%08xh) not implemented.\n",
3206 lpszServiceName,
3207 lpHandlerProc));
3208
3209 return (0); /* signal failure */
3210}
3211
3212
3213/*****************************************************************************
3214 * Name : RegisterServiceCtrlHandlerW
3215 * Purpose : The RegisterServiceCtrlHandler function registers a function to
3216 * handle service control requests for a service.
3217 * Parameters: LPCWSTR lpszServiceName address of name of service
3218 * LPHANDLER_FUNCTION lpHandlerProc address of handler function
3219 * Variables :
3220 * Result :
3221 * Remark :
3222 * Status : UNTESTED STUB
3223 *
3224 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3225 *****************************************************************************/
3226
3227SERVICE_STATUS_HANDLE WIN32API RegisterServiceCtrlHandlerW(LPCWSTR lpszServiceName,
3228 LPHANDLER_FUNCTION lpHandlerProc)
3229{
3230 dprintf(("ADVAPI32: RegisterServiceCtrlHandlerW(%s,%08xh) not implemented.\n",
3231 lpszServiceName,
3232 lpHandlerProc));
3233
3234 return (0); /* signal failure */
3235}
3236
3237
3238
3239/*****************************************************************************
3240 * Name : SetAclInformation
3241 * Purpose : The SetAclInformation function sets information about an access-control list (ACL).
3242 * Parameters: PACL pAcl address of access-control list
3243 * LPVOID lpvAclInfo address of ACL information
3244 * DWORD cbAclInfo size of ACL information
3245 * ACL_INFORMATION_CLASS aclic specifies class of requested info
3246 * Variables :
3247 * Result :
3248 * Remark :
3249 * Status : UNTESTED STUB
3250 *
3251 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3252 *****************************************************************************/
3253
3254#define ACL_INFORMATION_CLASS DWORD
3255BOOL WIN32API SetAclInformation(PACL pAcl,
3256 LPVOID lpvAclInfo,
3257 DWORD cbAclInfo,
3258 ACL_INFORMATION_CLASS aclic)
3259{
3260 dprintf(("ADVAPI32: SetAclInformation(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3261 pAcl,
3262 lpvAclInfo,
3263 cbAclInfo,
3264 aclic));
3265
3266 return (FALSE); /* signal failure */
3267}
3268
3269
3270/*****************************************************************************
3271 * Name : SetKernelObjectSecurity
3272 * Purpose : The SetKernelObjectSecurity function sets the security of a kernel
3273 * object. For example, this can be a process, thread, or event.
3274 * Parameters: HANDLE hObject handle of object
3275 * SECURITY_INFORMATION si type of information to set
3276 * PSECURITY_DESCRIPTOR psd address of security descriptor
3277 * Variables :
3278 * Result :
3279 * Remark :
3280 * Status : UNTESTED STUB
3281 *
3282 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3283 *****************************************************************************/
3284
3285BOOL WIN32API SetKernelObjectSecurity(HANDLE hObject,
3286 SECURITY_INFORMATION si,
3287 PSECURITY_DESCRIPTOR psd)
3288{
3289 dprintf(("ADVAPI32: SetKernelObjectSecurity(%08xh,%08xh,%08xh) not implemented.\n",
3290 hObject,
3291 si,
3292 psd));
3293
3294 return (FALSE); /* signal failure */
3295}
3296
3297
3298/*****************************************************************************
3299 * Name : SetPrivateObjectSecurity
3300 * Purpose : The SetPrivateObjectSecurity function modifies a private
3301 * object's security descriptor.
3302 * Parameters: SECURITY_INFORMATION si type of security information
3303 * PSECURITY_DESCRIPTOR psdSource address of SD to apply to object
3304 * PSECURITY_DESCRIPTOR *lppsdTarget address of object's SD
3305 * PGENERIC_MAPPING pgm address of access-mapping structure
3306 * HANDLE hClientToken handle of client access token
3307 * Variables :
3308 * Result :
3309 * Remark :
3310 * Status : UNTESTED STUB
3311 *
3312 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3313 *****************************************************************************/
3314
3315BOOL WIN32API SetPrivateObjectSecurity(SECURITY_INFORMATION si,
3316 PSECURITY_DESCRIPTOR psdSource,
3317 PSECURITY_DESCRIPTOR *lppsdTarget,
3318 PGENERIC_MAPPING pgm,
3319 HANDLE hClientToken)
3320{
3321 dprintf(("ADVAPI32: SetPrivateObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3322 si,
3323 psdSource,
3324 lppsdTarget,
3325 pgm,
3326 hClientToken));
3327
3328 return (FALSE); /* signal failure */
3329}
3330
3331
3332
3333/*****************************************************************************
3334 * Name : SetServiceBits
3335 * Purpose : The SetServiceBits function registers a service's service type
3336 * with the Service Control Manager and the Server service. The
3337 * Server service can then announce the registered service type
3338 * as one it currently supports. The LAN Manager functions
3339 * NetServerGetInfo and NetServerEnum obtain a specified machine's
3340 * supported service types.
3341 * A service type is represented as a set of bit flags; the
3342 * SetServiceBits function sets or clears combinations of those bit flags.
3343 * Parameters: SERVICE_STATUS_HANDLE hServiceStatus service status handle
3344 * DWORD dwServiceBits service type bits to set or clear
3345 * BOOL bSetBitsOn flag to set or clear the service type bits
3346 * BOOL bUpdateImmediately flag to announce server type immediately
3347 * Variables :
3348 * Result :
3349 * Remark :
3350 * Status : UNTESTED STUB
3351 *
3352 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3353 *****************************************************************************/
3354
3355BOOL WIN32API SetServiceBits(SERVICE_STATUS_HANDLE hServiceStatus,
3356 DWORD dwServiceBits,
3357 BOOL bSetBitsOn,
3358 BOOL bUpdateImmediately)
3359{
3360 dprintf(("ADVAPI32: SetServiceBits(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3361 hServiceStatus,
3362 dwServiceBits,
3363 bSetBitsOn,
3364 bUpdateImmediately));
3365
3366 return (FALSE); /* signal failure */
3367}
3368
3369
3370/*****************************************************************************
3371 * Name : SetServiceObjectSecurity
3372 * Purpose : The SetServiceObjectSecurity function sets the security
3373 * descriptor of a service object.
3374 * Parameters: SC_HANDLE schService handle of service
3375 * SECURITY_INFORMATION fdwSecurityInfo type of security information requested
3376 * PSECURITY_DESCRIPTOR psdSecurityDesc address of security descriptor
3377 * Variables :
3378 * Result :
3379 * Remark :
3380 * Status : UNTESTED STUB
3381 *
3382 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3383 *****************************************************************************/
3384
3385BOOL WIN32API SetServiceObjectSecurity(SC_HANDLE schService,
3386 SECURITY_INFORMATION fdwSecurityInfo,
3387 PSECURITY_DESCRIPTOR psdSecurityDesc)
3388{
3389 dprintf(("ADVAPI32: SetServiceObjectSecurity(%08xh,%08xh,%08xh) not implemented.\n",
3390 schService,
3391 fdwSecurityInfo,
3392 psdSecurityDesc));
3393
3394 return (FALSE); /* signal failure */
3395}
3396
3397
3398/*****************************************************************************
3399 * Name : SetServiceStatus
3400 * Purpose : The SetServiceStatus function updates the service control
3401 * manager's status information for the calling service.
3402 * Parameters: SERVICE_STATUS_HANDLE sshServiceStatus service status handle
3403 * LPSERVICE_STATUS lpssServiceStatus address of status structure
3404 * Variables :
3405 * Result :
3406 * Remark :
3407 * Status : UNTESTED STUB
3408 *
3409 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3410 *****************************************************************************/
3411
3412BOOL WIN32API SetServiceStatus(SERVICE_STATUS_HANDLE sshServiceStatus,
3413 LPSERVICE_STATUS lpssServiceStatus)
3414{
3415 dprintf(("ADVAPI32: SetServiceStatus(%08xh,%08xh) not implemented.\n",
3416 sshServiceStatus,
3417 lpssServiceStatus));
3418
3419 return (FALSE); /* signal failure */
3420}
3421
3422
3423/*****************************************************************************
3424 * Name : StartServiceA
3425 * Purpose : The StartService function starts the execution of a service.
3426 * Parameters: SC_HANDLE schService handle of service
3427 * DWORD dwNumServiceArgs number of arguments
3428 * LPCSTR *lpszServiceArgs address of array of argument string pointers
3429 * Variables :
3430 * Result :
3431 * Remark :
3432 * Status : UNTESTED STUB
3433 *
3434 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3435 *****************************************************************************/
3436
3437BOOL WIN32API StartServiceA(SC_HANDLE schService,
3438 DWORD dwNumServiceArgs,
3439 LPCSTR *lpszServiceArgs)
3440{
3441 dprintf(("ADVAPI32: StartServiceA(%08xh,%08xh,%s) not implemented.\n",
3442 schService,
3443 dwNumServiceArgs,
3444 lpszServiceArgs));
3445
3446 return (FALSE); /* signal failure */
3447}
3448
3449
3450/*****************************************************************************
3451 * Name : StartServiceCtrlDispatcherW
3452 * Purpose : The StartServiceCtrlDispatcher function connects the main thread
3453 * of a service process to the service control manager, which causes
3454 * the thread to be the service control dispatcher thread for the calling process.
3455 * Parameters: LPSERVICE_TABLE_ENTRY lpsteServiceTable address of service table
3456 * Variables :
3457 * Result :
3458 * Remark :
3459 * Status : UNTESTED STUB
3460 *
3461 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3462 *****************************************************************************/
3463
3464#define LPSERVICE_TABLE_ENTRY LPVOID
3465BOOL WIN32API StartServiceCtrlDispatcherW(LPSERVICE_TABLE_ENTRY lpsteServiceTable)
3466{
3467 dprintf(("ADVAPI32: StartServiceCtrlDispatcherW(%08xh) not implemented.\n",
3468 lpsteServiceTable));
3469
3470 return (FALSE); /* signal failure */
3471}
3472
3473
3474/*****************************************************************************
3475 * Name : StartServiceCtrlDispatcherA
3476 * Purpose : The StartServiceCtrlDispatcher function connects the main thread
3477 * of a service process to the service control manager, which causes
3478 * the thread to be the service control dispatcher thread for the calling process.
3479 * Parameters: LPSERVICE_TABLE_ENTRY lpsteServiceTable address of service table
3480 * Variables :
3481 * Result :
3482 * Remark :
3483 * Status : UNTESTED STUB
3484 *
3485 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3486 *****************************************************************************/
3487
3488BOOL WIN32API StartServiceCtrlDispatcherA(LPSERVICE_TABLE_ENTRY lpsteServiceTable)
3489{
3490 dprintf(("ADVAPI32: StartServiceCtrlDispatcherA(%08xh) not implemented.\n",
3491 lpsteServiceTable));
3492
3493 return (FALSE); /* signal failure */
3494}
3495
3496
3497/*****************************************************************************
3498 * Name : StartServiceW
3499 * Purpose : The StartService function starts the execution of a service.
3500 * Parameters: SC_HANDLE schService handle of service
3501 * DWORD dwNumServiceArgs number of arguments
3502 * LPCWSTR *lpszServiceArgs address of array of argument string pointers
3503 * Variables :
3504 * Result :
3505 * Remark :
3506 * Status : UNTESTED STUB
3507 *
3508 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3509 *****************************************************************************/
3510
3511BOOL WIN32API StartServiceW(SC_HANDLE schService,
3512 DWORD dwNumServiceArgs,
3513 LPCWSTR *lpszServiceArgs)
3514{
3515 dprintf(("ADVAPI32: StartServiceW(%08xh,%08xh,%s) not implemented.\n",
3516 schService,
3517 dwNumServiceArgs,
3518 lpszServiceArgs));
3519
3520 return (FALSE); /* signal failure */
3521}
3522
3523
3524/*****************************************************************************
3525 * Name : UnlockServiceDatabase
3526 * Purpose : The UnlockServiceDatabase function unlocks a service control
3527 * manager database by releasing the specified lock.
3528 * Parameters: SC_LOCK sclLock service control manager database lock to be released
3529 * Variables :
3530 * Result :
3531 * Remark :
3532 * Status : UNTESTED STUB
3533 *
3534 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3535
3536 *****************************************************************************/
3537
3538BOOL WIN32API UnlockServiceDatabase(SC_LOCK sclLock)
3539{
3540 dprintf(("ADVAPI32: UnlockServiceDatabase(%08xh) not implemented.\n",
3541 sclLock));
3542
3543 return (FALSE); /* signal failure */
3544}
3545
Note: See TracBrowser for help on using the repository browser.