Context Navigation

source: trunk/src/kernel32/registry.cpp@ 4510

Visit:

Last change on this file since 4510 was 4510, checked in by sandervl, 25 years ago
registry api fixes + version keys added
File size: 50.5 KB

Line
1	/* $Id: registry.cpp,v 1.6 2000-10-21 14:30:47 sandervl Exp $ */
2
3	/*
4	* Win32 registry API functions for OS/2
5	*
6	* 1998/06/12
7	*
8	* Copyright 1998 Sander van Leeuwen
9	* Copyright 1998 Patrick Haller
10	*
11	* Project Odin Software License can be found in LICENSE.TXT
12	*
13	*/
14
15
16	/*****************************************************************************
17	* Includes *
18	*****************************************************************************/
19
20	#include <odin.h>
21	#include <odinwrap.h>
22	#include <os2sel.h>
23
24	#include <os2win.h>
25	#include <stdlib.h>
26	#include <stdarg.h>
27	#include <string.h>
28	#include <odinwrap.h>
29	#include <misc.h>
30	#include "unicode.h"
31	#include <winreg.h>
32	#include <heapstring.h>
33
34	#define DBG_LOCALLOG DBG_registry
35	#include "dbglocal.h"
36
37
38	ODINDEBUGCHANNEL(ADVAPI32-REGISTRY)
39
40
41	/*****************************************************************************
42	* Defines *
43	*****************************************************************************/
44
45	/* this define enables certain less important debug messages */
46	//#define DEBUG_LOCAL 1
47
48
49	/*****************************************************************************
50	* Name : Convert Key
51	* Purpose : convert key handle values between win32 and os/2
52	* Parameters: HKEY winkey - the win32 key handle value
53	* Variables :
54	* Result : the os/2 warp registry key handle value
55	* Remark :
56	* Status : UNTESTED STUB
57	*
58	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
59	*****************************************************************************/
60
61	static HKEY ConvertKey(HKEY winkey)
62	{
63	switch((int)winkey)
64	{
65	case HKEY_CLASSES_ROOT: return HKEY_CLASSES_ROOT_O32;
66	case HKEY_CURRENT_USER: return HKEY_CURRENT_USER_O32;
67	case HKEY_LOCAL_MACHINE: return HKEY_LOCAL_MACHINE_O32;
68	case HKEY_USERS: return HKEY_USERS_O32;
69	}
70	return(winkey);
71	}
72
73
74	/*****************************************************************************
75	* Name :
76	* Purpose :
77	* Parameters:
78	* Variables :
79	* Result :
80	* Remark :
81	* Status : CORRECTED UNTESTED
82	*
83	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
84	*****************************************************************************/
85
86	ODINFUNCTION1(LONG,RegCloseKey,HKEY,hKey)
87	{
88	return O32_RegCloseKey(ConvertKey(hKey));
89	}
90
91
92	/*****************************************************************************
93	* Name :
94	* Purpose :
95	* Parameters:
96	* Variables :
97	* Result :
98	* Remark :
99	* Status : CORRECTED UNTESTED
100	*
101	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
102	*****************************************************************************/
103
104	ODINFUNCTION3(LONG,RegCreateKeyA,HKEY, hKey,
105	LPCSTR,lpszSubKey,
106	PHKEY, phkResult)
107	{
108	dprintf(("RegCreateKeyA %x %s", hKey, lpszSubKey));
109	return O32_RegCreateKey(ConvertKey(hKey),
110	lpszSubKey,
111	phkResult);
112	}
113
114
115	/*****************************************************************************
116	* Name :
117	* Purpose :
118	* Parameters:
119	* Variables :
120	* Result :
121	* Remark :
122	* Status : CORRECTED UNTESTED
123	*
124	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
125	*****************************************************************************/
126
127	ODINFUNCTION3(LONG,RegCreateKeyW,HKEY, hKey,
128	LPCWSTR,lpszSubKey,
129	PHKEY, phkResult)
130	{
131	char *astring = UnicodeToAsciiString((LPWSTR)lpszSubKey);
132	LONG rc;
133
134	dprintf(("RegCreateKeyW %x %s", hKey, astring));
135	rc = O32_RegCreateKey(ConvertKey(hKey),
136	astring,
137	phkResult);
138
139	FreeAsciiString(astring);
140	return(rc);
141	}
142
143
144	/*****************************************************************************
145	* Name :
146	* Purpose :
147	* Parameters:
148	* Variables :
149	* Result :
150	* Remark :
151	* Status : CORRECTED UNTESTED
152	*
153	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
154	*****************************************************************************/
155
156	ODINFUNCTION9(LONG,RegCreateKeyExA,HKEY, hKey,
157	LPCSTR, lpszSubKey,
158	DWORD, dwReserved,
159	LPSTR, lpszClass,
160	DWORD, fdwOptions,
161	REGSAM, samDesired,
162	LPSECURITY_ATTRIBUTES,lpSecurityAttributes,
163	PHKEY, phkResult,
164	LPDWORD, lpdwDisposition)
165	{
166	dprintf(("RegCreateKeyExA %x %s", hKey, lpszSubKey));
167
168	return O32_RegCreateKeyEx(ConvertKey(hKey),
169	lpszSubKey,
170	dwReserved,
171	lpszClass,
172	fdwOptions,
173	samDesired, // \| KEY_READ
174	lpSecurityAttributes,
175	phkResult,
176	lpdwDisposition);
177	}
178
179
180	/*****************************************************************************
181	* Name :
182	* Purpose :
183	* Parameters:
184	* Variables :
185	* Result :
186	* Remark :
187	* Status : CORRECTED UNTESTED
188	*
189	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
190	*****************************************************************************/
191
192	ODINFUNCTION9(LONG,RegCreateKeyExW,HKEY, hKey,
193	LPCWSTR, lpszSubKey,
194	DWORD, dwReserved,
195	LPWSTR, lpszClass,
196	DWORD, fdwOptions,
197	REGSAM, samDesired,
198	LPSECURITY_ATTRIBUTES,lpSecurityAttributes,
199	PHKEY, phkResult,
200	LPDWORD, lpdwDisposition)
201	{
202	char *astring1 = UnicodeToAsciiString((LPWSTR)lpszSubKey);
203	char *astring2 = UnicodeToAsciiString(lpszClass);
204	LONG rc;
205
206	dprintf(("RegCreateKeyExW %x %s", hKey, astring1));
207
208	rc = O32_RegCreateKeyEx(ConvertKey(hKey),
209	astring1,
210	dwReserved,
211	astring2,
212	fdwOptions,
213	samDesired, // \| KEY_READ
214	lpSecurityAttributes,
215	phkResult,
216	lpdwDisposition);
217
218	FreeAsciiString(astring1);
219	FreeAsciiString(astring2);
220	return(rc);
221	}
222
223
224	/*****************************************************************************
225	* Name :
226	* Purpose :
227	* Parameters:
228	* Variables :
229	* Result :
230	* Remark :
231	* Status : CORRECTED UNTESTED
232	*
233	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
234	*****************************************************************************/
235
236	ODINFUNCTION2(LONG,RegDeleteKeyW,HKEY, hKey,
237	LPWSTR,lpszSubKey)
238	{
239	char *astring = UnicodeToAsciiString(lpszSubKey);
240	LONG rc;
241
242	dprintf(("RegDeleteKeyW %s", astring));
243	rc = O32_RegDeleteKey(ConvertKey(hKey),
244	astring);
245	FreeAsciiString(astring);
246	return(rc);
247	}
248
249
250	/*****************************************************************************
251	* Name :
252	* Purpose :
253	* Parameters:
254	* Variables :
255	* Result :
256	* Remark :
257	* Status : CORRECTED UNTESTED
258	*
259	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
260	*****************************************************************************/
261
262	ODINFUNCTION2(LONG,RegDeleteKeyA,HKEY, hKey,
263	LPCSTR,lpszSubKey)
264	{
265	dprintf(("RegDeleteKeyW %s", lpszSubKey));
266	return O32_RegDeleteKey(ConvertKey(hKey),
267	lpszSubKey);
268	}
269
270
271	/*****************************************************************************
272	* Name :
273	* Purpose :
274	* Parameters:
275	* Variables :
276	* Result :
277	* Remark :
278	* Status : CORRECTED UNTESTED
279	*
280	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
281	*****************************************************************************/
282
283	ODINFUNCTION2(LONG,RegDeleteValueA,HKEY, hKey,
284	LPSTR,lpszValue)
285	{
286	return O32_RegDeleteValue(ConvertKey(hKey),
287	lpszValue);
288	}
289
290
291	/*****************************************************************************
292	* Name :
293	* Purpose :
294	* Parameters:
295	* Variables :
296	* Result :
297	* Remark :
298	* Status : CORRECTED UNTESTED
299	*
300	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
301	*****************************************************************************/
302
303	ODINFUNCTION2(LONG,RegDeleteValueW,HKEY, hKey,
304	LPWSTR,lpszValue)
305	{
306	char *astring = UnicodeToAsciiString(lpszValue);
307	LONG rc;
308
309	rc = O32_RegDeleteValue(ConvertKey(hKey),
310	astring);
311	FreeAsciiString(astring);
312	return(rc);
313	}
314
315
316	/*****************************************************************************
317	* Name :
318	* Purpose :
319	* Parameters:
320	* Variables :
321	* Result :
322	* Remark :
323	* Status : UNTESTED STUB
324	*
325	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
326	*****************************************************************************/
327
328	ODINFUNCTION4(LONG,RegEnumKeyA,HKEY, hKey,
329	DWORD,iSubKey,
330	LPSTR,lpszName,
331	DWORD,cchName)
332	{
333	return O32_RegEnumKey(ConvertKey(hKey),
334	iSubKey,
335	lpszName,
336	cchName);
337	}
338
339
340	/*****************************************************************************
341	* Name :
342	* Purpose :
343	* Parameters:
344	* Variables :
345	* Result :
346	* Remark :
347	* Status : UNTESTED STUB
348	*
349	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
350	*****************************************************************************/
351
352	ODINFUNCTION4(LONG,RegEnumKeyW,HKEY, hKey,
353	DWORD, iSubKey,
354	LPWSTR,lpszName,
355	DWORD, cchName)
356	{
357	char *astring;
358	LONG rc;
359
360	rc = O32_RegEnumKey(ConvertKey(hKey),
361	iSubKey,
362	(char *)lpszName,
363	cchName);
364	if(rc == ERROR_SUCCESS)
365	{
366	astring = (char *)malloc(cchName);
367	strcpy(astring, (char *)lpszName);
368	AsciiToUnicode(astring, lpszName);
369	free(astring);
370	}
371	return(rc);
372	}
373
374
375	/*****************************************************************************
376	* Name :
377	* Purpose :
378	* Parameters:
379	* Variables :
380	* Result :
381	* Remark :
382	* Status : UNTESTED STUB
383	*
384	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
385	*****************************************************************************/
386
387	ODINFUNCTION8(LONG,RegEnumKeyExA,HKEY, arg1,
388	DWORD, arg2,
389	LPSTR, arg3,
390	LPDWORD, arg4,
391	LPDWORD, arg5,
392	LPSTR, arg6,
393	LPDWORD, arg7,
394	LPFILETIME,arg8)
395	{
396	return O32_RegEnumKeyEx(ConvertKey(arg1),
397	arg2,
398	arg3,
399	arg4,
400	arg5,
401	arg6,
402	arg7,
403	arg8);
404	}
405
406
407	/*****************************************************************************
408	* Name :
409	* Purpose :
410	* Parameters:
411	* Variables :
412	* Result :
413	* Remark :
414	* Status : UNTESTED STUB
415	*
416	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
417	*****************************************************************************/
418
419	ODINFUNCTION8(LONG,RegEnumKeyExW,HKEY, arg1,
420	DWORD, arg2,
421	LPWSTR, arg3,
422	LPDWORD, arg4,
423	LPDWORD, arg5,
424	LPWSTR, arg6,
425	LPDWORD, arg7,
426	LPFILETIME,arg8)
427	{
428	char *astring;
429	LONG rc;
430
431	rc = O32_RegEnumKeyEx(ConvertKey(arg1),
432	arg2,
433	(char *)arg3,
434	arg4,
435	arg5,
436	(char *)arg6,
437	arg7,
438	arg8);
439	if(rc == ERROR_SUCCESS)
440	{
441	astring = (char )malloc(max(arg4, *arg7)); //class & keyname
442	strcpy(astring, (char *)arg3);
443	AsciiToUnicode(astring, arg3);
444	if(arg6 != NULL)
445	{
446	strcpy(astring, (char *)arg6);
447	AsciiToUnicode(astring, arg6);
448	}
449	free(astring);
450	}
451	return(rc);
452	}
453
454
455	/*****************************************************************************
456	* Name :
457	* Purpose :
458	* Parameters:
459	* Variables :
460	* Result :
461	* Remark :
462	* Status : UNTESTED STUB
463	*
464	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
465	*****************************************************************************/
466
467	ODINFUNCTION8(LONG,RegEnumValueA,HKEY, arg1,
468	DWORD, arg2,
469	LPSTR, arg3,
470	LPDWORD,arg4,
471	LPDWORD,arg5,
472	LPDWORD,arg6,
473	LPBYTE, arg7,
474	LPDWORD,arg8)
475	{
476	return O32_RegEnumValue(ConvertKey(arg1),
477	arg2,
478	arg3,
479	arg4,
480	arg5,
481	arg6,
482	arg7,
483	arg8);
484	}
485
486
487	/*****************************************************************************
488	* Name :
489	* Purpose :
490	* Parameters:
491	* Variables :
492	* Result :
493	* Remark :
494	* Status : UNTESTED STUB
495	*
496	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
497	*****************************************************************************/
498
499	ODINFUNCTION8(LONG,RegEnumValueW,HKEY, arg1,
500	DWORD, arg2,
501	LPWSTR, arg3,
502	LPDWORD,arg4,
503	LPDWORD,arg5,
504	LPDWORD,arg6,
505	LPBYTE, arg7,
506	LPDWORD,arg8)
507	{
508	char *astring;
509	LONG rc;
510
511	rc = O32_RegEnumValue(ConvertKey(arg1),
512	arg2,
513	(char *)arg3,
514	arg4,
515	arg5,
516	arg6,
517	arg7,
518	arg8);
519	if(rc == ERROR_SUCCESS)
520	{
521	astring = (char )malloc(arg4);
522	strcpy(astring, (char *)arg3);
523	AsciiToUnicode(astring, arg3);
524	free(astring);
525	}
526	return(rc);
527	}
528
529
530	/*****************************************************************************
531	* Name :
532	* Purpose :
533	* Parameters:
534	* Variables :
535	* Result :
536	* Remark :
537	* Status : UNTESTED STUB
538	*
539	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
540	*****************************************************************************/
541
542	ODINFUNCTION3(LONG,RegOpenKeyA,HKEY, arg1,
543	LPCSTR,arg2,
544	PHKEY, arg3)
545	{
546	LONG rc;
547
548	dprintf(("RegOpenKey %s", arg2));
549
550	rc = O32_RegOpenKey(ConvertKey(arg1),
551	arg2,
552	arg3);
553	if(rc)
554	*arg3 = 0;
555
556	return(rc);
557	}
558
559
560	/*****************************************************************************
561	* Name :
562	* Purpose :
563	* Parameters:
564	* Variables :
565	* Result :
566	* Remark :
567	* Status : UNTESTED STUB
568	*
569	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
570	*****************************************************************************/
571
572	ODINFUNCTION3(LONG,RegOpenKeyW,HKEY, arg1,
573	LPCWSTR,arg2,
574	PHKEY, arg3)
575	{
576	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
577	LONG rc;
578
579	rc = O32_RegOpenKey(ConvertKey(arg1),
580	astring,
581	arg3);
582	if(rc)
583	*arg3 = 0;
584
585	FreeAsciiString(astring);
586	return(rc);
587	}
588
589
590	/*****************************************************************************
591	* Name :
592	* Purpose :
593	* Parameters:
594	* Variables :
595	* Result :
596	* Remark :
597	* Status : UNTESTED STUB
598	*
599	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
600	*****************************************************************************/
601
602	ODINFUNCTION5(LONG,RegOpenKeyExA,HKEY, arg1,
603	LPCSTR,arg2,
604	DWORD, arg3,
605	REGSAM,arg4,
606	PHKEY, arg5)
607	{
608	LONG rc;
609
610	dprintf(("RegOpenKeyEx %s", arg2));
611	rc = O32_RegOpenKeyEx(ConvertKey(arg1),
612	arg2,
613	arg3,
614	arg4,
615	arg5);
616
617	//SvL: This fixes crashes in pmwinx.dll. (if an app doesn't check the
618	// return value and uses the whatever *arg5 contains)
619	if(rc)
620	*arg5 = 0;
621
622	return(rc);
623	}
624
625
626	/*****************************************************************************
627	* Name :
628	* Purpose :
629	* Parameters:
630	* Variables :
631	* Result :
632	* Remark :
633	* Status : UNTESTED STUB
634	*
635	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
636	*****************************************************************************/
637
638	ODINFUNCTION5(LONG,RegOpenKeyExW,HKEY, arg1,
639	LPCWSTR,arg2,
640	DWORD, arg3,
641	REGSAM, arg4,
642	PHKEY, arg5)
643	{
644	char *astring = UnicodeToAsciiString((LPWSTR)arg2);
645	LONG rc;
646
647	rc = CALL_ODINFUNC(RegOpenKeyExA)(arg1,
648	astring,
649	arg3,
650	arg4,
651	arg5);
652	//SvL: This fixes crashes in pmwinx.dll. (if an app doesn't check the
653	// return value and uses the whatever *arg5 contains)
654	if(rc)
655	*arg5 = 0;
656
657	FreeAsciiString(astring);
658	return(rc);
659	}
660
661
662	/*****************************************************************************
663	* Name :
664	* Purpose :
665	* Parameters:
666	* Variables :
667	* Result :
668	* Remark :
669	* Status : UNTESTED STUB
670	*
671	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
672	*****************************************************************************/
673
674	ODINFUNCTION12(LONG,RegQueryInfoKeyA,HKEY, arg1,
675	LPSTR, arg2,
676	LPDWORD, arg3,
677	LPDWORD, arg4,
678	LPDWORD, arg5,
679	LPDWORD, arg6,
680	LPDWORD, arg7,
681	LPDWORD, arg8,
682	LPDWORD, arg9,
683	LPDWORD, arg10,
684	LPDWORD, arg11,
685	LPFILETIME, arg12)
686	{
687	return O32_RegQueryInfoKey(ConvertKey(arg1),
688	arg2,
689	arg3,
690	arg4,
691	arg5,
692	arg6,
693	arg7,
694	arg8,
695	arg9,
696	arg10,
697	arg11,
698	arg12);
699	}
700
701
702	/*****************************************************************************
703	* Name :
704	* Purpose :
705	* Parameters:
706	* Variables :
707	* Result :
708	* Remark :
709	* Status : UNTESTED STUB
710	*
711	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
712	*****************************************************************************/
713
714	ODINFUNCTION12(LONG,RegQueryInfoKeyW,HKEY, arg1,
715	LPWSTR, arg2,
716	LPDWORD, arg3,
717	LPDWORD, arg4,
718	LPDWORD, arg5,
719	LPDWORD, arg6,
720	LPDWORD, arg7,
721	LPDWORD, arg8,
722	LPDWORD, arg9,
723	LPDWORD, arg10,
724	LPDWORD, arg11,
725	LPFILETIME, arg12)
726	{
727	char *astring;
728	LONG rc;
729
730	rc = O32_RegQueryInfoKey(ConvertKey(arg1),
731	(char *)arg2,
732	arg3,
733	arg4,
734	arg5,
735	arg6,
736	arg7,
737	arg8,
738	arg9,
739	arg10,
740	arg11,
741	arg12);
742	if(rc == ERROR_SUCCESS)
743	{
744	if(*arg3) {
745	astring = (char )malloc(arg3);
746	strcpy(astring, (char *)arg2);
747	AsciiToUnicode(astring, arg2);
748	free(astring);
749	}
750	else *arg2 = 0;
751	}
752	return(rc);
753	}
754
755
756	/*****************************************************************************
757	* Name :
758	* Purpose :
759	* Parameters:
760	* Variables :
761	* Result :
762	* Remark :
763	* Status : UNTESTED STUB
764	*
765	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
766	*****************************************************************************/
767
768	ODINFUNCTION4(LONG,RegQueryValueA,HKEY, arg1,
769	LPCSTR,arg2,
770	LPSTR, arg3,
771	PLONG, arg4)
772	{
773	dprintf(("ADVAPI32:Registry key=%s\n",
774	arg2));
775	return O32_RegQueryValue(ConvertKey(arg1),
776	arg2,
777	arg3,
778	arg4);
779	}
780
781
782	/*****************************************************************************
783	* Name :
784	* Purpose :
785	* Parameters:
786	* Variables :
787	* Result :
788	* Remark :
789	* Status : UNTESTED STUB
790	*
791	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
792	*****************************************************************************/
793
794	ODINFUNCTION4(LONG,RegQueryValueW,HKEY, hkey,
795	LPCWSTR,lpszSubKey,
796	LPWSTR, lpszValue,
797	PLONG, pcbValue)
798	{
799	char *astring1 = UnicodeToAsciiString((LPWSTR)lpszSubKey);
800	char *astring2;
801	LONG rc;
802
803	rc = CALL_ODINFUNC(RegQueryValueA)(hkey,
804	astring1,
805	(char *)lpszValue,
806	pcbValue);
807	if(rc == ERROR_SUCCESS)
808	{
809	if(pcbValue) {
810	astring2 = (char )malloc(pcbValue);
811	strcpy(astring2, (char *)lpszValue);
812	AsciiToUnicode(astring2, lpszValue);
813	free(astring2);
814	}
815	}
816	FreeAsciiString(astring1);
817	return(rc);
818	}
819
820
821	/*****************************************************************************
822	* Name :
823	* Purpose :
824	* Parameters:
825	* Variables :
826	* Result :
827	* Remark :
828	* Status : UNTESTED STUB
829	*
830	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
831	*****************************************************************************/
832
833	ODINFUNCTION6(LONG,RegQueryValueExA,HKEY, hkey,
834	LPSTR, lpszValueName,
835	LPDWORD,lpdwType,
836	LPDWORD,lpdwReserved,
837	LPBYTE, lpbData,
838	LPDWORD,lpcbData)
839	{
840	dprintf(("ADVAPI32:Registry key=%s", lpszValueName));
841
842	return O32_RegQueryValueEx(ConvertKey(hkey),
843	lpszValueName,
844	lpdwType,
845	lpdwReserved,
846	lpbData,
847	lpcbData);
848	}
849
850
851	/*****************************************************************************
852	* Name :
853	* Purpose :
854	* Parameters:
855	* Variables :
856	* Result :
857	* Remark : TODO: DOESN'T WORK FOR STRING DATA!!
858	* Status : UNTESTED STUB
859	*
860	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
861	*****************************************************************************/
862
863	ODINFUNCTION6(LONG,RegQueryValueExW,HKEY, hkey,
864	LPWSTR, lpszValueName,
865	LPDWORD,lpdwType,
866	LPDWORD,lpdwReserved,
867	LPBYTE, lpbData,
868	LPDWORD,lpcbData)
869	{
870	char *astring = UnicodeToAsciiString(lpszValueName);
871	char *akeydata = NULL;
872	LONG rc;
873
874	if(lpbData && lpcbData)
875	{
876	akeydata = (char )malloc(lpcbData+1);
877	akeydata[*lpcbData] = 0;
878	}
879
880	rc = CALL_ODINFUNC(RegQueryValueExA)(hkey,
881	astring,
882	lpdwType,
883	lpdwReserved,
884	(LPBYTE)akeydata,
885	lpcbData);
886	//could also query key type (without returning data), call it again and only allocate translation
887	//buffer if string type
888	if(rc == ERROR_SUCCESS && lpbData && lpcbData)
889	{
890	if(lpdwType == NULL) {//NULL apparently means REG_SZ
891	lstrcpyAtoW((LPWSTR)lpcbData, akeydata);
892	}
893	else {
894	switch(*lpdwType) {
895	case REG_SZ:
896	case REG_EXPAND_SZ:
897	lstrcpyAtoW((LPWSTR)lpcbData, akeydata);
898	break;
899	case REG_MULTI_SZ:
900	case REG_LINK: //???
901	dprintf(("ERROR: key data must be translated from Unicode to Ascii!!"));
902	break;
903	default:
904	memcpy(lpbData, akeydata, *lpcbData);
905	break;
906	}
907	}
908	}
909	FreeAsciiString(astring);
910	if(akeydata) {
911	free(akeydata);
912	}
913	return(rc);
914	}
915
916
917	/*****************************************************************************
918	* Name :
919	* Purpose :
920	* Parameters:
921	* Variables :
922	* Result :
923	* Remark :
924	* Status : UNTESTED STUB
925	*
926	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
927	*****************************************************************************/
928
929	ODINFUNCTION5(LONG,RegSetValueA,HKEY, hkey,
930	LPCSTR,lpSubKey,
931	DWORD, dwType,
932	LPCSTR,lpData,
933	DWORD, cbData)
934	{
935	LONG rc;
936
937	//SvL: 8-11-'97: Bugfix: crash in pmwinx if size == 0 and string is large
938	if(cbData == 0)
939	cbData = strlen(lpData);
940
941	rc = O32_RegSetValue(ConvertKey(hkey),
942	lpSubKey,
943	dwType,
944	lpData,
945	cbData);
946	if(rc == ERROR_NOT_ENOUGH_MEMORY && cbData == 0 && dwType == REG_SZ)
947	{
948	char regdata = 0;
949	//SvL: Netscape sets an empty string key this way; Open32 doesn't like it
950	rc = O32_RegSetValue(ConvertKey(hkey),
951	lpSubKey,
952	dwType,
953	&regdata,
954	1);
955	}
956	return rc;
957	}
958
959
960	/*****************************************************************************
961	* Name :
962	* Purpose :
963	* Parameters:
964	* Variables :
965	* Result :
966	* Remark :
967	* Status : UNTESTED STUB
968	*
969	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
970	*****************************************************************************/
971
972	ODINFUNCTION5(LONG,RegSetValueW,HKEY, hkey,
973	LPCWSTR,lpSubKey,
974	DWORD, dwType,
975	LPCWSTR,lpData,
976	DWORD, cbData)
977	{
978	char *astring1 = UnicodeToAsciiString((LPWSTR)lpSubKey);
979	char *astring2 = UnicodeToAsciiString((LPWSTR)lpData);
980	LONG rc;
981
982	rc = CALL_ODINFUNC(RegSetValueA)(hkey,
983	astring1,
984	dwType,
985	astring2,
986	cbData);
987
988	FreeAsciiString(astring1);
989	FreeAsciiString(astring2);
990	return(rc);
991	}
992
993
994	/*****************************************************************************
995	* Name :
996	* Purpose :
997	* Parameters:
998	* Variables :
999	* Result :
1000	* Remark : TODO:Check for string length here too?
1001	* Status : UNTESTED STUB
1002	*
1003	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1004	*****************************************************************************/
1005
1006	ODINFUNCTION6(LONG,RegSetValueExA,HKEY, hkey,
1007	LPSTR, lpszValueName,
1008	DWORD, dwReserved,
1009	DWORD, fdwType,
1010	BYTE*, lpbData,
1011	DWORD, cbData)
1012	{
1013	if(fdwType == REG_SZ) {
1014	dprintf(("ADVAPI32: RegSetValueExA)%08xh,%s,%08xh,%08xh,%s,%08xh)",
1015	hkey,
1016	lpszValueName,
1017	dwReserved,
1018	fdwType,
1019	lpbData,
1020	cbData));
1021	}
1022	else {
1023	dprintf(("ADVAPI32: RegSetValueExA)%08xh,%s,%08xh,%08xh,%08xh,%08xh)",
1024	hkey,
1025	lpszValueName,
1026	dwReserved,
1027	fdwType,
1028	lpbData,
1029	cbData));
1030	}
1031
1032	return O32_RegSetValueEx(ConvertKey(hkey),
1033	lpszValueName,
1034	dwReserved,
1035	fdwType,
1036	lpbData,
1037	cbData);
1038	}
1039
1040
1041	/*****************************************************************************
1042	* Name :
1043	* Purpose :
1044	* Parameters:
1045	* Variables :
1046	* Result :
1047	* Remark : TODO:Check for string length here too?
1048	* Status : UNTESTED STUB
1049	*
1050	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1051	*****************************************************************************/
1052
1053	ODINFUNCTION6(LONG,RegSetValueExW,HKEY, hkey,
1054	LPWSTR,lpszValueName,
1055	DWORD, dwReserved,
1056	DWORD, fdwType,
1057	BYTE*, lpbData,
1058	DWORD, cbData)
1059	{
1060	char *astring = UnicodeToAsciiString(lpszValueName);
1061	char *akeydata = NULL;
1062	LONG rc;
1063
1064	switch(fdwType) {
1065	case REG_SZ:
1066	case REG_EXPAND_SZ:
1067	akeydata = UnicodeToAsciiString((LPWSTR)lpbData);
1068	lpbData = (BYTE *)akeydata;
1069	break;
1070	case REG_MULTI_SZ:
1071	case REG_LINK: //???
1072	dprintf(("ERROR: key data must be translated from Unicode to Ascii!!"));
1073	break;
1074	}
1075	rc = CALL_ODINFUNC(RegSetValueExA)(hkey,
1076	astring,
1077	dwReserved,
1078	fdwType,
1079	lpbData,
1080	cbData);
1081	if(akeydata)
1082	FreeAsciiString(akeydata);
1083
1084	FreeAsciiString(astring);
1085	return(rc);
1086	}
1087
1088
1089	/*****************************************************************************
1090	* Name :
1091	* Purpose :
1092	* Parameters:
1093	* Variables :
1094	* Result :
1095	* Remark :
1096	* Status : UNTESTED STUB
1097	*
1098	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1099	*****************************************************************************/
1100
1101	ODINFUNCTION1(LONG,RegFlushKey,HKEY,hkey)
1102	{
1103	dprintf(("ADVAPI32: RegFlushKey not implemented yet."));
1104
1105	return(ERROR_SUCCESS);
1106	}
1107
1108
1109	/*****************************************************************************
1110	* Name : RegConnectRegistryA
1111	* Purpose : The RegConnectRegistry function establishes a connection to a
1112	* predefined registry handle on another computer.
1113	* Parameters: LPTSTR lpszComputerName address of name of remote computer
1114	* HKEY hKey predefined registry handle
1115	* PHKEY phkResult address of buffer for remote registry handle
1116	* Variables :
1117	* Result :
1118	* Remark :
1119	* Status : UNTESTED STUB
1120	*
1121	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1122	*****************************************************************************/
1123
1124	ODINFUNCTION3(LONG,RegConnectRegistryA,LPCSTR,lpszComputerName,
1125	HKEY, hKey,
1126	PHKEY, phkResult)
1127	{
1128	char szLocalName[256];
1129	DWORD dwNameLength = sizeof(szLocalName)-2;
1130
1131	szLocalName[0] = '\\';
1132	szLocalName[1] = '\\';
1133	GetComputerNameA(szLocalName+2, &dwNameLength);
1134
1135	dprintf(("ADVAPI32: RegConnectRegistryA(%s,local %s) not implemented yet.\n",
1136	lpszComputerName,
1137	szLocalName));
1138
1139	/* local registry ? */
1140	if ( ( lpszComputerName == NULL) \|\|
1141	(strcmp(szLocalName, lpszComputerName) == 0 ) )
1142	{
1143	/* @@@PH experimental !!! */
1144	*phkResult = hKey;
1145
1146	return (NO_ERROR);
1147	}
1148
1149	return (ERROR_ACCESS_DENIED);
1150	}
1151
1152
1153	/*****************************************************************************
1154	* Name : RegConnectRegistryW
1155	* Purpose : The RegConnectRegistry function establishes a connection to a
1156	* predefined registry handle on another computer.
1157	* Parameters: LPWSTR lpszComputerName address of name of remote computer
1158	* HKEY hKey predefined registry handle
1159	* PHKEY phkResult address of buffer for remote registry handle
1160	* Variables :
1161	* Result :
1162	* Remark :
1163	* Status : UNTESTED STUB
1164	*
1165	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1166	*****************************************************************************/
1167
1168	ODINFUNCTION3(LONG,RegConnectRegistryW,LPCWSTR,lpszComputerName,
1169	HKEY, hKey,
1170	PHKEY, phkResult)
1171	{
1172	/* corresponding ascii string */
1173	LPSTR pszAscii;
1174	LONG rc; /* returncode from call to ascii version of this function */
1175
1176	dprintf(("ADVAPI32: RegConnectRegistryW not implemented yet."));
1177
1178	if (lpszComputerName != NULL)
1179	pszAscii = UnicodeToAsciiString((LPWSTR)lpszComputerName);
1180	else
1181	pszAscii = NULL;
1182
1183	rc = RegConnectRegistryA(pszAscii,
1184	hKey,
1185	phkResult);
1186
1187	if (pszAscii != NULL)
1188	FreeAsciiString(pszAscii);
1189
1190	return (rc); /* OK */
1191	}
1192
1193
1194	/*****************************************************************************
1195	* Name : RegGetKeySecurity
1196	* Purpose : The RegGetKeySecurity function retrieves a copy of the security
1197	* descriptor protecting the specified open registry key.
1198	* Parameters: HKEY hKey open handle of key to set
1199	* SECURITY_INFORMATION SecInf descriptor contents
1200	* PSECURITY_DESCRIPTOR pSecDesc address of descriptor for key
1201	* LPDWORD lpcbSecDesc address of size of buffer and descriptor
1202	* Variables :
1203	* Result :
1204	* Remark :
1205	* Status : UNTESTED STUB
1206	*
1207	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1208	*****************************************************************************/
1209
1210	ODINFUNCTION4(LONG,RegGetKeySecurity,HKEY, hKey,
1211	SECURITY_INFORMATION, SecInf,
1212	PSECURITY_DESCRIPTOR, pSecDesc,
1213	LPDWORD, lpcbSecDesc)
1214	{
1215	dprintf(("ADVAPI32: RegGetKeySecurity not implemented.\n"));
1216
1217	return (ERROR_ACCESS_DENIED); /* signal failure */
1218	}
1219
1220
1221	/*****************************************************************************
1222	* Name : RegLoadKeyA
1223	* Purpose : The RegLoadKey function creates a subkey under HKEY_USER or
1224	* HKEY_LOCAL_MACHINE and stores registration information from a
1225	* specified file into that subkey. This registration information
1226	* is in the form of a hive. A hive is a discrete body of keys,
1227	* subkeys, and values that is rooted at the top of the registry
1228	* hierarchy. A hive is backed by a single file and .LOG file.
1229	* Parameters: HKEY hKey handle of open key
1230	* LPCSTR lpszSubKey address of name of subkey
1231	* LPCSTR lpszFile address of filename for registry information
1232	* Variables :
1233	* Result :
1234	* Remark :
1235	* Status : UNTESTED STUB
1236	*
1237	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1238	*****************************************************************************/
1239
1240	ODINFUNCTION3(LONG,RegLoadKeyA,HKEY, hKey,
1241	LPCSTR,lpszSubKey,
1242	LPCSTR,lpszFile)
1243	{
1244	dprintf(("ADVAPI32: RegLoadKeyA not implemented.\n"));
1245
1246	return (ERROR_ACCESS_DENIED); /* signal failure */
1247	}
1248
1249
1250	/*****************************************************************************
1251	* Name : RegLoadKeyW
1252	* Purpose : The RegLoadKey function creates a subkey under HKEY_USER or
1253	* HKEY_LOCAL_MACHINE and stores registration information from a
1254	* specified file into that subkey. This registration information
1255	* is in the form of a hive. A hive is a discrete body of keys,
1256	* subkeys, and values that is rooted at the top of the registry
1257	* hierarchy. A hive is backed by a single file and .LOG file.
1258	* Parameters: HKEY hKey handle of open key
1259	* LPCWSTR lpszSubKey address of name of subkey
1260	* LPCWSTR lpszFile address of filename for registry information
1261	* Variables :
1262	* Result :
1263	* Remark :
1264	* Status : UNTESTED STUB
1265	*
1266	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1267	*****************************************************************************/
1268
1269	ODINFUNCTION3(LONG,RegLoadKeyW,HKEY, hKey,
1270	LPCWSTR,lpszSubKey,
1271	LPCWSTR,lpszFile)
1272	{
1273	dprintf(("ADVAPI32: RegLoadKeyW not implemented.\n"));
1274
1275	return (ERROR_ACCESS_DENIED); /* signal failure */
1276	}
1277
1278
1279	/*****************************************************************************
1280	* Name : RegQueryMultipleValuesA
1281	* Purpose : The RegQueryMultipleValues function retrieves the type and data
1282	* for a list of value names associated with an open registry key.
1283	* Parameters: HKEY hKey handle of key to query
1284	* PVALENT val_list address of array of value entry structures
1285	* DWORD num_vals size of array of value entry structures
1286	* LPTSTR lpValueBuf address of buffer for value information
1287	* LPDWORD ldwTotsize address of size of value buffer
1288	* Variables :
1289	* Result :
1290	* Remark :
1291	* Status : UNTESTED STUB
1292	*
1293	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1294	*****************************************************************************/
1295
1296	ODINFUNCTION5(LONG,RegQueryMultipleValuesA,HKEY, hKey,
1297	PVALENTA,val_list,
1298	DWORD, num_vals,
1299	LPTSTR, lpValueBuf,
1300	LPDWORD, ldwTotsize)
1301	{
1302	dprintf(("ADVAPI32: RegQueryMultipleValuesA not implemented.\n"));
1303
1304	return (ERROR_ACCESS_DENIED); /* signal failure */
1305	}
1306
1307
1308	/*****************************************************************************
1309	* Name : RegQueryMultipleValuesW
1310	* Purpose : The RegQueryMultipleValues function retrieves the type and data
1311	* for a list of value names associated with an open registry key.
1312	* Parameters: HKEY hKey handle of key to query
1313	* PVALENT val_list address of array of value entry structures
1314	* DWORD num_vals size of array of value entry structures
1315	* LPWSTR lpValueBuf address of buffer for value information
1316	* LPDWORD ldwTotsize address of size of value buffer
1317	* Variables :
1318	* Result :
1319	* Remark :
1320	* Status : UNTESTED STUB
1321	*
1322	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1323	*****************************************************************************/
1324
1325	ODINFUNCTION5(LONG,RegQueryMultipleValuesW,HKEY, hKey,
1326	PVALENTW,val_list,
1327	DWORD, num_vals,
1328	LPWSTR, lpValueBuf,
1329	LPDWORD, ldwTotsize)
1330	{
1331	dprintf(("ADVAPI32: RegQueryMultipleValuesW not implemented.\n"));
1332
1333	return (ERROR_ACCESS_DENIED); /* signal failure */
1334	}
1335
1336
1337	/*****************************************************************************
1338	* Name : RegRemapPreDefKey
1339	* Purpose :
1340	* Parameters:
1341	* Variables :
1342	* Result :
1343	* Remark :
1344	* Status : UNTESTED STUB
1345	*
1346	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1347	*****************************************************************************/
1348
1349	#if 0
1350	ODINFUNCTION1(LONG,RegRemapPreDefKey,HKEY,hKey)
1351	{
1352	dprintf(("ADVAPI32: RegRemapPreDefKey not implemented.\n"));
1353
1354	return (ERROR_ACCESS_DENIED); /* signal failure */
1355	}
1356	#endif
1357
1358
1359	/*****************************************************************************
1360	* Name : RegReplaceKeyA
1361	* Purpose : The RegReplaceKey function replaces the file backing a key and
1362	* all its subkeys with another file, so that when the system is
1363	* next started, the key and subkeys will have the values stored in the new file.
1364	* Parameters: HKEY hKey handle of open key
1365	* LPCSTR lpSubKey address of name of subkey
1366	* LPCSTR lpNewFile address of filename for file with new data
1367	* LPCSTR lpOldFile address of filename for backup file
1368	* Variables :
1369	* Result :
1370	* Remark :
1371	* Status : UNTESTED STUB
1372	*
1373	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1374	*****************************************************************************/
1375
1376	ODINFUNCTION4(LONG,RegReplaceKeyA,HKEY, hKey,
1377	LPCSTR,lpSubKey,
1378	LPCSTR,lpNewFile,
1379	LPCSTR,lpOldFile)
1380	{
1381	dprintf(("ADVAPI32: RegReplaceKeyA not implemented.\n"));
1382
1383	return (ERROR_ACCESS_DENIED); /* signal failure */
1384	}
1385
1386
1387	/*****************************************************************************
1388	* Name : RegReplaceKeyW
1389	* Purpose : The RegReplaceKey function replaces the file backing a key and
1390	* all its subkeys with another file, so that when the system is
1391	* next started, the key and subkeys will have the values stored in the new file.
1392	* Parameters: HKEY hKey handle of open key
1393	* LPCWSTR lpSubKey address of name of subkey
1394	* LPCWSTR lpNewFile address of filename for file with new data
1395	* LPCWSTR lpOldFile address of filename for backup file
1396	* Variables :
1397	* Result :
1398	* Remark :
1399	* Status : UNTESTED STUB
1400	*
1401	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1402	*****************************************************************************/
1403
1404	ODINFUNCTION4(LONG,RegReplaceKeyW,HKEY, hKey,
1405	LPCWSTR,lpSubKey,
1406	LPCWSTR,lpNewFile,
1407	LPCWSTR,lpOldFile)
1408	{
1409	dprintf(("ADVAPI32: RegReplaceKeyW not implemented.\n"));
1410
1411	return (ERROR_ACCESS_DENIED); /* signal failure */
1412	}
1413
1414
1415	/*****************************************************************************
1416	* Name : RegRestoreKeyA
1417	* Purpose : The RegRestoreKey function reads the registry information in a
1418	* specified file and copies it over the specified key. This
1419	* registry information may be in the form of a key and multiple
1420	* levels of subkeys.
1421	* Parameters: HKEY hKey handle of key where restore begins
1422	* LPCSTR lpszFile address of filename containing saved tree
1423	* DWORD fdw optional flags
1424	* Variables :
1425	* Result :
1426	* Remark :
1427	* Status : UNTESTED STUB
1428	*
1429	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1430	*****************************************************************************/
1431
1432	ODINFUNCTION3(LONG,RegRestoreKeyA,HKEY, hKey,
1433	LPCSTR,lpszFile,
1434	DWORD, fdw)
1435	{
1436	dprintf(("ADVAPI32: RegRestoreKeyA not implemented.\n"));
1437
1438	return (ERROR_ACCESS_DENIED); /* signal failure */
1439	}
1440
1441
1442	/*****************************************************************************
1443	* Name : RegRestoreKeyW
1444	* Purpose : The RegRestoreKey function reads the registry information in a
1445	* specified file and copies it over the specified key. This
1446	* registry information may be in the form of a key and multiple
1447	* levels of subkeys.
1448	* Parameters: HKEY hKey handle of key where restore begins
1449	* LPCWSTR lpszFile address of filename containing saved tree
1450	* DWORD fdw optional flags
1451	* Variables :
1452	* Result :
1453	* Remark :
1454	* Status : UNTESTED STUB
1455	*
1456	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1457	*****************************************************************************/
1458
1459	ODINFUNCTION3(LONG,RegRestoreKeyW,HKEY, hKey,
1460	LPCWSTR, lpszFile,
1461	DWORD, fdw)
1462	{
1463	dprintf(("ADVAPI32: RegRestoreKeyW not implemented.\n"));
1464
1465	return (ERROR_ACCESS_DENIED); /* signal failure */
1466	}
1467
1468
1469	/*****************************************************************************
1470	* Name : RegSaveKeyA
1471	* Purpose : The RegSaveKey function saves the specified key and all of its
1472	* subkeys and values to a new file.
1473	* Parameters: HKEY hKey handle of key where save begins
1474	* LPCSTR lpszFile address of filename to save to
1475	* LPSECURITY_ATTRIBUTES lpsa address of security structure
1476	* Variables :
1477	* Result :
1478	* Remark :
1479	* Status : UNTESTED STUB
1480	*
1481	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1482	*****************************************************************************/
1483
1484	ODINFUNCTION3(LONG,RegSaveKeyA,HKEY, hKey,
1485	LPCSTR, lpszFile,
1486	LPSECURITY_ATTRIBUTES,lpsa)
1487	{
1488	dprintf(("ADVAPI32: RegSaveKeyA not implemented.\n"));
1489
1490	return (ERROR_ACCESS_DENIED); /* signal failure */
1491	}
1492
1493
1494	/*****************************************************************************
1495	* Name : RegSaveKeyW
1496	* Purpose : The RegSaveKey function saves the specified key and all of its
1497	* subkeys and values to a new file.
1498	* Parameters: HKEY hKey handle of key where save begins
1499	* LPCWSTR lpszFile address of filename to save to
1500	* LPSECURITY_ATTRIBUTES lpsa address of security structure
1501	* Variables :
1502	* Result :
1503	* Remark :
1504	* Status : UNTESTED STUB
1505	*
1506	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1507	*****************************************************************************/
1508
1509	ODINFUNCTION3(LONG,RegSaveKeyW,HKEY, hKey,
1510	LPCWSTR, lpszFile,
1511	LPSECURITY_ATTRIBUTES,lpsa)
1512	{
1513	dprintf(("ADVAPI32: RegSaveKeyW not implemented.\n"));
1514
1515	return (ERROR_ACCESS_DENIED); /* signal failure */
1516	}
1517
1518
1519	/*****************************************************************************
1520	* Name : RegSetKeySecurity
1521	* Purpose : The RegSetKeySecurity function sets the security of an open registry key.
1522	* Parameters: HKEY hKey open handle of key to set
1523	* SECURITY_INFORMATION si descriptor contents
1524	* PSECURITY_DESCRIPTOR psd address of descriptor for key
1525	* Variables :
1526	* Result :
1527	* Remark :
1528	* Status : UNTESTED STUB
1529	*
1530	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1531	*****************************************************************************/
1532
1533	ODINFUNCTION3(LONG,RegSetKeySecurity,HKEY, hKey,
1534	SECURITY_INFORMATION,si,
1535	PSECURITY_DESCRIPTOR,psd)
1536	{
1537	dprintf(("ADVAPI32: RegSetKeySecurity not implemented.\n"));
1538
1539	return (ERROR_ACCESS_DENIED); /* signal failure */
1540	}
1541
1542
1543	/*****************************************************************************
1544	* Name : RegUnLoadKeyA
1545	* Purpose : The RegUnLoadKey function unloads the specified key and subkeys from the registry.
1546	* Parameters: HKEY hKey handle of open key
1547	* LPCSTR lpszSubKey address of name of subkey to unload
1548	* Variables :
1549	* Result :
1550	* Remark :
1551	* Status : UNTESTED STUB
1552	*
1553	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1554	*****************************************************************************/
1555
1556	ODINFUNCTION2(LONG,RegUnLoadKeyA,HKEY, hKey,
1557	LPCSTR, lpszSubKey)
1558	{
1559	dprintf(("ADVAPI32: RegUnLoadKeyA not implemented.\n"));
1560
1561	return (ERROR_ACCESS_DENIED); /* signal failure */
1562	}
1563
1564
1565	/*****************************************************************************
1566	* Name : RegUnLoadKeyW
1567	* Purpose : The RegUnLoadKey function unloads the specified key and subkeys from the registry.
1568	* Parameters: HKEY hKey handle of open key
1569	* LPCWSTR lpszSubKey address of name of subkey to unload
1570	* Variables :
1571	* Result :
1572	* Remark :
1573	* Status : UNTESTED STUB
1574	*
1575	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1576	*****************************************************************************/
1577
1578	ODINFUNCTION2(LONG,RegUnLoadKeyW,HKEY, hKey,
1579	LPCWSTR, lpszSubKey)
1580	{
1581	dprintf(("ADVAPI32: RegUnLoadKeyW not implemented.\n"));
1582
1583	return (ERROR_ACCESS_DENIED); /* signal failure */
1584	}
1585
1586
1587	/*****************************************************************************
1588	* Name : RegNotifyChangeKeyValue
1589	* Purpose :
1590	* Parameters: HKEY hKey handle of open key
1591	* LPCWSTR lpszSubKey address of name of subkey to unload
1592	* Variables :
1593	* Result :
1594	* Remark :
1595	* Status : UNTESTED STUB
1596	*
1597	* Author : Patrick Haller [Tue, 1998/06/16 23:00]
1598	*****************************************************************************/
1599
1600	ODINFUNCTION5(LONG,RegNotifyChangeKeyValue,HKEY, hKey,
1601	BOOL, bWatchSubtree,
1602	DWORD, dwNotifyFilter,
1603	HANDLE,hEvent,
1604	BOOL, fAsynchronus)
1605	{
1606	dprintf(("ADVAPI32: RegNotifyChangeKeyValue() not implemented.\n"));
1607
1608	return ERROR_ACCESS_DENIED;
1609	}
1610

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

Download in other formats: