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

Last change on this file since 497 was 480, checked in by phaller, 26 years ago

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