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 <stdlib.h>
  22 #include <windows.h>
  23 #include <commctrl.h>
  24 #include <shellapi.h>
  25
  26 #include "wine/debug.h"
  27 #include "main.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(regedit);
  30
  31 static void output_writeconsole(const WCHAR *str, DWORD wlen)
  32 {
  33     DWORD count;
  34
  35     if (!WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), str, wlen, &count, NULL))
  36     {
  37         DWORD len;
  38         char  *msgA;
  39
  40         /* WriteConsole() fails on Windows if its output is redirected. If this occurs,
  41          * we should call WriteFile() with OEM code page.
  42          */
  43         len = WideCharToMultiByte(GetOEMCP(), 0, str, wlen, NULL, 0, NULL, NULL);
  44         msgA = malloc(len);
  45         if (!msgA) return;
  46
  47         WideCharToMultiByte(GetOEMCP(), 0, str, wlen, msgA, len, NULL, NULL);
  48         WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), msgA, len, &count, FALSE);
  49         free(msgA);
  50     }
  51 }
  52
  53 static void output_formatstring(const WCHAR *fmt, va_list va_args)
  54 {
  55     WCHAR *str;
  56     DWORD len;
  57
  58     len = FormatMessageW(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER,
  59                          fmt, 0, 0, (WCHAR *)&str, 0, &va_args);
  60     if (len == 0 && GetLastError() != ERROR_NO_WORK_DONE)
  61     {
  62         WINE_FIXME("Could not format string: le=%lu, fmt=%s\n", GetLastError(), wine_dbgstr_w(fmt));
  63         return;
  64     }
  65     output_writeconsole(str, len);
  66     LocalFree(str);
  67 }
  68
  69 void WINAPIV output_message(unsigned int id, ...)
  70 {
  71     WCHAR fmt[1536];
  72     va_list va_args;
  73
  74     if (!LoadStringW(GetModuleHandleW(NULL), id, fmt, ARRAY_SIZE(fmt)))
  75     {
  76         WINE_FIXME("LoadString failed with %ld\n", GetLastError());
  77         return;
  78     }
  79     va_start(va_args, id);
  80     output_formatstring(fmt, va_args);
  81     va_end(va_args);
  82 }
  83
  84 void WINAPIV error_exit(unsigned int id, ...)
  85 {
  86     WCHAR fmt[1536];
  87     va_list va_args;
  88
  89     if (!LoadStringW(GetModuleHandleW(NULL), id, fmt, ARRAY_SIZE(fmt)))
  90     {
  91         WINE_FIXME("LoadString failed with %lu\n", GetLastError());
  92         return;
  93     }
  94     va_start(va_args, id);
  95     output_formatstring(fmt, va_args);
  96     va_end(va_args);
  97
  98     exit(0); /* regedit.exe always terminates with error code zero */
  99 }
 100
 101 typedef enum {
 102     ACTION_ADD, ACTION_EXPORT, ACTION_DELETE
 103 } REGEDIT_ACTION;
 104
 105 static void PerformRegAction(REGEDIT_ACTION action, WCHAR **argv, int *i)
 106 {
 107     switch (action) {
 108     case ACTION_ADD: {
 109             WCHAR *filename = argv[*i];
 110             WCHAR *realname = NULL;
 111             FILE *reg_file;
 112
 113             if (!lstrcmpW(filename, L"-"))
 114                 reg_file = stdin;
 115             else
 116             {
 117                 int size;
 118
 119                 size = SearchPathW(NULL, filename, NULL, 0, NULL, NULL);
 120                 if (size > 0)
 121                 {
 122                     realname = malloc(size * sizeof(WCHAR));
 123                     size = SearchPathW(NULL, filename, NULL, size, realname, NULL);
 124                 }
 125                 if (size == 0)
 126                 {
 127                     output_message(STRING_FILE_NOT_FOUND, filename);
 128                     free(realname);
 129                     return;
 130                 }
 131                 reg_file = _wfopen(realname, L"rb");
 132                 if (reg_file == NULL)
 133                 {
 134                     _wperror(L"regedit");
 135                     output_message(STRING_CANNOT_OPEN_FILE, filename);
 136                     free(realname);
 137                     return;
 138                 }
 139             }
 140             import_registry_file(reg_file);
 141             if (realname)
 142             {
 143                 free(realname);
 144                 fclose(reg_file);
 145             }
 146             break;
 147         }
 148     case ACTION_DELETE:
 149             delete_registry_key(argv[*i]);
 150             break;
 151     case ACTION_EXPORT: {
 152             WCHAR *filename = argv[*i];
 153             WCHAR *key_name = argv[++(*i)];
 154
 155             if (key_name && *key_name)
 156                 export_registry_key(filename, key_name, REG_FORMAT_5);
 157             else
 158                 export_registry_key(filename, NULL, REG_FORMAT_5);
 159             break;
 160         }
 161     default:
 162         error_exit(STRING_UNHANDLED_ACTION);
 163         break;
 164     }
 165 }
 166
 167 BOOL ProcessCmdLine(WCHAR *cmdline)
 168 {
 169     WCHAR **argv;
 170     int argc, i;
 171     REGEDIT_ACTION action = ACTION_ADD;
 172
 173     argv = CommandLineToArgvW(cmdline, &argc);
 174
 175     if (!argv)
 176         return FALSE;
 177
 178     if (argc == 1)
 179     {
 180         LocalFree(argv);
 181         return FALSE;
 182     }
 183
 184     for (i = 1; i < argc; i++)
 185     {
 186         if (argv[i][0] != '/' && argv[i][0] != '-')
 187             break; /* No flags specified. */
 188
 189         if (!argv[i][1] && argv[i][0] == '-')
 190             break; /* '-' is a filename. It indicates we should use stdin. */
 191
 192         if (argv[i][1] && argv[i][2] && argv[i][2] != ':')
 193             break; /* This is a file path beginning with '/'. */
 194
 195         switch (towupper(argv[i][1]))
 196         {
 197         case '?':
 198             error_exit(STRING_USAGE);
 199             break;
 200         case 'D':
 201             action = ACTION_DELETE;
 202             break;
 203         case 'E':
 204             action = ACTION_EXPORT;
 205             break;
 206         case 'C':
 207         case 'L':
 208         case 'M':
 209         case 'R':
 210             /* unhandled */;
 211             break;
 212         case 'S':
 213         case 'V':
 214             /* ignored */;
 215             break;
 216         default:
 217             output_message(STRING_INVALID_SWITCH, argv[i]);
 218             error_exit(STRING_HELP);
 219         }
 220     }
 221
 222     if (i == argc)
 223     {
 224         switch (action)
 225         {
 226         case ACTION_ADD:
 227         case ACTION_EXPORT:
 228             output_message(STRING_NO_FILENAME);
 229             break;
 230         case ACTION_DELETE:
 231             output_message(STRING_NO_REG_KEY);
 232             break;
 233         }
 234         error_exit(STRING_HELP);
 235     }
 236
 237     for (; i < argc; i++)
 238         PerformRegAction(action, argv, &i);
 239
 240     LocalFree(argv);
 241
 242     return TRUE;
 243 }