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

Last change on this file since 2149 was 2143, checked in by sandervl, 26 years ago

Moved Service apis into separate sourcefile
File size: 102.7 KB
Line 
1/* $Id: ADVAPI32.CPP,v 1.10 1999-12-19 19:53:36 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 : ClearEventLogA
638 * Purpose : The ClearEventLog function clears the specified event log, and
639 * optionally saves the current copy of the logfile to a backup file.
640 * Parameters: HANDLE hEventLog handle to event log
641 * LPCSTR lpBackupFileName name of backup file
642 * Variables :
643 * Result :
644 * Remark :
645 * Status : UNTESTED STUB
646 *
647 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
648 *****************************************************************************/
649
650BOOL WIN32API ClearEventLogA(HANDLE hEventLog,
651 LPCSTR lpBackupFileName)
652{
653 dprintf(("ADVAPI32: ClearEventLogA(%08xh,%s) not implemented.\n",
654 hEventLog,
655 lpBackupFileName));
656
657 return (FALSE); /* signal failure */
658}
659
660
661/*****************************************************************************
662 * Name : ClearEventLogW
663 * Purpose : The ClearEventLog function clears the specified event log, and
664 * optionally saves the current copy of the logfile to a backup file.
665 * Parameters: HANDLE hEventLog handle to event log
666 * LPCSTR lpBackupFileName name of backup file
667 * Variables :
668 * Result :
669 * Remark :
670 * Status : UNTESTED STUB
671 *
672 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
673 *****************************************************************************/
674
675BOOL WIN32API ClearEventLogW(HANDLE hEventLog,
676 LPCWSTR lpBackupFileName)
677{
678 dprintf(("ADVAPI32: ClearEventLogW(%08xh,%s) not implemented.\n",
679 hEventLog,
680 lpBackupFileName));
681
682 return (FALSE); /* signal failure */
683}
684
685
686/*****************************************************************************
687 * Name : CloseEventLog
688 * Purpose : The CloseEventLog function closes the specified event log.
689 * Parameters: HANDLE hEventLog handle to event log
690 * Variables :
691 * Result :
692 * Remark :
693 * Status : UNTESTED STUB
694 *
695 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
696 *****************************************************************************/
697
698BOOL WIN32API CloseEventLog(HANDLE hEventLog)
699{
700 dprintf(("ADVAPI32: CloseEventLog(%08xh) not implemented.\n",
701 hEventLog));
702
703 return (FALSE); /* signal failure */
704}
705
706
707
708
709
710/*****************************************************************************
711 * Name : CreatePrivateObjectSecurity
712 * Purpose : The CreatePrivateObjectSecurity function allocates and initializes
713 * a self-relative security descriptor for a new protected server's
714 * object. This function is called when a new protected server object is being created.
715 * Parameters: PSECURITY_DESCRIPTOR ParentDescriptor address of parent directory SD
716 * PSECURITY_DESCRIPTOR CreatorDescriptor address of creator SD
717 * PSECURITY_DESCRIPTOR *NewDescriptor address of pointer to new SD
718 * BOOL IsDirectoryObject container flag for new SD
719 * HANDLE Token handle of client's access token
720 * PGENERIC_MAPPING GenericMapping address of access-rights structure
721 * Variables :
722 * Result :
723 * Remark :
724 * Status : UNTESTED STUB
725 *
726 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
727 *****************************************************************************/
728
729BOOL WIN32API CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR ParentDescriptor,
730 PSECURITY_DESCRIPTOR CreatorDescriptor,
731 PSECURITY_DESCRIPTOR *NewDescriptor,
732 BOOL IsDirectoryObject,
733 HANDLE Token,
734 PGENERIC_MAPPING GenericMapping)
735{
736 dprintf(("ADVAPI32: CreatePrivateObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
737 ParentDescriptor,
738 CreatorDescriptor,
739 NewDescriptor,
740 IsDirectoryObject,
741 Token,
742 GenericMapping));
743
744 return (FALSE); /* signal failure */
745}
746
747
748/*****************************************************************************
749 * Name : CreateProcessAsUserA
750 * Purpose : The CreateProcessAsUser function creates a new process and its
751 * primary thread. The new process then executes a specified executable
752 * file. The CreateProcessAsUser function behaves just like the
753 * CreateProcess function, with one important difference: the
754 * created process runs in a context in which the system sees the
755 * user represented by the hToken parameter as if that user had
756 * logged on to the system and then called the CreateProcess function.
757 * Parameters: HANDLE hToken handle to a token that represents a logged-on user
758 * LPCSTR lpApplicationName pointer to name of executable module
759 * LPTSTR lpCommandLine pointer to command line string
760 * LPSECURITY_ATTRIBUTES lpProcessAttributes pointer to process security attributes
761 * LPSECURITY_ATTRIBUTES lpThreadAttributes pointer to thread security attributes
762 * BOOL bInheritHandles new process inherits handles
763 * DWORD dwCreationFlags creation flags
764 * LPVOID lpEnvironment pointer to new environment block
765 * LPCSTR lpCurrentDirectory pointer to current directory name
766 * LPSTARTUPINFO lpStartupInfo pointer to STARTUPINFO
767 * LPPROCESS_INFORMATION lpProcessInformation pointer to PROCESS_INFORMATION
768 * Variables :
769 * Result :
770 * Remark :
771 * Status : UNTESTED STUB
772 *
773 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
774 *****************************************************************************/
775
776BOOL WIN32API CreateProcessAsUserA(HANDLE hToken,
777 LPCSTR lpApplicationName,
778 LPTSTR lpCommandLine,
779 LPSECURITY_ATTRIBUTES lpProcessAttributes,
780 LPSECURITY_ATTRIBUTES lpThreadAttributes,
781 BOOL bInheritHandles,
782 DWORD dwCreationFlags,
783 LPVOID lpEnvironment,
784 LPCSTR lpCurrentDirectory,
785 LPSTARTUPINFOA lpStartupInfo,
786 LPPROCESS_INFORMATION lpProcessInformation)
787{
788 dprintf(("ADVAPI32: CreateProcessAsUserA(%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%s,%08xh,%08xh) not implemented.\n",
789 hToken,
790 lpApplicationName,
791 lpCommandLine,
792 lpProcessAttributes,
793 lpThreadAttributes,
794 bInheritHandles,
795 dwCreationFlags,
796 lpEnvironment,
797 lpCurrentDirectory,
798 lpStartupInfo,
799 lpProcessInformation));
800
801 return (FALSE); /* signal failure */
802}
803
804
805/*****************************************************************************
806 * Name : CreateProcessAsUserW
807 * Purpose : The CreateProcessAsUser function creates a new process and its
808 * primary thread. The new process then executes a specified executable
809 * file. The CreateProcessAsUser function behaves just like the
810 * CreateProcess function, with one important difference: the
811 * created process runs in a context in which the system sees the
812 * user represented by the hToken parameter as if that user had
813 * logged on to the system and then called the CreateProcess function.
814 * Parameters: HANDLE hToken handle to a token that represents a logged-on user
815 * LPCWSTR lpApplicationName pointer to name of executable module
816 * LPWSTR lpCommandLine pointer to command line string
817 * LPSECURITY_ATTRIBUTES lpProcessAttributes pointer to process security attributes
818 * LPSECURITY_ATTRIBUTES lpThreadAttributes pointer to thread security attributes
819 * BOOL bInheritHandles new process inherits handles
820 * DWORD dwCreationFlags creation flags
821 * LPVOID lpEnvironment pointer to new environment block
822 * LPCWSTR lpCurrentDirectory pointer to current directory name
823 * LPSTARTUPINFO lpStartupInfo pointer to STARTUPINFO
824 * LPPROCESS_INFORMATION lpProcessInformation pointer to PROCESS_INFORMATION
825 * Variables :
826 * Result :
827 * Remark :
828 * Status : UNTESTED STUB
829 *
830 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
831 *****************************************************************************/
832
833BOOL WIN32API CreateProcessAsUserW(HANDLE hToken,
834 LPCWSTR lpApplicationName,
835 LPWSTR lpCommandLine,
836 LPSECURITY_ATTRIBUTES lpProcessAttributes,
837 LPSECURITY_ATTRIBUTES lpThreadAttributes,
838 BOOL bInheritHandles,
839 DWORD dwCreationFlags,
840 LPVOID lpEnvironment,
841 LPCWSTR lpCurrentDirectory,
842 LPSTARTUPINFOA lpStartupInfo,
843 LPPROCESS_INFORMATION lpProcessInformation)
844{
845 dprintf(("ADVAPI32: CreateProcessAsUserW(%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%s,%08xh,%08xh) not implemented.\n",
846 hToken,
847 lpApplicationName,
848 lpCommandLine,
849 lpProcessAttributes,
850 lpThreadAttributes,
851 bInheritHandles,
852 dwCreationFlags,
853 lpEnvironment,
854 lpCurrentDirectory,
855 lpStartupInfo,
856 lpProcessInformation));
857
858 return (FALSE); /* signal failure */
859}
860
861
862
863/*****************************************************************************
864 * Name : DeleteAce
865 * Purpose : The DeleteAce function deletes an ACE from an ACL.
866 * An ACE is an access-control entry. An ACL is an access-control list.
867 * Parameters: PACL pAcl address of access-control list
868 * DWORD dwAceIndex index of ACE position in ACL
869 * Variables :
870 * Result :
871 * Remark :
872 * Status : UNTESTED STUB
873 *
874 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
875 *****************************************************************************/
876
877BOOL WIN32API DeleteAce(PACL pAcl,
878 DWORD dwAceIndex)
879{
880 dprintf(("ADVAPI32: DeleteAce(%08xh, %08xh) not implemented.\n",
881 pAcl,
882 dwAceIndex));
883
884 return (FALSE); /* signal failure */
885}
886
887
888
889/*****************************************************************************
890 * Name : DestroyPrivateObjectSecurity
891 * Purpose : The DestroyPrivateObjectSecurity function deletes a protected
892 * server object's security descriptor. This security descriptor
893 * must have been created by a call to the CreatePrivateObjectSecurity function.
894 * Parameters: PSECURITY_DESCRIPTOR * ObjectDescriptor address of pointer to SECURITY_DESCRIPTOR
895 * Variables :
896 * Result :
897 * Remark :
898 * Status : UNTESTED STUB
899 *
900 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
901 *****************************************************************************/
902
903BOOL WIN32API DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR *ObjectDescriptor)
904{
905 dprintf(("ADVAPI32: DestroyPrivateObjectSecurity(%08xh) not implemented.\n",
906 ObjectDescriptor));
907
908 return (FALSE); /* signal failure */
909}
910
911
912/*****************************************************************************
913 * Name : DuplicateToken
914 * Purpose : The DuplicateToken function creates a new access token that
915 * duplicates one already in existence.
916 * Parameters: HANDLE ExistingTokenHandle handle of token to duplicate
917 * SECURITY_IMPERSONATION_LEVEL ImpersonationLevel impersonation level
918 * PHANDLE DuplicateTokenHandle handle of duplicated token
919 * Variables :
920 * Result :
921 * Remark :
922 * Status : UNTESTED STUB
923 *
924 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
925 *****************************************************************************/
926
927BOOL WIN32API DuplicateToken(HANDLE ExistingTokenHandle,
928 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
929 PHANDLE DuplicateTokenHandle)
930{
931 dprintf(("ADVAPI32: DuplicateToken(%08x,%08xh,%08xh) not implemented.\n",
932 ExistingTokenHandle,
933 ImpersonationLevel,
934 DuplicateTokenHandle));
935
936 return (FALSE); /* signal failure */
937}
938
939/*****************************************************************************
940 * Name : FindFirstFreeAce
941 * Purpose : The FindFirstFreeAce function retrieves a pointer to the first
942 * free byte in an access-control list (ACL).
943 * Parameters: PACL pAcl address of access-control list
944 * LPVOID *pAce address of pointer to first free byte
945 * Variables :
946 * Result :
947 * Remark :
948 * Status : UNTESTED STUB
949 *
950 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
951 *****************************************************************************/
952
953BOOL WIN32API FindFirstFreeAce(PACL pAcl,
954 LPVOID *pAce)
955{
956 dprintf(("ADVAPI32: FindFirstFreeAce(%08xh, %08xh) not implemented.\n",
957 pAcl,
958 pAce));
959
960 return (FALSE); /* signal failure */
961}
962
963
964/*****************************************************************************
965 * Name : GetAce
966 * Purpose : The GetAce function obtains a pointer to an ACE in an ACL.
967 * An ACE is an access control entry. An ACL is an access control list.
968 * Parameters: PACL pAcl address of access-control list
969 * DWORD dwAceIndex index of ACE to retrieve
970 * LPVOID *pAce address of pointer to ACE
971 * Variables :
972 * Result :
973 * Remark :
974 * Status : UNTESTED STUB
975 *
976 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
977 *****************************************************************************/
978
979BOOL WIN32API GetAce(PACL pAcl,
980 DWORD dwAceIndex,
981 LPVOID *pAce)
982{
983 dprintf(("ADVAPI32: GetAce(%08xh,%08xh,%08xh) not implemented.\n",
984 pAcl,
985 dwAceIndex,
986 pAce));
987
988 return (FALSE); /* signal failure */
989}
990
991
992/*****************************************************************************
993 * Name : GetAclInformation
994 * Purpose : The GetAclInformation function retrieves information about an
995 * access-control list (ACL).
996 * Parameters: PACL pAcl address of access-control list
997 * LPVOID pAclInformation address of ACL information
998 * DWORD nAclInformationLength size of ACL information
999 * ACL_INFORMATION_CLASS dwAclInformationClass class of requested information
1000 * Variables :
1001 * Result :
1002 * Remark :
1003 * Status : UNTESTED STUB
1004 *
1005 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1006 *****************************************************************************/
1007
1008#define ACL_INFORMATION_CLASS DWORD
1009BOOL WIN32API GetAclInformation(PACL pAcl,
1010 LPVOID pAclInformation,
1011 DWORD nAclInformationLength,
1012 ACL_INFORMATION_CLASS dwAclInformationClass)
1013{
1014 dprintf(("ADVAPI32: GetAclInformation(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1015 pAcl,
1016 pAclInformation,
1017 nAclInformationLength,
1018 dwAclInformationClass));
1019
1020 return (FALSE); /* signal failure */
1021}
1022
1023
1024/*****************************************************************************
1025 * Name : GetKernelObjectSecurity
1026 * Purpose : The GetKernelObjectSecurity function retrieves a copy of the
1027 * security descriptor protecting a kernel object.
1028 * Parameters: HANDLE Handle handle of object to query
1029 * SECURITY_INFORMATION RequestedInformation requested information
1030 * PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
1031 * DWORD nLength size of buffer for security descriptor
1032 * LPDWORD lpnLengthNeeded address of required size of buffer
1033 * Variables :
1034 * Result :
1035 * Remark :
1036 * Status : UNTESTED STUB
1037 *
1038 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1039 *****************************************************************************/
1040
1041BOOL WIN32API GetKernelObjectSecurity(HANDLE Handle,
1042 SECURITY_INFORMATION RequestedInformation,
1043 PSECURITY_DESCRIPTOR pSecurityDescriptor,
1044 DWORD nLength,
1045 LPDWORD lpnLengthNeeded)
1046{
1047 dprintf(("ADVAPI32: GetKernelObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1048 Handle,
1049 RequestedInformation,
1050 pSecurityDescriptor,
1051 nLength,
1052 lpnLengthNeeded));
1053
1054 return (FALSE); /* signal failure */
1055}
1056
1057
1058
1059/*****************************************************************************
1060 * Name : GetNumberOfEventLogRecords
1061 * Purpose : The GetNumberOfEventLogRecords function retrieves the number of
1062 * records in the specified event log.
1063 * Parameters: HANDLE hEventLog handle to event log
1064 * LPDWORD NumberOfRecords buffer for number of records
1065 * Variables :
1066 * Result :
1067 * Remark :
1068 * Status : UNTESTED STUB
1069 *
1070 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1071 *****************************************************************************/
1072
1073BOOL WIN32API GetNumberOfEventLogRecords(HANDLE hEventLog,
1074 LPDWORD NumberOfRecords)
1075{
1076 dprintf(("ADVAPI32: GetNumberOfEventLogRecords(%08xh,%08xh) not implemented.\n",
1077 hEventLog,
1078 NumberOfRecords));
1079
1080 return (FALSE); /* signal failure */
1081}
1082
1083
1084/*****************************************************************************
1085 * Name : GetOldestEventLogRecord
1086 * Purpose : The GetOldestEventLogRecord function retrieves the absolute
1087 * record number of the oldest record in the specified event log.
1088 * Parameters: HANDLE hEventLog handle to event log
1089 * LPDWORD OldestRecord buffer for number of oldest record
1090 * Variables :
1091 * Result :
1092 * Remark :
1093 * Status : UNTESTED STUB
1094 *
1095 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1096 *****************************************************************************/
1097
1098BOOL WIN32API GetOldestEventLogRecord(HANDLE hEventLog,
1099 LPDWORD OldestRecord)
1100{
1101 dprintf(("ADVAPI32: GetOldestEventLogRecord(%08xh,%08xh) not implemented.\n",
1102 hEventLog,
1103 OldestRecord));
1104
1105 return (FALSE); /* signal failure */
1106}
1107
1108
1109/*****************************************************************************
1110 * Name : GetPrivateObjectSecurity
1111 * Purpose : The GetPrivateObjectSecurity retrieves information from a
1112 * protected server object's security descriptor.
1113 * Parameters: PSECURITY_DESCRIPTOR ObjectDescriptor address of SD to query
1114 * SECURITY_INFORMATION SecurityInformation requested information
1115 * PSECURITY_DESCRIPTOR ResultantDescriptor address of retrieved SD
1116 * DWORD DescriptorLength size of buffer for retrieved SD
1117 * LPDWORD ReturnLength address of buffer size required for SD
1118 * Variables :
1119 * Result :
1120 * Remark :
1121 * Status : UNTESTED STUB
1122 *
1123 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1124 *****************************************************************************/
1125
1126BOOL WIN32API GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR ObjectDescriptor,
1127 SECURITY_INFORMATION SecurityInformation,
1128 PSECURITY_DESCRIPTOR ResultantDescriptor,
1129 DWORD DescriptorLength,
1130 LPDWORD ReturnLength)
1131{
1132 dprintf(("ADVAPI32: GetPrivateObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1133 ObjectDescriptor,
1134 SecurityInformation,
1135 ResultantDescriptor,
1136 DescriptorLength,
1137 ReturnLength));
1138
1139 return (FALSE); /* signal failure */
1140}
1141
1142
1143/*****************************************************************************
1144 * Name : ImpersonateLoggedOnUser
1145 * Purpose : The ImpersonateLoggedOnUser function lets the calling thread
1146 * impersonate a user. The user is represented by a token handle
1147 * obtained by calling the LogonUser function
1148 * Parameters: HANDLE hToken
1149 * Variables :
1150 * Result :
1151 * Remark :
1152 * Status : UNTESTED STUB
1153 *
1154 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1155 *****************************************************************************/
1156
1157BOOL WIN32API ImpersonateLoggedOnUser(HANDLE hToken)
1158{
1159 dprintf(("ADVAPI32: ImpersonateLoggedOnUser(%08xh) not implemented.\n",
1160 hToken));
1161
1162 return (TRUE); /* signal OK */
1163}
1164
1165
1166/*****************************************************************************
1167 * Name : ImpersonateNamedPipeClient
1168 * Purpose : The ImpersonateNamedPipeClient function impersonates a named-pipe
1169 * client application.
1170 * Parameters: HANDLE hNamedPipe handle of a named pipe
1171 * Variables :
1172 * Result :
1173 * Remark :
1174 * Status : UNTESTED STUB
1175 *
1176 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1177 *****************************************************************************/
1178
1179BOOL WIN32API ImpersonateNamedPipeClient(HANDLE hNamedPipe)
1180{
1181 dprintf(("ADVAPI32: ImpersonateNamedPipeClient(%08xh) not implemented.\n",
1182 hNamedPipe));
1183
1184 return (TRUE); /* signal OK */
1185}
1186
1187
1188
1189/*****************************************************************************
1190 * Name : InitializeAcl
1191 * Purpose : The InitializeAcl function creates a new ACL structure.
1192 * An ACL is an access-control list.
1193 * Parameters: PACL pAcl address of access-control list
1194 * DWORD nAclLength size of access-control list
1195 * DWORD dwAclRevision revision level of access-control list
1196 * Variables :
1197 * Result :
1198 * Remark :
1199 * Status : UNTESTED STUB
1200 *
1201 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1202 *****************************************************************************/
1203
1204BOOL WIN32API InitializeAcl(PACL pAcl,
1205 DWORD nAclLength,
1206 DWORD dwAclRevision)
1207{
1208 dprintf(("ADVAPI32: InitializeAcl(%08xh,%08xh,%08xh) not implemented.\n",
1209 pAcl,
1210 nAclLength,
1211 dwAclRevision));
1212
1213 return (FALSE); /* signal failure */
1214}
1215
1216
1217
1218/*****************************************************************************
1219 * Name : InitiateSystemShutdownA
1220 * Purpose : The InitiateSystemShutdown function initiates a shutdown and
1221 * optional restart of the specified computer.
1222 * Parameters: LPTSTR lpMachineName address of name of computer to shut down
1223 * LPTSTR lpMessage address of message to display in dialog box
1224 * DWORD dwTimeout time to display dialog box
1225 * BOOL bForceAppsClosed force applications with unsaved changes flag
1226 * BOOL bRebootAfterShutdown reboot flag
1227 * Variables :
1228 * Result :
1229 * Remark :
1230 * Status : UNTESTED STUB
1231 *
1232 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1233 *****************************************************************************/
1234
1235BOOL WIN32API InitiateSystemShutdownA(LPTSTR lpMachineName,
1236 LPTSTR lpMessage,
1237 DWORD dwTimeout,
1238 BOOL bForceAppsClosed,
1239 BOOL bRebootAfterShutdown)
1240{
1241 dprintf(("ADVAPI32: InitiateSystemShutdownA(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1242 lpMachineName,
1243 lpMessage,
1244 dwTimeout,
1245 bForceAppsClosed,
1246 bRebootAfterShutdown));
1247
1248 return (FALSE); /* signal failure */
1249}
1250
1251
1252/*****************************************************************************
1253 * Name : InitiateSystemShutdownW
1254 * Purpose : The InitiateSystemShutdown function initiates a shutdown and
1255 * optional restart of the specified computer.
1256 * Parameters: LPWSTR lpMachineName address of name of computer to shut down
1257 * LPWSTR lpMessage address of message to display in dialog box
1258 * DWORD dwTimeout time to display dialog box
1259 * BOOL bForceAppsClosed force applications with unsaved changes flag
1260 * BOOL bRebootAfterShutdown reboot flag
1261 * Variables :
1262 * Result :
1263 * Remark :
1264 * Status : UNTESTED STUB
1265 *
1266 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1267 *****************************************************************************/
1268
1269BOOL WIN32API InitiateSystemShutdownW(LPWSTR lpMachineName,
1270 LPWSTR lpMessage,
1271 DWORD dwTimeout,
1272 BOOL bForceAppsClosed,
1273 BOOL bRebootAfterShutdown)
1274{
1275 dprintf(("ADVAPI32: InitiateSystemShutdownW(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1276 lpMachineName,
1277 lpMessage,
1278 dwTimeout,
1279 bForceAppsClosed,
1280 bRebootAfterShutdown));
1281
1282 return (FALSE); /* signal failure */
1283}
1284
1285
1286/*****************************************************************************
1287 * Name : IsTextUnicode
1288 * Purpose : The IsTextUnicode function determines whether a buffer probably
1289 * contains a form of Unicode text. The function uses various
1290 * statistical and deterministic methods to make its determination,
1291 * under the control of flags passed via lpi. When the function
1292 * returns, the results of such tests are reported via lpi. If all
1293 * specified tests are passed, the function returns TRUE; otherwise,
1294 * it returns FALSE.
1295 * Parameters: CONST LPVOID lpBuffer pointer to an input buffer to be examined
1296 * int cb the size in bytes of the input buffer
1297 * LPINT lpi pointer to flags that condition text examination and receive results
1298 * Variables :
1299 * Result :
1300 * Remark :
1301 * Status : UNTESTED STUB
1302 *
1303 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1304 *****************************************************************************/
1305
1306DWORD WIN32API IsTextUnicode(CONST LPVOID lpBuffer,
1307 int cb,
1308 LPINT lpi)
1309{
1310 DWORD dwResult = 0;
1311
1312 dprintf(("ADVAPI32: IsTextUnicode(%08xh,%08xh,%08xh) not implemented.\n",
1313 lpBuffer,
1314 cb,
1315 lpi));
1316
1317 if (cb & 0x0001) dwResult |= IS_TEXT_UNICODE_ODD_LENGTH;
1318
1319 return (dwResult); /* signal failure */
1320}
1321
1322
1323/*****************************************************************************
1324 * Name : IsValidAcl
1325 * Purpose : The IsValidAcl function validates an access-control list (ACL).
1326 * Parameters: PACL pAcl address of access-control list
1327 * Variables :
1328 * Result :
1329 * Remark :
1330 * Status : UNTESTED STUB
1331 *
1332 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1333 *****************************************************************************/
1334
1335BOOL WIN32API IsValidAcl(PACL pAcl)
1336{
1337 dprintf(("ADVAPI32: IsValidAcl(%08xh) not implemented.\n",
1338 pAcl));
1339
1340 return (TRUE); /* signal OK */
1341}
1342
1343
1344/*****************************************************************************
1345 * Name : LogonUserA
1346 * Purpose : The LogonUser function attempts to perform a user logon
1347 * operation. You specify the user with a user name and domain,
1348 * and authenticate the user with a clear-text password. If the
1349 * function succeeds, you receive a handle to a token that
1350 * represents the logged-on user. You can then use this token
1351 * handle to impersonate the specified user, or to create a process
1352 * running in the context of the specified user.
1353 * Parameters: LPTSTR lpszUsername string that specifies the user name
1354 * LPTSTR lpszDomain string that specifies the domain or servero
1355 * LPTSTR lpszPassword string that specifies the password
1356 * DWORD dwLogonType specifies the type of logon operation
1357 * DWORD dwLogonProvider specifies the logon provider
1358 * PHANDLE phToken pointer to variable to receive token handle
1359 * Variables :
1360 * Result :
1361 * Remark :
1362 * Status : UNTESTED STUB
1363 *
1364 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1365 *****************************************************************************/
1366
1367BOOL WIN32API LogonUserA(LPTSTR lpszUsername,
1368 LPTSTR lpszDomain,
1369 LPTSTR lpszPassword,
1370 DWORD dwLogonType,
1371 DWORD dwLogonProvider,
1372 PHANDLE phToken)
1373{
1374 dprintf(("ADVAPI32: LogonUserA(%s,%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
1375 lpszUsername,
1376 lpszDomain,
1377 lpszPassword,
1378 dwLogonType,
1379 dwLogonProvider,
1380 phToken));
1381
1382 return (TRUE); /* signal OK */
1383}
1384
1385
1386/*****************************************************************************
1387 * Name : LogonUserW
1388 * Purpose : The LogonUser function attempts to perform a user logon
1389 * operation. You specify the user with a user name and domain,
1390 * and authenticate the user with a clear-text password. If the
1391 * function succeeds, you receive a handle to a token that
1392 * represents the logged-on user. You can then use this token
1393 * handle to impersonate the specified user, or to create a process
1394 * running in the context of the specified user.
1395 * Parameters: LPWSTR lpszUsername string that specifies the user name
1396 * LPWSTR lpszDomain string that specifies the domain or servero
1397 * LPWSTR lpszPassword string that specifies the password
1398 * DWORD dwLogonType specifies the type of logon operation
1399 * DWORD dwLogonProvider specifies the logon provider
1400 * PHANDLE phToken pointer to variable to receive token handle
1401 * Variables :
1402 * Result :
1403 * Remark :
1404 * Status : UNTESTED STUB
1405 *
1406 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1407 *****************************************************************************/
1408
1409BOOL WIN32API LogonUserW(LPWSTR lpszUsername,
1410 LPWSTR lpszDomain,
1411 LPWSTR lpszPassword,
1412 DWORD dwLogonType,
1413 DWORD dwLogonProvider,
1414 PHANDLE phToken)
1415{
1416 dprintf(("ADVAPI32: LogonUserW(%s,%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
1417 lpszUsername,
1418 lpszDomain,
1419 lpszPassword,
1420 dwLogonType,
1421 dwLogonProvider,
1422 phToken));
1423
1424 return (TRUE); /* signal OK */
1425}
1426
1427
1428/*****************************************************************************
1429 * Name : LookupAccountNameA
1430 * Purpose : The LookupAccountName function accepts the name of a system and
1431 * an account as input. It retrieves a security identifier (SID)
1432 * for the account and the name of the domain on which the account was found.
1433 * Parameters: LPCSTR lpSystemName address of string for system name
1434 * LPCSTR lpAccountName address of string for account name
1435 * PSID Sid address of security identifier
1436 * LPDWORD cbSid address of size of security identifier
1437 * LPTSTR ReferencedDomainName address of string for referenced domain
1438 * LPDWORD cbReferencedDomainName address of size of domain string
1439 * PSID_NAME_USE peUse address of SID-type indicator
1440 * Variables :
1441 * Result :
1442 * Remark :
1443 * Status : UNTESTED STUB
1444 *
1445 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1446 *****************************************************************************/
1447
1448#define PSID_NAME_USE LPVOID
1449BOOL WIN32API LookupAccountNameA(LPCSTR lpSystemName,
1450 LPCSTR lpAccountName,
1451 PSID Sid,
1452 LPDWORD cbSid,
1453 LPTSTR ReferencedDomainName,
1454 LPDWORD cbReferencedDomainName,
1455 PSID_NAME_USE peUse)
1456{
1457 dprintf(("ADVAPI32: LookupAccountNameA(%s,%s,%08xh,%08xh,%s,%08xh,%08xh) not implemented.\n",
1458 lpSystemName,
1459 lpAccountName,
1460 Sid,
1461 cbSid,
1462 ReferencedDomainName,
1463 cbReferencedDomainName,
1464 peUse));
1465
1466 return (FALSE); /* signal failure */
1467}
1468
1469
1470/*****************************************************************************
1471 * Name : LookupAccountNameW
1472 * Purpose : The LookupAccountName function accepts the name of a system and
1473 * an account as input. It retrieves a security identifier (SID)
1474 * for the account and the name of the domain on which the account was found.
1475 * Parameters: LPCWSTR lpSystemName address of string for system name
1476 * LPCWSTR lpAccountName address of string for account name
1477 * PSID Sid address of security identifier
1478 * LPDWORD cbSid address of size of security identifier
1479 * LPWSTR ReferencedDomainName address of string for referenced domain
1480 * LPDWORD cbReferencedDomainName address of size of domain string
1481 * PSID_NAME_USE peUse address of SID-type indicator
1482 * Variables :
1483 * Result :
1484 * Remark :
1485 * Status : UNTESTED STUB
1486 *
1487 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1488 *****************************************************************************/
1489
1490BOOL WIN32API LookupAccountNameW(LPCWSTR lpSystemName,
1491 LPCWSTR lpAccountName,
1492 PSID Sid,
1493 LPDWORD cbSid,
1494 LPWSTR ReferencedDomainName,
1495 LPDWORD cbReferencedDomainName,
1496 PSID_NAME_USE peUse)
1497{
1498 dprintf(("ADVAPI32: LookupAccountNameW(%s,%s,%08xh,%08xh,%s,%08xh,%08xh) not implemented.\n",
1499 lpSystemName,
1500 lpAccountName,
1501 Sid,
1502 cbSid,
1503 ReferencedDomainName,
1504 cbReferencedDomainName,
1505 peUse));
1506
1507 return (FALSE); /* signal failure */
1508}
1509
1510
1511
1512/*****************************************************************************
1513 * Name : LookupPrivilegeDisplayNameA
1514 * Purpose : The LookupPrivilegeDisplayName function retrieves a displayable
1515 * name representing a specified privilege.
1516 * Parameters: LPCSTR lpSystemName address of string specifying the system
1517 * LPCSTR lpName address of string specifying the privilege
1518 * LPTSTR lpDisplayName address of string receiving the displayable name
1519 * LPDWORD cbDisplayName address of size of string for displayable name
1520 * LPDWORD lpLanguageId address of language identifier
1521 * Variables :
1522 * Result :
1523 * Remark :
1524 * Status : UNTESTED STUB
1525 *
1526 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1527 *****************************************************************************/
1528
1529BOOL WIN32API LookupPrivilegeDisplayNameA(LPCSTR lpSystemName,
1530 LPCSTR lpName,
1531 LPTSTR lpDisplayName,
1532 LPDWORD cbDisplayName,
1533 LPDWORD lpLanguageId)
1534{
1535 dprintf(("ADVAPI32: LookupPrivilegeDisplayNameA(%s,%s,%s,%08xh,%08xh) not implemented.\n",
1536 lpSystemName,
1537 lpName,
1538 lpDisplayName,
1539 cbDisplayName,
1540 lpLanguageId));
1541
1542 return (FALSE); /* signal failure */
1543}
1544
1545
1546/*****************************************************************************
1547 * Name : LookupPrivilegeDisplayNameW
1548 * Purpose : The LookupPrivilegeDisplayName function retrieves a displayable
1549 * name representing a specified privilege.
1550 * Parameters: LPCWSTR lpSystemName address of string specifying the system
1551 * LPCWSTR lpName address of string specifying the privilege
1552 * LPWSTR lpDisplayName address of string receiving the displayable name
1553 * LPDWORD cbDisplayName address of size of string for displayable name
1554 * LPDWORD lpLanguageId address of language identifier
1555 * Variables :
1556 * Result :
1557 * Remark :
1558 * Status : UNTESTED STUB
1559 *
1560 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1561 *****************************************************************************/
1562
1563BOOL WIN32API LookupPrivilegeDisplayNameW(LPCWSTR lpSystemName,
1564 LPCWSTR lpName,
1565 LPWSTR lpDisplayName,
1566 LPDWORD cbDisplayName,
1567 LPDWORD lpLanguageId)
1568{
1569 dprintf(("ADVAPI32: LookupPrivilegeDisplayNameW(%s,%s,%s,%08xh,%08xh) not implemented.\n",
1570 lpSystemName,
1571 lpName,
1572 lpDisplayName,
1573 cbDisplayName,
1574 lpLanguageId));
1575
1576 return (FALSE); /* signal failure */
1577}
1578
1579
1580/*****************************************************************************
1581 * Name : LookupPrivilegeNameA
1582 * Purpose : The LookupPrivilegeName function retrieves the name corresponding
1583 * to the privilege represented on a specific system by a specified
1584 * locally unique identifier (LUID).
1585 * Parameters: LPCSTR lpSystemName address of string specifying the system
1586 * PLUID lpLuid address of locally unique identifier
1587 * LPTSTR lpName address of string specifying the privilege
1588 * LPDWORD cbName address of size of string for displayable name
1589 * Variables :
1590 * Result :
1591 * Remark :
1592 * Status : UNTESTED STUB
1593 *
1594 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1595 *****************************************************************************/
1596
1597BOOL WIN32API LookupPrivilegeNameA(LPCSTR lpSystemName,
1598 PLUID lpLuid,
1599 LPTSTR lpName,
1600 LPDWORD cbName)
1601{
1602 dprintf(("ADVAPI32: LookupPrivilegeNameA(%s,%08xh,%s,%08xh) not implemented.\n",
1603 lpSystemName,
1604 lpLuid,
1605 lpName,
1606 cbName));
1607
1608 return (FALSE); /* signal failure */
1609}
1610
1611
1612/*****************************************************************************
1613 * Name : LookupPrivilegeNameW
1614 * Purpose : The LookupPrivilegeName function retrieves the name corresponding
1615 * to the privilege represented on a specific system by a specified
1616 * locally unique identifier (LUID).
1617 * Parameters: LPCWSTR lpSystemName address of string specifying the system
1618 * PLUID lpLuid address of locally unique identifier
1619 * LPWSTR lpName address of string specifying the privilege
1620 * LPDWORD cbName address of size of string for displayable name
1621 * Variables :
1622 * Result :
1623 * Remark :
1624 * Status : UNTESTED STUB
1625 *
1626 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1627 *****************************************************************************/
1628
1629BOOL WIN32API LookupPrivilegeNameW(LPCWSTR lpSystemName,
1630 PLUID lpLuid,
1631 LPWSTR lpName,
1632 LPDWORD cbName)
1633{
1634 dprintf(("ADVAPI32: LookupPrivilegeNameW(%s,%08xh,%s,%08xh) not implemented.\n",
1635 lpSystemName,
1636 lpLuid,
1637 lpName,
1638 cbName));
1639
1640 return (FALSE); /* signal failure */
1641}
1642
1643
1644/*****************************************************************************
1645 * Name : MakeAbsoluteSD
1646 * Purpose : The MakeAbsoluteSD function creates a security descriptor in
1647 * absolute format by using a security descriptor in self-relative
1648 * format as a template.
1649 * Parameters: PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor address self-relative SD
1650 * PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor address of absolute SD
1651 * LPDWORD lpdwAbsoluteSecurityDescriptorSize address of size of absolute SD
1652 * PACL pDacl address of discretionary ACL
1653 * LPDWORD lpdwDaclSize address of size of discretionary ACL
1654 * PACL pSacl address of system ACL
1655 * LPDWORD lpdwSaclSize address of size of system ACL
1656 * PSID pOwner address of owner SID
1657 * LPDWORD lpdwOwnerSize address of size of owner SID
1658 * PSID pPrimaryGroup address of primary-group SID
1659 * LPDWORD lpdwPrimaryGroupSize address of size of group SID
1660 * Variables :
1661 * Result :
1662 * Remark :
1663 * Status : UNTESTED STUB
1664 *
1665 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1666 *****************************************************************************/
1667
1668BOOL WIN32API MakeAbsoluteSD(PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
1669 PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
1670 LPDWORD lpdwAbsoluteSecurityDescriptorSize,
1671 PACL pDacl,
1672 LPDWORD lpdwDaclSize,
1673 PACL pSacl,
1674 LPDWORD lpdwSaclSize,
1675 PSID pOwner,
1676 LPDWORD lpdwOwnerSize,
1677 PSID pPrimaryGroup,
1678 LPDWORD lpdwPrimaryGroupSize)
1679{
1680 dprintf(("ADVAPI32: MakeAbsoluteSD(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1681 pSelfRelativeSecurityDescriptor,
1682 pAbsoluteSecurityDescriptor,
1683 lpdwAbsoluteSecurityDescriptorSize,
1684 pDacl,
1685 lpdwDaclSize,
1686 pSacl,
1687 lpdwSaclSize,
1688 pOwner,
1689 lpdwOwnerSize,
1690 pPrimaryGroup,
1691 lpdwPrimaryGroupSize));
1692
1693 return (FALSE); /* signal failure */
1694}
1695
1696
1697
1698
1699/*****************************************************************************
1700 * Name : MapGenericMask
1701 * Purpose : The MapGenericMask function maps the generic access rights in
1702 * an access mask to specific and standard access rights. The function
1703 * applies a mapping supplied in a GENERIC_MAPPING structure.
1704 * Parameters: LPDWORD AccessMask address of access mask
1705 * PGENERIC_MAPPING GenericMapping address of GENERIC_MAPPING structure
1706 * Variables :
1707 * Result :
1708 * Remark :
1709 * Status : UNTESTED STUB
1710 *
1711 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1712 *****************************************************************************/
1713
1714VOID WIN32API MapGenericMask(LPDWORD AccessMask,
1715 PGENERIC_MAPPING GenericMapping)
1716{
1717 dprintf(("ADVAPI32: MapGenericMask(%08xh,%08xh) not implemented.\n",
1718 AccessMask,
1719 GenericMapping));
1720}
1721
1722
1723
1724
1725/*****************************************************************************
1726 * Name : NotifyChangeEventLog
1727 * Purpose : The NotifyChangeEventLog function lets an application receive
1728 * notification when an event is written to the event log file
1729 * specified by hEventLog. When the event is written to the event
1730 * log file, the function causes the event object specified by
1731 * hEvent to become signaled.
1732 * Parameters: HANDLE hEventLog special default locale value to be converted
1733 * HANDLE hEvent special default locale value to be converted
1734 * Variables :
1735 * Result :
1736 * Remark :
1737 * Status : UNTESTED STUB
1738 *
1739 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1740 *****************************************************************************/
1741
1742BOOL WIN32API NotifyChangeEventLog(HANDLE hEventLog,
1743 HANDLE hEvent)
1744{
1745 dprintf(("ADVAPI32: NotifyChangeEventLog(%08xh,%08xh) not implemented.\n",
1746 hEventLog,
1747 hEvent));
1748
1749 return (FALSE); /* signal failure */
1750}
1751
1752
1753/*****************************************************************************
1754 * Name : ObjectCloseAuditAlarmA
1755 * Purpose : The ObjectCloseAuditAlarm function generates audit messages when
1756 * a handle of an object is deleted. Alarms are not supported in the
1757 * current version of Windows NT.
1758 * Parameters: LPCSTR SubsystemName address of string for subsystem name
1759 * LPVOID HandleId address of handle identifier
1760 * BOOL GenerateOnClose flag for audit generation
1761 * Variables :
1762 * Result :
1763 * Remark :
1764 * Status : UNTESTED STUB
1765 *
1766 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1767 *****************************************************************************/
1768
1769BOOL WIN32API ObjectCloseAuditAlarmA(LPCSTR SubsystemName,
1770 LPVOID HandleId,
1771 BOOL GenerateOnClose)
1772{
1773 dprintf(("ADVAPI32: ObjectCloseAuditAlarmA(%s,%08xh,%08xh) not implemented.\n",
1774 SubsystemName,
1775 HandleId,
1776 GenerateOnClose));
1777
1778 return (FALSE); /* signal failure */
1779}
1780
1781
1782/*****************************************************************************
1783 * Name : ObjectCloseAuditAlarmW
1784 * Purpose : The ObjectCloseAuditAlarm function generates audit messages when
1785 * a handle of an object is deleted. Alarms are not supported in the
1786 * current version of Windows NT.
1787 * Parameters: LPCWSTR SubsystemName address of string for subsystem name
1788 * LPVOID HandleId address of handle identifier
1789 * BOOL GenerateOnClose flag for audit generation
1790 * Variables :
1791 * Result :
1792 * Remark :
1793 * Status : UNTESTED STUB
1794 *
1795 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1796 *****************************************************************************/
1797
1798BOOL WIN32API ObjectCloseAuditAlarmW(LPCWSTR SubsystemName,
1799 LPVOID HandleId,
1800 BOOL GenerateOnClose)
1801{
1802 dprintf(("ADVAPI32: ObjectCloseAuditAlarmW(%s,%08xh,%08xh) not implemented.\n",
1803 SubsystemName,
1804 HandleId,
1805 GenerateOnClose));
1806
1807 return (FALSE); /* signal failure */
1808}
1809
1810
1811
1812/*****************************************************************************
1813 * Name : ObjectOpenAuditAlarmA
1814 * Purpose : The ObjectOpenAuditAlarm function generates audit messages when
1815 * a client application attempts to gain access to an object or to
1816 * create a new one. Alarms are not supported in the current version
1817 * of Windows NT.
1818 * Parameters: LPCSTR SubsystemName address of string for subsystem name
1819 * LPVOID HandleId address of handle identifier
1820 * LPTSTR ObjectTypeName address of string for object type
1821 * LPTSTR ObjectName address of string for object name
1822 * PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
1823 * HANDLE ClientToken handle of client's access token
1824 * DWORD DesiredAccess mask for desired access rights
1825 * DWORD GrantedAccess mask for granted access rights
1826 * PPRIVILEGE_SET Privileges address of privileges
1827 * BOOL ObjectCreation flag for object creation
1828 * BOOL AccessGranted flag for results
1829 * LPBOOL GenerateOnClose address of flag for audit generation
1830 * Variables :
1831 * Result :
1832 * Remark :
1833 * Status : UNTESTED STUB
1834 *
1835 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1836 *****************************************************************************/
1837
1838BOOL WIN32API ObjectOpenAuditAlarmA(LPCSTR SubsystemName,
1839 LPVOID HandleId,
1840 LPTSTR ObjectTypeName,
1841 LPTSTR ObjectName,
1842 PSECURITY_DESCRIPTOR pSecurityDescriptor,
1843 HANDLE ClientToken,
1844 DWORD DesiredAccess,
1845 DWORD GrantedAccess,
1846 PPRIVILEGE_SET Privileges,
1847 BOOL ObjectCreation,
1848 BOOL AccessGranted,
1849 LPBOOL GenerateOnClose)
1850{
1851 dprintf(("ADVAPI32: ObjectOpenAuditAlarmA(%s,%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1852 SubsystemName,
1853 HandleId,
1854 ObjectTypeName,
1855 ObjectName,
1856 pSecurityDescriptor,
1857 ClientToken,
1858 DesiredAccess,
1859 GrantedAccess,
1860 Privileges,
1861 ObjectCreation,
1862 AccessGranted,
1863 GenerateOnClose));
1864
1865 return (FALSE); /* signal failure */
1866}
1867
1868
1869/*****************************************************************************
1870 * Name : ObjectOpenAuditAlarmW
1871 * Purpose : The ObjectOpenAuditAlarm function generates audit messages when
1872 * a client application attempts to gain access to an object or to
1873 * create a new one. Alarms are not supported in the current version
1874 * of Windows NT.
1875 * Parameters: LPCWSTR SubsystemName address of string for subsystem name
1876 * LPVOID HandleId address of handle identifier
1877 * LPWSTR ObjectTypeName address of string for object type
1878 * LPWSTR ObjectName address of string for object name
1879 * PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
1880 * HANDLE ClientToken handle of client's access token
1881 * DWORD DesiredAccess mask for desired access rights
1882 * DWORD GrantedAccess mask for granted access rights
1883 * PPRIVILEGE_SET Privileges address of privileges
1884 * BOOL ObjectCreation flag for object creation
1885 * BOOL AccessGranted flag for results
1886 * LPBOOL GenerateOnClose address of flag for audit generation
1887 * Variables :
1888 * Result :
1889 * Remark :
1890 * Status : UNTESTED STUB
1891 *
1892 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1893 *****************************************************************************/
1894
1895BOOL WIN32API ObjectOpenAuditAlarmW(LPCWSTR SubsystemName,
1896 LPVOID HandleId,
1897 LPWSTR ObjectTypeName,
1898 LPWSTR ObjectName,
1899 PSECURITY_DESCRIPTOR pSecurityDescriptor,
1900 HANDLE ClientToken,
1901 DWORD DesiredAccess,
1902 DWORD GrantedAccess,
1903 PPRIVILEGE_SET Privileges,
1904 BOOL ObjectCreation,
1905 BOOL AccessGranted,
1906 LPBOOL GenerateOnClose)
1907{
1908 dprintf(("ADVAPI32: ObjectOpenAuditAlarmW(%s,%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1909 SubsystemName,
1910 HandleId,
1911 ObjectTypeName,
1912 ObjectName,
1913 pSecurityDescriptor,
1914 ClientToken,
1915 DesiredAccess,
1916 GrantedAccess,
1917 Privileges,
1918 ObjectCreation,
1919 AccessGranted,
1920 GenerateOnClose));
1921
1922 return (FALSE); /* signal failure */
1923}
1924
1925
1926/*****************************************************************************
1927 * Name : ObjectPrivilegeAuditAlarmA
1928 * Purpose : The ObjectPrivilegeAuditAlarm function generates audit messages
1929 * as a result of a client's attempt to perform a privileged operation
1930 * on a server application object using an already opened handle of
1931 * that object. Alarms are not supported in the current version of Windows NT.
1932 * Parameters: LPCSTR lpszSubsystem address of string for subsystem name
1933 * LPVOID lpvHandleId address of handle identifier
1934 * HANDLE hClientToken handle of client's access token
1935 * DWORD dwDesiredAccess mask for desired access rights
1936 * PPRIVILEGE_SET pps address of privileges
1937 * BOOL fAccessGranted flag for results
1938 * Variables :
1939 * Result :
1940 * Remark :
1941 * Status : UNTESTED STUB
1942 *
1943 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1944 *****************************************************************************/
1945
1946BOOL WIN32API ObjectPrivilegeAuditAlarmA(LPCSTR lpszSubsystem,
1947 LPVOID lpvHandleId,
1948 HANDLE hClientToken,
1949 DWORD dwDesiredAccess,
1950 PPRIVILEGE_SET pps,
1951 BOOL fAccessGranted)
1952{
1953 dprintf(("ADVAPI32: ObjectPrivilegeAuditAlarmA(%s,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1954 lpszSubsystem,
1955 lpvHandleId,
1956 hClientToken,
1957 dwDesiredAccess,
1958 pps,
1959 fAccessGranted));
1960
1961 return (FALSE); /* signal failure */
1962}
1963
1964
1965/*****************************************************************************
1966 * Name : ObjectPrivilegeAuditAlarmW
1967 * Purpose : The ObjectPrivilegeAuditAlarm function generates audit messages
1968 * as a result of a client's attempt to perform a privileged operation
1969 * on a server application object using an already opened handle of
1970 * that object. Alarms are not supported in the current version of Windows NT.
1971 * Parameters: LPCWSTR lpszSubsystem address of string for subsystem name
1972 * LPVOID lpvHandleId address of handle identifier
1973 * HANDLE hClientToken handle of client's access token
1974 * DWORD dwDesiredAccess mask for desired access rights
1975 * PPRIVILEGE_SET pps address of privileges
1976 * BOOL fAccessGranted flag for results
1977 * Variables :
1978 * Result :
1979 * Remark :
1980 * Status : UNTESTED STUB
1981 *
1982 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1983 *****************************************************************************/
1984
1985BOOL WIN32API ObjectPrivilegeAuditAlarmW(LPCWSTR lpszSubsystem,
1986 LPVOID lpvHandleId,
1987 HANDLE hClientToken,
1988 DWORD dwDesiredAccess,
1989 PPRIVILEGE_SET pps,
1990 BOOL fAccessGranted)
1991{
1992 dprintf(("ADVAPI32: ObjectPrivilegeAuditAlarmW(%s,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1993 lpszSubsystem,
1994 lpvHandleId,
1995 hClientToken,
1996 dwDesiredAccess,
1997 pps,
1998 fAccessGranted));
1999
2000 return (FALSE); /* signal failure */
2001}
2002
2003
2004/*****************************************************************************
2005 * Name : OpenBackupEventLogA
2006 * Purpose : The OpenBackupEventLog function opens a handle of a backup event
2007 * log. This handle can be used with the BackupEventLog function.
2008 * Parameters: LPCSTR lpszUNCServerName backup file server name
2009 * LPCSTR lpszFileName backup filename
2010 * Variables :
2011 * Result :
2012 * Remark :
2013 * Status : UNTESTED STUB
2014 *
2015 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2016 *****************************************************************************/
2017
2018HANDLE WIN32API OpenBackupEventLogA(LPCSTR lpszUNCServerName,
2019 LPCSTR lpszFileName)
2020{
2021 dprintf(("ADVAPI32: OpenBackupEventLogA(%s,%s) not implemented.\n",
2022 lpszUNCServerName,
2023 lpszFileName));
2024
2025 return (NULL); /* signal failure */
2026}
2027
2028
2029/*****************************************************************************
2030 * Name : OpenBackupEventLogW
2031 * Purpose : The OpenBackupEventLog function opens a handle of a backup event
2032 * log. This handle can be used with the BackupEventLog function.
2033 * Parameters: LPCWSTR lpszUNCServerName backup file server name
2034 * LPCWSTR lpszFileName backup filename
2035 * Variables :
2036 * Result :
2037 * Remark :
2038 * Status : UNTESTED STUB
2039 *
2040 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2041 *****************************************************************************/
2042
2043HANDLE WIN32API OpenBackupEventLogW(LPCWSTR lpszUNCServerName,
2044 LPCWSTR lpszFileName)
2045{
2046 dprintf(("ADVAPI32: OpenBackupEventLogW(%s,%s) not implemented.\n",
2047 lpszUNCServerName,
2048 lpszFileName));
2049
2050 return (NULL); /* signal failure */
2051}
2052
2053
2054/*****************************************************************************
2055 * Name : OpenEventLogA
2056 * Purpose : The OpenEventLog function opens a handle of an event log.
2057 * Parameters: LPCSTR lpszUNCServerName
2058 * LPCSTR lpszSourceName
2059 * Variables :
2060 * Result :
2061 * Remark :
2062 * Status : UNTESTED STUB
2063 *
2064 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2065 *****************************************************************************/
2066
2067HANDLE WIN32API OpenEventLogA(LPCSTR lpszUNCServerName,
2068 LPCSTR lpszSourceName)
2069{
2070 dprintf(("ADVAPI32: OpenEventLogA(%s,%s) not implemented.\n",
2071 lpszUNCServerName,
2072 lpszSourceName));
2073
2074 return (NULL); /* signal failure */
2075}
2076
2077
2078/*****************************************************************************
2079 * Name : OpenEventLogW
2080 * Purpose : The OpenEventLog function opens a handle of an event log.
2081 * Parameters: LPCWSTR lpszUNCServerName
2082 * LPCWSTR lpszSourceName
2083 * Variables :
2084 * Result :
2085 * Remark :
2086 * Status : UNTESTED STUB
2087 *
2088 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2089 *****************************************************************************/
2090
2091HANDLE WIN32API OpenEventLogW(LPCWSTR lpszUNCServerName,
2092 LPCWSTR lpszSourceName)
2093{
2094 dprintf(("ADVAPI32: OpenEventLogW(%s,%s) not implemented.\n",
2095 lpszUNCServerName,
2096 lpszSourceName));
2097
2098 return (NULL); /* signal failure */
2099}
2100
2101
2102
2103/*****************************************************************************
2104 * Name : PrivilegeCheck
2105 * Purpose : The PrivilegeCheck function tests the security context represented
2106 * by a specific access token to discover whether it contains the
2107 * specified privileges. This function is typically called by a server
2108 * application to check the privileges of a client's access token.
2109 * Parameters: HANDLE hClientToken handle of client's access token
2110 * PPRIVILEGE_SET pps address of privileges
2111 * LPBOOL lpfResult address of flag for result
2112 * Variables :
2113 * Result :
2114 * Remark :
2115 * Status : UNTESTED STUB
2116 *
2117 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2118 *****************************************************************************/
2119
2120BOOL WIN32API PrivilegeCheck(HANDLE hClientToken,
2121 PPRIVILEGE_SET pps,
2122 LPBOOL lpfResult)
2123{
2124 dprintf(("ADVAPI32: PrivilegeCheck(%08xh,%08xh,%08xh) not implemented.\n",
2125 hClientToken,
2126 pps,
2127 lpfResult));
2128
2129 return (FALSE); /* signal failure */
2130}
2131
2132
2133/*****************************************************************************
2134 * Name : PrivilegedServiceAuditAlarmA
2135 * Purpose : The PrivilegedServiceAuditAlarm function generates audit messages
2136 * when an attempt is made to perform privileged system service
2137 * operations. Alarms are not supported in the current version of Windows NT.
2138 * Parameters: LPCSTR lpszSubsystem address of string for subsystem name
2139 * LPCSTR lpszService address of string for service name
2140 * HANDLE hClientToken handle of access token
2141 * PPRIVILEGE_SET pps address of privileges
2142 * BOOL fAccessGranted flag for granted access rights
2143 * Variables :
2144 * Result :
2145 * Remark :
2146 * Status : UNTESTED STUB
2147 *
2148 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2149 *****************************************************************************/
2150
2151BOOL WIN32API PrivilegedServiceAuditAlarmA(LPCSTR lpszSubsystem,
2152 LPCSTR lpszService,
2153 HANDLE hClientToken,
2154 PPRIVILEGE_SET pps,
2155 BOOL fAccessGranted)
2156{
2157 dprintf(("ADVAPI32: PrivilegedServiceAuditAlarmA(%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
2158 lpszSubsystem,
2159 lpszService,
2160 hClientToken,
2161 pps,
2162 fAccessGranted));
2163
2164 return (FALSE); /* signal failure */
2165}
2166
2167
2168/*****************************************************************************
2169 * Name : PrivilegedServiceAuditAlarmW
2170 * Purpose : The PrivilegedServiceAuditAlarm function generates audit messages
2171 * when an attempt is made to perform privileged system service
2172 * operations. Alarms are not supported in the current version of Windows NT.
2173 * Parameters: LPCWSTR lpszSubsystem address of string for subsystem name
2174 * LPCWSTR lpszService address of string for service name
2175 * HANDLE hClientToken handle of access token
2176 * PPRIVILEGE_SET pps address of privileges
2177 * BOOL fAccessGranted flag for granted access rights
2178 * Variables :
2179 * Result :
2180 * Remark :
2181 * Status : UNTESTED STUB
2182 *
2183 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2184 *****************************************************************************/
2185
2186BOOL WIN32API PrivilegedServiceAuditAlarmW(LPCWSTR lpszSubsystem,
2187 LPCWSTR lpszService,
2188 HANDLE hClientToken,
2189 PPRIVILEGE_SET pps,
2190 BOOL fAccessGranted)
2191{
2192 dprintf(("ADVAPI32: PrivilegedServiceAuditAlarmW(%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
2193 lpszSubsystem,
2194 lpszService,
2195 hClientToken,
2196 pps,
2197 fAccessGranted));
2198
2199 return (FALSE); /* signal failure */
2200}
2201
2202
2203
2204
2205/*****************************************************************************
2206 * Name : ReadEventLogW
2207 * Purpose : The ReadEventLog function reads a whole number of entries from
2208 * the specified event log. The function can be used to read log
2209 * entries in forward or reverse chronological order.
2210 * Parameters: HANDLE hEventLog handle of event log
2211 * DWORD dwReadFlags specifies how to read log
2212 * DWORD dwRecordOffset number of first record
2213 * LPVOID lpBuffer address of buffer for read data
2214 * DWORD nNumberOfBytesToRead number of bytes to read
2215 * DWORD *pnBytesRea number of bytes read
2216 * DWORD *pnMinNumberOfBytesNeeded number of bytes required for next record
2217 * Variables :
2218 * Result :
2219 * Remark :
2220 * Status : UNTESTED STUB
2221 *
2222 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2223 *****************************************************************************/
2224
2225BOOL WIN32API ReadEventLogW(HANDLE hEventLog,
2226 DWORD dwReadFlags,
2227 DWORD dwRecordOffset,
2228 LPVOID lpBuffer,
2229 DWORD nNumberOfBytesToRead,
2230 DWORD *pnBytesRead,
2231 DWORD *pnMinNumberOfBytesNeeded)
2232{
2233 dprintf(("ADVAPI32: ReadEventLogW(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2234 hEventLog,
2235 dwReadFlags,
2236 dwRecordOffset,
2237 lpBuffer,
2238 nNumberOfBytesToRead,
2239 pnBytesRead,
2240 pnMinNumberOfBytesNeeded));
2241
2242 return (FALSE); /* signal failure */
2243}
2244
2245
2246/*****************************************************************************
2247 * Name : ReadEventLogA
2248 * Purpose : The ReadEventLog function reads a whole number of entries from
2249 * the specified event log. The function can be used to read log
2250 * entries in forward or reverse chronological order.
2251 * Parameters: HANDLE hEventLog handle of event log
2252 * DWORD dwReadFlags specifies how to read log
2253 * DWORD dwRecordOffset number of first record
2254 * LPVOID lpBuffer address of buffer for read data
2255 * DWORD nNumberOfBytesToRead number of bytes to read
2256 * DWORD *pnBytesRea number of bytes read
2257 * DWORD *pnMinNumberOfBytesNeeded number of bytes required for next record
2258 * Variables :
2259 * Result :
2260 * Remark :
2261 * Status : UNTESTED STUB
2262 *
2263 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2264 *****************************************************************************/
2265
2266BOOL WIN32API ReadEventLogA(HANDLE hEventLog,
2267 DWORD dwReadFlags,
2268 DWORD dwRecordOffset,
2269 LPVOID lpBuffer,
2270 DWORD nNumberOfBytesToRead,
2271 DWORD *pnBytesRead,
2272 DWORD *pnMinNumberOfBytesNeeded)
2273{
2274 dprintf(("ADVAPI32: ReadEventLogA(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2275 hEventLog,
2276 dwReadFlags,
2277 dwRecordOffset,
2278 lpBuffer,
2279 nNumberOfBytesToRead,
2280 pnBytesRead,
2281 pnMinNumberOfBytesNeeded));
2282
2283 return (FALSE); /* signal failure */
2284}
2285
2286
2287/*****************************************************************************
2288 * Name : RegisterServiceCtrlHandlerA
2289 * Purpose : The RegisterServiceCtrlHandler function registers a function to
2290 * handle service control requests for a service.
2291 * Parameters: LPCSTR lpszServiceName address of name of service
2292 * LPHANDLER_FUNCTION lpHandlerProc address of handler function
2293 * Variables :
2294 * Result :
2295 * Remark :
2296 * Status : UNTESTED STUB
2297 *
2298 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2299 *****************************************************************************/
2300
2301#define SERVICE_STATUS_HANDLE DWORD
2302#define LPHANDLER_FUNCTION LPVOID
2303SERVICE_STATUS_HANDLE WIN32API RegisterServiceCtrlHandlerA(LPCSTR lpszServiceName,
2304 LPHANDLER_FUNCTION lpHandlerProc)
2305{
2306 dprintf(("ADVAPI32: RegisterServiceCtrlHandlerA(%s,%08xh) not implemented.\n",
2307 lpszServiceName,
2308 lpHandlerProc));
2309
2310 return (0); /* signal failure */
2311}
2312
2313
2314/*****************************************************************************
2315 * Name : RegisterServiceCtrlHandlerW
2316 * Purpose : The RegisterServiceCtrlHandler function registers a function to
2317 * handle service control requests for a service.
2318 * Parameters: LPCWSTR lpszServiceName address of name of service
2319 * LPHANDLER_FUNCTION lpHandlerProc address of handler function
2320 * Variables :
2321 * Result :
2322 * Remark :
2323 * Status : UNTESTED STUB
2324 *
2325 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2326 *****************************************************************************/
2327
2328SERVICE_STATUS_HANDLE WIN32API RegisterServiceCtrlHandlerW(LPCWSTR lpszServiceName,
2329 LPHANDLER_FUNCTION lpHandlerProc)
2330{
2331 dprintf(("ADVAPI32: RegisterServiceCtrlHandlerW(%s,%08xh) not implemented.\n",
2332 lpszServiceName,
2333 lpHandlerProc));
2334
2335 return (0); /* signal failure */
2336}
2337
2338
2339
2340/*****************************************************************************
2341 * Name : SetAclInformation
2342 * Purpose : The SetAclInformation function sets information about an access-control list (ACL).
2343 * Parameters: PACL pAcl address of access-control list
2344 * LPVOID lpvAclInfo address of ACL information
2345 * DWORD cbAclInfo size of ACL information
2346 * ACL_INFORMATION_CLASS aclic specifies class of requested info
2347 * Variables :
2348 * Result :
2349 * Remark :
2350 * Status : UNTESTED STUB
2351 *
2352 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2353 *****************************************************************************/
2354
2355#define ACL_INFORMATION_CLASS DWORD
2356BOOL WIN32API SetAclInformation(PACL pAcl,
2357 LPVOID lpvAclInfo,
2358 DWORD cbAclInfo,
2359 ACL_INFORMATION_CLASS aclic)
2360{
2361 dprintf(("ADVAPI32: SetAclInformation(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2362 pAcl,
2363 lpvAclInfo,
2364 cbAclInfo,
2365 aclic));
2366
2367 return (FALSE); /* signal failure */
2368}
2369
2370
2371/*****************************************************************************
2372 * Name : SetKernelObjectSecurity
2373 * Purpose : The SetKernelObjectSecurity function sets the security of a kernel
2374 * object. For example, this can be a process, thread, or event.
2375 * Parameters: HANDLE hObject handle of object
2376 * SECURITY_INFORMATION si type of information to set
2377 * PSECURITY_DESCRIPTOR psd address of security descriptor
2378 * Variables :
2379 * Result :
2380 * Remark :
2381 * Status : UNTESTED STUB
2382 *
2383 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2384 *****************************************************************************/
2385
2386BOOL WIN32API SetKernelObjectSecurity(HANDLE hObject,
2387 SECURITY_INFORMATION si,
2388 PSECURITY_DESCRIPTOR psd)
2389{
2390 dprintf(("ADVAPI32: SetKernelObjectSecurity(%08xh,%08xh,%08xh) not implemented.\n",
2391 hObject,
2392 si,
2393 psd));
2394
2395 return (FALSE); /* signal failure */
2396}
2397
2398
2399/*****************************************************************************
2400 * Name : SetPrivateObjectSecurity
2401 * Purpose : The SetPrivateObjectSecurity function modifies a private
2402 * object's security descriptor.
2403 * Parameters: SECURITY_INFORMATION si type of security information
2404 * PSECURITY_DESCRIPTOR psdSource address of SD to apply to object
2405 * PSECURITY_DESCRIPTOR *lppsdTarget address of object's SD
2406 * PGENERIC_MAPPING pgm address of access-mapping structure
2407 * HANDLE hClientToken handle of client access token
2408 * Variables :
2409 * Result :
2410 * Remark :
2411 * Status : UNTESTED STUB
2412 *
2413 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2414 *****************************************************************************/
2415
2416BOOL WIN32API SetPrivateObjectSecurity(SECURITY_INFORMATION si,
2417 PSECURITY_DESCRIPTOR psdSource,
2418 PSECURITY_DESCRIPTOR *lppsdTarget,
2419 PGENERIC_MAPPING pgm,
2420 HANDLE hClientToken)
2421{
2422 dprintf(("ADVAPI32: SetPrivateObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2423 si,
2424 psdSource,
2425 lppsdTarget,
2426 pgm,
2427 hClientToken));
2428
2429 return (FALSE); /* signal failure */
2430}
2431
2432
2433
2434/*****************************************************************************
2435 * Name : SetServiceBits
2436 * Purpose : The SetServiceBits function registers a service's service type
2437 * with the Service Control Manager and the Server service. The
2438 * Server service can then announce the registered service type
2439 * as one it currently supports. The LAN Manager functions
2440 * NetServerGetInfo and NetServerEnum obtain a specified machine's
2441 * supported service types.
2442 * A service type is represented as a set of bit flags; the
2443 * SetServiceBits function sets or clears combinations of those bit flags.
2444 * Parameters: SERVICE_STATUS_HANDLE hServiceStatus service status handle
2445 * DWORD dwServiceBits service type bits to set or clear
2446 * BOOL bSetBitsOn flag to set or clear the service type bits
2447 * BOOL bUpdateImmediately flag to announce server type immediately
2448 * Variables :
2449 * Result :
2450 * Remark :
2451 * Status : UNTESTED STUB
2452 *
2453 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2454 *****************************************************************************/
2455
2456BOOL WIN32API SetServiceBits(SERVICE_STATUS_HANDLE hServiceStatus,
2457 DWORD dwServiceBits,
2458 BOOL bSetBitsOn,
2459 BOOL bUpdateImmediately)
2460{
2461 dprintf(("ADVAPI32: SetServiceBits(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2462 hServiceStatus,
2463 dwServiceBits,
2464 bSetBitsOn,
2465 bUpdateImmediately));
2466
2467 return (FALSE); /* signal failure */
2468}
2469
2470
2471
2472/*****************************************************************************
2473 * Name : SetServiceStatus
2474 * Purpose : The SetServiceStatus function updates the service control
2475 * manager's status information for the calling service.
2476 * Parameters: SERVICE_STATUS_HANDLE sshServiceStatus service status handle
2477 * LPSERVICE_STATUS lpssServiceStatus address of status structure
2478 * Variables :
2479 * Result :
2480 * Remark :
2481 * Status : UNTESTED STUB
2482 *
2483 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2484 *****************************************************************************/
2485
2486BOOL WIN32API SetServiceStatus(SERVICE_STATUS_HANDLE sshServiceStatus,
2487 LPSERVICE_STATUS lpssServiceStatus)
2488{
2489 dprintf(("ADVAPI32: SetServiceStatus(%08xh,%08xh) not implemented.\n",
2490 sshServiceStatus,
2491 lpssServiceStatus));
2492
2493 return (FALSE); /* signal failure */
2494}
2495
2496
2497
2498/*****************************************************************************
2499 * Name : StartServiceCtrlDispatcherW
2500 * Purpose : The StartServiceCtrlDispatcher function connects the main thread
2501 * of a service process to the service control manager, which causes
2502 * the thread to be the service control dispatcher thread for the calling process.
2503 * Parameters: LPSERVICE_TABLE_ENTRY lpsteServiceTable address of service table
2504 * Variables :
2505 * Result :
2506 * Remark :
2507 * Status : UNTESTED STUB
2508 *
2509 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2510 *****************************************************************************/
2511
2512#define LPSERVICE_TABLE_ENTRY LPVOID
2513BOOL WIN32API StartServiceCtrlDispatcherW(LPSERVICE_TABLE_ENTRY lpsteServiceTable)
2514{
2515 dprintf(("ADVAPI32: StartServiceCtrlDispatcherW(%08xh) not implemented.\n",
2516 lpsteServiceTable));
2517
2518 return (FALSE); /* signal failure */
2519}
2520
2521
2522/*****************************************************************************
2523 * Name : StartServiceCtrlDispatcherA
2524 * Purpose : The StartServiceCtrlDispatcher function connects the main thread
2525 * of a service process to the service control manager, which causes
2526 * the thread to be the service control dispatcher thread for the calling process.
2527 * Parameters: LPSERVICE_TABLE_ENTRY lpsteServiceTable address of service table
2528 * Variables :
2529 * Result :
2530 * Remark :
2531 * Status : UNTESTED STUB
2532 *
2533 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2534 *****************************************************************************/
2535
2536BOOL WIN32API StartServiceCtrlDispatcherA(LPSERVICE_TABLE_ENTRY lpsteServiceTable)
2537{
2538 dprintf(("ADVAPI32: StartServiceCtrlDispatcherA(%08xh) not implemented.\n",
2539 lpsteServiceTable));
2540
2541 return (FALSE); /* signal failure */
2542}
2543
2544
2545
Note: See TracBrowser for help on using the repository browser.