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

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

security api define fixes
File size: 183.9 KB
Line 
1/* $Id: ADVAPI32.CPP,v 1.7 1999-08-25 11:25:24 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//******************************************************************************
46BOOL WIN32API GetFileSecurityA(LPCSTR lpFileName,
47 SECURITY_INFORMATION RequestedInformation,
48 PSECURITY_DESCRIPTOR pSecurityDescriptor,
49 DWORD nLength,
50 LPDWORD lpnLengthNeeded)
51{
52#ifdef DEBUG
53 WriteLog("GetFileSecurityA %s, not implemented\n", lpFileName);
54#endif
55 return(FALSE);
56}
57//******************************************************************************
58//******************************************************************************
59BOOL WIN32API GetFileSecurityW(LPCWSTR lpFileName,
60 SECURITY_INFORMATION RequestedInformation,
61 PSECURITY_DESCRIPTOR pSecurityDescriptor,
62 DWORD nLength,
63 LPDWORD lpnLengthNeeded)
64{
65#ifdef DEBUG
66 WriteLog("GetFileSecurityW %s, not implemented\n",
67 lpFileName);
68#endif
69 return(FALSE);
70}
71//******************************************************************************
72//******************************************************************************
73BOOL WIN32API SetFileSecurityA(LPCSTR lpFileName,
74 SECURITY_INFORMATION RequestedInformation,
75 PSECURITY_DESCRIPTOR pSecurityDescriptor)
76{
77#ifdef DEBUG
78 WriteLog("SetFileSecurityA %s, not implemented\n", lpFileName);
79#endif
80 return(FALSE);
81}
82//******************************************************************************
83//******************************************************************************
84BOOL WIN32API SetFileSecurityW(LPCWSTR lpFileName,
85 SECURITY_INFORMATION RequestedInformation,
86 PSECURITY_DESCRIPTOR pSecurityDescriptor)
87{
88#ifdef DEBUG
89 WriteLog("SetFileSecurityW %s, not implemented\n", lpFileName);
90#endif
91 return(FALSE);
92}
93//******************************************************************************
94//******************************************************************************
95BOOL WIN32API GetUserNameA( /*PLF Wed 98-02-11 13:33:39*/
96 LPTSTR lpBuffer, /* address of name buffer */
97 LPDWORD lpcchBuffer) /* address of size of name buffer */
98
99
100 /* The GetUserName function retrieves the user name of the current
101 * thread. This is the name of the user currently logged onto the
102 * system.
103 */
104
105{
106 #define USERNAME "USER"
107 if(*lpcchBuffer < sizeof(USERNAME))
108 return FALSE;
109 strcpy(lpBuffer, USERNAME);
110 return TRUE;
111}
112//******************************************************************************
113//******************************************************************************
114BOOL WIN32API GetUserNameW( /*KSO Thu 21.05.1998 */
115 LPWSTR lpBuffer,
116 LPDWORD lpccBuffer
117 )
118{
119
120 if ( *lpccBuffer >= sizeof(USERNAME)*2 )
121 {
122 AsciiToUnicode(USERNAME, lpBuffer);
123 return TRUE;
124 }
125 return FALSE;
126}
127//******************************************************************************
128//******************************************************************************
129
130
131
132BOOL WIN32API ReportEventA( /*PLF Sat 98-03-07 00:36:43*/
133 HANDLE hEventLog,
134 WORD wType,
135 WORD wCategory,
136 DWORD dwEventID,
137 PSID lpUserSid,
138 WORD wNumStrings,
139 DWORD dwDataSize,
140 LPCSTR *lpStrings,
141 LPVOID lpRawData
142 )
143{
144 dprintf(("ReportEventA(): NIY\n"));
145 return TRUE;
146}
147
148
149BOOL WIN32API ReportEventW( /*PLF Sat 98-03-07 00:36:43*/
150 HANDLE hEventLog,
151 WORD wType,
152 WORD wCategory,
153 DWORD dwEventID,
154 PSID lpUserSid,
155 WORD wNumStrings,
156 DWORD dwDataSize,
157 LPCWSTR *lpStrings,
158 LPVOID lpRawData
159 )
160{
161 dprintf(("ReportEventW(): NIY\n"));
162 return TRUE;
163}
164
165
166BOOL WIN32API SetSecurityDescriptorDacl( /*PLF Sat 98-03-07 02:48:45*/
167 PSECURITY_DESCRIPTOR pSecurityDescriptor,
168 BOOL bDaclPresent,
169 PACL pDacl,
170 BOOL bDaclDefaulted
171 )
172
173{
174 dprintf(("SetSecurityDescriptorDacl(): NIY - returning error\n"));
175 return FALSE;
176}
177
178
179
180/*PLF Sat 98-03-07 02:59:20*/
181BOOL WIN32API InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR pSecurityDescriptor,
182 DWORD dwRevision)
183{
184 dprintf(("InitializeSecurityDescriptor() NIY\n"));
185 return FALSE;
186}
187
188/*PLF Sat 98-03-07 02:59:20*/
189HANDLE WIN32API RegisterEventSourceA(LPCSTR lpUNCServerName, LPCSTR lpSourceName)
190{
191 dprintf(("ADVAPI32: RegisterEventSourceA() NIY\n"));
192 return FALSE;
193}
194
195/*PLF Sat 98-03-07 02:59:20*/
196HANDLE WIN32API RegisterEventSourceW(LPCWSTR lpUNCServerName, LPCWSTR lpSourceName)
197{
198 dprintf(("ADVAPI32: RegisterEventSourceW() NIY\n"));
199 return FALSE;
200}
201
202
203/*PLF Sat 98-03-07 02:59:20*/
204BOOL WIN32API DeregisterEventSource(HANDLE hEventLog)
205{
206 dprintf(("DeregisterEventSource() NIY\n"));
207 return FALSE;
208}
209
210
211/*PLF Sat 98-03-07 02:59:20*/
212BOOL WIN32API AdjustTokenPrivileges(
213 HANDLE TokenHandle,
214 BOOL DisableAllPrivileges,
215 PTOKEN_PRIVILEGES NewState,
216 DWORD BufferLength,
217 PTOKEN_PRIVILEGES PreviousState,
218 LPDWORD ReturnLength
219)
220{
221 dprintf(("AdjustTokenPrivileges() NIY\n"));
222 return FALSE;
223}
224
225/*PLF Sat 98-03-07 02:59:20*/
226BOOL WIN32API LookupPrivilegeValueA(LPCSTR lpSystemName,
227 LPCSTR lpName,
228 LPVOID lpLuid)
229{
230 dprintf(("LookupPrivilegeValueA() NIY\n"));
231 return FALSE;
232}
233
234BOOL WIN32API LookupPrivilegeValueW(LPCWSTR lpSystemName,
235 LPCWSTR lpName,
236 LPVOID lpLuid)
237{
238 dprintf(("LookupPrivilegeValueW() NIY\n"));
239 return FALSE;
240}
241
242
243/*PLF Sat 98-03-07 02:59:20*/
244BOOL WIN32API OpenProcessToken(HANDLE ProcessHandle,
245 DWORD DesiredAccess,
246 PHANDLE TokenHandle
247)
248{
249 dprintf(("OpenProcessToken() NIY\n"));
250 return FALSE;
251}
252
253
254//******************************************************************************
255//******************************************************************************
256/*KSO Thu 21.05.1998*/
257BOOL WIN32API SetThreadToken (
258 PHANDLE Thread,
259 HANDLE Token
260 )
261{
262 dprintf(("SetThreadToken() NIY\n"));
263 return FALSE;
264}
265
266//******************************************************************************
267//******************************************************************************
268/*KSO Thu 21.05.1998*/
269BOOL WIN32API OpenThreadToken (
270 HANDLE ThreadHandle,
271 DWORD DesiredAccess,
272 BOOL OpenAsSelf,
273 PHANDLE TokenHandle
274 )
275{
276 dprintf(("OpenThreadToken() NIY\n"));
277 return FALSE;
278}
279
280
281
282
283
284/*****************************************************************************
285 * Name : AbortSystemShutdownA
286 * Purpose : The AbortSystemShutdown function stops a system shutdown started
287 * by using the InitiateSystemShutdown function.
288 * Parameters: LPTSTR lpMachineName address of name of computer to stop shutting down
289 * Variables :
290 * Result :
291 * Remark :
292 * Status : UNTESTED STUB
293 *
294 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
295 *****************************************************************************/
296
297BOOL WIN32API AbortSystemShutdownA(LPTSTR lpMachineName)
298{
299 dprintf(("ADVAPI32: AbortSystemShutdownA(%s) not implemented.\n",
300 lpMachineName));
301
302 return (FALSE);
303}
304
305
306/*****************************************************************************
307 * Name : AbortSystemShutdownW
308 * Purpose : The AbortSystemShutdown function stops a system shutdown started
309 * by using the InitiateSystemShutdown function.
310 * Parameters: LPWSTR lpMachineName address of name of computer to stop shutting down
311 * Variables :
312 * Result :
313 * Remark :
314 * Status : UNTESTED STUB
315 *
316 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
317 *****************************************************************************/
318
319BOOL WIN32API AbortSystemShutdownW(LPWSTR lpMachineName)
320{
321 dprintf(("ADVAPI32: AbortSystemShutdownW(%s) not implemented.\n",
322 lpMachineName));
323
324 return (FALSE);
325}
326
327
328/*****************************************************************************
329 * Name : AccessCheck
330 * Purpose : The AccessCheck function is used by a server application to
331 * check a client's access to an object against the access control
332 * associated with the object.
333 * Parameters: PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
334 * HANDLE ClientToken handle of client access token
335 * DWORD DesiredAccess access mask to request
336 * PGENERIC_MAPPING GenericMapping address of generic-mapping structure
337 * PPRIVILEGE_SET PrivilegeSet address of privilege-set structure
338 * LPDWORD PrivilegeSetLength size of privilege-set structure
339 * LPDWORD GrantedAccess address of granted access mask
340 * LPBOOL AccessStatus address of flag indicating whether access granted
341 * Variables :
342 * Result :
343 * Remark :
344 * Status : UNTESTED STUB
345 *
346 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
347 *****************************************************************************/
348
349#define PGENERIC_MAPPING LPVOID
350#define PPRIVILEGE_SET LPVOID
351BOOL WIN32API AccessCheck(PSECURITY_DESCRIPTOR pSecurityDescriptor,
352 HANDLE ClientToken,
353 DWORD DesiredAccess,
354 PGENERIC_MAPPING GenericMapping,
355 PPRIVILEGE_SET PrivilegeSet,
356 LPDWORD PrivilegeSetLength,
357 LPDWORD GrantedAccess,
358 LPBOOL AccessStatus)
359{
360 dprintf(("ADVAPI32: AccessCheck(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
361 pSecurityDescriptor,
362 ClientToken,
363 DesiredAccess,
364 GenericMapping,
365 PrivilegeSet,
366 PrivilegeSetLength,
367 GrantedAccess,
368 AccessStatus));
369
370 return (TRUE); /* always grant access */
371}
372
373
374/*****************************************************************************
375 * Name : AccessCheckAndAuditAlarmA
376 * Purpose : The AccessCheckAndAuditAlarm function performs an access
377 * validation and generates corresponding audit messages. An
378 * application can also use this function to determine whether
379 * necessary privileges are held by a client process. This function
380 * is generally used by a server application impersonating a client
381 * process. Alarms are not supported in the current version of Windows NT.
382 * Parameters: LPCSTR SubsystemName address of string for subsystem name
383 * LPVOID HandleId address of handle identifier
384 * LPTSTR ObjectTypeName address of string for object type
385 * LPTSTR ObjectName address of string for object name
386 * PSECURITY_DESCRIPTOR SecurityDescriptor address of security descriptor
387 * DWORD DesiredAccess mask for requested access rights
388 * PGENERIC_MAPPING GenericMapping address of GENERIC_MAPPING
389 * BOOL ObjectCreation object-creation flag
390 * LPDWORD GrantedAccess address of mask for granted rights
391 * LPBOOL AccessStatus address of flag for results
392 * LPBOOL pfGenerateOnClose address of flag for audit generation
393 * Variables :
394 * Result :
395 * Remark :
396 * Status : UNTESTED STUB
397 *
398 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
399 *****************************************************************************/
400
401BOOL WIN32API AccessCheckAndAuditAlarmA(LPCSTR SubsystemName,
402 LPVOID HandleId,
403 LPTSTR ObjectTypeName,
404 LPTSTR ObjectName,
405 PSECURITY_DESCRIPTOR SecurityDescriptor,
406 DWORD DesiredAccess,
407 PGENERIC_MAPPING GenericMapping,
408 BOOL ObjectCreation,
409 LPDWORD GrantedAccess,
410 LPBOOL AccessStatus,
411 LPBOOL pfGenerateOnClose)
412{
413 dprintf(("ADVAPI32: AccessCheckAndAuditAlarmA(%s,%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
414 SubsystemName,
415 HandleId,
416 ObjectTypeName,
417 ObjectName,
418 SecurityDescriptor,
419 DesiredAccess,
420 GenericMapping,
421 ObjectCreation,
422 GrantedAccess,
423 AccessStatus,
424 pfGenerateOnClose));
425
426 return (FALSE);
427}
428
429
430/*****************************************************************************
431 * Name : AccessCheckAndAuditAlarmW
432 * Purpose : The AccessCheckAndAuditAlarm function performs an access
433 * validation and generates corresponding audit messages. An
434 * application can also use this function to determine whether
435 * necessary privileges are held by a client process. This function
436 * is generally used by a server application impersonating a client
437 * process. Alarms are not supported in the current version of Windows NT.
438 * Parameters: LPCSTR SubsystemName address of string for subsystem name
439 * LPVOID HandleId address of handle identifier
440 * LPTSTR ObjectTypeName address of string for object type
441 * LPTSTR ObjectName address of string for object name
442 * PSECURITY_DESCRIPTOR SecurityDescriptor address of security descriptor
443 * DWORD DesiredAccess mask for requested access rights
444 * PGENERIC_MAPPING GenericMapping address of GENERIC_MAPPING
445 * BOOL ObjectCreation object-creation flag
446 * LPDWORD GrantedAccess address of mask for granted rights
447 * LPBOOL AccessStatus address of flag for results
448 * LPBOOL pfGenerateOnClose address of flag for audit generation
449 * Variables :
450 * Result :
451 * Remark :
452 * Status : UNTESTED STUB
453 *
454 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
455 *****************************************************************************/
456
457BOOL WIN32API AccessCheckAndAuditAlarmW(LPCWSTR SubsystemName,
458 LPVOID HandleId,
459 LPWSTR ObjectTypeName,
460 LPWSTR ObjectName,
461 PSECURITY_DESCRIPTOR SecurityDescriptor,
462 DWORD DesiredAccess,
463 PGENERIC_MAPPING GenericMapping,
464 BOOL ObjectCreation,
465 LPDWORD GrantedAccess,
466 LPBOOL AccessStatus,
467 LPBOOL pfGenerateOnClose)
468{
469 dprintf(("ADVAPI32: AccessCheckAndAuditAlarmW(%s,%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
470 SubsystemName,
471 HandleId,
472 ObjectTypeName,
473 ObjectName,
474 SecurityDescriptor,
475 DesiredAccess,
476 GenericMapping,
477 ObjectCreation,
478 GrantedAccess,
479 AccessStatus,
480 pfGenerateOnClose));
481
482 return (FALSE);
483}
484
485
486/*****************************************************************************
487 * Name : AddAccessAllowedAce
488 * Purpose : The AddAccessAllowedAce function adds an access-allowed ACE to
489 * an ACL. The access is granted to a specified SID. An ACE is an
490 * access-control entry. An ACL is an access-control list. A SID is
491 * a security identifier.
492 * Parameters: PACL pAcl address of access-control list
493 * DWORD dwAceRevision ACL revision level
494 * DWORD AccessMask access mask
495 * PSID pSid address of security identifier
496 * Variables :
497 * Result :
498 * Remark :
499 * Status : UNTESTED STUB
500 *
501 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
502 *****************************************************************************/
503
504BOOL WIN32API AddAccessAllowedAce(PACL pAcl,
505 DWORD dwAceRevision,
506 DWORD AccessMask,
507 PSID pSid)
508{
509 dprintf(("ADVAPI32: AddAccessAllowedAce(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
510 pAcl,
511 dwAceRevision,
512 AccessMask,
513 pSid));
514
515 return (FALSE);
516}
517
518
519/*****************************************************************************
520 * Name : AddAccessDeniedAce
521 * Purpose : The AddAccessDeniedAce function adds an access-denied ACE to an
522 * ACL. The access is denied to a specified SID. An ACE is an
523 * access-control entry. An ACL is an access-control list. A SID
524 * is a security identifier.
525 * Parameters: PACL pAcl address of access-control list
526 * DWORD dwAceRevision ACL revision level
527 * DWORD AccessMask access mask
528 * PSID pSid address of security identifier
529 * Variables :
530 * Result :
531 * Remark :
532 * Status : UNTESTED STUB
533 *
534 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
535 *****************************************************************************/
536
537BOOL WIN32API AddAccessDeniedAce(PACL pAcl,
538 DWORD dwAceRevision,
539 DWORD AccessMask,
540 PSID pSid)
541{
542 dprintf(("ADVAPI32: AddAccessDeniedAce(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
543 pAcl,
544 dwAceRevision,
545 AccessMask,
546 pSid));
547
548 return (FALSE);
549}
550
551
552/*****************************************************************************
553 * Name : AddAce
554 * Purpose : The AddAce function adds one or more ACEs to a specified ACL.
555 * An ACE is an access-control entry. An ACL is an access-control list.
556 * Parameters: PACL pAcl address of access-control list
557 * DWORD dwAceRevision ACL revision level
558 * DWORD dwStartingAceIndex index of ACE position in ACL
559 * LPVOID pAceList address of one or more ACEs
560 * DWORD nAceListLength size of buffer for ACEs
561 * Variables :
562 * Result :
563 * Remark :
564 * Status : UNTESTED STUB
565 *
566 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
567 *****************************************************************************/
568
569BOOL WIN32API AddAce(PACL pAcl,
570 DWORD dwAceRevision,
571 DWORD dwStartingAceIndex,
572 LPVOID pAceList,
573 DWORD nAceListLength)
574{
575 dprintf(("ADVAPI32: AddAce(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
576 pAcl,
577 dwAceRevision,
578 dwStartingAceIndex,
579 pAceList,
580 nAceListLength));
581
582 return (FALSE);
583}
584
585
586/*****************************************************************************
587 * Name : AddAuditAccessAce
588 * Purpose : The AddAuditAccessAce function adds a system-audit ACE to a
589 * system ACL. The access of a specified SID is audited. An ACE is
590 * an access-control entry. An ACL is an access-control list. A SID
591 * is a security identifier.
592 * Parameters: PACL pAcl address of access-control list
593 * DWORD dwAceRevision ACL revision level
594 * DWORD dwAccessMask access mask
595 * PSID pSid address of security identifier
596 * BOOL bAuditSuccess flag for auditing successful access
597 * BOOL bAuditFailure flag for auditing unsuccessful access attempts
598 * Variables :
599 * Result :
600 * Remark :
601 * Status : UNTESTED STUB
602 *
603 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
604 *****************************************************************************/
605
606BOOL WIN32API AddAuditAccessAce(PACL pAcl,
607 DWORD dwAceRevision,
608 DWORD dwAccessMask,
609 PSID pSid,
610 BOOL bAuditSuccess,
611 BOOL bAuditFailure)
612{
613 dprintf(("ADVAPI32: AddAuditAccessAce(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
614 pAcl,
615 dwAceRevision,
616 dwAccessMask,
617 pSid,
618 bAuditSuccess,
619 bAuditFailure));
620
621 return (FALSE);
622}
623
624
625/*****************************************************************************
626 * Name : AdjustTokenGroups
627 * Purpose : The AdjustTokenGroups function adjusts groups in the specified
628 * access token. TOKEN_ADJUST_GROUPS access is required to enable
629 * or disable groups in an access token.
630 * Parameters: HANDLE TokenHandle handle of token that contains groups
631 * BOOL ResetToDefault flag for default settings
632 * PTOKEN_GROUPS NewState address of new group information
633 * DWORD BufferLength size of buffer for previous information
634 * PTOKEN_GROUPS PreviousState address of previous group information
635 * LPDWORD ReturnLength address of required buffer size
636 * Variables :
637 * Result :
638 * Remark :
639 * Status : UNTESTED STUB
640 *
641 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
642 *****************************************************************************/
643
644#define PTOKEN_GROUPS LPVOID
645BOOL WIN32API AdjustTokenGroups(HANDLE TokenHandle,
646 BOOL ResetToDefault,
647 PTOKEN_GROUPS NewState,
648 DWORD BufferLength,
649 PTOKEN_GROUPS PreviousState,
650 LPDWORD ReturnLength)
651{
652 dprintf(("ADVAPI32: AdjustTokenGroups(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
653 TokenHandle,
654 ResetToDefault,
655 NewState,
656 BufferLength,
657 PreviousState,
658 ReturnLength));
659
660 return (FALSE); /* signal failure */
661}
662
663
664/*****************************************************************************
665 * Name : AllocateAndInitializeSid
666 * Purpose : The AllocateAndInitializeSid function allocates and initializes
667 * a security identifier (SID) with up to eight subauthorities.
668 * Parameters: PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority address of identifier authority
669 * BYTE nSubAuthorityCount count of subauthorities
670 * DWORD dwSubAuthority0 subauthority 0
671 * DWORD dwSubAuthority1 subauthority 1
672 * DWORD dwSubAuthority2 subauthority 2
673 * DWORD dwSubAuthority3 subauthority 3
674 * DWORD dwSubAuthority4 subauthority 4
675 * DWORD dwSubAuthority5 subauthority 5
676 * DWORD dwSubAuthority6 subauthority 6
677 * DWORD dwSubAuthority7 subauthority 7
678 * PSID *pSid address of pointer to SID
679 * Variables :
680 * Result :
681 * Remark :
682 * Status : UNTESTED STUB
683 *
684 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
685 *****************************************************************************/
686
687BOOL WIN32API AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
688 BYTE nSubAuthorityCount,
689 DWORD dwSubAuthority0,
690 DWORD dwSubAuthority1,
691 DWORD dwSubAuthority2,
692 DWORD dwSubAuthority3,
693 DWORD dwSubAuthority4,
694 DWORD dwSubAuthority5,
695 DWORD dwSubAuthority6,
696 DWORD dwSubAuthority7,
697 PSID *pSid)
698{
699 dprintf(("ADVAPI32: AllocateAndInitializeSid(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
700 pIdentifierAuthority,
701 nSubAuthorityCount,
702 dwSubAuthority0,
703 dwSubAuthority1,
704 dwSubAuthority2,
705 dwSubAuthority3,
706 dwSubAuthority4,
707 dwSubAuthority5,
708 dwSubAuthority6,
709 dwSubAuthority7,
710 pSid));
711
712 return (FALSE); /* signal failure */
713}
714
715
716/*****************************************************************************
717 * Name : AllocateLocallyUniqueId
718 * Purpose : The AllocateLocallyUniqueId function allocates a locally unique
719 * identifier (LUID).
720 * Parameters: PLUID Luid address of locally unique identifier
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 AllocateLocallyUniqueId(PLUID Luid)
730{
731 dprintf(("ADVAPI32: AllocateLocallyUniqueId(%08xh) not implemented.\n",
732 Luid));
733
734 return (FALSE); /* signal failure */
735}
736
737
738/*****************************************************************************
739 * Name : AreAllAccessesGranted
740 * Purpose : The AreAllAccessesGranted function checks whether a set of
741 * requested access rights has been granted. The access rights are
742 * represented as bit flags in a 32-bit access mask.
743 * Parameters: DWORD GrantedAccess access mask for granted access rights
744 * DWORD DesiredAccess access mask for requested access rights
745 * Variables :
746 * Result :
747 * Remark :
748 * Status : UNTESTED STUB
749 *
750 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
751 *****************************************************************************/
752
753BOOL WIN32API AreAllAccessesGranted(DWORD GrantedAccess,
754 DWORD DesiredAccess)
755{
756 dprintf(("ADVAPI32: AreAllAccessesGranted(%08xh,%08xh) not implemented.\n",
757 GrantedAccess,
758 DesiredAccess));
759
760 return (TRUE); /* grant all access */
761}
762
763
764/*****************************************************************************
765 * Name : AreAnyAccessesGranted
766 * Purpose : The AreAnyAccessesGranted function tests whether any of a set of
767 * requested access rights has been granted. The access rights are
768 * represented as bit flags in a 32-bit access mask.
769 * Parameters: DWORD GrantedAccess access mask for granted access rights
770 * DWORD DesiredAccess access mask for requested access rights
771 * Variables :
772 * Result :
773 * Remark :
774 * Status : UNTESTED STUB
775 *
776 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
777 *****************************************************************************/
778
779BOOL WIN32API AreAnyAccessesGranted(DWORD GrantedAccess,
780 DWORD DesiredAccess)
781{
782 dprintf(("ADVAPI32: AreAnyAccessesGranted(%08xh,%08xh) not implemented.\n",
783 GrantedAccess,
784 DesiredAccess));
785
786 return (TRUE); /* grant all access */
787}
788
789
790/*****************************************************************************
791 * Name : BackupEventLogA
792 * Purpose : The BackupEventLog function saves the specified event log to a
793 * backup file. The function does not clear the event log.
794 * Parameters: HANDLE hEventLog handle to event log
795 * LPCSTR lpBackupFileName name of backup file
796 * Variables :
797 * Result :
798 * Remark :
799 * Status : UNTESTED STUB
800 *
801 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
802 *****************************************************************************/
803
804BOOL WIN32API BackupEventLogA(HANDLE hEventLog,
805 LPCSTR lpBackupFileName)
806{
807 dprintf(("ADVAPI32: BackupEventLogA(%08xh,%s) not implemented.\n",
808 hEventLog,
809 lpBackupFileName));
810
811 return (FALSE); /* signal failure */
812}
813
814
815/*****************************************************************************
816 * Name : BackupEventLogW
817 * Purpose : The BackupEventLog function saves the specified event log to a
818 * backup file. The function does not clear the event log.
819 * Parameters: HANDLE hEventLog handle to event log
820 * LPCWSTR lpBackupFileName name of backup file
821 * Variables :
822 * Result :
823 * Remark :
824 * Status : UNTESTED STUB
825 *
826 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
827 *****************************************************************************/
828
829BOOL WIN32API BackupEventLogW(HANDLE hEventLog,
830 LPCWSTR lpBackupFileName)
831{
832 dprintf(("ADVAPI32: BackupEventLogW() not implemented.\n",
833 hEventLog,
834 lpBackupFileName));
835
836 return (FALSE); /* signal failure */
837}
838
839
840/*****************************************************************************
841 * Name : ChangeServiceConfigA
842 * Purpose : The ChangeServiceConfig function changes the configuration
843 * parameters of a service.
844 * Parameters: SC_HANDLE hService handle of service
845 * DWORD dwServiceType type of service
846 * DWORD dwStartType when to start service
847 * DWORD dwErrorControl severity if service fails to start
848 * LPCSTR lpBinaryPathName address of service binary file name
849 * LPCSTR lpLoadOrderGroup address of load ordering group name
850 * LPDWORD lpdwTagId address of variable to get tag identifier
851 * LPCSTR lpDependencies address of array of dependency names
852 * LPCSTR lpServiceStartName address of account name of service
853 * LPCSTR lpPassword address of password for service account
854 * LPCSTR lpDisplayName address of display name
855 * Variables :
856 * Result :
857 * Remark :
858 * Status : UNTESTED STUB
859 *
860 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
861 *****************************************************************************/
862
863#define SC_HANDLE HANDLE
864BOOL WIN32API ChangeServiceConfigA(SC_HANDLE hService,
865 DWORD dwServiceType,
866 DWORD dwStartType,
867 DWORD dwErrorControl,
868 LPCSTR lpBinaryPathName,
869 LPCSTR lpLoadOrderGroup,
870 LPDWORD lpdwTagId,
871 LPCSTR lpDependencies,
872 LPCSTR lpServiceStartName,
873 LPCSTR lpPassword,
874 LPCSTR lpDisplayName)
875{
876 dprintf(("ADVAPI32: ChangeServiceConfigA(%08xh,%08xh,%08xh,%08xh,%s,%s,%08xh,%s,%s,%s,%s) not implemented.\n",
877 hService,
878 dwServiceType,
879 dwStartType,
880 dwErrorControl,
881 lpBinaryPathName,
882 lpLoadOrderGroup,
883 lpdwTagId,
884 lpDependencies,
885 lpServiceStartName,
886 lpPassword,
887 lpDisplayName));
888
889 return (FALSE); /* signal failure */
890}
891
892
893/*****************************************************************************
894 * Name : ChangeServiceConfigW
895 * Purpose : The ChangeServiceConfig function changes the configuration
896 * parameters of a service.
897 * Parameters: SC_HANDLE hService handle of service
898 * DWORD dwServiceType type of service
899 * DWORD dwStartType when to start service
900 * DWORD dwErrorControl severity if service fails to start
901 * LPCWSTR lpBinaryPathName address of service binary file name
902 * LPCWSTR lpLoadOrderGroup address of load ordering group name
903 * LPDWORD lpdwTagId address of variable to get tag identifier
904 * LPCWSTR lpDependencies address of array of dependency names
905 * LPCWSTR lpServiceStartName address of account name of service
906 * LPCWSTR lpPassword address of password for service account
907 * LPCWSTR lpDisplayName address of display name
908 * Variables :
909 * Result :
910 * Remark :
911 * Status : UNTESTED STUB
912 *
913 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
914 *****************************************************************************/
915
916BOOL WIN32API ChangeServiceConfigW(SC_HANDLE hService,
917 DWORD dwServiceType,
918 DWORD dwStartType,
919 DWORD dwErrorControl,
920 LPCWSTR lpBinaryPathName,
921 LPCWSTR lpLoadOrderGroup,
922 LPDWORD lpdwTagId,
923 LPCWSTR lpDependencies,
924 LPCWSTR lpServiceStartName,
925 LPCWSTR lpPassword,
926 LPCWSTR lpDisplayName)
927{
928 dprintf(("ADVAPI32: ChangeServiceConfigW(%08xh,%08xh,%08xh,%08xh,%s,%s,%08xh,%s,%s,%s,%s) not implemented.\n",
929 hService,
930 dwServiceType,
931 dwStartType,
932 dwErrorControl,
933 lpBinaryPathName,
934 lpLoadOrderGroup,
935 lpdwTagId,
936 lpDependencies,
937 lpServiceStartName,
938 lpPassword,
939 lpDisplayName));
940
941 return (FALSE); /* signal failure */
942}
943
944
945/*****************************************************************************
946 * Name : ClearEventLogA
947 * Purpose : The ClearEventLog function clears the specified event log, and
948 * optionally saves the current copy of the logfile to a backup file.
949 * Parameters: HANDLE hEventLog handle to event log
950 * LPCSTR lpBackupFileName name of backup file
951 * Variables :
952 * Result :
953 * Remark :
954 * Status : UNTESTED STUB
955 *
956 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
957 *****************************************************************************/
958
959BOOL WIN32API ClearEventLogA(HANDLE hEventLog,
960 LPCSTR lpBackupFileName)
961{
962 dprintf(("ADVAPI32: ClearEventLogA(%08xh,%s) not implemented.\n",
963 hEventLog,
964 lpBackupFileName));
965
966 return (FALSE); /* signal failure */
967}
968
969
970/*****************************************************************************
971 * Name : ClearEventLogW
972 * Purpose : The ClearEventLog function clears the specified event log, and
973 * optionally saves the current copy of the logfile to a backup file.
974 * Parameters: HANDLE hEventLog handle to event log
975 * LPCSTR lpBackupFileName name of backup file
976 * Variables :
977 * Result :
978 * Remark :
979 * Status : UNTESTED STUB
980 *
981 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
982 *****************************************************************************/
983
984BOOL WIN32API ClearEventLogW(HANDLE hEventLog,
985 LPCWSTR lpBackupFileName)
986{
987 dprintf(("ADVAPI32: ClearEventLogW(%08xh,%s) not implemented.\n",
988 hEventLog,
989 lpBackupFileName));
990
991 return (FALSE); /* signal failure */
992}
993
994
995/*****************************************************************************
996 * Name : CloseEventLog
997 * Purpose : The CloseEventLog function closes the specified event log.
998 * Parameters: HANDLE hEventLog handle to event log
999 * Variables :
1000 * Result :
1001 * Remark :
1002 * Status : UNTESTED STUB
1003 *
1004 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1005 *****************************************************************************/
1006
1007BOOL WIN32API CloseEventLog(HANDLE hEventLog)
1008{
1009 dprintf(("ADVAPI32: CloseEventLog(%08xh) not implemented.\n",
1010 hEventLog));
1011
1012 return (FALSE); /* signal failure */
1013}
1014
1015
1016/*****************************************************************************
1017 * Name : CloseServiceHandle
1018 * Purpose : The CloseServiceHandle function closes a handle to a service
1019 * control manager database as returned by the OpenSCManager function,
1020 * or it closes a handle to a service object as returned by either
1021 * the OpenService or CreateService function.
1022 * Parameters: SC_HANDLE hSCObject handle of service or service control manager database
1023 * Variables :
1024 * Result :
1025 * Remark :
1026 * Status : UNTESTED STUB
1027 *
1028 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1029 *****************************************************************************/
1030
1031BOOL WIN32API CloseServiceHandle(SC_HANDLE hSCObject)
1032{
1033 dprintf(("ADVAPI32: CloseServiceHandle(%08xh) not implemented.\n",
1034 hSCObject));
1035
1036 return (FALSE); /* signal failure */
1037}
1038
1039
1040/*****************************************************************************
1041 * Name : ControlService
1042 * Purpose : The ControlService function sends a control code to a Win32 service.
1043 * Parameters: SC_HANDLE hService handle of service
1044 * DWORD dwControl control code
1045 * LPSERVICE_STATUS lpServiceStatus address of service status structure
1046 * Variables :
1047 * Result :
1048 * Remark :
1049 * Status : UNTESTED STUB
1050 *
1051 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1052 *****************************************************************************/
1053
1054BOOL WIN32API ControlService(SC_HANDLE hService,
1055 DWORD dwControl,
1056 LPSERVICE_STATUS lpServiceStatus)
1057{
1058 dprintf(("ADVAPI32: ControlService(%08xh,%08xh,%08xh) not implemented.\n",
1059 hService,
1060 dwControl,
1061 lpServiceStatus));
1062
1063 return (FALSE); /* signal failure */
1064}
1065
1066
1067/*****************************************************************************
1068 * Name : CopySid
1069 * Purpose : The CopySid function copies a security identifier (SID) to a buffer.
1070 * Parameters: DWORD nDestinationSidLength size of buffer for copied SID
1071 * PSID pDestinationSid address of buffer for copied SID
1072 * PSID pSourceSid address of source SID
1073 * Variables :
1074 * Result :
1075 * Remark :
1076 * Status : UNTESTED STUB
1077 *
1078 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1079 *****************************************************************************/
1080
1081BOOL WIN32API CopySid(DWORD nDestinationSidLength,
1082 PSID pDestinationSid,
1083 PSID pSourceSid)
1084{
1085 dprintf(("ADVAPI32: CopySid(%08xh,%08xh,%08xh)\n",
1086 nDestinationSidLength,
1087 pDestinationSid,
1088 pSourceSid));
1089
1090 memcpy((LPVOID)pDestinationSid, /* that's all :) */
1091 (LPVOID)pSourceSid,
1092 nDestinationSidLength);
1093
1094 return (TRUE);
1095}
1096
1097
1098/*****************************************************************************
1099 * Name : CreatePrivateObjectSecurity
1100 * Purpose : The CreatePrivateObjectSecurity function allocates and initializes
1101 * a self-relative security descriptor for a new protected server's
1102 * object. This function is called when a new protected server object is being created.
1103 * Parameters: PSECURITY_DESCRIPTOR ParentDescriptor address of parent directory SD
1104 * PSECURITY_DESCRIPTOR CreatorDescriptor address of creator SD
1105 * PSECURITY_DESCRIPTOR *NewDescriptor address of pointer to new SD
1106 * BOOL IsDirectoryObject container flag for new SD
1107 * HANDLE Token handle of client's access token
1108 * PGENERIC_MAPPING GenericMapping address of access-rights structure
1109 * Variables :
1110 * Result :
1111 * Remark :
1112 * Status : UNTESTED STUB
1113 *
1114 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1115 *****************************************************************************/
1116
1117BOOL WIN32API CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR ParentDescriptor,
1118 PSECURITY_DESCRIPTOR CreatorDescriptor,
1119 PSECURITY_DESCRIPTOR *NewDescriptor,
1120 BOOL IsDirectoryObject,
1121 HANDLE Token,
1122 PGENERIC_MAPPING GenericMapping)
1123{
1124 dprintf(("ADVAPI32: CreatePrivateObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1125 ParentDescriptor,
1126 CreatorDescriptor,
1127 NewDescriptor,
1128 IsDirectoryObject,
1129 Token,
1130 GenericMapping));
1131
1132 return (FALSE); /* signal failure */
1133}
1134
1135
1136/*****************************************************************************
1137 * Name : CreateProcessAsUserA
1138 * Purpose : The CreateProcessAsUser function creates a new process and its
1139 * primary thread. The new process then executes a specified executable
1140 * file. The CreateProcessAsUser function behaves just like the
1141 * CreateProcess function, with one important difference: the
1142 * created process runs in a context in which the system sees the
1143 * user represented by the hToken parameter as if that user had
1144 * logged on to the system and then called the CreateProcess function.
1145 * Parameters: HANDLE hToken handle to a token that represents a logged-on user
1146 * LPCSTR lpApplicationName pointer to name of executable module
1147 * LPTSTR lpCommandLine pointer to command line string
1148 * LPSECURITY_ATTRIBUTES lpProcessAttributes pointer to process security attributes
1149 * LPSECURITY_ATTRIBUTES lpThreadAttributes pointer to thread security attributes
1150 * BOOL bInheritHandles new process inherits handles
1151 * DWORD dwCreationFlags creation flags
1152 * LPVOID lpEnvironment pointer to new environment block
1153 * LPCSTR lpCurrentDirectory pointer to current directory name
1154 * LPSTARTUPINFO lpStartupInfo pointer to STARTUPINFO
1155 * LPPROCESS_INFORMATION lpProcessInformation pointer to PROCESS_INFORMATION
1156 * Variables :
1157 * Result :
1158 * Remark :
1159 * Status : UNTESTED STUB
1160 *
1161 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1162 *****************************************************************************/
1163
1164BOOL WIN32API CreateProcessAsUserA(HANDLE hToken,
1165 LPCSTR lpApplicationName,
1166 LPTSTR lpCommandLine,
1167 LPSECURITY_ATTRIBUTES lpProcessAttributes,
1168 LPSECURITY_ATTRIBUTES lpThreadAttributes,
1169 BOOL bInheritHandles,
1170 DWORD dwCreationFlags,
1171 LPVOID lpEnvironment,
1172 LPCSTR lpCurrentDirectory,
1173 LPSTARTUPINFOA lpStartupInfo,
1174 LPPROCESS_INFORMATION lpProcessInformation)
1175{
1176 dprintf(("ADVAPI32: CreateProcessAsUserA(%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%s,%08xh,%08xh) not implemented.\n",
1177 hToken,
1178 lpApplicationName,
1179 lpCommandLine,
1180 lpProcessAttributes,
1181 lpThreadAttributes,
1182 bInheritHandles,
1183 dwCreationFlags,
1184 lpEnvironment,
1185 lpCurrentDirectory,
1186 lpStartupInfo,
1187 lpProcessInformation));
1188
1189 return (FALSE); /* signal failure */
1190}
1191
1192
1193/*****************************************************************************
1194 * Name : CreateProcessAsUserW
1195 * Purpose : The CreateProcessAsUser function creates a new process and its
1196 * primary thread. The new process then executes a specified executable
1197 * file. The CreateProcessAsUser function behaves just like the
1198 * CreateProcess function, with one important difference: the
1199 * created process runs in a context in which the system sees the
1200 * user represented by the hToken parameter as if that user had
1201 * logged on to the system and then called the CreateProcess function.
1202 * Parameters: HANDLE hToken handle to a token that represents a logged-on user
1203 * LPCWSTR lpApplicationName pointer to name of executable module
1204 * LPWSTR lpCommandLine pointer to command line string
1205 * LPSECURITY_ATTRIBUTES lpProcessAttributes pointer to process security attributes
1206 * LPSECURITY_ATTRIBUTES lpThreadAttributes pointer to thread security attributes
1207 * BOOL bInheritHandles new process inherits handles
1208 * DWORD dwCreationFlags creation flags
1209 * LPVOID lpEnvironment pointer to new environment block
1210 * LPCWSTR lpCurrentDirectory pointer to current directory name
1211 * LPSTARTUPINFO lpStartupInfo pointer to STARTUPINFO
1212 * LPPROCESS_INFORMATION lpProcessInformation pointer to PROCESS_INFORMATION
1213 * Variables :
1214 * Result :
1215 * Remark :
1216 * Status : UNTESTED STUB
1217 *
1218 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1219 *****************************************************************************/
1220
1221BOOL WIN32API CreateProcessAsUserW(HANDLE hToken,
1222 LPCWSTR lpApplicationName,
1223 LPWSTR lpCommandLine,
1224 LPSECURITY_ATTRIBUTES lpProcessAttributes,
1225 LPSECURITY_ATTRIBUTES lpThreadAttributes,
1226 BOOL bInheritHandles,
1227 DWORD dwCreationFlags,
1228 LPVOID lpEnvironment,
1229 LPCWSTR lpCurrentDirectory,
1230 LPSTARTUPINFOA lpStartupInfo,
1231 LPPROCESS_INFORMATION lpProcessInformation)
1232{
1233 dprintf(("ADVAPI32: CreateProcessAsUserW(%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%s,%08xh,%08xh) not implemented.\n",
1234 hToken,
1235 lpApplicationName,
1236 lpCommandLine,
1237 lpProcessAttributes,
1238 lpThreadAttributes,
1239 bInheritHandles,
1240 dwCreationFlags,
1241 lpEnvironment,
1242 lpCurrentDirectory,
1243 lpStartupInfo,
1244 lpProcessInformation));
1245
1246 return (FALSE); /* signal failure */
1247}
1248
1249
1250/*****************************************************************************
1251 * Name : CreateServiceA
1252 * Purpose : The CreateService function creates a service object and adds it
1253 * to the specified service control manager database.
1254 * Parameters: SC_HANDLE hSCManager handle of service control manager database
1255 * LPCSTR lpServiceName address of name of service to start
1256 * LPCSTR lpDisplayName address of display name
1257 * DWORD dwDesiredAccess type of access to service
1258 * DWORD dwServiceType type of service
1259 * DWORD dwStartType when to start service
1260 * DWORD dwErrorControl severity if service fails to start
1261 * LPCSTR lpBinaryPathName address of name of binary file
1262 * LPCSTR lpLoadOrderGroup address of name of load ordering group
1263 * LPDWORD lpdwTagId address of variable to get tag identifier
1264 * LPCSTR lpDependencies address of array of dependency names
1265 * LPCSTR lpServiceStartName address of account name of service
1266 * LPCSTR lpPassword address of password for service account
1267 * Variables :
1268 * Result :
1269 * Remark :
1270 * Status : UNTESTED STUB
1271 *
1272 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1273 *****************************************************************************/
1274
1275SC_HANDLE WIN32API CreateServiceA(SC_HANDLE hSCManager,
1276 LPCSTR lpServiceName,
1277 LPCSTR lpDisplayName,
1278 DWORD dwDesiredAccess,
1279 DWORD dwServiceType,
1280 DWORD dwStartType,
1281 DWORD dwErrorControl,
1282 LPCSTR lpBinaryPathName,
1283 LPCSTR lpLoadOrderGroup,
1284 LPDWORD lpdwTagId,
1285 LPCSTR lpDependencies,
1286 LPCSTR lpServiceStartName,
1287 LPCSTR lpPassword)
1288{
1289 dprintf(("ADVAPI32: CreateServiceA(%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%s,%s,%08xh,%s,%s,%s) not implemented.\n",
1290 hSCManager,
1291 lpServiceName,
1292 lpDisplayName,
1293 dwDesiredAccess,
1294 dwServiceType,
1295 dwStartType,
1296 dwErrorControl,
1297 lpBinaryPathName,
1298 lpLoadOrderGroup,
1299 lpdwTagId,
1300 lpDependencies,
1301 lpServiceStartName,
1302 lpPassword));
1303
1304 return (NULL); /* signal failure */
1305}
1306
1307
1308/*****************************************************************************
1309 * Name : CreateServiceW
1310 * Purpose : The CreateService function creates a service object and adds it
1311 * to the specified service control manager database.
1312 * Parameters: SC_HANDLE hSCManager handle of service control manager database
1313 * LPCWSTR lpServiceName address of name of service to start
1314 * LPCWSTR lpDisplayName address of display name
1315 * DWORD dwDesiredAccess type of access to service
1316 * DWORD dwServiceType type of service
1317 * DWORD dwStartType when to start service
1318 * DWORD dwErrorControl severity if service fails to start
1319 * LPCWSTR lpBinaryPathName address of name of binary file
1320 * LPCWSTR lpLoadOrderGroup address of name of load ordering group
1321 * LPDWORD lpdwTagId address of variable to get tag identifier
1322 * LPCWSTR lpDependencies address of array of dependency names
1323 * LPCWSTR lpServiceStartName address of account name of service
1324 * LPCWSTR lpPassword address of password for service account
1325 * Variables :
1326 * Result :
1327 * Remark :
1328 * Status : UNTESTED STUB
1329 *
1330 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1331 *****************************************************************************/
1332
1333SC_HANDLE WIN32API CreateServiceW(SC_HANDLE hSCManager,
1334 LPCWSTR lpServiceName,
1335 LPCWSTR lpDisplayName,
1336 DWORD dwDesiredAccess,
1337 DWORD dwServiceType,
1338 DWORD dwStartType,
1339 DWORD dwErrorControl,
1340 LPCWSTR lpBinaryPathName,
1341 LPCWSTR lpLoadOrderGroup,
1342 LPDWORD lpdwTagId,
1343 LPCWSTR lpDependencies,
1344 LPCWSTR lpServiceStartName,
1345 LPCWSTR lpPassword)
1346{
1347 dprintf(("ADVAPI32: CreateServiceW(%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%s,%s,%08xh,%s,%s,%s) not implemented.\n",
1348 hSCManager,
1349 lpServiceName,
1350 lpDisplayName,
1351 dwDesiredAccess,
1352 dwServiceType,
1353 dwStartType,
1354 dwErrorControl,
1355 lpBinaryPathName,
1356 lpLoadOrderGroup,
1357 lpdwTagId,
1358 lpDependencies,
1359 lpServiceStartName,
1360 lpPassword));
1361
1362 return (NULL); /* signal failure */
1363}
1364
1365
1366/*****************************************************************************
1367 * Name : DeleteAce
1368 * Purpose : The DeleteAce function deletes an ACE from an ACL.
1369 * An ACE is an access-control entry. An ACL is an access-control list.
1370 * Parameters: PACL pAcl address of access-control list
1371 * DWORD dwAceIndex index of ACE position in ACL
1372 * Variables :
1373 * Result :
1374 * Remark :
1375 * Status : UNTESTED STUB
1376 *
1377 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1378 *****************************************************************************/
1379
1380BOOL WIN32API DeleteAce(PACL pAcl,
1381 DWORD dwAceIndex)
1382{
1383 dprintf(("ADVAPI32: DeleteAce(%08xh, %08xh) not implemented.\n",
1384 pAcl,
1385 dwAceIndex));
1386
1387 return (FALSE); /* signal failure */
1388}
1389
1390
1391/*****************************************************************************
1392 * Name : DeleteService
1393 * Purpose : The DeleteService function marks the specified service for
1394 * deletion from the service control manager database.
1395 * Parameters: SC_HANDLE hService handle of service
1396 * Variables :
1397 * Result :
1398 * Remark :
1399 * Status : UNTESTED STUB
1400 *
1401 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1402 *****************************************************************************/
1403
1404BOOL WIN32API DeleteService(SC_HANDLE hService)
1405{
1406 dprintf(("ADVAPI32: DeleteService(%08xh) not implemented.\n",
1407 hService));
1408
1409 return (FALSE); /* signal failure */
1410}
1411
1412
1413/*****************************************************************************
1414 * Name : DestroyPrivateObjectSecurity
1415 * Purpose : The DestroyPrivateObjectSecurity function deletes a protected
1416 * server object's security descriptor. This security descriptor
1417 * must have been created by a call to the CreatePrivateObjectSecurity function.
1418 * Parameters: PSECURITY_DESCRIPTOR * ObjectDescriptor address of pointer to SECURITY_DESCRIPTOR
1419 * Variables :
1420 * Result :
1421 * Remark :
1422 * Status : UNTESTED STUB
1423 *
1424 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1425 *****************************************************************************/
1426
1427BOOL WIN32API DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR *ObjectDescriptor)
1428{
1429 dprintf(("ADVAPI32: DestroyPrivateObjectSecurity(%08xh) not implemented.\n",
1430 ObjectDescriptor));
1431
1432 return (FALSE); /* signal failure */
1433}
1434
1435
1436/*****************************************************************************
1437 * Name : DuplicateToken
1438 * Purpose : The DuplicateToken function creates a new access token that
1439 * duplicates one already in existence.
1440 * Parameters: HANDLE ExistingTokenHandle handle of token to duplicate
1441 * SECURITY_IMPERSONATION_LEVEL ImpersonationLevel impersonation level
1442 * PHANDLE DuplicateTokenHandle handle of duplicated token
1443 * Variables :
1444 * Result :
1445 * Remark :
1446 * Status : UNTESTED STUB
1447 *
1448 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1449 *****************************************************************************/
1450
1451BOOL WIN32API DuplicateToken(HANDLE ExistingTokenHandle,
1452 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
1453 PHANDLE DuplicateTokenHandle)
1454{
1455 dprintf(("ADVAPI32: DuplicateToken(%08x,%08xh,%08xh) not implemented.\n",
1456 ExistingTokenHandle,
1457 ImpersonationLevel,
1458 DuplicateTokenHandle));
1459
1460 return (FALSE); /* signal failure */
1461}
1462
1463
1464/*****************************************************************************
1465 * Name : EnumDependentServicesA
1466 * Purpose : The EnumDependentServices function enumerates services that
1467 * depend on another specified service; that is, the specified
1468 * service must be running before the enumerated services can run.
1469 * The name and status of each dependent service are provided.
1470 * Parameters: SC_HANDLE hService handle of service
1471 * DWORD dwServiceState state of services to enumerate
1472 * LPENUM_SERVICE_STATUS lpServices address of service status buffer
1473 * DWORD cbBufSize size of service status buffer
1474 * LPDWORD pcbBytesNeeded address of variable for bytes needed
1475 * LPDWORD lpServicesReturned address of variable for number returned
1476 * Variables :
1477 * Result :
1478 * Remark :
1479 * Status : UNTESTED STUB
1480 *
1481 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1482 *****************************************************************************/
1483
1484#define LPENUM_SERVICE_STATUS LPVOID
1485BOOL WIN32API EnumDependentServicesA(SC_HANDLE hService,
1486 DWORD dwServiceState,
1487 LPENUM_SERVICE_STATUS lpServices,
1488 DWORD cbBufSize,
1489 LPDWORD pcbBytesNeeded,
1490 LPDWORD lpServicesReturned)
1491{
1492 dprintf(("ADVAPI32: EnumDependentServicesA(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1493 hService,
1494 dwServiceState,
1495 lpServices,
1496 cbBufSize,
1497 pcbBytesNeeded,
1498 lpServicesReturned));
1499
1500 return (FALSE); /* signal failure */
1501}
1502
1503
1504/*****************************************************************************
1505 * Name : EnumDependentServicesW
1506 * Purpose : The EnumDependentServices function enumerates services that
1507 * depend on another specified service; that is, the specified
1508 * service must be running before the enumerated services can run.
1509 * The name and status of each dependent service are provided.
1510 * Parameters: SC_HANDLE hService handle of service
1511 * DWORD dwServiceState state of services to enumerate
1512 * LPENUM_SERVICE_STATUS lpServices address of service status buffer
1513 * DWORD cbBufSize size of service status buffer
1514 * LPDWORD pcbBytesNeeded address of variable for bytes needed
1515 * LPDWORD lpServicesReturned address of variable for number returned
1516 * Variables :
1517 * Result :
1518 * Remark :
1519 * Status : UNTESTED STUB
1520 *
1521 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1522 *****************************************************************************/
1523
1524BOOL WIN32API EnumDependentServicesW(SC_HANDLE hService,
1525 DWORD dwServiceState,
1526 LPENUM_SERVICE_STATUS lpServices,
1527 DWORD cbBufSize,
1528 LPDWORD pcbBytesNeeded,
1529 LPDWORD lpServicesReturned)
1530{
1531 dprintf(("ADVAPI32: EnumDependentServicesW(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1532 hService,
1533 dwServiceState,
1534 lpServices,
1535 cbBufSize,
1536 pcbBytesNeeded,
1537 lpServicesReturned));
1538
1539 return (FALSE); /* signal failure */
1540}
1541
1542
1543/*****************************************************************************
1544 * Name : EnumServicesStatusA
1545 * Purpose : The EnumServicesStatus function enumerates services in the specified
1546 * service control manager database. The name and status of each service are provided.
1547 * Parameters: SC_HANDLE hSCManager handle of service control manager database
1548 * DWORD dwServiceType type of services to enumerate
1549 * DWORD dwServiceState state of services to enumerate
1550 * LPENUM_SERVICE_STATUS lpServices address of service status buffer
1551 * DWORD cbBufSize size of service status buffer
1552 * LPDWORD pcbBytesNeeded address of variable for bytes needed
1553 * LPDWORD lpServicesReturned address of variable for number returned
1554 * LPDWORD lpResumeHandle address of variable for next entry
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 EnumServicesStatusA(SC_HANDLE hSCManager,
1564 DWORD dwServiceType,
1565 DWORD dwServiceState,
1566 LPENUM_SERVICE_STATUS lpServices,
1567 DWORD cbBufSize,
1568 LPDWORD pcbBytesNeeded,
1569 LPDWORD lpServicesReturned,
1570 LPDWORD lpResumeHandle)
1571{
1572 dprintf(("ADVAPI32: EnumServicesStatusA(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1573 hSCManager,
1574 dwServiceType,
1575 dwServiceState,
1576 lpServices,
1577 cbBufSize,
1578 pcbBytesNeeded,
1579 lpServicesReturned,
1580 lpResumeHandle));
1581
1582 return (FALSE); /* signal failure */
1583}
1584
1585
1586/*****************************************************************************
1587 * Name : EnumServicesStatusW
1588 * Purpose : The EnumServicesStatus function enumerates services in the specified
1589 * service control manager database. The name and status of each service are provided.
1590 * Parameters: SC_HANDLE hSCManager handle of service control manager database
1591 * DWORD dwServiceType type of services to enumerate
1592 * DWORD dwServiceState state of services to enumerate
1593 * LPENUM_SERVICE_STATUS lpServices address of service status buffer
1594 * DWORD cbBufSize size of service status buffer
1595 * LPDWORD pcbBytesNeeded address of variable for bytes needed
1596 * LPDWORD lpServicesReturned address of variable for number returned
1597 * LPDWORD lpResumeHandle address of variable for next entry
1598 * Variables :
1599 * Result :
1600 * Remark :
1601 * Status : UNTESTED STUB
1602 *
1603 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1604 *****************************************************************************/
1605
1606BOOL WIN32API EnumServicesStatusW(SC_HANDLE hSCManager,
1607 DWORD dwServiceType,
1608 DWORD dwServiceState,
1609 LPENUM_SERVICE_STATUS lpServices,
1610 DWORD cbBufSize,
1611 LPDWORD pcbBytesNeeded,
1612 LPDWORD lpServicesReturned,
1613 LPDWORD lpResumeHandle)
1614{
1615 dprintf(("ADVAPI32: EnumServicesStatusW(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1616 hSCManager,
1617 dwServiceType,
1618 dwServiceState,
1619 lpServices,
1620 cbBufSize,
1621 pcbBytesNeeded,
1622 lpServicesReturned,
1623 lpResumeHandle));
1624
1625 return (FALSE); /* signal failure */
1626}
1627
1628
1629/*****************************************************************************
1630 * Name : EqualPrefixSid
1631 * Purpose : The EqualPrefixSid function tests two security-identifier (SID)
1632 * prefix values for equality. An SID prefix is the entire SID except
1633 * for the last subauthority value.
1634 * Parameters: PSID pSid1 address of first SID to compare
1635 * PSID pSid2 address of second SID to compare
1636 * Variables :
1637 * Result :
1638 * Remark :
1639 * Status : UNTESTED STUB
1640 *
1641 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1642 *****************************************************************************/
1643
1644BOOL WIN32API EqualPrefixSid(PSID pSid1,
1645 PSID pSid2)
1646{
1647 dprintf(("ADVAPI32: EqualPrefixSid(%08xh,%08xh) not correctly implemented.\n",
1648 pSid1,
1649 pSid2));
1650
1651 return ( lstrcmpA( (LPCSTR)pSid1,
1652 (LPCSTR)pSid2) == 0 ); /* @@@PH roughly ... :) */
1653}
1654
1655
1656/*****************************************************************************
1657 * Name : EqualSid
1658 * Purpose : The EqualSid function tests two security identifier (SID) values
1659 * for equality. Two SIDs must match exactly to be considered equal.
1660 * Parameters: PSID pSid1 address of first SID to compare
1661 * PSID pSid2 address of second SID to compare
1662 * Variables :
1663 * Result :
1664 * Remark :
1665 * Status : UNTESTED STUB
1666 *
1667 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1668 *****************************************************************************/
1669
1670BOOL WIN32API EqualSid(PSID pSid1,
1671 PSID pSid2)
1672{
1673 dprintf(("ADVAPI32: EqualSid(%08xh, %08xh) not correctly implemented.\n",
1674 pSid1,
1675 pSid2));
1676
1677 return ( lstrcmpA( (LPCSTR)pSid1,
1678 (LPCSTR)pSid2) == 0 ); /* @@@PH roughly ... :) */
1679}
1680
1681
1682/*****************************************************************************
1683 * Name : FindFirstFreeAce
1684 * Purpose : The FindFirstFreeAce function retrieves a pointer to the first
1685 * free byte in an access-control list (ACL).
1686 * Parameters: PACL pAcl address of access-control list
1687 * LPVOID *pAce address of pointer to first free byte
1688 * Variables :
1689 * Result :
1690 * Remark :
1691 * Status : UNTESTED STUB
1692 *
1693 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1694 *****************************************************************************/
1695
1696BOOL WIN32API FindFirstFreeAce(PACL pAcl,
1697 LPVOID *pAce)
1698{
1699 dprintf(("ADVAPI32: FindFirstFreeAce(%08xh, %08xh) not implemented.\n",
1700 pAcl,
1701 pAce));
1702
1703 return (FALSE); /* signal failure */
1704}
1705
1706
1707/*****************************************************************************
1708 * Name : FreeSid
1709 * Purpose : The FreeSid function frees a security identifier (SID) previously
1710 * allocated by using the AllocateAndInitializeSid function.
1711 * Parameters: PSID pSid address of SID to free
1712 * Variables :
1713 * Result :
1714 * Remark :
1715 * Status : UNTESTED STUB
1716 *
1717 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1718 *****************************************************************************/
1719
1720PVOID WIN32API FreeSid(PSID pSid)
1721{
1722 dprintf(("ADVAPI32: FreeSid(%08xh) not implemented.\n",
1723 pSid));
1724 return NULL;
1725}
1726
1727
1728/*****************************************************************************
1729 * Name : GetAce
1730 * Purpose : The GetAce function obtains a pointer to an ACE in an ACL.
1731 * An ACE is an access control entry. An ACL is an access control list.
1732 * Parameters: PACL pAcl address of access-control list
1733 * DWORD dwAceIndex index of ACE to retrieve
1734 * LPVOID *pAce address of pointer to ACE
1735 * Variables :
1736 * Result :
1737 * Remark :
1738 * Status : UNTESTED STUB
1739 *
1740 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1741 *****************************************************************************/
1742
1743BOOL WIN32API GetAce(PACL pAcl,
1744 DWORD dwAceIndex,
1745 LPVOID *pAce)
1746{
1747 dprintf(("ADVAPI32: GetAce(%08xh,%08xh,%08xh) not implemented.\n",
1748 pAcl,
1749 dwAceIndex,
1750 pAce));
1751
1752 return (FALSE); /* signal failure */
1753}
1754
1755
1756/*****************************************************************************
1757 * Name : GetAclInformation
1758 * Purpose : The GetAclInformation function retrieves information about an
1759 * access-control list (ACL).
1760 * Parameters: PACL pAcl address of access-control list
1761 * LPVOID pAclInformation address of ACL information
1762 * DWORD nAclInformationLength size of ACL information
1763 * ACL_INFORMATION_CLASS dwAclInformationClass class of requested information
1764 * Variables :
1765 * Result :
1766 * Remark :
1767 * Status : UNTESTED STUB
1768 *
1769 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1770 *****************************************************************************/
1771
1772#define ACL_INFORMATION_CLASS DWORD
1773BOOL WIN32API GetAclInformation(PACL pAcl,
1774 LPVOID pAclInformation,
1775 DWORD nAclInformationLength,
1776 ACL_INFORMATION_CLASS dwAclInformationClass)
1777{
1778 dprintf(("ADVAPI32: GetAclInformation(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1779 pAcl,
1780 pAclInformation,
1781 nAclInformationLength,
1782 dwAclInformationClass));
1783
1784 return (FALSE); /* signal failure */
1785}
1786
1787
1788/*****************************************************************************
1789 * Name : GetKernelObjectSecurity
1790 * Purpose : The GetKernelObjectSecurity function retrieves a copy of the
1791 * security descriptor protecting a kernel object.
1792 * Parameters: HANDLE Handle handle of object to query
1793 * SECURITY_INFORMATION RequestedInformation requested information
1794 * PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
1795 * DWORD nLength size of buffer for security descriptor
1796 * LPDWORD lpnLengthNeeded address of required size of buffer
1797 * Variables :
1798 * Result :
1799 * Remark :
1800 * Status : UNTESTED STUB
1801 *
1802 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1803 *****************************************************************************/
1804
1805BOOL WIN32API GetKernelObjectSecurity(HANDLE Handle,
1806 SECURITY_INFORMATION RequestedInformation,
1807 PSECURITY_DESCRIPTOR pSecurityDescriptor,
1808 DWORD nLength,
1809 LPDWORD lpnLengthNeeded)
1810{
1811 dprintf(("ADVAPI32: GetKernelObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1812 Handle,
1813 RequestedInformation,
1814 pSecurityDescriptor,
1815 nLength,
1816 lpnLengthNeeded));
1817
1818 return (FALSE); /* signal failure */
1819}
1820
1821
1822/*****************************************************************************
1823 * Name : GetLengthSid
1824 * Purpose : The GetLengthSid function returns the length, in bytes, of a
1825 * valid SID structure. A SID is a security identifier.
1826 * Parameters: PSID pSid address of SID to query
1827 * Variables :
1828 * Result :
1829 * Remark :
1830 * Status : UNTESTED STUB
1831 *
1832 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1833 *****************************************************************************/
1834
1835DWORD WIN32API GetLengthSid(PSID pSid)
1836{
1837 dprintf(("ADVAPI32: GetLengthSid(%08xh) not correctly implemented.\n",
1838 pSid));
1839
1840 return (lstrlenA( (LPCSTR)pSid)); /* @@@PH might not work */
1841}
1842
1843
1844/*****************************************************************************
1845 * Name : GetNumberOfEventLogRecords
1846 * Purpose : The GetNumberOfEventLogRecords function retrieves the number of
1847 * records in the specified event log.
1848 * Parameters: HANDLE hEventLog handle to event log
1849 * LPDWORD NumberOfRecords buffer for number of records
1850 * Variables :
1851 * Result :
1852 * Remark :
1853 * Status : UNTESTED STUB
1854 *
1855 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1856 *****************************************************************************/
1857
1858BOOL WIN32API GetNumberOfEventLogRecords(HANDLE hEventLog,
1859 LPDWORD NumberOfRecords)
1860{
1861 dprintf(("ADVAPI32: GetNumberOfEventLogRecords(%08xh,%08xh) not implemented.\n",
1862 hEventLog,
1863 NumberOfRecords));
1864
1865 return (FALSE); /* signal failure */
1866}
1867
1868
1869/*****************************************************************************
1870 * Name : GetOldestEventLogRecord
1871 * Purpose : The GetOldestEventLogRecord function retrieves the absolute
1872 * record number of the oldest record in the specified event log.
1873 * Parameters: HANDLE hEventLog handle to event log
1874 * LPDWORD OldestRecord buffer for number of oldest record
1875 * Variables :
1876 * Result :
1877 * Remark :
1878 * Status : UNTESTED STUB
1879 *
1880 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1881 *****************************************************************************/
1882
1883BOOL WIN32API GetOldestEventLogRecord(HANDLE hEventLog,
1884 LPDWORD OldestRecord)
1885{
1886 dprintf(("ADVAPI32: GetOldestEventLogRecord(%08xh,%08xh) not implemented.\n",
1887 hEventLog,
1888 OldestRecord));
1889
1890 return (FALSE); /* signal failure */
1891}
1892
1893
1894/*****************************************************************************
1895 * Name : GetPrivateObjectSecurity
1896 * Purpose : The GetPrivateObjectSecurity retrieves information from a
1897 * protected server object's security descriptor.
1898 * Parameters: PSECURITY_DESCRIPTOR ObjectDescriptor address of SD to query
1899 * SECURITY_INFORMATION SecurityInformation requested information
1900 * PSECURITY_DESCRIPTOR ResultantDescriptor address of retrieved SD
1901 * DWORD DescriptorLength size of buffer for retrieved SD
1902 * LPDWORD ReturnLength address of buffer size required for SD
1903 * Variables :
1904 * Result :
1905 * Remark :
1906 * Status : UNTESTED STUB
1907 *
1908 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1909 *****************************************************************************/
1910
1911BOOL WIN32API GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR ObjectDescriptor,
1912 SECURITY_INFORMATION SecurityInformation,
1913 PSECURITY_DESCRIPTOR ResultantDescriptor,
1914 DWORD DescriptorLength,
1915 LPDWORD ReturnLength)
1916{
1917 dprintf(("ADVAPI32: GetPrivateObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1918 ObjectDescriptor,
1919 SecurityInformation,
1920 ResultantDescriptor,
1921 DescriptorLength,
1922 ReturnLength));
1923
1924 return (FALSE); /* signal failure */
1925}
1926
1927
1928/*****************************************************************************
1929 * Name : GetSecurityDescriptorControl
1930 * Purpose : The GetSecurityDescriptorControl function retrieves a security
1931 * descriptor's control and revision information.
1932 * Parameters: PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
1933 * PSECURITY_DESCRIPTOR_CONTROL pControl address of control structure
1934 * LPDWORD lpdwRevision address of revision value
1935 * Variables :
1936 * Result :
1937 * Remark :
1938 * Status : UNTESTED STUB
1939 *
1940 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1941 *****************************************************************************/
1942
1943#define PSECURITY_DESCRIPTOR_CONTROL LPVOID
1944BOOL WIN32API GetSecurityDescriptorControl(PSECURITY_DESCRIPTOR pSecurityDescriptor,
1945 PSECURITY_DESCRIPTOR_CONTROL pControl,
1946 LPDWORD lpdwRevision)
1947{
1948 dprintf(("ADVAPI32: GetSecurityDescriptorControl(%08xh,%08xh,%08xh) not implemented.\n",
1949 pSecurityDescriptor,
1950 pControl,
1951 lpdwRevision));
1952
1953 return (FALSE); /* signal failure */
1954}
1955
1956
1957/*****************************************************************************
1958 * Name : GetSecurityDescriptorDacl
1959 * Purpose : The GetSecurityDescriptorDacl function retrieves a pointer to the
1960 * discretionary access-control list (ACL) in a specified security descriptor.
1961 * Parameters: PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
1962 * LPBOOL lpbDaclPresent address of flag for presence of disc. ACL
1963 * PACL *pDacl address of pointer to ACL
1964 * LPBOOL lpbDaclDefaulted address of flag for default disc. ACL
1965 * Variables :
1966 * Result :
1967 * Remark :
1968 * Status : UNTESTED STUB
1969 *
1970 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1971 *****************************************************************************/
1972
1973BOOL WIN32API GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor,
1974 LPBOOL lpbDaclPresent,
1975 PACL *pDacl,
1976 LPBOOL lpbDaclDefaulted)
1977{
1978 dprintf(("ADVAPI32: GetSecurityDescriptorDacl(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1979 pSecurityDescriptor,
1980 lpbDaclPresent,
1981 pDacl,
1982 lpbDaclDefaulted));
1983
1984 return (FALSE); /* signal failure */
1985}
1986
1987
1988/*****************************************************************************
1989 * Name : GetSecurityDescriptorGroup
1990 * Purpose : The GetSecurityDescriptorGroup function retrieves the primary
1991 * group information from a security descriptor.
1992 * Parameters: PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
1993 * PSID *pGroup address of pointer to group security identifier (SID)
1994 * LPBOOL lpbGroupDefaulted address of flag for default
1995 * Variables :
1996 * Result :
1997 * Remark :
1998 * Status : UNTESTED STUB
1999 *
2000 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2001 *****************************************************************************/
2002
2003BOOL WIN32API GetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR pSecurityDescriptor,
2004 PSID *pGroup,
2005 LPBOOL lpbGroupDefaulted)
2006{
2007 dprintf(("ADVAPI32: GetSecurityDescriptorGroup(%08xh,%08xh,%08xh) not implemented.\n",
2008 pSecurityDescriptor,
2009 pGroup,
2010 lpbGroupDefaulted));
2011
2012 return (FALSE); /* signal failure */
2013}
2014
2015
2016/*****************************************************************************
2017 * Name : GetSecurityDescriptorLength
2018 * Purpose : The GetSecurityDescriptorLength function returns the length, in
2019 * bytes, of a structurally valid SECURITY_DESCRIPTOR structure. The
2020 * length includes the length of all associated structures, such as
2021 * SID and ACL structures.
2022 * Parameters: PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
2023 * Variables :
2024 * Result :
2025 * Remark :
2026 * Status : UNTESTED STUB
2027 *
2028 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2029 *****************************************************************************/
2030
2031#define SECURITY_DESCRIPTOR DWORD
2032DWORD WIN32API GetSecurityDescriptorLength(PSECURITY_DESCRIPTOR pSecurityDescriptor)
2033{
2034 dprintf(("ADVAPI32: GetSecurityDescriptorLength(%08xh) not correctly implemented.\n",
2035 pSecurityDescriptor));
2036
2037 return ( sizeof(SECURITY_DESCRIPTOR) );
2038}
2039
2040
2041/*****************************************************************************
2042 * Name : GetSecurityDescriptorOwner
2043 * Purpose : The GetSecurityDescriptorOwner function retrieves the owner
2044 * information from a security descriptor.
2045 * Parameters: PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
2046 * PSID *pOwner address of pointer to owner security identifier (SID)
2047 * LPBOOL lpbOwnerDefaulted address of flag for default
2048 * Variables :
2049 * Result :
2050 * Remark :
2051 * Status : UNTESTED STUB
2052 *
2053 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2054 *****************************************************************************/
2055
2056BOOL WIN32API GetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR pSecurityDescriptor,
2057 PSID *pOwner,
2058 LPBOOL lpbOwnerDefaulted)
2059{
2060 dprintf(("ADVAPI32: GetSecurityDescriptorOwner(%08xh,%08xh,%08xh) not implemented.\n",
2061 pSecurityDescriptor,
2062 pOwner,
2063 lpbOwnerDefaulted));
2064
2065 return (FALSE); /* signal failure */
2066}
2067
2068
2069/*****************************************************************************
2070 * Name : GetSecurityDescriptorSacl
2071 * Purpose : The GetSecurityDescriptorSacl function retrieves a pointer to
2072 * the system access-control list (ACL) in a specified security descriptor.
2073 * Parameters: PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
2074 * LPBOOL lpbSaclPresent address of flag for presence of system ACL
2075 * PACL *pSacl address of pointer to ACL
2076 * LPBOOL lpbSaclDefaulted address of flag for default system ACL
2077 * Variables :
2078 * Result :
2079 * Remark :
2080 * Status : UNTESTED STUB
2081 *
2082 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2083 *****************************************************************************/
2084
2085BOOL WIN32API GetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR pSecurityDescriptor,
2086 LPBOOL lpbSaclPresent,
2087 PACL *pSacl,
2088 LPBOOL lpbSaclDefaulted)
2089{
2090 dprintf(("ADVAPI32: GetSecurityDescriptorSacl(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2091 pSecurityDescriptor,
2092 lpbSaclPresent,
2093 pSacl,
2094 lpbSaclDefaulted));
2095
2096 return (FALSE); /* signal failure */
2097}
2098
2099
2100/*****************************************************************************
2101 * Name : GetServiceDisplayNameA
2102 * Purpose : The GetServiceDisplayName function obtains the display name that
2103 * is associated with a particular service name. The service name
2104 * is the same as the service's registry key name.
2105 * Parameters: SC_HANDLE hSCManager handle to a service control manager database
2106 * LPCSTR lpServiceName the service name
2107 * LPTSTR lpDisplayName buffer to receive the service's display name
2108 * LPDWORD lpcchBuffer size of display name buffer and display name
2109 * Variables :
2110 * Result :
2111 * Remark :
2112 * Status : UNTESTED STUB
2113 *
2114 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2115 *****************************************************************************/
2116
2117BOOL WIN32API GetServiceDisplayNameA(SC_HANDLE hSCManager,
2118 LPCSTR lpServiceName,
2119 LPTSTR lpDisplayName,
2120 LPDWORD lpcchBuffer)
2121{
2122 dprintf(("ADVAPI32: GetServiceDisplayNameA(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2123 hSCManager,
2124 lpServiceName,
2125 lpDisplayName,
2126 lpcchBuffer));
2127
2128 return (FALSE); /* signal failure */
2129}
2130
2131
2132/*****************************************************************************
2133 * Name : GetServiceDisplayNameW
2134 * Purpose : The GetServiceDisplayName function obtains the display name that
2135 * is associated with a particular service name. The service name
2136 * is the same as the service's registry key name.
2137 * Parameters: SC_HANDLE hSCManager handle to a service control manager database
2138 * LPCWSTR lpServiceName the service name
2139 * LPWSTR lpDisplayName buffer to receive the service's display name
2140 * LPDWORD lpcchBuffer size of display name buffer and display name
2141 * Variables :
2142 * Result :
2143 * Remark :
2144 * Status : UNTESTED STUB
2145 *
2146 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2147 *****************************************************************************/
2148
2149BOOL WIN32API GetServiceDisplayNameW(SC_HANDLE hSCManager,
2150 LPCWSTR lpServiceName,
2151 LPWSTR lpDisplayName,
2152 LPDWORD lpcchBuffer)
2153{
2154 dprintf(("ADVAPI32: GetServiceDisplayNameW(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2155 hSCManager,
2156 lpServiceName,
2157 lpDisplayName,
2158 lpcchBuffer));
2159
2160 return (FALSE); /* signal failure */
2161}
2162
2163
2164/*****************************************************************************
2165 * Name : GetServiceKeyNameA
2166 * Purpose : The GetServiceKeyName function obtains the service name that is
2167 * associated with a particular service's display name. The service
2168 * name is the same as the service's registry key name.
2169 * Parameters: SC_HANDLE hSCManager handle to a service control manager database
2170 * LPCSTR lpDisplayName the service's display name
2171 * LPTSTR lpServiceName buffer to receive the service name
2172 * LPDWORD lpcchBuffer size of service name buffer and service name
2173 * Variables :
2174 * Result :
2175 * Remark :
2176 * Status : UNTESTED STUB
2177 *
2178 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2179 *****************************************************************************/
2180
2181BOOL WIN32API GetServiceKeyNameA(SC_HANDLE hSCManager,
2182 LPCSTR lpDisplayName,
2183 LPTSTR lpServiceName,
2184 LPDWORD lpcchBuffer)
2185{
2186 dprintf(("ADVAPI32: GetServiceKeyNameA(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2187 hSCManager,
2188 lpDisplayName,
2189 lpServiceName,
2190 lpcchBuffer));
2191
2192 return (FALSE); /* signal failure */
2193}
2194
2195
2196/*****************************************************************************
2197 * Name : GetServiceKeyNameW
2198 * Purpose : The GetServiceKeyName function obtains the service name that is
2199 * associated with a particular service's display name. The service
2200 * name is the same as the service's registry key name.
2201 * Parameters: SC_HANDLE hSCManager handle to a service control manager database
2202 * LPCWSTR lpDisplayName the service's display name
2203 * LPWSTR lpServiceName buffer to receive the service name
2204 * LPDWORD lpcchBuffer size of service name buffer and service name
2205 * Variables :
2206 * Result :
2207 * Remark :
2208 * Status : UNTESTED STUB
2209 *
2210 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2211 *****************************************************************************/
2212
2213BOOL WIN32API GetServiceKeyNameW(SC_HANDLE hSCManager,
2214 LPCWSTR lpDisplayName,
2215 LPWSTR lpServiceName,
2216 LPDWORD lpcchBuffer)
2217{
2218 dprintf(("ADVAPI32: GetServiceKeyNameW(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2219 hSCManager,
2220 lpDisplayName,
2221 lpServiceName,
2222 lpcchBuffer));
2223
2224 return (FALSE); /* signal failure */
2225}
2226
2227
2228/*****************************************************************************
2229 * Name : GetSidIdentifierAuthority
2230 * Purpose : The GetSidIdentifierAuthority function returns the address of
2231 * the SID_IDENTIFIER_AUTHORITY structure in a specified security identifier (SID).
2232 * Parameters: PSID pSid address of SID to query
2233 * Variables :
2234 * Result :
2235 * Remark :
2236 * Status : UNTESTED STUB
2237 *
2238 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2239 *****************************************************************************/
2240
2241PSID_IDENTIFIER_AUTHORITY WIN32API GetSidIdentifierAuthority(PSID pSid)
2242{
2243 dprintf(("ADVAPI32: GetSidIdentifierAuthority(%08xh) not implemented.\n",
2244 pSid));
2245
2246 return (NULL); /* signal failure */
2247}
2248
2249
2250/*****************************************************************************
2251 * Name : GetSidLengthRequired
2252 * Purpose : The GetSidLengthRequired function returns the length, in bytes,
2253 * of the buffer required to store a SID structure with a specified
2254 * number of subauthorities.
2255 * Parameters: UCHAR nSubAuthorityCount count of subauthorities
2256 * Variables :
2257 * Result :
2258 * Remark :
2259 * Status : UNTESTED STUB
2260 *
2261 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2262 *****************************************************************************/
2263
2264#define SID DWORD
2265DWORD WIN32API GetSidLengthRequired(UCHAR nSubAuthorityCount)
2266{
2267 dprintf(("ADVAPI32: GetSidLengthRequired(%u) not correctly implemented.\n",
2268 nSubAuthorityCount));
2269
2270 return ( sizeof(SID) );
2271}
2272
2273
2274/*****************************************************************************
2275 * Name : GetSidSubAuthority
2276 * Purpose : The GetSidSubAuthority function returns the address of a
2277 * specified subauthority in a SID structure. The subauthority
2278 * value is a relative identifier (RID). A SID is a security identifier.
2279 * Parameters: PSID pSid address of security identifier to query
2280 * DWORD nSubAuthority index of subauthority to retrieve
2281 * Variables :
2282 * Result :
2283 * Remark :
2284 * Status : UNTESTED STUB
2285 *
2286 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2287 *****************************************************************************/
2288
2289LPDWORD WIN32API GetSidSubAuthority(PSID pSid,
2290 DWORD nSubAuthority)
2291{
2292 dprintf(("ADVAPI32: GetSidSubAuthority(%08xh,%08xh) not implemented.\n",
2293 pSid,
2294 nSubAuthority));
2295
2296 return ( (LPDWORD)pSid ); /* signal failure */
2297}
2298
2299
2300/*****************************************************************************
2301 * Name : GetSidSubAuthorityCount
2302 * Purpose : The GetSidSubAuthorityCount function returns the address of the
2303 * field in a SID structure containing the subauthority count. A
2304 * SID is a security identifier.
2305 * Parameters: PSID pSid address of security identifier to query
2306 * Variables :
2307 * Result :
2308 * Remark :
2309 * Status : UNTESTED STUB
2310 *
2311 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2312 *****************************************************************************/
2313
2314PUCHAR WIN32API GetSidSubAuthorityCount(PSID pSid)
2315{
2316 static UCHAR ucSubAuthorityCount = 1;
2317
2318 dprintf(("ADVAPI32: GetSidSubAuthorityCount(%08xh) not implemented.\n",
2319 pSid));
2320
2321 return (&ucSubAuthorityCount);
2322}
2323
2324
2325/*****************************************************************************
2326 * Name : GetTokenInformation
2327 * Purpose : The GetTokenInformation function retrieves a specified type of
2328 * information about an access token. The calling process must have
2329 * appropriate access rights to obtain the information.
2330 * Parameters: HANDLE TokenHandle handle of access token
2331 * TOKEN_INFORMATION_CLASS TokenInformationClass type of information to retrieve
2332 * LPVOID TokenInformation address of retrieved information
2333 * DWORD TokenInformationLength size of information buffer
2334 * LPDWORD ReturnLength address of required buffer size
2335 * Variables :
2336 * Result :
2337 * Remark :
2338 * Status : UNTESTED STUB
2339 *
2340 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2341 *****************************************************************************/
2342
2343BOOL WIN32API GetTokenInformation(HANDLE TokenHandle,
2344 TOKEN_INFORMATION_CLASS TokenInformationClass,
2345 LPVOID TokenInformation,
2346 DWORD TokenInformationLength,
2347 LPDWORD ReturnLength)
2348{
2349 dprintf(("ADVAPI32: GetTokenInformation(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2350 TokenHandle,
2351 TokenInformationClass,
2352 TokenInformation,
2353 TokenInformationLength,
2354 ReturnLength));
2355
2356 return (FALSE); /* signal failure */
2357}
2358
2359
2360/*****************************************************************************
2361 * Name : ImpersonateLoggedOnUser
2362 * Purpose : The ImpersonateLoggedOnUser function lets the calling thread
2363 * impersonate a user. The user is represented by a token handle
2364 * obtained by calling the LogonUser function
2365 * Parameters: HANDLE hToken
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 ImpersonateLoggedOnUser(HANDLE hToken)
2375{
2376 dprintf(("ADVAPI32: ImpersonateLoggedOnUser(%08xh) not implemented.\n",
2377 hToken));
2378
2379 return (TRUE); /* signal OK */
2380}
2381
2382
2383/*****************************************************************************
2384 * Name : ImpersonateNamedPipeClient
2385 * Purpose : The ImpersonateNamedPipeClient function impersonates a named-pipe
2386 * client application.
2387 * Parameters: HANDLE hNamedPipe handle of a named pipe
2388 * Variables :
2389 * Result :
2390 * Remark :
2391 * Status : UNTESTED STUB
2392 *
2393 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2394 *****************************************************************************/
2395
2396BOOL WIN32API ImpersonateNamedPipeClient(HANDLE hNamedPipe)
2397{
2398 dprintf(("ADVAPI32: ImpersonateNamedPipeClient(%08xh) not implemented.\n",
2399 hNamedPipe));
2400
2401 return (TRUE); /* signal OK */
2402}
2403
2404
2405/*****************************************************************************
2406 * Name : ImpersonateSelf
2407 * Purpose : The ImpersonateSelf function obtains an access token that
2408 * impersonates the security context of the calling process. The
2409 * token is assigned to the calling thread.
2410 * Parameters: SECURITY_IMPERSONATION_LEVEL ImpersonationLevel impersonation level
2411 * Variables :
2412 * Result :
2413 * Remark :
2414 * Status : UNTESTED STUB
2415 *
2416 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2417 *****************************************************************************/
2418
2419BOOL WIN32API ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
2420{
2421 dprintf(("ADVAPI32: ImpersonateSelf(%08xh) not implemented.\n",
2422 ImpersonationLevel));
2423
2424 return (TRUE); /* signal OK */
2425}
2426
2427
2428/*****************************************************************************
2429 * Name : InitializeAcl
2430 * Purpose : The InitializeAcl function creates a new ACL structure.
2431 * An ACL is an access-control list.
2432 * Parameters: PACL pAcl address of access-control list
2433 * DWORD nAclLength size of access-control list
2434 * DWORD dwAclRevision revision level of access-control list
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 InitializeAcl(PACL pAcl,
2444 DWORD nAclLength,
2445 DWORD dwAclRevision)
2446{
2447 dprintf(("ADVAPI32: InitializeAcl(%08xh,%08xh,%08xh) not implemented.\n",
2448 pAcl,
2449 nAclLength,
2450 dwAclRevision));
2451
2452 return (FALSE); /* signal failure */
2453}
2454
2455
2456/*****************************************************************************
2457 * Name : InitializeSid
2458 * Purpose : The InitializeSid function initializes a SID structure. An SID
2459 * is a security identifier.
2460 * Parameters: PSID pSid address of SID to initialize
2461 * PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority address of identifier authority
2462 * BYTE nSubAuthorityCount count of subauthorities
2463 * Variables :
2464 * Result :
2465 * Remark :
2466 * Status : UNTESTED STUB
2467 *
2468 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2469 *****************************************************************************/
2470
2471BOOL WIN32API InitializeSid(PSID pSid,
2472 PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
2473 BYTE nSubAuthorityCount)
2474{
2475 dprintf(("ADVAPI32: InitializeSid(%08xh,%08xh,%08xh) not implemented.\n",
2476 pSid,
2477 pIdentifierAuthority,
2478 nSubAuthorityCount));
2479
2480 return (FALSE); /* signal failure */
2481}
2482
2483
2484/*****************************************************************************
2485 * Name : InitiateSystemShutdownA
2486 * Purpose : The InitiateSystemShutdown function initiates a shutdown and
2487 * optional restart of the specified computer.
2488 * Parameters: LPTSTR lpMachineName address of name of computer to shut down
2489 * LPTSTR lpMessage address of message to display in dialog box
2490 * DWORD dwTimeout time to display dialog box
2491 * BOOL bForceAppsClosed force applications with unsaved changes flag
2492 * BOOL bRebootAfterShutdown reboot flag
2493 * Variables :
2494 * Result :
2495 * Remark :
2496 * Status : UNTESTED STUB
2497 *
2498 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2499 *****************************************************************************/
2500
2501BOOL WIN32API InitiateSystemShutdownA(LPTSTR lpMachineName,
2502 LPTSTR lpMessage,
2503 DWORD dwTimeout,
2504 BOOL bForceAppsClosed,
2505 BOOL bRebootAfterShutdown)
2506{
2507 dprintf(("ADVAPI32: InitiateSystemShutdownA(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2508 lpMachineName,
2509 lpMessage,
2510 dwTimeout,
2511 bForceAppsClosed,
2512 bRebootAfterShutdown));
2513
2514 return (FALSE); /* signal failure */
2515}
2516
2517
2518/*****************************************************************************
2519 * Name : InitiateSystemShutdownW
2520 * Purpose : The InitiateSystemShutdown function initiates a shutdown and
2521 * optional restart of the specified computer.
2522 * Parameters: LPWSTR lpMachineName address of name of computer to shut down
2523 * LPWSTR lpMessage address of message to display in dialog box
2524 * DWORD dwTimeout time to display dialog box
2525 * BOOL bForceAppsClosed force applications with unsaved changes flag
2526 * BOOL bRebootAfterShutdown reboot flag
2527 * Variables :
2528 * Result :
2529 * Remark :
2530 * Status : UNTESTED STUB
2531 *
2532 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2533 *****************************************************************************/
2534
2535BOOL WIN32API InitiateSystemShutdownW(LPWSTR lpMachineName,
2536 LPWSTR lpMessage,
2537 DWORD dwTimeout,
2538 BOOL bForceAppsClosed,
2539 BOOL bRebootAfterShutdown)
2540{
2541 dprintf(("ADVAPI32: InitiateSystemShutdownW(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2542 lpMachineName,
2543 lpMessage,
2544 dwTimeout,
2545 bForceAppsClosed,
2546 bRebootAfterShutdown));
2547
2548 return (FALSE); /* signal failure */
2549}
2550
2551
2552/*****************************************************************************
2553 * Name : IsTextUnicode
2554 * Purpose : The IsTextUnicode function determines whether a buffer probably
2555 * contains a form of Unicode text. The function uses various
2556 * statistical and deterministic methods to make its determination,
2557 * under the control of flags passed via lpi. When the function
2558 * returns, the results of such tests are reported via lpi. If all
2559 * specified tests are passed, the function returns TRUE; otherwise,
2560 * it returns FALSE.
2561 * Parameters: CONST LPVOID lpBuffer pointer to an input buffer to be examined
2562 * int cb the size in bytes of the input buffer
2563 * LPINT lpi pointer to flags that condition text examination and receive results
2564 * Variables :
2565 * Result :
2566 * Remark :
2567 * Status : UNTESTED STUB
2568 *
2569 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2570 *****************************************************************************/
2571
2572DWORD WIN32API IsTextUnicode(CONST LPVOID lpBuffer,
2573 int cb,
2574 LPINT lpi)
2575{
2576 DWORD dwResult = 0;
2577
2578 dprintf(("ADVAPI32: IsTextUnicode(%08xh,%08xh,%08xh) not implemented.\n",
2579 lpBuffer,
2580 cb,
2581 lpi));
2582
2583 if (cb & 0x0001) dwResult |= IS_TEXT_UNICODE_ODD_LENGTH;
2584
2585 return (dwResult); /* signal failure */
2586}
2587
2588
2589/*****************************************************************************
2590 * Name : IsValidAcl
2591 * Purpose : The IsValidAcl function validates an access-control list (ACL).
2592 * Parameters: PACL pAcl address of access-control list
2593 * Variables :
2594 * Result :
2595 * Remark :
2596 * Status : UNTESTED STUB
2597 *
2598 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2599 *****************************************************************************/
2600
2601BOOL WIN32API IsValidAcl(PACL pAcl)
2602{
2603 dprintf(("ADVAPI32: IsValidAcl(%08xh) not implemented.\n",
2604 pAcl));
2605
2606 return (TRUE); /* signal OK */
2607}
2608
2609
2610/*****************************************************************************
2611 * Name : IsValidSecurityDescriptor
2612 * Purpose : The IsValidSecurityDescriptor function validates a
2613 * SECURITY_DESCRIPTOR structure. Validation is performed by
2614 * checking the revision level of each component in the security descriptor.
2615 * Parameters: PSECURITY_DESCRIPTOR pSecurityDescriptor
2616 * Variables :
2617 * Result :
2618 * Remark :
2619 * Status : UNTESTED STUB
2620 *
2621 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2622 *****************************************************************************/
2623
2624BOOL WIN32API IsValidSecurityDescriptor(PSECURITY_DESCRIPTOR pSecurityDescriptor)
2625{
2626 dprintf(("ADVAPI32: IsValidSecurityDescriptor(%08xh) not implemented.\n",
2627 pSecurityDescriptor));
2628
2629 return (TRUE); /* signal OK */
2630}
2631
2632
2633/*****************************************************************************
2634 * Name : IsValidSid
2635 * Purpose : The IsValidSid function validates a SID structure by verifying
2636 * that the revision number is within a known range and that the
2637 * number of subauthorities is less than the maximum. A SID is a
2638 * security identifier.
2639 * Parameters: PSID pSid address of SID to query
2640 * Variables :
2641 * Result :
2642 * Remark :
2643 * Status : UNTESTED STUB
2644 *
2645 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2646 *****************************************************************************/
2647
2648BOOL WIN32API IsValidSid(PSID pSid)
2649{
2650 dprintf(("ADVAPI32: IsValidSid(%08xh) not implemented.\n",
2651 pSid));
2652
2653 return (TRUE); /* signal OK */
2654}
2655
2656
2657/*****************************************************************************
2658 * Name : LockServiceDatabase
2659 * Purpose : The LockServiceDatabase function locks a specified database.
2660 * Parameters: SC_HANDLE hSCManager handle of service control manager database
2661 * Variables :
2662 * Result :
2663 * Remark :
2664 * Status : UNTESTED STUB
2665 *
2666 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2667 *****************************************************************************/
2668
2669#define SC_LOCK DWORD
2670SC_LOCK WIN32API LockServiceDatabase(SC_HANDLE hSCManager)
2671{
2672 dprintf(("ADVAPI32: LockServiceDatabase(%08xh) not implemented.\n",
2673 hSCManager));
2674
2675 return (ERROR_ACCESS_DENIED); /* signal failure */
2676}
2677
2678
2679/*****************************************************************************
2680 * Name : LogonUserA
2681 * Purpose : The LogonUser function attempts to perform a user logon
2682 * operation. You specify the user with a user name and domain,
2683 * and authenticate the user with a clear-text password. If the
2684 * function succeeds, you receive a handle to a token that
2685 * represents the logged-on user. You can then use this token
2686 * handle to impersonate the specified user, or to create a process
2687 * running in the context of the specified user.
2688 * Parameters: LPTSTR lpszUsername string that specifies the user name
2689 * LPTSTR lpszDomain string that specifies the domain or servero
2690 * LPTSTR lpszPassword string that specifies the password
2691 * DWORD dwLogonType specifies the type of logon operation
2692 * DWORD dwLogonProvider specifies the logon provider
2693 * PHANDLE phToken pointer to variable to receive token handle
2694 * Variables :
2695 * Result :
2696 * Remark :
2697 * Status : UNTESTED STUB
2698 *
2699 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2700 *****************************************************************************/
2701
2702BOOL WIN32API LogonUserA(LPTSTR lpszUsername,
2703 LPTSTR lpszDomain,
2704 LPTSTR lpszPassword,
2705 DWORD dwLogonType,
2706 DWORD dwLogonProvider,
2707 PHANDLE phToken)
2708{
2709 dprintf(("ADVAPI32: LogonUserA(%s,%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
2710 lpszUsername,
2711 lpszDomain,
2712 lpszPassword,
2713 dwLogonType,
2714 dwLogonProvider,
2715 phToken));
2716
2717 return (TRUE); /* signal OK */
2718}
2719
2720
2721/*****************************************************************************
2722 * Name : LogonUserW
2723 * Purpose : The LogonUser function attempts to perform a user logon
2724 * operation. You specify the user with a user name and domain,
2725 * and authenticate the user with a clear-text password. If the
2726 * function succeeds, you receive a handle to a token that
2727 * represents the logged-on user. You can then use this token
2728 * handle to impersonate the specified user, or to create a process
2729 * running in the context of the specified user.
2730 * Parameters: LPWSTR lpszUsername string that specifies the user name
2731 * LPWSTR lpszDomain string that specifies the domain or servero
2732 * LPWSTR lpszPassword string that specifies the password
2733 * DWORD dwLogonType specifies the type of logon operation
2734 * DWORD dwLogonProvider specifies the logon provider
2735 * PHANDLE phToken pointer to variable to receive token handle
2736 * Variables :
2737 * Result :
2738 * Remark :
2739 * Status : UNTESTED STUB
2740 *
2741 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2742 *****************************************************************************/
2743
2744BOOL WIN32API LogonUserW(LPWSTR lpszUsername,
2745 LPWSTR lpszDomain,
2746 LPWSTR lpszPassword,
2747 DWORD dwLogonType,
2748 DWORD dwLogonProvider,
2749 PHANDLE phToken)
2750{
2751 dprintf(("ADVAPI32: LogonUserW(%s,%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
2752 lpszUsername,
2753 lpszDomain,
2754 lpszPassword,
2755 dwLogonType,
2756 dwLogonProvider,
2757 phToken));
2758
2759 return (TRUE); /* signal OK */
2760}
2761
2762
2763/*****************************************************************************
2764 * Name : LookupAccountNameA
2765 * Purpose : The LookupAccountName function accepts the name of a system and
2766 * an account as input. It retrieves a security identifier (SID)
2767 * for the account and the name of the domain on which the account was found.
2768 * Parameters: LPCSTR lpSystemName address of string for system name
2769 * LPCSTR lpAccountName address of string for account name
2770 * PSID Sid address of security identifier
2771 * LPDWORD cbSid address of size of security identifier
2772 * LPTSTR ReferencedDomainName address of string for referenced domain
2773 * LPDWORD cbReferencedDomainName address of size of domain string
2774 * PSID_NAME_USE peUse address of SID-type indicator
2775 * Variables :
2776 * Result :
2777 * Remark :
2778 * Status : UNTESTED STUB
2779 *
2780 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2781 *****************************************************************************/
2782
2783#define PSID_NAME_USE LPVOID
2784BOOL WIN32API LookupAccountNameA(LPCSTR lpSystemName,
2785 LPCSTR lpAccountName,
2786 PSID Sid,
2787 LPDWORD cbSid,
2788 LPTSTR ReferencedDomainName,
2789 LPDWORD cbReferencedDomainName,
2790 PSID_NAME_USE peUse)
2791{
2792 dprintf(("ADVAPI32: LookupAccountNameA(%s,%s,%08xh,%08xh,%s,%08xh,%08xh) not implemented.\n",
2793 lpSystemName,
2794 lpAccountName,
2795 Sid,
2796 cbSid,
2797 ReferencedDomainName,
2798 cbReferencedDomainName,
2799 peUse));
2800
2801 return (FALSE); /* signal failure */
2802}
2803
2804
2805/*****************************************************************************
2806 * Name : LookupAccountNameW
2807 * Purpose : The LookupAccountName function accepts the name of a system and
2808 * an account as input. It retrieves a security identifier (SID)
2809 * for the account and the name of the domain on which the account was found.
2810 * Parameters: LPCWSTR lpSystemName address of string for system name
2811 * LPCWSTR lpAccountName address of string for account name
2812 * PSID Sid address of security identifier
2813 * LPDWORD cbSid address of size of security identifier
2814 * LPWSTR ReferencedDomainName address of string for referenced domain
2815 * LPDWORD cbReferencedDomainName address of size of domain string
2816 * PSID_NAME_USE peUse address of SID-type indicator
2817 * Variables :
2818 * Result :
2819 * Remark :
2820 * Status : UNTESTED STUB
2821 *
2822 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2823 *****************************************************************************/
2824
2825BOOL WIN32API LookupAccountNameW(LPCWSTR lpSystemName,
2826 LPCWSTR lpAccountName,
2827 PSID Sid,
2828 LPDWORD cbSid,
2829 LPWSTR ReferencedDomainName,
2830 LPDWORD cbReferencedDomainName,
2831 PSID_NAME_USE peUse)
2832{
2833 dprintf(("ADVAPI32: LookupAccountNameW(%s,%s,%08xh,%08xh,%s,%08xh,%08xh) not implemented.\n",
2834 lpSystemName,
2835 lpAccountName,
2836 Sid,
2837 cbSid,
2838 ReferencedDomainName,
2839 cbReferencedDomainName,
2840 peUse));
2841
2842 return (FALSE); /* signal failure */
2843}
2844
2845
2846/*****************************************************************************
2847 * Name : LookupAccountSidA
2848 * Purpose : The LookupAccountSid function accepts a security identifier (SID)
2849 * as input. It retrieves the name of the account for this SID and
2850 * the name of the first domain on which this SID is found.
2851 * Parameters: LPCSTR lpSystemName address of string for system name
2852 * PSID Sid address of security identifier
2853 * LPTSTR Name address of string for account name
2854 * LPDWORD cbName address of size account string
2855 * LPTSTR ReferencedDomainName address of string for referenced domain
2856 * LPDWORD cbReferencedDomainName address of size domain string
2857 * PSID_NAME_USE peUse address of structure for SID type
2858 * Variables :
2859 * Result :
2860 * Remark :
2861 * Status : UNTESTED STUB
2862 *
2863 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2864 *****************************************************************************/
2865
2866BOOL WIN32API LookupAccountSidA(LPCSTR lpSystemName,
2867 PSID Sid,
2868 LPTSTR Name,
2869 LPDWORD cbName,
2870 LPTSTR ReferencedDomainName,
2871 LPDWORD cbReferencedDomainName,
2872 PSID_NAME_USE peUse)
2873{
2874 dprintf(("ADVAPI32: LookupAccountSidA(%s,%08xh,%s,%08xh,%s,%08xh,%08xh) not implemented.\n",
2875 lpSystemName,
2876 Sid,
2877 Name,
2878 cbName,
2879 ReferencedDomainName,
2880 cbReferencedDomainName,
2881 peUse));
2882
2883 return (FALSE); /* signal failure */
2884}
2885
2886
2887/*****************************************************************************
2888 * Name : LookupAccountSidW
2889 * Purpose : The LookupAccountSid function accepts a security identifier (SID)
2890 * as input. It retrieves the name of the account for this SID and
2891 * the name of the first domain on which this SID is found.
2892 * Parameters: LPCWSTR lpSystemName address of string for system name
2893 * PSID Sid address of security identifier
2894 * LPWSTR Name address of string for account name
2895 * LPDWORD cbName address of size account string
2896 * LPWSTR ReferencedDomainName address of string for referenced domain
2897 * LPDWORD cbReferencedDomainName address of size domain string
2898 * PSID_NAME_USE peUse address of structure for SID type
2899 * Variables :
2900 * Result :
2901 * Remark :
2902 * Status : UNTESTED STUB
2903 *
2904 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2905 *****************************************************************************/
2906
2907BOOL WIN32API LookupAccountSidW(LPCWSTR lpSystemName,
2908 PSID Sid,
2909 LPWSTR Name,
2910 LPDWORD cbName,
2911 LPWSTR ReferencedDomainName,
2912 LPDWORD cbReferencedDomainName,
2913 PSID_NAME_USE peUse)
2914{
2915 dprintf(("ADVAPI32: LookupAccountSidW(%s,%08xh,%s,%08xh,%s,%08xh,%08xh) not implemented.\n",
2916 lpSystemName,
2917 Sid,
2918 Name,
2919 cbName,
2920 ReferencedDomainName,
2921 cbReferencedDomainName,
2922 peUse));
2923
2924 return (FALSE); /* signal failure */
2925}
2926
2927
2928/*****************************************************************************
2929 * Name : LookupPrivilegeDisplayNameA
2930 * Purpose : The LookupPrivilegeDisplayName function retrieves a displayable
2931 * name representing a specified privilege.
2932 * Parameters: LPCSTR lpSystemName address of string specifying the system
2933 * LPCSTR lpName address of string specifying the privilege
2934 * LPTSTR lpDisplayName address of string receiving the displayable name
2935 * LPDWORD cbDisplayName address of size of string for displayable name
2936 * LPDWORD lpLanguageId address of language identifier
2937 * Variables :
2938 * Result :
2939 * Remark :
2940 * Status : UNTESTED STUB
2941 *
2942 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2943 *****************************************************************************/
2944
2945BOOL WIN32API LookupPrivilegeDisplayNameA(LPCSTR lpSystemName,
2946 LPCSTR lpName,
2947 LPTSTR lpDisplayName,
2948 LPDWORD cbDisplayName,
2949 LPDWORD lpLanguageId)
2950{
2951 dprintf(("ADVAPI32: LookupPrivilegeDisplayNameA(%s,%s,%s,%08xh,%08xh) not implemented.\n",
2952 lpSystemName,
2953 lpName,
2954 lpDisplayName,
2955 cbDisplayName,
2956 lpLanguageId));
2957
2958 return (FALSE); /* signal failure */
2959}
2960
2961
2962/*****************************************************************************
2963 * Name : LookupPrivilegeDisplayNameW
2964 * Purpose : The LookupPrivilegeDisplayName function retrieves a displayable
2965 * name representing a specified privilege.
2966 * Parameters: LPCWSTR lpSystemName address of string specifying the system
2967 * LPCWSTR lpName address of string specifying the privilege
2968 * LPWSTR lpDisplayName address of string receiving the displayable name
2969 * LPDWORD cbDisplayName address of size of string for displayable name
2970 * LPDWORD lpLanguageId address of language identifier
2971 * Variables :
2972 * Result :
2973 * Remark :
2974 * Status : UNTESTED STUB
2975 *
2976 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
2977 *****************************************************************************/
2978
2979BOOL WIN32API LookupPrivilegeDisplayNameW(LPCWSTR lpSystemName,
2980 LPCWSTR lpName,
2981 LPWSTR lpDisplayName,
2982 LPDWORD cbDisplayName,
2983 LPDWORD lpLanguageId)
2984{
2985 dprintf(("ADVAPI32: LookupPrivilegeDisplayNameW(%s,%s,%s,%08xh,%08xh) not implemented.\n",
2986 lpSystemName,
2987 lpName,
2988 lpDisplayName,
2989 cbDisplayName,
2990 lpLanguageId));
2991
2992 return (FALSE); /* signal failure */
2993}
2994
2995
2996/*****************************************************************************
2997 * Name : LookupPrivilegeNameA
2998 * Purpose : The LookupPrivilegeName function retrieves the name corresponding
2999 * to the privilege represented on a specific system by a specified
3000 * locally unique identifier (LUID).
3001 * Parameters: LPCSTR lpSystemName address of string specifying the system
3002 * PLUID lpLuid address of locally unique identifier
3003 * LPTSTR lpName address of string specifying the privilege
3004 * LPDWORD cbName address of size of string for displayable name
3005 * Variables :
3006 * Result :
3007 * Remark :
3008 * Status : UNTESTED STUB
3009 *
3010 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3011 *****************************************************************************/
3012
3013BOOL WIN32API LookupPrivilegeNameA(LPCSTR lpSystemName,
3014 PLUID lpLuid,
3015 LPTSTR lpName,
3016 LPDWORD cbName)
3017{
3018 dprintf(("ADVAPI32: LookupPrivilegeNameA(%s,%08xh,%s,%08xh) not implemented.\n",
3019 lpSystemName,
3020 lpLuid,
3021 lpName,
3022 cbName));
3023
3024 return (FALSE); /* signal failure */
3025}
3026
3027
3028/*****************************************************************************
3029 * Name : LookupPrivilegeNameW
3030 * Purpose : The LookupPrivilegeName function retrieves the name corresponding
3031 * to the privilege represented on a specific system by a specified
3032 * locally unique identifier (LUID).
3033 * Parameters: LPCWSTR lpSystemName address of string specifying the system
3034 * PLUID lpLuid address of locally unique identifier
3035 * LPWSTR lpName address of string specifying the privilege
3036 * LPDWORD cbName address of size of string for displayable name
3037 * Variables :
3038 * Result :
3039 * Remark :
3040 * Status : UNTESTED STUB
3041 *
3042 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3043 *****************************************************************************/
3044
3045BOOL WIN32API LookupPrivilegeNameW(LPCWSTR lpSystemName,
3046 PLUID lpLuid,
3047 LPWSTR lpName,
3048 LPDWORD cbName)
3049{
3050 dprintf(("ADVAPI32: LookupPrivilegeNameW(%s,%08xh,%s,%08xh) not implemented.\n",
3051 lpSystemName,
3052 lpLuid,
3053 lpName,
3054 cbName));
3055
3056 return (FALSE); /* signal failure */
3057}
3058
3059
3060/*****************************************************************************
3061 * Name : MakeAbsoluteSD
3062 * Purpose : The MakeAbsoluteSD function creates a security descriptor in
3063 * absolute format by using a security descriptor in self-relative
3064 * format as a template.
3065 * Parameters: PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor address self-relative SD
3066 * PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor address of absolute SD
3067 * LPDWORD lpdwAbsoluteSecurityDescriptorSize address of size of absolute SD
3068 * PACL pDacl address of discretionary ACL
3069 * LPDWORD lpdwDaclSize address of size of discretionary ACL
3070 * PACL pSacl address of system ACL
3071 * LPDWORD lpdwSaclSize address of size of system ACL
3072 * PSID pOwner address of owner SID
3073 * LPDWORD lpdwOwnerSize address of size of owner SID
3074 * PSID pPrimaryGroup address of primary-group SID
3075 * LPDWORD lpdwPrimaryGroupSize address of size of group SID
3076 * Variables :
3077 * Result :
3078 * Remark :
3079 * Status : UNTESTED STUB
3080 *
3081 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3082 *****************************************************************************/
3083
3084BOOL WIN32API MakeAbsoluteSD(PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
3085 PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
3086 LPDWORD lpdwAbsoluteSecurityDescriptorSize,
3087 PACL pDacl,
3088 LPDWORD lpdwDaclSize,
3089 PACL pSacl,
3090 LPDWORD lpdwSaclSize,
3091 PSID pOwner,
3092 LPDWORD lpdwOwnerSize,
3093 PSID pPrimaryGroup,
3094 LPDWORD lpdwPrimaryGroupSize)
3095{
3096 dprintf(("ADVAPI32: MakeAbsoluteSD(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3097 pSelfRelativeSecurityDescriptor,
3098 pAbsoluteSecurityDescriptor,
3099 lpdwAbsoluteSecurityDescriptorSize,
3100 pDacl,
3101 lpdwDaclSize,
3102 pSacl,
3103 lpdwSaclSize,
3104 pOwner,
3105 lpdwOwnerSize,
3106 pPrimaryGroup,
3107 lpdwPrimaryGroupSize));
3108
3109 return (FALSE); /* signal failure */
3110}
3111
3112
3113/*****************************************************************************
3114 * Name : MakeSelfRelativeSD
3115 * Purpose : The MakeSelfRelativeSD function creates a security descriptor
3116 * in self-relative format by using a security descriptor in absolute
3117 * format as a template.
3118 * Parameters: PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor address of absolute SD
3119 * PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor address self-relative SD
3120 * LPDWORD lpdwBufferLength address of SD size
3121 * Variables :
3122 * Result :
3123 * Remark :
3124 * Status : UNTESTED STUB
3125 *
3126 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3127 *****************************************************************************/
3128
3129BOOL WIN32API MakeSelfRelativeSD(PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
3130 PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
3131 LPDWORD lpdwBufferLength)
3132{
3133 dprintf(("ADVAPI32: MakeSelfRelativeSD(%08xh,%08xh,%08xh) not implemented.\n",
3134 pAbsoluteSecurityDescriptor,
3135 pSelfRelativeSecurityDescriptor,
3136 lpdwBufferLength));
3137
3138 return (FALSE); /* signal failure */
3139}
3140
3141
3142/*****************************************************************************
3143 * Name : MapGenericMask
3144 * Purpose : The MapGenericMask function maps the generic access rights in
3145 * an access mask to specific and standard access rights. The function
3146 * applies a mapping supplied in a GENERIC_MAPPING structure.
3147 * Parameters: LPDWORD AccessMask address of access mask
3148 * PGENERIC_MAPPING GenericMapping address of GENERIC_MAPPING structure
3149 * Variables :
3150 * Result :
3151 * Remark :
3152 * Status : UNTESTED STUB
3153 *
3154 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3155 *****************************************************************************/
3156
3157VOID WIN32API MapGenericMask(LPDWORD AccessMask,
3158 PGENERIC_MAPPING GenericMapping)
3159{
3160 dprintf(("ADVAPI32: MapGenericMask(%08xh,%08xh) not implemented.\n",
3161 AccessMask,
3162 GenericMapping));
3163}
3164
3165
3166/*****************************************************************************
3167 * Name : NotifyBootConfigStatus
3168 * Purpose : The NotifyBootConfigStatus function notifies the service control
3169 * manager as to the acceptability of the configuration that booted
3170 * the system. An acceptable configuration triggers the storage of
3171 * that configuration as the last-known good configuration; an
3172 * unacceptable configuration triggers a system reboot.
3173 * Parameters: BOOL BootAcceptable indicates acceptability of boot configuration
3174 * Variables :
3175 * Result :
3176 * Remark :
3177 * Status : UNTESTED STUB
3178 *
3179 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3180 *****************************************************************************/
3181
3182BOOL WIN32API NotifyBootConfigStatus(BOOL BootAcceptable)
3183{
3184 dprintf(("ADVAPI32: NotifyBootConfigStatus(%08xh) not implemented.\n",
3185 BootAcceptable));
3186
3187 return (TRUE); /* signal OK */
3188}
3189
3190
3191/*****************************************************************************
3192 * Name : NotifyChangeEventLog
3193 * Purpose : The NotifyChangeEventLog function lets an application receive
3194 * notification when an event is written to the event log file
3195 * specified by hEventLog. When the event is written to the event
3196 * log file, the function causes the event object specified by
3197 * hEvent to become signaled.
3198 * Parameters: HANDLE hEventLog special default locale value to be converted
3199 * HANDLE hEvent special default locale value to be converted
3200 * Variables :
3201 * Result :
3202 * Remark :
3203 * Status : UNTESTED STUB
3204 *
3205 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3206 *****************************************************************************/
3207
3208BOOL WIN32API NotifyChangeEventLog(HANDLE hEventLog,
3209 HANDLE hEvent)
3210{
3211 dprintf(("ADVAPI32: NotifyChangeEventLog(%08xh,%08xh) not implemented.\n",
3212 hEventLog,
3213 hEvent));
3214
3215 return (FALSE); /* signal failure */
3216}
3217
3218
3219/*****************************************************************************
3220 * Name : ObjectCloseAuditAlarmA
3221 * Purpose : The ObjectCloseAuditAlarm function generates audit messages when
3222 * a handle of an object is deleted. Alarms are not supported in the
3223 * current version of Windows NT.
3224 * Parameters: LPCSTR SubsystemName address of string for subsystem name
3225 * LPVOID HandleId address of handle identifier
3226 * BOOL GenerateOnClose flag for audit generation
3227 * Variables :
3228 * Result :
3229 * Remark :
3230 * Status : UNTESTED STUB
3231 *
3232 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3233 *****************************************************************************/
3234
3235BOOL WIN32API ObjectCloseAuditAlarmA(LPCSTR SubsystemName,
3236 LPVOID HandleId,
3237 BOOL GenerateOnClose)
3238{
3239 dprintf(("ADVAPI32: ObjectCloseAuditAlarmA(%s,%08xh,%08xh) not implemented.\n",
3240 SubsystemName,
3241 HandleId,
3242 GenerateOnClose));
3243
3244 return (FALSE); /* signal failure */
3245}
3246
3247
3248/*****************************************************************************
3249 * Name : ObjectCloseAuditAlarmW
3250 * Purpose : The ObjectCloseAuditAlarm function generates audit messages when
3251 * a handle of an object is deleted. Alarms are not supported in the
3252 * current version of Windows NT.
3253 * Parameters: LPCWSTR SubsystemName address of string for subsystem name
3254 * LPVOID HandleId address of handle identifier
3255 * BOOL GenerateOnClose flag for audit generation
3256 * Variables :
3257 * Result :
3258 * Remark :
3259 * Status : UNTESTED STUB
3260 *
3261 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3262 *****************************************************************************/
3263
3264BOOL WIN32API ObjectCloseAuditAlarmW(LPCWSTR SubsystemName,
3265 LPVOID HandleId,
3266 BOOL GenerateOnClose)
3267{
3268 dprintf(("ADVAPI32: ObjectCloseAuditAlarmW(%s,%08xh,%08xh) not implemented.\n",
3269 SubsystemName,
3270 HandleId,
3271 GenerateOnClose));
3272
3273 return (FALSE); /* signal failure */
3274}
3275
3276
3277
3278/*****************************************************************************
3279 * Name : ObjectOpenAuditAlarmA
3280 * Purpose : The ObjectOpenAuditAlarm function generates audit messages when
3281 * a client application attempts to gain access to an object or to
3282 * create a new one. Alarms are not supported in the current version
3283 * of Windows NT.
3284 * Parameters: LPCSTR SubsystemName address of string for subsystem name
3285 * LPVOID HandleId address of handle identifier
3286 * LPTSTR ObjectTypeName address of string for object type
3287 * LPTSTR ObjectName address of string for object name
3288 * PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
3289 * HANDLE ClientToken handle of client's access token
3290 * DWORD DesiredAccess mask for desired access rights
3291 * DWORD GrantedAccess mask for granted access rights
3292 * PPRIVILEGE_SET Privileges address of privileges
3293 * BOOL ObjectCreation flag for object creation
3294 * BOOL AccessGranted flag for results
3295 * LPBOOL GenerateOnClose address of flag for audit generation
3296 * Variables :
3297 * Result :
3298 * Remark :
3299 * Status : UNTESTED STUB
3300 *
3301 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3302 *****************************************************************************/
3303
3304BOOL WIN32API ObjectOpenAuditAlarmA(LPCSTR SubsystemName,
3305 LPVOID HandleId,
3306 LPTSTR ObjectTypeName,
3307 LPTSTR ObjectName,
3308 PSECURITY_DESCRIPTOR pSecurityDescriptor,
3309 HANDLE ClientToken,
3310 DWORD DesiredAccess,
3311 DWORD GrantedAccess,
3312 PPRIVILEGE_SET Privileges,
3313 BOOL ObjectCreation,
3314 BOOL AccessGranted,
3315 LPBOOL GenerateOnClose)
3316{
3317 dprintf(("ADVAPI32: ObjectOpenAuditAlarmA(%s,%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3318 SubsystemName,
3319 HandleId,
3320 ObjectTypeName,
3321 ObjectName,
3322 pSecurityDescriptor,
3323 ClientToken,
3324 DesiredAccess,
3325 GrantedAccess,
3326 Privileges,
3327 ObjectCreation,
3328 AccessGranted,
3329 GenerateOnClose));
3330
3331 return (FALSE); /* signal failure */
3332}
3333
3334
3335/*****************************************************************************
3336 * Name : ObjectOpenAuditAlarmW
3337 * Purpose : The ObjectOpenAuditAlarm function generates audit messages when
3338 * a client application attempts to gain access to an object or to
3339 * create a new one. Alarms are not supported in the current version
3340 * of Windows NT.
3341 * Parameters: LPCWSTR SubsystemName address of string for subsystem name
3342 * LPVOID HandleId address of handle identifier
3343 * LPWSTR ObjectTypeName address of string for object type
3344 * LPWSTR ObjectName address of string for object name
3345 * PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
3346 * HANDLE ClientToken handle of client's access token
3347 * DWORD DesiredAccess mask for desired access rights
3348 * DWORD GrantedAccess mask for granted access rights
3349 * PPRIVILEGE_SET Privileges address of privileges
3350 * BOOL ObjectCreation flag for object creation
3351 * BOOL AccessGranted flag for results
3352 * LPBOOL GenerateOnClose address of flag for audit generation
3353 * Variables :
3354 * Result :
3355 * Remark :
3356 * Status : UNTESTED STUB
3357 *
3358 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3359 *****************************************************************************/
3360
3361BOOL WIN32API ObjectOpenAuditAlarmW(LPCWSTR SubsystemName,
3362 LPVOID HandleId,
3363 LPWSTR ObjectTypeName,
3364 LPWSTR ObjectName,
3365 PSECURITY_DESCRIPTOR pSecurityDescriptor,
3366 HANDLE ClientToken,
3367 DWORD DesiredAccess,
3368 DWORD GrantedAccess,
3369 PPRIVILEGE_SET Privileges,
3370 BOOL ObjectCreation,
3371 BOOL AccessGranted,
3372 LPBOOL GenerateOnClose)
3373{
3374 dprintf(("ADVAPI32: ObjectOpenAuditAlarmW(%s,%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3375 SubsystemName,
3376 HandleId,
3377 ObjectTypeName,
3378 ObjectName,
3379 pSecurityDescriptor,
3380 ClientToken,
3381 DesiredAccess,
3382 GrantedAccess,
3383 Privileges,
3384 ObjectCreation,
3385 AccessGranted,
3386 GenerateOnClose));
3387
3388 return (FALSE); /* signal failure */
3389}
3390
3391
3392/*****************************************************************************
3393 * Name : ObjectPrivilegeAuditAlarmA
3394 * Purpose : The ObjectPrivilegeAuditAlarm function generates audit messages
3395 * as a result of a client's attempt to perform a privileged operation
3396 * on a server application object using an already opened handle of
3397 * that object. Alarms are not supported in the current version of Windows NT.
3398 * Parameters: LPCSTR lpszSubsystem address of string for subsystem name
3399 * LPVOID lpvHandleId address of handle identifier
3400 * HANDLE hClientToken handle of client's access token
3401 * DWORD dwDesiredAccess mask for desired access rights
3402 * PPRIVILEGE_SET pps address of privileges
3403 * BOOL fAccessGranted flag for results
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 ObjectPrivilegeAuditAlarmA(LPCSTR lpszSubsystem,
3413 LPVOID lpvHandleId,
3414 HANDLE hClientToken,
3415 DWORD dwDesiredAccess,
3416 PPRIVILEGE_SET pps,
3417 BOOL fAccessGranted)
3418{
3419 dprintf(("ADVAPI32: ObjectPrivilegeAuditAlarmA(%s,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3420 lpszSubsystem,
3421 lpvHandleId,
3422 hClientToken,
3423 dwDesiredAccess,
3424 pps,
3425 fAccessGranted));
3426
3427 return (FALSE); /* signal failure */
3428}
3429
3430
3431/*****************************************************************************
3432 * Name : ObjectPrivilegeAuditAlarmW
3433 * Purpose : The ObjectPrivilegeAuditAlarm function generates audit messages
3434 * as a result of a client's attempt to perform a privileged operation
3435 * on a server application object using an already opened handle of
3436 * that object. Alarms are not supported in the current version of Windows NT.
3437 * Parameters: LPCWSTR lpszSubsystem address of string for subsystem name
3438 * LPVOID lpvHandleId address of handle identifier
3439 * HANDLE hClientToken handle of client's access token
3440 * DWORD dwDesiredAccess mask for desired access rights
3441 * PPRIVILEGE_SET pps address of privileges
3442 * BOOL fAccessGranted flag for results
3443 * Variables :
3444 * Result :
3445 * Remark :
3446 * Status : UNTESTED STUB
3447 *
3448 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3449 *****************************************************************************/
3450
3451BOOL WIN32API ObjectPrivilegeAuditAlarmW(LPCWSTR lpszSubsystem,
3452 LPVOID lpvHandleId,
3453 HANDLE hClientToken,
3454 DWORD dwDesiredAccess,
3455 PPRIVILEGE_SET pps,
3456 BOOL fAccessGranted)
3457{
3458 dprintf(("ADVAPI32: ObjectPrivilegeAuditAlarmW(%s,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3459 lpszSubsystem,
3460 lpvHandleId,
3461 hClientToken,
3462 dwDesiredAccess,
3463 pps,
3464 fAccessGranted));
3465
3466 return (FALSE); /* signal failure */
3467}
3468
3469
3470/*****************************************************************************
3471 * Name : OpenBackupEventLogA
3472 * Purpose : The OpenBackupEventLog function opens a handle of a backup event
3473 * log. This handle can be used with the BackupEventLog function.
3474 * Parameters: LPCSTR lpszUNCServerName backup file server name
3475 * LPCSTR lpszFileName backup filename
3476 * Variables :
3477 * Result :
3478 * Remark :
3479 * Status : UNTESTED STUB
3480 *
3481 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3482 *****************************************************************************/
3483
3484HANDLE WIN32API OpenBackupEventLogA(LPCSTR lpszUNCServerName,
3485 LPCSTR lpszFileName)
3486{
3487 dprintf(("ADVAPI32: OpenBackupEventLogA(%s,%s) not implemented.\n",
3488 lpszUNCServerName,
3489 lpszFileName));
3490
3491 return (NULL); /* signal failure */
3492}
3493
3494
3495/*****************************************************************************
3496 * Name : OpenBackupEventLogW
3497 * Purpose : The OpenBackupEventLog function opens a handle of a backup event
3498 * log. This handle can be used with the BackupEventLog function.
3499 * Parameters: LPCWSTR lpszUNCServerName backup file server name
3500 * LPCWSTR lpszFileName backup filename
3501 * Variables :
3502 * Result :
3503 * Remark :
3504 * Status : UNTESTED STUB
3505 *
3506 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3507 *****************************************************************************/
3508
3509HANDLE WIN32API OpenBackupEventLogW(LPCWSTR lpszUNCServerName,
3510 LPCWSTR lpszFileName)
3511{
3512 dprintf(("ADVAPI32: OpenBackupEventLogW(%s,%s) not implemented.\n",
3513 lpszUNCServerName,
3514 lpszFileName));
3515
3516 return (NULL); /* signal failure */
3517}
3518
3519
3520/*****************************************************************************
3521 * Name : OpenEventLogA
3522 * Purpose : The OpenEventLog function opens a handle of an event log.
3523 * Parameters: LPCSTR lpszUNCServerName
3524 * LPCSTR lpszSourceName
3525 * Variables :
3526 * Result :
3527 * Remark :
3528 * Status : UNTESTED STUB
3529 *
3530 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3531 *****************************************************************************/
3532
3533HANDLE WIN32API OpenEventLogA(LPCSTR lpszUNCServerName,
3534 LPCSTR lpszSourceName)
3535{
3536 dprintf(("ADVAPI32: OpenEventLogA(%s,%s) not implemented.\n",
3537 lpszUNCServerName,
3538 lpszSourceName));
3539
3540 return (NULL); /* signal failure */
3541}
3542
3543
3544/*****************************************************************************
3545 * Name : OpenEventLogW
3546 * Purpose : The OpenEventLog function opens a handle of an event log.
3547 * Parameters: LPCWSTR lpszUNCServerName
3548 * LPCWSTR lpszSourceName
3549 * Variables :
3550 * Result :
3551 * Remark :
3552 * Status : UNTESTED STUB
3553 *
3554 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3555 *****************************************************************************/
3556
3557HANDLE WIN32API OpenEventLogW(LPCWSTR lpszUNCServerName,
3558 LPCWSTR lpszSourceName)
3559{
3560 dprintf(("ADVAPI32: OpenEventLogW(%s,%s) not implemented.\n",
3561 lpszUNCServerName,
3562 lpszSourceName));
3563
3564 return (NULL); /* signal failure */
3565}
3566
3567
3568/*****************************************************************************
3569 * Name : OpenSCManagerA
3570 * Purpose : The OpenSCManager function establishes a connection to the
3571 * service control manager on the specified computer and opens the
3572 * specified database.
3573 * Parameters: LPCSTR lpszMachineName address of machine name string
3574 * LPCSTR lpszDatabaseName address of database name string
3575 * DWORD fdwDesiredAccess type of access
3576 * Variables :
3577 * Result :
3578 * Remark :
3579 * Status : UNTESTED STUB
3580 *
3581 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3582 *****************************************************************************/
3583
3584SC_HANDLE WIN32API OpenSCManagerA(LPCSTR lpszMachineName,
3585 LPCSTR lpszDatabaseName,
3586 DWORD fdwDesiredAccess)
3587{
3588 dprintf(("ADVAPI32: OpenSCManagerA(%s,%s,%s) not implemented.\n",
3589 lpszMachineName,
3590 lpszDatabaseName,
3591 fdwDesiredAccess));
3592
3593 return (NULL); /* signal failure */
3594}
3595
3596
3597/*****************************************************************************
3598 * Name : OpenSCManagerW
3599 * Purpose : The OpenSCManager function establishes a connection to the
3600 * service control manager on the specified computer and opens the
3601 * specified database.
3602 * Parameters: LPCWSTR lpszMachineName address of machine name string
3603 * LPCWSTR lpszDatabaseName address of database name string
3604 * DWORD fdwDesiredAccess type of access
3605 * Variables :
3606 * Result :
3607 * Remark :
3608 * Status : UNTESTED STUB
3609 *
3610 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3611 *****************************************************************************/
3612
3613SC_HANDLE WIN32API OpenSCManagerW(LPCWSTR lpszMachineName,
3614 LPCWSTR lpszDatabaseName,
3615 DWORD fdwDesiredAccess)
3616{
3617 dprintf(("ADVAPI32: OpenSCManagerW(%s,%s,%s) not implemented.\n",
3618 lpszMachineName,
3619 lpszDatabaseName,
3620 fdwDesiredAccess));
3621
3622 return (NULL); /* signal failure */
3623}
3624
3625
3626/*****************************************************************************
3627 * Name : OpenServiceA
3628 * Purpose : The OpenService function opens a handle to an existing service.
3629 * Parameters: SC_HANDLE schSCManager handle of service control manager database
3630 * LPCSTR lpszServiceName address of name of service to start
3631 * DWORD fdwDesiredAccess type of access to service
3632 * Variables :
3633 * Result :
3634 * Remark :
3635 * Status : UNTESTED STUB
3636 *
3637 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3638 *****************************************************************************/
3639
3640SC_HANDLE WIN32API OpenServiceA(SC_HANDLE schSCManager,
3641 LPCSTR lpszServiceName,
3642 DWORD fdwDesiredAccess)
3643{
3644 dprintf(("ADVAPI32: OpenServiceA(%08xh,%s,%08xh) not implemented.\n",
3645 schSCManager,
3646 lpszServiceName,
3647 fdwDesiredAccess));
3648
3649 return (NULL); /* signal failure */
3650}
3651
3652
3653/*****************************************************************************
3654 * Name : OpenServiceW
3655 * Purpose : The OpenService function opens a handle to an existing service.
3656 * Parameters: SC_HANDLE schSCManager handle of service control manager database
3657 * LPCWSTR lpszServiceName address of name of service to start
3658 * DWORD fdwDesiredAccess type of access to service
3659 * Variables :
3660 * Result :
3661 * Remark :
3662 * Status : UNTESTED STUB
3663 *
3664 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3665 *****************************************************************************/
3666
3667SC_HANDLE WIN32API OpenServiceW(SC_HANDLE schSCManager,
3668 LPCWSTR lpszServiceName,
3669 DWORD fdwDesiredAccess)
3670{
3671 dprintf(("ADVAPI32: OpenServiceW(%08xh,%s,%08xh) not implemented.\n",
3672 schSCManager,
3673 lpszServiceName,
3674 fdwDesiredAccess));
3675
3676 return (NULL); /* signal failure */
3677}
3678
3679
3680/*****************************************************************************
3681 * Name : PrivilegeCheck
3682 * Purpose : The PrivilegeCheck function tests the security context represented
3683 * by a specific access token to discover whether it contains the
3684 * specified privileges. This function is typically called by a server
3685 * application to check the privileges of a client's access token.
3686 * Parameters: HANDLE hClientToken handle of client's access token
3687 * PPRIVILEGE_SET pps address of privileges
3688 * LPBOOL lpfResult address of flag for result
3689 * Variables :
3690 * Result :
3691 * Remark :
3692 * Status : UNTESTED STUB
3693 *
3694 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3695 *****************************************************************************/
3696
3697BOOL WIN32API PrivilegeCheck(HANDLE hClientToken,
3698 PPRIVILEGE_SET pps,
3699 LPBOOL lpfResult)
3700{
3701 dprintf(("ADVAPI32: PrivilegeCheck(%08xh,%08xh,%08xh) not implemented.\n",
3702 hClientToken,
3703 pps,
3704 lpfResult));
3705
3706 return (FALSE); /* signal failure */
3707}
3708
3709
3710/*****************************************************************************
3711 * Name : PrivilegedServiceAuditAlarmA
3712 * Purpose : The PrivilegedServiceAuditAlarm function generates audit messages
3713 * when an attempt is made to perform privileged system service
3714 * operations. Alarms are not supported in the current version of Windows NT.
3715 * Parameters: LPCSTR lpszSubsystem address of string for subsystem name
3716 * LPCSTR lpszService address of string for service name
3717 * HANDLE hClientToken handle of access token
3718 * PPRIVILEGE_SET pps address of privileges
3719 * BOOL fAccessGranted flag for granted access rights
3720 * Variables :
3721 * Result :
3722 * Remark :
3723 * Status : UNTESTED STUB
3724 *
3725 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3726 *****************************************************************************/
3727
3728BOOL WIN32API PrivilegedServiceAuditAlarmA(LPCSTR lpszSubsystem,
3729 LPCSTR lpszService,
3730 HANDLE hClientToken,
3731 PPRIVILEGE_SET pps,
3732 BOOL fAccessGranted)
3733{
3734 dprintf(("ADVAPI32: PrivilegedServiceAuditAlarmA(%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
3735 lpszSubsystem,
3736 lpszService,
3737 hClientToken,
3738 pps,
3739 fAccessGranted));
3740
3741 return (FALSE); /* signal failure */
3742}
3743
3744
3745/*****************************************************************************
3746 * Name : PrivilegedServiceAuditAlarmW
3747 * Purpose : The PrivilegedServiceAuditAlarm function generates audit messages
3748 * when an attempt is made to perform privileged system service
3749 * operations. Alarms are not supported in the current version of Windows NT.
3750 * Parameters: LPCWSTR lpszSubsystem address of string for subsystem name
3751 * LPCWSTR lpszService address of string for service name
3752 * HANDLE hClientToken handle of access token
3753 * PPRIVILEGE_SET pps address of privileges
3754 * BOOL fAccessGranted flag for granted access rights
3755 * Variables :
3756 * Result :
3757 * Remark :
3758 * Status : UNTESTED STUB
3759 *
3760 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3761 *****************************************************************************/
3762
3763BOOL WIN32API PrivilegedServiceAuditAlarmW(LPCWSTR lpszSubsystem,
3764 LPCWSTR lpszService,
3765 HANDLE hClientToken,
3766 PPRIVILEGE_SET pps,
3767 BOOL fAccessGranted)
3768{
3769 dprintf(("ADVAPI32: PrivilegedServiceAuditAlarmW(%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
3770 lpszSubsystem,
3771 lpszService,
3772 hClientToken,
3773 pps,
3774 fAccessGranted));
3775
3776 return (FALSE); /* signal failure */
3777}
3778
3779
3780/*****************************************************************************
3781 * Name : QueryServiceConfigA
3782 * Purpose : The QueryServiceConfig function retrieves the configuration
3783 * parameters of the specified service.
3784 * Parameters: SC_HANDLE schService handle of service
3785 * LPQUERY_SERVICE_CONFIG lpqscServConfig address of service config. structure
3786 * DWORD cbBufSize size of service configuration buffer
3787 * LPDWORD lpcbBytesNeeded address of variable for bytes needed
3788 * Variables :
3789 * Result :
3790 * Remark :
3791 * Status : UNTESTED STUB
3792 *
3793 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3794 *****************************************************************************/
3795
3796#define LPQUERY_SERVICE_CONFIG LPVOID
3797BOOL WIN32API QueryServiceConfigA(SC_HANDLE schService,
3798 LPQUERY_SERVICE_CONFIG lpqscServConfig,
3799 DWORD cbBufSize,
3800 LPDWORD lpcbBytesNeeded)
3801{
3802 dprintf(("ADVAPI32: QueryServiceConfigA(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3803 schService,
3804 lpqscServConfig,
3805 cbBufSize,
3806 lpcbBytesNeeded));
3807
3808 return (FALSE); /* signal failure */
3809}
3810
3811
3812/*****************************************************************************
3813 * Name : QueryServiceConfigW
3814 * Purpose : The QueryServiceConfig function retrieves the configuration
3815 * parameters of the specified service.
3816 * Parameters: SC_HANDLE schService handle of service
3817 * LPQUERY_SERVICE_CONFIG lpqscServConfig address of service config. structure
3818 * DWORD cbBufSize size of service configuration buffer
3819 * LPDWORD lpcbBytesNeeded address of variable for bytes needed
3820 * Variables :
3821 * Result :
3822 * Remark :
3823 * Status : UNTESTED STUB
3824 *
3825 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3826 *****************************************************************************/
3827
3828BOOL WIN32API QueryServiceConfigW(SC_HANDLE schService,
3829 LPQUERY_SERVICE_CONFIG lpqscServConfig,
3830 DWORD cbBufSize,
3831 LPDWORD lpcbBytesNeeded)
3832{
3833 dprintf(("ADVAPI32: QueryServiceConfigW(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3834 schService,
3835 lpqscServConfig,
3836 cbBufSize,
3837 lpcbBytesNeeded));
3838
3839 return (FALSE); /* signal failure */
3840}
3841
3842
3843/*****************************************************************************
3844 * Name : QueryServiceLockStatusA
3845 * Purpose : The QueryServiceLockStatus function retrieves the lock status
3846 * of the specified service control manager database.
3847 * Parameters: SC_HANDLE schSCManager handle of svc. ctrl. mgr. database
3848 * LPQUERY_SERVICE_LOCK_STATUS lpqslsLockStat address of lock status structure
3849 * DWORD cbBufSize size of service configuration buffer
3850 * LPDWORD lpcbBytesNeeded address of variable for bytes needed
3851 * Variables :
3852 * Result :
3853 * Remark :
3854 * Status : UNTESTED STUB
3855 *
3856 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3857 *****************************************************************************/
3858
3859#define LPQUERY_SERVICE_LOCK_STATUS LPVOID
3860BOOL WIN32API QueryServiceLockStatusA(SC_HANDLE schSCManager,
3861 LPQUERY_SERVICE_LOCK_STATUS lpqslsLockStat,
3862 DWORD cbBufSize,
3863 LPDWORD lpcbBytesNeeded)
3864{
3865 dprintf(("ADVAPI32: QueryServiceLockStatusA(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3866 schSCManager,
3867 lpqslsLockStat,
3868 cbBufSize,
3869 lpcbBytesNeeded));
3870
3871 return (FALSE); /* signal failure */
3872}
3873
3874
3875/*****************************************************************************
3876 * Name : QueryServiceLockStatusW
3877 * Purpose : The QueryServiceLockStatus function retrieves the lock status
3878 * of the specified service control manager database.
3879 * Parameters: SC_HANDLE schSCManager handle of svc. ctrl. mgr. database
3880 * LPQUERY_SERVICE_LOCK_STATUS lpqslsLockStat address of lock status structure
3881 * DWORD cbBufSize size of service configuration buffer
3882 * LPDWORD lpcbBytesNeeded address of variable for bytes needed
3883 * Variables :
3884 * Result :
3885 * Remark :
3886 * Status : UNTESTED STUB
3887 *
3888 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3889 *****************************************************************************/
3890
3891BOOL WIN32API QueryServiceLockStatusW(SC_HANDLE schSCManager,
3892 LPQUERY_SERVICE_LOCK_STATUS lpqslsLockStat,
3893 DWORD cbBufSize,
3894 LPDWORD lpcbBytesNeeded)
3895{
3896 dprintf(("ADVAPI32: QueryServiceLockStatusW(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3897 schSCManager,
3898 lpqslsLockStat,
3899 cbBufSize,
3900 lpcbBytesNeeded));
3901
3902 return (FALSE); /* signal failure */
3903}
3904
3905
3906/*****************************************************************************
3907 * Name : QueryServiceObjectSecurity
3908 * Purpose : The QueryServiceObjectSecurity function retrieves a copy of the
3909 * security descriptor protecting a service object.
3910 * Parameters: SC_HANDLE schService handle of service
3911 * SECURITY_INFORMATION fdwSecurityInfo type of security information requested
3912 * PSECURITY_DESCRIPTOR psdSecurityDesc address of security descriptor
3913 * DWORD cbBufSize size of security descriptor buffer
3914 * LPDWORD lpcbBytesNeeded address of variable for bytes needed
3915 * Variables :
3916 * Result :
3917 * Remark :
3918 * Status : UNTESTED STUB
3919 *
3920 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3921 *****************************************************************************/
3922
3923BOOL WIN32API QueryServiceObjectSecurity(SC_HANDLE schService,
3924 SECURITY_INFORMATION fdwSecurityInfo,
3925 PSECURITY_DESCRIPTOR psdSecurityDesc,
3926 DWORD cbBufSize,
3927 LPDWORD lpcbBytesNeeded)
3928{
3929 dprintf(("ADVAPI32: QueryServiceObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3930 schService,
3931 fdwSecurityInfo,
3932 psdSecurityDesc,
3933 cbBufSize,
3934 lpcbBytesNeeded));
3935
3936 return (FALSE); /* signal failure */
3937}
3938
3939
3940/*****************************************************************************
3941 * Name : QueryServiceStatus
3942 * Purpose : The QueryServiceStatus function retrieves the current status of
3943 * the specified service.
3944 * Parameters: SC_HANDLE schService handle of service
3945 * LPSERVICE_STATUS lpssServiceStatus address of service status structure
3946 * Variables :
3947 * Result :
3948 * Remark :
3949 * Status : UNTESTED STUB
3950 *
3951 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3952 *****************************************************************************/
3953
3954BOOL WIN32API QueryServiceStatus(SC_HANDLE schService,
3955 LPSERVICE_STATUS lpssServiceStatus)
3956{
3957 dprintf(("ADVAPI32: QueryServiceStatus(%08xh,%08xh) not implemented.\n",
3958 schService,
3959 lpssServiceStatus));
3960
3961 return (FALSE); /* signal failure */
3962}
3963
3964
3965/*****************************************************************************
3966 * Name : ReadEventLogW
3967 * Purpose : The ReadEventLog function reads a whole number of entries from
3968 * the specified event log. The function can be used to read log
3969 * entries in forward or reverse chronological order.
3970 * Parameters: HANDLE hEventLog handle of event log
3971 * DWORD dwReadFlags specifies how to read log
3972 * DWORD dwRecordOffset number of first record
3973 * LPVOID lpBuffer address of buffer for read data
3974 * DWORD nNumberOfBytesToRead number of bytes to read
3975 * DWORD *pnBytesRea number of bytes read
3976 * DWORD *pnMinNumberOfBytesNeeded number of bytes required for next record
3977 * Variables :
3978 * Result :
3979 * Remark :
3980 * Status : UNTESTED STUB
3981 *
3982 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
3983 *****************************************************************************/
3984
3985BOOL WIN32API ReadEventLogW(HANDLE hEventLog,
3986 DWORD dwReadFlags,
3987 DWORD dwRecordOffset,
3988 LPVOID lpBuffer,
3989 DWORD nNumberOfBytesToRead,
3990 DWORD *pnBytesRead,
3991 DWORD *pnMinNumberOfBytesNeeded)
3992{
3993 dprintf(("ADVAPI32: ReadEventLogW(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
3994 hEventLog,
3995 dwReadFlags,
3996 dwRecordOffset,
3997 lpBuffer,
3998 nNumberOfBytesToRead,
3999 pnBytesRead,
4000 pnMinNumberOfBytesNeeded));
4001
4002 return (FALSE); /* signal failure */
4003}
4004
4005
4006/*****************************************************************************
4007 * Name : ReadEventLogA
4008 * Purpose : The ReadEventLog function reads a whole number of entries from
4009 * the specified event log. The function can be used to read log
4010 * entries in forward or reverse chronological order.
4011 * Parameters: HANDLE hEventLog handle of event log
4012 * DWORD dwReadFlags specifies how to read log
4013 * DWORD dwRecordOffset number of first record
4014 * LPVOID lpBuffer address of buffer for read data
4015 * DWORD nNumberOfBytesToRead number of bytes to read
4016 * DWORD *pnBytesRea number of bytes read
4017 * DWORD *pnMinNumberOfBytesNeeded number of bytes required for next record
4018 * Variables :
4019 * Result :
4020 * Remark :
4021 * Status : UNTESTED STUB
4022 *
4023 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4024 *****************************************************************************/
4025
4026BOOL WIN32API ReadEventLogA(HANDLE hEventLog,
4027 DWORD dwReadFlags,
4028 DWORD dwRecordOffset,
4029 LPVOID lpBuffer,
4030 DWORD nNumberOfBytesToRead,
4031 DWORD *pnBytesRead,
4032 DWORD *pnMinNumberOfBytesNeeded)
4033{
4034 dprintf(("ADVAPI32: ReadEventLogA(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4035 hEventLog,
4036 dwReadFlags,
4037 dwRecordOffset,
4038 lpBuffer,
4039 nNumberOfBytesToRead,
4040 pnBytesRead,
4041 pnMinNumberOfBytesNeeded));
4042
4043 return (FALSE); /* signal failure */
4044}
4045
4046
4047/*****************************************************************************
4048 * Name : RegisterServiceCtrlHandlerA
4049 * Purpose : The RegisterServiceCtrlHandler function registers a function to
4050 * handle service control requests for a service.
4051 * Parameters: LPCSTR lpszServiceName address of name of service
4052 * LPHANDLER_FUNCTION lpHandlerProc address of handler function
4053 * Variables :
4054 * Result :
4055 * Remark :
4056 * Status : UNTESTED STUB
4057 *
4058 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4059 *****************************************************************************/
4060
4061#define SERVICE_STATUS_HANDLE DWORD
4062#define LPHANDLER_FUNCTION LPVOID
4063SERVICE_STATUS_HANDLE WIN32API RegisterServiceCtrlHandlerA(LPCSTR lpszServiceName,
4064 LPHANDLER_FUNCTION lpHandlerProc)
4065{
4066 dprintf(("ADVAPI32: RegisterServiceCtrlHandlerA(%s,%08xh) not implemented.\n",
4067 lpszServiceName,
4068 lpHandlerProc));
4069
4070 return (0); /* signal failure */
4071}
4072
4073
4074/*****************************************************************************
4075 * Name : RegisterServiceCtrlHandlerW
4076 * Purpose : The RegisterServiceCtrlHandler function registers a function to
4077 * handle service control requests for a service.
4078 * Parameters: LPCWSTR lpszServiceName address of name of service
4079 * LPHANDLER_FUNCTION lpHandlerProc address of handler function
4080 * Variables :
4081 * Result :
4082 * Remark :
4083 * Status : UNTESTED STUB
4084 *
4085 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4086 *****************************************************************************/
4087
4088SERVICE_STATUS_HANDLE WIN32API RegisterServiceCtrlHandlerW(LPCWSTR lpszServiceName,
4089 LPHANDLER_FUNCTION lpHandlerProc)
4090{
4091 dprintf(("ADVAPI32: RegisterServiceCtrlHandlerW(%s,%08xh) not implemented.\n",
4092 lpszServiceName,
4093 lpHandlerProc));
4094
4095 return (0); /* signal failure */
4096}
4097
4098
4099
4100/*****************************************************************************
4101 * Name : RevertToSelf
4102 * Purpose : The RevertToSelf function terminates the impersonation of a client application.
4103 * Parameters:
4104 * Variables :
4105 * Result :
4106 * Remark :
4107 * Status : UNTESTED STUB
4108 *
4109 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4110 *****************************************************************************/
4111
4112BOOL WIN32API RevertToSelf(VOID)
4113{
4114 dprintf(("ADVAPI32: RevertToSelf() not implemented.\n"));
4115
4116 return (TRUE); /* signal OK */
4117}
4118
4119
4120/*****************************************************************************
4121 * Name : SetAclInformation
4122 * Purpose : The SetAclInformation function sets information about an access-control list (ACL).
4123 * Parameters: PACL pAcl address of access-control list
4124 * LPVOID lpvAclInfo address of ACL information
4125 * DWORD cbAclInfo size of ACL information
4126 * ACL_INFORMATION_CLASS aclic specifies class of requested info
4127 * Variables :
4128 * Result :
4129 * Remark :
4130 * Status : UNTESTED STUB
4131 *
4132 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4133 *****************************************************************************/
4134
4135#define ACL_INFORMATION_CLASS DWORD
4136BOOL WIN32API SetAclInformation(PACL pAcl,
4137 LPVOID lpvAclInfo,
4138 DWORD cbAclInfo,
4139 ACL_INFORMATION_CLASS aclic)
4140{
4141 dprintf(("ADVAPI32: SetAclInformation(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4142 pAcl,
4143 lpvAclInfo,
4144 cbAclInfo,
4145 aclic));
4146
4147 return (FALSE); /* signal failure */
4148}
4149
4150
4151/*****************************************************************************
4152 * Name : SetKernelObjectSecurity
4153 * Purpose : The SetKernelObjectSecurity function sets the security of a kernel
4154 * object. For example, this can be a process, thread, or event.
4155 * Parameters: HANDLE hObject handle of object
4156 * SECURITY_INFORMATION si type of information to set
4157 * PSECURITY_DESCRIPTOR psd address of security descriptor
4158 * Variables :
4159 * Result :
4160 * Remark :
4161 * Status : UNTESTED STUB
4162 *
4163 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4164 *****************************************************************************/
4165
4166BOOL WIN32API SetKernelObjectSecurity(HANDLE hObject,
4167 SECURITY_INFORMATION si,
4168 PSECURITY_DESCRIPTOR psd)
4169{
4170 dprintf(("ADVAPI32: SetKernelObjectSecurity(%08xh,%08xh,%08xh) not implemented.\n",
4171 hObject,
4172 si,
4173 psd));
4174
4175 return (FALSE); /* signal failure */
4176}
4177
4178
4179/*****************************************************************************
4180 * Name : SetPrivateObjectSecurity
4181 * Purpose : The SetPrivateObjectSecurity function modifies a private
4182 * object's security descriptor.
4183 * Parameters: SECURITY_INFORMATION si type of security information
4184 * PSECURITY_DESCRIPTOR psdSource address of SD to apply to object
4185 * PSECURITY_DESCRIPTOR *lppsdTarget address of object's SD
4186 * PGENERIC_MAPPING pgm address of access-mapping structure
4187 * HANDLE hClientToken handle of client access token
4188 * Variables :
4189 * Result :
4190 * Remark :
4191 * Status : UNTESTED STUB
4192 *
4193 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4194 *****************************************************************************/
4195
4196BOOL WIN32API SetPrivateObjectSecurity(SECURITY_INFORMATION si,
4197 PSECURITY_DESCRIPTOR psdSource,
4198 PSECURITY_DESCRIPTOR *lppsdTarget,
4199 PGENERIC_MAPPING pgm,
4200 HANDLE hClientToken)
4201{
4202 dprintf(("ADVAPI32: SetPrivateObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4203 si,
4204 psdSource,
4205 lppsdTarget,
4206 pgm,
4207 hClientToken));
4208
4209 return (FALSE); /* signal failure */
4210}
4211
4212
4213/*****************************************************************************
4214 * Name : SetSecurityDescriptorGroup
4215 * Purpose : The SetSecurityDescriptorGroup function sets the primary group
4216 * information of an absolute-format security descriptor, replacing
4217 * any primary group information already present in the security descriptor.
4218 * Parameters: PSECURITY_DESCRIPTOR psd address of security descriptor
4219 * PSID psidGroup address of SID for group
4220 * BOOL fGroupDefaulted flag for default
4221 * Variables :
4222 * Result :
4223 * Remark :
4224 * Status : UNTESTED STUB
4225 *
4226 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4227 *****************************************************************************/
4228
4229BOOL WIN32API SetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR psd,
4230 PSID psidGroup,
4231 BOOL fGroupDefaulted)
4232{
4233 dprintf(("ADVAPI32: SetSecurityDescriptorGroup(%08xh,%08xh,%08xh) not implemented.\n",
4234 psd,
4235 psidGroup,
4236 fGroupDefaulted));
4237
4238 return (FALSE); /* signal failure */
4239}
4240
4241
4242/*****************************************************************************
4243 * Name : SetSecurityDescriptorOwner
4244 * Purpose : The SetSecurityDescriptorOwner function sets the owner information
4245 * of an absolute-format security descriptor. It replaces any owner
4246 * information already present in the security descriptor.
4247 * Parameters: PSECURITY_DESCRIPTOR psd address of security descriptor
4248 * PSID psidOwner address of SID for owner
4249 * BOOL fOwnerDefaulted flag for default
4250 * Variables :
4251 * Result :
4252 * Remark :
4253 * Status : UNTESTED STUB
4254 *
4255 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4256 *****************************************************************************/
4257
4258BOOL WIN32API SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR psd,
4259 PSID psidOwner,
4260 BOOL fOwnerDefaulted)
4261{
4262 dprintf(("ADVAPI32: SetSecurityDescriptorOwner(%08xh,%08xh,%08xh) not implemented.\n",
4263 psd,
4264 psidOwner,
4265 fOwnerDefaulted));
4266
4267 return (FALSE); /* signal failure */
4268}
4269
4270
4271/*****************************************************************************
4272 * Name : SetSecurityDescriptorSacl
4273 * Purpose : The SetSecurityDescriptorSacl function sets information in a
4274 * system access-control list (ACL). If there is already a system
4275 * ACL present in the security descriptor, it is replaced.
4276 * Parameters:
4277 * Variables :
4278 * Result :
4279 * Remark :
4280 * Status : UNTESTED STUB
4281 *
4282 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4283 *****************************************************************************/
4284
4285BOOL WIN32API SetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR psd,
4286 BOOL fSaclPresent,
4287 PACL pAcl,
4288 BOOL fSaclDefaulted)
4289{
4290 dprintf(("ADVAPI32: SetSecurityDescriptorSacl(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4291 psd,
4292 fSaclPresent,
4293 pAcl,
4294 fSaclDefaulted));
4295
4296 return (FALSE); /* signal failure */
4297}
4298
4299
4300/*****************************************************************************
4301 * Name : SetServiceBits
4302 * Purpose : The SetServiceBits function registers a service's service type
4303 * with the Service Control Manager and the Server service. The
4304 * Server service can then announce the registered service type
4305 * as one it currently supports. The LAN Manager functions
4306 * NetServerGetInfo and NetServerEnum obtain a specified machine's
4307 * supported service types.
4308 * A service type is represented as a set of bit flags; the
4309 * SetServiceBits function sets or clears combinations of those bit flags.
4310 * Parameters: SERVICE_STATUS_HANDLE hServiceStatus service status handle
4311 * DWORD dwServiceBits service type bits to set or clear
4312 * BOOL bSetBitsOn flag to set or clear the service type bits
4313 * BOOL bUpdateImmediately flag to announce server type immediately
4314 * Variables :
4315 * Result :
4316 * Remark :
4317 * Status : UNTESTED STUB
4318 *
4319 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4320 *****************************************************************************/
4321
4322BOOL WIN32API SetServiceBits(SERVICE_STATUS_HANDLE hServiceStatus,
4323 DWORD dwServiceBits,
4324 BOOL bSetBitsOn,
4325 BOOL bUpdateImmediately)
4326{
4327 dprintf(("ADVAPI32: SetServiceBits(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4328 hServiceStatus,
4329 dwServiceBits,
4330 bSetBitsOn,
4331 bUpdateImmediately));
4332
4333 return (FALSE); /* signal failure */
4334}
4335
4336
4337/*****************************************************************************
4338 * Name : SetServiceObjectSecurity
4339 * Purpose : The SetServiceObjectSecurity function sets the security
4340 * descriptor of a service object.
4341 * Parameters: SC_HANDLE schService handle of service
4342 * SECURITY_INFORMATION fdwSecurityInfo type of security information requested
4343 * PSECURITY_DESCRIPTOR psdSecurityDesc address of security descriptor
4344 * Variables :
4345 * Result :
4346 * Remark :
4347 * Status : UNTESTED STUB
4348 *
4349 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4350 *****************************************************************************/
4351
4352BOOL WIN32API SetServiceObjectSecurity(SC_HANDLE schService,
4353 SECURITY_INFORMATION fdwSecurityInfo,
4354 PSECURITY_DESCRIPTOR psdSecurityDesc)
4355{
4356 dprintf(("ADVAPI32: SetServiceObjectSecurity(%08xh,%08xh,%08xh) not implemented.\n",
4357 schService,
4358 fdwSecurityInfo,
4359 psdSecurityDesc));
4360
4361 return (FALSE); /* signal failure */
4362}
4363
4364
4365/*****************************************************************************
4366 * Name : SetServiceStatus
4367 * Purpose : The SetServiceStatus function updates the service control
4368 * manager's status information for the calling service.
4369 * Parameters: SERVICE_STATUS_HANDLE sshServiceStatus service status handle
4370 * LPSERVICE_STATUS lpssServiceStatus address of status structure
4371 * Variables :
4372 * Result :
4373 * Remark :
4374 * Status : UNTESTED STUB
4375 *
4376 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4377 *****************************************************************************/
4378
4379BOOL WIN32API SetServiceStatus(SERVICE_STATUS_HANDLE sshServiceStatus,
4380 LPSERVICE_STATUS lpssServiceStatus)
4381{
4382 dprintf(("ADVAPI32: SetServiceStatus(%08xh,%08xh) not implemented.\n",
4383 sshServiceStatus,
4384 lpssServiceStatus));
4385
4386 return (FALSE); /* signal failure */
4387}
4388
4389
4390/*****************************************************************************
4391 * Name : SetTokenInformation
4392 * Purpose : The SetTokenInformation function sets various types of
4393 * information for a specified access token. The information it
4394 * sets replaces existing information. The calling process must
4395 * have appropriate access rights to set the information.
4396 * Parameters: HANDLE hToken handle of access token
4397 * TOKEN_INFORMATION_CLASS tic type of information to set
4398 * LPVOID lpvInformation address of information to set
4399 * DWORD cbInformation size of information buffer
4400 * Variables :
4401 * Result :
4402 * Remark :
4403 * Status : UNTESTED STUB
4404 *
4405 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4406 *****************************************************************************/
4407
4408#define TOKEN_INFORMATION_CLASS DWORD
4409BOOL WIN32API SetTokenInformation(HANDLE hToken,
4410 TOKEN_INFORMATION_CLASS tic,
4411 LPVOID lpvInformation,
4412 DWORD cbInformation)
4413{
4414 dprintf(("ADVAPI32: SetTokenInformation(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
4415 hToken,
4416 tic,
4417 lpvInformation,
4418 cbInformation));
4419
4420 return (FALSE); /* signal failure */
4421}
4422
4423
4424/*****************************************************************************
4425 * Name : StartServiceA
4426 * Purpose : The StartService function starts the execution of a service.
4427 * Parameters: SC_HANDLE schService handle of service
4428 * DWORD dwNumServiceArgs number of arguments
4429 * LPCSTR *lpszServiceArgs address of array of argument string pointers
4430 * Variables :
4431 * Result :
4432 * Remark :
4433 * Status : UNTESTED STUB
4434 *
4435 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4436 *****************************************************************************/
4437
4438BOOL WIN32API StartServiceA(SC_HANDLE schService,
4439 DWORD dwNumServiceArgs,
4440 LPCSTR *lpszServiceArgs)
4441{
4442 dprintf(("ADVAPI32: StartServiceA(%08xh,%08xh,%s) not implemented.\n",
4443 schService,
4444 dwNumServiceArgs,
4445 lpszServiceArgs));
4446
4447 return (FALSE); /* signal failure */
4448}
4449
4450
4451/*****************************************************************************
4452 * Name : StartServiceCtrlDispatcherW
4453 * Purpose : The StartServiceCtrlDispatcher function connects the main thread
4454 * of a service process to the service control manager, which causes
4455 * the thread to be the service control dispatcher thread for the calling process.
4456 * Parameters: LPSERVICE_TABLE_ENTRY lpsteServiceTable address of service table
4457 * Variables :
4458 * Result :
4459 * Remark :
4460 * Status : UNTESTED STUB
4461 *
4462 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4463 *****************************************************************************/
4464
4465#define LPSERVICE_TABLE_ENTRY LPVOID
4466BOOL WIN32API StartServiceCtrlDispatcherW(LPSERVICE_TABLE_ENTRY lpsteServiceTable)
4467{
4468 dprintf(("ADVAPI32: StartServiceCtrlDispatcherW(%08xh) not implemented.\n",
4469 lpsteServiceTable));
4470
4471 return (FALSE); /* signal failure */
4472}
4473
4474
4475/*****************************************************************************
4476 * Name : StartServiceCtrlDispatcherA
4477 * Purpose : The StartServiceCtrlDispatcher function connects the main thread
4478 * of a service process to the service control manager, which causes
4479 * the thread to be the service control dispatcher thread for the calling process.
4480 * Parameters: LPSERVICE_TABLE_ENTRY lpsteServiceTable address of service table
4481 * Variables :
4482 * Result :
4483 * Remark :
4484 * Status : UNTESTED STUB
4485 *
4486 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4487 *****************************************************************************/
4488
4489BOOL WIN32API StartServiceCtrlDispatcherA(LPSERVICE_TABLE_ENTRY lpsteServiceTable)
4490{
4491 dprintf(("ADVAPI32: StartServiceCtrlDispatcherA(%08xh) not implemented.\n",
4492 lpsteServiceTable));
4493
4494 return (FALSE); /* signal failure */
4495}
4496
4497
4498/*****************************************************************************
4499 * Name : StartServiceW
4500 * Purpose : The StartService function starts the execution of a service.
4501 * Parameters: SC_HANDLE schService handle of service
4502 * DWORD dwNumServiceArgs number of arguments
4503 * LPCWSTR *lpszServiceArgs address of array of argument string pointers
4504 * Variables :
4505 * Result :
4506 * Remark :
4507 * Status : UNTESTED STUB
4508 *
4509 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4510 *****************************************************************************/
4511
4512BOOL WIN32API StartServiceW(SC_HANDLE schService,
4513 DWORD dwNumServiceArgs,
4514 LPCWSTR *lpszServiceArgs)
4515{
4516 dprintf(("ADVAPI32: StartServiceW(%08xh,%08xh,%s) not implemented.\n",
4517 schService,
4518 dwNumServiceArgs,
4519 lpszServiceArgs));
4520
4521 return (FALSE); /* signal failure */
4522}
4523
4524
4525/*****************************************************************************
4526 * Name : UnlockServiceDatabase
4527 * Purpose : The UnlockServiceDatabase function unlocks a service control
4528 * manager database by releasing the specified lock.
4529 * Parameters: SC_LOCK sclLock service control manager database lock to be released
4530 * Variables :
4531 * Result :
4532 * Remark :
4533 * Status : UNTESTED STUB
4534 *
4535 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
4536
4537 *****************************************************************************/
4538
4539BOOL WIN32API UnlockServiceDatabase(SC_LOCK sclLock)
4540{
4541 dprintf(("ADVAPI32: UnlockServiceDatabase(%08xh) not implemented.\n",
4542 sclLock));
4543
4544 return (FALSE); /* signal failure */
4545}
4546
Note: See TracBrowser for help on using the repository browser.