[REG] Sync with Wine Staging 4.18. CORE-16441
[reactos.git] / base / applications / cmdutils / reg / import.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 <errno.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23
24 #include <wine/debug.h>
25 #include <wine/heap.h>
26
27 #include "reg.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(reg);
30
31 static WCHAR *GetWideString(const char *strA)
32 {
33 if (strA)
34 {
35 WCHAR *strW;
36 int len = MultiByteToWideChar(CP_ACP, 0, strA, -1, NULL, 0);
37
38 strW = heap_xalloc(len * sizeof(WCHAR));
39 MultiByteToWideChar(CP_ACP, 0, strA, -1, strW, len);
40 return strW;
41 }
42 return NULL;
43 }
44
45 static WCHAR *GetWideStringN(const char *strA, int size, DWORD *len)
46 {
47 if (strA)
48 {
49 WCHAR *strW;
50 *len = MultiByteToWideChar(CP_ACP, 0, strA, size, NULL, 0);
51
52 strW = heap_xalloc(*len * sizeof(WCHAR));
53 MultiByteToWideChar(CP_ACP, 0, strA, size, strW, *len);
54 return strW;
55 }
56 *len = 0;
57 return NULL;
58 }
59
60 static WCHAR *(*get_line)(FILE *);
61
62 /* parser definitions */
63 enum parser_state
64 {
65 HEADER, /* parsing the registry file version header */
66 PARSE_WIN31_LINE, /* parsing a Windows 3.1 registry line */
67 LINE_START, /* at the beginning of a registry line */
68 KEY_NAME, /* parsing a key name */
69 DELETE_KEY, /* deleting a registry key */
70 DEFAULT_VALUE_NAME, /* parsing a default value name */
71 QUOTED_VALUE_NAME, /* parsing a double-quoted value name */
72 DATA_START, /* preparing for data parsing operations */
73 DELETE_VALUE, /* deleting a registry value */
74 DATA_TYPE, /* parsing the registry data type */
75 STRING_DATA, /* parsing REG_SZ data */
76 DWORD_DATA, /* parsing DWORD data */
77 HEX_DATA, /* parsing REG_BINARY, REG_NONE, REG_EXPAND_SZ or REG_MULTI_SZ data */
78 EOL_BACKSLASH, /* preparing to parse multiple lines of hex data */
79 HEX_MULTILINE, /* parsing multiple lines of hex data */
80 UNKNOWN_DATA, /* parsing an unhandled or invalid data type */
81 SET_VALUE, /* adding a value to the registry */
82 NB_PARSER_STATES
83 };
84
85 struct parser
86 {
87 FILE *file; /* pointer to a registry file */
88 WCHAR two_wchars[2]; /* first two characters from the encoding check */
89 BOOL is_unicode; /* parsing Unicode or ASCII data */
90 short int reg_version; /* registry file version */
91 HKEY hkey; /* current registry key */
92 WCHAR *key_name; /* current key name */
93 WCHAR *value_name; /* value name */
94 DWORD parse_type; /* generic data type for parsing */
95 DWORD data_type; /* data type */
96 void *data; /* value data */
97 DWORD data_size; /* size of the data (in bytes) */
98 BOOL backslash; /* TRUE if the current line contains a backslash */
99 enum parser_state state; /* current parser state */
100 };
101
102 typedef WCHAR *(*parser_state_func)(struct parser *parser, WCHAR *pos);
103
104 /* parser state machine functions */
105 static WCHAR *header_state(struct parser *parser, WCHAR *pos);
106 static WCHAR *parse_win31_line_state(struct parser *parser, WCHAR *pos);
107 static WCHAR *line_start_state(struct parser *parser, WCHAR *pos);
108 static WCHAR *key_name_state(struct parser *parser, WCHAR *pos);
109 static WCHAR *delete_key_state(struct parser *parser, WCHAR *pos);
110 static WCHAR *default_value_name_state(struct parser *parser, WCHAR *pos);
111 static WCHAR *quoted_value_name_state(struct parser *parser, WCHAR *pos);
112 static WCHAR *data_start_state(struct parser *parser, WCHAR *pos);
113 static WCHAR *delete_value_state(struct parser *parser, WCHAR *pos);
114 static WCHAR *data_type_state(struct parser *parser, WCHAR *pos);
115 static WCHAR *string_data_state(struct parser *parser, WCHAR *pos);
116 static WCHAR *dword_data_state(struct parser *parser, WCHAR *pos);
117 static WCHAR *hex_data_state(struct parser *parser, WCHAR *pos);
118 static WCHAR *eol_backslash_state(struct parser *parser, WCHAR *pos);
119 static WCHAR *hex_multiline_state(struct parser *parser, WCHAR *pos);
120 static WCHAR *unknown_data_state(struct parser *parser, WCHAR *pos);
121 static WCHAR *set_value_state(struct parser *parser, WCHAR *pos);
122
123 static const parser_state_func parser_funcs[NB_PARSER_STATES] =
124 {
125 header_state, /* HEADER */
126 parse_win31_line_state, /* PARSE_WIN31_LINE */
127 line_start_state, /* LINE_START */
128 key_name_state, /* KEY_NAME */
129 delete_key_state, /* DELETE_KEY */
130 default_value_name_state, /* DEFAULT_VALUE_NAME */
131 quoted_value_name_state, /* QUOTED_VALUE_NAME */
132 data_start_state, /* DATA_START */
133 delete_value_state, /* DELETE_VALUE */
134 data_type_state, /* DATA_TYPE */
135 string_data_state, /* STRING_DATA */
136 dword_data_state, /* DWORD_DATA */
137 hex_data_state, /* HEX_DATA */
138 eol_backslash_state, /* EOL_BACKSLASH */
139 hex_multiline_state, /* HEX_MULTILINE */
140 unknown_data_state, /* UNKNOWN_DATA */
141 set_value_state, /* SET_VALUE */
142 };
143
144 /* set the new parser state and return the previous one */
145 static inline enum parser_state set_state(struct parser *parser, enum parser_state state)
146 {
147 enum parser_state ret = parser->state;
148 parser->state = state;
149 return ret;
150 }
151
152 /******************************************************************************
153 * Converts a hex representation of a DWORD into a DWORD.
154 */
155 static BOOL convert_hex_to_dword(WCHAR *str, DWORD *dw)
156 {
157 WCHAR *p, *end;
158 int count = 0;
159
160 while (*str == ' ' || *str == '\t') str++;
161 if (!*str) goto error;
162
163 p = str;
164 while (iswxdigit(*p))
165 {
166 count++;
167 p++;
168 }
169 if (count > 8) goto error;
170
171 end = p;
172 while (*p == ' ' || *p == '\t') p++;
173 if (*p && *p != ';') goto error;
174
175 *end = 0;
176 *dw = wcstoul(str, &end, 16);
177 return TRUE;
178
179 error:
180 return FALSE;
181 }
182
183 /******************************************************************************
184 * Converts comma-separated hex data into a binary string and modifies
185 * the input parameter to skip the concatenating backslash, if found.
186 *
187 * Returns TRUE or FALSE to indicate whether parsing was successful.
188 */
189 static BOOL convert_hex_csv_to_hex(struct parser *parser, WCHAR **str)
190 {
191 size_t size;
192 BYTE *d;
193 WCHAR *s;
194
195 parser->backslash = FALSE;
196
197 /* The worst case is 1 digit + 1 comma per byte */
198 size = ((lstrlenW(*str) + 1) / 2) + parser->data_size;
199 parser->data = heap_xrealloc(parser->data, size);
200
201 s = *str;
202 d = (BYTE *)parser->data + parser->data_size;
203
204 while (*s)
205 {
206 WCHAR *end;
207 unsigned long wc;
208
209 wc = wcstoul(s, &end, 16);
210 if (wc > 0xff) return FALSE;
211
212 if (s == end && wc == 0)
213 {
214 while (*end == ' ' || *end == '\t') end++;
215 if (*end == '\\')
216 {
217 parser->backslash = TRUE;
218 *str = end + 1;
219 return TRUE;
220 }
221 else if (*end == ';')
222 return TRUE;
223 return FALSE;
224 }
225
226 *d++ = wc;
227 parser->data_size++;
228
229 if (*end && *end != ',')
230 {
231 while (*end == ' ' || *end == '\t') end++;
232 if (*end && *end != ';') return FALSE;
233 return TRUE;
234 }
235
236 if (*end) end++;
237 s = end;
238 }
239
240 return TRUE;
241 }
242
243 /******************************************************************************
244 * Parses the data type of the registry value being imported and modifies
245 * the input parameter to skip the string representation of the data type.
246 *
247 * Returns TRUE or FALSE to indicate whether a data type was found.
248 */
249 static BOOL parse_data_type(struct parser *parser, WCHAR **line)
250 {
251 struct data_type { const WCHAR *tag; int len; int type; int parse_type; };
252
253 static const WCHAR quote[] = {'"'};
254 static const WCHAR hex[] = {'h','e','x',':'};
255 static const WCHAR dword[] = {'d','w','o','r','d',':'};
256 static const WCHAR hexp[] = {'h','e','x','('};
257
258 static const struct data_type data_types[] = {
259 /* tag len type parse type */
260 { quote, 1, REG_SZ, REG_SZ },
261 { hex, 4, REG_BINARY, REG_BINARY },
262 { dword, 6, REG_DWORD, REG_DWORD },
263 { hexp, 4, -1, REG_BINARY }, /* REG_NONE, REG_EXPAND_SZ, REG_MULTI_SZ */
264 { NULL, 0, 0, 0 }
265 };
266
267 const struct data_type *ptr;
268
269 for (ptr = data_types; ptr->tag; ptr++)
270 {
271 if (wcsncmp(ptr->tag, *line, ptr->len))
272 continue;
273
274 parser->parse_type = ptr->parse_type;
275 parser->data_type = ptr->parse_type;
276 *line += ptr->len;
277
278 if (ptr->type == -1)
279 {
280 WCHAR *end;
281 DWORD val;
282
283 if (!**line || towlower((*line)[1]) == 'x')
284 return FALSE;
285
286 /* "hex(xx):" is special */
287 val = wcstoul(*line, &end, 16);
288 if (*end != ')' || *(end + 1) != ':' || (val == ~0u && errno == ERANGE))
289 return FALSE;
290
291 parser->data_type = val;
292 *line = end + 2;
293 }
294 return TRUE;
295 }
296 return FALSE;
297 }
298
299 /******************************************************************************
300 * Replaces escape sequences with their character equivalents and
301 * null-terminates the string on the first non-escaped double quote.
302 *
303 * Assigns a pointer to the remaining unparsed data in the line.
304 * Returns TRUE or FALSE to indicate whether a closing double quote was found.
305 */
306 static BOOL unescape_string(WCHAR *str, WCHAR **unparsed)
307 {
308 int str_idx = 0; /* current character under analysis */
309 int val_idx = 0; /* the last character of the unescaped string */
310 int len = lstrlenW(str);
311 BOOL ret;
312
313 for (str_idx = 0; str_idx < len; str_idx++, val_idx++)
314 {
315 if (str[str_idx] == '\\')
316 {
317 str_idx++;
318 switch (str[str_idx])
319 {
320 case 'n':
321 str[val_idx] = '\n';
322 break;
323 case 'r':
324 str[val_idx] = '\r';
325 break;
326 case '0':
327 str[val_idx] = '\0';
328 break;
329 case '\\':
330 case '"':
331 str[val_idx] = str[str_idx];
332 break;
333 default:
334 if (!str[str_idx]) return FALSE;
335 output_message(STRING_ESCAPE_SEQUENCE, str[str_idx]);
336 str[val_idx] = str[str_idx];
337 break;
338 }
339 }
340 else if (str[str_idx] == '"')
341 break;
342 else
343 str[val_idx] = str[str_idx];
344 }
345
346 ret = (str[str_idx] == '"');
347 *unparsed = str + str_idx + 1;
348 str[val_idx] = '\0';
349 return ret;
350 }
351
352 static HKEY parse_key_name(WCHAR *key_name, WCHAR **key_path)
353 {
354 if (!key_name) return 0;
355
356 *key_path = wcschr(key_name, '\\');
357 if (*key_path) (*key_path)++;
358
359 return path_get_rootkey(key_name);
360 }
361
362 static void close_key(struct parser *parser)
363 {
364 if (parser->hkey)
365 {
366 heap_free(parser->key_name);
367 parser->key_name = NULL;
368
369 RegCloseKey(parser->hkey);
370 parser->hkey = NULL;
371 }
372 }
373
374 static LONG open_key(struct parser *parser, WCHAR *path)
375 {
376 HKEY key_class;
377 WCHAR *key_path;
378 LONG res;
379
380 close_key(parser);
381
382 /* Get the registry class */
383 if (!path || !(key_class = parse_key_name(path, &key_path)))
384 return ERROR_INVALID_PARAMETER;
385
386 res = RegCreateKeyExW(key_class, key_path, 0, NULL, REG_OPTION_NON_VOLATILE,
387 KEY_ALL_ACCESS, NULL, &parser->hkey, NULL);
388
389 if (res == ERROR_SUCCESS)
390 {
391 parser->key_name = heap_xalloc((lstrlenW(path) + 1) * sizeof(WCHAR));
392 lstrcpyW(parser->key_name, path);
393 }
394 else
395 parser->hkey = NULL;
396
397 return res;
398 }
399
400 static void free_parser_data(struct parser *parser)
401 {
402 if (parser->parse_type == REG_DWORD || parser->parse_type == REG_BINARY)
403 heap_free(parser->data);
404
405 parser->data = NULL;
406 parser->data_size = 0;
407 }
408
409 static void prepare_hex_string_data(struct parser *parser)
410 {
411 if (parser->data_type == REG_EXPAND_SZ || parser->data_type == REG_MULTI_SZ ||
412 parser->data_type == REG_SZ)
413 {
414 if (parser->is_unicode)
415 {
416 WCHAR *data = parser->data;
417 DWORD len = parser->data_size / sizeof(WCHAR);
418
419 if (data[len - 1] != 0)
420 {
421 data[len] = 0;
422 parser->data_size += sizeof(WCHAR);
423 }
424 }
425 else
426 {
427 BYTE *data = parser->data;
428
429 if (data[parser->data_size - 1] != 0)
430 {
431 data[parser->data_size] = 0;
432 parser->data_size++;
433 }
434
435 parser->data = GetWideStringN(parser->data, parser->data_size, &parser->data_size);
436 parser->data_size *= sizeof(WCHAR);
437 heap_free(data);
438 }
439 }
440 }
441
442 enum reg_versions {
443 REG_VERSION_31,
444 REG_VERSION_40,
445 REG_VERSION_50,
446 REG_VERSION_FUZZY,
447 REG_VERSION_INVALID
448 };
449
450 static enum reg_versions parse_file_header(const WCHAR *s)
451 {
452 static const WCHAR header_31[] = {'R','E','G','E','D','I','T',0};
453 static const WCHAR header_40[] = {'R','E','G','E','D','I','T','4',0};
454 static const WCHAR header_50[] = {'W','i','n','d','o','w','s',' ',
455 'R','e','g','i','s','t','r','y',' ','E','d','i','t','o','r',' ',
456 'V','e','r','s','i','o','n',' ','5','.','0','0',0};
457
458 while (*s == ' ' || *s == '\t') s++;
459
460 if (!lstrcmpW(s, header_31))
461 return REG_VERSION_31;
462
463 if (!lstrcmpW(s, header_40))
464 return REG_VERSION_40;
465
466 if (!lstrcmpW(s, header_50))
467 return REG_VERSION_50;
468
469 /* The Windows version accepts registry file headers beginning with "REGEDIT" and ending
470 * with other characters, as long as "REGEDIT" appears at the start of the line. For example,
471 * "REGEDIT 4", "REGEDIT9" and "REGEDIT4FOO" are all treated as valid file headers.
472 * In all such cases, however, the contents of the registry file are not imported.
473 */
474 if (!wcsncmp(s, header_31, 7)) /* "REGEDIT" without NUL */
475 return REG_VERSION_FUZZY;
476
477 return REG_VERSION_INVALID;
478 }
479
480 /* handler for parser HEADER state */
481 static WCHAR *header_state(struct parser *parser, WCHAR *pos)
482 {
483 WCHAR *line, *header;
484
485 if (!(line = get_line(parser->file)))
486 return NULL;
487
488 if (!parser->is_unicode)
489 {
490 header = heap_xalloc((lstrlenW(line) + 3) * sizeof(WCHAR));
491 header[0] = parser->two_wchars[0];
492 header[1] = parser->two_wchars[1];
493 lstrcpyW(header + 2, line);
494 parser->reg_version = parse_file_header(header);
495 heap_free(header);
496 }
497 else parser->reg_version = parse_file_header(line);
498
499 switch (parser->reg_version)
500 {
501 case REG_VERSION_31:
502 set_state(parser, PARSE_WIN31_LINE);
503 break;
504 case REG_VERSION_40:
505 case REG_VERSION_50:
506 set_state(parser, LINE_START);
507 break;
508 default:
509 get_line(NULL); /* Reset static variables */
510 return NULL;
511 }
512
513 return line;
514 }
515
516 /* handler for parser PARSE_WIN31_LINE state */
517 static WCHAR *parse_win31_line_state(struct parser *parser, WCHAR *pos)
518 {
519 WCHAR *line, *value;
520 static WCHAR hkcr[] = {'H','K','E','Y','_','C','L','A','S','S','E','S','_','R','O','O','T'};
521 unsigned int key_end = 0;
522
523 if (!(line = get_line(parser->file)))
524 return NULL;
525
526 if (wcsncmp(line, hkcr, ARRAY_SIZE(hkcr)))
527 return line;
528
529 /* get key name */
530 while (line[key_end] && !iswspace(line[key_end])) key_end++;
531
532 value = line + key_end;
533 while (*value == ' ' || *value == '\t') value++;
534
535 if (*value == '=') value++;
536 if (*value == ' ') value++; /* at most one space is skipped */
537
538 line[key_end] = 0;
539
540 if (open_key(parser, line) != ERROR_SUCCESS)
541 {
542 output_message(STRING_OPEN_KEY_FAILED, line);
543 return line;
544 }
545
546 parser->value_name = NULL;
547 parser->data_type = REG_SZ;
548 parser->data = value;
549 parser->data_size = (lstrlenW(value) + 1) * sizeof(WCHAR);
550
551 set_state(parser, SET_VALUE);
552 return value;
553 }
554
555 /* handler for parser LINE_START state */
556 static WCHAR *line_start_state(struct parser *parser, WCHAR *pos)
557 {
558 WCHAR *line, *p;
559
560 if (!(line = get_line(parser->file)))
561 return NULL;
562
563 for (p = line; *p; p++)
564 {
565 switch (*p)
566 {
567 case '[':
568 set_state(parser, KEY_NAME);
569 return p + 1;
570 case '@':
571 set_state(parser, DEFAULT_VALUE_NAME);
572 return p;
573 case '"':
574 set_state(parser, QUOTED_VALUE_NAME);
575 return p + 1;
576 case ' ':
577 case '\t':
578 break;
579 default:
580 return p;
581 }
582 }
583
584 return p;
585 }
586
587 /* handler for parser KEY_NAME state */
588 static WCHAR *key_name_state(struct parser *parser, WCHAR *pos)
589 {
590 WCHAR *p = pos, *key_end;
591
592 if (*p == ' ' || *p == '\t' || !(key_end = wcsrchr(p, ']')))
593 goto done;
594
595 *key_end = 0;
596
597 if (*p == '-')
598 {
599 set_state(parser, DELETE_KEY);
600 return p + 1;
601 }
602 else if (open_key(parser, p) != ERROR_SUCCESS)
603 output_message(STRING_OPEN_KEY_FAILED, p);
604
605 done:
606 set_state(parser, LINE_START);
607 return p;
608 }
609
610 /* handler for parser DELETE_KEY state */
611 static WCHAR *delete_key_state(struct parser *parser, WCHAR *pos)
612 {
613 WCHAR *p = pos;
614
615 close_key(parser);
616
617 if (*p == 'H' || *p == 'h')
618 {
619 HKEY root;
620 WCHAR *path;
621
622 root = parse_key_name(p, &path);
623
624 if (root && path && *path)
625 RegDeleteTreeW(root, path);
626 }
627
628 set_state(parser, LINE_START);
629 return p;
630 }
631
632 /* handler for parser DEFAULT_VALUE_NAME state */
633 static WCHAR *default_value_name_state(struct parser *parser, WCHAR *pos)
634 {
635 heap_free(parser->value_name);
636 parser->value_name = NULL;
637
638 set_state(parser, DATA_START);
639 return pos + 1;
640 }
641
642 /* handler for parser QUOTED_VALUE_NAME state */
643 static WCHAR *quoted_value_name_state(struct parser *parser, WCHAR *pos)
644 {
645 WCHAR *val_name = pos, *p;
646
647 heap_free(parser->value_name);
648 parser->value_name = NULL;
649
650 if (!unescape_string(val_name, &p))
651 goto invalid;
652
653 /* copy the value name in case we need to parse multiple lines and the buffer is overwritten */
654 parser->value_name = heap_xalloc((lstrlenW(val_name) + 1) * sizeof(WCHAR));
655 lstrcpyW(parser->value_name, val_name);
656
657 set_state(parser, DATA_START);
658 return p;
659
660 invalid:
661 set_state(parser, LINE_START);
662 return val_name;
663 }
664
665 /* handler for parser DATA_START state */
666 static WCHAR *data_start_state(struct parser *parser, WCHAR *pos)
667 {
668 WCHAR *p = pos;
669 unsigned int len;
670
671 while (*p == ' ' || *p == '\t') p++;
672 if (*p != '=') goto invalid;
673 p++;
674 while (*p == ' ' || *p == '\t') p++;
675
676 /* trim trailing whitespace */
677 len = lstrlenW(p);
678 while (len > 0 && (p[len - 1] == ' ' || p[len - 1] == '\t')) len--;
679 p[len] = 0;
680
681 if (*p == '-')
682 set_state(parser, DELETE_VALUE);
683 else
684 set_state(parser, DATA_TYPE);
685 return p;
686
687 invalid:
688 set_state(parser, LINE_START);
689 return p;
690 }
691
692 /* handler for parser DELETE_VALUE state */
693 static WCHAR *delete_value_state(struct parser *parser, WCHAR *pos)
694 {
695 WCHAR *p = pos + 1;
696
697 while (*p == ' ' || *p == '\t') p++;
698 if (*p && *p != ';') goto done;
699
700 RegDeleteValueW(parser->hkey, parser->value_name);
701
702 done:
703 set_state(parser, LINE_START);
704 return p;
705 }
706
707 /* handler for parser DATA_TYPE state */
708 static WCHAR *data_type_state(struct parser *parser, WCHAR *pos)
709 {
710 WCHAR *line = pos;
711
712 if (!parse_data_type(parser, &line))
713 {
714 set_state(parser, LINE_START);
715 return line;
716 }
717
718 switch (parser->parse_type)
719 {
720 case REG_SZ:
721 set_state(parser, STRING_DATA);
722 break;
723 case REG_DWORD:
724 set_state(parser, DWORD_DATA);
725 break;
726 case REG_BINARY: /* all hex data types, including undefined */
727 set_state(parser, HEX_DATA);
728 break;
729 default:
730 set_state(parser, UNKNOWN_DATA);
731 }
732
733 return line;
734 }
735
736 /* handler for parser STRING_DATA state */
737 static WCHAR *string_data_state(struct parser *parser, WCHAR *pos)
738 {
739 WCHAR *line;
740
741 parser->data = pos;
742
743 if (!unescape_string(parser->data, &line))
744 goto invalid;
745
746 while (*line == ' ' || *line == '\t') line++;
747 if (*line && *line != ';') goto invalid;
748
749 parser->data_size = (lstrlenW(parser->data) + 1) * sizeof(WCHAR);
750
751 set_state(parser, SET_VALUE);
752 return line;
753
754 invalid:
755 free_parser_data(parser);
756 set_state(parser, LINE_START);
757 return line;
758 }
759
760 /* handler for parser DWORD_DATA state */
761 static WCHAR *dword_data_state(struct parser *parser, WCHAR *pos)
762 {
763 WCHAR *line = pos;
764
765 parser->data = heap_xalloc(sizeof(DWORD));
766
767 if (!convert_hex_to_dword(line, parser->data))
768 goto invalid;
769
770 parser->data_size = sizeof(DWORD);
771
772 set_state(parser, SET_VALUE);
773 return line;
774
775 invalid:
776 free_parser_data(parser);
777 set_state(parser, LINE_START);
778 return line;
779 }
780
781 /* handler for parser HEX_DATA state */
782 static WCHAR *hex_data_state(struct parser *parser, WCHAR *pos)
783 {
784 WCHAR *line = pos;
785
786 if (!*line)
787 goto set_value;
788
789 if (!convert_hex_csv_to_hex(parser, &line))
790 goto invalid;
791
792 if (parser->backslash)
793 {
794 set_state(parser, EOL_BACKSLASH);
795 return line;
796 }
797
798 prepare_hex_string_data(parser);
799
800 set_value:
801 set_state(parser, SET_VALUE);
802 return line;
803
804 invalid:
805 free_parser_data(parser);
806 set_state(parser, LINE_START);
807 return line;
808 }
809
810 /* handler for parser EOL_BACKSLASH state */
811 static WCHAR *eol_backslash_state(struct parser *parser, WCHAR *pos)
812 {
813 WCHAR *p = pos;
814
815 while (*p == ' ' || *p == '\t') p++;
816 if (*p && *p != ';') goto invalid;
817
818 set_state(parser, HEX_MULTILINE);
819 return pos;
820
821 invalid:
822 free_parser_data(parser);
823 set_state(parser, LINE_START);
824 return p;
825 }
826
827 /* handler for parser HEX_MULTILINE state */
828 static WCHAR *hex_multiline_state(struct parser *parser, WCHAR *pos)
829 {
830 WCHAR *line;
831
832 if (!(line = get_line(parser->file)))
833 {
834 prepare_hex_string_data(parser);
835 set_state(parser, SET_VALUE);
836 return pos;
837 }
838
839 while (*line == ' ' || *line == '\t') line++;
840 if (!*line || *line == ';') return line;
841
842 if (!iswxdigit(*line)) goto invalid;
843
844 set_state(parser, HEX_DATA);
845 return line;
846
847 invalid:
848 free_parser_data(parser);
849 set_state(parser, LINE_START);
850 return line;
851 }
852
853 /* handler for parser UNKNOWN_DATA state */
854 static WCHAR *unknown_data_state(struct parser *parser, WCHAR *pos)
855 {
856 FIXME("Unknown registry data type [0x%x]\n", parser->data_type);
857
858 set_state(parser, LINE_START);
859 return pos;
860 }
861
862 /* handler for parser SET_VALUE state */
863 static WCHAR *set_value_state(struct parser *parser, WCHAR *pos)
864 {
865 RegSetValueExW(parser->hkey, parser->value_name, 0, parser->data_type,
866 parser->data, parser->data_size);
867
868 free_parser_data(parser);
869
870 if (parser->reg_version == REG_VERSION_31)
871 set_state(parser, PARSE_WIN31_LINE);
872 else
873 set_state(parser, LINE_START);
874
875 return pos;
876 }
877
878 #define REG_VAL_BUF_SIZE 4096
879
880 static WCHAR *get_lineA(FILE *fp)
881 {
882 static WCHAR *lineW;
883 static size_t size;
884 static char *buf, *next;
885 char *line;
886
887 heap_free(lineW);
888
889 if (!fp) goto cleanup;
890
891 if (!size)
892 {
893 size = REG_VAL_BUF_SIZE;
894 buf = heap_xalloc(size);
895 *buf = 0;
896 next = buf;
897 }
898 line = next;
899
900 while (next)
901 {
902 char *p = strpbrk(line, "\r\n");
903 if (!p)
904 {
905 size_t len, count;
906 len = strlen(next);
907 memmove(buf, next, len + 1);
908 if (size - len < 3)
909 {
910 size *= 2;
911 buf = heap_xrealloc(buf, size);
912 }
913 if (!(count = fread(buf + len, 1, size - len - 1, fp)))
914 {
915 next = NULL;
916 lineW = GetWideString(buf);
917 return lineW;
918 }
919 buf[len + count] = 0;
920 next = buf;
921 line = buf;
922 continue;
923 }
924 next = p + 1;
925 if (*p == '\r' && *(p + 1) == '\n') next++;
926 *p = 0;
927 lineW = GetWideString(line);
928 return lineW;
929 }
930
931 cleanup:
932 lineW = NULL;
933 if (size) heap_free(buf);
934 size = 0;
935 return NULL;
936 }
937
938 static WCHAR *get_lineW(FILE *fp)
939 {
940 static size_t size;
941 static WCHAR *buf, *next;
942 WCHAR *line;
943
944 if (!fp) goto cleanup;
945
946 if (!size)
947 {
948 size = REG_VAL_BUF_SIZE;
949 buf = heap_xalloc(size * sizeof(WCHAR));
950 *buf = 0;
951 next = buf;
952 }
953 line = next;
954
955 while (next)
956 {
957 static const WCHAR line_endings[] = {'\r','\n',0};
958 WCHAR *p = wcspbrk(line, line_endings);
959 if (!p)
960 {
961 size_t len, count;
962 len = lstrlenW(next);
963 memmove(buf, next, (len + 1) * sizeof(WCHAR));
964 if (size - len < 3)
965 {
966 size *= 2;
967 buf = heap_xrealloc(buf, size * sizeof(WCHAR));
968 }
969 if (!(count = fread(buf + len, sizeof(WCHAR), size - len - 1, fp)))
970 {
971 next = NULL;
972 return buf;
973 }
974 buf[len + count] = 0;
975 next = buf;
976 line = buf;
977 continue;
978 }
979 next = p + 1;
980 if (*p == '\r' && *(p + 1) == '\n') next++;
981 *p = 0;
982 return line;
983 }
984
985 cleanup:
986 if (size) heap_free(buf);
987 size = 0;
988 return NULL;
989 }
990
991 int reg_import(const WCHAR *filename)
992 {
993 FILE *fp;
994 static const WCHAR rb_mode[] = {'r','b',0};
995 BYTE s[2];
996 struct parser parser;
997 WCHAR *pos;
998
999 fp = _wfopen(filename, rb_mode);
1000 if (!fp)
1001 {
1002 output_message(STRING_FILE_NOT_FOUND, filename);
1003 return 1;
1004 }
1005
1006 if (fread(s, sizeof(WCHAR), 1, fp) != 1)
1007 goto error;
1008
1009 parser.is_unicode = (s[0] == 0xff && s[1] == 0xfe);
1010 get_line = parser.is_unicode ? get_lineW : get_lineA;
1011
1012 parser.file = fp;
1013 parser.two_wchars[0] = s[0];
1014 parser.two_wchars[1] = s[1];
1015 parser.reg_version = -1;
1016 parser.hkey = NULL;
1017 parser.key_name = NULL;
1018 parser.value_name = NULL;
1019 parser.parse_type = 0;
1020 parser.data_type = 0;
1021 parser.data = NULL;
1022 parser.data_size = 0;
1023 parser.backslash = FALSE;
1024 parser.state = HEADER;
1025
1026 pos = parser.two_wchars;
1027
1028 /* parser main loop */
1029 while (pos)
1030 pos = (parser_funcs[parser.state])(&parser, pos);
1031
1032 if (parser.reg_version == REG_VERSION_INVALID)
1033 goto error;
1034
1035 heap_free(parser.value_name);
1036 close_key(&parser);
1037
1038 fclose(fp);
1039 return 0;
1040
1041 error:
1042 fclose(fp);
1043 return 1;
1044 }