8b08da1299983bcd82453e1f466928c5cf933082
[reactos.git] / base / applications / cmdutils / reg / export.c
1 /*
2 * Copyright 2017 Hugh McMaster
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 <stdlib.h>
21
22 #include <wine/unicode.h>
23 #include <wine/heap.h>
24
25 #include "reg.h"
26
27 static void write_file(HANDLE hFile, const WCHAR *str)
28 {
29 DWORD written;
30
31 WriteFile(hFile, str, lstrlenW(str) * sizeof(WCHAR), &written, NULL);
32 }
33
34 static WCHAR *escape_string(WCHAR *str, size_t str_len, size_t *line_len)
35 {
36 size_t i, escape_count, pos;
37 WCHAR *buf;
38
39 for (i = 0, escape_count = 0; i < str_len; i++)
40 {
41 WCHAR c = str[i];
42
43 if (!c) break;
44
45 if (c == '\r' || c == '\n' || c == '\\' || c == '"')
46 escape_count++;
47 }
48
49 buf = heap_xalloc((str_len + escape_count + 1) * sizeof(WCHAR));
50
51 for (i = 0, pos = 0; i < str_len; i++, pos++)
52 {
53 WCHAR c = str[i];
54
55 if (!c) break;
56
57 switch (c)
58 {
59 case '\r':
60 buf[pos++] = '\\';
61 buf[pos] = 'r';
62 break;
63 case '\n':
64 buf[pos++] = '\\';
65 buf[pos] = 'n';
66 break;
67 case '\\':
68 buf[pos++] = '\\';
69 buf[pos] = '\\';
70 break;
71 case '"':
72 buf[pos++] = '\\';
73 buf[pos] = '"';
74 break;
75 default:
76 buf[pos] = c;
77 }
78 }
79
80 buf[pos] = 0;
81 *line_len = pos;
82 return buf;
83 }
84
85 static size_t export_value_name(HANDLE hFile, WCHAR *name, size_t len)
86 {
87 static const WCHAR quoted_fmt[] = {'"','%','s','"','=',0};
88 static const WCHAR default_name[] = {'@','=',0};
89 size_t line_len;
90
91 if (name && *name)
92 {
93 WCHAR *str = escape_string(name, len, &line_len);
94 WCHAR *buf = heap_xalloc((line_len + 4) * sizeof(WCHAR));
95 line_len = sprintfW(buf, quoted_fmt, str);
96 write_file(hFile, buf);
97 heap_free(buf);
98 heap_free(str);
99 }
100 else
101 {
102 line_len = lstrlenW(default_name);
103 write_file(hFile, default_name);
104 }
105
106 return line_len;
107 }
108
109 static void export_string_data(WCHAR **buf, WCHAR *data, size_t size)
110 {
111 size_t len = 0, line_len;
112 WCHAR *str;
113 static const WCHAR fmt[] = {'"','%','s','"',0};
114
115 if (size)
116 len = size / sizeof(WCHAR) - 1;
117 str = escape_string(data, len, &line_len);
118 *buf = heap_xalloc((line_len + 3) * sizeof(WCHAR));
119 sprintfW(*buf, fmt, str);
120 heap_free(str);
121 }
122
123 static void export_dword_data(WCHAR **buf, DWORD *data)
124 {
125 static const WCHAR fmt[] = {'d','w','o','r','d',':','%','0','8','x',0};
126
127 *buf = heap_xalloc(15 * sizeof(WCHAR));
128 sprintfW(*buf, fmt, *data);
129 }
130
131 static size_t export_hex_data_type(HANDLE hFile, DWORD type)
132 {
133 static const WCHAR hex[] = {'h','e','x',':',0};
134 static const WCHAR hexp_fmt[] = {'h','e','x','(','%','x',')',':',0};
135 size_t line_len;
136
137 if (type == REG_BINARY)
138 {
139 line_len = lstrlenW(hex);
140 write_file(hFile, hex);
141 }
142 else
143 {
144 WCHAR *buf = heap_xalloc(15 * sizeof(WCHAR));
145 line_len = sprintfW(buf, hexp_fmt, type);
146 write_file(hFile, buf);
147 heap_free(buf);
148 }
149
150 return line_len;
151 }
152
153 #define MAX_HEX_CHARS 77
154
155 static void export_hex_data(HANDLE hFile, WCHAR **buf, DWORD type,
156 DWORD line_len, void *data, DWORD size)
157 {
158 static const WCHAR fmt[] = {'%','0','2','x',0};
159 static const WCHAR hex_concat[] = {'\\','\r','\n',' ',' ',0};
160 size_t num_commas, i, pos;
161
162 line_len += export_hex_data_type(hFile, type);
163
164 if (!size) return;
165
166 num_commas = size - 1;
167 *buf = heap_xalloc(size * 3 * sizeof(WCHAR));
168
169 for (i = 0, pos = 0; i < size; i++)
170 {
171 pos += sprintfW(*buf + pos, fmt, ((BYTE *)data)[i]);
172 if (i == num_commas) break;
173 (*buf)[pos++] = ',';
174 (*buf)[pos] = 0;
175 line_len += 3;
176
177 if (line_len >= MAX_HEX_CHARS)
178 {
179 write_file(hFile, *buf);
180 write_file(hFile, hex_concat);
181 line_len = 2;
182 pos = 0;
183 }
184 }
185 }
186
187 static void export_newline(HANDLE hFile)
188 {
189 static const WCHAR newline[] = {'\r','\n',0};
190
191 write_file(hFile, newline);
192 }
193
194 static void export_data(HANDLE hFile, WCHAR *value_name, DWORD value_len,
195 DWORD type, void *data, size_t size)
196 {
197 WCHAR *buf = NULL;
198 size_t line_len = export_value_name(hFile, value_name, value_len);
199
200 switch (type)
201 {
202 case REG_SZ:
203 export_string_data(&buf, data, size);
204 break;
205 case REG_DWORD:
206 if (size)
207 {
208 export_dword_data(&buf, data);
209 break;
210 }
211 /* fall through */
212 case REG_NONE:
213 case REG_EXPAND_SZ:
214 case REG_BINARY:
215 case REG_MULTI_SZ:
216 default:
217 export_hex_data(hFile, &buf, type, line_len, data, size);
218 break;
219 }
220
221 if (size || type == REG_SZ)
222 {
223 write_file(hFile, buf);
224 heap_free(buf);
225 }
226
227 export_newline(hFile);
228 }
229
230 static void export_key_name(HANDLE hFile, WCHAR *name)
231 {
232 static const WCHAR fmt[] = {'\r','\n','[','%','s',']','\r','\n',0};
233 WCHAR *buf;
234
235 buf = heap_xalloc((lstrlenW(name) + 7) * sizeof(WCHAR));
236 sprintfW(buf, fmt, name);
237 write_file(hFile, buf);
238 heap_free(buf);
239 }
240
241 static int export_registry_data(HANDLE hFile, HKEY key, WCHAR *path)
242 {
243 LONG rc;
244 DWORD max_value_len = 256, value_len;
245 DWORD max_data_bytes = 2048, data_size;
246 DWORD subkey_len;
247 DWORD i, type, path_len;
248 WCHAR *value_name, *subkey_name, *subkey_path;
249 BYTE *data;
250 HKEY subkey;
251
252 export_key_name(hFile, path);
253
254 value_name = heap_xalloc(max_value_len * sizeof(WCHAR));
255 data = heap_xalloc(max_data_bytes);
256
257 i = 0;
258 for (;;)
259 {
260 value_len = max_value_len;
261 data_size = max_data_bytes;
262 rc = RegEnumValueW(key, i, value_name, &value_len, NULL, &type, data, &data_size);
263
264 if (rc == ERROR_SUCCESS)
265 {
266 export_data(hFile, value_name, value_len, type, data, data_size);
267 i++;
268 }
269 else if (rc == ERROR_MORE_DATA)
270 {
271 if (data_size > max_data_bytes)
272 {
273 max_data_bytes = data_size;
274 data = heap_xrealloc(data, max_data_bytes);
275 }
276 else
277 {
278 max_value_len *= 2;
279 value_name = heap_xrealloc(value_name, max_value_len * sizeof(WCHAR));
280 }
281 }
282 else break;
283 }
284
285 heap_free(data);
286 heap_free(value_name);
287
288 subkey_name = heap_xalloc(MAX_SUBKEY_LEN * sizeof(WCHAR));
289
290 path_len = lstrlenW(path);
291
292 i = 0;
293 for (;;)
294 {
295 subkey_len = MAX_SUBKEY_LEN;
296 rc = RegEnumKeyExW(key, i, subkey_name, &subkey_len, NULL, NULL, NULL, NULL);
297 if (rc == ERROR_SUCCESS)
298 {
299 subkey_path = build_subkey_path(path, path_len, subkey_name, subkey_len);
300 if (!RegOpenKeyExW(key, subkey_name, 0, KEY_READ, &subkey))
301 {
302 export_registry_data(hFile, subkey, subkey_path);
303 RegCloseKey(subkey);
304 }
305 heap_free(subkey_path);
306 i++;
307 }
308 else break;
309 }
310
311 heap_free(subkey_name);
312 return 0;
313 }
314
315 static void export_file_header(HANDLE hFile)
316 {
317 static const WCHAR header[] = { 0xfeff,'W','i','n','d','o','w','s',' ',
318 'R','e','g','i','s','t','r','y',' ','E','d','i','t','o','r',' ',
319 'V','e','r','s','i','o','n',' ','5','.','0','0','\r','\n'};
320
321 write_file(hFile, header);
322 }
323
324 static HANDLE create_file(const WCHAR *filename, DWORD action)
325 {
326 return CreateFileW(filename, GENERIC_WRITE, 0, NULL, action, FILE_ATTRIBUTE_NORMAL, NULL);
327 }
328
329 static HANDLE get_file_handle(WCHAR *filename, BOOL overwrite_file)
330 {
331 HANDLE hFile = create_file(filename, overwrite_file ? CREATE_ALWAYS : CREATE_NEW);
332
333 if (hFile == INVALID_HANDLE_VALUE)
334 {
335 DWORD error = GetLastError();
336
337 if (error == ERROR_FILE_EXISTS)
338 {
339 if (!ask_confirm(STRING_OVERWRITE_FILE, filename))
340 {
341 output_message(STRING_CANCELLED);
342 exit(0);
343 }
344
345 hFile = create_file(filename, CREATE_ALWAYS);
346 }
347 else
348 {
349 WCHAR *str;
350
351 FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
352 FORMAT_MESSAGE_IGNORE_INSERTS, NULL, error, 0, (WCHAR *)&str, 0, NULL);
353 output_writeconsole(str, lstrlenW(str));
354 LocalFree(str);
355 exit(1);
356 }
357 }
358
359 return hFile;
360 }
361
362 static BOOL is_overwrite_switch(const WCHAR *s)
363 {
364 if (strlenW(s) > 2)
365 return FALSE;
366
367 if ((s[0] == '/' || s[0] == '-') && (s[1] == 'y' || s[1] == 'Y'))
368 return TRUE;
369
370 return FALSE;
371 }
372
373 int reg_export(int argc, WCHAR *argv[])
374 {
375 HKEY root, hkey;
376 WCHAR *path, *long_key;
377 BOOL overwrite_file = FALSE;
378 HANDLE hFile;
379 int ret;
380
381 if (argc == 3 || argc > 5)
382 goto error;
383
384 if (!parse_registry_key(argv[2], &root, &path, &long_key))
385 return 1;
386
387 if (argc == 5 && !(overwrite_file = is_overwrite_switch(argv[4])))
388 goto error;
389
390 if (RegOpenKeyExW(root, path, 0, KEY_READ, &hkey))
391 {
392 output_message(STRING_INVALID_KEY);
393 return 1;
394 }
395
396 hFile = get_file_handle(argv[3], overwrite_file);
397 export_file_header(hFile);
398 ret = export_registry_data(hFile, hkey, long_key);
399 export_newline(hFile);
400 CloseHandle(hFile);
401
402 RegCloseKey(hkey);
403
404 return ret;
405
406 error:
407 output_message(STRING_INVALID_SYNTAX);
408 output_message(STRING_FUNC_HELP, struprW(argv[1]));
409 return 1;
410 }