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

Last change on this file since 6420 was 5594, checked in by sandervl, 25 years ago

IsTextUnicode forwarded to RtlIsTextUnicode (ntdll)
File size: 74.6 KB
Line 
1/* $Id: ADVAPI32.CPP,v 1.18 2001-04-26 17:00:33 sandervl Exp $ */
2
3/*
4 * Win32 advanced API functions for OS/2
5 *
6 * 1998/06/12
7 *
8 * Copyright 1998 Sander van Leeuwen
9 * Copyright 1998 Patrick Haller
10 *
11 * @(#) ADVAPI32.C 1.0.1 1998/06/14 PH added stubs
12 *
13 *
14 * Project Odin Software License can be found in LICENSE.TXT
15 *
16 */
17
18
19/*****************************************************************************
20 * Includes *
21 *****************************************************************************/
22
23#include <os2win.h>
24#include <stdlib.h>
25#include <stdarg.h>
26#include <string.h>
27#include <odinwrap.h>
28#include "misc.h"
29#include "advapi32.h"
30#include "unicode.h"
31#include "winreg.h"
32#include <heapstring.h>
33
34ODINDEBUGCHANNEL(ADVAPI32-ADVAPI32)
35
36
37/*****************************************************************************
38 * Defines *
39 *****************************************************************************/
40
41 /* this define enables certain less important debug messages */
42//#define DEBUG_LOCAL 1
43
44
45/*****************************************************************************
46 * Name : SetTokenInformation
47 * Purpose : The SetTokenInformation function sets various types of
48 * information for a specified access token. The information it
49 * sets replaces existing information. The calling process must
50 * have appropriate access rights to set the information.
51 * Parameters: HANDLE hToken handle of access token
52 * TOKEN_INFORMATION_CLASS tic type of information to set
53 * LPVOID lpvInformation address of information to set
54 * DWORD cbInformation size of information buffer
55 * Variables :
56 * Result :
57 * Remark :
58 * Status : UNTESTED STUB
59 *
60 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
61 *****************************************************************************/
62
63BOOL WIN32API SetTokenInformation(HANDLE hToken,
64 TOKEN_INFORMATION_CLASS tic,
65 LPVOID lpvInformation,
66 DWORD cbInformation)
67{
68 dprintf(("ADVAPI32: SetTokenInformation(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
69 hToken,
70 tic,
71 lpvInformation,
72 cbInformation));
73
74 return (FALSE); /* signal failure */
75}
76
77//******************************************************************************
78//******************************************************************************
79BOOL WIN32API GetUserNameA( /*PLF Wed 98-02-11 13:33:39*/
80 LPTSTR lpBuffer, /* address of name buffer */
81 LPDWORD lpcchBuffer) /* address of size of name buffer */
82
83
84 /* The GetUserName function retrieves the user name of the current
85 * thread. This is the name of the user currently logged onto the
86 * system.
87 */
88
89{
90 #define USERNAME "USER"
91 if(*lpcchBuffer < sizeof(USERNAME))
92 return FALSE;
93 strcpy(lpBuffer, USERNAME);
94 return TRUE;
95}
96//******************************************************************************
97//******************************************************************************
98BOOL WIN32API GetUserNameW( /*KSO Thu 21.05.1998 */
99 LPWSTR lpBuffer,
100 LPDWORD lpccBuffer
101 )
102{
103
104 if ( *lpccBuffer >= sizeof(USERNAME)*2 )
105 {
106 AsciiToUnicode(USERNAME, lpBuffer);
107 return TRUE;
108 }
109 return FALSE;
110}
111//******************************************************************************
112//******************************************************************************
113
114
115
116/*PLF Sat 98-03-07 02:59:20*/
117
118/*****************************************************************************
119 * Name : AbortSystemShutdownA
120 * Purpose : The AbortSystemShutdown function stops a system shutdown started
121 * by using the InitiateSystemShutdown function.
122 * Parameters: LPTSTR lpMachineName address of name of computer to stop shutting down
123 * Variables :
124 * Result :
125 * Remark :
126 * Status : UNTESTED STUB
127 *
128 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
129 *****************************************************************************/
130
131BOOL WIN32API AbortSystemShutdownA(LPTSTR lpMachineName)
132{
133 dprintf(("ADVAPI32: AbortSystemShutdownA(%s) not implemented.\n",
134 lpMachineName));
135
136 return (FALSE);
137}
138
139
140/*****************************************************************************
141 * Name : AbortSystemShutdownW
142 * Purpose : The AbortSystemShutdown function stops a system shutdown started
143 * by using the InitiateSystemShutdown function.
144 * Parameters: LPWSTR lpMachineName address of name of computer to stop shutting down
145 * Variables :
146 * Result :
147 * Remark :
148 * Status : UNTESTED STUB
149 *
150 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
151 *****************************************************************************/
152
153BOOL WIN32API AbortSystemShutdownW(LPWSTR lpMachineName)
154{
155 dprintf(("ADVAPI32: AbortSystemShutdownW(%s) not implemented.\n",
156 lpMachineName));
157
158 return (FALSE);
159}
160
161
162
163
164/*****************************************************************************
165 * Name : AccessCheckAndAuditAlarmA
166 * Purpose : The AccessCheckAndAuditAlarm function performs an access
167 * validation and generates corresponding audit messages. An
168 * application can also use this function to determine whether
169 * necessary privileges are held by a client process. This function
170 * is generally used by a server application impersonating a client
171 * process. Alarms are not supported in the current version of Windows NT.
172 * Parameters: LPCSTR SubsystemName address of string for subsystem name
173 * LPVOID HandleId address of handle identifier
174 * LPTSTR ObjectTypeName address of string for object type
175 * LPTSTR ObjectName address of string for object name
176 * PSECURITY_DESCRIPTOR SecurityDescriptor address of security descriptor
177 * DWORD DesiredAccess mask for requested access rights
178 * PGENERIC_MAPPING GenericMapping address of GENERIC_MAPPING
179 * BOOL ObjectCreation object-creation flag
180 * LPDWORD GrantedAccess address of mask for granted rights
181 * LPBOOL AccessStatus address of flag for results
182 * LPBOOL pfGenerateOnClose address of flag for audit generation
183 * Variables :
184 * Result :
185 * Remark :
186 * Status : UNTESTED STUB
187 *
188 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
189 *****************************************************************************/
190
191BOOL WIN32API AccessCheckAndAuditAlarmA(LPCSTR SubsystemName,
192 LPVOID HandleId,
193 LPTSTR ObjectTypeName,
194 LPTSTR ObjectName,
195 PSECURITY_DESCRIPTOR SecurityDescriptor,
196 DWORD DesiredAccess,
197 PGENERIC_MAPPING GenericMapping,
198 BOOL ObjectCreation,
199 LPDWORD GrantedAccess,
200 LPBOOL AccessStatus,
201 LPBOOL pfGenerateOnClose)
202{
203 dprintf(("ADVAPI32: AccessCheckAndAuditAlarmA(%s,%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
204 SubsystemName,
205 HandleId,
206 ObjectTypeName,
207 ObjectName,
208 SecurityDescriptor,
209 DesiredAccess,
210 GenericMapping,
211 ObjectCreation,
212 GrantedAccess,
213 AccessStatus,
214 pfGenerateOnClose));
215
216 return (FALSE);
217}
218
219
220/*****************************************************************************
221 * Name : AccessCheckAndAuditAlarmW
222 * Purpose : The AccessCheckAndAuditAlarm function performs an access
223 * validation and generates corresponding audit messages. An
224 * application can also use this function to determine whether
225 * necessary privileges are held by a client process. This function
226 * is generally used by a server application impersonating a client
227 * process. Alarms are not supported in the current version of Windows NT.
228 * Parameters: LPCSTR SubsystemName address of string for subsystem name
229 * LPVOID HandleId address of handle identifier
230 * LPTSTR ObjectTypeName address of string for object type
231 * LPTSTR ObjectName address of string for object name
232 * PSECURITY_DESCRIPTOR SecurityDescriptor address of security descriptor
233 * DWORD DesiredAccess mask for requested access rights
234 * PGENERIC_MAPPING GenericMapping address of GENERIC_MAPPING
235 * BOOL ObjectCreation object-creation flag
236 * LPDWORD GrantedAccess address of mask for granted rights
237 * LPBOOL AccessStatus address of flag for results
238 * LPBOOL pfGenerateOnClose address of flag for audit generation
239 * Variables :
240 * Result :
241 * Remark :
242 * Status : UNTESTED STUB
243 *
244 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
245 *****************************************************************************/
246
247BOOL WIN32API AccessCheckAndAuditAlarmW(LPCWSTR SubsystemName,
248 LPVOID HandleId,
249 LPWSTR ObjectTypeName,
250 LPWSTR ObjectName,
251 PSECURITY_DESCRIPTOR SecurityDescriptor,
252 DWORD DesiredAccess,
253 PGENERIC_MAPPING GenericMapping,
254 BOOL ObjectCreation,
255 LPDWORD GrantedAccess,
256 LPBOOL AccessStatus,
257 LPBOOL pfGenerateOnClose)
258{
259 dprintf(("ADVAPI32: AccessCheckAndAuditAlarmW(%s,%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
260 SubsystemName,
261 HandleId,
262 ObjectTypeName,
263 ObjectName,
264 SecurityDescriptor,
265 DesiredAccess,
266 GenericMapping,
267 ObjectCreation,
268 GrantedAccess,
269 AccessStatus,
270 pfGenerateOnClose));
271
272 return (FALSE);
273}
274
275/*****************************************************************************
276 * Name : AddAccessDeniedAce
277 * Purpose : The AddAccessDeniedAce function adds an access-denied ACE to an
278 * ACL. The access is denied to a specified SID. An ACE is an
279 * access-control entry. An ACL is an access-control list. A SID
280 * is a security identifier.
281 * Parameters: PACL pAcl address of access-control list
282 * DWORD dwAceRevision ACL revision level
283 * DWORD AccessMask access mask
284 * PSID pSid address of security identifier
285 * Variables :
286 * Result :
287 * Remark :
288 * Status : UNTESTED STUB
289 *
290 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
291 *****************************************************************************/
292
293BOOL WIN32API AddAccessDeniedAce(PACL pAcl,
294 DWORD dwAceRevision,
295 DWORD AccessMask,
296 PSID pSid)
297{
298 dprintf(("ADVAPI32: AddAccessDeniedAce(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
299 pAcl,
300 dwAceRevision,
301 AccessMask,
302 pSid));
303
304 return (FALSE);
305}
306
307/*****************************************************************************
308 * Name : AddAuditAccessAce
309 * Purpose : The AddAuditAccessAce function adds a system-audit ACE to a
310 * system ACL. The access of a specified SID is audited. An ACE is
311 * an access-control entry. An ACL is an access-control list. A SID
312 * is a security identifier.
313 * Parameters: PACL pAcl address of access-control list
314 * DWORD dwAceRevision ACL revision level
315 * DWORD dwAccessMask access mask
316 * PSID pSid address of security identifier
317 * BOOL bAuditSuccess flag for auditing successful access
318 * BOOL bAuditFailure flag for auditing unsuccessful access attempts
319 * Variables :
320 * Result :
321 * Remark :
322 * Status : UNTESTED STUB
323 *
324 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
325 *****************************************************************************/
326
327BOOL WIN32API AddAuditAccessAce(PACL pAcl,
328 DWORD dwAceRevision,
329 DWORD dwAccessMask,
330 PSID pSid,
331 BOOL bAuditSuccess,
332 BOOL bAuditFailure)
333{
334 dprintf(("ADVAPI32: AddAuditAccessAce(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
335 pAcl,
336 dwAceRevision,
337 dwAccessMask,
338 pSid,
339 bAuditSuccess,
340 bAuditFailure));
341
342 return (FALSE);
343}
344
345
346/*****************************************************************************
347 * Name : AdjustTokenGroups
348 * Purpose : The AdjustTokenGroups function adjusts groups in the specified
349 * access token. TOKEN_ADJUST_GROUPS access is required to enable
350 * or disable groups in an access token.
351 * Parameters: HANDLE TokenHandle handle of token that contains groups
352 * BOOL ResetToDefault flag for default settings
353 * PTOKEN_GROUPS NewState address of new group information
354 * DWORD BufferLength size of buffer for previous information
355 * PTOKEN_GROUPS PreviousState address of previous group information
356 * LPDWORD ReturnLength address of required buffer size
357 * Variables :
358 * Result :
359 * Remark :
360 * Status : UNTESTED STUB
361 *
362 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
363 *****************************************************************************/
364
365BOOL WIN32API AdjustTokenGroups(HANDLE TokenHandle,
366 BOOL ResetToDefault,
367 PTOKEN_GROUPS NewState,
368 DWORD BufferLength,
369 PTOKEN_GROUPS PreviousState,
370 LPDWORD ReturnLength)
371{
372 dprintf(("ADVAPI32: AdjustTokenGroups(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
373 TokenHandle,
374 ResetToDefault,
375 NewState,
376 BufferLength,
377 PreviousState,
378 ReturnLength));
379
380 return (FALSE); /* signal failure */
381}
382
383
384
385/*****************************************************************************
386 * Name : AllocateLocallyUniqueId
387 * Purpose : The AllocateLocallyUniqueId function allocates a locally unique
388 * identifier (LUID).
389 * Parameters: PLUID Luid address of locally unique identifier
390 * Variables :
391 * Result :
392 * Remark :
393 * Status : UNTESTED STUB
394 *
395 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
396 *****************************************************************************/
397
398BOOL WIN32API AllocateLocallyUniqueId(PLUID Luid)
399{
400 dprintf(("ADVAPI32: AllocateLocallyUniqueId(%08xh) not implemented.\n",
401 Luid));
402
403 return (FALSE); /* signal failure */
404}
405
406
407/*****************************************************************************
408 * Name : AreAllAccessesGranted
409 * Purpose : The AreAllAccessesGranted function checks whether a set of
410 * requested access rights has been granted. The access rights are
411 * represented as bit flags in a 32-bit access mask.
412 * Parameters: DWORD GrantedAccess access mask for granted access rights
413 * DWORD DesiredAccess access mask for requested access rights
414 * Variables :
415 * Result :
416 * Remark :
417 * Status : UNTESTED STUB
418 *
419 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
420 *****************************************************************************/
421
422BOOL WIN32API AreAllAccessesGranted(DWORD GrantedAccess,
423 DWORD DesiredAccess)
424{
425 dprintf(("ADVAPI32: AreAllAccessesGranted(%08xh,%08xh) not implemented.\n",
426 GrantedAccess,
427 DesiredAccess));
428
429 return (TRUE); /* grant all access */
430}
431
432
433/*****************************************************************************
434 * Name : AreAnyAccessesGranted
435 * Purpose : The AreAnyAccessesGranted function tests whether any of a set of
436 * requested access rights has been granted. The access rights are
437 * represented as bit flags in a 32-bit access mask.
438 * Parameters: DWORD GrantedAccess access mask for granted access rights
439 * DWORD DesiredAccess access mask for requested access rights
440 * Variables :
441 * Result :
442 * Remark :
443 * Status : UNTESTED STUB
444 *
445 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
446 *****************************************************************************/
447
448BOOL WIN32API AreAnyAccessesGranted(DWORD GrantedAccess,
449 DWORD DesiredAccess)
450{
451 dprintf(("ADVAPI32: AreAnyAccessesGranted(%08xh,%08xh) not implemented.\n",
452 GrantedAccess,
453 DesiredAccess));
454
455 return (TRUE); /* grant all access */
456}
457
458/*****************************************************************************
459 * Name : CreatePrivateObjectSecurity
460 * Purpose : The CreatePrivateObjectSecurity function allocates and initializes
461 * a self-relative security descriptor for a new protected server's
462 * object. This function is called when a new protected server object is being created.
463 * Parameters: PSECURITY_DESCRIPTOR ParentDescriptor address of parent directory SD
464 * PSECURITY_DESCRIPTOR CreatorDescriptor address of creator SD
465 * PSECURITY_DESCRIPTOR *NewDescriptor address of pointer to new SD
466 * BOOL IsDirectoryObject container flag for new SD
467 * HANDLE Token handle of client's access token
468 * PGENERIC_MAPPING GenericMapping address of access-rights structure
469 * Variables :
470 * Result :
471 * Remark :
472 * Status : UNTESTED STUB
473 *
474 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
475 *****************************************************************************/
476
477BOOL WIN32API CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR ParentDescriptor,
478 PSECURITY_DESCRIPTOR CreatorDescriptor,
479 PSECURITY_DESCRIPTOR *NewDescriptor,
480 BOOL IsDirectoryObject,
481 HANDLE Token,
482 PGENERIC_MAPPING GenericMapping)
483{
484 dprintf(("ADVAPI32: CreatePrivateObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
485 ParentDescriptor,
486 CreatorDescriptor,
487 NewDescriptor,
488 IsDirectoryObject,
489 Token,
490 GenericMapping));
491
492 return (FALSE); /* signal failure */
493}
494
495
496/*****************************************************************************
497 * Name : CreateProcessAsUserA
498 * Purpose : The CreateProcessAsUser function creates a new process and its
499 * primary thread. The new process then executes a specified executable
500 * file. The CreateProcessAsUser function behaves just like the
501 * CreateProcess function, with one important difference: the
502 * created process runs in a context in which the system sees the
503 * user represented by the hToken parameter as if that user had
504 * logged on to the system and then called the CreateProcess function.
505 * Parameters: HANDLE hToken handle to a token that represents a logged-on user
506 * LPCSTR lpApplicationName pointer to name of executable module
507 * LPTSTR lpCommandLine pointer to command line string
508 * LPSECURITY_ATTRIBUTES lpProcessAttributes pointer to process security attributes
509 * LPSECURITY_ATTRIBUTES lpThreadAttributes pointer to thread security attributes
510 * BOOL bInheritHandles new process inherits handles
511 * DWORD dwCreationFlags creation flags
512 * LPVOID lpEnvironment pointer to new environment block
513 * LPCSTR lpCurrentDirectory pointer to current directory name
514 * LPSTARTUPINFO lpStartupInfo pointer to STARTUPINFO
515 * LPPROCESS_INFORMATION lpProcessInformation pointer to PROCESS_INFORMATION
516 * Variables :
517 * Result :
518 * Remark :
519 * Status : UNTESTED STUB
520 *
521 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
522 *****************************************************************************/
523
524BOOL WIN32API CreateProcessAsUserA(HANDLE hToken,
525 LPCSTR lpApplicationName,
526 LPTSTR lpCommandLine,
527 LPSECURITY_ATTRIBUTES lpProcessAttributes,
528 LPSECURITY_ATTRIBUTES lpThreadAttributes,
529 BOOL bInheritHandles,
530 DWORD dwCreationFlags,
531 LPVOID lpEnvironment,
532 LPCSTR lpCurrentDirectory,
533 LPSTARTUPINFOA lpStartupInfo,
534 LPPROCESS_INFORMATION lpProcessInformation)
535{
536 dprintf(("ADVAPI32: CreateProcessAsUserA(%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%s,%08xh,%08xh) not implemented.\n",
537 hToken,
538 lpApplicationName,
539 lpCommandLine,
540 lpProcessAttributes,
541 lpThreadAttributes,
542 bInheritHandles,
543 dwCreationFlags,
544 lpEnvironment,
545 lpCurrentDirectory,
546 lpStartupInfo,
547 lpProcessInformation));
548
549 return (FALSE); /* signal failure */
550}
551
552
553/*****************************************************************************
554 * Name : CreateProcessAsUserW
555 * Purpose : The CreateProcessAsUser function creates a new process and its
556 * primary thread. The new process then executes a specified executable
557 * file. The CreateProcessAsUser function behaves just like the
558 * CreateProcess function, with one important difference: the
559 * created process runs in a context in which the system sees the
560 * user represented by the hToken parameter as if that user had
561 * logged on to the system and then called the CreateProcess function.
562 * Parameters: HANDLE hToken handle to a token that represents a logged-on user
563 * LPCWSTR lpApplicationName pointer to name of executable module
564 * LPWSTR lpCommandLine pointer to command line string
565 * LPSECURITY_ATTRIBUTES lpProcessAttributes pointer to process security attributes
566 * LPSECURITY_ATTRIBUTES lpThreadAttributes pointer to thread security attributes
567 * BOOL bInheritHandles new process inherits handles
568 * DWORD dwCreationFlags creation flags
569 * LPVOID lpEnvironment pointer to new environment block
570 * LPCWSTR lpCurrentDirectory pointer to current directory name
571 * LPSTARTUPINFO lpStartupInfo pointer to STARTUPINFO
572 * LPPROCESS_INFORMATION lpProcessInformation pointer to PROCESS_INFORMATION
573 * Variables :
574 * Result :
575 * Remark :
576 * Status : UNTESTED STUB
577 *
578 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
579 *****************************************************************************/
580
581BOOL WIN32API CreateProcessAsUserW(HANDLE hToken,
582 LPCWSTR lpApplicationName,
583 LPWSTR lpCommandLine,
584 LPSECURITY_ATTRIBUTES lpProcessAttributes,
585 LPSECURITY_ATTRIBUTES lpThreadAttributes,
586 BOOL bInheritHandles,
587 DWORD dwCreationFlags,
588 LPVOID lpEnvironment,
589 LPCWSTR lpCurrentDirectory,
590 LPSTARTUPINFOA lpStartupInfo,
591 LPPROCESS_INFORMATION lpProcessInformation)
592{
593 dprintf(("ADVAPI32: CreateProcessAsUserW(%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%s,%08xh,%08xh) not implemented.\n",
594 hToken,
595 lpApplicationName,
596 lpCommandLine,
597 lpProcessAttributes,
598 lpThreadAttributes,
599 bInheritHandles,
600 dwCreationFlags,
601 lpEnvironment,
602 lpCurrentDirectory,
603 lpStartupInfo,
604 lpProcessInformation));
605
606 return (FALSE); /* signal failure */
607}
608
609
610
611/*****************************************************************************
612 * Name : DeleteAce
613 * Purpose : The DeleteAce function deletes an ACE from an ACL.
614 * An ACE is an access-control entry. An ACL is an access-control list.
615 * Parameters: PACL pAcl address of access-control list
616 * DWORD dwAceIndex index of ACE position in ACL
617 * Variables :
618 * Result :
619 * Remark :
620 * Status : UNTESTED STUB
621 *
622 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
623 *****************************************************************************/
624
625BOOL WIN32API DeleteAce(PACL pAcl,
626 DWORD dwAceIndex)
627{
628 dprintf(("ADVAPI32: DeleteAce(%08xh, %08xh) not implemented.\n",
629 pAcl,
630 dwAceIndex));
631
632 return (FALSE); /* signal failure */
633}
634
635
636
637/*****************************************************************************
638 * Name : DestroyPrivateObjectSecurity
639 * Purpose : The DestroyPrivateObjectSecurity function deletes a protected
640 * server object's security descriptor. This security descriptor
641 * must have been created by a call to the CreatePrivateObjectSecurity function.
642 * Parameters: PSECURITY_DESCRIPTOR * ObjectDescriptor address of pointer to SECURITY_DESCRIPTOR
643 * Variables :
644 * Result :
645 * Remark :
646 * Status : UNTESTED STUB
647 *
648 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
649 *****************************************************************************/
650
651BOOL WIN32API DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR *ObjectDescriptor)
652{
653 dprintf(("ADVAPI32: DestroyPrivateObjectSecurity(%08xh) not implemented.\n",
654 ObjectDescriptor));
655
656 return (FALSE); /* signal failure */
657}
658
659
660/*****************************************************************************
661 * Name : DuplicateToken
662 * Purpose : The DuplicateToken function creates a new access token that
663 * duplicates one already in existence.
664 * Parameters: HANDLE ExistingTokenHandle handle of token to duplicate
665 * SECURITY_IMPERSONATION_LEVEL ImpersonationLevel impersonation level
666 * PHANDLE DuplicateTokenHandle handle of duplicated token
667 * Variables :
668 * Result :
669 * Remark :
670 * Status : UNTESTED STUB
671 *
672 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
673 *****************************************************************************/
674
675BOOL WIN32API DuplicateToken(HANDLE ExistingTokenHandle,
676 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
677 PHANDLE DuplicateTokenHandle)
678{
679 dprintf(("ADVAPI32: DuplicateToken(%08x,%08xh,%08xh) not implemented.\n",
680 ExistingTokenHandle,
681 ImpersonationLevel,
682 DuplicateTokenHandle));
683
684 return (FALSE); /* signal failure */
685}
686
687
688
689
690/*****************************************************************************
691 * Name : GetAclInformation
692 * Purpose : The GetAclInformation function retrieves information about an
693 * access-control list (ACL).
694 * Parameters: PACL pAcl address of access-control list
695 * LPVOID pAclInformation address of ACL information
696 * DWORD nAclInformationLength size of ACL information
697 * ACL_INFORMATION_CLASS dwAclInformationClass class of requested information
698 * Variables :
699 * Result :
700 * Remark :
701 * Status : UNTESTED STUB
702 *
703 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
704 *****************************************************************************/
705
706BOOL WIN32API GetAclInformation(PACL pAcl,
707 LPVOID pAclInformation,
708 DWORD nAclInformationLength,
709 ACL_INFORMATION_CLASS dwAclInformationClass)
710{
711 dprintf(("ADVAPI32: GetAclInformation(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
712 pAcl,
713 pAclInformation,
714 nAclInformationLength,
715 dwAclInformationClass));
716
717 return (FALSE); /* signal failure */
718}
719
720
721/*****************************************************************************
722 * Name : GetKernelObjectSecurity
723 * Purpose : The GetKernelObjectSecurity function retrieves a copy of the
724 * security descriptor protecting a kernel object.
725 * Parameters: HANDLE Handle handle of object to query
726 * SECURITY_INFORMATION RequestedInformation requested information
727 * PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
728 * DWORD nLength size of buffer for security descriptor
729 * LPDWORD lpnLengthNeeded address of required size of buffer
730 * Variables :
731 * Result :
732 * Remark :
733 * Status : UNTESTED STUB
734 *
735 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
736 *****************************************************************************/
737
738BOOL WIN32API GetKernelObjectSecurity(HANDLE Handle,
739 SECURITY_INFORMATION RequestedInformation,
740 PSECURITY_DESCRIPTOR pSecurityDescriptor,
741 DWORD nLength,
742 LPDWORD lpnLengthNeeded)
743{
744 dprintf(("ADVAPI32: GetKernelObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
745 Handle,
746 RequestedInformation,
747 pSecurityDescriptor,
748 nLength,
749 lpnLengthNeeded));
750
751 return (FALSE); /* signal failure */
752}
753
754
755
756
757/*****************************************************************************
758 * Name : GetPrivateObjectSecurity
759 * Purpose : The GetPrivateObjectSecurity retrieves information from a
760 * protected server object's security descriptor.
761 * Parameters: PSECURITY_DESCRIPTOR ObjectDescriptor address of SD to query
762 * SECURITY_INFORMATION SecurityInformation requested information
763 * PSECURITY_DESCRIPTOR ResultantDescriptor address of retrieved SD
764 * DWORD DescriptorLength size of buffer for retrieved SD
765 * LPDWORD ReturnLength address of buffer size required for SD
766 * Variables :
767 * Result :
768 * Remark :
769 * Status : UNTESTED STUB
770 *
771 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
772 *****************************************************************************/
773
774BOOL WIN32API GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR ObjectDescriptor,
775 SECURITY_INFORMATION SecurityInformation,
776 PSECURITY_DESCRIPTOR ResultantDescriptor,
777 DWORD DescriptorLength,
778 LPDWORD ReturnLength)
779{
780 dprintf(("ADVAPI32: GetPrivateObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
781 ObjectDescriptor,
782 SecurityInformation,
783 ResultantDescriptor,
784 DescriptorLength,
785 ReturnLength));
786
787 return (FALSE); /* signal failure */
788}
789
790
791/*****************************************************************************
792 * Name : ImpersonateLoggedOnUser
793 * Purpose : The ImpersonateLoggedOnUser function lets the calling thread
794 * impersonate a user. The user is represented by a token handle
795 * obtained by calling the LogonUser function
796 * Parameters: HANDLE hToken
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 ImpersonateLoggedOnUser(HANDLE hToken)
806{
807 dprintf(("ADVAPI32: ImpersonateLoggedOnUser(%08xh) not implemented.\n",
808 hToken));
809
810 return (TRUE); /* signal OK */
811}
812
813
814/*****************************************************************************
815 * Name : ImpersonateNamedPipeClient
816 * Purpose : The ImpersonateNamedPipeClient function impersonates a named-pipe
817 * client application.
818 * Parameters: HANDLE hNamedPipe handle of a named pipe
819 * Variables :
820 * Result :
821 * Remark :
822 * Status : UNTESTED STUB
823 *
824 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
825 *****************************************************************************/
826
827BOOL WIN32API ImpersonateNamedPipeClient(HANDLE hNamedPipe)
828{
829 dprintf(("ADVAPI32: ImpersonateNamedPipeClient(%08xh) not implemented.\n",
830 hNamedPipe));
831
832 return (TRUE); /* signal OK */
833}
834
835/*****************************************************************************
836 * Name : InitiateSystemShutdownA
837 * Purpose : The InitiateSystemShutdown function initiates a shutdown and
838 * optional restart of the specified computer.
839 * Parameters: LPTSTR lpMachineName address of name of computer to shut down
840 * LPTSTR lpMessage address of message to display in dialog box
841 * DWORD dwTimeout time to display dialog box
842 * BOOL bForceAppsClosed force applications with unsaved changes flag
843 * BOOL bRebootAfterShutdown reboot flag
844 * Variables :
845 * Result :
846 * Remark :
847 * Status : UNTESTED STUB
848 *
849 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
850 *****************************************************************************/
851
852BOOL WIN32API InitiateSystemShutdownA(LPTSTR lpMachineName,
853 LPTSTR lpMessage,
854 DWORD dwTimeout,
855 BOOL bForceAppsClosed,
856 BOOL bRebootAfterShutdown)
857{
858 dprintf(("ADVAPI32: InitiateSystemShutdownA(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
859 lpMachineName,
860 lpMessage,
861 dwTimeout,
862 bForceAppsClosed,
863 bRebootAfterShutdown));
864
865 return (FALSE); /* signal failure */
866}
867
868
869/*****************************************************************************
870 * Name : InitiateSystemShutdownW
871 * Purpose : The InitiateSystemShutdown function initiates a shutdown and
872 * optional restart of the specified computer.
873 * Parameters: LPWSTR lpMachineName address of name of computer to shut down
874 * LPWSTR lpMessage address of message to display in dialog box
875 * DWORD dwTimeout time to display dialog box
876 * BOOL bForceAppsClosed force applications with unsaved changes flag
877 * BOOL bRebootAfterShutdown reboot flag
878 * Variables :
879 * Result :
880 * Remark :
881 * Status : UNTESTED STUB
882 *
883 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
884 *****************************************************************************/
885
886BOOL WIN32API InitiateSystemShutdownW(LPWSTR lpMachineName,
887 LPWSTR lpMessage,
888 DWORD dwTimeout,
889 BOOL bForceAppsClosed,
890 BOOL bRebootAfterShutdown)
891{
892 dprintf(("ADVAPI32: InitiateSystemShutdownW(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
893 lpMachineName,
894 lpMessage,
895 dwTimeout,
896 bForceAppsClosed,
897 bRebootAfterShutdown));
898
899 return (FALSE); /* signal failure */
900}
901
902
903
904/*****************************************************************************
905 * Name : IsValidAcl
906 * Purpose : The IsValidAcl function validates an access-control list (ACL).
907 * Parameters: PACL pAcl address of access-control list
908 * Variables :
909 * Result :
910 * Remark :
911 * Status : UNTESTED STUB
912 *
913 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
914 *****************************************************************************/
915
916BOOL WIN32API IsValidAcl(PACL pAcl)
917{
918 dprintf(("ADVAPI32: IsValidAcl(%08xh) not implemented.\n",
919 pAcl));
920
921 return (TRUE); /* signal OK */
922}
923
924
925/*****************************************************************************
926 * Name : LogonUserA
927 * Purpose : The LogonUser function attempts to perform a user logon
928 * operation. You specify the user with a user name and domain,
929 * and authenticate the user with a clear-text password. If the
930 * function succeeds, you receive a handle to a token that
931 * represents the logged-on user. You can then use this token
932 * handle to impersonate the specified user, or to create a process
933 * running in the context of the specified user.
934 * Parameters: LPTSTR lpszUsername string that specifies the user name
935 * LPTSTR lpszDomain string that specifies the domain or servero
936 * LPTSTR lpszPassword string that specifies the password
937 * DWORD dwLogonType specifies the type of logon operation
938 * DWORD dwLogonProvider specifies the logon provider
939 * PHANDLE phToken pointer to variable to receive token handle
940 * Variables :
941 * Result :
942 * Remark :
943 * Status : UNTESTED STUB
944 *
945 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
946 *****************************************************************************/
947
948BOOL WIN32API LogonUserA(LPTSTR lpszUsername,
949 LPTSTR lpszDomain,
950 LPTSTR lpszPassword,
951 DWORD dwLogonType,
952 DWORD dwLogonProvider,
953 PHANDLE phToken)
954{
955 dprintf(("ADVAPI32: LogonUserA(%s,%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
956 lpszUsername,
957 lpszDomain,
958 lpszPassword,
959 dwLogonType,
960 dwLogonProvider,
961 phToken));
962
963 return (TRUE); /* signal OK */
964}
965
966
967/*****************************************************************************
968 * Name : LogonUserW
969 * Purpose : The LogonUser function attempts to perform a user logon
970 * operation. You specify the user with a user name and domain,
971 * and authenticate the user with a clear-text password. If the
972 * function succeeds, you receive a handle to a token that
973 * represents the logged-on user. You can then use this token
974 * handle to impersonate the specified user, or to create a process
975 * running in the context of the specified user.
976 * Parameters: LPWSTR lpszUsername string that specifies the user name
977 * LPWSTR lpszDomain string that specifies the domain or servero
978 * LPWSTR lpszPassword string that specifies the password
979 * DWORD dwLogonType specifies the type of logon operation
980 * DWORD dwLogonProvider specifies the logon provider
981 * PHANDLE phToken pointer to variable to receive token handle
982 * Variables :
983 * Result :
984 * Remark :
985 * Status : UNTESTED STUB
986 *
987 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
988 *****************************************************************************/
989
990BOOL WIN32API LogonUserW(LPWSTR lpszUsername,
991 LPWSTR lpszDomain,
992 LPWSTR lpszPassword,
993 DWORD dwLogonType,
994 DWORD dwLogonProvider,
995 PHANDLE phToken)
996{
997 dprintf(("ADVAPI32: LogonUserW(%s,%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
998 lpszUsername,
999 lpszDomain,
1000 lpszPassword,
1001 dwLogonType,
1002 dwLogonProvider,
1003 phToken));
1004
1005 return (TRUE); /* signal OK */
1006}
1007
1008
1009/*****************************************************************************
1010 * Name : LookupAccountNameA
1011 * Purpose : The LookupAccountName function accepts the name of a system and
1012 * an account as input. It retrieves a security identifier (SID)
1013 * for the account and the name of the domain on which the account was found.
1014 * Parameters: LPCSTR lpSystemName address of string for system name
1015 * LPCSTR lpAccountName address of string for account name
1016 * PSID Sid address of security identifier
1017 * LPDWORD cbSid address of size of security identifier
1018 * LPTSTR ReferencedDomainName address of string for referenced domain
1019 * LPDWORD cbReferencedDomainName address of size of domain string
1020 * PSID_NAME_USE peUse address of SID-type indicator
1021 * Variables :
1022 * Result :
1023 * Remark :
1024 * Status : UNTESTED STUB
1025 *
1026 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1027 *****************************************************************************/
1028
1029BOOL WIN32API LookupAccountNameA(LPCSTR lpSystemName,
1030 LPCSTR lpAccountName,
1031 PSID Sid,
1032 LPDWORD cbSid,
1033 LPTSTR ReferencedDomainName,
1034 LPDWORD cbReferencedDomainName,
1035 PSID_NAME_USE peUse)
1036{
1037 dprintf(("ADVAPI32: LookupAccountNameA(%s,%s,%08xh,%08xh,%s,%08xh,%08xh) not implemented.\n",
1038 lpSystemName,
1039 lpAccountName,
1040 Sid,
1041 cbSid,
1042 ReferencedDomainName,
1043 cbReferencedDomainName,
1044 peUse));
1045
1046 return (FALSE); /* signal failure */
1047}
1048
1049
1050/*****************************************************************************
1051 * Name : LookupAccountNameW
1052 * Purpose : The LookupAccountName function accepts the name of a system and
1053 * an account as input. It retrieves a security identifier (SID)
1054 * for the account and the name of the domain on which the account was found.
1055 * Parameters: LPCWSTR lpSystemName address of string for system name
1056 * LPCWSTR lpAccountName address of string for account name
1057 * PSID Sid address of security identifier
1058 * LPDWORD cbSid address of size of security identifier
1059 * LPWSTR ReferencedDomainName address of string for referenced domain
1060 * LPDWORD cbReferencedDomainName address of size of domain string
1061 * PSID_NAME_USE peUse address of SID-type indicator
1062 * Variables :
1063 * Result :
1064 * Remark :
1065 * Status : UNTESTED STUB
1066 *
1067 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1068 *****************************************************************************/
1069
1070BOOL WIN32API LookupAccountNameW(LPCWSTR lpSystemName,
1071 LPCWSTR lpAccountName,
1072 PSID Sid,
1073 LPDWORD cbSid,
1074 LPWSTR ReferencedDomainName,
1075 LPDWORD cbReferencedDomainName,
1076 PSID_NAME_USE peUse)
1077{
1078 dprintf(("ADVAPI32: LookupAccountNameW(%s,%s,%08xh,%08xh,%s,%08xh,%08xh) not implemented.\n",
1079 lpSystemName,
1080 lpAccountName,
1081 Sid,
1082 cbSid,
1083 ReferencedDomainName,
1084 cbReferencedDomainName,
1085 peUse));
1086
1087 return (FALSE); /* signal failure */
1088}
1089
1090
1091
1092/*****************************************************************************
1093 * Name : LookupPrivilegeDisplayNameA
1094 * Purpose : The LookupPrivilegeDisplayName function retrieves a displayable
1095 * name representing a specified privilege.
1096 * Parameters: LPCSTR lpSystemName address of string specifying the system
1097 * LPCSTR lpName address of string specifying the privilege
1098 * LPTSTR lpDisplayName address of string receiving the displayable name
1099 * LPDWORD cbDisplayName address of size of string for displayable name
1100 * LPDWORD lpLanguageId address of language identifier
1101 * Variables :
1102 * Result :
1103 * Remark :
1104 * Status : UNTESTED STUB
1105 *
1106 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1107 *****************************************************************************/
1108
1109BOOL WIN32API LookupPrivilegeDisplayNameA(LPCSTR lpSystemName,
1110 LPCSTR lpName,
1111 LPTSTR lpDisplayName,
1112 LPDWORD cbDisplayName,
1113 LPDWORD lpLanguageId)
1114{
1115 dprintf(("ADVAPI32: LookupPrivilegeDisplayNameA(%s,%s,%s,%08xh,%08xh) not implemented.\n",
1116 lpSystemName,
1117 lpName,
1118 lpDisplayName,
1119 cbDisplayName,
1120 lpLanguageId));
1121
1122 return (FALSE); /* signal failure */
1123}
1124
1125
1126/*****************************************************************************
1127 * Name : LookupPrivilegeDisplayNameW
1128 * Purpose : The LookupPrivilegeDisplayName function retrieves a displayable
1129 * name representing a specified privilege.
1130 * Parameters: LPCWSTR lpSystemName address of string specifying the system
1131 * LPCWSTR lpName address of string specifying the privilege
1132 * LPWSTR lpDisplayName address of string receiving the displayable name
1133 * LPDWORD cbDisplayName address of size of string for displayable name
1134 * LPDWORD lpLanguageId address of language identifier
1135 * Variables :
1136 * Result :
1137 * Remark :
1138 * Status : UNTESTED STUB
1139 *
1140 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1141 *****************************************************************************/
1142
1143BOOL WIN32API LookupPrivilegeDisplayNameW(LPCWSTR lpSystemName,
1144 LPCWSTR lpName,
1145 LPWSTR lpDisplayName,
1146 LPDWORD cbDisplayName,
1147 LPDWORD lpLanguageId)
1148{
1149 dprintf(("ADVAPI32: LookupPrivilegeDisplayNameW(%s,%s,%s,%08xh,%08xh) not implemented.\n",
1150 lpSystemName,
1151 lpName,
1152 lpDisplayName,
1153 cbDisplayName,
1154 lpLanguageId));
1155
1156 return (FALSE); /* signal failure */
1157}
1158
1159
1160/*****************************************************************************
1161 * Name : LookupPrivilegeNameA
1162 * Purpose : The LookupPrivilegeName function retrieves the name corresponding
1163 * to the privilege represented on a specific system by a specified
1164 * locally unique identifier (LUID).
1165 * Parameters: LPCSTR lpSystemName address of string specifying the system
1166 * PLUID lpLuid address of locally unique identifier
1167 * LPTSTR lpName address of string specifying the privilege
1168 * LPDWORD cbName address of size of string for displayable name
1169 * Variables :
1170 * Result :
1171 * Remark :
1172 * Status : UNTESTED STUB
1173 *
1174 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1175 *****************************************************************************/
1176
1177BOOL WIN32API LookupPrivilegeNameA(LPCSTR lpSystemName,
1178 PLUID lpLuid,
1179 LPTSTR lpName,
1180 LPDWORD cbName)
1181{
1182 dprintf(("ADVAPI32: LookupPrivilegeNameA(%s,%08xh,%s,%08xh) not implemented.\n",
1183 lpSystemName,
1184 lpLuid,
1185 lpName,
1186 cbName));
1187
1188 return (FALSE); /* signal failure */
1189}
1190
1191
1192/*****************************************************************************
1193 * Name : LookupPrivilegeNameW
1194 * Purpose : The LookupPrivilegeName function retrieves the name corresponding
1195 * to the privilege represented on a specific system by a specified
1196 * locally unique identifier (LUID).
1197 * Parameters: LPCWSTR lpSystemName address of string specifying the system
1198 * PLUID lpLuid address of locally unique identifier
1199 * LPWSTR lpName address of string specifying the privilege
1200 * LPDWORD cbName address of size of string for displayable name
1201 * Variables :
1202 * Result :
1203 * Remark :
1204 * Status : UNTESTED STUB
1205 *
1206 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1207 *****************************************************************************/
1208
1209BOOL WIN32API LookupPrivilegeNameW(LPCWSTR lpSystemName,
1210 PLUID lpLuid,
1211 LPWSTR lpName,
1212 LPDWORD cbName)
1213{
1214 dprintf(("ADVAPI32: LookupPrivilegeNameW(%s,%08xh,%s,%08xh) not implemented.\n",
1215 lpSystemName,
1216 lpLuid,
1217 lpName,
1218 cbName));
1219
1220 return (FALSE); /* signal failure */
1221}
1222
1223
1224/*****************************************************************************
1225 * Name : MakeAbsoluteSD
1226 * Purpose : The MakeAbsoluteSD function creates a security descriptor in
1227 * absolute format by using a security descriptor in self-relative
1228 * format as a template.
1229 * Parameters: PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor address self-relative SD
1230 * PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor address of absolute SD
1231 * LPDWORD lpdwAbsoluteSecurityDescriptorSize address of size of absolute SD
1232 * PACL pDacl address of discretionary ACL
1233 * LPDWORD lpdwDaclSize address of size of discretionary ACL
1234 * PACL pSacl address of system ACL
1235 * LPDWORD lpdwSaclSize address of size of system ACL
1236 * PSID pOwner address of owner SID
1237 * LPDWORD lpdwOwnerSize address of size of owner SID
1238 * PSID pPrimaryGroup address of primary-group SID
1239 * LPDWORD lpdwPrimaryGroupSize address of size of group SID
1240 * Variables :
1241 * Result :
1242 * Remark :
1243 * Status : UNTESTED STUB
1244 *
1245 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1246 *****************************************************************************/
1247
1248BOOL WIN32API MakeAbsoluteSD(PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
1249 PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
1250 LPDWORD lpdwAbsoluteSecurityDescriptorSize,
1251 PACL pDacl,
1252 LPDWORD lpdwDaclSize,
1253 PACL pSacl,
1254 LPDWORD lpdwSaclSize,
1255 PSID pOwner,
1256 LPDWORD lpdwOwnerSize,
1257 PSID pPrimaryGroup,
1258 LPDWORD lpdwPrimaryGroupSize)
1259{
1260 dprintf(("ADVAPI32: MakeAbsoluteSD(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1261 pSelfRelativeSecurityDescriptor,
1262 pAbsoluteSecurityDescriptor,
1263 lpdwAbsoluteSecurityDescriptorSize,
1264 pDacl,
1265 lpdwDaclSize,
1266 pSacl,
1267 lpdwSaclSize,
1268 pOwner,
1269 lpdwOwnerSize,
1270 pPrimaryGroup,
1271 lpdwPrimaryGroupSize));
1272
1273 return (FALSE); /* signal failure */
1274}
1275
1276
1277
1278
1279/*****************************************************************************
1280 * Name : MapGenericMask
1281 * Purpose : The MapGenericMask function maps the generic access rights in
1282 * an access mask to specific and standard access rights. The function
1283 * applies a mapping supplied in a GENERIC_MAPPING structure.
1284 * Parameters: LPDWORD AccessMask address of access mask
1285 * PGENERIC_MAPPING GenericMapping address of GENERIC_MAPPING structure
1286 * Variables :
1287 * Result :
1288 * Remark :
1289 * Status : UNTESTED STUB
1290 *
1291 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1292 *****************************************************************************/
1293
1294VOID WIN32API MapGenericMask(LPDWORD AccessMask,
1295 PGENERIC_MAPPING GenericMapping)
1296{
1297 dprintf(("ADVAPI32: MapGenericMask(%08xh,%08xh) not implemented.\n",
1298 AccessMask,
1299 GenericMapping));
1300}
1301
1302
1303
1304
1305
1306/*****************************************************************************
1307 * Name : ObjectCloseAuditAlarmA
1308 * Purpose : The ObjectCloseAuditAlarm function generates audit messages when
1309 * a handle of an object is deleted. Alarms are not supported in the
1310 * current version of Windows NT.
1311 * Parameters: LPCSTR SubsystemName address of string for subsystem name
1312 * LPVOID HandleId address of handle identifier
1313 * BOOL GenerateOnClose flag for audit generation
1314 * Variables :
1315 * Result :
1316 * Remark :
1317 * Status : UNTESTED STUB
1318 *
1319 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1320 *****************************************************************************/
1321
1322BOOL WIN32API ObjectCloseAuditAlarmA(LPCSTR SubsystemName,
1323 LPVOID HandleId,
1324 BOOL GenerateOnClose)
1325{
1326 dprintf(("ADVAPI32: ObjectCloseAuditAlarmA(%s,%08xh,%08xh) not implemented.\n",
1327 SubsystemName,
1328 HandleId,
1329 GenerateOnClose));
1330
1331 return (FALSE); /* signal failure */
1332}
1333
1334
1335/*****************************************************************************
1336 * Name : ObjectCloseAuditAlarmW
1337 * Purpose : The ObjectCloseAuditAlarm function generates audit messages when
1338 * a handle of an object is deleted. Alarms are not supported in the
1339 * current version of Windows NT.
1340 * Parameters: LPCWSTR SubsystemName address of string for subsystem name
1341 * LPVOID HandleId address of handle identifier
1342 * BOOL GenerateOnClose flag for audit generation
1343 * Variables :
1344 * Result :
1345 * Remark :
1346 * Status : UNTESTED STUB
1347 *
1348 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1349 *****************************************************************************/
1350
1351BOOL WIN32API ObjectCloseAuditAlarmW(LPCWSTR SubsystemName,
1352 LPVOID HandleId,
1353 BOOL GenerateOnClose)
1354{
1355 dprintf(("ADVAPI32: ObjectCloseAuditAlarmW(%s,%08xh,%08xh) not implemented.\n",
1356 SubsystemName,
1357 HandleId,
1358 GenerateOnClose));
1359
1360 return (FALSE); /* signal failure */
1361}
1362
1363
1364
1365/*****************************************************************************
1366 * Name : ObjectOpenAuditAlarmA
1367 * Purpose : The ObjectOpenAuditAlarm function generates audit messages when
1368 * a client application attempts to gain access to an object or to
1369 * create a new one. Alarms are not supported in the current version
1370 * of Windows NT.
1371 * Parameters: LPCSTR SubsystemName address of string for subsystem name
1372 * LPVOID HandleId address of handle identifier
1373 * LPTSTR ObjectTypeName address of string for object type
1374 * LPTSTR ObjectName address of string for object name
1375 * PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
1376 * HANDLE ClientToken handle of client's access token
1377 * DWORD DesiredAccess mask for desired access rights
1378 * DWORD GrantedAccess mask for granted access rights
1379 * PPRIVILEGE_SET Privileges address of privileges
1380 * BOOL ObjectCreation flag for object creation
1381 * BOOL AccessGranted flag for results
1382 * LPBOOL GenerateOnClose address of flag for audit generation
1383 * Variables :
1384 * Result :
1385 * Remark :
1386 * Status : UNTESTED STUB
1387 *
1388 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1389 *****************************************************************************/
1390
1391BOOL WIN32API ObjectOpenAuditAlarmA(LPCSTR SubsystemName,
1392 LPVOID HandleId,
1393 LPTSTR ObjectTypeName,
1394 LPTSTR ObjectName,
1395 PSECURITY_DESCRIPTOR pSecurityDescriptor,
1396 HANDLE ClientToken,
1397 DWORD DesiredAccess,
1398 DWORD GrantedAccess,
1399 PPRIVILEGE_SET Privileges,
1400 BOOL ObjectCreation,
1401 BOOL AccessGranted,
1402 LPBOOL GenerateOnClose)
1403{
1404 dprintf(("ADVAPI32: ObjectOpenAuditAlarmA(%s,%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1405 SubsystemName,
1406 HandleId,
1407 ObjectTypeName,
1408 ObjectName,
1409 pSecurityDescriptor,
1410 ClientToken,
1411 DesiredAccess,
1412 GrantedAccess,
1413 Privileges,
1414 ObjectCreation,
1415 AccessGranted,
1416 GenerateOnClose));
1417
1418 return (FALSE); /* signal failure */
1419}
1420
1421
1422/*****************************************************************************
1423 * Name : ObjectOpenAuditAlarmW
1424 * Purpose : The ObjectOpenAuditAlarm function generates audit messages when
1425 * a client application attempts to gain access to an object or to
1426 * create a new one. Alarms are not supported in the current version
1427 * of Windows NT.
1428 * Parameters: LPCWSTR SubsystemName address of string for subsystem name
1429 * LPVOID HandleId address of handle identifier
1430 * LPWSTR ObjectTypeName address of string for object type
1431 * LPWSTR ObjectName address of string for object name
1432 * PSECURITY_DESCRIPTOR pSecurityDescriptor address of security descriptor
1433 * HANDLE ClientToken handle of client's access token
1434 * DWORD DesiredAccess mask for desired access rights
1435 * DWORD GrantedAccess mask for granted access rights
1436 * PPRIVILEGE_SET Privileges address of privileges
1437 * BOOL ObjectCreation flag for object creation
1438 * BOOL AccessGranted flag for results
1439 * LPBOOL GenerateOnClose address of flag for audit generation
1440 * Variables :
1441 * Result :
1442 * Remark :
1443 * Status : UNTESTED STUB
1444 *
1445 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1446 *****************************************************************************/
1447
1448BOOL WIN32API ObjectOpenAuditAlarmW(LPCWSTR SubsystemName,
1449 LPVOID HandleId,
1450 LPWSTR ObjectTypeName,
1451 LPWSTR ObjectName,
1452 PSECURITY_DESCRIPTOR pSecurityDescriptor,
1453 HANDLE ClientToken,
1454 DWORD DesiredAccess,
1455 DWORD GrantedAccess,
1456 PPRIVILEGE_SET Privileges,
1457 BOOL ObjectCreation,
1458 BOOL AccessGranted,
1459 LPBOOL GenerateOnClose)
1460{
1461 dprintf(("ADVAPI32: ObjectOpenAuditAlarmW(%s,%08xh,%s,%s,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1462 SubsystemName,
1463 HandleId,
1464 ObjectTypeName,
1465 ObjectName,
1466 pSecurityDescriptor,
1467 ClientToken,
1468 DesiredAccess,
1469 GrantedAccess,
1470 Privileges,
1471 ObjectCreation,
1472 AccessGranted,
1473 GenerateOnClose));
1474
1475 return (FALSE); /* signal failure */
1476}
1477
1478
1479/*****************************************************************************
1480 * Name : ObjectPrivilegeAuditAlarmA
1481 * Purpose : The ObjectPrivilegeAuditAlarm function generates audit messages
1482 * as a result of a client's attempt to perform a privileged operation
1483 * on a server application object using an already opened handle of
1484 * that object. Alarms are not supported in the current version of Windows NT.
1485 * Parameters: LPCSTR lpszSubsystem address of string for subsystem name
1486 * LPVOID lpvHandleId address of handle identifier
1487 * HANDLE hClientToken handle of client's access token
1488 * DWORD dwDesiredAccess mask for desired access rights
1489 * PPRIVILEGE_SET pps address of privileges
1490 * BOOL fAccessGranted flag for results
1491 * Variables :
1492 * Result :
1493 * Remark :
1494 * Status : UNTESTED STUB
1495 *
1496 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1497 *****************************************************************************/
1498
1499BOOL WIN32API ObjectPrivilegeAuditAlarmA(LPCSTR lpszSubsystem,
1500 LPVOID lpvHandleId,
1501 HANDLE hClientToken,
1502 DWORD dwDesiredAccess,
1503 PPRIVILEGE_SET pps,
1504 BOOL fAccessGranted)
1505{
1506 dprintf(("ADVAPI32: ObjectPrivilegeAuditAlarmA(%s,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1507 lpszSubsystem,
1508 lpvHandleId,
1509 hClientToken,
1510 dwDesiredAccess,
1511 pps,
1512 fAccessGranted));
1513
1514 return (FALSE); /* signal failure */
1515}
1516
1517
1518/*****************************************************************************
1519 * Name : ObjectPrivilegeAuditAlarmW
1520 * Purpose : The ObjectPrivilegeAuditAlarm function generates audit messages
1521 * as a result of a client's attempt to perform a privileged operation
1522 * on a server application object using an already opened handle of
1523 * that object. Alarms are not supported in the current version of Windows NT.
1524 * Parameters: LPCWSTR lpszSubsystem address of string for subsystem name
1525 * LPVOID lpvHandleId address of handle identifier
1526 * HANDLE hClientToken handle of client's access token
1527 * DWORD dwDesiredAccess mask for desired access rights
1528 * PPRIVILEGE_SET pps address of privileges
1529 * BOOL fAccessGranted flag for results
1530 * Variables :
1531 * Result :
1532 * Remark :
1533 * Status : UNTESTED STUB
1534 *
1535 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1536 *****************************************************************************/
1537
1538BOOL WIN32API ObjectPrivilegeAuditAlarmW(LPCWSTR lpszSubsystem,
1539 LPVOID lpvHandleId,
1540 HANDLE hClientToken,
1541 DWORD dwDesiredAccess,
1542 PPRIVILEGE_SET pps,
1543 BOOL fAccessGranted)
1544{
1545 dprintf(("ADVAPI32: ObjectPrivilegeAuditAlarmW(%s,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1546 lpszSubsystem,
1547 lpvHandleId,
1548 hClientToken,
1549 dwDesiredAccess,
1550 pps,
1551 fAccessGranted));
1552
1553 return (FALSE); /* signal failure */
1554}
1555
1556/*****************************************************************************
1557 * Name : PrivilegeCheck
1558 * Purpose : The PrivilegeCheck function tests the security context represented
1559 * by a specific access token to discover whether it contains the
1560 * specified privileges. This function is typically called by a server
1561 * application to check the privileges of a client's access token.
1562 * Parameters: HANDLE hClientToken handle of client's access token
1563 * PPRIVILEGE_SET pps address of privileges
1564 * LPBOOL lpfResult address of flag for result
1565 * Variables :
1566 * Result :
1567 * Remark :
1568 * Status : UNTESTED STUB
1569 *
1570 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1571 *****************************************************************************/
1572
1573BOOL WIN32API PrivilegeCheck(HANDLE hClientToken,
1574 PPRIVILEGE_SET pps,
1575 LPBOOL lpfResult)
1576{
1577 dprintf(("ADVAPI32: PrivilegeCheck(%08xh,%08xh,%08xh) not implemented.\n",
1578 hClientToken,
1579 pps,
1580 lpfResult));
1581
1582 return (FALSE); /* signal failure */
1583}
1584
1585
1586/*****************************************************************************
1587 * Name : PrivilegedServiceAuditAlarmA
1588 * Purpose : The PrivilegedServiceAuditAlarm function generates audit messages
1589 * when an attempt is made to perform privileged system service
1590 * operations. Alarms are not supported in the current version of Windows NT.
1591 * Parameters: LPCSTR lpszSubsystem address of string for subsystem name
1592 * LPCSTR lpszService address of string for service name
1593 * HANDLE hClientToken handle of access token
1594 * PPRIVILEGE_SET pps address of privileges
1595 * BOOL fAccessGranted flag for granted access rights
1596 * Variables :
1597 * Result :
1598 * Remark :
1599 * Status : UNTESTED STUB
1600 *
1601 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1602 *****************************************************************************/
1603
1604BOOL WIN32API PrivilegedServiceAuditAlarmA(LPCSTR lpszSubsystem,
1605 LPCSTR lpszService,
1606 HANDLE hClientToken,
1607 PPRIVILEGE_SET pps,
1608 BOOL fAccessGranted)
1609{
1610 dprintf(("ADVAPI32: PrivilegedServiceAuditAlarmA(%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
1611 lpszSubsystem,
1612 lpszService,
1613 hClientToken,
1614 pps,
1615 fAccessGranted));
1616
1617 return (FALSE); /* signal failure */
1618}
1619
1620
1621/*****************************************************************************
1622 * Name : PrivilegedServiceAuditAlarmW
1623 * Purpose : The PrivilegedServiceAuditAlarm function generates audit messages
1624 * when an attempt is made to perform privileged system service
1625 * operations. Alarms are not supported in the current version of Windows NT.
1626 * Parameters: LPCWSTR lpszSubsystem address of string for subsystem name
1627 * LPCWSTR lpszService address of string for service name
1628 * HANDLE hClientToken handle of access token
1629 * PPRIVILEGE_SET pps address of privileges
1630 * BOOL fAccessGranted flag for granted access rights
1631 * Variables :
1632 * Result :
1633 * Remark :
1634 * Status : UNTESTED STUB
1635 *
1636 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1637 *****************************************************************************/
1638
1639BOOL WIN32API PrivilegedServiceAuditAlarmW(LPCWSTR lpszSubsystem,
1640 LPCWSTR lpszService,
1641 HANDLE hClientToken,
1642 PPRIVILEGE_SET pps,
1643 BOOL fAccessGranted)
1644{
1645 dprintf(("ADVAPI32: PrivilegedServiceAuditAlarmW(%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
1646 lpszSubsystem,
1647 lpszService,
1648 hClientToken,
1649 pps,
1650 fAccessGranted));
1651
1652 return (FALSE); /* signal failure */
1653}
1654
1655/*****************************************************************************
1656 * Name : SetAclInformation
1657 * Purpose : The SetAclInformation function sets information about an access-control list (ACL).
1658 * Parameters: PACL pAcl address of access-control list
1659 * LPVOID lpvAclInfo address of ACL information
1660 * DWORD cbAclInfo size of ACL information
1661 * ACL_INFORMATION_CLASS aclic specifies class of requested info
1662 * Variables :
1663 * Result :
1664 * Remark :
1665 * Status : UNTESTED STUB
1666 *
1667 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1668 *****************************************************************************/
1669
1670BOOL WIN32API SetAclInformation(PACL pAcl,
1671 LPVOID lpvAclInfo,
1672 DWORD cbAclInfo,
1673 ACL_INFORMATION_CLASS aclic)
1674{
1675 dprintf(("ADVAPI32: SetAclInformation(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1676 pAcl,
1677 lpvAclInfo,
1678 cbAclInfo,
1679 aclic));
1680
1681 return (FALSE); /* signal failure */
1682}
1683
1684
1685/*****************************************************************************
1686 * Name : SetKernelObjectSecurity
1687 * Purpose : The SetKernelObjectSecurity function sets the security of a kernel
1688 * object. For example, this can be a process, thread, or event.
1689 * Parameters: HANDLE hObject handle of object
1690 * SECURITY_INFORMATION si type of information to set
1691 * PSECURITY_DESCRIPTOR psd address of security descriptor
1692 * Variables :
1693 * Result :
1694 * Remark :
1695 * Status : UNTESTED STUB
1696 *
1697 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1698 *****************************************************************************/
1699
1700BOOL WIN32API SetKernelObjectSecurity(HANDLE hObject,
1701 SECURITY_INFORMATION si,
1702 PSECURITY_DESCRIPTOR psd)
1703{
1704 dprintf(("ADVAPI32: SetKernelObjectSecurity(%08xh,%08xh,%08xh) not implemented.\n",
1705 hObject,
1706 si,
1707 psd));
1708
1709 return (FALSE); /* signal failure */
1710}
1711
1712
1713/*****************************************************************************
1714 * Name : SetPrivateObjectSecurity
1715 * Purpose : The SetPrivateObjectSecurity function modifies a private
1716 * object's security descriptor.
1717 * Parameters: SECURITY_INFORMATION si type of security information
1718 * PSECURITY_DESCRIPTOR psdSource address of SD to apply to object
1719 * PSECURITY_DESCRIPTOR *lppsdTarget address of object's SD
1720 * PGENERIC_MAPPING pgm address of access-mapping structure
1721 * HANDLE hClientToken handle of client access token
1722 * Variables :
1723 * Result :
1724 * Remark :
1725 * Status : UNTESTED STUB
1726 *
1727 * Author : Patrick Haller [Tue, 1998/06/16 23:00]
1728 *****************************************************************************/
1729
1730
1731BOOL WIN32API SetPrivateObjectSecurity(SECURITY_INFORMATION si,
1732 PSECURITY_DESCRIPTOR psdSource,
1733 PSECURITY_DESCRIPTOR *lppsdTarget,
1734 PGENERIC_MAPPING pgm,
1735 HANDLE hClientToken)
1736{
1737 dprintf(("ADVAPI32: SetPrivateObjectSecurity(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1738 si,
1739 psdSource,
1740 lppsdTarget,
1741 pgm,
1742 hClientToken));
1743
1744 return (FALSE); /* signal failure */
1745}
1746
1747
1748
1749
1750
1751
Note: See TracBrowser for help on using the repository browser.