base/applications/cmdutils/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 <stdarg.h>
  20 #include <windef.h>
  21 #include <winbase.h>
  22 #include <winuser.h>
  23 #include <winreg.h>
  24 #include <wincon.h>
  25 #include <shlwapi.h>
  26 #include <wine/unicode.h>
  27
  28 #include "reg.h"
  29
  30 static int reg_printfW(const WCHAR *msg, ...)
  31 {
  32     va_list va_args;
  33     int wlen;
  34     DWORD count, ret;
  35     WCHAR msg_buffer[8192];
  36
  37     va_start(va_args, msg);
  38     vsnprintfW(msg_buffer, 8192, msg, va_args);
  39     va_end(va_args);
  40
  41     wlen = lstrlenW(msg_buffer);
  42     ret = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), msg_buffer, wlen, &count, NULL);
  43     if (!ret)
  44     {
  45         DWORD len;
  46         char  *msgA;
  47
  48         /* On Windows WriteConsoleW() fails if the output is redirected. So fall
  49          * back to WriteFile(), assuming the console encoding is still the right
  50          * one in that case.
  51          */
  52         len = WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen,
  53             NULL, 0, NULL, NULL);
  54         msgA = HeapAlloc(GetProcessHeap(), 0, len * sizeof(char));
  55         if (!msgA)
  56             return 0;
  57
  58         WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen, msgA, len,
  59             NULL, NULL);
  60         WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), msgA, len, &count, FALSE);
  61         HeapFree(GetProcessHeap(), 0, msgA);
  62     }
  63
  64     return count;
  65 }
  66
  67 static int reg_message(int msg)
  68 {
  69     static const WCHAR formatW[] = {'%','s',0};
  70     WCHAR msg_buffer[8192];
  71
  72     LoadStringW(GetModuleHandleW(NULL), msg, msg_buffer,
  73         sizeof(msg_buffer)/sizeof(WCHAR));
  74     return reg_printfW(formatW, msg_buffer);
  75 }
  76
  77 static HKEY get_rootkey(LPWSTR key)
  78 {
  79     static const WCHAR szHKLM[] = {'H','K','L','M',0};
  80     static const WCHAR szHKEY_LOCAL_MACHINE[] = {'H','K','E','Y','_','L','O','C','A','L','_','M','A','C','H','I','N','E',0};
  81     static const WCHAR szHKCU[] = {'H','K','C','U',0};
  82     static const WCHAR szHKEY_CURRENT_USER[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R',0};
  83     static const WCHAR szHKCR[] = {'H','K','C','R',0};
  84     static const WCHAR szHKEY_CLASSES_ROOT[] = {'H','K','E','Y','_','C','L','A','S','S','E','S','_','R','O','O','T',0};
  85     static const WCHAR szHKU[] = {'H','K','U',0};
  86     static const WCHAR szHKEY_USERS[] = {'H','K','E','Y','_','U','S','E','R','S',0};
  87     static const WCHAR szHKCC[] = {'H','K','C','C',0};
  88     static const WCHAR szHKEY_CURRENT_CONFIG[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','C','O','N','F','I','G',0};
  89
  90     if (CompareStringW(CP_ACP,NORM_IGNORECASE,key,4,szHKLM,4)==CSTR_EQUAL ||
  91         CompareStringW(CP_ACP,NORM_IGNORECASE,key,18,szHKEY_LOCAL_MACHINE,18)==CSTR_EQUAL)
  92         return HKEY_LOCAL_MACHINE;
  93     else if (CompareStringW(CP_ACP,NORM_IGNORECASE,key,4,szHKCU,4)==CSTR_EQUAL ||
  94              CompareStringW(CP_ACP,NORM_IGNORECASE,key,17,szHKEY_CURRENT_USER,17)==CSTR_EQUAL)
  95         return HKEY_CURRENT_USER;
  96     else if (CompareStringW(CP_ACP,NORM_IGNORECASE,key,4,szHKCR,4)==CSTR_EQUAL ||
  97              CompareStringW(CP_ACP,NORM_IGNORECASE,key,17,szHKEY_CLASSES_ROOT,17)==CSTR_EQUAL)
  98         return HKEY_CLASSES_ROOT;
  99     else if (CompareStringW(CP_ACP,NORM_IGNORECASE,key,3,szHKU,3)==CSTR_EQUAL ||
 100              CompareStringW(CP_ACP,NORM_IGNORECASE,key,10,szHKEY_USERS,10)==CSTR_EQUAL)
 101         return HKEY_USERS;
 102     else if (CompareStringW(CP_ACP,NORM_IGNORECASE,key,4,szHKCC,4)==CSTR_EQUAL ||
 103              CompareStringW(CP_ACP,NORM_IGNORECASE,key,19,szHKEY_CURRENT_CONFIG,19)==CSTR_EQUAL)
 104         return HKEY_CURRENT_CONFIG;
 105     else return NULL;
 106 }
 107
 108 static DWORD get_regtype(LPWSTR type)
 109 {
 110     static const WCHAR szREG_SZ[] = {'R','E','G','_','S','Z',0};
 111     static const WCHAR szREG_MULTI_SZ[] = {'R','E','G','_','M','U','L','T','I','_','S','Z',0};
 112     static const WCHAR szREG_DWORD_BIG_ENDIAN[] = {'R','E','G','_','D','W','O','R','D','_','B','I','G','_','E','N','D','I','A','N',0};
 113     static const WCHAR szREG_DWORD[] = {'R','E','G','_','D','W','O','R','D',0};
 114     static const WCHAR szREG_BINARY[] = {'R','E','G','_','B','I','N','A','R','Y',0};
 115     static const WCHAR szREG_DWORD_LITTLE_ENDIAN[] = {'R','E','G','_','D','W','O','R','D','_','L','I','T','T','L','E','_','E','N','D','I','A','N',0};
 116     static const WCHAR szREG_NONE[] = {'R','E','G','_','N','O','N','E',0};
 117     static const WCHAR szREG_EXPAND_SZ[] = {'R','E','G','_','E','X','P','A','N','D','_','S','Z',0};
 118
 119     if (!type)
 120         return REG_SZ;
 121
 122     if (lstrcmpiW(type,szREG_SZ)==0) return REG_SZ;
 123     if (lstrcmpiW(type,szREG_DWORD)==0) return REG_DWORD;
 124     if (lstrcmpiW(type,szREG_MULTI_SZ)==0) return REG_MULTI_SZ;
 125     if (lstrcmpiW(type,szREG_EXPAND_SZ)==0) return REG_EXPAND_SZ;
 126     if (lstrcmpiW(type,szREG_DWORD_BIG_ENDIAN)==0) return REG_DWORD_BIG_ENDIAN;
 127     if (lstrcmpiW(type,szREG_DWORD_LITTLE_ENDIAN)==0) return REG_DWORD_LITTLE_ENDIAN;
 128     if (lstrcmpiW(type,szREG_BINARY)==0) return REG_BINARY;
 129     if (lstrcmpiW(type,szREG_NONE)==0) return REG_NONE;
 130
 131     return -1;
 132 }
 133
 134 static LPBYTE get_regdata(LPWSTR data, DWORD reg_type, WCHAR separator, DWORD *reg_count)
 135 {
 136     LPBYTE out_data = NULL;
 137     *reg_count = 0;
 138
 139     switch (reg_type)
 140     {
 141         case REG_SZ:
 142         {
 143             *reg_count = (lstrlenW(data) + 1) * sizeof(WCHAR);
 144             out_data = HeapAlloc(GetProcessHeap(),0,*reg_count);
 145             lstrcpyW((LPWSTR)out_data,data);
 146             break;
 147         }
 148         case REG_DWORD:
 149         {
 150             LPWSTR rest;
 151             DWORD val;
 152             val = strtolW(data, &rest, 0);
 153             if (rest == data) {
 154                 static const WCHAR nonnumber[] = {'E','r','r','o','r',':',' ','/','d',' ','r','e','q','u','i','r','e','s',' ','n','u','m','b','e','r','.','\n',0};
 155                 reg_printfW(nonnumber);
 156                 break;
 157             }
 158             *reg_count = sizeof(DWORD);
 159             out_data = HeapAlloc(GetProcessHeap(),0,*reg_count);
 160             ((LPDWORD)out_data)[0] = val;
 161             break;
 162         }
 163         default:
 164         {
 165             static const WCHAR unhandled[] = {'U','n','h','a','n','d','l','e','d',' ','T','y','p','e',' ','0','x','%','x',' ',' ','d','a','t','a',' ','%','s','\n',0};
 166             reg_printfW(unhandled, reg_type,data);
 167         }
 168     }
 169
 170     return out_data;
 171 }
 172
 173 static int reg_add(WCHAR *key_name, WCHAR *value_name, BOOL value_empty,
 174     WCHAR *type, WCHAR separator, WCHAR *data, BOOL force)
 175 {
 176     static const WCHAR stubW[] = {'A','D','D',' ','-',' ','%','s',
 177         ' ','%','s',' ','%','d',' ','%','s',' ','%','s',' ','%','d','\n',0};
 178     LPWSTR p;
 179     HKEY root,subkey;
 180
 181     reg_printfW(stubW, key_name, value_name, value_empty, type, data, force);
 182
 183     if (key_name[0]=='\\' && key_name[1]=='\\')
 184     {
 185         reg_message(STRING_NO_REMOTE);
 186         return 1;
 187     }
 188
 189     p = strchrW(key_name,'\\');
 190     if (!p)
 191     {
 192         reg_message(STRING_INVALID_KEY);
 193         return 1;
 194     }
 195     p++;
 196
 197     root = get_rootkey(key_name);
 198     if (!root)
 199     {
 200         reg_message(STRING_INVALID_KEY);
 201         return 1;
 202     }
 203
 204     if(RegCreateKeyW(root,p,&subkey)!=ERROR_SUCCESS)
 205     {
 206         reg_message(STRING_INVALID_KEY);
 207         return 1;
 208     }
 209
 210     if (value_name || data)
 211     {
 212         DWORD reg_type;
 213         DWORD reg_count = 0;
 214         BYTE* reg_data = NULL;
 215
 216         if (!force)
 217         {
 218             if (RegQueryValueW(subkey,value_name,NULL,NULL)==ERROR_SUCCESS)
 219             {
 220                 /* FIXME:  Prompt for overwrite */
 221             }
 222         }
 223
 224         reg_type = get_regtype(type);
 225         if (reg_type == -1)
 226         {
 227             RegCloseKey(subkey);
 228             reg_message(STRING_INVALID_CMDLINE);
 229             return 1;
 230         }
 231
 232         if (data)
 233             reg_data = get_regdata(data,reg_type,separator,&reg_count);
 234
 235         RegSetValueExW(subkey,value_name,0,reg_type,reg_data,reg_count);
 236         HeapFree(GetProcessHeap(),0,reg_data);
 237     }
 238
 239     RegCloseKey(subkey);
 240     reg_message(STRING_SUCCESS);
 241
 242     return 0;
 243 }
 244
 245 static int reg_delete(WCHAR *key_name, WCHAR *value_name, BOOL value_empty,
 246     BOOL value_all, BOOL force)
 247 {
 248     LPWSTR p;
 249     HKEY root,subkey;
 250
 251     static const WCHAR stubW[] = {'D','E','L','E','T','E',
 252         ' ','-',' ','%','s',' ','%','s',' ','%','d',' ','%','d',' ','%','d','\n'
 253         ,0};
 254     reg_printfW(stubW, key_name, value_name, value_empty, value_all, force);
 255
 256     if (key_name[0]=='\\' && key_name[1]=='\\')
 257     {
 258         reg_message(STRING_NO_REMOTE);
 259         return 1;
 260     }
 261
 262     p = strchrW(key_name,'\\');
 263     if (!p)
 264     {
 265         reg_message(STRING_INVALID_KEY);
 266         return 1;
 267     }
 268     p++;
 269
 270     root = get_rootkey(key_name);
 271     if (!root)
 272     {
 273         reg_message(STRING_INVALID_KEY);
 274         return 1;
 275     }
 276
 277     if (value_name && value_empty)
 278     {
 279         reg_message(STRING_INVALID_CMDLINE);
 280         return 1;
 281     }
 282
 283     if (value_empty && value_all)
 284     {
 285         reg_message(STRING_INVALID_CMDLINE);
 286         return 1;
 287     }
 288
 289     if (!force)
 290     {
 291         /* FIXME:  Prompt for delete */
 292     }
 293
 294     /* Delete subtree only if no /v* option is given */
 295     if (!value_name && !value_empty && !value_all)
 296     {
 297         if (SHDeleteKeyW(root, p) != ERROR_SUCCESS)
 298         {
 299             reg_message(STRING_CANNOT_FIND);
 300             return 1;
 301         }
 302         reg_message(STRING_SUCCESS);
 303         return 0;
 304     }
 305
 306     if(RegOpenKeyW(root,p,&subkey)!=ERROR_SUCCESS)
 307     {
 308         reg_message(STRING_CANNOT_FIND);
 309         return 1;
 310     }
 311
 312     if (value_all)
 313     {
 314         LPWSTR szValue;
 315         DWORD maxValue;
 316         DWORD count;
 317         LONG rc;
 318
 319         rc = RegQueryInfoKeyW(subkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 320             &maxValue, NULL, NULL, NULL);
 321         if (rc != ERROR_SUCCESS)
 322         {
 323             /* FIXME: failure */
 324             RegCloseKey(subkey);
 325             return 1;
 326         }
 327         maxValue++;
 328         szValue = HeapAlloc(GetProcessHeap(),0,maxValue*sizeof(WCHAR));
 329
 330         while (1)
 331         {
 332             count = maxValue;
 333             rc = RegEnumValueW(subkey, 0, szValue, &count, NULL, NULL, NULL, NULL);
 334             if (rc == ERROR_SUCCESS)
 335             {
 336                 rc = RegDeleteValueW(subkey, szValue);
 337                 if (rc != ERROR_SUCCESS)
 338                     break;
 339             }
 340             else break;
 341         }
 342         if (rc != ERROR_SUCCESS)
 343         {
 344             /* FIXME  delete failed */
 345         }
 346     }
 347     else if (value_name)
 348     {
 349         if (RegDeleteValueW(subkey,value_name) != ERROR_SUCCESS)
 350         {
 351             RegCloseKey(subkey);
 352             reg_message(STRING_CANNOT_FIND);
 353             return 1;
 354         }
 355     }
 356     else if (value_empty)
 357     {
 358         RegSetValueExW(subkey,NULL,0,REG_SZ,NULL,0);
 359     }
 360
 361     RegCloseKey(subkey);
 362     reg_message(STRING_SUCCESS);
 363     return 0;
 364 }
 365
 366 static int reg_query(WCHAR *key_name, WCHAR *value_name, BOOL value_empty,
 367     BOOL subkey)
 368 {
 369     static const WCHAR stubW[] = {'S','T','U','B',' ','Q','U','E','R','Y',' ',
 370         '-',' ','%','s',' ','%','s',' ','%','d',' ','%','d','\n',0};
 371     reg_printfW(stubW, key_name, value_name, value_empty, subkey);
 372
 373     return 1;
 374 }
 375
 376 int wmain(int argc, WCHAR *argvW[])
 377 {
 378     int i;
 379
 380     static const WCHAR addW[] = {'a','d','d',0};
 381     static const WCHAR deleteW[] = {'d','e','l','e','t','e',0};
 382     static const WCHAR queryW[] = {'q','u','e','r','y',0};
 383     static const WCHAR slashDW[] = {'/','d',0};
 384     static const WCHAR slashFW[] = {'/','f',0};
 385     static const WCHAR slashHW[] = {'/','h',0};
 386     static const WCHAR slashSW[] = {'/','s',0};
 387     static const WCHAR slashTW[] = {'/','t',0};
 388     static const WCHAR slashVW[] = {'/','v',0};
 389     static const WCHAR slashVAW[] = {'/','v','a',0};
 390     static const WCHAR slashVEW[] = {'/','v','e',0};
 391     static const WCHAR slashHelpW[] = {'/','?',0};
 392
 393     if (argc < 2 || !lstrcmpW(argvW[1], slashHelpW)
 394                  || !lstrcmpiW(argvW[1], slashHW))
 395     {
 396         reg_message(STRING_USAGE);
 397         return 0;
 398     }
 399
 400     if (!lstrcmpiW(argvW[1], addW))
 401     {
 402         WCHAR *key_name, *value_name = NULL, *type = NULL, separator = '\0', *data = NULL;
 403         BOOL value_empty = FALSE, force = FALSE;
 404
 405         if (argc < 3)
 406         {
 407             reg_message(STRING_INVALID_CMDLINE);
 408             return 1;
 409         }
 410         else if (argc == 3 && (!lstrcmpW(argvW[2], slashHelpW) ||
 411                                !lstrcmpiW(argvW[2], slashHW)))
 412         {
 413             reg_message(STRING_ADD_USAGE);
 414             return 0;
 415         }
 416
 417         key_name = argvW[2];
 418         for (i = 1; i < argc; i++)
 419         {
 420             if (!lstrcmpiW(argvW[i], slashVW))
 421                 value_name = argvW[++i];
 422             else if (!lstrcmpiW(argvW[i], slashVEW))
 423                 value_empty = TRUE;
 424             else if (!lstrcmpiW(argvW[i], slashTW))
 425                 type = argvW[++i];
 426             else if (!lstrcmpiW(argvW[i], slashSW))
 427                 separator = argvW[++i][0];
 428             else if (!lstrcmpiW(argvW[i], slashDW))
 429                 data = argvW[++i];
 430             else if (!lstrcmpiW(argvW[i], slashFW))
 431                 force = TRUE;
 432         }
 433         return reg_add(key_name, value_name, value_empty, type, separator,
 434             data, force);
 435     }
 436     else if (!lstrcmpiW(argvW[1], deleteW))
 437     {
 438         WCHAR *key_name, *value_name = NULL;
 439         BOOL value_empty = FALSE, value_all = FALSE, force = FALSE;
 440
 441         if (argc < 3)
 442         {
 443             reg_message(STRING_INVALID_CMDLINE);
 444             return 1;
 445         }
 446         else if (argc == 3 && (!lstrcmpW(argvW[2], slashHelpW) ||
 447                                !lstrcmpiW(argvW[2], slashHW)))
 448         {
 449             reg_message(STRING_DELETE_USAGE);
 450             return 0;
 451         }
 452
 453         key_name = argvW[2];
 454         for (i = 1; i < argc; i++)
 455         {
 456             if (!lstrcmpiW(argvW[i], slashVW))
 457                 value_name = argvW[++i];
 458             else if (!lstrcmpiW(argvW[i], slashVEW))
 459                 value_empty = TRUE;
 460             else if (!lstrcmpiW(argvW[i], slashVAW))
 461                 value_all = TRUE;
 462             else if (!lstrcmpiW(argvW[i], slashFW))
 463                 force = TRUE;
 464         }
 465         return reg_delete(key_name, value_name, value_empty, value_all, force);
 466     }
 467     else if (!lstrcmpiW(argvW[1], queryW))
 468     {
 469         WCHAR *key_name, *value_name = NULL;
 470         BOOL value_empty = FALSE, subkey = FALSE;
 471
 472         if (argc < 3)
 473         {
 474             reg_message(STRING_INVALID_CMDLINE);
 475             return 1;
 476         }
 477         else if (argc == 3 && (!lstrcmpW(argvW[2], slashHelpW) ||
 478                                !lstrcmpiW(argvW[2], slashHW)))
 479         {
 480             reg_message(STRING_QUERY_USAGE);
 481             return 0;
 482         }
 483
 484         key_name = argvW[2];
 485         for (i = 1; i < argc; i++)
 486         {
 487             if (!lstrcmpiW(argvW[i], slashVW))
 488                 value_name = argvW[++i];
 489             else if (!lstrcmpiW(argvW[i], slashVEW))
 490                 value_empty = TRUE;
 491             else if (!lstrcmpiW(argvW[i], slashSW))
 492                 subkey = TRUE;
 493         }
 494         return reg_query(key_name, value_name, value_empty, subkey);
 495     }
 496     else
 497     {
 498         reg_message(STRING_INVALID_CMDLINE);
 499         return 1;
 500     }
 501 }