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