2 * Copyright 2008 Andrew Riedi
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.
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.
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
20 #include <wine/unicode.h>
23 static int reg_printfW(const WCHAR
*msg
, ...)
28 WCHAR msg_buffer
[8192];
30 va_start(va_args
, msg
);
31 vsnprintfW(msg_buffer
, 8192, msg
, va_args
);
34 wlen
= lstrlenW(msg_buffer
);
35 ret
= WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE
), msg_buffer
, wlen
, &count
, NULL
);
41 /* On Windows WriteConsoleW() fails if the output is redirected. So fall
42 * back to WriteFile(), assuming the console encoding is still the right
45 len
= WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer
, wlen
,
47 msgA
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(char));
51 WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer
, wlen
, msgA
, len
,
53 WriteFile(GetStdHandle(STD_OUTPUT_HANDLE
), msgA
, len
, &count
, FALSE
);
54 HeapFree(GetProcessHeap(), 0, msgA
);
60 static int reg_message(int msg
)
62 static const WCHAR formatW
[] = {'%','s',0};
63 WCHAR msg_buffer
[8192];
65 LoadStringW(GetModuleHandleW(NULL
), msg
, msg_buffer
,
66 sizeof(msg_buffer
)/sizeof(WCHAR
));
67 return reg_printfW(formatW
, msg_buffer
);
70 static int reg_StrCmpNIW(LPCWSTR str
, LPCWSTR comp
, int len
)
74 for (i
= 0; i
< len
; i
++)
83 return CompareStringW(CP_ACP
, NORM_IGNORECASE
, str
, len
, comp
, len
) - CSTR_EQUAL
;
86 static HKEY
get_rootkey(LPWSTR key
)
88 static const WCHAR szHKLM
[] = {'H','K','L','M',0};
89 static const WCHAR szHKEY_LOCAL_MACHINE
[] = {'H','K','E','Y','_','L','O','C','A','L','_','M','A','C','H','I','N','E',0};
90 static const WCHAR szHKCU
[] = {'H','K','C','U',0};
91 static const WCHAR szHKEY_CURRENT_USER
[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R',0};
92 static const WCHAR szHKCR
[] = {'H','K','C','R',0};
93 static const WCHAR szHKEY_CLASSES_ROOT
[] = {'H','K','E','Y','_','C','L','A','S','S','E','S','_','R','O','O','T',0};
94 static const WCHAR szHKU
[] = {'H','K','U',0};
95 static const WCHAR szHKEY_USERS
[] = {'H','K','E','Y','_','U','S','E','R','S',0};
96 static const WCHAR szHKCC
[] = {'H','K','C','C',0};
97 static const WCHAR szHKEY_CURRENT_CONFIG
[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','C','O','N','F','I','G',0};
99 if (!reg_StrCmpNIW(key
, szHKLM
, 4) ||
100 !reg_StrCmpNIW(key
, szHKEY_LOCAL_MACHINE
, 18))
101 return HKEY_LOCAL_MACHINE
;
102 else if (!reg_StrCmpNIW(key
, szHKCU
, 4) ||
103 !reg_StrCmpNIW(key
, szHKEY_CURRENT_USER
, 17))
104 return HKEY_CURRENT_USER
;
105 else if (!reg_StrCmpNIW(key
, szHKCR
, 4) ||
106 !reg_StrCmpNIW(key
, szHKEY_CLASSES_ROOT
, 17))
107 return HKEY_CLASSES_ROOT
;
108 else if (!reg_StrCmpNIW(key
, szHKU
, 3) ||
109 !reg_StrCmpNIW(key
, szHKEY_USERS
, 10))
111 else if (!reg_StrCmpNIW(key
, szHKCC
, 4) ||
112 !reg_StrCmpNIW(key
, szHKEY_CURRENT_CONFIG
, 19))
113 return HKEY_CURRENT_CONFIG
;
117 static DWORD
get_regtype(LPWSTR type
)
119 static const WCHAR szREG_SZ
[] = {'R','E','G','_','S','Z',0};
120 static const WCHAR szREG_MULTI_SZ
[] = {'R','E','G','_','M','U','L','T','I','_','S','Z',0};
121 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};
122 static const WCHAR szREG_DWORD
[] = {'R','E','G','_','D','W','O','R','D',0};
123 static const WCHAR szREG_BINARY
[] = {'R','E','G','_','B','I','N','A','R','Y',0};
124 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};
125 static const WCHAR szREG_NONE
[] = {'R','E','G','_','N','O','N','E',0};
126 static const WCHAR szREG_EXPAND_SZ
[] = {'R','E','G','_','E','X','P','A','N','D','_','S','Z',0};
131 if (lstrcmpiW(type
,szREG_SZ
)==0) return REG_SZ
;
132 if (lstrcmpiW(type
,szREG_DWORD
)==0) return REG_DWORD
;
133 if (lstrcmpiW(type
,szREG_MULTI_SZ
)==0) return REG_MULTI_SZ
;
134 if (lstrcmpiW(type
,szREG_EXPAND_SZ
)==0) return REG_EXPAND_SZ
;
135 if (lstrcmpiW(type
,szREG_DWORD_BIG_ENDIAN
)==0) return REG_DWORD_BIG_ENDIAN
;
136 if (lstrcmpiW(type
,szREG_DWORD_LITTLE_ENDIAN
)==0) return REG_DWORD_LITTLE_ENDIAN
;
137 if (lstrcmpiW(type
,szREG_BINARY
)==0) return REG_BINARY
;
138 if (lstrcmpiW(type
,szREG_NONE
)==0) return REG_NONE
;
143 static LPBYTE
get_regdata(LPWSTR data
, DWORD reg_type
, WCHAR separator
, DWORD
*reg_count
)
145 LPBYTE out_data
= NULL
;
152 *reg_count
= (lstrlenW(data
) + 1) * sizeof(WCHAR
);
153 out_data
= HeapAlloc(GetProcessHeap(),0,*reg_count
);
154 lstrcpyW((LPWSTR
)out_data
,data
);
161 val
= strtolW(data
, &rest
, 0);
163 static const WCHAR nonnumber
[] = {'E','r','r','o','r',':',' ','/','d',' ','r','e','q','u','i','r','e','s',' ','n','u','m','b','e','r','.','\n',0};
164 reg_printfW(nonnumber
);
167 *reg_count
= sizeof(DWORD
);
168 out_data
= HeapAlloc(GetProcessHeap(),0,*reg_count
);
169 ((LPDWORD
)out_data
)[0] = val
;
174 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};
175 reg_printfW(unhandled
, reg_type
,data
);
182 static int reg_add(WCHAR
*key_name
, WCHAR
*value_name
, BOOL value_empty
,
183 WCHAR
*type
, WCHAR separator
, WCHAR
*data
, BOOL force
)
185 static const WCHAR stubW
[] = {'A','D','D',' ','-',' ','%','s',
186 ' ','%','s',' ','%','d',' ','%','s',' ','%','s',' ','%','d','\n',0};
190 reg_printfW(stubW
, key_name
, value_name
, value_empty
, type
, data
, force
);
192 if (key_name
[0]=='\\' && key_name
[1]=='\\')
194 reg_message(STRING_NO_REMOTE
);
198 p
= strchrW(key_name
,'\\');
201 reg_message(STRING_INVALID_KEY
);
206 root
= get_rootkey(key_name
);
209 reg_message(STRING_INVALID_KEY
);
213 if(RegCreateKeyW(root
,p
,&subkey
)!=ERROR_SUCCESS
)
215 reg_message(STRING_INVALID_KEY
);
219 if (value_name
|| data
)
223 BYTE
* reg_data
= NULL
;
227 if (RegQueryValueW(subkey
,value_name
,NULL
,NULL
)==ERROR_SUCCESS
)
229 /* FIXME: Prompt for overwrite */
233 reg_type
= get_regtype(type
);
237 reg_message(STRING_INVALID_CMDLINE
);
242 reg_data
= get_regdata(data
,reg_type
,separator
,®_count
);
244 RegSetValueExW(subkey
,value_name
,0,reg_type
,reg_data
,reg_count
);
245 HeapFree(GetProcessHeap(),0,reg_data
);
249 reg_message(STRING_SUCCESS
);
254 static int reg_delete(WCHAR
*key_name
, WCHAR
*value_name
, BOOL value_empty
,
255 BOOL value_all
, BOOL force
)
260 static const WCHAR stubW
[] = {'D','E','L','E','T','E',
261 ' ','-',' ','%','s',' ','%','s',' ','%','d',' ','%','d',' ','%','d','\n'
263 reg_printfW(stubW
, key_name
, value_name
, value_empty
, value_all
, force
);
265 if (key_name
[0]=='\\' && key_name
[1]=='\\')
267 reg_message(STRING_NO_REMOTE
);
271 p
= strchrW(key_name
,'\\');
274 reg_message(STRING_INVALID_KEY
);
279 root
= get_rootkey(key_name
);
282 reg_message(STRING_INVALID_KEY
);
286 if (value_name
&& value_empty
)
288 reg_message(STRING_INVALID_CMDLINE
);
292 if (value_empty
&& value_all
)
294 reg_message(STRING_INVALID_CMDLINE
);
300 /* FIXME: Prompt for delete */
303 /* Delete subtree only if no /v* option is given */
304 if (!value_name
&& !value_empty
&& !value_all
)
306 if (RegDeleteTreeW(root
,p
)!=ERROR_SUCCESS
)
308 reg_message(STRING_CANNOT_FIND
);
311 reg_message(STRING_SUCCESS
);
315 if(RegOpenKeyW(root
,p
,&subkey
)!=ERROR_SUCCESS
)
317 reg_message(STRING_CANNOT_FIND
);
328 rc
= RegQueryInfoKeyW(subkey
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
329 &maxValue
, NULL
, NULL
, NULL
);
330 if (rc
!= ERROR_SUCCESS
)
337 szValue
= HeapAlloc(GetProcessHeap(),0,maxValue
*sizeof(WCHAR
));
342 rc
= RegEnumValueW(subkey
, 0, szValue
, &count
, NULL
, NULL
, NULL
, NULL
);
343 if (rc
== ERROR_SUCCESS
)
345 rc
= RegDeleteValueW(subkey
, szValue
);
346 if (rc
!= ERROR_SUCCESS
)
351 if (rc
!= ERROR_SUCCESS
)
353 /* FIXME delete failed */
358 if (RegDeleteValueW(subkey
,value_name
) != ERROR_SUCCESS
)
361 reg_message(STRING_CANNOT_FIND
);
365 else if (value_empty
)
367 RegSetValueExW(subkey
,NULL
,0,REG_SZ
,NULL
,0);
371 reg_message(STRING_SUCCESS
);
375 static int reg_query(WCHAR
*key_name
, WCHAR
*value_name
, BOOL value_empty
,
378 static const WCHAR stubW
[] = {'S','T','U','B',' ','Q','U','E','R','Y',' ',
379 '-',' ','%','s',' ','%','s',' ','%','d',' ','%','d','\n',0};
380 reg_printfW(stubW
, key_name
, value_name
, value_empty
, subkey
);
385 int wmain(int argc
, WCHAR
*argvW
[])
389 static const WCHAR addW
[] = {'a','d','d',0};
390 static const WCHAR deleteW
[] = {'d','e','l','e','t','e',0};
391 static const WCHAR queryW
[] = {'q','u','e','r','y',0};
392 static const WCHAR slashDW
[] = {'/','d',0};
393 static const WCHAR slashFW
[] = {'/','f',0};
394 static const WCHAR slashHW
[] = {'/','h',0};
395 static const WCHAR slashSW
[] = {'/','s',0};
396 static const WCHAR slashTW
[] = {'/','t',0};
397 static const WCHAR slashVW
[] = {'/','v',0};
398 static const WCHAR slashVAW
[] = {'/','v','a',0};
399 static const WCHAR slashVEW
[] = {'/','v','e',0};
400 static const WCHAR slashHelpW
[] = {'/','?',0};
402 if (argc
< 2 || !lstrcmpW(argvW
[1], slashHelpW
)
403 || !lstrcmpiW(argvW
[1], slashHW
))
405 reg_message(STRING_USAGE
);
409 if (!lstrcmpiW(argvW
[1], addW
))
411 WCHAR
*key_name
, *value_name
= NULL
, *type
= NULL
, separator
= '\0', *data
= NULL
;
412 BOOL value_empty
= FALSE
, force
= FALSE
;
416 reg_message(STRING_INVALID_CMDLINE
);
419 else if (argc
== 3 && (!lstrcmpW(argvW
[2], slashHelpW
) ||
420 !lstrcmpiW(argvW
[2], slashHW
)))
422 reg_message(STRING_ADD_USAGE
);
427 for (i
= 1; i
< argc
; i
++)
429 if (!lstrcmpiW(argvW
[i
], slashVW
))
430 value_name
= argvW
[++i
];
431 else if (!lstrcmpiW(argvW
[i
], slashVEW
))
433 else if (!lstrcmpiW(argvW
[i
], slashTW
))
435 else if (!lstrcmpiW(argvW
[i
], slashSW
))
436 separator
= argvW
[++i
][0];
437 else if (!lstrcmpiW(argvW
[i
], slashDW
))
439 else if (!lstrcmpiW(argvW
[i
], slashFW
))
442 return reg_add(key_name
, value_name
, value_empty
, type
, separator
,
445 else if (!lstrcmpiW(argvW
[1], deleteW
))
447 WCHAR
*key_name
, *value_name
= NULL
;
448 BOOL value_empty
= FALSE
, value_all
= FALSE
, force
= FALSE
;
452 reg_message(STRING_INVALID_CMDLINE
);
455 else if (argc
== 3 && (!lstrcmpW(argvW
[2], slashHelpW
) ||
456 !lstrcmpiW(argvW
[2], slashHW
)))
458 reg_message(STRING_DELETE_USAGE
);
463 for (i
= 1; i
< argc
; i
++)
465 if (!lstrcmpiW(argvW
[i
], slashVW
))
466 value_name
= argvW
[++i
];
467 else if (!lstrcmpiW(argvW
[i
], slashVEW
))
469 else if (!lstrcmpiW(argvW
[i
], slashVAW
))
471 else if (!lstrcmpiW(argvW
[i
], slashFW
))
474 return reg_delete(key_name
, value_name
, value_empty
, value_all
, force
);
476 else if (!lstrcmpiW(argvW
[1], queryW
))
478 WCHAR
*key_name
, *value_name
= NULL
;
479 BOOL value_empty
= FALSE
, subkey
= FALSE
;
483 reg_message(STRING_INVALID_CMDLINE
);
486 else if (argc
== 3 && (!lstrcmpW(argvW
[2], slashHelpW
) ||
487 !lstrcmpiW(argvW
[2], slashHW
)))
489 reg_message(STRING_QUERY_USAGE
);
494 for (i
= 1; i
< argc
; i
++)
496 if (!lstrcmpiW(argvW
[i
], slashVW
))
497 value_name
= argvW
[++i
];
498 else if (!lstrcmpiW(argvW
[i
], slashVEW
))
500 else if (!lstrcmpiW(argvW
[i
], slashSW
))
503 return reg_query(key_name
, value_name
, value_empty
, subkey
);
507 reg_message(STRING_INVALID_CMDLINE
);