?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
regedit: Improve the parsing of multiline hex data during the registry import operation.
[wine.git] / programs / regedit / regproc.c
blob512ddb469653d97f0f979dda3d1583875475a24c
1 /*
2 * Registry processing routines. Routines, common for registry
3 * processing frontends.
4 *
5 * Copyright 1999 Sylvain St-Germain
6 * Copyright 2002 Andriy Palamarchuk
7 * Copyright 2008 Alexander N. Sørnes <alex@thehandofagony.com>
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 <errno.h>
25 #include <limits.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <fcntl.h>
29 #include <io.h>
30 #include <windows.h>
31 #include <winnt.h>
32 #include <winreg.h>
33 #include <assert.h>
34 #include <wine/unicode.h>
35 #include <wine/debug.h>
36 #include "regproc.h"
37
38 #define REG_VAL_BUF_SIZE 4096
39
40 /* maximal number of characters in hexadecimal data line,
41 * including the indentation, but not including the '\' character
42 */
43 #define REG_FILE_HEX_LINE_LEN (2 + 25 * 3)
44
45 extern const WCHAR* reg_class_namesW[];
46
47 static HKEY reg_class_keys[] = {
48 HKEY_LOCAL_MACHINE, HKEY_USERS, HKEY_CLASSES_ROOT,
49 HKEY_CURRENT_CONFIG, HKEY_CURRENT_USER, HKEY_DYN_DATA
50 };
51
52 #define ARRAY_SIZE(A) (sizeof(A)/sizeof(*A))
53
54 /******************************************************************************
55 * Allocates memory and converts input from multibyte to wide chars
56 * Returned string must be freed by the caller
57 */
58 static WCHAR* GetWideString(const char* strA)
59 {
60 if(strA)
61 {
62 WCHAR* strW;
63 int len = MultiByteToWideChar(CP_ACP, 0, strA, -1, NULL, 0);
64
65 strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
66 CHECK_ENOUGH_MEMORY(strW);
67 MultiByteToWideChar(CP_ACP, 0, strA, -1, strW, len);
68 return strW;
69 }
70 return NULL;
71 }
72
73 /******************************************************************************
74 * Allocates memory and converts input from multibyte to wide chars
75 * Returned string must be freed by the caller
76 */
77 static WCHAR* GetWideStringN(const char* strA, int chars, DWORD *len)
78 {
79 if(strA)
80 {
81 WCHAR* strW;
82 *len = MultiByteToWideChar(CP_ACP, 0, strA, chars, NULL, 0);
83
84 strW = HeapAlloc(GetProcessHeap(), 0, *len * sizeof(WCHAR));
85 CHECK_ENOUGH_MEMORY(strW);
86 MultiByteToWideChar(CP_ACP, 0, strA, chars, strW, *len);
87 return strW;
88 }
89 *len = 0;
90 return NULL;
91 }
92
93 /******************************************************************************
94 * Allocates memory and converts input from wide chars to multibyte
95 * Returned string must be freed by the caller
96 */
97 char* GetMultiByteString(const WCHAR* strW)
98 {
99 if(strW)
100 {
101 char* strA;
102 int len = WideCharToMultiByte(CP_ACP, 0, strW, -1, NULL, 0, NULL, NULL);
103
104 strA = HeapAlloc(GetProcessHeap(), 0, len);
105 CHECK_ENOUGH_MEMORY(strA);
106 WideCharToMultiByte(CP_ACP, 0, strW, -1, strA, len, NULL, NULL);
107 return strA;
108 }
109 return NULL;
110 }
111
112 /******************************************************************************
113 * Allocates memory and converts input from wide chars to multibyte
114 * Returned string must be freed by the caller
115 */
116 static char* GetMultiByteStringN(const WCHAR* strW, int chars, DWORD* len)
117 {
118 if(strW)
119 {
120 char* strA;
121 *len = WideCharToMultiByte(CP_ACP, 0, strW, chars, NULL, 0, NULL, NULL);
122
123 strA = HeapAlloc(GetProcessHeap(), 0, *len);
124 CHECK_ENOUGH_MEMORY(strA);
125 WideCharToMultiByte(CP_ACP, 0, strW, chars, strA, *len, NULL, NULL);
126 return strA;
127 }
128 *len = 0;
129 return NULL;
130 }
131
132 static WCHAR *(*get_line)(FILE *);
133
134 /* parser definitions */
135 enum parser_state
136 {
137 HEADER, /* parsing the registry file version header */
138 PARSE_WIN31_LINE, /* parsing a Windows 3.1 registry line */
139 LINE_START, /* at the beginning of a registry line */
140 KEY_NAME, /* parsing a key name */
141 DELETE_KEY, /* deleting a registry key */
142 DEFAULT_VALUE_NAME, /* parsing a default value name */
143 QUOTED_VALUE_NAME, /* parsing a double-quoted value name */
144 DATA_START, /* preparing for data parsing operations */
145 DELETE_VALUE, /* deleting a registry value */
146 DATA_TYPE, /* parsing the registry data type */
147 STRING_DATA, /* parsing REG_SZ data */
148 DWORD_DATA, /* parsing DWORD data */
149 HEX_DATA, /* parsing REG_BINARY, REG_NONE, REG_EXPAND_SZ or REG_MULTI_SZ data */
150 EOL_BACKSLASH, /* preparing to parse multiple lines of hex data */
151 HEX_MULTILINE, /* parsing multiple lines of hex data */
152 UNKNOWN_DATA, /* parsing an unhandled or invalid data type */
153 SET_VALUE, /* adding a value to the registry */
154 NB_PARSER_STATES
155 };
156
157 struct parser
158 {
159 FILE *file; /* pointer to a registry file */
160 WCHAR two_wchars[2]; /* first two characters from the encoding check */
161 BOOL is_unicode; /* parsing Unicode or ASCII data */
162 short int reg_version; /* registry file version */
163 HKEY hkey; /* current registry key */
164 WCHAR *key_name; /* current key name */
165 WCHAR *value_name; /* value name */
166 DWORD parse_type; /* generic data type for parsing */
167 DWORD data_type; /* data type */
168 void *data; /* value data */
169 DWORD data_size; /* size of the data (in bytes) */
170 BOOL backslash; /* TRUE if the current line contains a backslash */
171 enum parser_state state; /* current parser state */
172 };
173
174 typedef WCHAR *(*parser_state_func)(struct parser *parser, WCHAR *pos);
175
176 /* parser state machine functions */
177 static WCHAR *header_state(struct parser *parser, WCHAR *pos);
178 static WCHAR *parse_win31_line_state(struct parser *parser, WCHAR *pos);
179 static WCHAR *line_start_state(struct parser *parser, WCHAR *pos);
180 static WCHAR *key_name_state(struct parser *parser, WCHAR *pos);
181 static WCHAR *delete_key_state(struct parser *parser, WCHAR *pos);
182 static WCHAR *default_value_name_state(struct parser *parser, WCHAR *pos);
183 static WCHAR *quoted_value_name_state(struct parser *parser, WCHAR *pos);
184 static WCHAR *data_start_state(struct parser *parser, WCHAR *pos);
185 static WCHAR *delete_value_state(struct parser *parser, WCHAR *pos);
186 static WCHAR *data_type_state(struct parser *parser, WCHAR *pos);
187 static WCHAR *string_data_state(struct parser *parser, WCHAR *pos);
188 static WCHAR *dword_data_state(struct parser *parser, WCHAR *pos);
189 static WCHAR *hex_data_state(struct parser *parser, WCHAR *pos);
190 static WCHAR *eol_backslash_state(struct parser *parser, WCHAR *pos);
191 static WCHAR *hex_multiline_state(struct parser *parser, WCHAR *pos);
192 static WCHAR *unknown_data_state(struct parser *parser, WCHAR *pos);
193 static WCHAR *set_value_state(struct parser *parser, WCHAR *pos);
194
195 static const parser_state_func parser_funcs[NB_PARSER_STATES] =
196 {
197 header_state, /* HEADER */
198 parse_win31_line_state, /* PARSE_WIN31_LINE */
199 line_start_state, /* LINE_START */
200 key_name_state, /* KEY_NAME */
201 delete_key_state, /* DELETE_KEY */
202 default_value_name_state, /* DEFAULT_VALUE_NAME */
203 quoted_value_name_state, /* QUOTED_VALUE_NAME */
204 data_start_state, /* DATA_START */
205 delete_value_state, /* DELETE_VALUE */
206 data_type_state, /* DATA_TYPE */
207 string_data_state, /* STRING_DATA */
208 dword_data_state, /* DWORD_DATA */
209 hex_data_state, /* HEX_DATA */
210 eol_backslash_state, /* EOL_BACKSLASH */
211 hex_multiline_state, /* HEX_MULTILINE */
212 unknown_data_state, /* UNKNOWN_DATA */
213 set_value_state, /* SET_VALUE */
214 };
215
216 /* set the new parser state and return the previous one */
217 static inline enum parser_state set_state(struct parser *parser, enum parser_state state)
218 {
219 enum parser_state ret = parser->state;
220 parser->state = state;
221 return ret;
222 }
223
224 static void *resize_buffer(void *buf, size_t count)
225 {
226 void *new_buf;
227
228 if (buf)
229 new_buf = HeapReAlloc(GetProcessHeap(), 0, buf, count);
230 else
231 new_buf = HeapAlloc(GetProcessHeap(), 0, count);
232
233 CHECK_ENOUGH_MEMORY(new_buf);
234 return new_buf;
235 }
236
237 /******************************************************************************
238 * Converts a hex representation of a DWORD into a DWORD.
239 */
240 static BOOL convert_hex_to_dword(WCHAR *str, DWORD *dw)
241 {
242 WCHAR *p, *end;
243 int count = 0;
244
245 while (*str == ' ' || *str == '\t') str++;
246 if (!*str) goto error;
247
248 p = str;
249 while (isxdigitW(*p))
250 {
251 count++;
252 p++;
253 }
254 if (count > 8) goto error;
255
256 end = p;
257 while (*p == ' ' || *p == '\t') p++;
258 if (*p && *p != ';') goto error;
259
260 *end = 0;
261 *dw = strtoulW(str, &end, 16);
262 return TRUE;
263
264 error:
265 return FALSE;
266 }
267
268 /******************************************************************************
269 * Converts comma-separated hex data into a binary string and modifies
270 * the input parameter to skip the concatenating backslash, if found.
271 *
272 * Returns TRUE or FALSE to indicate whether parsing was successful.
273 */
274 static BOOL convert_hex_csv_to_hex(struct parser *parser, WCHAR **str)
275 {
276 size_t size;
277 BYTE *d;
278 WCHAR *s;
279
280 parser->backslash = FALSE;
281
282 /* The worst case is 1 digit + 1 comma per byte */
283 size = ((lstrlenW(*str) + 1) / 2) + parser->data_size;
284 parser->data = resize_buffer(parser->data, size);
285
286 s = *str;
287 d = (BYTE *)parser->data + parser->data_size;
288
289 while (*s)
290 {
291 WCHAR *end;
292 unsigned long wc;
293
294 wc = strtoulW(s, &end, 16);
295 if (wc > 0xff) return FALSE;
296
297 if (s == end && wc == 0)
298 {
299 while (*end == ' ' || *end == '\t') end++;
300 if (*end == '\\')
301 {
302 parser->backslash = TRUE;
303 *str = end + 1;
304 return TRUE;
305 }
306 return FALSE;
307 }
308
309 *d++ = wc;
310 parser->data_size++;
311
312 if (*end && *end != ',')
313 {
314 while (*end == ' ' || *end == '\t') end++;
315 if (*end && *end != ';') return FALSE;
316 return TRUE;
317 }
318
319 if (*end) end++;
320 s = end;
321 }
322
323 return TRUE;
324 }
325
326 /******************************************************************************
327 * Parses the data type of the registry value being imported and modifies
328 * the input parameter to skip the string representation of the data type.
329 *
330 * Returns TRUE or FALSE to indicate whether a data type was found.
331 */
332 static BOOL parse_data_type(struct parser *parser, WCHAR **line)
333 {
334 struct data_type { const WCHAR *tag; int len; int type; int parse_type; };
335
336 static const WCHAR quote[] = {'"'};
337 static const WCHAR hex[] = {'h','e','x',':'};
338 static const WCHAR dword[] = {'d','w','o','r','d',':'};
339 static const WCHAR hexp[] = {'h','e','x','('};
340
341 static const struct data_type data_types[] = {
342 /* tag len type parse type */
343 { quote, 1, REG_SZ, REG_SZ },
344 { hex, 4, REG_BINARY, REG_BINARY },
345 { dword, 6, REG_DWORD, REG_DWORD },
346 { hexp, 4, -1, REG_BINARY }, /* REG_NONE, REG_EXPAND_SZ, REG_MULTI_SZ */
347 { NULL, 0, 0, 0 }
348 };
349
350 const struct data_type *ptr;
351
352 for (ptr = data_types; ptr->tag; ptr++)
353 {
354 if (strncmpW(ptr->tag, *line, ptr->len))
355 continue;
356
357 parser->parse_type = ptr->parse_type;
358 parser->data_type = ptr->parse_type;
359 *line += ptr->len;
360
361 if (ptr->type == -1)
362 {
363 WCHAR *end;
364 DWORD val;
365
366 /* "hex(xx):" is special */
367 val = wcstoul(*line, &end, 16);
368 if (!**line || *end != ')' || *(end + 1) != ':' || (val == ~0u && errno == ERANGE))
369 return FALSE;
370
371 parser->data_type = val;
372 *line = end + 2;
373 }
374 return TRUE;
375 }
376 return FALSE;
377 }
378
379 /******************************************************************************
380 * Replaces escape sequences with their character equivalents and
381 * null-terminates the string on the first non-escaped double quote.
382 *
383 * Assigns a pointer to the remaining unparsed data in the line.
384 * Returns TRUE or FALSE to indicate whether a closing double quote was found.
385 */
386 static BOOL REGPROC_unescape_string(WCHAR *str, WCHAR **unparsed)
387 {
388 int str_idx = 0; /* current character under analysis */
389 int val_idx = 0; /* the last character of the unescaped string */
390 int len = lstrlenW(str);
391 BOOL ret;
392
393 for (str_idx = 0; str_idx < len; str_idx++, val_idx++) {
394 if (str[str_idx] == '\\') {
395 str_idx++;
396 switch (str[str_idx]) {
397 case 'n':
398 str[val_idx] = '\n';
399 break;
400 case 'r':
401 str[val_idx] = '\r';
402 break;
403 case '0':
404 str[val_idx] = '\0';
405 break;
406 case '\\':
407 case '"':
408 str[val_idx] = str[str_idx];
409 break;
410 default:
411 output_message(STRING_ESCAPE_SEQUENCE, str[str_idx]);
412 str[val_idx] = str[str_idx];
413 break;
414 }
415 } else if (str[str_idx] == '"') {
416 break;
417 } else {
418 str[val_idx] = str[str_idx];
419 }
420 }
421
422 ret = (str[str_idx] == '"');
423 *unparsed = str + str_idx + 1;
424 str[val_idx] = '\0';
425 return ret;
426 }
427
428 static HKEY parse_key_name(WCHAR *key_name, WCHAR **key_path)
429 {
430 unsigned int i;
431
432 if (!key_name) return 0;
433
434 *key_path = strchrW(key_name, '\\');
435 if (*key_path) (*key_path)++;
436
437 for (i = 0; i < ARRAY_SIZE(reg_class_keys); i++)
438 {
439 int len = lstrlenW(reg_class_namesW[i]);
440 if (!strncmpiW(key_name, reg_class_namesW[i], len) &&
441 (key_name[len] == 0 || key_name[len] == '\\'))
442 {
443 return reg_class_keys[i];
444 }
445 }
446
447 return 0;
448 }
449
450 static void close_key(struct parser *parser)
451 {
452 if (parser->hkey)
453 {
454 HeapFree(GetProcessHeap(), 0, parser->key_name);
455 parser->key_name = NULL;
456
457 RegCloseKey(parser->hkey);
458 parser->hkey = NULL;
459 }
460 }
461
462 /******************************************************************************
463 * Opens the registry key given by the input path.
464 * This key must be closed by calling close_key().
465 */
466 static LONG open_key(struct parser *parser, WCHAR *path)
467 {
468 HKEY key_class;
469 WCHAR *key_path;
470 LONG res;
471
472 close_key(parser);
473
474 /* Get the registry class */
475 if (!path || !(key_class = parse_key_name(path, &key_path)))
476 return ERROR_INVALID_PARAMETER;
477
478 res = RegCreateKeyExW(key_class, key_path, 0, NULL, REG_OPTION_NON_VOLATILE,
479 KEY_ALL_ACCESS, NULL, &parser->hkey, NULL);
480
481 if (res == ERROR_SUCCESS)
482 {
483 parser->key_name = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(path) + 1) * sizeof(WCHAR));
484 CHECK_ENOUGH_MEMORY(parser->key_name);
485 lstrcpyW(parser->key_name, path);
486 }
487 else
488 parser->hkey = NULL;
489
490 return res;
491 }
492
493 enum reg_versions {
494 REG_VERSION_31,
495 REG_VERSION_40,
496 REG_VERSION_50,
497 REG_VERSION_FUZZY,
498 REG_VERSION_INVALID
499 };
500
501 static enum reg_versions parse_file_header(const WCHAR *s)
502 {
503 static const WCHAR header_31[] = {'R','E','G','E','D','I','T',0};
504 static const WCHAR header_40[] = {'R','E','G','E','D','I','T','4',0};
505 static const WCHAR header_50[] = {'W','i','n','d','o','w','s',' ',
506 'R','e','g','i','s','t','r','y',' ','E','d','i','t','o','r',' ',
507 'V','e','r','s','i','o','n',' ','5','.','0','0',0};
508
509 while (*s && (*s == ' ' || *s == '\t')) s++;
510
511 if (!strcmpW(s, header_31))
512 return REG_VERSION_31;
513
514 if (!strcmpW(s, header_40))
515 return REG_VERSION_40;
516
517 if (!strcmpW(s, header_50))
518 return REG_VERSION_50;
519
520 /* The Windows version accepts registry file headers beginning with "REGEDIT" and ending
521 * with other characters, as long as "REGEDIT" appears at the start of the line. For example,
522 * "REGEDIT 4", "REGEDIT9" and "REGEDIT4FOO" are all treated as valid file headers.
523 * In all such cases, however, the contents of the registry file are not imported.
524 */
525 if (!strncmpW(s, header_31, 7)) /* "REGEDIT" without NUL */
526 return REG_VERSION_FUZZY;
527
528 return REG_VERSION_INVALID;
529 }
530
531 /* handler for parser HEADER state */
532 static WCHAR *header_state(struct parser *parser, WCHAR *pos)
533 {
534 WCHAR *line, *header;
535
536 if (!(line = get_line(parser->file)))
537 return NULL;
538
539 if (!parser->is_unicode)
540 {
541 header = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(line) + 3) * sizeof(WCHAR));
542 CHECK_ENOUGH_MEMORY(header);
543 header[0] = parser->two_wchars[0];
544 header[1] = parser->two_wchars[1];
545 lstrcpyW(header + 2, line);
546 parser->reg_version = parse_file_header(header);
547 HeapFree(GetProcessHeap(), 0, header);
548 }
549 else parser->reg_version = parse_file_header(line);
550
551 switch (parser->reg_version)
552 {
553 case REG_VERSION_31:
554 set_state(parser, PARSE_WIN31_LINE);
555 break;
556 case REG_VERSION_40:
557 case REG_VERSION_50:
558 set_state(parser, LINE_START);
559 break;
560 default:
561 get_line(NULL); /* Reset static variables */
562 return NULL;
563 }
564
565 return line;
566 }
567
568 /* handler for parser PARSE_WIN31_LINE state */
569 static WCHAR *parse_win31_line_state(struct parser *parser, WCHAR *pos)
570 {
571 WCHAR *line, *value;
572 static WCHAR hkcr[] = {'H','K','E','Y','_','C','L','A','S','S','E','S','_','R','O','O','T'};
573 unsigned int key_end = 0;
574
575 if (!(line = get_line(parser->file)))
576 return NULL;
577
578 if (strncmpW(line, hkcr, ARRAY_SIZE(hkcr)))
579 return line;
580
581 /* get key name */
582 while (line[key_end] && !isspaceW(line[key_end])) key_end++;
583
584 value = line + key_end;
585 while (*value == ' ' || *value == '\t') value++;
586
587 if (*value == '=') value++;
588 if (*value == ' ') value++; /* at most one space is skipped */
589
590 line[key_end] = 0;
591
592 if (open_key(parser, line) != ERROR_SUCCESS)
593 {
594 output_message(STRING_OPEN_KEY_FAILED, line);
595 return line;
596 }
597
598 parser->value_name = NULL;
599 parser->data_type = REG_SZ;
600 parser->data = value;
601 parser->data_size = (lstrlenW(value) + 1) * sizeof(WCHAR);
602
603 set_state(parser, SET_VALUE);
604 return value;
605 }
606
607 /* handler for parser LINE_START state */
608 static WCHAR *line_start_state(struct parser *parser, WCHAR *pos)
609 {
610 WCHAR *line, *p;
611
612 if (!(line = get_line(parser->file)))
613 return NULL;
614
615 for (p = line; *p; p++)
616 {
617 switch (*p)
618 {
619 case '[':
620 set_state(parser, KEY_NAME);
621 return p + 1;
622 case '@':
623 set_state(parser, DEFAULT_VALUE_NAME);
624 return p;
625 case '"':
626 set_state(parser, QUOTED_VALUE_NAME);
627 return p + 1;
628 case ' ':
629 case '\t':
630 break;
631 default:
632 return p;
633 }
634 }
635
636 return p;
637 }
638
639 /* handler for parser KEY_NAME state */
640 static WCHAR *key_name_state(struct parser *parser, WCHAR *pos)
641 {
642 WCHAR *p = pos, *key_end;
643
644 if (*p == ' ' || *p == '\t' || !(key_end = strrchrW(p, ']')))
645 goto done;
646
647 *key_end = 0;
648
649 if (*p == '-')
650 {
651 set_state(parser, DELETE_KEY);
652 return p + 1;
653 }
654 else if (open_key(parser, p) != ERROR_SUCCESS)
655 output_message(STRING_OPEN_KEY_FAILED, p);
656
657 done:
658 set_state(parser, LINE_START);
659 return p;
660 }
661
662 /* handler for parser DELETE_KEY state */
663 static WCHAR *delete_key_state(struct parser *parser, WCHAR *pos)
664 {
665 WCHAR *p = pos;
666
667 if (*p == 'H' || *p == 'h')
668 delete_registry_key(p);
669
670 set_state(parser, LINE_START);
671 return p;
672 }
673
674 /* handler for parser DEFAULT_VALUE_NAME state */
675 static WCHAR *default_value_name_state(struct parser *parser, WCHAR *pos)
676 {
677 parser->value_name = NULL;
678
679 set_state(parser, DATA_START);
680 return pos + 1;
681 }
682
683 /* handler for parser QUOTED_VALUE_NAME state */
684 static WCHAR *quoted_value_name_state(struct parser *parser, WCHAR *pos)
685 {
686 WCHAR *val_name = pos, *p;
687
688 if (parser->value_name)
689 {
690 HeapFree(GetProcessHeap(), 0, parser->value_name);
691 parser->value_name = NULL;
692 }
693
694 if (!REGPROC_unescape_string(val_name, &p))
695 goto invalid;
696
697 /* copy the value name in case we need to parse multiple lines and the buffer is overwritten */
698 parser->value_name = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(val_name) + 1) * sizeof(WCHAR));
699 CHECK_ENOUGH_MEMORY(parser->value_name);
700 lstrcpyW(parser->value_name, val_name);
701
702 set_state(parser, DATA_START);
703 return p;
704
705 invalid:
706 set_state(parser, LINE_START);
707 return p;
708 }
709
710 /* handler for parser DATA_START state */
711 static WCHAR *data_start_state(struct parser *parser, WCHAR *pos)
712 {
713 WCHAR *p = pos;
714 unsigned int len;
715
716 while (*p == ' ' || *p == '\t') p++;
717 if (*p != '=') goto done;
718 p++;
719 while (*p == ' ' || *p == '\t') p++;
720
721 /* trim trailing whitespace */
722 len = strlenW(p);
723 while (len > 0 && (p[len - 1] == ' ' || p[len - 1] == '\t')) len--;
724 p[len] = 0;
725
726 if (*p == '-')
727 set_state(parser, DELETE_VALUE);
728 else
729 set_state(parser, DATA_TYPE);
730 return p;
731
732 done:
733 set_state(parser, LINE_START);
734 return p;
735 }
736
737 /* handler for parser DELETE_VALUE state */
738 static WCHAR *delete_value_state(struct parser *parser, WCHAR *pos)
739 {
740 WCHAR *p = pos + 1;
741
742 while (*p == ' ' || *p == '\t') p++;
743 if (*p && *p != ';') goto done;
744
745 RegDeleteValueW(parser->hkey, parser->value_name);
746
747 done:
748 set_state(parser, LINE_START);
749 return p;
750 }
751
752 /* handler for parser DATA_TYPE state */
753 static WCHAR *data_type_state(struct parser *parser, WCHAR *pos)
754 {
755 WCHAR *line = pos;
756
757 if (!parse_data_type(parser, &line))
758 {
759 set_state(parser, LINE_START);
760 return line;
761 }
762
763 switch (parser->parse_type)
764 {
765 case REG_SZ:
766 set_state(parser, STRING_DATA);
767 break;
768 case REG_DWORD:
769 set_state(parser, DWORD_DATA);
770 break;
771 case REG_BINARY: /* all hex data types, including undefined */
772 set_state(parser, HEX_DATA);
773 break;
774 default:
775 set_state(parser, UNKNOWN_DATA);
776 }
777
778 return line;
779 }
780
781 /* handler for parser STRING_DATA state */
782 static WCHAR *string_data_state(struct parser *parser, WCHAR *pos)
783 {
784 WCHAR *line;
785
786 parser->data = pos;
787
788 if (!REGPROC_unescape_string(parser->data, &line))
789 goto invalid;
790
791 while (*line == ' ' || *line == '\t') line++;
792 if (*line && *line != ';') goto invalid;
793
794 parser->data_size = (lstrlenW(parser->data) + 1) * sizeof(WCHAR);
795
796 set_state(parser, SET_VALUE);
797 return line;
798
799 invalid:
800 parser->data = NULL;
801 parser->data_size = 0;
802
803 set_state(parser, LINE_START);
804 return line;
805 }
806
807 /* handler for parser DWORD_DATA state */
808 static WCHAR *dword_data_state(struct parser *parser, WCHAR *pos)
809 {
810 WCHAR *line = pos;
811
812 parser->data = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD));
813 CHECK_ENOUGH_MEMORY(parser->data);
814
815 if (!convert_hex_to_dword(line, parser->data))
816 goto invalid;
817
818 parser->data_size = sizeof(DWORD);
819
820 set_state(parser, SET_VALUE);
821 return line;
822
823 invalid:
824 HeapFree(GetProcessHeap(), 0, parser->data);
825 parser->data = NULL;
826 parser->data_size = 0;
827
828 set_state(parser, LINE_START);
829 return line;
830 }
831
832 /* handler for parser HEX_DATA state */
833 static WCHAR *hex_data_state(struct parser *parser, WCHAR *pos)
834 {
835 WCHAR *line = pos;
836
837 if (!convert_hex_csv_to_hex(parser, &line))
838 goto invalid;
839
840 if (parser->backslash)
841 {
842 set_state(parser, EOL_BACKSLASH);
843 return line;
844 }
845
846 if (!parser->is_unicode && (parser->data_type == REG_EXPAND_SZ || parser->data_type == REG_MULTI_SZ))
847 {
848 void *tmp = parser->data;
849
850 parser->data = GetWideStringN(parser->data, parser->data_size, &parser->data_size);
851 parser->data_size *= sizeof(WCHAR);
852 HeapFree(GetProcessHeap(), 0, tmp);
853 }
854
855 set_state(parser, SET_VALUE);
856 return line;
857
858 invalid:
859 HeapFree(GetProcessHeap(), 0, parser->data);
860 parser->data = NULL;
861 parser->data_size = 0;
862
863 set_state(parser, LINE_START);
864 return line;
865 }
866
867 /* handler for parser EOL_BACKSLASH state */
868 static WCHAR *eol_backslash_state(struct parser *parser, WCHAR *pos)
869 {
870 WCHAR *p = pos;
871
872 while (*p == ' ' || *p == '\t') p++;
873 if (*p && *p != ';') goto invalid;
874
875 set_state(parser, HEX_MULTILINE);
876 return pos;
877
878 invalid:
879 HeapFree(GetProcessHeap(), 0, parser->data);
880 parser->data = NULL;
881 parser->data_size = 0;
882
883 set_state(parser, LINE_START);
884 return p;
885 }
886
887 /* handler for parser HEX_MULTILINE state */
888 static WCHAR *hex_multiline_state(struct parser *parser, WCHAR *pos)
889 {
890 WCHAR *line;
891
892 if (!(line = get_line(parser->file)))
893 {
894 set_state(parser, SET_VALUE);
895 return pos;
896 }
897
898 while (*line == ' ' || *line == '\t') line++;
899 if (*line == ';') return line;
900
901 set_state(parser, HEX_DATA);
902 return line;
903 }
904
905 /* handler for parser UNKNOWN_DATA state */
906 static WCHAR *unknown_data_state(struct parser *parser, WCHAR *pos)
907 {
908 output_message(STRING_UNKNOWN_DATA_FORMAT, parser->data_type);
909
910 set_state(parser, LINE_START);
911 return pos;
912 }
913
914 /* handler for parser SET_VALUE state */
915 static WCHAR *set_value_state(struct parser *parser, WCHAR *pos)
916 {
917 RegSetValueExW(parser->hkey, parser->value_name, 0, parser->data_type,
918 parser->data, parser->data_size);
919
920 if (parser->parse_type == REG_DWORD || parser->parse_type == REG_BINARY)
921 HeapFree(GetProcessHeap(), 0, parser->data);
922
923 parser->data = NULL;
924 parser->data_size = 0;
925
926 if (parser->reg_version == REG_VERSION_31)
927 set_state(parser, PARSE_WIN31_LINE);
928 else
929 set_state(parser, LINE_START);
930
931 return pos;
932 }
933
934 static WCHAR *get_lineA(FILE *fp)
935 {
936 static WCHAR *lineW;
937 static size_t size;
938 static char *buf, *next;
939 char *line;
940
941 HeapFree(GetProcessHeap(), 0, lineW);
942
943 if (!fp) goto cleanup;
944
945 if (!size)
946 {
947 size = REG_VAL_BUF_SIZE;
948 buf = HeapAlloc(GetProcessHeap(), 0, size);
949 CHECK_ENOUGH_MEMORY(buf);
950 *buf = 0;
951 next = buf;
952 }
953 line = next;
954
955 while (next)
956 {
957 char *p = strpbrk(line, "\r\n");
958 if (!p)
959 {
960 size_t len, count;
961 len = strlen(next);
962 memmove(buf, next, len + 1);
963 if (size - len < 3)
964 {
965 char *new_buf = HeapReAlloc(GetProcessHeap(), 0, buf, size * 2);
966 CHECK_ENOUGH_MEMORY(new_buf);
967 buf = new_buf;
968 size *= 2;
969 }
970 if (!(count = fread(buf + len, 1, size - len - 1, fp)))
971 {
972 next = NULL;
973 lineW = GetWideString(buf);
974 return lineW;
975 }
976 buf[len + count] = 0;
977 next = buf;
978 line = buf;
979 continue;
980 }
981 next = p + 1;
982 if (*p == '\r' && *(p + 1) == '\n') next++;
983 *p = 0;
984 if (*line == ';' || *line == '#')
985 {
986 line = next;
987 continue;
988 }
989 lineW = GetWideString(line);
990 return lineW;
991 }
992
993 cleanup:
994 lineW = NULL;
995 if (size) HeapFree(GetProcessHeap(), 0, buf);
996 size = 0;
997 return NULL;
998 }
999
1000 static WCHAR *get_lineW(FILE *fp)
1001 {
1002 static size_t size;
1003 static WCHAR *buf, *next;
1004 WCHAR *line;
1005
1006 if (!fp) goto cleanup;
1007
1008 if (!size)
1009 {
1010 size = REG_VAL_BUF_SIZE;
1011 buf = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
1012 CHECK_ENOUGH_MEMORY(buf);
1013 *buf = 0;
1014 next = buf;
1015 }
1016 line = next;
1017
1018 while (next)
1019 {
1020 static const WCHAR line_endings[] = {'\r','\n',0};
1021 WCHAR *p = strpbrkW(line, line_endings);
1022 if (!p)
1023 {
1024 size_t len, count;
1025 len = strlenW(next);
1026 memmove(buf, next, (len + 1) * sizeof(WCHAR));
1027 if (size - len < 3)
1028 {
1029 WCHAR *new_buf = HeapReAlloc(GetProcessHeap(), 0, buf, (size * 2) * sizeof(WCHAR));
1030 CHECK_ENOUGH_MEMORY(new_buf);
1031 buf = new_buf;
1032 size *= 2;
1033 }
1034 if (!(count = fread(buf + len, sizeof(WCHAR), size - len - 1, fp)))
1035 {
1036 next = NULL;
1037 return buf;
1038 }
1039 buf[len + count] = 0;
1040 next = buf;
1041 line = buf;
1042 continue;
1043 }
1044 next = p + 1;
1045 if (*p == '\r' && *(p + 1) == '\n') next++;
1046 *p = 0;
1047 if (*line == ';' || *line == '#')
1048 {
1049 line = next;
1050 continue;
1051 }
1052 return line;
1053 }
1054
1055 cleanup:
1056 if (size) HeapFree(GetProcessHeap(), 0, buf);
1057 size = 0;
1058 return NULL;
1059 }
1060
1061 /******************************************************************************
1062 * Checks whether the buffer has enough room for the string or required size.
1063 * Resizes the buffer if necessary.
1064 *
1065 * Parameters:
1066 * buffer - pointer to a buffer for string
1067 * len - current length of the buffer in characters.
1068 * required_len - length of the string to place to the buffer in characters.
1069 * The length does not include the terminating null character.
1070 */
1071 static void REGPROC_resize_char_buffer(WCHAR **buffer, DWORD *len, DWORD required_len)
1072 {
1073 required_len++;
1074 if (required_len > *len) {
1075 *len = required_len;
1076 if (!*buffer)
1077 *buffer = HeapAlloc(GetProcessHeap(), 0, *len * sizeof(**buffer));
1078 else
1079 *buffer = HeapReAlloc(GetProcessHeap(), 0, *buffer, *len * sizeof(**buffer));
1080 CHECK_ENOUGH_MEMORY(*buffer);
1081 }
1082 }
1083
1084 /******************************************************************************
1085 * Same as REGPROC_resize_char_buffer() but on a regular buffer.
1086 *
1087 * Parameters:
1088 * buffer - pointer to a buffer
1089 * len - current size of the buffer in bytes
1090 * required_size - size of the data to place in the buffer in bytes
1091 */
1092 static void REGPROC_resize_binary_buffer(BYTE **buffer, DWORD *size, DWORD required_size)
1093 {
1094 if (required_size > *size) {
1095 *size = required_size;
1096 if (!*buffer)
1097 *buffer = HeapAlloc(GetProcessHeap(), 0, *size);
1098 else
1099 *buffer = HeapReAlloc(GetProcessHeap(), 0, *buffer, *size);
1100 CHECK_ENOUGH_MEMORY(*buffer);
1101 }
1102 }
1103
1104 /******************************************************************************
1105 * Prints string str to file
1106 */
1107 static void REGPROC_export_string(WCHAR **line_buf, DWORD *line_buf_size, DWORD *line_len, WCHAR *str, DWORD str_len)
1108 {
1109 DWORD i, pos;
1110 DWORD extra = 0;
1111
1112 REGPROC_resize_char_buffer(line_buf, line_buf_size, *line_len + str_len + 10);
1113
1114 /* escaping characters */
1115 pos = *line_len;
1116 for (i = 0; i < str_len; i++) {
1117 WCHAR c = str[i];
1118 switch (c) {
1119 case '\n':
1120 extra++;
1121 REGPROC_resize_char_buffer(line_buf, line_buf_size, *line_len + str_len + extra);
1122 (*line_buf)[pos++] = '\\';
1123 (*line_buf)[pos++] = 'n';
1124 break;
1125
1126 case '\r':
1127 extra++;
1128 REGPROC_resize_char_buffer(line_buf, line_buf_size, *line_len + str_len + extra);
1129 (*line_buf)[pos++] = '\\';
1130 (*line_buf)[pos++] = 'r';
1131 break;
1132
1133 case '\\':
1134 case '"':
1135 extra++;
1136 REGPROC_resize_char_buffer(line_buf, line_buf_size, *line_len + str_len + extra);
1137 (*line_buf)[pos++] = '\\';
1138 /* Fall through */
1139
1140 default:
1141 (*line_buf)[pos++] = c;
1142 break;
1143 }
1144 }
1145 (*line_buf)[pos] = '\0';
1146 *line_len = pos;
1147 }
1148
1149 static void REGPROC_export_binary(WCHAR **line_buf, DWORD *line_buf_size, DWORD *line_len, DWORD type, BYTE *value, DWORD value_size, BOOL unicode)
1150 {
1151 DWORD hex_pos, data_pos;
1152 const WCHAR *hex_prefix;
1153 const WCHAR hex[] = {'h','e','x',':',0};
1154 WCHAR hex_buf[17];
1155 const WCHAR concat[] = {'\\','\r','\n',' ',' ',0};
1156 DWORD concat_prefix, concat_len;
1157 const WCHAR newline[] = {'\r','\n',0};
1158 CHAR* value_multibyte = NULL;
1159
1160 if (type == REG_BINARY) {
1161 hex_prefix = hex;
1162 } else {
1163 const WCHAR hex_format[] = {'h','e','x','(','%','x',')',':',0};
1164 hex_prefix = hex_buf;
1165 sprintfW(hex_buf, hex_format, type);
1166 if ((type == REG_SZ || type == REG_EXPAND_SZ || type == REG_MULTI_SZ) && !unicode)
1167 {
1168 value_multibyte = GetMultiByteStringN((WCHAR*)value, value_size / sizeof(WCHAR), &value_size);
1169 value = (BYTE*)value_multibyte;
1170 }
1171 }
1172
1173 concat_len = lstrlenW(concat);
1174 concat_prefix = 2;
1175
1176 hex_pos = *line_len;
1177 *line_len += lstrlenW(hex_prefix);
1178 data_pos = *line_len;
1179 *line_len += value_size * 3;
1180 /* - The 2 spaces that concat places at the start of the
1181 * line effectively reduce the space available for data.
1182 * - If the value name and hex prefix are very long
1183 * ( > REG_FILE_HEX_LINE_LEN) or *line_len divides
1184 * without a remainder then we may overestimate
1185 * the needed number of lines by one. But that's ok.
1186 * - The trailing '\r' takes the place of a comma so
1187 * we only need to add 1 for the trailing '\n'
1188 */
1189 *line_len += *line_len / (REG_FILE_HEX_LINE_LEN - concat_prefix) * concat_len + 1;
1190 REGPROC_resize_char_buffer(line_buf, line_buf_size, *line_len);
1191 lstrcpyW(*line_buf + hex_pos, hex_prefix);
1192 if (value_size)
1193 {
1194 const WCHAR format[] = {'%','0','2','x',0};
1195 DWORD i, column;
1196
1197 column = data_pos; /* no line wrap yet */
1198 i = 0;
1199 while (1)
1200 {
1201 sprintfW(*line_buf + data_pos, format, (unsigned int)value[i]);
1202 data_pos += 2;
1203 if (++i == value_size)
1204 break;
1205
1206 (*line_buf)[data_pos++] = ',';
1207 column += 3;
1208
1209 /* wrap the line */
1210 if (column >= REG_FILE_HEX_LINE_LEN) {
1211 lstrcpyW(*line_buf + data_pos, concat);
1212 data_pos += concat_len;
1213 column = concat_prefix;
1214 }
1215 }
1216 }
1217 lstrcpyW(*line_buf + data_pos, newline);
1218 HeapFree(GetProcessHeap(), 0, value_multibyte);
1219 }
1220
1221 /******************************************************************************
1222 * Writes the given line to a file, in multi-byte or wide characters
1223 */
1224 static void REGPROC_write_line(FILE *file, const WCHAR* str, BOOL unicode)
1225 {
1226 if(unicode)
1227 {
1228 fwrite(str, sizeof(WCHAR), lstrlenW(str), file);
1229 } else
1230 {
1231 char* strA = GetMultiByteString(str);
1232 fputs(strA, file);
1233 HeapFree(GetProcessHeap(), 0, strA);
1234 }
1235 }
1236
1237 /******************************************************************************
1238 * Writes contents of the registry key to the specified file stream.
1239 *
1240 * Parameters:
1241 * file - writable file stream to export registry branch to.
1242 * key - registry branch to export.
1243 * reg_key_name_buf - name of the key with registry class.
1244 * Is resized if necessary.
1245 * reg_key_name_size - length of the buffer for the registry class in characters.
1246 * val_name_buf - buffer for storing value name.
1247 * Is resized if necessary.
1248 * val_name_size - length of the buffer for storing value names in characters.
1249 * val_buf - buffer for storing values while extracting.
1250 * Is resized if necessary.
1251 * val_size - size of the buffer for storing values in bytes.
1252 */
1253 static void export_hkey(FILE *file, HKEY key,
1254 WCHAR **reg_key_name_buf, DWORD *reg_key_name_size,
1255 WCHAR **val_name_buf, DWORD *val_name_size,
1256 BYTE **val_buf, DWORD *val_size,
1257 WCHAR **line_buf, DWORD *line_buf_size,
1258 BOOL unicode)
1259 {
1260 DWORD max_sub_key_len;
1261 DWORD max_val_name_len;
1262 DWORD max_val_size;
1263 DWORD curr_len;
1264 DWORD i;
1265 LONG ret;
1266 WCHAR key_format[] = {'\r','\n','[','%','s',']','\r','\n',0};
1267
1268 /* get size information and resize the buffers if necessary */
1269 if (RegQueryInfoKeyW(key, NULL, NULL, NULL, NULL,
1270 &max_sub_key_len, NULL,
1271 NULL, &max_val_name_len, &max_val_size, NULL, NULL
1272 ) != ERROR_SUCCESS)
1273 return;
1274 curr_len = strlenW(*reg_key_name_buf);
1275 REGPROC_resize_char_buffer(reg_key_name_buf, reg_key_name_size,
1276 max_sub_key_len + curr_len + 1);
1277 REGPROC_resize_char_buffer(val_name_buf, val_name_size,
1278 max_val_name_len);
1279 REGPROC_resize_binary_buffer(val_buf, val_size, max_val_size);
1280 REGPROC_resize_char_buffer(line_buf, line_buf_size, lstrlenW(*reg_key_name_buf) + 4);
1281 /* output data for the current key */
1282 sprintfW(*line_buf, key_format, *reg_key_name_buf);
1283 REGPROC_write_line(file, *line_buf, unicode);
1284
1285 /* print all the values */
1286 i = 0;
1287 for (;;) {
1288 DWORD value_type;
1289 DWORD val_name_size1 = *val_name_size;
1290 DWORD val_size1 = *val_size;
1291 ret = RegEnumValueW(key, i, *val_name_buf, &val_name_size1, NULL,
1292 &value_type, *val_buf, &val_size1);
1293 if (ret == ERROR_MORE_DATA) {
1294 /* Increase the size of the buffers and retry */
1295 REGPROC_resize_char_buffer(val_name_buf, val_name_size, val_name_size1);
1296 REGPROC_resize_binary_buffer(val_buf, val_size, val_size1);
1297 } else if (ret == ERROR_SUCCESS) {
1298 DWORD line_len;
1299 i++;
1300
1301 if ((*val_name_buf)[0]) {
1302 const WCHAR val_start[] = {'"','%','s','"','=',0};
1303
1304 line_len = 0;
1305 REGPROC_export_string(line_buf, line_buf_size, &line_len, *val_name_buf, lstrlenW(*val_name_buf));
1306 REGPROC_resize_char_buffer(val_name_buf, val_name_size, lstrlenW(*line_buf) + 1);
1307 lstrcpyW(*val_name_buf, *line_buf);
1308
1309 line_len = 3 + lstrlenW(*val_name_buf);
1310 REGPROC_resize_char_buffer(line_buf, line_buf_size, line_len);
1311 sprintfW(*line_buf, val_start, *val_name_buf);
1312 } else {
1313 const WCHAR std_val[] = {'@','=',0};
1314 line_len = 2;
1315 REGPROC_resize_char_buffer(line_buf, line_buf_size, line_len);
1316 lstrcpyW(*line_buf, std_val);
1317 }
1318
1319 switch (value_type) {
1320 case REG_SZ:
1321 {
1322 WCHAR* wstr = (WCHAR*)*val_buf;
1323
1324 if (val_size1 < sizeof(WCHAR) || val_size1 % sizeof(WCHAR) ||
1325 wstr[val_size1 / sizeof(WCHAR) - 1]) {
1326 REGPROC_export_binary(line_buf, line_buf_size, &line_len, value_type, *val_buf, val_size1, unicode);
1327 } else {
1328 const WCHAR start[] = {'"',0};
1329 const WCHAR end[] = {'"','\r','\n',0};
1330 DWORD len;
1331
1332 len = lstrlenW(start);
1333 REGPROC_resize_char_buffer(line_buf, line_buf_size, line_len + len);
1334 lstrcpyW(*line_buf + line_len, start);
1335 line_len += len;
1336
1337 REGPROC_export_string(line_buf, line_buf_size, &line_len, wstr, lstrlenW(wstr));
1338
1339 REGPROC_resize_char_buffer(line_buf, line_buf_size, line_len + lstrlenW(end));
1340 lstrcpyW(*line_buf + line_len, end);
1341 }
1342 break;
1343 }
1344
1345 case REG_DWORD:
1346 {
1347 WCHAR format[] = {'d','w','o','r','d',':','%','0','8','x','\r','\n',0};
1348
1349 REGPROC_resize_char_buffer(line_buf, line_buf_size, line_len + 15);
1350 sprintfW(*line_buf + line_len, format, *((DWORD *)*val_buf));
1351 break;
1352 }
1353
1354 case REG_NONE:
1355 case REG_EXPAND_SZ:
1356 case REG_MULTI_SZ:
1357 case REG_BINARY:
1358 default:
1359 REGPROC_export_binary(line_buf, line_buf_size, &line_len, value_type, *val_buf, val_size1, unicode);
1360 }
1361 REGPROC_write_line(file, *line_buf, unicode);
1362 }
1363 else break;
1364 }
1365
1366 i = 0;
1367 (*reg_key_name_buf)[curr_len] = '\\';
1368 for (;;) {
1369 DWORD buf_size = *reg_key_name_size - curr_len - 1;
1370
1371 ret = RegEnumKeyExW(key, i, *reg_key_name_buf + curr_len + 1, &buf_size,
1372 NULL, NULL, NULL, NULL);
1373 if (ret == ERROR_MORE_DATA) {
1374 /* Increase the size of the buffer and retry */
1375 REGPROC_resize_char_buffer(reg_key_name_buf, reg_key_name_size, curr_len + 1 + buf_size);
1376 } else if (ret == ERROR_SUCCESS) {
1377 HKEY subkey;
1378
1379 i++;
1380 if (RegOpenKeyW(key, *reg_key_name_buf + curr_len + 1,
1381 &subkey) == ERROR_SUCCESS) {
1382 export_hkey(file, subkey, reg_key_name_buf, reg_key_name_size,
1383 val_name_buf, val_name_size, val_buf, val_size,
1384 line_buf, line_buf_size, unicode);
1385 RegCloseKey(subkey);
1386 }
1387 else break;
1388 }
1389 else break;
1390 }
1391 (*reg_key_name_buf)[curr_len] = '\0';
1392 }
1393
1394 /******************************************************************************
1395 * Open file in binary mode for export.
1396 */
1397 static FILE *REGPROC_open_export_file(WCHAR *file_name, BOOL unicode)
1398 {
1399 FILE *file;
1400 WCHAR dash = '-';
1401
1402 if (strncmpW(file_name,&dash,1)==0) {
1403 file=stdout;
1404 _setmode(_fileno(file), _O_BINARY);
1405 } else
1406 {
1407 WCHAR wb_mode[] = {'w','b',0};
1408 WCHAR regedit[] = {'r','e','g','e','d','i','t',0};
1409
1410 file = _wfopen(file_name, wb_mode);
1411 if (!file) {
1412 _wperror(regedit);
1413 output_message(STRING_CANNOT_OPEN_FILE, file_name);
1414 exit(1);
1415 }
1416 }
1417 if(unicode)
1418 {
1419 const BYTE unicode_seq[] = {0xff,0xfe};
1420 const WCHAR header[] = {'W','i','n','d','o','w','s',' ','R','e','g','i','s','t','r','y',' ','E','d','i','t','o','r',' ','V','e','r','s','i','o','n',' ','5','.','0','0','\r','\n'};
1421 fwrite(unicode_seq, sizeof(BYTE), sizeof(unicode_seq)/sizeof(unicode_seq[0]), file);
1422 fwrite(header, sizeof(WCHAR), sizeof(header)/sizeof(header[0]), file);
1423 } else
1424 {
1425 fputs("REGEDIT4\r\n", file);
1426 }
1427
1428 return file;
1429 }
1430
1431 /******************************************************************************
1432 * Writes contents of the registry key to the specified file stream.
1433 *
1434 * Parameters:
1435 * file_name - name of a file to export registry branch to.
1436 * reg_key_name - registry branch to export. The whole registry is exported if
1437 * reg_key_name is NULL or contains an empty string.
1438 */
1439 BOOL export_registry_key(WCHAR *file_name, WCHAR *reg_key_name, DWORD format)
1440 {
1441 WCHAR *reg_key_name_buf;
1442 WCHAR *val_name_buf;
1443 BYTE *val_buf;
1444 WCHAR *line_buf;
1445 DWORD reg_key_name_size = KEY_MAX_LEN;
1446 DWORD val_name_size = KEY_MAX_LEN;
1447 DWORD val_size = REG_VAL_BUF_SIZE;
1448 DWORD line_buf_size = KEY_MAX_LEN + REG_VAL_BUF_SIZE;
1449 FILE *file = NULL;
1450 BOOL unicode = (format == REG_FORMAT_5);
1451
1452 reg_key_name_buf = HeapAlloc(GetProcessHeap(), 0,
1453 reg_key_name_size * sizeof(*reg_key_name_buf));
1454 val_name_buf = HeapAlloc(GetProcessHeap(), 0,
1455 val_name_size * sizeof(*val_name_buf));
1456 val_buf = HeapAlloc(GetProcessHeap(), 0, val_size);
1457 line_buf = HeapAlloc(GetProcessHeap(), 0, line_buf_size * sizeof(*line_buf));
1458 CHECK_ENOUGH_MEMORY(reg_key_name_buf && val_name_buf && val_buf && line_buf);
1459
1460 if (reg_key_name && reg_key_name[0]) {
1461 HKEY reg_key_class;
1462 WCHAR *branch_name = NULL;
1463 HKEY key;
1464
1465 REGPROC_resize_char_buffer(&reg_key_name_buf, &reg_key_name_size,
1466 lstrlenW(reg_key_name));
1467 lstrcpyW(reg_key_name_buf, reg_key_name);
1468
1469 /* open the specified key */
1470 if (!(reg_key_class = parse_key_name(reg_key_name, &branch_name))) {
1471 output_message(STRING_INCORRECT_REG_CLASS, reg_key_name);
1472 exit(1);
1473 }
1474 if (!branch_name || !*branch_name) {
1475 /* no branch - registry class is specified */
1476 file = REGPROC_open_export_file(file_name, unicode);
1477 export_hkey(file, reg_key_class,
1478 &reg_key_name_buf, &reg_key_name_size,
1479 &val_name_buf, &val_name_size,
1480 &val_buf, &val_size, &line_buf,
1481 &line_buf_size, unicode);
1482 } else if (RegOpenKeyW(reg_key_class, branch_name, &key) == ERROR_SUCCESS) {
1483 file = REGPROC_open_export_file(file_name, unicode);
1484 export_hkey(file, key,
1485 &reg_key_name_buf, &reg_key_name_size,
1486 &val_name_buf, &val_name_size,
1487 &val_buf, &val_size, &line_buf,
1488 &line_buf_size, unicode);
1489 RegCloseKey(key);
1490 } else {
1491 output_message(STRING_REG_KEY_NOT_FOUND, reg_key_name);
1492 }
1493 } else {
1494 unsigned int i;
1495
1496 /* export all registry classes */
1497 file = REGPROC_open_export_file(file_name, unicode);
1498 for (i = 0; i < ARRAY_SIZE(reg_class_keys); i++) {
1499 /* do not export HKEY_CLASSES_ROOT */
1500 if (reg_class_keys[i] != HKEY_CLASSES_ROOT &&
1501 reg_class_keys[i] != HKEY_CURRENT_USER &&
1502 reg_class_keys[i] != HKEY_CURRENT_CONFIG &&
1503 reg_class_keys[i] != HKEY_DYN_DATA) {
1504 lstrcpyW(reg_key_name_buf, reg_class_namesW[i]);
1505 export_hkey(file, reg_class_keys[i],
1506 &reg_key_name_buf, &reg_key_name_size,
1507 &val_name_buf, &val_name_size,
1508 &val_buf, &val_size, &line_buf,
1509 &line_buf_size, unicode);
1510 }
1511 }
1512 }
1513
1514 if (file) {
1515 fclose(file);
1516 }
1517 HeapFree(GetProcessHeap(), 0, reg_key_name);
1518 HeapFree(GetProcessHeap(), 0, val_name_buf);
1519 HeapFree(GetProcessHeap(), 0, val_buf);
1520 HeapFree(GetProcessHeap(), 0, line_buf);
1521 return TRUE;
1522 }
1523
1524 /******************************************************************************
1525 * Reads contents of the specified file into the registry.
1526 */
1527 BOOL import_registry_file(FILE *reg_file)
1528 {
1529 BYTE s[2];
1530 struct parser parser;
1531 WCHAR *pos;
1532
1533 if (!reg_file || (fread(s, 2, 1, reg_file) != 1))
1534 return FALSE;
1535
1536 parser.is_unicode = (s[0] == 0xff && s[1] == 0xfe);
1537 get_line = parser.is_unicode ? get_lineW : get_lineA;
1538
1539 parser.file = reg_file;
1540 parser.two_wchars[0] = s[0];
1541 parser.two_wchars[1] = s[1];
1542 parser.reg_version = -1;
1543 parser.hkey = NULL;
1544 parser.key_name = NULL;
1545 parser.value_name = NULL;
1546 parser.parse_type = 0;
1547 parser.data_type = 0;
1548 parser.data = NULL;
1549 parser.data_size = 0;
1550 parser.backslash = FALSE;
1551 parser.state = HEADER;
1552
1553 pos = parser.two_wchars;
1554
1555 /* parser main loop */
1556 while (pos)
1557 pos = (parser_funcs[parser.state])(&parser, pos);
1558
1559 if (parser.reg_version == REG_VERSION_FUZZY || parser.reg_version == REG_VERSION_INVALID)
1560 return parser.reg_version == REG_VERSION_FUZZY;
1561
1562 if (parser.value_name)
1563 HeapFree(GetProcessHeap(), 0, parser.value_name);
1564
1565 close_key(&parser);
1566
1567 return TRUE;
1568 }
1569
1570 /******************************************************************************
1571 * Removes the registry key with all subkeys. Parses full key name.
1572 *
1573 * Parameters:
1574 * reg_key_name - full name of registry branch to delete. Ignored if is NULL,
1575 * empty, points to register key class, does not exist.
1576 */
1577 void delete_registry_key(WCHAR *reg_key_name)
1578 {
1579 WCHAR *key_name = NULL;
1580 HKEY key_class;
1581
1582 if (!reg_key_name || !reg_key_name[0])
1583 return;
1584
1585 if (!(key_class = parse_key_name(reg_key_name, &key_name))) {
1586 output_message(STRING_INCORRECT_REG_CLASS, reg_key_name);
1587 exit(1);
1588 }
1589 if (!*key_name) {
1590 output_message(STRING_DELETE_REG_CLASS_FAILED, reg_key_name);
1591 exit(1);
1592 }
1593
1594 RegDeleteTreeW(key_class, key_name);
1595 }
Windows API implementation