programs/reg/reg.c

   1 /*
   2  * Copyright 2008 Andrew Riedi
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <windows.h>
  20 #include <wine/unicode.h>
  21 #include <wine/debug.h>
  22 #include <errno.h>
  23 #include "reg.h"
  24
  25 #define ARRAY_SIZE(A) (sizeof(A)/sizeof(*A))
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(reg);
  28
  29 static const WCHAR short_hklm[] = {'H','K','L','M',0};
  30 static const WCHAR short_hkcu[] = {'H','K','C','U',0};
  31 static const WCHAR short_hkcr[] = {'H','K','C','R',0};
  32 static const WCHAR short_hku[] = {'H','K','U',0};
  33 static const WCHAR short_hkcc[] = {'H','K','C','C',0};
  34 static const WCHAR long_hklm[] = {'H','K','E','Y','_','L','O','C','A','L','_','M','A','C','H','I','N','E',0};
  35 static const WCHAR long_hkcu[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R',0};
  36 static const WCHAR long_hkcr[] = {'H','K','E','Y','_','C','L','A','S','S','E','S','_','R','O','O','T',0};
  37 static const WCHAR long_hku[] = {'H','K','E','Y','_','U','S','E','R','S',0};
  38 static const WCHAR long_hkcc[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','C','O','N','F','I','G',0};
  39
  40 static const struct
  41 {
  42     HKEY key;
  43     const WCHAR *short_name;
  44     const WCHAR *long_name;
  45 }
  46 root_rels[] =
  47 {
  48     {HKEY_LOCAL_MACHINE, short_hklm, long_hklm},
  49     {HKEY_CURRENT_USER, short_hkcu, long_hkcu},
  50     {HKEY_CLASSES_ROOT, short_hkcr, long_hkcr},
  51     {HKEY_USERS, short_hku, long_hku},
  52     {HKEY_CURRENT_CONFIG, short_hkcc, long_hkcc},
  53 };
  54
  55 static const WCHAR type_none[] = {'R','E','G','_','N','O','N','E',0};
  56 static const WCHAR type_sz[] = {'R','E','G','_','S','Z',0};
  57 static const WCHAR type_expand_sz[] = {'R','E','G','_','E','X','P','A','N','D','_','S','Z',0};
  58 static const WCHAR type_binary[] = {'R','E','G','_','B','I','N','A','R','Y',0};
  59 static const WCHAR type_dword[] = {'R','E','G','_','D','W','O','R','D',0};
  60 static const WCHAR type_dword_le[] = {'R','E','G','_','D','W','O','R','D','_','L','I','T','T','L','E','_','E','N','D','I','A','N',0};
  61 static const WCHAR type_dword_be[] = {'R','E','G','_','D','W','O','R','D','_','B','I','G','_','E','N','D','I','A','N',0};
  62 static const WCHAR type_multi_sz[] = {'R','E','G','_','M','U','L','T','I','_','S','Z',0};
  63
  64 static const struct
  65 {
  66     DWORD type;
  67     const WCHAR *name;
  68 }
  69 type_rels[] =
  70 {
  71     {REG_NONE, type_none},
  72     {REG_SZ, type_sz},
  73     {REG_EXPAND_SZ, type_expand_sz},
  74     {REG_BINARY, type_binary},
  75     {REG_DWORD, type_dword},
  76     {REG_DWORD_LITTLE_ENDIAN, type_dword_le},
  77     {REG_DWORD_BIG_ENDIAN, type_dword_be},
  78     {REG_MULTI_SZ, type_multi_sz},
  79 };
  80
  81 static void output_writeconsole(const WCHAR *str, DWORD wlen)
  82 {
  83     DWORD count, ret;
  84
  85     ret = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), str, wlen, &count, NULL);
  86     if (!ret)
  87     {
  88         DWORD len;
  89         char  *msgA;
  90
  91         /* On Windows WriteConsoleW() fails if the output is redirected. So fall
  92          * back to WriteFile(), assuming the console encoding is still the right
  93          * one in that case.
  94          */
  95         len = WideCharToMultiByte(GetConsoleOutputCP(), 0, str, wlen, NULL, 0, NULL, NULL);
  96         msgA = HeapAlloc(GetProcessHeap(), 0, len * sizeof(char));
  97         if (!msgA) return;
  98
  99         WideCharToMultiByte(GetConsoleOutputCP(), 0, str, wlen, msgA, len, NULL, NULL);
 100         WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), msgA, len, &count, FALSE);
 101         HeapFree(GetProcessHeap(), 0, msgA);
 102     }
 103 }
 104
 105 static void output_formatstring(const WCHAR *fmt, __ms_va_list va_args)
 106 {
 107     WCHAR *str;
 108     DWORD len;
 109
 110     SetLastError(NO_ERROR);
 111     len = FormatMessageW(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER,
 112                          fmt, 0, 0, (WCHAR *)&str, 0, &va_args);
 113     if (len == 0 && GetLastError() != NO_ERROR)
 114     {
 115         WINE_FIXME("Could not format string: le=%u, fmt=%s\n", GetLastError(), wine_dbgstr_w(fmt));
 116         return;
 117     }
 118     output_writeconsole(str, len);
 119     LocalFree(str);
 120 }
 121
 122 static void __cdecl output_message(unsigned int id, ...)
 123 {
 124     WCHAR fmt[1024];
 125     __ms_va_list va_args;
 126
 127     if (!LoadStringW(GetModuleHandleW(NULL), id, fmt, ARRAY_SIZE(fmt)))
 128     {
 129         WINE_FIXME("LoadString failed with %d\n", GetLastError());
 130         return;
 131     }
 132     __ms_va_start(va_args, id);
 133     output_formatstring(fmt, va_args);
 134     __ms_va_end(va_args);
 135 }
 136
 137 static void __cdecl output_string(const WCHAR *fmt, ...)
 138 {
 139     __ms_va_list va_args;
 140
 141     __ms_va_start(va_args, fmt);
 142     output_formatstring(fmt, va_args);
 143     __ms_va_end(va_args);
 144 }
 145
 146 /* ask_confirm() adapted from programs/cmd/builtins.c */
 147 static BOOL ask_confirm(unsigned int msgid, WCHAR *reg_info)
 148 {
 149     HMODULE hmod;
 150     WCHAR Ybuffer[4];
 151     WCHAR Nbuffer[4];
 152     WCHAR defval[32];
 153     WCHAR answer[MAX_PATH];
 154     WCHAR *str;
 155     DWORD count;
 156
 157     hmod = GetModuleHandleW(NULL);
 158     LoadStringW(hmod, STRING_YES, Ybuffer, ARRAY_SIZE(Ybuffer));
 159     LoadStringW(hmod, STRING_NO,  Nbuffer, ARRAY_SIZE(Nbuffer));
 160     LoadStringW(hmod, STRING_DEFAULT_VALUE, defval, ARRAY_SIZE(defval));
 161
 162     str = (reg_info && strlenW(reg_info)) ? reg_info : defval;
 163
 164     while (1)
 165     {
 166         output_message(msgid, str);
 167         output_message(STRING_YESNO);
 168         ReadConsoleW(GetStdHandle(STD_INPUT_HANDLE), answer, ARRAY_SIZE(answer), &count, NULL);
 169         answer[0] = toupperW(answer[0]);
 170         if (answer[0] == Ybuffer[0])
 171             return TRUE;
 172         if (answer[0] == Nbuffer[0])
 173             return FALSE;
 174     }
 175 }
 176
 177 static inline BOOL path_rootname_cmp(const WCHAR *input_path, const WCHAR *rootkey_name)
 178 {
 179     DWORD length = strlenW(rootkey_name);
 180
 181     return (!strncmpiW(input_path, rootkey_name, length) &&
 182             (input_path[length] == 0 || input_path[length] == '\\'));
 183 }
 184
 185 static HKEY path_get_rootkey(const WCHAR *path)
 186 {
 187     DWORD i;
 188
 189     for (i = 0; i < ARRAY_SIZE(root_rels); i++)
 190     {
 191         if (path_rootname_cmp(path, root_rels[i].short_name) ||
 192             path_rootname_cmp(path, root_rels[i].long_name))
 193             return root_rels[i].key;
 194     }
 195
 196     return NULL;
 197 }
 198
 199 static DWORD wchar_get_type(const WCHAR *type_name)
 200 {
 201     DWORD i;
 202
 203     if (!type_name)
 204         return REG_SZ;
 205
 206     for (i = 0; i < ARRAY_SIZE(type_rels); i++)
 207     {
 208         if (!strcmpiW(type_rels[i].name, type_name))
 209             return type_rels[i].type;
 210     }
 211
 212     return ~0u;
 213 }
 214
 215 /* hexchar_to_byte from programs/regedit/hexedit.c */
 216 static inline BYTE hexchar_to_byte(WCHAR ch)
 217 {
 218     if (ch >= '0' && ch <= '9')
 219         return ch - '0';
 220     else if (ch >= 'a' && ch <= 'f')
 221         return ch - 'a' + 10;
 222     else if (ch >= 'A' && ch <= 'F')
 223         return ch - 'A' + 10;
 224     else
 225         return -1;
 226 }
 227
 228 static LPBYTE get_regdata(const WCHAR *data, DWORD reg_type, WCHAR separator, DWORD *reg_count)
 229 {
 230     static const WCHAR empty;
 231     LPBYTE out_data = NULL;
 232     *reg_count = 0;
 233
 234     if (!data) data = &empty;
 235
 236     switch (reg_type)
 237     {
 238         case REG_NONE:
 239         case REG_SZ:
 240         case REG_EXPAND_SZ:
 241         {
 242             *reg_count = (lstrlenW(data) + 1) * sizeof(WCHAR);
 243             out_data = HeapAlloc(GetProcessHeap(),0,*reg_count);
 244             lstrcpyW((LPWSTR)out_data,data);
 245             break;
 246         }
 247         case REG_DWORD:
 248      /* case REG_DWORD_LITTLE_ENDIAN: */
 249         case REG_DWORD_BIG_ENDIAN: /* Yes, this is correct! */
 250         {
 251             LPWSTR rest;
 252             DWORD val;
 253             val = strtoulW(data, &rest, (tolowerW(data[1]) == 'x') ? 16 : 10);
 254             if (*rest || data[0] == '-' || (val == ~0u && errno == ERANGE)) {
 255                 output_message(STRING_MISSING_INTEGER);
 256                 break;
 257             }
 258             *reg_count = sizeof(DWORD);
 259             out_data = HeapAlloc(GetProcessHeap(),0,*reg_count);
 260             ((LPDWORD)out_data)[0] = val;
 261             break;
 262         }
 263         case REG_BINARY:
 264         {
 265             BYTE hex0, hex1;
 266             int i = 0, destByteIndex = 0, datalen = lstrlenW(data);
 267             *reg_count = ((datalen + datalen % 2) / 2) * sizeof(BYTE);
 268             out_data = HeapAlloc(GetProcessHeap(), 0, *reg_count);
 269             if(datalen % 2)
 270             {
 271                 hex1 = hexchar_to_byte(data[i++]);
 272                 if(hex1 == 0xFF)
 273                     goto no_hex_data;
 274                 out_data[destByteIndex++] = hex1;
 275             }
 276             for(;i + 1 < datalen;i += 2)
 277             {
 278                 hex0 = hexchar_to_byte(data[i]);
 279                 hex1 = hexchar_to_byte(data[i + 1]);
 280                 if(hex0 == 0xFF || hex1 == 0xFF)
 281                     goto no_hex_data;
 282                 out_data[destByteIndex++] = (hex0 << 4) | hex1;
 283             }
 284             break;
 285             no_hex_data:
 286             /* cleanup, print error */
 287             HeapFree(GetProcessHeap(), 0, out_data);
 288             output_message(STRING_MISSING_HEXDATA);
 289             out_data = NULL;
 290             break;
 291         }
 292         case REG_MULTI_SZ:
 293         {
 294             int i, destindex, len = strlenW(data);
 295             WCHAR *buffer = HeapAlloc(GetProcessHeap(), 0, (len + 2) * sizeof(WCHAR));
 296
 297             for (i = 0, destindex = 0; i < len; i++, destindex++)
 298             {
 299                 if (!separator && data[i] == '\\' && data[i + 1] == '0')
 300                 {
 301                     buffer[destindex] = 0;
 302                     i++;
 303                 }
 304                 else if (data[i] == separator)
 305                     buffer[destindex] = 0;
 306                 else
 307                     buffer[destindex] = data[i];
 308
 309                 if (destindex && !buffer[destindex - 1] && (!buffer[destindex] || destindex == 1))
 310                 {
 311                     HeapFree(GetProcessHeap(), 0, buffer);
 312                     output_message(STRING_INVALID_STRING);
 313                     return NULL;
 314                 }
 315             }
 316             buffer[destindex] = 0;
 317             if (destindex && buffer[destindex - 1])
 318                 buffer[++destindex] = 0;
 319             *reg_count = (destindex + 1) * sizeof(WCHAR);
 320             return (BYTE *)buffer;
 321         }
 322         default:
 323             output_message(STRING_UNHANDLED_TYPE, reg_type, data);
 324     }
 325
 326     return out_data;
 327 }
 328
 329 static BOOL sane_path(const WCHAR *key)
 330 {
 331     unsigned int i = strlenW(key);
 332
 333     if (i < 3 || (key[i - 1] == '\\' && key[i - 2] == '\\'))
 334     {
 335         output_message(STRING_INVALID_KEY);
 336         return FALSE;
 337     }
 338
 339     if (key[0] == '\\' && key[1] == '\\' && key[2] != '\\')
 340     {
 341         output_message(STRING_NO_REMOTE);
 342         return FALSE;
 343     }
 344
 345     return TRUE;
 346 }
 347
 348 static int reg_add(WCHAR *key_name, WCHAR *value_name, BOOL value_empty,
 349     WCHAR *type, WCHAR separator, WCHAR *data, BOOL force)
 350 {
 351     LPWSTR p;
 352     HKEY root,subkey;
 353
 354     if (!sane_path(key_name))
 355         return 1;
 356
 357     p = strchrW(key_name,'\\');
 358     if (p) p++;
 359
 360     root = path_get_rootkey(key_name);
 361     if (!root)
 362     {
 363         output_message(STRING_INVALID_KEY);
 364         return 1;
 365     }
 366
 367     if (value_name && value_empty)
 368     {
 369         output_message(STRING_INVALID_CMDLINE);
 370         return 1;
 371     }
 372
 373     if(RegCreateKeyW(root,p,&subkey)!=ERROR_SUCCESS)
 374     {
 375         output_message(STRING_INVALID_KEY);
 376         return 1;
 377     }
 378
 379     if (value_name || value_empty || data)
 380     {
 381         DWORD reg_type;
 382         DWORD reg_count = 0;
 383         BYTE* reg_data = NULL;
 384
 385         if (!force)
 386         {
 387             if (RegQueryValueExW(subkey, value_name, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
 388             {
 389                 if (!ask_confirm(STRING_OVERWRITE_VALUE, value_name))
 390                 {
 391                     RegCloseKey(subkey);
 392                     output_message(STRING_CANCELLED);
 393                     return 0;
 394                 }
 395             }
 396         }
 397
 398         reg_type = wchar_get_type(type);
 399         if (reg_type == ~0u)
 400         {
 401             RegCloseKey(subkey);
 402             output_message(STRING_UNSUPPORTED_TYPE, type);
 403             return 1;
 404         }
 405         if ((reg_type == REG_DWORD || reg_type == REG_DWORD_BIG_ENDIAN) && !data)
 406         {
 407              RegCloseKey(subkey);
 408              output_message(STRING_INVALID_CMDLINE);
 409              return 1;
 410         }
 411
 412         if (!(reg_data = get_regdata(data, reg_type, separator, &reg_count)))
 413         {
 414             RegCloseKey(subkey);
 415             return 1;
 416         }
 417
 418         RegSetValueExW(subkey,value_name,0,reg_type,reg_data,reg_count);
 419         HeapFree(GetProcessHeap(),0,reg_data);
 420     }
 421
 422     RegCloseKey(subkey);
 423     output_message(STRING_SUCCESS);
 424
 425     return 0;
 426 }
 427
 428 static int reg_delete(WCHAR *key_name, WCHAR *value_name, BOOL value_empty,
 429     BOOL value_all, BOOL force)
 430 {
 431     LPWSTR p;
 432     HKEY root,subkey;
 433
 434     if (!sane_path(key_name))
 435         return 1;
 436
 437     p = strchrW(key_name,'\\');
 438     if (p) p++;
 439
 440     root = path_get_rootkey(key_name);
 441     if (!root)
 442     {
 443         output_message(STRING_INVALID_KEY);
 444         return 1;
 445     }
 446
 447     if ((value_name && value_empty) || (value_name && value_all) || (value_empty && value_all))
 448     {
 449         output_message(STRING_INVALID_CMDLINE);
 450         return 1;
 451     }
 452
 453     if (!force)
 454     {
 455         BOOL ret;
 456
 457         if (value_name || value_empty)
 458             ret = ask_confirm(STRING_DELETE_VALUE, value_name);
 459         else if (value_all)
 460             ret = ask_confirm(STRING_DELETE_VALUEALL, key_name);
 461         else
 462             ret = ask_confirm(STRING_DELETE_SUBKEY, key_name);
 463
 464         if (!ret)
 465         {
 466             output_message(STRING_CANCELLED);
 467             return 0;
 468         }
 469     }
 470
 471     /* Delete subtree only if no /v* option is given */
 472     if (!value_name && !value_empty && !value_all)
 473     {
 474         if (RegDeleteTreeW(root,p)!=ERROR_SUCCESS)
 475         {
 476             output_message(STRING_CANNOT_FIND);
 477             return 1;
 478         }
 479         output_message(STRING_SUCCESS);
 480         return 0;
 481     }
 482
 483     if(RegOpenKeyW(root,p,&subkey)!=ERROR_SUCCESS)
 484     {
 485         output_message(STRING_CANNOT_FIND);
 486         return 1;
 487     }
 488
 489     if (value_all)
 490     {
 491         LPWSTR szValue;
 492         DWORD maxValue;
 493         DWORD count;
 494         LONG rc;
 495
 496         rc = RegQueryInfoKeyW(subkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 497             &maxValue, NULL, NULL, NULL);
 498         if (rc != ERROR_SUCCESS)
 499         {
 500             RegCloseKey(subkey);
 501             output_message(STRING_GENERAL_FAILURE);
 502             return 1;
 503         }
 504         maxValue++;
 505         szValue = HeapAlloc(GetProcessHeap(),0,maxValue*sizeof(WCHAR));
 506
 507         while (1)
 508         {
 509             count = maxValue;
 510             rc = RegEnumValueW(subkey, 0, szValue, &count, NULL, NULL, NULL, NULL);
 511             if (rc == ERROR_SUCCESS)
 512             {
 513                 rc = RegDeleteValueW(subkey, szValue);
 514                 if (rc != ERROR_SUCCESS)
 515                 {
 516                     HeapFree(GetProcessHeap(), 0, szValue);
 517                     RegCloseKey(subkey);
 518                     output_message(STRING_VALUEALL_FAILED, key_name);
 519                     return 1;
 520                 }
 521             }
 522             else break;
 523         }
 524     }
 525     else if (value_name || value_empty)
 526     {
 527         if (RegDeleteValueW(subkey, value_empty ? NULL : value_name) != ERROR_SUCCESS)
 528         {
 529             RegCloseKey(subkey);
 530             output_message(STRING_CANNOT_FIND);
 531             return 1;
 532         }
 533     }
 534
 535     RegCloseKey(subkey);
 536     output_message(STRING_SUCCESS);
 537     return 0;
 538 }
 539
 540 static WCHAR *reg_data_to_wchar(DWORD type, const BYTE *src, DWORD size_bytes)
 541 {
 542     WCHAR *buffer = NULL;
 543     int i;
 544
 545     switch (type)
 546     {
 547         case REG_SZ:
 548         case REG_EXPAND_SZ:
 549             buffer = HeapAlloc(GetProcessHeap(), 0, size_bytes);
 550             strcpyW(buffer, (WCHAR *)src);
 551             break;
 552         case REG_NONE:
 553         case REG_BINARY:
 554         {
 555             WCHAR *ptr;
 556             WCHAR fmt[] = {'%','0','2','X',0};
 557
 558             buffer = HeapAlloc(GetProcessHeap(), 0, (size_bytes * 2 + 1) * sizeof(WCHAR));
 559             ptr = buffer;
 560             for (i = 0; i < size_bytes; i++)
 561                 ptr += sprintfW(ptr, fmt, src[i]);
 562             break;
 563         }
 564         case REG_DWORD:
 565      /* case REG_DWORD_LITTLE_ENDIAN: */
 566         case REG_DWORD_BIG_ENDIAN:
 567         {
 568             const int zero_x_dword = 10;
 569             WCHAR fmt[] = {'0','x','%','x',0};
 570
 571             buffer = HeapAlloc(GetProcessHeap(), 0, (zero_x_dword + 1) * sizeof(WCHAR));
 572             sprintfW(buffer, fmt, *(DWORD *)src);
 573             break;
 574         }
 575         case REG_MULTI_SZ:
 576         {
 577             const int two_wchars = 2 * sizeof(WCHAR);
 578             DWORD tmp_size;
 579             const WCHAR *tmp = (const WCHAR *)src;
 580             int len, destindex;
 581
 582             if (size_bytes <= two_wchars)
 583             {
 584                 buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR));
 585                 *buffer = 0;
 586                 return buffer;
 587             }
 588
 589             tmp_size = size_bytes - two_wchars; /* exclude both null terminators */
 590             buffer = HeapAlloc(GetProcessHeap(), 0, tmp_size * 2 + sizeof(WCHAR));
 591             len = tmp_size / sizeof(WCHAR);
 592
 593             for (i = 0, destindex = 0; i < len; i++, destindex++)
 594             {
 595                 if (tmp[i])
 596                     buffer[destindex] = tmp[i];
 597                 else
 598                 {
 599                     buffer[destindex++] = '\\';
 600                     buffer[destindex] = '0';
 601                 }
 602             }
 603             buffer[destindex] = 0;
 604             break;
 605         }
 606     }
 607     return buffer;
 608 }
 609
 610 static const WCHAR *reg_type_to_wchar(DWORD type)
 611 {
 612     int i, array_size = ARRAY_SIZE(type_rels);
 613
 614     for (i = 0; i < array_size; i++)
 615     {
 616         if (type == type_rels[i].type)
 617             return type_rels[i].name;
 618     }
 619     return NULL;
 620 }
 621
 622 static void output_value(const WCHAR *value_name, DWORD type, BYTE *data, DWORD data_size)
 623 {
 624     WCHAR fmt[] = {' ',' ',' ',' ','%','1',0};
 625     WCHAR *reg_data;
 626     WCHAR newlineW[] = {'\n',0};
 627
 628     if (value_name && value_name[0])
 629         output_string(fmt, value_name);
 630     else
 631     {
 632         WCHAR defval[32];
 633         LoadStringW(GetModuleHandleW(NULL), STRING_DEFAULT_VALUE, defval, ARRAY_SIZE(defval));
 634         output_string(fmt, defval);
 635     }
 636     output_string(fmt, reg_type_to_wchar(type));
 637     reg_data = reg_data_to_wchar(type, data, data_size);
 638     output_string(fmt, reg_data);
 639     HeapFree(GetProcessHeap(), 0, reg_data);
 640     output_string(newlineW);
 641 }
 642
 643 static WCHAR *build_subkey_path(WCHAR *path, DWORD path_len, WCHAR *subkey_name, DWORD subkey_len)
 644 {
 645     WCHAR *subkey_path;
 646     WCHAR fmt[] = {'%','s','\\','%','s',0};
 647
 648     subkey_path = HeapAlloc(GetProcessHeap(), 0, (path_len + subkey_len + 2) * sizeof(WCHAR));
 649     if (!subkey_path)
 650     {
 651         ERR("Failed to allocate memory for subkey_path\n");
 652         return NULL;
 653     }
 654     sprintfW(subkey_path, fmt, path, subkey_name);
 655     return subkey_path;
 656 }
 657
 658 static int query_value(HKEY key, WCHAR *value_name, WCHAR *path, BOOL recurse)
 659 {
 660     LONG rc;
 661     DWORD num_subkeys, max_subkey_len, subkey_len;
 662     DWORD max_data_bytes, data_size;
 663     DWORD type, path_len, i;
 664     BYTE *data;
 665     WCHAR fmt[] = {'%','1','\n',0};
 666     WCHAR newlineW[] = {'\n',0};
 667     WCHAR *subkey_name, *subkey_path;
 668     HKEY subkey;
 669
 670     rc = RegQueryInfoKeyW(key, NULL, NULL, NULL, &num_subkeys, &max_subkey_len,
 671                           NULL, NULL, NULL, &max_data_bytes, NULL, NULL);
 672     if (rc)
 673     {
 674         ERR("RegQueryInfoKey failed: %d\n", rc);
 675         return 1;
 676     }
 677
 678     data = HeapAlloc(GetProcessHeap(), 0, max_data_bytes);
 679     if (!data)
 680     {
 681         ERR("Failed to allocate memory for data\n");
 682         return 1;
 683     }
 684
 685     data_size = max_data_bytes;
 686     rc = RegQueryValueExW(key, value_name, NULL, &type, data, &data_size);
 687     if (rc == ERROR_SUCCESS)
 688     {
 689         output_string(fmt, path);
 690         output_value(value_name, type, data, data_size);
 691         output_string(newlineW);
 692     }
 693
 694     HeapFree(GetProcessHeap(), 0, data);
 695
 696     if (!recurse)
 697     {
 698         if (rc == ERROR_FILE_NOT_FOUND)
 699         {
 700             output_message(STRING_CANNOT_FIND);
 701             return 1;
 702         }
 703         return 0;
 704     }
 705
 706     max_subkey_len++;
 707     subkey_name = HeapAlloc(GetProcessHeap(), 0, max_subkey_len * sizeof(WCHAR));
 708     if (!subkey_name)
 709     {
 710         ERR("Failed to allocate memory for subkey_name\n");
 711         return 1;
 712     }
 713
 714     path_len = strlenW(path);
 715
 716     for (i = 0; i < num_subkeys; i++)
 717     {
 718         subkey_len = max_subkey_len;
 719         rc = RegEnumKeyExW(key, i, subkey_name, &subkey_len, NULL, NULL, NULL, NULL);
 720         if (rc == ERROR_SUCCESS)
 721         {
 722             subkey_path = build_subkey_path(path, path_len, subkey_name, subkey_len);
 723             if (!RegOpenKeyExW(key, subkey_name, 0, KEY_READ, &subkey))
 724             {
 725                 query_value(subkey, value_name, subkey_path, recurse);
 726                 RegCloseKey(subkey);
 727             }
 728             HeapFree(GetProcessHeap(), 0, subkey_path);
 729         }
 730     }
 731
 732     HeapFree(GetProcessHeap(), 0, subkey_name);
 733     return 0;
 734 }
 735
 736 static int query_all(HKEY key, WCHAR *path, BOOL recurse)
 737 {
 738     LONG rc;
 739     DWORD num_subkeys, max_subkey_len, subkey_len;
 740     DWORD num_values, max_value_len, value_len;
 741     DWORD max_data_bytes, data_size;
 742     DWORD i, type, path_len;
 743     WCHAR fmt[] = {'%','1','\n',0};
 744     WCHAR fmt_path[] = {'%','1','\\','%','2','\n',0};
 745     WCHAR *value_name, *subkey_name, *subkey_path;
 746     WCHAR newlineW[] = {'\n',0};
 747     BYTE *data;
 748     HKEY subkey;
 749
 750     rc = RegQueryInfoKeyW(key, NULL, NULL, NULL, &num_subkeys, &max_subkey_len, NULL,
 751                           &num_values, &max_value_len, &max_data_bytes, NULL, NULL);
 752     if (rc)
 753     {
 754         ERR("RegQueryInfoKey failed: %d\n", rc);
 755         return 1;
 756     }
 757
 758     output_string(fmt, path);
 759
 760     max_value_len++;
 761     value_name = HeapAlloc(GetProcessHeap(), 0, max_value_len * sizeof(WCHAR));
 762     if (!value_name)
 763     {
 764         ERR("Failed to allocate memory for value_name\n");
 765         return 1;
 766     }
 767
 768     data = HeapAlloc(GetProcessHeap(), 0, max_data_bytes);
 769     if (!data)
 770     {
 771         HeapFree(GetProcessHeap(), 0, value_name);
 772         ERR("Failed to allocate memory for data\n");
 773         return 1;
 774     }
 775
 776     for (i = 0; i < num_values; i++)
 777     {
 778         value_len = max_value_len;
 779         data_size = max_data_bytes;
 780         rc = RegEnumValueW(key, i, value_name, &value_len, NULL, &type, data, &data_size);
 781         if (rc == ERROR_SUCCESS)
 782             output_value(value_name, type, data, data_size);
 783     }
 784
 785     HeapFree(GetProcessHeap(), 0, data);
 786     HeapFree(GetProcessHeap(), 0, value_name);
 787
 788     if (num_values || recurse)
 789         output_string(newlineW);
 790
 791     max_subkey_len++;
 792     subkey_name = HeapAlloc(GetProcessHeap(), 0, max_subkey_len * sizeof(WCHAR));
 793     if (!subkey_name)
 794     {
 795         ERR("Failed to allocate memory for subkey_name\n");
 796         return 1;
 797     }
 798
 799     path_len = strlenW(path);
 800
 801     for (i = 0; i < num_subkeys; i++)
 802     {
 803         subkey_len = max_subkey_len;
 804         rc = RegEnumKeyExW(key, i, subkey_name, &subkey_len, NULL, NULL, NULL, NULL);
 805         if (rc == ERROR_SUCCESS)
 806         {
 807             if (recurse)
 808             {
 809                 subkey_path = build_subkey_path(path, path_len, subkey_name, subkey_len);
 810                 if (!RegOpenKeyExW(key, subkey_name, 0, KEY_READ, &subkey))
 811                 {
 812                     query_all(subkey, subkey_path, recurse);
 813                     RegCloseKey(subkey);
 814                 }
 815                 HeapFree(GetProcessHeap(), 0, subkey_path);
 816             }
 817             else output_string(fmt_path, path, subkey_name);
 818         }
 819     }
 820
 821     HeapFree(GetProcessHeap(), 0, subkey_name);
 822
 823     if (num_subkeys && !recurse)
 824         output_string(newlineW);
 825
 826     return 0;
 827 }
 828
 829 static int reg_query(WCHAR *key_name, WCHAR *value_name, BOOL value_empty, BOOL recurse)
 830 {
 831     WCHAR *p;
 832     HKEY root, key;
 833     int ret;
 834
 835     if (!sane_path(key_name))
 836         return 1;
 837
 838     if (value_name && value_empty)
 839     {
 840         output_message(STRING_INVALID_CMDLINE);
 841         return 1;
 842     }
 843
 844     root = path_get_rootkey(key_name);
 845     if (!root)
 846     {
 847         output_message(STRING_INVALID_KEY);
 848         return 1;
 849     }
 850
 851     p = strchrW(key_name, '\\');
 852     if (p) p++;
 853
 854     if (RegOpenKeyExW(root, p, 0, KEY_READ, &key) != ERROR_SUCCESS)
 855     {
 856         output_message(STRING_CANNOT_FIND);
 857         return 1;
 858     }
 859
 860     if (value_name || value_empty)
 861         ret = query_value(key, value_name, key_name, recurse);
 862     else
 863         ret = query_all(key, key_name, recurse);
 864
 865     RegCloseKey(key);
 866
 867     return ret;
 868 }
 869
 870 int wmain(int argc, WCHAR *argvW[])
 871 {
 872     int i;
 873
 874     static const WCHAR addW[] = {'a','d','d',0};
 875     static const WCHAR deleteW[] = {'d','e','l','e','t','e',0};
 876     static const WCHAR queryW[] = {'q','u','e','r','y',0};
 877     static const WCHAR slashDW[] = {'/','d',0};
 878     static const WCHAR slashFW[] = {'/','f',0};
 879     static const WCHAR slashHW[] = {'/','h',0};
 880     static const WCHAR slashSW[] = {'/','s',0};
 881     static const WCHAR slashTW[] = {'/','t',0};
 882     static const WCHAR slashVW[] = {'/','v',0};
 883     static const WCHAR slashVAW[] = {'/','v','a',0};
 884     static const WCHAR slashVEW[] = {'/','v','e',0};
 885     static const WCHAR slashHelpW[] = {'/','?',0};
 886
 887     if (argc < 2 || !lstrcmpW(argvW[1], slashHelpW)
 888                  || !lstrcmpiW(argvW[1], slashHW))
 889     {
 890         output_message(STRING_USAGE);
 891         return 0;
 892     }
 893
 894     if (!lstrcmpiW(argvW[1], addW))
 895     {
 896         WCHAR *key_name, *value_name = NULL, *type = NULL, separator = '\0', *data = NULL;
 897         BOOL value_empty = FALSE, force = FALSE;
 898
 899         if (argc < 3)
 900         {
 901             output_message(STRING_INVALID_CMDLINE);
 902             return 1;
 903         }
 904         else if (argc == 3 && (!lstrcmpW(argvW[2], slashHelpW) ||
 905                                !lstrcmpiW(argvW[2], slashHW)))
 906         {
 907             output_message(STRING_ADD_USAGE);
 908             return 0;
 909         }
 910
 911         key_name = argvW[2];
 912         for (i = 1; i < argc; i++)
 913         {
 914             if (!lstrcmpiW(argvW[i], slashVW))
 915             {
 916                 if (value_name || !(value_name = argvW[++i]))
 917                 {
 918                     output_message(STRING_INVALID_CMDLINE);
 919                     return 1;
 920                 }
 921             }
 922             else if (!lstrcmpiW(argvW[i], slashVEW))
 923                 value_empty = TRUE;
 924             else if (!lstrcmpiW(argvW[i], slashTW))
 925                 type = argvW[++i];
 926             else if (!lstrcmpiW(argvW[i], slashSW))
 927             {
 928                 WCHAR *ptr = argvW[++i];
 929
 930                 if (!ptr || strlenW(ptr) != 1)
 931                 {
 932                     output_message(STRING_INVALID_CMDLINE);
 933                     return 1;
 934                 }
 935                 separator = ptr[0];
 936             }
 937             else if (!lstrcmpiW(argvW[i], slashDW))
 938             {
 939                 if (!(data = argvW[++i]))
 940                 {
 941                     output_message(STRING_INVALID_CMDLINE);
 942                     return 1;
 943                 }
 944             }
 945             else if (!lstrcmpiW(argvW[i], slashFW))
 946                 force = TRUE;
 947         }
 948         return reg_add(key_name, value_name, value_empty, type, separator,
 949             data, force);
 950     }
 951     else if (!lstrcmpiW(argvW[1], deleteW))
 952     {
 953         WCHAR *key_name, *value_name = NULL;
 954         BOOL value_empty = FALSE, value_all = FALSE, force = FALSE;
 955
 956         if (argc < 3)
 957         {
 958             output_message(STRING_INVALID_CMDLINE);
 959             return 1;
 960         }
 961         else if (argc == 3 && (!lstrcmpW(argvW[2], slashHelpW) ||
 962                                !lstrcmpiW(argvW[2], slashHW)))
 963         {
 964             output_message(STRING_DELETE_USAGE);
 965             return 0;
 966         }
 967
 968         key_name = argvW[2];
 969         for (i = 1; i < argc; i++)
 970         {
 971             if (!lstrcmpiW(argvW[i], slashVW))
 972             {
 973                 if (value_name || !(value_name = argvW[++i]))
 974                 {
 975                     output_message(STRING_INVALID_CMDLINE);
 976                     return 1;
 977                 }
 978             }
 979             else if (!lstrcmpiW(argvW[i], slashVEW))
 980                 value_empty = TRUE;
 981             else if (!lstrcmpiW(argvW[i], slashVAW))
 982                 value_all = TRUE;
 983             else if (!lstrcmpiW(argvW[i], slashFW))
 984                 force = TRUE;
 985         }
 986         return reg_delete(key_name, value_name, value_empty, value_all, force);
 987     }
 988     else if (!lstrcmpiW(argvW[1], queryW))
 989     {
 990         WCHAR *key_name, *value_name = NULL;
 991         BOOL value_empty = FALSE, recurse = FALSE;
 992
 993         if (argc < 3)
 994         {
 995             output_message(STRING_INVALID_CMDLINE);
 996             return 1;
 997         }
 998         else if (argc == 3 && (!lstrcmpW(argvW[2], slashHelpW) ||
 999                                !lstrcmpiW(argvW[2], slashHW)))
1000         {
1001             output_message(STRING_QUERY_USAGE);
1002             return 0;
1003         }
1004
1005         key_name = argvW[2];
1006         for (i = 1; i < argc; i++)
1007         {
1008             if (!lstrcmpiW(argvW[i], slashVW))
1009             {
1010                 if (value_name || !(value_name = argvW[++i]))
1011                 {
1012                     output_message(STRING_INVALID_CMDLINE);
1013                     return 1;
1014                 }
1015             }
1016             else if (!lstrcmpiW(argvW[i], slashVEW))
1017                 value_empty = TRUE;
1018             else if (!lstrcmpiW(argvW[i], slashSW))
1019                 recurse = TRUE;
1020         }
1021         return reg_query(key_name, value_name, value_empty, recurse);
1022     }
1023     else
1024     {
1025         output_message(STRING_INVALID_CMDLINE);
1026         return 1;
1027     }
1028 }