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  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <limits.h>
  24 #include <stdio.h>
  25 #include <windows.h>
  26 #include <winnt.h>
  27 #include <winreg.h>
  28 #include <assert.h>
  29 #include "regproc.h"
  30
  31 #define REG_VAL_BUF_SIZE        4096
  32
  33 /* maximal number of characters in hexadecimal data line,
  34    not including '\' character */
  35 #define REG_FILE_HEX_LINE_LEN   76
  36
  37 static const CHAR *reg_class_names[] = {
  38                                      "HKEY_LOCAL_MACHINE", "HKEY_USERS", "HKEY_CLASSES_ROOT",
  39                                      "HKEY_CURRENT_CONFIG", "HKEY_CURRENT_USER", "HKEY_DYN_DATA"
  40                                  };
  41
  42 #define REG_CLASS_NUMBER (sizeof(reg_class_names) / sizeof(reg_class_names[0]))
  43
  44 static HKEY reg_class_keys[REG_CLASS_NUMBER] = {
  45             HKEY_LOCAL_MACHINE, HKEY_USERS, HKEY_CLASSES_ROOT,
  46             HKEY_CURRENT_CONFIG, HKEY_CURRENT_USER, HKEY_DYN_DATA
  47         };
  48
  49 /* return values */
  50 #define NOT_ENOUGH_MEMORY     1
  51 #define IO_ERROR              2
  52
  53 /* processing macros */
  54
  55 /* common check of memory allocation results */
  56 #define CHECK_ENOUGH_MEMORY(p) \
  57 if (!(p)) \
  58 { \
  59     fprintf(stderr,"%s: file %s, line %d: Not enough memory\n", \
  60             getAppName(), __FILE__, __LINE__); \
  61     exit(NOT_ENOUGH_MEMORY); \
  62 }
  63
  64 /******************************************************************************
  65  * Converts a hex representation of a DWORD into a DWORD.
  66  */
  67 static BOOL convertHexToDWord(char* str, DWORD *dw)
  68 {
  69     char dummy;
  70     if (strlen(str) > 8 || sscanf(str, "%x%c", dw, &dummy) != 1) {
  71         fprintf(stderr,"%s: ERROR, invalid hex value\n", getAppName());
  72         return FALSE;
  73     }
  74     return TRUE;
  75 }
  76
  77 /******************************************************************************
  78  * Converts a hex comma separated values list into a binary string.
  79  */
  80 static BYTE* convertHexCSVToHex(char *str, DWORD *size)
  81 {
  82     char *s;
  83     BYTE *d, *data;
  84
  85     /* The worst case is 1 digit + 1 comma per byte */
  86     *size=(strlen(str)+1)/2;
  87     data=HeapAlloc(GetProcessHeap(), 0, *size);
  88     CHECK_ENOUGH_MEMORY(data);
  89
  90     s = str;
  91     d = data;
  92     *size=0;
  93     while (*s != '\0') {
  94         UINT wc;
  95         char dummy;
  96
  97         if (s[1] != ',' && s[1] != '\0' && s[2] != ',' && s[2] != '\0') {
  98             fprintf(stderr,"%s: ERROR converting CSV hex stream. Invalid sequence at '%s'\n",
  99                     getAppName(), s);
 100             HeapFree(GetProcessHeap(), 0, data);
 101             return NULL;
 102         }
 103         if (sscanf(s, "%x%c", &wc, &dummy) < 1 || dummy != ',') {
 104             fprintf(stderr,"%s: ERROR converting CSV hex stream. Invalid value at '%s'\n",
 105                     getAppName(), s);
 106             HeapFree(GetProcessHeap(), 0, data);
 107             return NULL;
 108         }
 109         *d++ =(BYTE)wc;
 110         (*size)++;
 111
 112         /* Skip one or two digits and any comma */
 113         while (*s && *s!=',') s++;
 114         if (*s) s++;
 115     }
 116
 117     return data;
 118 }
 119
 120 /******************************************************************************
 121  * This function returns the HKEY associated with the data type encoded in the
 122  * value.  It modifies the input parameter (key value) in order to skip this
 123  * "now useless" data type information.
 124  *
 125  * Note: Updated based on the algorithm used in 'server/registry.c'
 126  */
 127 static DWORD getDataType(LPSTR *lpValue, DWORD* parse_type)
 128 {
 129     struct data_type { const char *tag; int len; int type; int parse_type; };
 130
 131     static const struct data_type data_types[] = {                   /* actual type */  /* type to assume for parsing */
 132                 { "\"",        1,   REG_SZ,              REG_SZ },
 133                 { "str:\"",    5,   REG_SZ,              REG_SZ },
 134                 { "str(2):\"", 8,   REG_EXPAND_SZ,       REG_SZ },
 135                 { "hex:",      4,   REG_BINARY,          REG_BINARY },
 136                 { "dword:",    6,   REG_DWORD,           REG_DWORD },
 137                 { "hex(",      4,   -1,                  REG_BINARY },
 138                 { NULL,        0,    0,                  0 }
 139             };
 140
 141     const struct data_type *ptr;
 142     int type;
 143
 144     for (ptr = data_types; ptr->tag; ptr++) {
 145         if (memcmp( ptr->tag, *lpValue, ptr->len ))
 146             continue;
 147
 148         /* Found! */
 149         *parse_type = ptr->parse_type;
 150         type=ptr->type;
 151         *lpValue+=ptr->len;
 152         if (type == -1) {
 153             char* end;
 154             /* "hex(xx):" is special */
 155             type = (int)strtoul( *lpValue , &end, 16 );
 156             if (**lpValue=='\0' || *end!=')' || *(end+1)!=':') {
 157                 type=REG_NONE;
 158             } else {
 159                 *lpValue=end+2;
 160             }
 161         }
 162         return type;
 163     }
 164     *parse_type=REG_NONE;
 165     return REG_NONE;
 166 }
 167
 168 /******************************************************************************
 169  * Replaces escape sequences with the characters.
 170  */
 171 static void REGPROC_unescape_string(LPSTR str)
 172 {
 173     int str_idx = 0;            /* current character under analysis */
 174     int val_idx = 0;            /* the last character of the unescaped string */
 175     int len = strlen(str);
 176     for (str_idx = 0; str_idx < len; str_idx++, val_idx++) {
 177         if (str[str_idx] == '\\') {
 178             str_idx++;
 179             switch (str[str_idx]) {
 180             case 'n':
 181                 str[val_idx] = '\n';
 182                 break;
 183             case '\\':
 184             case '"':
 185                 str[val_idx] = str[str_idx];
 186                 break;
 187             default:
 188                 fprintf(stderr,"Warning! Unrecognized escape sequence: \\%c'\n",
 189                         str[str_idx]);
 190                 str[val_idx] = str[str_idx];
 191                 break;
 192             }
 193         } else {
 194             str[val_idx] = str[str_idx];
 195         }
 196     }
 197     str[val_idx] = '\0';
 198 }
 199
 200 /******************************************************************************
 201  * Parses HKEY_SOME_ROOT\some\key\path to get the root key handle and
 202  * extract the key path (what comes after the first '\').
 203  */
 204 static BOOL parseKeyName(LPSTR lpKeyName, HKEY *hKey, LPSTR *lpKeyPath)
 205 {
 206     LPSTR lpSlash;
 207     unsigned int i, len;
 208
 209     if (lpKeyName == NULL)
 210         return FALSE;
 211
 212     lpSlash = strchr(lpKeyName, '\\');
 213     if (lpSlash)
 214     {
 215         len = lpSlash-lpKeyName;
 216     }
 217     else
 218     {
 219         len = strlen(lpKeyName);
 220         lpSlash = lpKeyName+len;
 221     }
 222     *hKey = NULL;
 223     for (i = 0; i < REG_CLASS_NUMBER; i++) {
 224         if (strncmp(lpKeyName, reg_class_names[i], len) == 0 &&
 225             len == strlen(reg_class_names[i])) {
 226             *hKey = reg_class_keys[i];
 227             break;
 228         }
 229     }
 230     if (*hKey == NULL)
 231         return FALSE;
 232
 233     if (*lpSlash != '\0')
 234         lpSlash++;
 235     *lpKeyPath = lpSlash;
 236     return TRUE;
 237 }
 238
 239 /* Globals used by the setValue() & co */
 240 static LPSTR currentKeyName;
 241 static HKEY  currentKeyHandle = NULL;
 242
 243 /******************************************************************************
 244  * Sets the value with name val_name to the data in val_data for the currently
 245  * opened key.
 246  *
 247  * Parameters:
 248  * val_name - name of the registry value
 249  * val_data - registry value data
 250  */
 251 static LONG setValue(LPSTR val_name, LPSTR val_data)
 252 {
 253     LONG res;
 254     DWORD  dwDataType, dwParseType;
 255     LPBYTE lpbData;
 256     DWORD  dwData, dwLen;
 257
 258     if ( (val_name == NULL) || (val_data == NULL) )
 259         return ERROR_INVALID_PARAMETER;
 260
 261     if (strcmp(val_data, "-") == 0)
 262     {
 263         res=RegDeleteValue(currentKeyHandle,val_name);
 264         return (res == ERROR_FILE_NOT_FOUND ? ERROR_SUCCESS : res);
 265     }
 266
 267     /* Get the data type stored into the value field */
 268     dwDataType = getDataType(&val_data, &dwParseType);
 269
 270     if (dwParseType == REG_SZ)          /* no conversion for string */
 271     {
 272         REGPROC_unescape_string(val_data);
 273         /* Compute dwLen after REGPROC_unescape_string because it may
 274          * have changed the string length and we don't want to store
 275          * the extra garbage in the registry.
 276          */
 277         dwLen = strlen(val_data);
 278         if (dwLen>0 && val_data[dwLen-1]=='"')
 279         {
 280             dwLen--;
 281             val_data[dwLen]='\0';
 282         }
 283         lpbData = (BYTE*) val_data;
 284     }
 285     else if (dwParseType == REG_DWORD)  /* Convert the dword types */
 286     {
 287         if (!convertHexToDWord(val_data, &dwData))
 288             return ERROR_INVALID_DATA;
 289         lpbData = (BYTE*)&dwData;
 290         dwLen = sizeof(dwData);
 291     }
 292     else if (dwParseType == REG_BINARY) /* Convert the binary data */
 293     {
 294         lpbData = convertHexCSVToHex(val_data, &dwLen);
 295         if (!lpbData)
 296             return ERROR_INVALID_DATA;
 297     }
 298     else                                /* unknown format */
 299     {
 300         fprintf(stderr,"%s: ERROR, unknown data format\n", getAppName());
 301         return ERROR_INVALID_DATA;
 302     }
 303
 304     res = RegSetValueEx(
 305                currentKeyHandle,
 306                val_name,
 307                0,                  /* Reserved */
 308                dwDataType,
 309                lpbData,
 310                dwLen);
 311     if (dwParseType == REG_BINARY)
 312         HeapFree(GetProcessHeap(), 0, lpbData);
 313     return res;
 314 }
 315
 316 /******************************************************************************
 317  * A helper function for processRegEntry() that opens the current key.
 318  * That key must be closed by calling closeKey().
 319  */
 320 static LONG openKey(LPSTR stdInput)
 321 {
 322     HKEY keyClass;
 323     LPSTR keyPath;
 324     DWORD dwDisp;
 325     LONG res;
 326
 327     /* Sanity checks */
 328     if (stdInput == NULL)
 329         return ERROR_INVALID_PARAMETER;
 330
 331     /* Get the registry class */
 332     if (!parseKeyName(stdInput, &keyClass, &keyPath))
 333         return ERROR_INVALID_PARAMETER;
 334
 335     res = RegCreateKeyEx(
 336                keyClass,                 /* Class     */
 337                keyPath,                  /* Sub Key   */
 338                0,                        /* MUST BE 0 */
 339                NULL,                     /* object type */
 340                REG_OPTION_NON_VOLATILE,  /* option, REG_OPTION_NON_VOLATILE ... */
 341                KEY_ALL_ACCESS,           /* access mask, KEY_ALL_ACCESS */
 342                NULL,                     /* security attribute */
 343                &currentKeyHandle,        /* result */
 344                &dwDisp);                 /* disposition, REG_CREATED_NEW_KEY or
 345                                                         REG_OPENED_EXISTING_KEY */
 346
 347     if (res == ERROR_SUCCESS)
 348     {
 349         currentKeyName = HeapAlloc(GetProcessHeap(), 0, strlen(stdInput)+1);
 350         CHECK_ENOUGH_MEMORY(currentKeyName);
 351         strcpy(currentKeyName, stdInput);
 352     }
 353     else
 354     {
 355         currentKeyHandle = NULL;
 356     }
 357
 358     return res;
 359
 360 }
 361
 362 /******************************************************************************
 363  * Close the currently opened key.
 364  */
 365 static void closeKey(void)
 366 {
 367     if (currentKeyHandle)
 368     {
 369         HeapFree(GetProcessHeap(), 0, currentKeyName);
 370         RegCloseKey(currentKeyHandle);
 371         currentKeyHandle = NULL;
 372     }
 373 }
 374
 375 /******************************************************************************
 376  * This function is a wrapper for the setValue function.  It prepares the
 377  * land and clean the area once completed.
 378  * Note: this function modifies the line parameter.
 379  *
 380  * line - registry file unwrapped line. Should have the registry value name and
 381  *      complete registry value data.
 382  */
 383 static void processSetValue(LPSTR line)
 384 {
 385     LPSTR val_name;                   /* registry value name   */
 386     LPSTR val_data;                   /* registry value data   */
 387
 388     int line_idx = 0;                 /* current character under analysis */
 389     LONG res;
 390
 391     /* get value name */
 392     if (line[line_idx] == '@' && line[line_idx + 1] == '=') {
 393         line[line_idx] = '\0';
 394         val_name = line;
 395         line_idx++;
 396     } else if (line[line_idx] == '\"') {
 397         line_idx++;
 398         val_name = line + line_idx;
 399         while (TRUE) {
 400             if (line[line_idx] == '\\')   /* skip escaped character */
 401             {
 402                 line_idx += 2;
 403             } else {
 404                 if (line[line_idx] == '\"') {
 405                     line[line_idx] = '\0';
 406                     line_idx++;
 407                     break;
 408                 } else {
 409                     line_idx++;
 410                 }
 411             }
 412         }
 413         if (line[line_idx] != '=') {
 414             line[line_idx] = '\"';
 415             fprintf(stderr,"Warning! unrecognized line:\n%s\n", line);
 416             return;
 417         }
 418
 419     } else {
 420         fprintf(stderr,"Warning! unrecognized line:\n%s\n", line);
 421         return;
 422     }
 423     line_idx++;                   /* skip the '=' character */
 424     val_data = line + line_idx;
 425
 426     REGPROC_unescape_string(val_name);
 427     res = setValue(val_name, val_data);
 428     if ( res != ERROR_SUCCESS )
 429         fprintf(stderr,"%s: ERROR Key %s not created. Value: %s, Data: %s\n",
 430                 getAppName(),
 431                 currentKeyName,
 432                 val_name,
 433                 val_data);
 434 }
 435
 436 /******************************************************************************
 437  * This function receives the currently read entry and performs the
 438  * corresponding action.
 439  */
 440 static void processRegEntry(LPSTR stdInput)
 441 {
 442     /*
 443      * We encountered the end of the file, make sure we
 444      * close the opened key and exit
 445      */
 446     if (stdInput == NULL) {
 447         closeKey();
 448         return;
 449     }
 450
 451     if      ( stdInput[0] == '[')      /* We are reading a new key */
 452     {
 453         LPSTR keyEnd;
 454         closeKey();                    /* Close the previous key */
 455
 456         /* Get rid of the square brackets */
 457         stdInput++;
 458         keyEnd = strrchr(stdInput, ']');
 459         if (keyEnd)
 460             *keyEnd='\0';
 461
 462         /* delete the key if we encounter '-' at the start of reg key */
 463         if ( stdInput[0] == '-')
 464             delete_registry_key(stdInput+1);
 465         else if ( openKey(stdInput) != ERROR_SUCCESS )
 466             fprintf(stderr,"%s: setValue failed to open key %s\n",
 467                     getAppName(), stdInput);
 468     } else if( currentKeyHandle &&
 469                (( stdInput[0] == '@') || /* reading a default @=data pair */
 470                 ( stdInput[0] == '\"'))) /* reading a new value=data pair */
 471     {
 472         processSetValue(stdInput);
 473     } else
 474     {
 475         /* Since we are assuming that the file format is valid we must be
 476          * reading a blank line which indicates the end of this key processing
 477          */
 478         closeKey();
 479     }
 480 }
 481
 482 /******************************************************************************
 483  * Processes a registry file.
 484  * Correctly processes comments (in # form), line continuation.
 485  *
 486  * Parameters:
 487  *   in - input stream to read from
 488  */
 489 void processRegLines(FILE *in)
 490 {
 491     LPSTR line           = NULL;  /* line read from input stream */
 492     ULONG lineSize       = REG_VAL_BUF_SIZE;
 493
 494     line = HeapAlloc(GetProcessHeap(), 0, lineSize);
 495     CHECK_ENOUGH_MEMORY(line);
 496
 497     while (!feof(in)) {
 498         LPSTR s; /* The pointer into line for where the current fgets should read */
 499         s = line;
 500         for (;;) {
 501             size_t size_remaining;
 502             int size_to_get;
 503             char *s_eol; /* various local uses */
 504
 505             /* Do we need to expand the buffer ? */
 506             assert (s >= line && s <= line + lineSize);
 507             size_remaining = lineSize - (s-line);
 508             if (size_remaining < 2) /* room for 1 character and the \0 */
 509             {
 510                 char *new_buffer;
 511                 size_t new_size = lineSize + REG_VAL_BUF_SIZE;
 512                 if (new_size > lineSize) /* no arithmetic overflow */
 513                     new_buffer = HeapReAlloc (GetProcessHeap(), 0, line, new_size);
 514                 else
 515                     new_buffer = NULL;
 516                 CHECK_ENOUGH_MEMORY(new_buffer);
 517                 line = new_buffer;
 518                 s = line + lineSize - size_remaining;
 519                 lineSize = new_size;
 520                 size_remaining = lineSize - (s-line);
 521             }
 522
 523             /* Get as much as possible into the buffer, terminated either by
 524              * eof, error, eol or getting the maximum amount.  Abort on error.
 525              */
 526             size_to_get = (size_remaining > INT_MAX ? INT_MAX : size_remaining);
 527             if (NULL == fgets (s, size_to_get, in)) {
 528                 if (ferror(in)) {
 529                     perror ("While reading input");
 530                     exit (IO_ERROR);
 531                 } else {
 532                     assert (feof(in));
 533                     *s = '\0';
 534                     /* It is not clear to me from the definition that the
 535                      * contents of the buffer are well defined on detecting
 536                      * an eof without managing to read anything.
 537                      */
 538                 }
 539             }
 540
 541             /* If we didn't read the eol nor the eof go around for the rest */
 542             s_eol = strchr (s, '\n');
 543             if (!feof (in) && !s_eol) {
 544                 s = strchr (s, '\0');
 545                 /* It should be s + size_to_get - 1 but this is safer */
 546                 continue;
 547             }
 548
 549             /* If it is a comment line then discard it and go around again */
 550             if (line [0] == '#') {
 551                 s = line;
 552                 continue;
 553             }
 554
 555             /* Remove any line feed.  Leave s_eol on the \0 */
 556             if (s_eol) {
 557                 *s_eol = '\0';
 558                 if (s_eol > line && *(s_eol-1) == '\r')
 559                     *--s_eol = '\0';
 560             } else
 561                 s_eol = strchr (s, '\0');
 562
 563             /* If there is a concatenating \\ then go around again */
 564             if (s_eol > line && *(s_eol-1) == '\\') {
 565                 int c;
 566                 s = s_eol-1;
 567                 /* The following error protection could be made more self-
 568                  * correcting but I thought it not worth trying.
 569                  */
 570                 if ((c = fgetc (in)) == EOF || c != ' ' ||
 571                         (c = fgetc (in)) == EOF || c != ' ')
 572                     fprintf(stderr,"%s: ERROR - invalid continuation.\n",
 573                             getAppName());
 574                 continue;
 575             }
 576
 577             break; /* That is the full virtual line */
 578         }
 579
 580         processRegEntry(line);
 581     }
 582     processRegEntry(NULL);
 583
 584     HeapFree(GetProcessHeap(), 0, line);
 585 }
 586
 587 /****************************************************************************
 588  * REGPROC_print_error
 589  *
 590  * Print the message for GetLastError
 591  */
 592
 593 static void REGPROC_print_error(void)
 594 {
 595     LPVOID lpMsgBuf;
 596     DWORD error_code;
 597     int status;
 598
 599     error_code = GetLastError ();
 600     status = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
 601                            NULL, error_code, 0, (LPTSTR) &lpMsgBuf, 0, NULL);
 602     if (!status) {
 603         fprintf(stderr,"%s: Cannot display message for error %d, status %d\n",
 604                 getAppName(), error_code, GetLastError());
 605         exit(1);
 606     }
 607     puts(lpMsgBuf);
 608     LocalFree((HLOCAL)lpMsgBuf);
 609     exit(1);
 610 }
 611
 612 /******************************************************************************
 613  * Checks whether the buffer has enough room for the string or required size.
 614  * Resizes the buffer if necessary.
 615  *
 616  * Parameters:
 617  * buffer - pointer to a buffer for string
 618  * len - current length of the buffer in characters.
 619  * required_len - length of the string to place to the buffer in characters.
 620  *   The length does not include the terminating null character.
 621  */
 622 static void REGPROC_resize_char_buffer(CHAR **buffer, DWORD *len, DWORD required_len)
 623 {
 624     required_len++;
 625     if (required_len > *len) {
 626         *len = required_len;
 627         if (!*buffer)
 628             *buffer = HeapAlloc(GetProcessHeap(), 0, *len * sizeof(**buffer));
 629         else
 630             *buffer = HeapReAlloc(GetProcessHeap(), 0, *buffer, *len * sizeof(**buffer));
 631         CHECK_ENOUGH_MEMORY(*buffer);
 632     }
 633 }
 634
 635 /******************************************************************************
 636  * Prints string str to file
 637  */
 638 static void REGPROC_export_string(FILE *file, CHAR *str)
 639 {
 640     size_t len = strlen(str);
 641     size_t i;
 642
 643     /* escaping characters */
 644     for (i = 0; i < len; i++) {
 645         CHAR c = str[i];
 646         switch (c) {
 647         case '\\':
 648             fputs("\\\\", file);
 649             break;
 650         case '\"':
 651             fputs("\\\"", file);
 652             break;
 653         case '\n':
 654             fputs("\\\n", file);
 655             break;
 656         default:
 657             fputc(c, file);
 658             break;
 659         }
 660     }
 661 }
 662
 663 /******************************************************************************
 664  * Writes contents of the registry key to the specified file stream.
 665  *
 666  * Parameters:
 667  * file - writable file stream to export registry branch to.
 668  * key - registry branch to export.
 669  * reg_key_name_buf - name of the key with registry class.
 670  *      Is resized if necessary.
 671  * reg_key_name_len - length of the buffer for the registry class in characters.
 672  * val_name_buf - buffer for storing value name.
 673  *      Is resized if necessary.
 674  * val_name_len - length of the buffer for storing value names in characters.
 675  * val_buf - buffer for storing values while extracting.
 676  *      Is resized if necessary.
 677  * val_size - size of the buffer for storing values in bytes.
 678  */
 679 static void export_hkey(FILE *file, HKEY key,
 680                  CHAR **reg_key_name_buf, DWORD *reg_key_name_len,
 681                  CHAR **val_name_buf, DWORD *val_name_len,
 682                  BYTE **val_buf, DWORD *val_size)
 683 {
 684     DWORD max_sub_key_len;
 685     DWORD max_val_name_len;
 686     DWORD max_val_size;
 687     DWORD curr_len;
 688     DWORD i;
 689     BOOL more_data;
 690     LONG ret;
 691
 692     /* get size information and resize the buffers if necessary */
 693     if (RegQueryInfoKey(key, NULL, NULL, NULL, NULL,
 694                         &max_sub_key_len, NULL,
 695                         NULL, &max_val_name_len, &max_val_size, NULL, NULL
 696                        ) != ERROR_SUCCESS) {
 697         REGPROC_print_error();
 698     }
 699     curr_len = strlen(*reg_key_name_buf);
 700     REGPROC_resize_char_buffer(reg_key_name_buf, reg_key_name_len,
 701                                max_sub_key_len + curr_len + 1);
 702     REGPROC_resize_char_buffer(val_name_buf, val_name_len,
 703                                max_val_name_len);
 704     if (max_val_size > *val_size) {
 705         *val_size = max_val_size;
 706         if (!*val_buf) *val_buf = HeapAlloc(GetProcessHeap(), 0, *val_size);
 707         else *val_buf = HeapReAlloc(GetProcessHeap(), 0, *val_buf, *val_size);
 708         CHECK_ENOUGH_MEMORY(val_buf);
 709     }
 710
 711     /* output data for the current key */
 712     fputs("\n[", file);
 713     fputs(*reg_key_name_buf, file);
 714     fputs("]\n", file);
 715     /* print all the values */
 716     i = 0;
 717     more_data = TRUE;
 718     while(more_data) {
 719         DWORD value_type;
 720         DWORD val_name_len1 = *val_name_len;
 721         DWORD val_size1 = *val_size;
 722         ret = RegEnumValue(key, i, *val_name_buf, &val_name_len1, NULL,
 723                            &value_type, *val_buf, &val_size1);
 724         if (ret != ERROR_SUCCESS) {
 725             more_data = FALSE;
 726             if (ret != ERROR_NO_MORE_ITEMS) {
 727                 REGPROC_print_error();
 728             }
 729         } else {
 730             i++;
 731
 732             if ((*val_name_buf)[0]) {
 733                 fputs("\"", file);
 734                 REGPROC_export_string(file, *val_name_buf);
 735                 fputs("\"=", file);
 736             } else {
 737                 fputs("@=", file);
 738             }
 739
 740             switch (value_type) {
 741             case REG_SZ:
 742             case REG_EXPAND_SZ:
 743                 fputs("\"", file);
 744                 REGPROC_export_string(file, (char*) *val_buf);
 745                 fputs("\"\n", file);
 746                 break;
 747
 748             case REG_DWORD:
 749                 fprintf(file, "dword:%08x\n", *((DWORD *)*val_buf));
 750                 break;
 751
 752             default:
 753                 fprintf(stderr,"%s: warning - unsupported registry format '%d', "
 754                         "treat as binary\n",
 755                         getAppName(), value_type);
 756                 fprintf(stderr,"key name: \"%s\"\n", *reg_key_name_buf);
 757                 fprintf(stderr,"value name:\"%s\"\n\n", *val_name_buf);
 758                 /* falls through */
 759             case REG_MULTI_SZ:
 760                 /* falls through */
 761             case REG_BINARY: {
 762                     DWORD i1;
 763                     const CHAR *hex_prefix;
 764                     CHAR buf[20];
 765                     int cur_pos;
 766
 767                     if (value_type == REG_BINARY) {
 768                         hex_prefix = "hex:";
 769                     } else {
 770                         hex_prefix = buf;
 771                         sprintf(buf, "hex(%d):", value_type);
 772                     }
 773
 774                     /* position of where the next character will be printed */
 775                     /* NOTE: yes, strlen("hex:") is used even for hex(x): */
 776                     cur_pos = strlen("\"\"=") + strlen("hex:") +
 777                               strlen(*val_name_buf);
 778
 779                     fputs(hex_prefix, file);
 780                     for (i1 = 0; i1 < val_size1; i1++) {
 781                         fprintf(file, "%02x", (unsigned int)(*val_buf)[i1]);
 782                         if (i1 + 1 < val_size1) {
 783                             fputs(",", file);
 784                         }
 785                         cur_pos += 3;
 786
 787                         /* wrap the line */
 788                         if (cur_pos > REG_FILE_HEX_LINE_LEN) {
 789                             fputs("\\\n  ", file);
 790                             cur_pos = 2;
 791                         }
 792                     }
 793                     fputs("\n", file);
 794                     break;
 795                 }
 796             }
 797         }
 798     }
 799
 800     i = 0;
 801     more_data = TRUE;
 802     (*reg_key_name_buf)[curr_len] = '\\';
 803     while(more_data) {
 804         DWORD buf_len = *reg_key_name_len - curr_len;
 805
 806         ret = RegEnumKeyEx(key, i, *reg_key_name_buf + curr_len + 1, &buf_len,
 807                            NULL, NULL, NULL, NULL);
 808         if (ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA) {
 809             more_data = FALSE;
 810             if (ret != ERROR_NO_MORE_ITEMS) {
 811                 REGPROC_print_error();
 812             }
 813         } else {
 814             HKEY subkey;
 815
 816             i++;
 817             if (RegOpenKey(key, *reg_key_name_buf + curr_len + 1,
 818                            &subkey) == ERROR_SUCCESS) {
 819                 export_hkey(file, subkey, reg_key_name_buf, reg_key_name_len,
 820                             val_name_buf, val_name_len, val_buf, val_size);
 821                 RegCloseKey(subkey);
 822             } else {
 823                 REGPROC_print_error();
 824             }
 825         }
 826     }
 827     (*reg_key_name_buf)[curr_len] = '\0';
 828 }
 829
 830 /******************************************************************************
 831  * Open file for export.
 832  */
 833 static FILE *REGPROC_open_export_file(CHAR *file_name)
 834 {
 835     FILE *file;
 836
 837     if (strcmp(file_name,"-")==0)
 838         file=stdout;
 839     else
 840     {
 841         file = fopen(file_name, "w");
 842         if (!file) {
 843             perror("");
 844             fprintf(stderr,"%s: Can't open file \"%s\"\n", getAppName(), file_name);
 845             exit(1);
 846         }
 847     }
 848     fputs("REGEDIT4\n", file);
 849     return file;
 850 }
 851
 852 /******************************************************************************
 853  * Writes contents of the registry key to the specified file stream.
 854  *
 855  * Parameters:
 856  * file_name - name of a file to export registry branch to.
 857  * reg_key_name - registry branch to export. The whole registry is exported if
 858  *      reg_key_name is NULL or contains an empty string.
 859  */
 860 BOOL export_registry_key(CHAR *file_name, CHAR *reg_key_name)
 861 {
 862     CHAR *reg_key_name_buf;
 863     CHAR *val_name_buf;
 864     BYTE *val_buf;
 865     DWORD reg_key_name_len = KEY_MAX_LEN;
 866     DWORD val_name_len = KEY_MAX_LEN;
 867     DWORD val_size = REG_VAL_BUF_SIZE;
 868     FILE *file = NULL;
 869
 870     reg_key_name_buf = HeapAlloc(GetProcessHeap(), 0,
 871                                  reg_key_name_len  * sizeof(*reg_key_name_buf));
 872     val_name_buf = HeapAlloc(GetProcessHeap(), 0,
 873                              val_name_len * sizeof(*val_name_buf));
 874     val_buf = HeapAlloc(GetProcessHeap(), 0, val_size);
 875     CHECK_ENOUGH_MEMORY(reg_key_name_buf && val_name_buf && val_buf);
 876
 877     if (reg_key_name && reg_key_name[0]) {
 878         HKEY reg_key_class;
 879         CHAR *branch_name;
 880         HKEY key;
 881
 882         REGPROC_resize_char_buffer(&reg_key_name_buf, &reg_key_name_len,
 883                                    strlen(reg_key_name));
 884         strcpy(reg_key_name_buf, reg_key_name);
 885
 886         /* open the specified key */
 887         if (!parseKeyName(reg_key_name, &reg_key_class, &branch_name)) {
 888             fprintf(stderr,"%s: Incorrect registry class specification in '%s'\n",
 889                     getAppName(), reg_key_name);
 890             exit(1);
 891         }
 892         if (!branch_name[0]) {
 893             /* no branch - registry class is specified */
 894             file = REGPROC_open_export_file(file_name);
 895             export_hkey(file, reg_key_class,
 896                         &reg_key_name_buf, &reg_key_name_len,
 897                         &val_name_buf, &val_name_len,
 898                         &val_buf, &val_size);
 899         } else if (RegOpenKey(reg_key_class, branch_name, &key) == ERROR_SUCCESS) {
 900             file = REGPROC_open_export_file(file_name);
 901             export_hkey(file, key,
 902                         &reg_key_name_buf, &reg_key_name_len,
 903                         &val_name_buf, &val_name_len,
 904                         &val_buf, &val_size);
 905             RegCloseKey(key);
 906         } else {
 907             fprintf(stderr,"%s: Can't export. Registry key '%s' does not exist!\n",
 908                     getAppName(), reg_key_name);
 909             REGPROC_print_error();
 910         }
 911     } else {
 912         unsigned int i;
 913
 914         /* export all registry classes */
 915         file = REGPROC_open_export_file(file_name);
 916         for (i = 0; i < REG_CLASS_NUMBER; i++) {
 917             /* do not export HKEY_CLASSES_ROOT */
 918             if (reg_class_keys[i] != HKEY_CLASSES_ROOT &&
 919                     reg_class_keys[i] != HKEY_CURRENT_USER &&
 920                     reg_class_keys[i] != HKEY_CURRENT_CONFIG &&
 921                     reg_class_keys[i] != HKEY_DYN_DATA) {
 922                 strcpy(reg_key_name_buf, reg_class_names[i]);
 923                 export_hkey(file, reg_class_keys[i],
 924                             &reg_key_name_buf, &reg_key_name_len,
 925                             &val_name_buf, &val_name_len,
 926                             &val_buf, &val_size);
 927             }
 928         }
 929     }
 930
 931     if (file) {
 932         fclose(file);
 933     }
 934     HeapFree(GetProcessHeap(), 0, reg_key_name);
 935     HeapFree(GetProcessHeap(), 0, val_buf);
 936     return TRUE;
 937 }
 938
 939 /******************************************************************************
 940  * Reads contents of the specified file into the registry.
 941  */
 942 BOOL import_registry_file(LPTSTR filename)
 943 {
 944     FILE* reg_file = fopen(filename, "r");
 945
 946     if (reg_file) {
 947         processRegLines(reg_file);
 948         return TRUE;
 949     }
 950     return FALSE;
 951 }
 952
 953 /******************************************************************************
 954  * Removes the registry key with all subkeys. Parses full key name.
 955  *
 956  * Parameters:
 957  * reg_key_name - full name of registry branch to delete. Ignored if is NULL,
 958  *      empty, points to register key class, does not exist.
 959  */
 960 void delete_registry_key(CHAR *reg_key_name)
 961 {
 962     CHAR *key_name;
 963     HKEY key_class;
 964
 965     if (!reg_key_name || !reg_key_name[0])
 966         return;
 967
 968     if (!parseKeyName(reg_key_name, &key_class, &key_name)) {
 969         fprintf(stderr,"%s: Incorrect registry class specification in '%s'\n",
 970                 getAppName(), reg_key_name);
 971         exit(1);
 972     }
 973     if (!*key_name) {
 974         fprintf(stderr,"%s: Can't delete registry class '%s'\n",
 975                 getAppName(), reg_key_name);
 976         exit(1);
 977     }
 978
 979     RegDeleteTreeA(key_class, key_name);
 980 }