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