Create a branch for header work.
[reactos.git] / base / applications / cmdutils / reg / reg.c
1 /*
2 * Copyright 2008 Andrew Riedi
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <windows.h>
20 #include <wine/unicode.h>
21 #include "reg.h"
22
23 static int reg_printfW(const WCHAR *msg, ...)
24 {
25 va_list va_args;
26 int wlen;
27 DWORD count, ret;
28 WCHAR msg_buffer[8192];
29
30 va_start(va_args, msg);
31 vsprintfW(msg_buffer, msg, va_args);
32 va_end(va_args);
33
34 wlen = lstrlenW(msg_buffer);
35 ret = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), msg_buffer, wlen, &count, NULL);
36 if (!ret)
37 {
38 DWORD len;
39 char *msgA;
40
41 len = WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen,
42 NULL, 0, NULL, NULL);
43 msgA = HeapAlloc(GetProcessHeap(), 0, len * sizeof(char));
44 if (!msgA)
45 return 0;
46
47 WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen, msgA, len,
48 NULL, NULL);
49 WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), msgA, len, &count, FALSE);
50 HeapFree(GetProcessHeap(), 0, msgA);
51 }
52
53 return count;
54 }
55
56 static int reg_message(int msg)
57 {
58 static const WCHAR formatW[] = {'%','s',0};
59 WCHAR msg_buffer[8192];
60
61 LoadStringW(GetModuleHandleW(NULL), msg, msg_buffer,
62 sizeof(msg_buffer)/sizeof(WCHAR));
63 return reg_printfW(formatW, msg_buffer);
64 }
65
66 static HKEY get_rootkey(LPWSTR key)
67 {
68 static const WCHAR szHKLM[] = {'H','K','L','M',0};
69 static const WCHAR szHKCU[] = {'H','K','C','U',0};
70 static const WCHAR szHKCR[] = {'H','K','C','R',0};
71 static const WCHAR szHKU[] = {'H','K','U',0};
72 static const WCHAR szHKCC[] = {'H','K','C','C',0};
73
74 if (CompareStringW(CP_ACP,NORM_IGNORECASE,key,4,szHKLM,4)==2)
75 return HKEY_LOCAL_MACHINE;
76 else if (CompareStringW(CP_ACP,NORM_IGNORECASE,key,4,szHKCU,4)==2)
77 return HKEY_CURRENT_USER;
78 else if (CompareStringW(CP_ACP,NORM_IGNORECASE,key,4,szHKCR,4)==2)
79 return HKEY_CLASSES_ROOT;
80 else if (CompareStringW(CP_ACP,NORM_IGNORECASE,key,3,szHKU,3)==2)
81 return HKEY_USERS;
82 else if (CompareStringW(CP_ACP,NORM_IGNORECASE,key,4,szHKCC,4)==2)
83 return HKEY_CURRENT_CONFIG;
84 else return NULL;
85 }
86
87 static DWORD get_regtype(LPWSTR type)
88 {
89 static const WCHAR szREG_SZ[] = {'R','E','G','_','S','Z',0};
90 static const WCHAR szREG_MULTI_SZ[] = {'R','E','G','_','M','U','L','T','I','_','S','Z',0};
91 static const WCHAR szREG_DWORD_BIG_ENDIAN[] = {'R','E','G','_','D','W','O','R','D','_','B','I','G','_','E','N','D','I','A','N',0};
92 static const WCHAR szREG_DWORD[] = {'R','E','G','_','D','W','O','R','D',0};
93 static const WCHAR szREG_BINARY[] = {'R','E','G','_','B','I','N','A','R','Y',0};
94 static const WCHAR szREG_DWORD_LITTLE_ENDIAN[] = {'R','E','G','_','D','W','O','R','D','_','L','I','T','T','L','E','_','E','N','D','I','A','N',0};
95 static const WCHAR szREG_NONE[] = {'R','E','G','_','N','O','N','E',0};
96 static const WCHAR szREG_EXPAND_SZ[] = {'R','E','G','_','E','X','P','A','N','D','_','S','Z',0};
97
98 if (!type)
99 return REG_SZ;
100
101 if (lstrcmpiW(type,szREG_SZ)==0) return REG_SZ;
102 if (lstrcmpiW(type,szREG_DWORD)==0) return REG_DWORD;
103 if (lstrcmpiW(type,szREG_MULTI_SZ)==0) return REG_MULTI_SZ;
104 if (lstrcmpiW(type,szREG_EXPAND_SZ)==0) return REG_EXPAND_SZ;
105 if (lstrcmpiW(type,szREG_DWORD_BIG_ENDIAN)==0) return REG_DWORD_BIG_ENDIAN;
106 if (lstrcmpiW(type,szREG_DWORD_LITTLE_ENDIAN)==0) return REG_DWORD_LITTLE_ENDIAN;
107 if (lstrcmpiW(type,szREG_BINARY)==0) return REG_BINARY;
108 if (lstrcmpiW(type,szREG_NONE)==0) return REG_NONE;
109
110 return -1;
111 }
112
113 static LPBYTE get_regdata(LPWSTR data, DWORD reg_type, WCHAR separator, DWORD *reg_count)
114 {
115 LPBYTE out_data = NULL;
116 *reg_count = 0;
117
118 switch (reg_type)
119 {
120 case REG_SZ:
121 {
122 *reg_count = (lstrlenW(data) + 1) * sizeof(WCHAR);
123 out_data = HeapAlloc(GetProcessHeap(),0,*reg_count);
124 lstrcpyW((LPWSTR)out_data,data);
125 break;
126 }
127 default:
128 {
129 static const WCHAR unhandled[] = {'U','n','h','a','n','d','l','e','d',' ','T','y','p','e',' ','0','x','%','x',' ',' ','d','a','t','a',' ','%','s','\n',0};
130 reg_printfW(unhandled, reg_type,data);
131 }
132 }
133
134 return out_data;
135 }
136
137 static int reg_add(WCHAR *key_name, WCHAR *value_name, BOOL value_empty,
138 WCHAR *type, WCHAR separator, WCHAR *data, BOOL force)
139 {
140 static const WCHAR stubW[] = {'A','D','D',' ','-',' ','%','s',
141 ' ','%','s',' ','%','d',' ','%','s',' ','%','s',' ','%','d','\n',0};
142 LPWSTR p;
143 HKEY root,subkey;
144
145 reg_printfW(stubW, key_name, value_name, value_empty, type, data, force);
146
147 if (key_name[0]=='\\' && key_name[1]=='\\')
148 {
149 reg_message(STRING_NO_REMOTE);
150 return 1;
151 }
152
153 p = strchrW(key_name,'\\');
154 if (!p)
155 {
156 reg_message(STRING_INVALID_KEY);
157 return 1;
158 }
159 p++;
160
161 root = get_rootkey(key_name);
162 if (!root)
163 {
164 reg_message(STRING_INVALID_KEY);
165 return 1;
166 }
167
168 if(RegCreateKeyW(root,p,&subkey)!=ERROR_SUCCESS)
169 {
170 reg_message(STRING_INVALID_KEY);
171 return 1;
172 }
173
174 if (value_name || data)
175 {
176 DWORD reg_type;
177 DWORD reg_count = 0;
178 BYTE* reg_data = NULL;
179
180 if (!force)
181 {
182 if (RegQueryValueW(subkey,value_name,NULL,NULL)==ERROR_SUCCESS)
183 {
184 /* FIXME: Prompt for overwrite */
185 }
186 }
187
188 reg_type = get_regtype(type);
189 if (reg_type == -1)
190 {
191 RegCloseKey(subkey);
192 reg_message(STRING_INVALID_CMDLINE);
193 return 1;
194 }
195
196 if (data)
197 reg_data = get_regdata(data,reg_type,separator,&reg_count);
198
199 RegSetValueExW(subkey,value_name,0,reg_type,reg_data,reg_count);
200 HeapFree(GetProcessHeap(),0,reg_data);
201 }
202
203 RegCloseKey(subkey);
204 reg_message(STRING_SUCCESS);
205
206 return 0;
207 }
208
209 static int reg_delete(WCHAR *key_name, WCHAR *value_name, BOOL value_empty,
210 BOOL value_all, BOOL force)
211 {
212 LPWSTR p;
213 HKEY root,subkey;
214
215 static const WCHAR stubW[] = {'D','E','L','E','T','E',
216 ' ','-',' ','%','s',' ','%','s',' ','%','d',' ','%','d',' ','%','d','\n'
217 ,0};
218 reg_printfW(stubW, key_name, value_name, value_empty, value_all, force);
219
220 if (key_name[0]=='\\' && key_name[1]=='\\')
221 {
222 reg_message(STRING_NO_REMOTE);
223 return 1;
224 }
225
226 p = strchrW(key_name,'\\');
227 if (!p)
228 {
229 reg_message(STRING_INVALID_KEY);
230 return 1;
231 }
232 p++;
233
234 root = get_rootkey(key_name);
235 if (!root)
236 {
237 reg_message(STRING_INVALID_KEY);
238 return 1;
239 }
240
241 if (value_name && value_empty)
242 {
243 reg_message(STRING_INVALID_CMDLINE);
244 return 1;
245 }
246
247 if (value_empty && value_all)
248 {
249 reg_message(STRING_INVALID_CMDLINE);
250 return 1;
251 }
252
253 if (!force)
254 {
255 /* FIXME: Prompt for delete */
256 }
257
258 /* Delete subtree only if no /v* option is given */
259 if (!value_name && !value_empty && !value_all)
260 {
261 if (RegDeleteTreeW(root,p)!=ERROR_SUCCESS)
262 {
263 reg_message(STRING_CANNOT_FIND);
264 return 1;
265 }
266 reg_message(STRING_SUCCESS);
267 return 0;
268 }
269
270 if(RegOpenKeyW(root,p,&subkey)!=ERROR_SUCCESS)
271 {
272 reg_message(STRING_CANNOT_FIND);
273 return 1;
274 }
275
276 if (value_all)
277 {
278 LPWSTR szValue;
279 DWORD maxValue;
280 DWORD count;
281 LONG rc;
282
283 rc = RegQueryInfoKeyW(subkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
284 &maxValue, NULL, NULL, NULL);
285 if (rc != ERROR_SUCCESS)
286 {
287 /* FIXME: failure */
288 RegCloseKey(subkey);
289 return 1;
290 }
291 maxValue++;
292 szValue = HeapAlloc(GetProcessHeap(),0,maxValue*sizeof(WCHAR));
293
294 while (1)
295 {
296 count = maxValue;
297 rc = RegEnumValueW(subkey, 0, szValue, &count, NULL, NULL, NULL, NULL);
298 if (rc == ERROR_SUCCESS)
299 {
300 rc = RegDeleteValueW(subkey, szValue);
301 if (rc != ERROR_SUCCESS)
302 break;
303 }
304 else break;
305 }
306 if (rc != ERROR_SUCCESS)
307 {
308 /* FIXME delete failed */
309 }
310 }
311 else if (value_name)
312 {
313 if (RegDeleteValueW(subkey,value_name) != ERROR_SUCCESS)
314 {
315 RegCloseKey(subkey);
316 reg_message(STRING_CANNOT_FIND);
317 return 1;
318 }
319 }
320 else if (value_empty)
321 {
322 RegSetValueExW(subkey,NULL,0,REG_SZ,NULL,0);
323 }
324
325 RegCloseKey(subkey);
326 reg_message(STRING_SUCCESS);
327 return 0;
328 }
329
330 static int reg_query(WCHAR *key_name, WCHAR *value_name, BOOL value_empty,
331 BOOL subkey)
332 {
333 static const WCHAR stubW[] = {'S','T','U','B',' ','Q','U','E','R','Y',' ',
334 '-',' ','%','s',' ','%','s',' ','%','d',' ','%','d','\n',0};
335 reg_printfW(stubW, key_name, value_name, value_empty, subkey);
336
337 return 1;
338 }
339
340 int wmain(int argc, WCHAR *argvW[])
341 {
342 int i;
343
344 static const WCHAR addW[] = {'a','d','d',0};
345 static const WCHAR deleteW[] = {'d','e','l','e','t','e',0};
346 static const WCHAR queryW[] = {'q','u','e','r','y',0};
347 static const WCHAR slashDW[] = {'/','d',0};
348 static const WCHAR slashFW[] = {'/','f',0};
349 static const WCHAR slashHW[] = {'/','h',0};
350 static const WCHAR slashSW[] = {'/','s',0};
351 static const WCHAR slashTW[] = {'/','t',0};
352 static const WCHAR slashVW[] = {'/','v',0};
353 static const WCHAR slashVAW[] = {'/','v','a',0};
354 static const WCHAR slashVEW[] = {'/','v','e',0};
355 static const WCHAR slashHelpW[] = {'/','?',0};
356
357 if (argc < 2 || !lstrcmpW(argvW[1], slashHelpW)
358 || !lstrcmpiW(argvW[1], slashHW))
359 {
360 reg_message(STRING_USAGE);
361 return 0;
362 }
363
364 if (!lstrcmpiW(argvW[1], addW))
365 {
366 WCHAR *key_name, *value_name = NULL, *type = NULL, separator = '\0', *data = NULL;
367 BOOL value_empty = FALSE, force = FALSE;
368
369 if (argc < 3)
370 {
371 reg_message(STRING_INVALID_CMDLINE);
372 return 1;
373 }
374 else if (argc == 3 && (!lstrcmpW(argvW[2], slashHelpW) ||
375 !lstrcmpiW(argvW[2], slashHW)))
376 {
377 reg_message(STRING_ADD_USAGE);
378 return 0;
379 }
380
381 key_name = argvW[2];
382 for (i = 1; i < argc; i++)
383 {
384 if (!lstrcmpiW(argvW[i], slashVW))
385 value_name = argvW[++i];
386 else if (!lstrcmpiW(argvW[i], slashVEW))
387 value_empty = TRUE;
388 else if (!lstrcmpiW(argvW[i], slashTW))
389 type = argvW[++i];
390 else if (!lstrcmpiW(argvW[i], slashSW))
391 separator = argvW[++i][0];
392 else if (!lstrcmpiW(argvW[i], slashDW))
393 data = argvW[++i];
394 else if (!lstrcmpiW(argvW[i], slashFW))
395 force = TRUE;
396 }
397 return reg_add(key_name, value_name, value_empty, type, separator,
398 data, force);
399 }
400 else if (!lstrcmpiW(argvW[1], deleteW))
401 {
402 WCHAR *key_name, *value_name = NULL;
403 BOOL value_empty = FALSE, value_all = FALSE, force = FALSE;
404
405 if (argc < 3)
406 {
407 reg_message(STRING_INVALID_CMDLINE);
408 return 1;
409 }
410 else if (argc == 3 && (!lstrcmpW(argvW[2], slashHelpW) ||
411 !lstrcmpiW(argvW[2], slashHW)))
412 {
413 reg_message(STRING_DELETE_USAGE);
414 return 0;
415 }
416
417 key_name = argvW[2];
418 for (i = 1; i < argc; i++)
419 {
420 if (!lstrcmpiW(argvW[i], slashVW))
421 value_name = argvW[++i];
422 else if (!lstrcmpiW(argvW[i], slashVEW))
423 value_empty = TRUE;
424 else if (!lstrcmpiW(argvW[i], slashVAW))
425 value_all = TRUE;
426 else if (!lstrcmpiW(argvW[i], slashFW))
427 force = TRUE;
428 }
429 return reg_delete(key_name, value_name, value_empty, value_all, force);
430 }
431 else if (!lstrcmpiW(argvW[1], queryW))
432 {
433 WCHAR *key_name, *value_name = NULL;
434 BOOL value_empty = FALSE, subkey = FALSE;
435
436 if (argc < 3)
437 {
438 reg_message(STRING_INVALID_CMDLINE);
439 return 1;
440 }
441 else if (argc == 3 && (!lstrcmpW(argvW[2], slashHelpW) ||
442 !lstrcmpiW(argvW[2], slashHW)))
443 {
444 reg_message(STRING_QUERY_USAGE);
445 return 0;
446 }
447
448 key_name = argvW[2];
449 for (i = 1; i < argc; i++)
450 {
451 if (!lstrcmpiW(argvW[i], slashVW))
452 value_name = argvW[++i];
453 else if (!lstrcmpiW(argvW[i], slashVEW))
454 value_empty = TRUE;
455 else if (!lstrcmpiW(argvW[i], slashSW))
456 subkey = TRUE;
457 }
458 return reg_query(key_name, value_name, value_empty, subkey);
459 }
460 else
461 {
462 reg_message(STRING_INVALID_CMDLINE);
463 return 1;
464 }
465 }