source: trunk/src/advapi32/advapi32.c@ 40

Last change on this file since 40 was 32, checked in by phaller, 27 years ago

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