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