Context Navigation

ADVAPI32.CPP@ 103

Visit:

Last change on this file since 103 was 103, checked in by phaller, 26 years ago
Fix: added more debug info, beautified source #2.
File size: 222.4 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format