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