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