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

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

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