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