shell32: Add a trailing '\n' to a WARN().
[wine] / dlls / kernel32 / registry16.c
1 /*
2  * 16-bit registry functions
3  *
4  * Copyright 1996 Marcus Meissner
5  * Copyright 1998 Matthew Becker
6  * Copyright 1999 Sylvain St-Germain
7  * Copyright 2002 Alexandre Julliard
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22  */
23
24 #include <stdarg.h>
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winreg.h"
29 #include "wine/debug.h"
30 #include "wine/winbase16.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(reg);
33
34 static DWORD (WINAPI *pRegCloseKey)(HKEY);
35 static DWORD (WINAPI *pRegCreateKeyA)(HKEY,LPCSTR,PHKEY);
36 static DWORD (WINAPI *pRegDeleteKeyA)(HKEY,LPCSTR);
37 static DWORD (WINAPI *pRegDeleteValueA)(HKEY,LPCSTR);
38 static DWORD (WINAPI *pRegEnumKeyA)(HKEY,DWORD,LPSTR,DWORD);
39 static DWORD (WINAPI *pRegEnumValueA)(HKEY,DWORD,LPSTR,LPDWORD,LPDWORD,LPDWORD,LPBYTE,LPDWORD);
40 static DWORD (WINAPI *pRegFlushKey)(HKEY);
41 static DWORD (WINAPI *pRegOpenKeyA)(HKEY,LPCSTR,PHKEY);
42 static DWORD (WINAPI *pRegQueryValueA)(HKEY,LPCSTR,LPSTR,LPLONG);
43 static DWORD (WINAPI *pRegQueryValueExA)(HKEY,LPCSTR,LPDWORD,LPDWORD,LPBYTE,LPDWORD);
44 static DWORD (WINAPI *pRegSetValueA)(HKEY,LPCSTR,DWORD,LPCSTR,DWORD);
45 static DWORD (WINAPI *pRegSetValueExA)(HKEY,LPCSTR,DWORD,DWORD,CONST BYTE*,DWORD);
46
47 static HMODULE advapi32;
48
49
50 /* 0 and 1 are valid rootkeys in win16 shell.dll and are used by
51  * some programs. Do not remove those cases. -MM
52  */
53 static inline void fix_win16_hkey( HKEY *hkey )
54 {
55     if (*hkey == 0 || *hkey == (HKEY)1) *hkey = HKEY_CLASSES_ROOT;
56 }
57
58 static void init_func_ptrs(void)
59 {
60     advapi32 = LoadLibraryA("advapi32.dll");
61     if (!advapi32)
62     {
63         ERR( "Unable to load advapi32.dll\n" );
64         ExitProcess(1);
65     }
66 #define GET_PTR(name)  p##name = (void *)GetProcAddress(advapi32,#name);
67     GET_PTR( RegCloseKey );
68     GET_PTR( RegCreateKeyA );
69     GET_PTR( RegDeleteKeyA );
70     GET_PTR( RegDeleteValueA );
71     GET_PTR( RegEnumKeyA );
72     GET_PTR( RegEnumValueA );
73     GET_PTR( RegFlushKey );
74     GET_PTR( RegOpenKeyA );
75     GET_PTR( RegQueryValueA );
76     GET_PTR( RegQueryValueExA );
77     GET_PTR( RegSetValueA );
78     GET_PTR( RegSetValueExA );
79 #undef GET_PTR
80 }
81
82 /******************************************************************************
83  *           RegEnumKey   [KERNEL.216]
84  */
85 DWORD WINAPI RegEnumKey16( HKEY hkey, DWORD index, LPSTR name, DWORD name_len )
86 {
87     if (!advapi32) init_func_ptrs();
88     fix_win16_hkey( &hkey );
89     return pRegEnumKeyA( hkey, index, name, name_len );
90 }
91
92 /******************************************************************************
93  *           RegOpenKey   [KERNEL.217]
94  */
95 DWORD WINAPI RegOpenKey16( HKEY hkey, LPCSTR name, PHKEY retkey )
96 {
97     if (!advapi32) init_func_ptrs();
98     fix_win16_hkey( &hkey );
99     return pRegOpenKeyA( hkey, name, retkey );
100 }
101
102 /******************************************************************************
103  *           RegCreateKey   [KERNEL.218]
104  */
105 DWORD WINAPI RegCreateKey16( HKEY hkey, LPCSTR name, PHKEY retkey )
106 {
107     if (!advapi32) init_func_ptrs();
108     fix_win16_hkey( &hkey );
109     return pRegCreateKeyA( hkey, name, retkey );
110 }
111
112 /******************************************************************************
113  *           RegDeleteKey   [KERNEL.219]
114  */
115 DWORD WINAPI RegDeleteKey16( HKEY hkey, LPCSTR name )
116 {
117     if (!advapi32) init_func_ptrs();
118     fix_win16_hkey( &hkey );
119     return pRegDeleteKeyA( hkey, name );
120 }
121
122 /******************************************************************************
123  *           RegCloseKey   [KERNEL.220]
124  */
125 DWORD WINAPI RegCloseKey16( HKEY hkey )
126 {
127     if (!advapi32) init_func_ptrs();
128     fix_win16_hkey( &hkey );
129     return pRegCloseKey( hkey );
130 }
131
132 /******************************************************************************
133  *           RegSetValue   [KERNEL.221]
134  */
135 DWORD WINAPI RegSetValue16( HKEY hkey, LPCSTR name, DWORD type, LPCSTR data, DWORD count )
136 {
137     if (!advapi32) init_func_ptrs();
138     fix_win16_hkey( &hkey );
139     return pRegSetValueA( hkey, name, type, data, count );
140 }
141
142 /******************************************************************************
143  *           RegDeleteValue  [KERNEL.222]
144  */
145 DWORD WINAPI RegDeleteValue16( HKEY hkey, LPSTR name )
146 {
147     if (!advapi32) init_func_ptrs();
148     fix_win16_hkey( &hkey );
149     return pRegDeleteValueA( hkey, name );
150 }
151
152 /******************************************************************************
153  *           RegEnumValue   [KERNEL.223]
154  */
155 DWORD WINAPI RegEnumValue16( HKEY hkey, DWORD index, LPSTR value, LPDWORD val_count,
156                              LPDWORD reserved, LPDWORD type, LPBYTE data, LPDWORD count )
157 {
158     if (!advapi32) init_func_ptrs();
159     fix_win16_hkey( &hkey );
160     return pRegEnumValueA( hkey, index, value, val_count, reserved, type, data, count );
161 }
162
163 /******************************************************************************
164  *           RegQueryValue   [KERNEL.224]
165  *
166  * NOTES
167  *    Is this HACK still applicable?
168  *
169  * HACK
170  *    The 16bit RegQueryValue doesn't handle selectorblocks anyway, so we just
171  *    mask out the high 16 bit.  This (not so much incidentally) hopefully fixes
172  *    Aldus FH4)
173  */
174 DWORD WINAPI RegQueryValue16( HKEY hkey, LPCSTR name, LPSTR data, LPDWORD count )
175 {
176     if (!advapi32) init_func_ptrs();
177     fix_win16_hkey( &hkey );
178     if (count) *count &= 0xffff;
179     return pRegQueryValueA( hkey, name, data, (LONG*) count );
180 }
181
182 /******************************************************************************
183  *           RegQueryValueEx   [KERNEL.225]
184  */
185 DWORD WINAPI RegQueryValueEx16( HKEY hkey, LPCSTR name, LPDWORD reserved, LPDWORD type,
186                                 LPBYTE data, LPDWORD count )
187 {
188     if (!advapi32) init_func_ptrs();
189     fix_win16_hkey( &hkey );
190     return pRegQueryValueExA( hkey, name, reserved, type, data, count );
191 }
192
193 /******************************************************************************
194  *           RegSetValueEx   [KERNEL.226]
195  */
196 DWORD WINAPI RegSetValueEx16( HKEY hkey, LPCSTR name, DWORD reserved, DWORD type,
197                               CONST BYTE *data, DWORD count )
198 {
199     if (!advapi32) init_func_ptrs();
200     fix_win16_hkey( &hkey );
201     if (!count && (type==REG_SZ)) count = strlen( (const char *)data );
202     return pRegSetValueExA( hkey, name, reserved, type, data, count );
203 }
204
205 /******************************************************************************
206  *           RegFlushKey   [KERNEL.227]
207  */
208 DWORD WINAPI RegFlushKey16( HKEY hkey )
209 {
210     if (!advapi32) init_func_ptrs();
211     fix_win16_hkey( &hkey );
212     return pRegFlushKey( hkey );
213 }