programs/reg/export.c

   1 /*
   2  * Copyright 2017 Hugh McMaster
   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 <stdlib.h>
  21
  22 #include <wine/unicode.h>
  23 #include <wine/heap.h>
  24
  25 #include "reg.h"
  26
  27 static void write_file(HANDLE hFile, const WCHAR *str)
  28 {
  29     DWORD written;
  30
  31     WriteFile(hFile, str, lstrlenW(str) * sizeof(WCHAR), &written, NULL);
  32 }
  33
  34 static WCHAR *escape_string(WCHAR *str, size_t str_len, size_t *line_len)
  35 {
  36     size_t i, escape_count, pos;
  37     WCHAR *buf;
  38
  39     for (i = 0, escape_count = 0; i < str_len; i++)
  40     {
  41         WCHAR c = str[i];
  42
  43         if (!c) break;
  44
  45         if (c == '\r' || c == '\n' || c == '\\' || c == '"')
  46             escape_count++;
  47     }
  48
  49     buf = heap_xalloc((str_len + escape_count + 1) * sizeof(WCHAR));
  50
  51     for (i = 0, pos = 0; i < str_len; i++, pos++)
  52     {
  53         WCHAR c = str[i];
  54
  55         if (!c) break;
  56
  57         switch (c)
  58         {
  59         case '\r':
  60             buf[pos++] = '\\';
  61             buf[pos] = 'r';
  62             break;
  63         case '\n':
  64             buf[pos++] = '\\';
  65             buf[pos] = 'n';
  66             break;
  67         case '\\':
  68             buf[pos++] = '\\';
  69             buf[pos] = '\\';
  70             break;
  71         case '"':
  72             buf[pos++] = '\\';
  73             buf[pos] = '"';
  74             break;
  75         default:
  76             buf[pos] = c;
  77         }
  78     }
  79
  80     buf[pos] = 0;
  81     *line_len = pos;
  82     return buf;
  83 }
  84
  85 static size_t export_value_name(HANDLE hFile, WCHAR *name, size_t len)
  86 {
  87     static const WCHAR quoted_fmt[] = {'"','%','s','"','=',0};
  88     static const WCHAR default_name[] = {'@','=',0};
  89     size_t line_len;
  90
  91     if (name && *name)
  92     {
  93         WCHAR *str = escape_string(name, len, &line_len);
  94         WCHAR *buf = heap_xalloc((line_len + 4) * sizeof(WCHAR));
  95         line_len = sprintfW(buf, quoted_fmt, str);
  96         write_file(hFile, buf);
  97         heap_free(buf);
  98         heap_free(str);
  99     }
 100     else
 101     {
 102         line_len = lstrlenW(default_name);
 103         write_file(hFile, default_name);
 104     }
 105
 106     return line_len;
 107 }
 108
 109 static void export_string_data(WCHAR **buf, WCHAR *data, size_t size)
 110 {
 111     size_t len = 0, line_len;
 112     WCHAR *str;
 113     static const WCHAR fmt[] = {'"','%','s','"',0};
 114
 115     if (size)
 116         len = size / sizeof(WCHAR) - 1;
 117     str = escape_string(data, len, &line_len);
 118     *buf = heap_xalloc((line_len + 3) * sizeof(WCHAR));
 119     sprintfW(*buf, fmt, str);
 120     heap_free(str);
 121 }
 122
 123 static void export_dword_data(WCHAR **buf, DWORD *data)
 124 {
 125     static const WCHAR fmt[] = {'d','w','o','r','d',':','%','0','8','x',0};
 126
 127     *buf = heap_xalloc(15 * sizeof(WCHAR));
 128     sprintfW(*buf, fmt, *data);
 129 }
 130
 131 static size_t export_hex_data_type(HANDLE hFile, DWORD type)
 132 {
 133     static const WCHAR hex[] = {'h','e','x',':',0};
 134     static const WCHAR hexp_fmt[] = {'h','e','x','(','%','x',')',':',0};
 135     size_t line_len;
 136
 137     if (type == REG_BINARY)
 138     {
 139         line_len = lstrlenW(hex);
 140         write_file(hFile, hex);
 141     }
 142     else
 143     {
 144         WCHAR *buf = heap_xalloc(15 * sizeof(WCHAR));
 145         line_len = sprintfW(buf, hexp_fmt, type);
 146         write_file(hFile, buf);
 147         heap_free(buf);
 148     }
 149
 150     return line_len;
 151 }
 152
 153 #define MAX_HEX_CHARS 77
 154
 155 static void export_hex_data(HANDLE hFile, WCHAR **buf, DWORD type,
 156                             DWORD line_len, void *data, DWORD size)
 157 {
 158     static const WCHAR fmt[] = {'%','0','2','x',0};
 159     static const WCHAR hex_concat[] = {'\\','\r','\n',' ',' ',0};
 160     size_t num_commas, i, pos;
 161
 162     line_len += export_hex_data_type(hFile, type);
 163
 164     if (!size) return;
 165
 166     num_commas = size - 1;
 167     *buf = heap_xalloc(size * 3 * sizeof(WCHAR));
 168
 169     for (i = 0, pos = 0; i < size; i++)
 170     {
 171         pos += sprintfW(*buf + pos, fmt, ((BYTE *)data)[i]);
 172         if (i == num_commas) break;
 173         (*buf)[pos++] = ',';
 174         (*buf)[pos] = 0;
 175         line_len += 3;
 176
 177         if (line_len >= MAX_HEX_CHARS)
 178         {
 179             write_file(hFile, *buf);
 180             write_file(hFile, hex_concat);
 181             line_len = 2;
 182             pos = 0;
 183         }
 184     }
 185 }
 186
 187 static void export_newline(HANDLE hFile)
 188 {
 189     static const WCHAR newline[] = {'\r','\n',0};
 190
 191     write_file(hFile, newline);
 192 }
 193
 194 static void export_data(HANDLE hFile, WCHAR *value_name, DWORD value_len,
 195                         DWORD type, void *data, size_t size)
 196 {
 197     WCHAR *buf = NULL;
 198     size_t line_len = export_value_name(hFile, value_name, value_len);
 199
 200     switch (type)
 201     {
 202     case REG_SZ:
 203         export_string_data(&buf, data, size);
 204         break;
 205     case REG_DWORD:
 206         if (size)
 207         {
 208             export_dword_data(&buf, data);
 209             break;
 210         }
 211         /* fall through */
 212     case REG_NONE:
 213     case REG_EXPAND_SZ:
 214     case REG_BINARY:
 215     case REG_MULTI_SZ:
 216     default:
 217         export_hex_data(hFile, &buf, type, line_len, data, size);
 218         break;
 219     }
 220
 221     if (size || type == REG_SZ)
 222     {
 223         write_file(hFile, buf);
 224         heap_free(buf);
 225     }
 226
 227     export_newline(hFile);
 228 }
 229
 230 static void export_key_name(HANDLE hFile, WCHAR *name)
 231 {
 232     static const WCHAR fmt[] = {'\r','\n','[','%','s',']','\r','\n',0};
 233     WCHAR *buf;
 234
 235     buf = heap_xalloc((lstrlenW(name) + 7) * sizeof(WCHAR));
 236     sprintfW(buf, fmt, name);
 237     write_file(hFile, buf);
 238     heap_free(buf);
 239 }
 240
 241 static int export_registry_data(HANDLE hFile, HKEY key, WCHAR *path)
 242 {
 243     LONG rc;
 244     DWORD max_value_len = 256, value_len;
 245     DWORD max_data_bytes = 2048, data_size;
 246     DWORD subkey_len;
 247     DWORD i, type, path_len;
 248     WCHAR *value_name, *subkey_name, *subkey_path;
 249     BYTE *data;
 250     HKEY subkey;
 251
 252     export_key_name(hFile, path);
 253
 254     value_name = heap_xalloc(max_value_len * sizeof(WCHAR));
 255     data = heap_xalloc(max_data_bytes);
 256
 257     i = 0;
 258     for (;;)
 259     {
 260         value_len = max_value_len;
 261         data_size = max_data_bytes;
 262         rc = RegEnumValueW(key, i, value_name, &value_len, NULL, &type, data, &data_size);
 263
 264         if (rc == ERROR_SUCCESS)
 265         {
 266             export_data(hFile, value_name, value_len, type, data, data_size);
 267             i++;
 268         }
 269         else if (rc == ERROR_MORE_DATA)
 270         {
 271             if (data_size > max_data_bytes)
 272             {
 273                 max_data_bytes = data_size;
 274                 data = heap_xrealloc(data, max_data_bytes);
 275             }
 276             else
 277             {
 278                 max_value_len *= 2;
 279                 value_name = heap_xrealloc(value_name, max_value_len * sizeof(WCHAR));
 280             }
 281         }
 282         else break;
 283     }
 284
 285     heap_free(data);
 286     heap_free(value_name);
 287
 288     subkey_name = heap_xalloc(MAX_SUBKEY_LEN * sizeof(WCHAR));
 289
 290     path_len = lstrlenW(path);
 291
 292     i = 0;
 293     for (;;)
 294     {
 295         subkey_len = MAX_SUBKEY_LEN;
 296         rc = RegEnumKeyExW(key, i, subkey_name, &subkey_len, NULL, NULL, NULL, NULL);
 297         if (rc == ERROR_SUCCESS)
 298         {
 299             subkey_path = build_subkey_path(path, path_len, subkey_name, subkey_len);
 300             if (!RegOpenKeyExW(key, subkey_name, 0, KEY_READ, &subkey))
 301             {
 302                 export_registry_data(hFile, subkey, subkey_path);
 303                 RegCloseKey(subkey);
 304             }
 305             heap_free(subkey_path);
 306             i++;
 307         }
 308         else break;
 309     }
 310
 311     heap_free(subkey_name);
 312     return 0;
 313 }
 314
 315 static void export_file_header(HANDLE hFile)
 316 {
 317     static const WCHAR header[] = { 0xfeff,'W','i','n','d','o','w','s',' ',
 318                                    'R','e','g','i','s','t','r','y',' ','E','d','i','t','o','r',' ',
 319                                    'V','e','r','s','i','o','n',' ','5','.','0','0','\r','\n'};
 320
 321     write_file(hFile, header);
 322 }
 323
 324 static HANDLE create_file(const WCHAR *filename, DWORD action)
 325 {
 326     return CreateFileW(filename, GENERIC_WRITE, 0, NULL, action, FILE_ATTRIBUTE_NORMAL, NULL);
 327 }
 328
 329 static HANDLE get_file_handle(WCHAR *filename, BOOL overwrite_file)
 330 {
 331     HANDLE hFile = create_file(filename, overwrite_file ? CREATE_ALWAYS : CREATE_NEW);
 332
 333     if (hFile == INVALID_HANDLE_VALUE)
 334     {
 335         DWORD error = GetLastError();
 336
 337         if (error == ERROR_FILE_EXISTS)
 338         {
 339             if (!ask_confirm(STRING_OVERWRITE_FILE, filename))
 340             {
 341                 output_message(STRING_CANCELLED);
 342                 exit(0);
 343             }
 344
 345             hFile = create_file(filename, CREATE_ALWAYS);
 346         }
 347         else
 348         {
 349             WCHAR *str;
 350
 351             FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
 352                            FORMAT_MESSAGE_IGNORE_INSERTS, NULL, error, 0, (WCHAR *)&str, 0, NULL);
 353             output_writeconsole(str, lstrlenW(str));
 354             LocalFree(str);
 355             exit(1);
 356         }
 357     }
 358
 359     return hFile;
 360 }
 361
 362 static BOOL is_overwrite_switch(const WCHAR *s)
 363 {
 364     if (strlenW(s) > 2)
 365         return FALSE;
 366
 367     if ((s[0] == '/' || s[0] == '-') && (s[1] == 'y' || s[1] == 'Y'))
 368         return TRUE;
 369
 370     return FALSE;
 371 }
 372
 373 int reg_export(int argc, WCHAR *argv[])
 374 {
 375     HKEY root, hkey;
 376     WCHAR *path, *long_key;
 377     BOOL overwrite_file = FALSE;
 378     HANDLE hFile;
 379     int ret;
 380
 381     if (argc == 3 || argc > 5)
 382         goto error;
 383
 384     if (!parse_registry_key(argv[2], &root, &path, &long_key))
 385         return 1;
 386
 387     if (argc == 5 && !(overwrite_file = is_overwrite_switch(argv[4])))
 388         goto error;
 389
 390     if (RegOpenKeyExW(root, path, 0, KEY_READ, &hkey))
 391     {
 392         output_message(STRING_INVALID_KEY);
 393         return 1;
 394     }
 395
 396     hFile = get_file_handle(argv[3], overwrite_file);
 397     export_file_header(hFile);
 398     ret = export_registry_data(hFile, hkey, long_key);
 399     export_newline(hFile);
 400     CloseHandle(hFile);
 401
 402     RegCloseKey(hkey);
 403
 404     return ret;
 405
 406 error:
 407     output_message(STRING_INVALID_SYNTAX);
 408     output_message(STRING_FUNC_HELP, struprW(argv[1]));
 409     return 1;
 410 }