programs/regedit/regedit.c

   1 /*
   2  * Windows regedit.exe registry editor implementation.
   3  *
   4  * Copyright 2002 Andriy Palamarchuk
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <windows.h>
  24 #include <shellapi.h>
  25 #include "wine/unicode.h"
  26 #include "wine/debug.h"
  27 #include "regproc.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(regedit);
  30
  31 static void output_writeconsole(const WCHAR *str, DWORD wlen)
  32 {
  33     DWORD count, ret;
  34
  35     ret = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), str, wlen, &count, NULL);
  36     if (!ret)
  37     {
  38         DWORD len;
  39         char  *msgA;
  40
  41         /* WriteConsole() fails on Windows if its output is redirected. If this occurs,
  42          * we should call WriteFile() and assume the console encoding is still correct.
  43          */
  44         len = WideCharToMultiByte(GetConsoleOutputCP(), 0, str, wlen, NULL, 0, NULL, NULL);
  45         msgA = HeapAlloc(GetProcessHeap(), 0, len);
  46         if (!msgA) return;
  47
  48         WideCharToMultiByte(GetConsoleOutputCP(), 0, str, wlen, msgA, len, NULL, NULL);
  49         WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), msgA, len, &count, FALSE);
  50         HeapFree(GetProcessHeap(), 0, msgA);
  51     }
  52 }
  53
  54 static void output_formatstring(const WCHAR *fmt, __ms_va_list va_args)
  55 {
  56     WCHAR *str;
  57     DWORD len;
  58
  59     SetLastError(NO_ERROR);
  60     len = FormatMessageW(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER,
  61                          fmt, 0, 0, (WCHAR *)&str, 0, &va_args);
  62     if (len == 0 && GetLastError() != NO_ERROR)
  63     {
  64         WINE_FIXME("Could not format string: le=%u, fmt=%s\n", GetLastError(), wine_dbgstr_w(fmt));
  65         return;
  66     }
  67     output_writeconsole(str, len);
  68     LocalFree(str);
  69 }
  70
  71 void __cdecl output_message(unsigned int id, ...)
  72 {
  73     WCHAR fmt[1536];
  74     __ms_va_list va_args;
  75
  76     if (!LoadStringW(GetModuleHandleW(NULL), id, fmt, sizeof(fmt)/sizeof(*fmt)))
  77     {
  78         WINE_FIXME("LoadString failed with %d\n", GetLastError());
  79         return;
  80     }
  81     __ms_va_start(va_args, id);
  82     output_formatstring(fmt, va_args);
  83     __ms_va_end(va_args);
  84 }
  85
  86 void __cdecl error_exit(unsigned int id, ...)
  87 {
  88     WCHAR fmt[1536];
  89     __ms_va_list va_args;
  90
  91     if (!LoadStringW(GetModuleHandleW(NULL), id, fmt, sizeof(fmt)/sizeof(*fmt)))
  92     {
  93         WINE_FIXME("LoadString failed with %u\n", GetLastError());
  94         return;
  95     }
  96     __ms_va_start(va_args, id);
  97     output_formatstring(fmt, va_args);
  98     __ms_va_end(va_args);
  99
 100     exit(0); /* regedit.exe always terminates with error code zero */
 101 }
 102
 103 typedef enum {
 104     ACTION_ADD, ACTION_EXPORT, ACTION_DELETE
 105 } REGEDIT_ACTION;
 106
 107 static void PerformRegAction(REGEDIT_ACTION action, WCHAR **argv, int *i)
 108 {
 109     switch (action) {
 110     case ACTION_ADD: {
 111             WCHAR *filename = argv[*i];
 112             WCHAR hyphen[] = {'-',0};
 113             WCHAR *realname = NULL;
 114             FILE *reg_file;
 115
 116             if (!strcmpW(filename, hyphen))
 117                 reg_file = stdin;
 118             else
 119             {
 120                 int size;
 121                 WCHAR rb_mode[] = {'r','b',0};
 122
 123                 size = SearchPathW(NULL, filename, NULL, 0, NULL, NULL);
 124                 if (size > 0)
 125                 {
 126                     realname = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
 127                     size = SearchPathW(NULL, filename, NULL, size, realname, NULL);
 128                 }
 129                 if (size == 0)
 130                 {
 131                     output_message(STRING_FILE_NOT_FOUND, filename);
 132                     HeapFree(GetProcessHeap(), 0, realname);
 133                     return;
 134                 }
 135                 reg_file = _wfopen(realname, rb_mode);
 136                 if (reg_file == NULL)
 137                 {
 138                     WCHAR regedit[] = {'r','e','g','e','d','i','t',0};
 139                     _wperror(regedit);
 140                     output_message(STRING_CANNOT_OPEN_FILE, filename);
 141                     HeapFree(GetProcessHeap(), 0, realname);
 142                     return;
 143                 }
 144             }
 145             import_registry_file(reg_file);
 146             if (realname)
 147             {
 148                 HeapFree(GetProcessHeap(), 0, realname);
 149                 fclose(reg_file);
 150             }
 151             break;
 152         }
 153     case ACTION_DELETE:
 154             delete_registry_key(argv[*i]);
 155             break;
 156     case ACTION_EXPORT: {
 157             WCHAR *filename = argv[*i];
 158             WCHAR *key_name = argv[++(*i)];
 159
 160             if (key_name && *key_name)
 161                 export_registry_key(filename, key_name, REG_FORMAT_4);
 162             else
 163                 export_registry_key(filename, NULL, REG_FORMAT_4);
 164             break;
 165         }
 166     default:
 167         error_exit(STRING_UNHANDLED_ACTION);
 168         break;
 169     }
 170 }
 171
 172 BOOL ProcessCmdLine(WCHAR *cmdline)
 173 {
 174     WCHAR **argv;
 175     int argc, i;
 176     REGEDIT_ACTION action = ACTION_ADD;
 177
 178     argv = CommandLineToArgvW(cmdline, &argc);
 179
 180     if (!argv)
 181         return FALSE;
 182
 183     if (argc == 1)
 184     {
 185         LocalFree(argv);
 186         return FALSE;
 187     }
 188
 189     for (i = 1; i < argc; i++)
 190     {
 191         if (argv[i][0] != '/' && argv[i][0] != '-')
 192             break; /* No flags specified. */
 193
 194         if (!argv[i][1] && argv[i][0] == '-')
 195             break; /* '-' is a filename. It indicates we should use stdin. */
 196
 197         if (argv[i][1] && argv[i][2] && argv[i][2] != ':')
 198             break; /* This is a file path beginning with '/'. */
 199
 200         switch (toupperW(argv[i][1]))
 201         {
 202         case '?':
 203             error_exit(STRING_USAGE);
 204             break;
 205         case 'D':
 206             action = ACTION_DELETE;
 207             break;
 208         case 'E':
 209             action = ACTION_EXPORT;
 210             break;
 211         case 'C':
 212         case 'L':
 213         case 'R':
 214             /* unhandled */;
 215             break;
 216         case 'S':
 217         case 'V':
 218             /* ignored */;
 219             break;
 220         default:
 221             output_message(STRING_INVALID_SWITCH, argv[i]);
 222             error_exit(STRING_HELP);
 223         }
 224     }
 225
 226     if (i == argc)
 227     {
 228         switch (action)
 229         {
 230         case ACTION_ADD:
 231         case ACTION_EXPORT:
 232             output_message(STRING_NO_FILENAME);
 233             break;
 234         case ACTION_DELETE:
 235             output_message(STRING_NO_REG_KEY);
 236             break;
 237         }
 238         error_exit(STRING_HELP);
 239     }
 240
 241     for (; i < argc; i++)
 242         PerformRegAction(action, argv, &i);
 243
 244     LocalFree(argv);
 245
 246     return TRUE;
 247 }