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