programs/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/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     heap_free(parser->value_name);
 649     parser->value_name = NULL;
 650
 651     if (!unescape_string(val_name, &p))
 652         goto invalid;
 653
 654     /* copy the value name in case we need to parse multiple lines and the buffer is overwritten */
 655     parser->value_name = heap_xalloc((lstrlenW(val_name) + 1) * sizeof(WCHAR));
 656     lstrcpyW(parser->value_name, val_name);
 657
 658     set_state(parser, DATA_START);
 659     return p;
 660
 661 invalid:
 662     set_state(parser, LINE_START);
 663     return val_name;
 664 }
 665
 666 /* handler for parser DATA_START state */
 667 static WCHAR *data_start_state(struct parser *parser, WCHAR *pos)
 668 {
 669     WCHAR *p = pos;
 670     unsigned int len;
 671
 672     while (*p == ' ' || *p == '\t') p++;
 673     if (*p != '=') goto invalid;
 674     p++;
 675     while (*p == ' ' || *p == '\t') p++;
 676
 677     /* trim trailing whitespace */
 678     len = strlenW(p);
 679     while (len > 0 && (p[len - 1] == ' ' || p[len - 1] == '\t')) len--;
 680     p[len] = 0;
 681
 682     if (*p == '-')
 683         set_state(parser, DELETE_VALUE);
 684     else
 685         set_state(parser, DATA_TYPE);
 686     return p;
 687
 688 invalid:
 689     set_state(parser, LINE_START);
 690     return p;
 691 }
 692
 693 /* handler for parser DELETE_VALUE state */
 694 static WCHAR *delete_value_state(struct parser *parser, WCHAR *pos)
 695 {
 696     WCHAR *p = pos + 1;
 697
 698     while (*p == ' ' || *p == '\t') p++;
 699     if (*p && *p != ';') goto done;
 700
 701     RegDeleteValueW(parser->hkey, parser->value_name);
 702
 703 done:
 704     set_state(parser, LINE_START);
 705     return p;
 706 }
 707
 708 /* handler for parser DATA_TYPE state */
 709 static WCHAR *data_type_state(struct parser *parser, WCHAR *pos)
 710 {
 711     WCHAR *line = pos;
 712
 713     if (!parse_data_type(parser, &line))
 714     {
 715         set_state(parser, LINE_START);
 716         return line;
 717     }
 718
 719     switch (parser->parse_type)
 720     {
 721     case REG_SZ:
 722         set_state(parser, STRING_DATA);
 723         break;
 724     case REG_DWORD:
 725         set_state(parser, DWORD_DATA);
 726         break;
 727     case REG_BINARY: /* all hex data types, including undefined */
 728         set_state(parser, HEX_DATA);
 729         break;
 730     default:
 731         set_state(parser, UNKNOWN_DATA);
 732     }
 733
 734     return line;
 735 }
 736
 737 /* handler for parser STRING_DATA state */
 738 static WCHAR *string_data_state(struct parser *parser, WCHAR *pos)
 739 {
 740     WCHAR *line;
 741
 742     parser->data = pos;
 743
 744     if (!unescape_string(parser->data, &line))
 745         goto invalid;
 746
 747     while (*line == ' ' || *line == '\t') line++;
 748     if (*line && *line != ';') goto invalid;
 749
 750     parser->data_size = (lstrlenW(parser->data) + 1) * sizeof(WCHAR);
 751
 752     set_state(parser, SET_VALUE);
 753     return line;
 754
 755 invalid:
 756     free_parser_data(parser);
 757     set_state(parser, LINE_START);
 758     return line;
 759 }
 760
 761 /* handler for parser DWORD_DATA state */
 762 static WCHAR *dword_data_state(struct parser *parser, WCHAR *pos)
 763 {
 764     WCHAR *line = pos;
 765
 766     parser->data = heap_xalloc(sizeof(DWORD));
 767
 768     if (!convert_hex_to_dword(line, parser->data))
 769         goto invalid;
 770
 771     parser->data_size = sizeof(DWORD);
 772
 773     set_state(parser, SET_VALUE);
 774     return line;
 775
 776 invalid:
 777     free_parser_data(parser);
 778     set_state(parser, LINE_START);
 779     return line;
 780 }
 781
 782 /* handler for parser HEX_DATA state */
 783 static WCHAR *hex_data_state(struct parser *parser, WCHAR *pos)
 784 {
 785     WCHAR *line = pos;
 786
 787     if (!*line)
 788         goto set_value;
 789
 790     if (!convert_hex_csv_to_hex(parser, &line))
 791         goto invalid;
 792
 793     if (parser->backslash)
 794     {
 795         set_state(parser, EOL_BACKSLASH);
 796         return line;
 797     }
 798
 799     prepare_hex_string_data(parser);
 800
 801 set_value:
 802     set_state(parser, SET_VALUE);
 803     return line;
 804
 805 invalid:
 806     free_parser_data(parser);
 807     set_state(parser, LINE_START);
 808     return line;
 809 }
 810
 811 /* handler for parser EOL_BACKSLASH state */
 812 static WCHAR *eol_backslash_state(struct parser *parser, WCHAR *pos)
 813 {
 814     WCHAR *p = pos;
 815
 816     while (*p == ' ' || *p == '\t') p++;
 817     if (*p && *p != ';') goto invalid;
 818
 819     set_state(parser, HEX_MULTILINE);
 820     return pos;
 821
 822 invalid:
 823     free_parser_data(parser);
 824     set_state(parser, LINE_START);
 825     return p;
 826 }
 827
 828 /* handler for parser HEX_MULTILINE state */
 829 static WCHAR *hex_multiline_state(struct parser *parser, WCHAR *pos)
 830 {
 831     WCHAR *line;
 832
 833     if (!(line = get_line(parser->file)))
 834     {
 835         prepare_hex_string_data(parser);
 836         set_state(parser, SET_VALUE);
 837         return pos;
 838     }
 839
 840     while (*line == ' ' || *line == '\t') line++;
 841     if (!*line || *line == ';') return line;
 842
 843     if (!isxdigitW(*line)) goto invalid;
 844
 845     set_state(parser, HEX_DATA);
 846     return line;
 847
 848 invalid:
 849     free_parser_data(parser);
 850     set_state(parser, LINE_START);
 851     return line;
 852 }
 853
 854 /* handler for parser UNKNOWN_DATA state */
 855 static WCHAR *unknown_data_state(struct parser *parser, WCHAR *pos)
 856 {
 857     FIXME("Unknown registry data type [0x%x]\n", parser->data_type);
 858
 859     set_state(parser, LINE_START);
 860     return pos;
 861 }
 862
 863 /* handler for parser SET_VALUE state */
 864 static WCHAR *set_value_state(struct parser *parser, WCHAR *pos)
 865 {
 866     RegSetValueExW(parser->hkey, parser->value_name, 0, parser->data_type,
 867                    parser->data, parser->data_size);
 868
 869     free_parser_data(parser);
 870
 871     if (parser->reg_version == REG_VERSION_31)
 872         set_state(parser, PARSE_WIN31_LINE);
 873     else
 874         set_state(parser, LINE_START);
 875
 876     return pos;
 877 }
 878
 879 #define REG_VAL_BUF_SIZE  4096
 880
 881 static WCHAR *get_lineA(FILE *fp)
 882 {
 883     static WCHAR *lineW;
 884     static size_t size;
 885     static char *buf, *next;
 886     char *line;
 887
 888     heap_free(lineW);
 889
 890     if (!fp) goto cleanup;
 891
 892     if (!size)
 893     {
 894         size = REG_VAL_BUF_SIZE;
 895         buf = heap_xalloc(size);
 896         *buf = 0;
 897         next = buf;
 898     }
 899     line = next;
 900
 901     while (next)
 902     {
 903         char *p = strpbrk(line, "\r\n");
 904         if (!p)
 905         {
 906             size_t len, count;
 907             len = strlen(next);
 908             memmove(buf, next, len + 1);
 909             if (size - len < 3)
 910             {
 911                 size *= 2;
 912                 buf = heap_xrealloc(buf, size);
 913             }
 914             if (!(count = fread(buf + len, 1, size - len - 1, fp)))
 915             {
 916                 next = NULL;
 917                 lineW = GetWideString(buf);
 918                 return lineW;
 919             }
 920             buf[len + count] = 0;
 921             next = buf;
 922             line = buf;
 923             continue;
 924         }
 925         next = p + 1;
 926         if (*p == '\r' && *(p + 1) == '\n') next++;
 927         *p = 0;
 928         lineW = GetWideString(line);
 929         return lineW;
 930     }
 931
 932 cleanup:
 933     lineW = NULL;
 934     if (size) heap_free(buf);
 935     size = 0;
 936     return NULL;
 937 }
 938
 939 static WCHAR *get_lineW(FILE *fp)
 940 {
 941     static size_t size;
 942     static WCHAR *buf, *next;
 943     WCHAR *line;
 944
 945     if (!fp) goto cleanup;
 946
 947     if (!size)
 948     {
 949         size = REG_VAL_BUF_SIZE;
 950         buf = heap_xalloc(size * sizeof(WCHAR));
 951         *buf = 0;
 952         next = buf;
 953     }
 954     line = next;
 955
 956     while (next)
 957     {
 958         static const WCHAR line_endings[] = {'\r','\n',0};
 959         WCHAR *p = strpbrkW(line, line_endings);
 960         if (!p)
 961         {
 962             size_t len, count;
 963             len = strlenW(next);
 964             memmove(buf, next, (len + 1) * sizeof(WCHAR));
 965             if (size - len < 3)
 966             {
 967                 size *= 2;
 968                 buf = heap_xrealloc(buf, size * sizeof(WCHAR));
 969             }
 970             if (!(count = fread(buf + len, sizeof(WCHAR), size - len - 1, fp)))
 971             {
 972                 next = NULL;
 973                 return buf;
 974             }
 975             buf[len + count] = 0;
 976             next = buf;
 977             line = buf;
 978             continue;
 979         }
 980         next = p + 1;
 981         if (*p == '\r' && *(p + 1) == '\n') next++;
 982         *p = 0;
 983         return line;
 984     }
 985
 986 cleanup:
 987     if (size) heap_free(buf);
 988     size = 0;
 989     return NULL;
 990 }
 991
 992 int reg_import(const WCHAR *filename)
 993 {
 994     FILE *fp;
 995     static const WCHAR rb_mode[] = {'r','b',0};
 996     BYTE s[2];
 997     struct parser parser;
 998     WCHAR *pos;
 999
1000     fp = _wfopen(filename, rb_mode);
1001     if (!fp)
1002     {
1003         output_message(STRING_FILE_NOT_FOUND, filename);
1004         return 1;
1005     }
1006
1007     if (fread(s, sizeof(WCHAR), 1, fp) != 1)
1008         goto error;
1009
1010     parser.is_unicode = (s[0] == 0xff && s[1] == 0xfe);
1011     get_line = parser.is_unicode ? get_lineW : get_lineA;
1012
1013     parser.file          = fp;
1014     parser.two_wchars[0] = s[0];
1015     parser.two_wchars[1] = s[1];
1016     parser.reg_version   = -1;
1017     parser.hkey          = NULL;
1018     parser.key_name      = NULL;
1019     parser.value_name    = NULL;
1020     parser.parse_type    = 0;
1021     parser.data_type     = 0;
1022     parser.data          = NULL;
1023     parser.data_size     = 0;
1024     parser.backslash     = FALSE;
1025     parser.state         = HEADER;
1026
1027     pos = parser.two_wchars;
1028
1029     /* parser main loop */
1030     while (pos)
1031         pos = (parser_funcs[parser.state])(&parser, pos);
1032
1033     if (parser.reg_version == REG_VERSION_INVALID)
1034         goto error;
1035
1036     heap_free(parser.value_name);
1037     close_key(&parser);
1038
1039     fclose(fp);
1040     return 0;
1041
1042 error:
1043     fclose(fp);
1044     return 1;
1045 }