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

Last change on this file since 7 was 4, checked in by ktk, 26 years ago

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