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

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

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