programs/regedit/regproc.c

   1 /*
   2  * Registry processing routines. Routines, common for registry
   3  * processing frontends.
   4  *
   5  * Copyright 1999 Sylvain St-Germain
   6  * Copyright 2002 Andriy Palamarchuk
   7  * Copyright 2008 Alexander N. Sørnes <alex@thehandofagony.com>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include <errno.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <fcntl.h>
  28 #include <io.h>
  29 #include <windows.h>
  30 #include <wine/unicode.h>
  31 #include "regproc.h"
  32
  33 #define REG_VAL_BUF_SIZE        4096
  34
  35 extern const WCHAR* reg_class_namesW[];
  36
  37 static HKEY reg_class_keys[] = {
  38             HKEY_LOCAL_MACHINE, HKEY_USERS, HKEY_CLASSES_ROOT,
  39             HKEY_CURRENT_CONFIG, HKEY_CURRENT_USER, HKEY_DYN_DATA
  40         };
  41
  42 #define ARRAY_SIZE(A) (sizeof(A)/sizeof(*A))
  43
  44 /******************************************************************************
  45  * Allocates memory and converts input from multibyte to wide chars
  46  * Returned string must be freed by the caller
  47  */
  48 static WCHAR* GetWideString(const char* strA)
  49 {
  50     if(strA)
  51     {
  52         WCHAR* strW;
  53         int len = MultiByteToWideChar(CP_ACP, 0, strA, -1, NULL, 0);
  54
  55         strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
  56         CHECK_ENOUGH_MEMORY(strW);
  57         MultiByteToWideChar(CP_ACP, 0, strA, -1, strW, len);
  58         return strW;
  59     }
  60     return NULL;
  61 }
  62
  63 /******************************************************************************
  64  * Allocates memory and converts input from multibyte to wide chars
  65  * Returned string must be freed by the caller
  66  */
  67 static WCHAR* GetWideStringN(const char* strA, int chars, DWORD *len)
  68 {
  69     if(strA)
  70     {
  71         WCHAR* strW;
  72         *len = MultiByteToWideChar(CP_ACP, 0, strA, chars, NULL, 0);
  73
  74         strW = HeapAlloc(GetProcessHeap(), 0, *len * sizeof(WCHAR));
  75         CHECK_ENOUGH_MEMORY(strW);
  76         MultiByteToWideChar(CP_ACP, 0, strA, chars, strW, *len);
  77         return strW;
  78     }
  79     *len = 0;
  80     return NULL;
  81 }
  82
  83 /******************************************************************************
  84  * Allocates memory and converts input from wide chars to multibyte
  85  * Returned string must be freed by the caller
  86  */
  87 char* GetMultiByteString(const WCHAR* strW)
  88 {
  89     if(strW)
  90     {
  91         char* strA;
  92         int len = WideCharToMultiByte(CP_ACP, 0, strW, -1, NULL, 0, NULL, NULL);
  93
  94         strA = HeapAlloc(GetProcessHeap(), 0, len);
  95         CHECK_ENOUGH_MEMORY(strA);
  96         WideCharToMultiByte(CP_ACP, 0, strW, -1, strA, len, NULL, NULL);
  97         return strA;
  98     }
  99     return NULL;
 100 }
 101
 102 /******************************************************************************
 103  * Allocates memory and converts input from wide chars to multibyte
 104  * Returned string must be freed by the caller
 105  */
 106 static char* GetMultiByteStringN(const WCHAR* strW, int chars, DWORD* len)
 107 {
 108     if(strW)
 109     {
 110         char* strA;
 111         *len = WideCharToMultiByte(CP_ACP, 0, strW, chars, NULL, 0, NULL, NULL);
 112
 113         strA = HeapAlloc(GetProcessHeap(), 0, *len);
 114         CHECK_ENOUGH_MEMORY(strA);
 115         WideCharToMultiByte(CP_ACP, 0, strW, chars, strA, *len, NULL, NULL);
 116         return strA;
 117     }
 118     *len = 0;
 119     return NULL;
 120 }
 121
 122 static WCHAR *(*get_line)(FILE *);
 123
 124 /* parser definitions */
 125 enum parser_state
 126 {
 127     HEADER,              /* parsing the registry file version header */
 128     PARSE_WIN31_LINE,    /* parsing a Windows 3.1 registry line */
 129     LINE_START,          /* at the beginning of a registry line */
 130     KEY_NAME,            /* parsing a key name */
 131     DELETE_KEY,          /* deleting a registry key */
 132     DEFAULT_VALUE_NAME,  /* parsing a default value name */
 133     QUOTED_VALUE_NAME,   /* parsing a double-quoted value name */
 134     DATA_START,          /* preparing for data parsing operations */
 135     DELETE_VALUE,        /* deleting a registry value */
 136     DATA_TYPE,           /* parsing the registry data type */
 137     STRING_DATA,         /* parsing REG_SZ data */
 138     DWORD_DATA,          /* parsing DWORD data */
 139     HEX_DATA,            /* parsing REG_BINARY, REG_NONE, REG_EXPAND_SZ or REG_MULTI_SZ data */
 140     EOL_BACKSLASH,       /* preparing to parse multiple lines of hex data */
 141     HEX_MULTILINE,       /* parsing multiple lines of hex data */
 142     UNKNOWN_DATA,        /* parsing an unhandled or invalid data type */
 143     SET_VALUE,           /* adding a value to the registry */
 144     NB_PARSER_STATES
 145 };
 146
 147 struct parser
 148 {
 149     FILE              *file;           /* pointer to a registry file */
 150     WCHAR              two_wchars[2];  /* first two characters from the encoding check */
 151     BOOL               is_unicode;     /* parsing Unicode or ASCII data */
 152     short int          reg_version;    /* registry file version */
 153     HKEY               hkey;           /* current registry key */
 154     WCHAR             *key_name;       /* current key name */
 155     WCHAR             *value_name;     /* value name */
 156     DWORD              parse_type;     /* generic data type for parsing */
 157     DWORD              data_type;      /* data type */
 158     void              *data;           /* value data */
 159     DWORD              data_size;      /* size of the data (in bytes) */
 160     BOOL               backslash;      /* TRUE if the current line contains a backslash */
 161     enum parser_state  state;          /* current parser state */
 162 };
 163
 164 typedef WCHAR *(*parser_state_func)(struct parser *parser, WCHAR *pos);
 165
 166 /* parser state machine functions */
 167 static WCHAR *header_state(struct parser *parser, WCHAR *pos);
 168 static WCHAR *parse_win31_line_state(struct parser *parser, WCHAR *pos);
 169 static WCHAR *line_start_state(struct parser *parser, WCHAR *pos);
 170 static WCHAR *key_name_state(struct parser *parser, WCHAR *pos);
 171 static WCHAR *delete_key_state(struct parser *parser, WCHAR *pos);
 172 static WCHAR *default_value_name_state(struct parser *parser, WCHAR *pos);
 173 static WCHAR *quoted_value_name_state(struct parser *parser, WCHAR *pos);
 174 static WCHAR *data_start_state(struct parser *parser, WCHAR *pos);
 175 static WCHAR *delete_value_state(struct parser *parser, WCHAR *pos);
 176 static WCHAR *data_type_state(struct parser *parser, WCHAR *pos);
 177 static WCHAR *string_data_state(struct parser *parser, WCHAR *pos);
 178 static WCHAR *dword_data_state(struct parser *parser, WCHAR *pos);
 179 static WCHAR *hex_data_state(struct parser *parser, WCHAR *pos);
 180 static WCHAR *eol_backslash_state(struct parser *parser, WCHAR *pos);
 181 static WCHAR *hex_multiline_state(struct parser *parser, WCHAR *pos);
 182 static WCHAR *unknown_data_state(struct parser *parser, WCHAR *pos);
 183 static WCHAR *set_value_state(struct parser *parser, WCHAR *pos);
 184
 185 static const parser_state_func parser_funcs[NB_PARSER_STATES] =
 186 {
 187     header_state,              /* HEADER */
 188     parse_win31_line_state,    /* PARSE_WIN31_LINE */
 189     line_start_state,          /* LINE_START */
 190     key_name_state,            /* KEY_NAME */
 191     delete_key_state,          /* DELETE_KEY */
 192     default_value_name_state,  /* DEFAULT_VALUE_NAME */
 193     quoted_value_name_state,   /* QUOTED_VALUE_NAME */
 194     data_start_state,          /* DATA_START */
 195     delete_value_state,        /* DELETE_VALUE */
 196     data_type_state,           /* DATA_TYPE */
 197     string_data_state,         /* STRING_DATA */
 198     dword_data_state,          /* DWORD_DATA */
 199     hex_data_state,            /* HEX_DATA */
 200     eol_backslash_state,       /* EOL_BACKSLASH */
 201     hex_multiline_state,       /* HEX_MULTILINE */
 202     unknown_data_state,        /* UNKNOWN_DATA */
 203     set_value_state,           /* SET_VALUE */
 204 };
 205
 206 /* set the new parser state and return the previous one */
 207 static inline enum parser_state set_state(struct parser *parser, enum parser_state state)
 208 {
 209     enum parser_state ret = parser->state;
 210     parser->state = state;
 211     return ret;
 212 }
 213
 214 static void *resize_buffer(void *buf, size_t count)
 215 {
 216     void *new_buf;
 217
 218     if (buf)
 219         new_buf = HeapReAlloc(GetProcessHeap(), 0, buf, count);
 220     else
 221         new_buf = HeapAlloc(GetProcessHeap(), 0, count);
 222
 223     CHECK_ENOUGH_MEMORY(new_buf);
 224     return new_buf;
 225 }
 226
 227 /******************************************************************************
 228  * Converts a hex representation of a DWORD into a DWORD.
 229  */
 230 static BOOL convert_hex_to_dword(WCHAR *str, DWORD *dw)
 231 {
 232     WCHAR *p, *end;
 233     int count = 0;
 234
 235     while (*str == ' ' || *str == '\t') str++;
 236     if (!*str) goto error;
 237
 238     p = str;
 239     while (isxdigitW(*p))
 240     {
 241         count++;
 242         p++;
 243     }
 244     if (count > 8) goto error;
 245
 246     end = p;
 247     while (*p == ' ' || *p == '\t') p++;
 248     if (*p && *p != ';') goto error;
 249
 250     *end = 0;
 251     *dw = strtoulW(str, &end, 16);
 252     return TRUE;
 253
 254 error:
 255     return FALSE;
 256 }
 257
 258 /******************************************************************************
 259  * Converts comma-separated hex data into a binary string and modifies
 260  * the input parameter to skip the concatenating backslash, if found.
 261  *
 262  * Returns TRUE or FALSE to indicate whether parsing was successful.
 263  */
 264 static BOOL convert_hex_csv_to_hex(struct parser *parser, WCHAR **str)
 265 {
 266     size_t size;
 267     BYTE *d;
 268     WCHAR *s;
 269
 270     parser->backslash = FALSE;
 271
 272     /* The worst case is 1 digit + 1 comma per byte */
 273     size = ((lstrlenW(*str) + 1) / 2) + parser->data_size;
 274     parser->data = resize_buffer(parser->data, size);
 275
 276     s = *str;
 277     d = (BYTE *)parser->data + parser->data_size;
 278
 279     while (*s)
 280     {
 281         WCHAR *end;
 282         unsigned long wc;
 283
 284         wc = strtoulW(s, &end, 16);
 285         if (wc > 0xff) return FALSE;
 286
 287         if (s == end && wc == 0)
 288         {
 289             while (*end == ' ' || *end == '\t') end++;
 290             if (*end == '\\')
 291             {
 292                 parser->backslash = TRUE;
 293                 *str = end + 1;
 294                 return TRUE;
 295             }
 296             else if (*end == ';')
 297                 return TRUE;
 298             return FALSE;
 299         }
 300
 301         *d++ = wc;
 302         parser->data_size++;
 303
 304         if (*end && *end != ',')
 305         {
 306             while (*end == ' ' || *end == '\t') end++;
 307             if (*end && *end != ';') return FALSE;
 308             return TRUE;
 309         }
 310
 311         if (*end) end++;
 312         s = end;
 313     }
 314
 315     return TRUE;
 316 }
 317
 318 /******************************************************************************
 319  * Parses the data type of the registry value being imported and modifies
 320  * the input parameter to skip the string representation of the data type.
 321  *
 322  * Returns TRUE or FALSE to indicate whether a data type was found.
 323  */
 324 static BOOL parse_data_type(struct parser *parser, WCHAR **line)
 325 {
 326     struct data_type { const WCHAR *tag; int len; int type; int parse_type; };
 327
 328     static const WCHAR quote[] = {'"'};
 329     static const WCHAR hex[] = {'h','e','x',':'};
 330     static const WCHAR dword[] = {'d','w','o','r','d',':'};
 331     static const WCHAR hexp[] = {'h','e','x','('};
 332
 333     static const struct data_type data_types[] = {
 334     /*    tag    len  type         parse type    */
 335         { quote,  1,  REG_SZ,      REG_SZ },
 336         { hex,    4,  REG_BINARY,  REG_BINARY },
 337         { dword,  6,  REG_DWORD,   REG_DWORD },
 338         { hexp,   4,  -1,          REG_BINARY }, /* REG_NONE, REG_EXPAND_SZ, REG_MULTI_SZ */
 339         { NULL,   0,  0,           0 }
 340     };
 341
 342     const struct data_type *ptr;
 343
 344     for (ptr = data_types; ptr->tag; ptr++)
 345     {
 346         if (strncmpW(ptr->tag, *line, ptr->len))
 347             continue;
 348
 349         parser->parse_type = ptr->parse_type;
 350         parser->data_type = ptr->parse_type;
 351         *line += ptr->len;
 352
 353         if (ptr->type == -1)
 354         {
 355             WCHAR *end;
 356             DWORD val;
 357
 358             if (!**line || tolowerW((*line)[1]) == 'x')
 359                 return FALSE;
 360
 361             /* "hex(xx):" is special */
 362             val = wcstoul(*line, &end, 16);
 363             if (*end != ')' || *(end + 1) != ':' || (val == ~0u && errno == ERANGE))
 364                 return FALSE;
 365
 366             parser->data_type = val;
 367             *line = end + 2;
 368         }
 369         return TRUE;
 370     }
 371     return FALSE;
 372 }
 373
 374 /******************************************************************************
 375  * Replaces escape sequences with their character equivalents and
 376  * null-terminates the string on the first non-escaped double quote.
 377  *
 378  * Assigns a pointer to the remaining unparsed data in the line.
 379  * Returns TRUE or FALSE to indicate whether a closing double quote was found.
 380  */
 381 static BOOL REGPROC_unescape_string(WCHAR *str, WCHAR **unparsed)
 382 {
 383     int str_idx = 0;            /* current character under analysis */
 384     int val_idx = 0;            /* the last character of the unescaped string */
 385     int len = lstrlenW(str);
 386     BOOL ret;
 387
 388     for (str_idx = 0; str_idx < len; str_idx++, val_idx++) {
 389         if (str[str_idx] == '\\') {
 390             str_idx++;
 391             switch (str[str_idx]) {
 392             case 'n':
 393                 str[val_idx] = '\n';
 394                 break;
 395             case 'r':
 396                 str[val_idx] = '\r';
 397                 break;
 398             case '0':
 399                 str[val_idx] = '\0';
 400                 break;
 401             case '\\':
 402             case '"':
 403                 str[val_idx] = str[str_idx];
 404                 break;
 405             default:
 406                 if (!str[str_idx]) return FALSE;
 407                 output_message(STRING_ESCAPE_SEQUENCE, str[str_idx]);
 408                 str[val_idx] = str[str_idx];
 409                 break;
 410             }
 411         } else if (str[str_idx] == '"') {
 412             break;
 413         } else {
 414             str[val_idx] = str[str_idx];
 415         }
 416     }
 417
 418     ret = (str[str_idx] == '"');
 419     *unparsed = str + str_idx + 1;
 420     str[val_idx] = '\0';
 421     return ret;
 422 }
 423
 424 static HKEY parse_key_name(WCHAR *key_name, WCHAR **key_path)
 425 {
 426     unsigned int i;
 427
 428     if (!key_name) return 0;
 429
 430     *key_path = strchrW(key_name, '\\');
 431     if (*key_path) (*key_path)++;
 432
 433     for (i = 0; i < ARRAY_SIZE(reg_class_keys); i++)
 434     {
 435         int len = lstrlenW(reg_class_namesW[i]);
 436         if (!strncmpiW(key_name, reg_class_namesW[i], len) &&
 437            (key_name[len] == 0 || key_name[len] == '\\'))
 438         {
 439             return reg_class_keys[i];
 440         }
 441     }
 442
 443     return 0;
 444 }
 445
 446 static void close_key(struct parser *parser)
 447 {
 448     if (parser->hkey)
 449     {
 450         HeapFree(GetProcessHeap(), 0, parser->key_name);
 451         parser->key_name = NULL;
 452
 453         RegCloseKey(parser->hkey);
 454         parser->hkey = NULL;
 455     }
 456 }
 457
 458 /******************************************************************************
 459  * Opens the registry key given by the input path.
 460  * This key must be closed by calling close_key().
 461  */
 462 static LONG open_key(struct parser *parser, WCHAR *path)
 463 {
 464     HKEY key_class;
 465     WCHAR *key_path;
 466     LONG res;
 467
 468     close_key(parser);
 469
 470     /* Get the registry class */
 471     if (!path || !(key_class = parse_key_name(path, &key_path)))
 472         return ERROR_INVALID_PARAMETER;
 473
 474     res = RegCreateKeyExW(key_class, key_path, 0, NULL, REG_OPTION_NON_VOLATILE,
 475                           KEY_ALL_ACCESS, NULL, &parser->hkey, NULL);
 476
 477     if (res == ERROR_SUCCESS)
 478     {
 479         parser->key_name = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(path) + 1) * sizeof(WCHAR));
 480         CHECK_ENOUGH_MEMORY(parser->key_name);
 481         lstrcpyW(parser->key_name, path);
 482     }
 483     else
 484         parser->hkey = NULL;
 485
 486     return res;
 487 }
 488
 489 static void free_parser_data(struct parser *parser)
 490 {
 491     if (parser->parse_type == REG_DWORD || parser->parse_type == REG_BINARY)
 492         HeapFree(GetProcessHeap(), 0, parser->data);
 493
 494     parser->data = NULL;
 495     parser->data_size = 0;
 496 }
 497
 498 static void prepare_hex_string_data(struct parser *parser)
 499 {
 500     if (parser->data_type == REG_EXPAND_SZ || parser->data_type == REG_MULTI_SZ)
 501     {
 502         BYTE *data = parser->data;
 503
 504         if (data[parser->data_size - 1] != 0)
 505         {
 506             data[parser->data_size] = 0;
 507             parser->data_size++;
 508         }
 509
 510         if (!parser->is_unicode)
 511         {
 512             parser->data = GetWideStringN(parser->data, parser->data_size, &parser->data_size);
 513             parser->data_size *= sizeof(WCHAR);
 514             HeapFree(GetProcessHeap(), 0, data);
 515         }
 516     }
 517 }
 518
 519 enum reg_versions {
 520     REG_VERSION_31,
 521     REG_VERSION_40,
 522     REG_VERSION_50,
 523     REG_VERSION_FUZZY,
 524     REG_VERSION_INVALID
 525 };
 526
 527 static enum reg_versions parse_file_header(const WCHAR *s)
 528 {
 529     static const WCHAR header_31[] = {'R','E','G','E','D','I','T',0};
 530     static const WCHAR header_40[] = {'R','E','G','E','D','I','T','4',0};
 531     static const WCHAR header_50[] = {'W','i','n','d','o','w','s',' ',
 532                                       'R','e','g','i','s','t','r','y',' ','E','d','i','t','o','r',' ',
 533                                       'V','e','r','s','i','o','n',' ','5','.','0','0',0};
 534
 535     while (*s == ' ' || *s == '\t') s++;
 536
 537     if (!strcmpW(s, header_31))
 538         return REG_VERSION_31;
 539
 540     if (!strcmpW(s, header_40))
 541         return REG_VERSION_40;
 542
 543     if (!strcmpW(s, header_50))
 544         return REG_VERSION_50;
 545
 546     /* The Windows version accepts registry file headers beginning with "REGEDIT" and ending
 547      * with other characters, as long as "REGEDIT" appears at the start of the line. For example,
 548      * "REGEDIT 4", "REGEDIT9" and "REGEDIT4FOO" are all treated as valid file headers.
 549      * In all such cases, however, the contents of the registry file are not imported.
 550      */
 551     if (!strncmpW(s, header_31, 7)) /* "REGEDIT" without NUL */
 552         return REG_VERSION_FUZZY;
 553
 554     return REG_VERSION_INVALID;
 555 }
 556
 557 /* handler for parser HEADER state */
 558 static WCHAR *header_state(struct parser *parser, WCHAR *pos)
 559 {
 560     WCHAR *line, *header;
 561
 562     if (!(line = get_line(parser->file)))
 563         return NULL;
 564
 565     if (!parser->is_unicode)
 566     {
 567         header = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(line) + 3) * sizeof(WCHAR));
 568         CHECK_ENOUGH_MEMORY(header);
 569         header[0] = parser->two_wchars[0];
 570         header[1] = parser->two_wchars[1];
 571         lstrcpyW(header + 2, line);
 572         parser->reg_version = parse_file_header(header);
 573         HeapFree(GetProcessHeap(), 0, header);
 574     }
 575     else parser->reg_version = parse_file_header(line);
 576
 577     switch (parser->reg_version)
 578     {
 579     case REG_VERSION_31:
 580         set_state(parser, PARSE_WIN31_LINE);
 581         break;
 582     case REG_VERSION_40:
 583     case REG_VERSION_50:
 584         set_state(parser, LINE_START);
 585         break;
 586     default:
 587         get_line(NULL); /* Reset static variables */
 588         return NULL;
 589     }
 590
 591     return line;
 592 }
 593
 594 /* handler for parser PARSE_WIN31_LINE state */
 595 static WCHAR *parse_win31_line_state(struct parser *parser, WCHAR *pos)
 596 {
 597     WCHAR *line, *value;
 598     static WCHAR hkcr[] = {'H','K','E','Y','_','C','L','A','S','S','E','S','_','R','O','O','T'};
 599     unsigned int key_end = 0;
 600
 601     if (!(line = get_line(parser->file)))
 602         return NULL;
 603
 604     if (strncmpW(line, hkcr, ARRAY_SIZE(hkcr)))
 605         return line;
 606
 607     /* get key name */
 608     while (line[key_end] && !isspaceW(line[key_end])) key_end++;
 609
 610     value = line + key_end;
 611     while (*value == ' ' || *value == '\t') value++;
 612
 613     if (*value == '=') value++;
 614     if (*value == ' ') value++; /* at most one space is skipped */
 615
 616     line[key_end] = 0;
 617
 618     if (open_key(parser, line) != ERROR_SUCCESS)
 619     {
 620         output_message(STRING_OPEN_KEY_FAILED, line);
 621         return line;
 622     }
 623
 624     parser->value_name = NULL;
 625     parser->data_type = REG_SZ;
 626     parser->data = value;
 627     parser->data_size = (lstrlenW(value) + 1) * sizeof(WCHAR);
 628
 629     set_state(parser, SET_VALUE);
 630     return value;
 631 }
 632
 633 /* handler for parser LINE_START state */
 634 static WCHAR *line_start_state(struct parser *parser, WCHAR *pos)
 635 {
 636     WCHAR *line, *p;
 637
 638     if (!(line = get_line(parser->file)))
 639         return NULL;
 640
 641     for (p = line; *p; p++)
 642     {
 643         switch (*p)
 644         {
 645         case '[':
 646             set_state(parser, KEY_NAME);
 647             return p + 1;
 648         case '@':
 649             set_state(parser, DEFAULT_VALUE_NAME);
 650             return p;
 651         case '"':
 652             set_state(parser, QUOTED_VALUE_NAME);
 653             return p + 1;
 654         case ' ':
 655         case '\t':
 656             break;
 657         default:
 658             return p;
 659         }
 660     }
 661
 662     return p;
 663 }
 664
 665 /* handler for parser KEY_NAME state */
 666 static WCHAR *key_name_state(struct parser *parser, WCHAR *pos)
 667 {
 668     WCHAR *p = pos, *key_end;
 669
 670     if (*p == ' ' || *p == '\t' || !(key_end = strrchrW(p, ']')))
 671         goto done;
 672
 673     *key_end = 0;
 674
 675     if (*p == '-')
 676     {
 677         set_state(parser, DELETE_KEY);
 678         return p + 1;
 679     }
 680     else if (open_key(parser, p) != ERROR_SUCCESS)
 681         output_message(STRING_OPEN_KEY_FAILED, p);
 682
 683 done:
 684     set_state(parser, LINE_START);
 685     return p;
 686 }
 687
 688 /* handler for parser DELETE_KEY state */
 689 static WCHAR *delete_key_state(struct parser *parser, WCHAR *pos)
 690 {
 691     WCHAR *p = pos;
 692
 693     if (*p == 'H' || *p == 'h')
 694         delete_registry_key(p);
 695
 696     set_state(parser, LINE_START);
 697     return p;
 698 }
 699
 700 /* handler for parser DEFAULT_VALUE_NAME state */
 701 static WCHAR *default_value_name_state(struct parser *parser, WCHAR *pos)
 702 {
 703     HeapFree(GetProcessHeap(), 0, parser->value_name);
 704     parser->value_name = NULL;
 705
 706     set_state(parser, DATA_START);
 707     return pos + 1;
 708 }
 709
 710 /* handler for parser QUOTED_VALUE_NAME state */
 711 static WCHAR *quoted_value_name_state(struct parser *parser, WCHAR *pos)
 712 {
 713     WCHAR *val_name = pos, *p;
 714
 715     if (parser->value_name)
 716     {
 717         HeapFree(GetProcessHeap(), 0, parser->value_name);
 718         parser->value_name = NULL;
 719     }
 720
 721     if (!REGPROC_unescape_string(val_name, &p))
 722         goto invalid;
 723
 724     /* copy the value name in case we need to parse multiple lines and the buffer is overwritten */
 725     parser->value_name = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(val_name) + 1) * sizeof(WCHAR));
 726     CHECK_ENOUGH_MEMORY(parser->value_name);
 727     lstrcpyW(parser->value_name, val_name);
 728
 729     set_state(parser, DATA_START);
 730     return p;
 731
 732 invalid:
 733     set_state(parser, LINE_START);
 734     return p;
 735 }
 736
 737 /* handler for parser DATA_START state */
 738 static WCHAR *data_start_state(struct parser *parser, WCHAR *pos)
 739 {
 740     WCHAR *p = pos;
 741     unsigned int len;
 742
 743     while (*p == ' ' || *p == '\t') p++;
 744     if (*p != '=') goto done;
 745     p++;
 746     while (*p == ' ' || *p == '\t') p++;
 747
 748     /* trim trailing whitespace */
 749     len = strlenW(p);
 750     while (len > 0 && (p[len - 1] == ' ' || p[len - 1] == '\t')) len--;
 751     p[len] = 0;
 752
 753     if (*p == '-')
 754         set_state(parser, DELETE_VALUE);
 755     else
 756         set_state(parser, DATA_TYPE);
 757     return p;
 758
 759 done:
 760     set_state(parser, LINE_START);
 761     return p;
 762 }
 763
 764 /* handler for parser DELETE_VALUE state */
 765 static WCHAR *delete_value_state(struct parser *parser, WCHAR *pos)
 766 {
 767     WCHAR *p = pos + 1;
 768
 769     while (*p == ' ' || *p == '\t') p++;
 770     if (*p && *p != ';') goto done;
 771
 772     RegDeleteValueW(parser->hkey, parser->value_name);
 773
 774 done:
 775     set_state(parser, LINE_START);
 776     return p;
 777 }
 778
 779 /* handler for parser DATA_TYPE state */
 780 static WCHAR *data_type_state(struct parser *parser, WCHAR *pos)
 781 {
 782     WCHAR *line = pos;
 783
 784     if (!parse_data_type(parser, &line))
 785     {
 786         set_state(parser, LINE_START);
 787         return line;
 788     }
 789
 790     switch (parser->parse_type)
 791     {
 792     case REG_SZ:
 793         set_state(parser, STRING_DATA);
 794         break;
 795     case REG_DWORD:
 796         set_state(parser, DWORD_DATA);
 797         break;
 798     case REG_BINARY: /* all hex data types, including undefined */
 799         set_state(parser, HEX_DATA);
 800         break;
 801     default:
 802         set_state(parser, UNKNOWN_DATA);
 803     }
 804
 805     return line;
 806 }
 807
 808 /* handler for parser STRING_DATA state */
 809 static WCHAR *string_data_state(struct parser *parser, WCHAR *pos)
 810 {
 811     WCHAR *line;
 812
 813     parser->data = pos;
 814
 815     if (!REGPROC_unescape_string(parser->data, &line))
 816         goto invalid;
 817
 818     while (*line == ' ' || *line == '\t') line++;
 819     if (*line && *line != ';') goto invalid;
 820
 821     parser->data_size = (lstrlenW(parser->data) + 1) * sizeof(WCHAR);
 822
 823     set_state(parser, SET_VALUE);
 824     return line;
 825
 826 invalid:
 827     free_parser_data(parser);
 828     set_state(parser, LINE_START);
 829     return line;
 830 }
 831
 832 /* handler for parser DWORD_DATA state */
 833 static WCHAR *dword_data_state(struct parser *parser, WCHAR *pos)
 834 {
 835     WCHAR *line = pos;
 836
 837     parser->data = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD));
 838     CHECK_ENOUGH_MEMORY(parser->data);
 839
 840     if (!convert_hex_to_dword(line, parser->data))
 841         goto invalid;
 842
 843     parser->data_size = sizeof(DWORD);
 844
 845     set_state(parser, SET_VALUE);
 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 HEX_DATA state */
 855 static WCHAR *hex_data_state(struct parser *parser, WCHAR *pos)
 856 {
 857     WCHAR *line = pos;
 858
 859     if (!convert_hex_csv_to_hex(parser, &line))
 860         goto invalid;
 861
 862     if (parser->backslash)
 863     {
 864         set_state(parser, EOL_BACKSLASH);
 865         return line;
 866     }
 867
 868     prepare_hex_string_data(parser);
 869
 870     set_state(parser, SET_VALUE);
 871     return line;
 872
 873 invalid:
 874     free_parser_data(parser);
 875     set_state(parser, LINE_START);
 876     return line;
 877 }
 878
 879 /* handler for parser EOL_BACKSLASH state */
 880 static WCHAR *eol_backslash_state(struct parser *parser, WCHAR *pos)
 881 {
 882     WCHAR *p = pos;
 883
 884     while (*p == ' ' || *p == '\t') p++;
 885     if (*p && *p != ';') goto invalid;
 886
 887     set_state(parser, HEX_MULTILINE);
 888     return pos;
 889
 890 invalid:
 891     free_parser_data(parser);
 892     set_state(parser, LINE_START);
 893     return p;
 894 }
 895
 896 /* handler for parser HEX_MULTILINE state */
 897 static WCHAR *hex_multiline_state(struct parser *parser, WCHAR *pos)
 898 {
 899     WCHAR *line;
 900
 901     if (!(line = get_line(parser->file)))
 902     {
 903         prepare_hex_string_data(parser);
 904         set_state(parser, SET_VALUE);
 905         return pos;
 906     }
 907
 908     while (*line == ' ' || *line == '\t') line++;
 909     if (!*line || *line == ';') return line;
 910
 911     if (!isxdigitW(*line)) goto invalid;
 912
 913     set_state(parser, HEX_DATA);
 914     return line;
 915
 916 invalid:
 917     free_parser_data(parser);
 918     set_state(parser, LINE_START);
 919     return line;
 920 }
 921
 922 /* handler for parser UNKNOWN_DATA state */
 923 static WCHAR *unknown_data_state(struct parser *parser, WCHAR *pos)
 924 {
 925     output_message(STRING_UNKNOWN_DATA_FORMAT, parser->data_type);
 926
 927     set_state(parser, LINE_START);
 928     return pos;
 929 }
 930
 931 /* handler for parser SET_VALUE state */
 932 static WCHAR *set_value_state(struct parser *parser, WCHAR *pos)
 933 {
 934     RegSetValueExW(parser->hkey, parser->value_name, 0, parser->data_type,
 935                    parser->data, parser->data_size);
 936
 937     free_parser_data(parser);
 938
 939     if (parser->reg_version == REG_VERSION_31)
 940         set_state(parser, PARSE_WIN31_LINE);
 941     else
 942         set_state(parser, LINE_START);
 943
 944     return pos;
 945 }
 946
 947 static WCHAR *get_lineA(FILE *fp)
 948 {
 949     static WCHAR *lineW;
 950     static size_t size;
 951     static char *buf, *next;
 952     char *line;
 953
 954     HeapFree(GetProcessHeap(), 0, lineW);
 955
 956     if (!fp) goto cleanup;
 957
 958     if (!size)
 959     {
 960         size = REG_VAL_BUF_SIZE;
 961         buf = HeapAlloc(GetProcessHeap(), 0, size);
 962         CHECK_ENOUGH_MEMORY(buf);
 963         *buf = 0;
 964         next = buf;
 965     }
 966     line = next;
 967
 968     while (next)
 969     {
 970         char *p = strpbrk(line, "\r\n");
 971         if (!p)
 972         {
 973             size_t len, count;
 974             len = strlen(next);
 975             memmove(buf, next, len + 1);
 976             if (size - len < 3)
 977             {
 978                 char *new_buf = HeapReAlloc(GetProcessHeap(), 0, buf, size * 2);
 979                 CHECK_ENOUGH_MEMORY(new_buf);
 980                 buf = new_buf;
 981                 size *= 2;
 982             }
 983             if (!(count = fread(buf + len, 1, size - len - 1, fp)))
 984             {
 985                 next = NULL;
 986                 lineW = GetWideString(buf);
 987                 return lineW;
 988             }
 989             buf[len + count] = 0;
 990             next = buf;
 991             line = buf;
 992             continue;
 993         }
 994         next = p + 1;
 995         if (*p == '\r' && *(p + 1) == '\n') next++;
 996         *p = 0;
 997         lineW = GetWideString(line);
 998         return lineW;
 999     }
1000
1001 cleanup:
1002     lineW = NULL;
1003     if (size) HeapFree(GetProcessHeap(), 0, buf);
1004     size = 0;
1005     return NULL;
1006 }
1007
1008 static WCHAR *get_lineW(FILE *fp)
1009 {
1010     static size_t size;
1011     static WCHAR *buf, *next;
1012     WCHAR *line;
1013
1014     if (!fp) goto cleanup;
1015
1016     if (!size)
1017     {
1018         size = REG_VAL_BUF_SIZE;
1019         buf = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
1020         CHECK_ENOUGH_MEMORY(buf);
1021         *buf = 0;
1022         next = buf;
1023     }
1024     line = next;
1025
1026     while (next)
1027     {
1028         static const WCHAR line_endings[] = {'\r','\n',0};
1029         WCHAR *p = strpbrkW(line, line_endings);
1030         if (!p)
1031         {
1032             size_t len, count;
1033             len = strlenW(next);
1034             memmove(buf, next, (len + 1) * sizeof(WCHAR));
1035             if (size - len < 3)
1036             {
1037                 WCHAR *new_buf = HeapReAlloc(GetProcessHeap(), 0, buf, (size * 2) * sizeof(WCHAR));
1038                 CHECK_ENOUGH_MEMORY(new_buf);
1039                 buf = new_buf;
1040                 size *= 2;
1041             }
1042             if (!(count = fread(buf + len, sizeof(WCHAR), size - len - 1, fp)))
1043             {
1044                 next = NULL;
1045                 return buf;
1046             }
1047             buf[len + count] = 0;
1048             next = buf;
1049             line = buf;
1050             continue;
1051         }
1052         next = p + 1;
1053         if (*p == '\r' && *(p + 1) == '\n') next++;
1054         *p = 0;
1055         return line;
1056     }
1057
1058 cleanup:
1059     if (size) HeapFree(GetProcessHeap(), 0, buf);
1060     size = 0;
1061     return NULL;
1062 }
1063
1064 /******************************************************************************
1065  * Reads contents of the specified file into the registry.
1066  */
1067 BOOL import_registry_file(FILE *reg_file)
1068 {
1069     BYTE s[2];
1070     struct parser parser;
1071     WCHAR *pos;
1072
1073     if (!reg_file || (fread(s, 2, 1, reg_file) != 1))
1074         return FALSE;
1075
1076     parser.is_unicode = (s[0] == 0xff && s[1] == 0xfe);
1077     get_line = parser.is_unicode ? get_lineW : get_lineA;
1078
1079     parser.file          = reg_file;
1080     parser.two_wchars[0] = s[0];
1081     parser.two_wchars[1] = s[1];
1082     parser.reg_version   = -1;
1083     parser.hkey          = NULL;
1084     parser.key_name      = NULL;
1085     parser.value_name    = NULL;
1086     parser.parse_type    = 0;
1087     parser.data_type     = 0;
1088     parser.data          = NULL;
1089     parser.data_size     = 0;
1090     parser.backslash     = FALSE;
1091     parser.state         = HEADER;
1092
1093     pos = parser.two_wchars;
1094
1095     /* parser main loop */
1096     while (pos)
1097         pos = (parser_funcs[parser.state])(&parser, pos);
1098
1099     if (parser.reg_version == REG_VERSION_FUZZY || parser.reg_version == REG_VERSION_INVALID)
1100         return parser.reg_version == REG_VERSION_FUZZY;
1101
1102     HeapFree(GetProcessHeap(), 0, parser.value_name);
1103     close_key(&parser);
1104
1105     return TRUE;
1106 }
1107
1108 /******************************************************************************
1109  * Removes the registry key with all subkeys. Parses full key name.
1110  *
1111  * Parameters:
1112  * reg_key_name - full name of registry branch to delete. Ignored if is NULL,
1113  *      empty, points to register key class, does not exist.
1114  */
1115 void delete_registry_key(WCHAR *reg_key_name)
1116 {
1117     WCHAR *key_name = NULL;
1118     HKEY key_class;
1119
1120     if (!reg_key_name || !reg_key_name[0])
1121         return;
1122
1123     if (!(key_class = parse_key_name(reg_key_name, &key_name)))
1124     {
1125         if (key_name) *(key_name - 1) = 0;
1126         error_exit(STRING_INVALID_SYSTEM_KEY, reg_key_name);
1127     }
1128
1129     if (!key_name || !*key_name)
1130         error_exit(STRING_DELETE_FAILED, reg_key_name);
1131
1132     RegDeleteTreeW(key_class, key_name);
1133 }
1134
1135 static void REGPROC_write_line(FILE *fp, const WCHAR *str, BOOL unicode)
1136 {
1137     if (unicode)
1138         fwrite(str, sizeof(WCHAR), lstrlenW(str), fp);
1139     else
1140     {
1141         char *strA = GetMultiByteString(str);
1142         fputs(strA, fp);
1143         HeapFree(GetProcessHeap(), 0, strA);
1144     }
1145 }
1146
1147 static WCHAR *REGPROC_escape_string(WCHAR *str, size_t str_len, size_t *line_len)
1148 {
1149     size_t i, escape_count, pos;
1150     WCHAR *buf;
1151
1152     for (i = 0, escape_count = 0; i < str_len; i++)
1153     {
1154         WCHAR c = str[i];
1155         if (c == '\r' || c == '\n' || c == '\\' || c == '"' || c == '\0')
1156             escape_count++;
1157     }
1158
1159     buf = resize_buffer(NULL, (str_len + escape_count + 1) * sizeof(WCHAR));
1160
1161     for (i = 0, pos = 0; i < str_len; i++, pos++)
1162     {
1163         WCHAR c = str[i];
1164
1165         switch (c)
1166         {
1167         case '\r':
1168             buf[pos++] = '\\';
1169             buf[pos] = 'r';
1170             break;
1171         case '\n':
1172             buf[pos++] = '\\';
1173             buf[pos] = 'n';
1174             break;
1175         case '\\':
1176             buf[pos++] = '\\';
1177             buf[pos] = '\\';
1178             break;
1179         case '"':
1180             buf[pos++] = '\\';
1181             buf[pos] = '"';
1182             break;
1183         case '\0':
1184             buf[pos++] = '\\';
1185             buf[pos] = '0';
1186             break;
1187         default:
1188             buf[pos] = c;
1189         }
1190     }
1191
1192     buf[pos] = 0;
1193     *line_len = pos;
1194     return buf;
1195 }
1196
1197 static size_t export_value_name(FILE *fp, WCHAR *name, size_t len, BOOL unicode)
1198 {
1199     static const WCHAR quoted_fmt[] = {'"','%','s','"','=',0};
1200     static const WCHAR default_name[] = {'@','=',0};
1201     size_t line_len;
1202
1203     if (name && *name)
1204     {
1205         WCHAR *str = REGPROC_escape_string(name, len, &line_len);
1206         WCHAR *buf = resize_buffer(NULL, (line_len + 4) * sizeof(WCHAR));
1207         line_len = sprintfW(buf, quoted_fmt, str);
1208         REGPROC_write_line(fp, buf, unicode);
1209         HeapFree(GetProcessHeap(), 0, buf);
1210         HeapFree(GetProcessHeap(), 0, str);
1211     }
1212     else
1213     {
1214         line_len = lstrlenW(default_name);
1215         REGPROC_write_line(fp, default_name, unicode);
1216     }
1217
1218     return line_len;
1219 }
1220
1221 static void export_string_data(WCHAR **buf, WCHAR *data, size_t size)
1222 {
1223     size_t len, line_len;
1224     WCHAR *str;
1225     static const WCHAR fmt[] = {'"','%','s','"',0};
1226
1227     len = size / sizeof(WCHAR) - 1;
1228     str = REGPROC_escape_string(data, len, &line_len);
1229     *buf = resize_buffer(NULL, (line_len + 3) * sizeof(WCHAR));
1230     sprintfW(*buf, fmt, str);
1231     HeapFree(GetProcessHeap(), 0, str);
1232 }
1233
1234 static void export_dword_data(WCHAR **buf, DWORD *data)
1235 {
1236     static const WCHAR fmt[] = {'d','w','o','r','d',':','%','0','8','x',0};
1237
1238     *buf = resize_buffer(NULL, 15 * sizeof(WCHAR));
1239     sprintfW(*buf, fmt, *data);
1240 }
1241
1242 static size_t export_hex_data_type(FILE *fp, DWORD type, BOOL unicode)
1243 {
1244     static const WCHAR hex[] = {'h','e','x',':',0};
1245     static const WCHAR hexp_fmt[] = {'h','e','x','(','%','x',')',':',0};
1246     size_t line_len;
1247
1248     if (type == REG_BINARY)
1249     {
1250         line_len = lstrlenW(hex);
1251         REGPROC_write_line(fp, hex, unicode);
1252     }
1253     else
1254     {
1255         WCHAR *buf = resize_buffer(NULL, 15 * sizeof(WCHAR));
1256         line_len = sprintfW(buf, hexp_fmt, type);
1257         REGPROC_write_line(fp, buf, unicode);
1258         HeapFree(GetProcessHeap(), 0, buf);
1259     }
1260
1261     return line_len;
1262 }
1263
1264 #define MAX_HEX_CHARS 77
1265
1266 static void export_hex_data(FILE *fp, WCHAR **buf, DWORD type, DWORD line_len,
1267                             void *data, DWORD size, BOOL unicode)
1268 {
1269     static const WCHAR fmt[] = {'%','0','2','x',0};
1270     static const WCHAR hex_concat[] = {'\\','\r','\n',' ',' ',0};
1271     size_t num_commas, i, pos;
1272
1273     line_len += export_hex_data_type(fp, type, unicode);
1274
1275     if (!unicode && (type == REG_EXPAND_SZ || type == REG_MULTI_SZ))
1276         data = GetMultiByteStringN(data, size / sizeof(WCHAR), &size);
1277
1278     num_commas = size - 1;
1279     *buf = resize_buffer(NULL, (size * 3) * sizeof(WCHAR));
1280
1281     for (i = 0, pos = 0; i < size; i++)
1282     {
1283         pos += sprintfW(*buf + pos, fmt, ((BYTE *)data)[i]);
1284         if (i == num_commas) break;
1285         (*buf)[pos++] = ',';
1286         (*buf)[pos] = 0;
1287         line_len += 3;
1288
1289         if (line_len >= MAX_HEX_CHARS)
1290         {
1291             REGPROC_write_line(fp, *buf, unicode);
1292             REGPROC_write_line(fp, hex_concat, unicode);
1293             line_len = 2;
1294             pos = 0;
1295         }
1296     }
1297 }
1298
1299 static void export_newline(FILE *fp, BOOL unicode)
1300 {
1301     static const WCHAR newline[] = {'\r','\n',0};
1302
1303     REGPROC_write_line(fp, newline, unicode);
1304 }
1305
1306 static void export_data(FILE *fp, WCHAR *value_name, DWORD value_len, DWORD type,
1307                         void *data, size_t size, BOOL unicode)
1308 {
1309     WCHAR *buf = NULL;
1310     size_t line_len = export_value_name(fp, value_name, value_len, unicode);
1311
1312     switch (type)
1313     {
1314     case REG_SZ:
1315         export_string_data(&buf, data, size);
1316         break;
1317     case REG_DWORD:
1318         export_dword_data(&buf, data);
1319         break;
1320     case REG_NONE:
1321     case REG_EXPAND_SZ:
1322     case REG_BINARY:
1323     case REG_MULTI_SZ:
1324     default:
1325         export_hex_data(fp, &buf, type, line_len, data, size, unicode);
1326         break;
1327     }
1328
1329     REGPROC_write_line(fp, buf, unicode);
1330     HeapFree(GetProcessHeap(), 0, buf);
1331     export_newline(fp, unicode);
1332 }
1333
1334 static WCHAR *build_subkey_path(WCHAR *path, DWORD path_len, WCHAR *subkey_name, DWORD subkey_len)
1335 {
1336     WCHAR *subkey_path;
1337     static const WCHAR fmt[] = {'%','s','\\','%','s',0};
1338
1339     subkey_path = resize_buffer(NULL, (path_len + subkey_len + 2) * sizeof(WCHAR));
1340     sprintfW(subkey_path, fmt, path, subkey_name);
1341
1342     return subkey_path;
1343 }
1344
1345 static void export_key_name(FILE *fp, WCHAR *name, BOOL unicode)
1346 {
1347     static const WCHAR fmt[] = {'\r','\n','[','%','s',']','\r','\n',0};
1348     WCHAR *buf;
1349
1350     buf = resize_buffer(NULL, (lstrlenW(name) + 7) * sizeof(WCHAR));
1351     sprintfW(buf, fmt, name);
1352     REGPROC_write_line(fp, buf, unicode);
1353     HeapFree(GetProcessHeap(), 0, buf);
1354 }
1355
1356 #define MAX_SUBKEY_LEN   257
1357
1358 static int export_registry_data(FILE *fp, HKEY key, WCHAR *path, BOOL unicode)
1359 {
1360     LONG rc;
1361     DWORD max_value_len = 256, value_len;
1362     DWORD max_data_bytes = 2048, data_size;
1363     DWORD subkey_len;
1364     DWORD i, type, path_len;
1365     WCHAR *value_name, *subkey_name, *subkey_path;
1366     BYTE *data;
1367     HKEY subkey;
1368
1369     export_key_name(fp, path, unicode);
1370
1371     value_name = resize_buffer(NULL, max_value_len * sizeof(WCHAR));
1372     data = resize_buffer(NULL, max_data_bytes);
1373
1374     i = 0;
1375     for (;;)
1376     {
1377         value_len = max_value_len;
1378         data_size = max_data_bytes;
1379         rc = RegEnumValueW(key, i, value_name, &value_len, NULL, &type, data, &data_size);
1380         if (rc == ERROR_SUCCESS)
1381         {
1382             export_data(fp, value_name, value_len, type, data, data_size, unicode);
1383             i++;
1384         }
1385         else if (rc == ERROR_MORE_DATA)
1386         {
1387             if (data_size > max_data_bytes)
1388             {
1389                 max_data_bytes = data_size;
1390                 data = resize_buffer(data, max_data_bytes);
1391             }
1392             else
1393             {
1394                 max_value_len *= 2;
1395                 value_name = resize_buffer(value_name, max_value_len * sizeof(WCHAR));
1396             }
1397         }
1398         else break;
1399     }
1400
1401     HeapFree(GetProcessHeap(), 0, data);
1402     HeapFree(GetProcessHeap(), 0, value_name);
1403
1404     subkey_name = resize_buffer(NULL, MAX_SUBKEY_LEN * sizeof(WCHAR));
1405
1406     path_len = lstrlenW(path);
1407
1408     i = 0;
1409     for (;;)
1410     {
1411         subkey_len = MAX_SUBKEY_LEN;
1412         rc = RegEnumKeyExW(key, i, subkey_name, &subkey_len, NULL, NULL, NULL, NULL);
1413         if (rc == ERROR_SUCCESS)
1414         {
1415             subkey_path = build_subkey_path(path, path_len, subkey_name, subkey_len);
1416             if (!RegOpenKeyExW(key, subkey_name, 0, KEY_READ, &subkey))
1417             {
1418                 export_registry_data(fp, subkey, subkey_path, unicode);
1419                 RegCloseKey(subkey);
1420             }
1421             HeapFree(GetProcessHeap(), 0, subkey_path);
1422             i++;
1423         }
1424         else break;
1425     }
1426
1427     HeapFree(GetProcessHeap(), 0, subkey_name);
1428     return 0;
1429 }
1430
1431 static FILE *REGPROC_open_export_file(WCHAR *file_name, BOOL unicode)
1432 {
1433     FILE *file;
1434     static const WCHAR hyphen[] = {'-',0};
1435
1436     if (!strcmpW(file_name, hyphen))
1437     {
1438         file = stdout;
1439         _setmode(_fileno(file), _O_BINARY);
1440     }
1441     else
1442     {
1443         static const WCHAR wb_mode[] = {'w','b',0};
1444
1445         file = _wfopen(file_name, wb_mode);
1446         if (!file)
1447         {
1448             static const WCHAR regedit[] = {'r','e','g','e','d','i','t',0};
1449             _wperror(regedit);
1450             error_exit(STRING_CANNOT_OPEN_FILE, file_name);
1451         }
1452     }
1453
1454     if (unicode)
1455     {
1456         static const BYTE bom[] = {0xff,0xfe};
1457         static const WCHAR header[] = {'W','i','n','d','o','w','s',' ',
1458                                        'R','e','g','i','s','t','r','y',' ','E','d','i','t','o','r',' ',
1459                                        'V','e','r','s','i','o','n',' ','5','.','0','0','\r','\n'};
1460
1461         fwrite(bom, sizeof(BYTE), ARRAY_SIZE(bom), file);
1462         fwrite(header, sizeof(WCHAR), ARRAY_SIZE(header), file);
1463     }
1464     else
1465         fputs("REGEDIT4\r\n", file);
1466
1467     return file;
1468 }
1469
1470 static HKEY open_export_key(HKEY key_class, WCHAR *subkey, WCHAR *path)
1471 {
1472     HKEY key;
1473
1474     if (!RegOpenKeyExW(key_class, subkey, 0, KEY_READ, &key))
1475         return key;
1476
1477     output_message(STRING_OPEN_KEY_FAILED, path);
1478     return NULL;
1479 }
1480
1481 static BOOL export_key(WCHAR *file_name, WCHAR *path, BOOL unicode)
1482 {
1483     HKEY key_class, key;
1484     WCHAR *subkey;
1485     FILE *fp;
1486     BOOL ret;
1487
1488     if (!(key_class = parse_key_name(path, &subkey)))
1489     {
1490         if (subkey) *(subkey - 1) = 0;
1491         output_message(STRING_INVALID_SYSTEM_KEY, path);
1492         return FALSE;
1493     }
1494
1495     if (!(key = open_export_key(key_class, subkey, path)))
1496         return FALSE;
1497
1498     fp = REGPROC_open_export_file(file_name, unicode);
1499     ret = export_registry_data(fp, key, path, unicode);
1500     export_newline(fp, unicode);
1501     fclose(fp);
1502
1503     RegCloseKey(key);
1504     return ret;
1505 }
1506
1507 static BOOL export_all(WCHAR *file_name, WCHAR *path, BOOL unicode)
1508 {
1509     FILE *fp;
1510     int i;
1511     HKEY classes[] = {HKEY_LOCAL_MACHINE, HKEY_USERS}, key;
1512     WCHAR *class_name;
1513
1514     fp = REGPROC_open_export_file(file_name, unicode);
1515
1516     for (i = 0; i < ARRAY_SIZE(classes); i++)
1517     {
1518         if (!(key = open_export_key(classes[i], NULL, path)))
1519         {
1520             fclose(fp);
1521             return FALSE;
1522         }
1523
1524         class_name = resize_buffer(NULL, (lstrlenW(reg_class_namesW[i]) + 1) * sizeof(WCHAR));
1525         lstrcpyW(class_name, reg_class_namesW[i]);
1526
1527         export_registry_data(fp, classes[i], class_name, unicode);
1528
1529         HeapFree(GetProcessHeap(), 0, class_name);
1530         RegCloseKey(key);
1531     }
1532
1533     export_newline(fp, unicode);
1534     fclose(fp);
1535
1536     return TRUE;
1537 }
1538
1539 BOOL export_registry_key(WCHAR *file_name, WCHAR *path, DWORD format)
1540 {
1541     BOOL unicode = (format == REG_FORMAT_5);
1542
1543     if (path && *path)
1544         return export_key(file_name, path, unicode);
1545     else
1546         return export_all(file_name, path, unicode);
1547 }