programs/reg/reg.c

   1 /*
   2  * Copyright 2008 Andrew Riedi
   3  * Copyright 2016-2017, 2021 Hugh McMaster
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "reg.h"
  21 #include <wine/debug.h>
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(reg);
  24
  25 static const struct
  26 {
  27     HKEY key;
  28     const WCHAR *short_name;
  29     const WCHAR *long_name;
  30 }
  31 root_rels[] =
  32 {
  33     {HKEY_LOCAL_MACHINE,  L"HKLM", L"HKEY_LOCAL_MACHINE"},
  34     {HKEY_CURRENT_USER,   L"HKCU", L"HKEY_CURRENT_USER"},
  35     {HKEY_CLASSES_ROOT,   L"HKCR", L"HKEY_CLASSES_ROOT"},
  36     {HKEY_USERS,          L"HKU",  L"HKEY_USERS"},
  37     {HKEY_CURRENT_CONFIG, L"HKCC", L"HKEY_CURRENT_CONFIG"},
  38 };
  39
  40 const struct reg_type_rels type_rels[] =
  41 {
  42     {REG_NONE,                L"REG_NONE"},
  43     {REG_SZ,                  L"REG_SZ"},
  44     {REG_EXPAND_SZ,           L"REG_EXPAND_SZ"},
  45     {REG_BINARY,              L"REG_BINARY"},
  46     {REG_DWORD,               L"REG_DWORD"},
  47     {REG_DWORD_LITTLE_ENDIAN, L"REG_DWORD_LITTLE_ENDIAN"},
  48     {REG_DWORD_BIG_ENDIAN,    L"REG_DWORD_BIG_ENDIAN"},
  49     {REG_MULTI_SZ,            L"REG_MULTI_SZ"},
  50 };
  51
  52 void output_writeconsole(const WCHAR *str, DWORD wlen)
  53 {
  54     DWORD count;
  55
  56     if (!WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), str, wlen, &count, NULL))
  57     {
  58         DWORD len;
  59         char  *msgA;
  60
  61         /* On Windows WriteConsoleW() fails if the output is redirected. So fall
  62          * back to WriteFile() with OEM code page.
  63          */
  64         len = WideCharToMultiByte(GetOEMCP(), 0, str, wlen, NULL, 0, NULL, NULL);
  65         msgA = malloc(len);
  66
  67         WideCharToMultiByte(GetOEMCP(), 0, str, wlen, msgA, len, NULL, NULL);
  68         WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), msgA, len, &count, FALSE);
  69         free(msgA);
  70     }
  71 }
  72
  73 static void output_formatstring(const WCHAR *fmt, va_list va_args)
  74 {
  75     WCHAR *str;
  76     DWORD len;
  77
  78     len = FormatMessageW(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER,
  79                          fmt, 0, 0, (WCHAR *)&str, 0, &va_args);
  80     if (len == 0 && GetLastError() != ERROR_NO_WORK_DONE)
  81     {
  82         WINE_FIXME("Could not format string: le=%lu, fmt=%s\n", GetLastError(), wine_dbgstr_w(fmt));
  83         return;
  84     }
  85     output_writeconsole(str, len);
  86     LocalFree(str);
  87 }
  88
  89 void WINAPIV output_message(unsigned int id, ...)
  90 {
  91     WCHAR *fmt = NULL;
  92     int len;
  93     va_list va_args;
  94
  95     if (!(len = LoadStringW(GetModuleHandleW(NULL), id, (WCHAR *)&fmt, 0)))
  96     {
  97         WINE_FIXME("LoadString failed with %ld\n", GetLastError());
  98         return;
  99     }
 100
 101     len++;
 102     fmt = malloc(len * sizeof(WCHAR));
 103     if (!fmt) return;
 104
 105     LoadStringW(GetModuleHandleW(NULL), id, fmt, len);
 106
 107     va_start(va_args, id);
 108     output_formatstring(fmt, va_args);
 109     va_end(va_args);
 110
 111     free(fmt);
 112 }
 113
 114 void WINAPIV output_string(const WCHAR *fmt, ...)
 115 {
 116     va_list va_args;
 117
 118     va_start(va_args, fmt);
 119     output_formatstring(fmt, va_args);
 120     va_end(va_args);
 121 }
 122
 123 /* ask_confirm() adapted from programs/cmd/builtins.c */
 124 BOOL ask_confirm(unsigned int msgid, WCHAR *reg_info)
 125 {
 126     HMODULE hmod;
 127     WCHAR Ybuffer[4];
 128     WCHAR Nbuffer[4];
 129     WCHAR defval[32];
 130     WCHAR answer[MAX_PATH];
 131     WCHAR *str;
 132     DWORD count;
 133
 134     hmod = GetModuleHandleW(NULL);
 135     LoadStringW(hmod, STRING_YES, Ybuffer, ARRAY_SIZE(Ybuffer));
 136     LoadStringW(hmod, STRING_NO,  Nbuffer, ARRAY_SIZE(Nbuffer));
 137     LoadStringW(hmod, STRING_DEFAULT_VALUE, defval, ARRAY_SIZE(defval));
 138
 139     str = (reg_info && *reg_info) ? reg_info : defval;
 140
 141     while (1)
 142     {
 143         output_message(msgid, str);
 144         output_message(STRING_YESNO);
 145         ReadConsoleW(GetStdHandle(STD_INPUT_HANDLE), answer, ARRAY_SIZE(answer), &count, NULL);
 146         answer[0] = towupper(answer[0]);
 147         if (answer[0] == Ybuffer[0])
 148             return TRUE;
 149         if (answer[0] == Nbuffer[0])
 150             return FALSE;
 151     }
 152 }
 153
 154 static inline BOOL path_rootname_cmp(const WCHAR *input_path, const WCHAR *rootkey_name)
 155 {
 156     DWORD length = lstrlenW(rootkey_name);
 157
 158     return (!wcsnicmp(input_path, rootkey_name, length) &&
 159             (input_path[length] == 0 || input_path[length] == '\\'));
 160 }
 161
 162 HKEY path_get_rootkey(const WCHAR *path)
 163 {
 164     DWORD i;
 165
 166     for (i = 0; i < ARRAY_SIZE(root_rels); i++)
 167     {
 168         if (path_rootname_cmp(path, root_rels[i].short_name) ||
 169             path_rootname_cmp(path, root_rels[i].long_name))
 170             return root_rels[i].key;
 171     }
 172
 173     return NULL;
 174 }
 175
 176 static BOOL sane_path(const WCHAR *key)
 177 {
 178     unsigned int i = lstrlenW(key);
 179
 180     if (i < 3 || (key[i - 1] == '\\' && key[i - 2] == '\\'))
 181     {
 182         output_message(STRING_INVALID_KEY);
 183         return FALSE;
 184     }
 185
 186     if (key[0] == '\\' && key[1] == '\\' && key[2] != '\\')
 187     {
 188         output_message(STRING_NO_REMOTE);
 189         return FALSE;
 190     }
 191
 192     return TRUE;
 193 }
 194
 195 WCHAR *build_subkey_path(WCHAR *path, DWORD path_len, WCHAR *subkey_name, DWORD subkey_len)
 196 {
 197     WCHAR *subkey_path;
 198
 199     subkey_path = malloc((path_len + subkey_len + 2) * sizeof(WCHAR));
 200     swprintf(subkey_path, path_len + subkey_len + 2, L"%s\\%s", path, subkey_name);
 201
 202     return subkey_path;
 203 }
 204
 205 WCHAR *get_long_key(HKEY root, WCHAR *path)
 206 {
 207     int i, len;
 208     WCHAR *long_key;
 209
 210     for (i = 0; i < ARRAY_SIZE(root_rels); i++)
 211     {
 212         if (root == root_rels[i].key)
 213             break;
 214     }
 215
 216     len = lstrlenW(root_rels[i].long_name);
 217
 218     if (!path)
 219     {
 220         long_key = malloc((len + 1) * sizeof(WCHAR));
 221         lstrcpyW(long_key, root_rels[i].long_name);
 222         return long_key;
 223     }
 224
 225     len += lstrlenW(path) + 1; /* add one for the concatenating backslash */
 226     long_key = malloc((len + 1) * sizeof(WCHAR));
 227     swprintf(long_key, len + 1, L"%s\\%s", root_rels[i].long_name, path);
 228     return long_key;
 229 }
 230
 231 BOOL parse_registry_key(const WCHAR *key, HKEY *root, WCHAR **path)
 232 {
 233     WCHAR *p;
 234
 235     if (!sane_path(key))
 236         return FALSE;
 237
 238     *root = path_get_rootkey(key);
 239     if (!*root)
 240     {
 241         output_message(STRING_INVALID_SYSTEM_KEY);
 242         return FALSE;
 243     }
 244
 245     *path = wcschr(key, '\\');
 246
 247     if (!*path)
 248         return TRUE;
 249
 250     (*path)++;
 251
 252     if (!**path)
 253     {
 254         output_message(STRING_INVALID_SYSTEM_KEY);
 255         return FALSE;
 256     }
 257
 258     p = *path + lstrlenW(*path) - 1;
 259     if (*p == '\\') *p = 0;
 260
 261     return TRUE;
 262 }
 263
 264 BOOL is_char(const WCHAR s, const WCHAR c)
 265 {
 266     return (s == c || s == towupper(c));
 267 }
 268
 269 BOOL is_switch(const WCHAR *s, const WCHAR c)
 270 {
 271     if (lstrlenW(s) > 2)
 272         return FALSE;
 273
 274     return ((s[0] == '/' || s[0] == '-') && is_char(s[1], c));
 275 }
 276
 277 static BOOL is_help_switch(const WCHAR *s)
 278 {
 279     return (is_switch(s, '?') || is_switch(s, 'h'));
 280 }
 281
 282 enum operations {
 283     REG_ADD,
 284     REG_COPY,
 285     REG_DELETE,
 286     REG_EXPORT,
 287     REG_IMPORT,
 288     REG_QUERY,
 289     REG_INVALID
 290 };
 291
 292 static enum operations get_operation(const WCHAR *str, int *op_help)
 293 {
 294     struct op_info { const WCHAR *op; int id; int help_id; };
 295
 296     static const struct op_info op_array[] =
 297     {
 298         { L"add",     REG_ADD,     STRING_ADD_USAGE },
 299         { L"copy",    REG_COPY,    STRING_COPY_USAGE },
 300         { L"delete",  REG_DELETE,  STRING_DELETE_USAGE },
 301         { L"export",  REG_EXPORT,  STRING_EXPORT_USAGE },
 302         { L"import",  REG_IMPORT,  STRING_IMPORT_USAGE },
 303         { L"query",   REG_QUERY,   STRING_QUERY_USAGE },
 304         { NULL,    -1,          0 }
 305     };
 306
 307     const struct op_info *ptr;
 308
 309     for (ptr = op_array; ptr->op; ptr++)
 310     {
 311         if (!lstrcmpiW(str, ptr->op))
 312         {
 313             *op_help = ptr->help_id;
 314             return ptr->id;
 315         }
 316     }
 317
 318     return REG_INVALID;
 319 }
 320
 321 int __cdecl wmain(int argc, WCHAR *argvW[])
 322 {
 323     int op, op_help;
 324
 325     if (argc == 1)
 326     {
 327         output_message(STRING_INVALID_SYNTAX);
 328         output_message(STRING_REG_HELP);
 329         return 1;
 330     }
 331
 332     if (is_help_switch(argvW[1]))
 333     {
 334         output_message(STRING_USAGE);
 335         return 0;
 336     }
 337
 338     op = get_operation(argvW[1], &op_help);
 339
 340     if (op == REG_INVALID)
 341     {
 342         output_message(STRING_INVALID_OPTION, argvW[1]);
 343         output_message(STRING_REG_HELP);
 344         return 1;
 345     }
 346     else if (argc == 2) /* Valid operation, no arguments supplied */
 347         goto invalid;
 348
 349     if (is_help_switch(argvW[2]))
 350     {
 351         if (argc > 3) goto invalid;
 352
 353         output_message(op_help);
 354         output_message(STRING_REG_VIEW_USAGE);
 355         return 0;
 356     }
 357
 358     if (op == REG_ADD)
 359         return reg_add(argc, argvW);
 360
 361     if (op == REG_COPY)
 362         return reg_copy(argc, argvW);
 363
 364     if (op == REG_DELETE)
 365         return reg_delete(argc, argvW);
 366
 367     if (op == REG_EXPORT)
 368         return reg_export(argc, argvW);
 369
 370     if (op == REG_IMPORT)
 371         return reg_import(argc, argvW);
 372
 373     return reg_query(argc, argvW);
 374
 375 invalid:
 376     output_message(STRING_INVALID_SYNTAX);
 377     output_message(STRING_FUNC_HELP, wcsupr(argvW[1]));
 378     return 1;
 379 }