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