git.oblomov.eu Git - wine/blob - programs/winecfg/winecfg.c

   1 /*
   2  * WineCfg configuration management
   3  *
   4  * Copyright 2002 Jaco Greeff
   5  * Copyright 2003 Dimitrie O. Paun
   6  * Copyright 2003-2004 Mike Hearn
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  *
  22  * TODO:
  23  *  - Use unicode
  24  *  - Icons in listviews/icons
  25  *  - Better add app dialog, scan c: for EXE files and add to list in background
  26  *  - Use [GNOME] HIG style groupboxes rather than win32 style (looks nicer, imho)
  27  *
  28  */
  29
  30 #define WIN32_LEAN_AND_MEAN
  31
  32 #include <assert.h>
  33 #include <stdio.h>
  34 #include <limits.h>
  35 #include <windows.h>
  36 #include <winreg.h>
  37 #include <wine/debug.h>
  38 #include <wine/list.h>
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(winecfg);
  41
  42 #include "winecfg.h"
  43 #include "resource.h"
  44
  45 HKEY config_key = NULL;
  46 HMENU hPopupMenus = 0;
  47
  48
  49 /* this is called from the WM_SHOWWINDOW handlers of each tab page.
  50  *
  51  * it's a nasty hack, necessary because the property sheet insists on resetting the window title
  52  * to the title of the tab, which is utterly useless. dropping the property sheet is on the todo list.
  53  */
  54 void set_window_title(HWND dialog)
  55 {
  56     char newtitle[256];
  57
  58     /* update the window title  */
  59     if (current_app)
  60     {
  61         char apptitle[256];
  62         LoadString(GetModuleHandle(NULL), IDS_WINECFG_TITLE_APP, apptitle, 256);
  63         sprintf(newtitle, apptitle, current_app);
  64     }
  65     else
  66     {
  67         LoadString(GetModuleHandle(NULL), IDS_WINECFG_TITLE, newtitle, 256);
  68     }
  69
  70     WINE_TRACE("setting title to %s\n", newtitle);
  71     SendMessage(GetParent(dialog), PSM_SETTITLE, 0, (LPARAM) newtitle);
  72 }
  73
  74
  75 /**
  76  * get_config_key: Retrieves a configuration value from the registry
  77  *
  78  * char *subkey : the name of the config section
  79  * char *name : the name of the config value
  80  * char *default : if the key isn't found, return this value instead
  81  *
  82  * Returns a buffer holding the value if successful, NULL if
  83  * not. Caller is responsible for releasing the result.
  84  *
  85  */
  86 static char *get_config_key (HKEY root, const char *subkey, const char *name, const char *def)
  87 {
  88     LPSTR buffer = NULL;
  89     DWORD len;
  90     HKEY hSubKey = NULL;
  91     DWORD res;
  92
  93     WINE_TRACE("subkey=%s, name=%s, def=%s\n", subkey, name, def);
  94
  95     res = RegOpenKey(root, subkey, &hSubKey);
  96     if (res != ERROR_SUCCESS)
  97     {
  98         if (res == ERROR_FILE_NOT_FOUND)
  99         {
 100             WINE_TRACE("Section key not present - using default\n");
 101             return def ? strdupA(def) : NULL;
 102         }
 103         else
 104         {
 105             WINE_ERR("RegOpenKey failed on wine config key (res=%ld)\n", res);
 106         }
 107         goto end;
 108     }
 109
 110     res = RegQueryValueExA(hSubKey, name, NULL, NULL, NULL, &len);
 111     if (res == ERROR_FILE_NOT_FOUND)
 112     {
 113         WINE_TRACE("Value not present - using default\n");
 114         buffer = def ? strdupA(def) : NULL;
 115         goto end;
 116     } else if (res != ERROR_SUCCESS)
 117     {
 118         WINE_ERR("Couldn't query value's length (res=%ld)\n", res);
 119         goto end;
 120     }
 121
 122     buffer = HeapAlloc(GetProcessHeap(), 0, len + 1);
 123
 124     RegQueryValueEx(hSubKey, name, NULL, NULL, (LPBYTE) buffer, &len);
 125
 126     WINE_TRACE("buffer=%s\n", buffer);
 127 end:
 128     if (hSubKey && hSubKey != root) RegCloseKey(hSubKey);
 129
 130     return buffer;
 131 }
 132
 133 /**
 134  * set_config_key: convenience wrapper to set a key/value pair
 135  *
 136  * const char *subKey : the name of the config section
 137  * const char *valueName : the name of the config value
 138  * const char *value : the value to set the configuration key to
 139  *
 140  * Returns 0 on success, non-zero otherwise
 141  *
 142  * If valueName or value is NULL, an empty section will be created
 143  */
 144 static int set_config_key(HKEY root, const char *subkey, const char *name, const void *value, DWORD type) {
 145     DWORD res = 1;
 146     HKEY key = NULL;
 147
 148     WINE_TRACE("subkey=%s: name=%s, value=%p, type=%ld\n", subkey, name, value, type);
 149
 150     assert( subkey != NULL );
 151
 152     if (subkey[0])
 153     {
 154         res = RegCreateKey(root, subkey, &key);
 155         if (res != ERROR_SUCCESS) goto end;
 156     }
 157     else key = root;
 158     if (name == NULL || value == NULL) goto end;
 159
 160     switch (type)
 161     {
 162         case REG_SZ: res = RegSetValueEx(key, name, 0, REG_SZ, value, strlen(value) + 1); break;
 163         case REG_DWORD: res = RegSetValueEx(key, name, 0, REG_DWORD, value, sizeof(DWORD)); break;
 164     }
 165     if (res != ERROR_SUCCESS) goto end;
 166
 167     res = 0;
 168 end:
 169     if (key && key != root) RegCloseKey(key);
 170     if (res != 0) WINE_ERR("Unable to set configuration key %s in section %s, res=%ld\n", name, subkey, res);
 171     return res;
 172 }
 173
 174 /* removes the requested value from the registry, however, does not
 175  * remove the section if empty. Returns S_OK (0) on success.
 176  */
 177 static HRESULT remove_value(HKEY root, const char *subkey, const char *name)
 178 {
 179     HRESULT hr;
 180     HKEY key;
 181
 182     WINE_TRACE("subkey=%s, name=%s\n", subkey, name);
 183
 184     hr = RegOpenKey(root, subkey, &key);
 185     if (hr != S_OK) return hr;
 186
 187     hr = RegDeleteValue(key, name);
 188     if (hr != ERROR_SUCCESS) return hr;
 189
 190     return S_OK;
 191 }
 192
 193 /* removes the requested subkey from the registry, assuming it exists */
 194 static LONG remove_path(HKEY root, char *section) {
 195     HKEY branch_key;
 196     DWORD max_sub_key_len;
 197     DWORD subkeys;
 198     DWORD curr_len;
 199     LONG ret = ERROR_SUCCESS;
 200     long int i;
 201     char *buffer;
 202
 203     WINE_TRACE("section=%s\n", section);
 204
 205     if ((ret = RegOpenKey(root, section, &branch_key)) != ERROR_SUCCESS)
 206         return ret;
 207
 208     /* get size information and resize the buffers if necessary */
 209     if ((ret = RegQueryInfoKey(branch_key, NULL, NULL, NULL,
 210                                &subkeys, &max_sub_key_len,
 211                                NULL, NULL, NULL, NULL, NULL, NULL
 212                               )) != ERROR_SUCCESS)
 213         return ret;
 214
 215     curr_len = strlen(section);
 216     buffer = HeapAlloc(GetProcessHeap(), 0, max_sub_key_len + curr_len + 1);
 217     strcpy(buffer, section);
 218
 219     buffer[curr_len] = '\\';
 220     for (i = subkeys - 1; i >= 0; i--)
 221     {
 222         DWORD buf_len = max_sub_key_len - curr_len - 1;
 223
 224         ret = RegEnumKeyEx(branch_key, i, buffer + curr_len + 1,
 225                            &buf_len, NULL, NULL, NULL, NULL);
 226         if (ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA &&
 227             ret != ERROR_NO_MORE_ITEMS)
 228             break;
 229         else
 230             remove_path(root, buffer);
 231     }
 232     HeapFree(GetProcessHeap(), 0, buffer);
 233     RegCloseKey(branch_key);
 234
 235     return RegDeleteKey(root, section);
 236 }
 237
 238
 239 /* ========================================================================= */
 240
 241 /* This code exists for the following reasons:
 242  *
 243  * - It makes working with the registry easier
 244  * - By storing a mini cache of the registry, we can more easily implement
 245  *   cancel/revert and apply. The 'settings list' is an overlay on top of
 246  *   the actual registry data that we can write out at will.
 247  *
 248  * Rather than model a tree in memory, we simply store each absolute (rooted
 249  * at the config key) path.
 250  *
 251  */
 252
 253 struct setting
 254 {
 255     struct list entry;
 256     HKEY root;    /* the key on which path is rooted */
 257     char *path;   /* path in the registry rooted at root  */
 258     char *name;   /* name of the registry value. if null, this means delete the key  */
 259     char *value;  /* contents of the registry value. if null, this means delete the value  */
 260     DWORD type;   /* type of registry value. REG_SZ or REG_DWORD for now */
 261 };
 262
 263 struct list *settings;
 264
 265 static void free_setting(struct setting *setting)
 266 {
 267     assert( setting != NULL );
 268     assert( setting->path );
 269
 270     WINE_TRACE("destroying %p: %s\n", setting, setting->path);
 271
 272     HeapFree(GetProcessHeap(), 0, setting->path);
 273     HeapFree(GetProcessHeap(), 0, setting->name);
 274     HeapFree(GetProcessHeap(), 0, setting->value);
 275
 276     list_remove(&setting->entry);
 277
 278     HeapFree(GetProcessHeap(), 0, setting);
 279 }
 280
 281 /**
 282  * Returns the contents of the value at path. If not in the settings
 283  * list, it will be fetched from the registry - failing that, the
 284  * default will be used.
 285  *
 286  * If already in the list, the contents as given there will be
 287  * returned. You are expected to HeapFree the result.
 288  */
 289 char *get_reg_key(HKEY root, const char *path, const char *name, const char *def)
 290 {
 291     struct list *cursor;
 292     struct setting *s;
 293     char *val;
 294
 295     WINE_TRACE("path=%s, name=%s, def=%s\n", path, name, def);
 296
 297     /* check if it's in the list */
 298     LIST_FOR_EACH( cursor, settings )
 299     {
 300         s = LIST_ENTRY(cursor, struct setting, entry);
 301
 302         if (root != s->root) continue;
 303         if (strcasecmp(path, s->path) != 0) continue;
 304         if (strcasecmp(name, s->name) != 0) continue;
 305
 306         WINE_TRACE("found %s:%s in settings list, returning %s\n", path, name, s->value);
 307         return s->value ? strdupA(s->value) : NULL;
 308     }
 309
 310     /* no, so get from the registry */
 311     val = get_config_key(root, path, name, def);
 312
 313     WINE_TRACE("returning %s\n", val);
 314
 315     return val;
 316 }
 317
 318 /**
 319  * Used to set a registry key.
 320  *
 321  * path is rooted at the config key, ie use "Version" or
 322  * "AppDefaults\\fooapp.exe\\Version". You can use keypath()
 323  * to get such a string.
 324  *
 325  * name is the value name, or NULL to delete the path.
 326  *
 327  * value is what to set the value to, or NULL to delete it.
 328  *
 329  * type is REG_SZ or REG_DWORD.
 330  *
 331  * These values will be copied when necessary.
 332  */
 333 static void set_reg_key_ex(HKEY root, const char *path, const char *name, const void *value, DWORD type)
 334 {
 335     struct list *cursor;
 336     struct setting *s;
 337
 338     assert( path != NULL );
 339
 340     WINE_TRACE("path=%s, name=%s, value=%p\n", path, name, value);
 341
 342     /* firstly, see if we already set this setting  */
 343     LIST_FOR_EACH( cursor, settings )
 344     {
 345         struct setting *s = LIST_ENTRY(cursor, struct setting, entry);
 346
 347         if (root != s->root) continue;
 348         if (strcasecmp(s->path, path) != 0) continue;
 349         if ((s->name && name) && strcasecmp(s->name, name) != 0) continue;
 350
 351         /* are we attempting a double delete? */
 352         if (!s->name && !name) return;
 353
 354         /* do we want to undelete this key? */
 355         if (!s->name && name) s->name = strdupA(name);
 356
 357         /* yes, we have already set it, so just replace the content and return  */
 358         HeapFree(GetProcessHeap(), 0, s->value);
 359         s->type = type;
 360         switch (type)
 361         {
 362             case REG_SZ:
 363                 s->value = value ? strdupA(value) : NULL;
 364                 break;
 365             case REG_DWORD:
 366                 s->value = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD));
 367                 memcpy( s->value, value, sizeof(DWORD) );
 368                 break;
 369         }
 370
 371         /* are we deleting this key? this won't remove any of the
 372          * children from the overlay so if the user adds it again in
 373          * that session it will appear to undelete the settings, but
 374          * in reality only the settings actually modified by the user
 375          * in that session will be restored. we might want to fix this
 376          * corner case in future by actually deleting all the children
 377          * here so that once it's gone, it's gone.
 378          */
 379         if (!name) s->name = NULL;
 380
 381         return;
 382     }
 383
 384     /* otherwise add a new setting for it  */
 385     s = HeapAlloc(GetProcessHeap(), 0, sizeof(struct setting));
 386     s->root  = root;
 387     s->path  = strdupA(path);
 388     s->name  = name  ? strdupA(name)  : NULL;
 389     s->type  = type;
 390     switch (type)
 391     {
 392         case REG_SZ:
 393             s->value = value ? strdupA(value) : NULL;
 394             break;
 395         case REG_DWORD:
 396             s->value = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD));
 397             memcpy( s->value, value, sizeof(DWORD) );
 398             break;
 399     }
 400
 401     list_add_tail(settings, &s->entry);
 402 }
 403
 404 void set_reg_key(HKEY root, const char *path, const char *name, const char *value)
 405 {
 406     set_reg_key_ex(root, path, name, value, REG_SZ);
 407 }
 408
 409 void set_reg_key_dword(HKEY root, const char *path, const char *name, DWORD value)
 410 {
 411     set_reg_key_ex(root, path, name, &value, REG_DWORD);
 412 }
 413
 414 /**
 415  * enumerates the value names at the given path, taking into account
 416  * the changes in the settings list.
 417  *
 418  * you are expected to HeapFree each element of the array, which is null
 419  * terminated, as well as the array itself.
 420  */
 421 char **enumerate_values(HKEY root, char *path)
 422 {
 423     HKEY key;
 424     DWORD res, i = 0;
 425     char **values = NULL;
 426     int valueslen = 0;
 427     struct list *cursor;
 428
 429     res = RegOpenKey(root, path, &key);
 430     if (res == ERROR_SUCCESS)
 431     {
 432         while (TRUE)
 433         {
 434             char name[1024];
 435             DWORD namesize = sizeof(name);
 436             BOOL removed = FALSE;
 437
 438             /* find out the needed size, allocate a buffer, read the value  */
 439             if ((res = RegEnumValue(key, i, name, &namesize, NULL, NULL, NULL, NULL)) != ERROR_SUCCESS)
 440                 break;
 441
 442             WINE_TRACE("name=%s\n", name);
 443
 444             /* check if this value name has been removed in the settings list  */
 445             LIST_FOR_EACH( cursor, settings )
 446             {
 447                 struct setting *s = LIST_ENTRY(cursor, struct setting, entry);
 448                 if (strcasecmp(s->path, path) != 0) continue;
 449                 if (strcasecmp(s->name, name) != 0) continue;
 450
 451                 if (!s->value)
 452                 {
 453                     WINE_TRACE("this key has been removed, so skipping\n");
 454                     removed = TRUE;
 455                     break;
 456                 }
 457             }
 458
 459             if (removed)            /* this value was deleted by the user, so don't include it */
 460             {
 461                 HeapFree(GetProcessHeap(), 0, name);
 462                 i++;
 463                 continue;
 464             }
 465
 466             /* grow the array if necessary, add buffer to it, iterate  */
 467             if (values) values = HeapReAlloc(GetProcessHeap(), 0, values, sizeof(char*) * (valueslen + 1));
 468             else values = HeapAlloc(GetProcessHeap(), 0, sizeof(char*));
 469
 470             values[valueslen++] = strdupA(name);
 471             WINE_TRACE("valueslen is now %d\n", valueslen);
 472             i++;
 473         }
 474     }
 475     else
 476     {
 477         WINE_WARN("failed opening registry key %s, res=0x%lx\n", path, res);
 478     }
 479
 480     WINE_TRACE("adding settings in list but not registry\n");
 481
 482     /* now we have to add the values that aren't in the registry but are in the settings list */
 483     LIST_FOR_EACH( cursor, settings )
 484     {
 485         struct setting *setting = LIST_ENTRY(cursor, struct setting, entry);
 486         BOOL found = FALSE;
 487
 488         if (strcasecmp(setting->path, path) != 0) continue;
 489
 490         if (!setting->value) continue;
 491
 492         for (i = 0; i < valueslen; i++)
 493         {
 494             if (strcasecmp(setting->name, values[i]) == 0)
 495             {
 496                 found = TRUE;
 497                 break;
 498             }
 499         }
 500
 501         if (found) continue;
 502
 503         WINE_TRACE("%s in list but not registry\n", setting->name);
 504
 505         /* otherwise it's been set by the user but isn't in the registry */
 506         if (values) values = HeapReAlloc(GetProcessHeap(), 0, values, sizeof(char*) * (valueslen + 1));
 507         else values = HeapAlloc(GetProcessHeap(), 0, sizeof(char*));
 508
 509         values[valueslen++] = strdupA(setting->name);
 510     }
 511
 512     WINE_TRACE("adding null terminator\n");
 513     if (values)
 514     {
 515         values = HeapReAlloc(GetProcessHeap(), 0, values, sizeof(char*) * (valueslen + 1));
 516         values[valueslen] = NULL;
 517     }
 518
 519     RegCloseKey(key);
 520
 521     return values;
 522 }
 523
 524 /**
 525  * returns true if the given key/value pair exists in the registry or
 526  * has been written to.
 527  */
 528 BOOL reg_key_exists(HKEY root, const char *path, const char *name)
 529 {
 530     char *val = get_reg_key(root, path, name, NULL);
 531
 532     if (val)
 533     {
 534         HeapFree(GetProcessHeap(), 0, val);
 535         return TRUE;
 536     }
 537
 538     return FALSE;
 539 }
 540
 541 static void process_setting(struct setting *s)
 542 {
 543     if (s->value)
 544     {
 545         WINE_TRACE("Setting %s:%s to '%s'\n", s->path, s->name, s->value);
 546         set_config_key(s->root, s->path, s->name, s->value, s->type);
 547     }
 548     else
 549     {
 550         /* NULL name means remove that path/section entirely */
 551         if (s->path && s->name) remove_value(s->root, s->path, s->name);
 552         else if (s->path && !s->name) remove_path(s->root, s->path);
 553     }
 554 }
 555
 556 void apply(void)
 557 {
 558     if (list_empty(settings)) return; /* we will be called for each page when the user clicks OK */
 559
 560     WINE_TRACE("()\n");
 561
 562     while (!list_empty(settings))
 563     {
 564         struct setting *s = (struct setting *) list_head(settings);
 565         process_setting(s);
 566         free_setting(s);
 567     }
 568 }
 569
 570 /* ================================== utility functions ============================ */
 571
 572 char *current_app = NULL; /* the app we are currently editing, or NULL if editing global */
 573
 574 /* returns a registry key path suitable for passing to addTransaction  */
 575 char *keypath(const char *section)
 576 {
 577     static char *result = NULL;
 578
 579     HeapFree(GetProcessHeap(), 0, result);
 580
 581     if (current_app)
 582     {
 583         result = HeapAlloc(GetProcessHeap(), 0, strlen("AppDefaults\\") + strlen(current_app) + 2 /* \\ */ + strlen(section) + 1 /* terminator */);
 584         sprintf(result, "AppDefaults\\%s", current_app);
 585         if (section[0]) sprintf( result + strlen(result), "\\%s", section );
 586     }
 587     else
 588     {
 589         result = strdupA(section);
 590     }
 591
 592     return result;
 593 }
 594
 595 void PRINTERROR(void)
 596 {
 597         LPSTR msg;
 598
 599         FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
 600                        0, GetLastError(), MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),
 601                        (LPSTR)&msg, 0, NULL);
 602
 603         /* eliminate trailing newline, is this a Wine bug? */
 604         *(strrchr(msg, '\r')) = '\0';
 605
 606         WINE_TRACE("error: '%s'\n", msg);
 607 }
 608
 609 int initialize(HINSTANCE hInstance)
 610 {
 611     DWORD res = RegCreateKey(HKEY_CURRENT_USER, WINE_KEY_ROOT, &config_key);
 612
 613     if (res != ERROR_SUCCESS) {
 614         WINE_ERR("RegOpenKey failed on wine config key (%ld)\n", res);
 615         return 1;
 616     }
 617
 618     /* load any menus */
 619     hPopupMenus = LoadMenu(hInstance, MAKEINTRESOURCE(IDR_WINECFG));
 620
 621     /* we could probably just have the list as static data  */
 622     settings = HeapAlloc(GetProcessHeap(), 0, sizeof(struct list));
 623     list_init(settings);
 624
 625     return 0;
 626 }