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