Context Navigation

source: trunk/src/advapi32/registry.cpp@ 811

Visit:

Last change on this file since 811 was 803, checked in by phaller, 26 years ago
Fix: Registry return codes
File size: 46.9 KB

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

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

Download in other formats: