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

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

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