WINGs/userdefaults.c

   1
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <stdio.h>
   5 #include <assert.h>
   6 #include <unistd.h>
   7 #include <sys/stat.h>
   8
   9 #include "wconfig.h"
  10
  11 #include "WINGs.h"
  12
  13 typedef struct W_UserDefaults {
  14         WMPropList *defaults;
  15
  16         WMPropList *appDomain;
  17
  18         WMPropList *searchListArray;
  19         WMPropList **searchList;        /* cache for searchListArray */
  20
  21         char dirty;
  22
  23         char dontSync;
  24
  25         char *path;             /* where is db located */
  26
  27         time_t timestamp;       /* last modification time */
  28
  29         struct W_UserDefaults *next;
  30
  31 } UserDefaults;
  32
  33 static UserDefaults *sharedUserDefaults = NULL;
  34
  35 char *WMUserDefaultsDidChangeNotification = "WMUserDefaultsDidChangeNotification";
  36
  37 static void synchronizeUserDefaults(void *foo);
  38
  39 extern char *WMGetApplicationName();
  40
  41 #define DEFAULTS_DIR "/Defaults"
  42 #ifndef HAVE_INOTIFY
  43 /* Check defaults database for changes every this many milliseconds */
  44 /* XXX: this is shared with src/ stuff, put it in some common header */
  45 #define UD_SYNC_INTERVAL        2000
  46 #endif
  47
  48 char *wusergnusteppath()
  49 {
  50         static char *path = NULL;
  51         char *gspath;
  52         int pathlen;
  53
  54         gspath = getenv("GNUSTEP_USER_ROOT");
  55         if (gspath) {
  56                 gspath = wexpandpath(gspath);
  57                 if (gspath) {
  58                         pathlen = strlen(gspath) + 4;
  59                         path = wmalloc(pathlen);
  60                         if (wstrlcpy(path, gspath, pathlen) >= pathlen) {
  61                                 wfree(gspath);
  62                                 return NULL;
  63                         }
  64                         wfree(gspath);
  65                 }
  66         } else {
  67                 char *h = wgethomedir();
  68                 if (!h)
  69                         return NULL;
  70                 pathlen = strlen(h) + 8 /* /GNUstep */ + 1;
  71                 path = wmalloc(pathlen);
  72                 if (wstrlcpy(path, h, pathlen) >= pathlen ||
  73                     wstrlcat(path, "/GNUstep", pathlen) >= pathlen) {
  74                         wfree(path);
  75                         return NULL;
  76                 }
  77         }
  78
  79         return path;
  80 }
  81
  82 char *wdefaultspathfordomain(char *domain)
  83 {
  84         char *path;
  85         char *gspath;
  86         size_t slen;
  87
  88         gspath = wusergnusteppath();
  89         slen = strlen(gspath) + strlen(DEFAULTS_DIR) + strlen(domain) + 4;
  90         path = wmalloc(slen);
  91
  92         if (wstrlcpy(path, gspath, slen) >= slen ||
  93             wstrlcat(path, DEFAULTS_DIR, slen) >= slen ||
  94             wstrlcat(path, "/", slen) >= slen ||
  95             wstrlcat(path, domain, slen) >= slen) {
  96                 wfree(path);
  97                 return NULL;
  98         }
  99
 100         return path;
 101 }
 102
 103 /* XXX: doesn't quite belong to *user*defaults.c */
 104 #ifndef GLOBAL_DEFAULTS_SUBDIR
 105 #define GLOBAL_DEFAULTS_SUBDIR "WindowMaker"
 106 #endif
 107 char *wglobaldefaultspathfordomain(const char *domain)
 108 {
 109         char *t = NULL;
 110         size_t len;
 111
 112         len = strlen( SYSCONFDIR ) + strlen( GLOBAL_DEFAULTS_SUBDIR ) + strlen(domain) + 3;
 113         t = wmalloc(len);
 114         snprintf(t, len, "%s/%s/%s", SYSCONFDIR, GLOBAL_DEFAULTS_SUBDIR, domain);
 115
 116         return t;
 117 }
 118
 119 static void
 120 saveDefaultsChanges(void)
 121 {
 122         /* save the user defaults databases */
 123         synchronizeUserDefaults(NULL);
 124 }
 125
 126 /* set to save changes in defaults when program is exited */
 127 static void registerSaveOnExit(void)
 128 {
 129         static Bool registeredSaveOnExit = False;
 130
 131         if (!registeredSaveOnExit) {
 132                 atexit(saveDefaultsChanges);
 133                 registeredSaveOnExit = True;
 134         }
 135 }
 136
 137 static void synchronizeUserDefaults(void *foo)
 138 {
 139         UserDefaults *database = sharedUserDefaults;
 140
 141         while (database) {
 142                 if (!database->dontSync)
 143                         WMSynchronizeUserDefaults(database);
 144                 database = database->next;
 145         }
 146 }
 147
 148 #ifndef HAVE_INOTIFY
 149 static void addSynchronizeTimerHandler(void)
 150 {
 151         static Bool initialized = False;
 152
 153         if (!initialized) {
 154                 WMAddPersistentTimerHandler(UD_SYNC_INTERVAL,
 155                     synchronizeUserDefaults, NULL);
 156                 initialized = True;
 157         }
 158 }
 159 #endif
 160
 161 void WMEnableUDPeriodicSynchronization(WMUserDefaults * database, Bool enable)
 162 {
 163         database->dontSync = !enable;
 164 }
 165
 166 void WMSynchronizeUserDefaults(WMUserDefaults * database)
 167 {
 168         Bool fileIsNewer = False, release = False, notify = False;
 169         WMPropList *plF, *key;
 170         char *path;
 171         struct stat stbuf;
 172
 173         if (!database->path) {
 174                 path = wdefaultspathfordomain(WMGetApplicationName());
 175                 release = True;
 176         } else {
 177                 path = database->path;
 178         }
 179
 180         if (stat(path, &stbuf) >= 0 && stbuf.st_mtime > database->timestamp)
 181                 fileIsNewer = True;
 182
 183         if (database->appDomain && (database->dirty || fileIsNewer)) {
 184                 if (database->dirty && fileIsNewer) {
 185                         plF = WMReadPropListFromFile(path);
 186                         if (plF) {
 187                                 plF = WMMergePLDictionaries(plF, database->appDomain, False);
 188                                 WMReleasePropList(database->appDomain);
 189                                 database->appDomain = plF;
 190                                 key = database->searchList[0];
 191                                 WMPutInPLDictionary(database->defaults, key, plF);
 192                                 notify = True;
 193                         } else {
 194                                 /* something happened with the file. just overwrite it */
 195                                 wwarning(_("cannot read domain from file '%s' when syncing"), path);
 196                                 WMWritePropListToFile(database->appDomain, path);
 197                         }
 198                 } else if (database->dirty) {
 199                         WMWritePropListToFile(database->appDomain, path);
 200                 } else if (fileIsNewer) {
 201                         plF = WMReadPropListFromFile(path);
 202                         if (plF) {
 203                                 WMReleasePropList(database->appDomain);
 204                                 database->appDomain = plF;
 205                                 key = database->searchList[0];
 206                                 WMPutInPLDictionary(database->defaults, key, plF);
 207                                 notify = True;
 208                         } else {
 209                                 /* something happened with the file. just overwrite it */
 210                                 wwarning(_("cannot read domain from file '%s' when syncing"), path);
 211                                 WMWritePropListToFile(database->appDomain, path);
 212                         }
 213                 }
 214
 215                 database->dirty = 0;
 216
 217                 if (stat(path, &stbuf) >= 0)
 218                         database->timestamp = stbuf.st_mtime;
 219
 220                 if (notify) {
 221                         WMPostNotificationName(WMUserDefaultsDidChangeNotification, database, NULL);
 222                 }
 223         }
 224
 225         if (release)
 226                 wfree(path);
 227
 228 }
 229
 230 void WMSaveUserDefaults(WMUserDefaults * database)
 231 {
 232         if (database->appDomain) {
 233                 struct stat stbuf;
 234                 char *path;
 235                 Bool release = False;
 236
 237                 if (!database->path) {
 238                         path = wdefaultspathfordomain(WMGetApplicationName());
 239                         release = True;
 240                 } else {
 241                         path = database->path;
 242                 }
 243                 WMWritePropListToFile(database->appDomain, path);
 244                 database->dirty = 0;
 245                 if (stat(path, &stbuf) >= 0)
 246                         database->timestamp = stbuf.st_mtime;
 247                 if (release)
 248                         wfree(path);
 249         }
 250 }
 251
 252 WMUserDefaults *WMGetStandardUserDefaults(void)
 253 {
 254         WMUserDefaults *defaults;
 255         WMPropList *domain;
 256         WMPropList *key;
 257         struct stat stbuf;
 258         char *path;
 259         int i;
 260
 261         if (sharedUserDefaults) {
 262                 defaults = sharedUserDefaults;
 263                 while (defaults) {
 264                         /* path == NULL only for StandardUserDefaults db */
 265                         if (defaults->path == NULL)
 266                                 return defaults;
 267                         defaults = defaults->next;
 268                 }
 269         }
 270
 271         /* we didn't found the database we are looking for. Go read it. XXX: wtf? */
 272         defaults = wmalloc(sizeof(WMUserDefaults));
 273         defaults->defaults = WMCreatePLDictionary(NULL, NULL);
 274         defaults->searchList = wmalloc(sizeof(WMPropList *) * 3);
 275
 276         /* application domain */
 277         key = WMCreatePLString(WMGetApplicationName());
 278         defaults->searchList[0] = key;
 279
 280         /* temporary kluge. wmaker handles synchronization itself */
 281         if (strcmp(WMGetApplicationName(), "WindowMaker") == 0) {
 282                 defaults->dontSync = 1;
 283         }
 284
 285         path = wdefaultspathfordomain(WMGetFromPLString(key));
 286
 287         if (stat(path, &stbuf) >= 0)
 288                 defaults->timestamp = stbuf.st_mtime;
 289
 290         domain = WMReadPropListFromFile(path);
 291
 292         if (!domain)
 293                 domain = WMCreatePLDictionary(NULL, NULL);
 294
 295         if (path)
 296                 wfree(path);
 297
 298         defaults->appDomain = domain;
 299
 300         if (domain)
 301                 WMPutInPLDictionary(defaults->defaults, key, domain);
 302
 303         /* global domain */
 304         key = WMCreatePLString("WMGLOBAL");
 305         defaults->searchList[1] = key;
 306
 307         path = wdefaultspathfordomain(WMGetFromPLString(key));
 308
 309         domain = WMReadPropListFromFile(path);
 310
 311         wfree(path);
 312
 313         if (!domain)
 314                 domain = WMCreatePLDictionary(NULL, NULL);
 315
 316         if (domain)
 317                 WMPutInPLDictionary(defaults->defaults, key, domain);
 318
 319         /* terminate list */
 320         defaults->searchList[2] = NULL;
 321
 322         defaults->searchListArray = WMCreatePLArray(NULL, NULL);
 323
 324         i = 0;
 325         while (defaults->searchList[i]) {
 326                 WMAddToPLArray(defaults->searchListArray, defaults->searchList[i]);
 327                 i++;
 328         }
 329
 330         if (sharedUserDefaults)
 331                 defaults->next = sharedUserDefaults;
 332         sharedUserDefaults = defaults;
 333
 334 #ifndef HAVE_INOTIFY
 335         addSynchronizeTimerHandler();
 336 #endif
 337         registerSaveOnExit();
 338
 339         return defaults;
 340 }
 341
 342 WMUserDefaults *WMGetDefaultsFromPath(char *path)
 343 {
 344         WMUserDefaults *defaults;
 345         WMPropList *domain;
 346         WMPropList *key;
 347         struct stat stbuf;
 348         char *name;
 349         int i;
 350
 351         assert(path != NULL);
 352
 353         if (sharedUserDefaults) {
 354                 defaults = sharedUserDefaults;
 355                 while (defaults) {
 356                         if (defaults->path && strcmp(defaults->path, path) == 0)
 357                                 return defaults;
 358                         defaults = defaults->next;
 359                 }
 360         }
 361
 362         /* we didn't found the database we are looking for. Go read it. XXX wtf? */
 363         defaults = wmalloc(sizeof(WMUserDefaults));
 364         defaults->defaults = WMCreatePLDictionary(NULL, NULL);
 365         defaults->searchList = wmalloc(sizeof(WMPropList *) * 2);
 366
 367         /* the domain we want, go in the first position */
 368         name = strrchr(path, '/');
 369         if (!name)
 370                 name = path;
 371         else
 372                 name++;
 373
 374         key = WMCreatePLString(name);
 375         defaults->searchList[0] = key;
 376
 377         if (stat(path, &stbuf) >= 0)
 378                 defaults->timestamp = stbuf.st_mtime;
 379
 380         domain = WMReadPropListFromFile(path);
 381
 382         if (!domain)
 383                 domain = WMCreatePLDictionary(NULL, NULL);
 384
 385         defaults->path = wstrdup(path);
 386
 387         defaults->appDomain = domain;
 388
 389         if (domain)
 390                 WMPutInPLDictionary(defaults->defaults, key, domain);
 391
 392         /* terminate list */
 393         defaults->searchList[1] = NULL;
 394
 395         defaults->searchListArray = WMCreatePLArray(NULL, NULL);
 396
 397         i = 0;
 398         while (defaults->searchList[i]) {
 399                 WMAddToPLArray(defaults->searchListArray, defaults->searchList[i]);
 400                 i++;
 401         }
 402
 403         if (sharedUserDefaults)
 404                 defaults->next = sharedUserDefaults;
 405         sharedUserDefaults = defaults;
 406
 407 #ifndef HAVE_INOTIFY
 408         addSynchronizeTimerHandler();
 409 #endif
 410         registerSaveOnExit();
 411
 412         return defaults;
 413 }
 414
 415 /* Returns a WMPropList array with all keys in the user defaults database.
 416  * Free the array with WMReleasePropList() when no longer needed,
 417  * but do not free the elements of the array! They're just references. */
 418 WMPropList *WMGetUDKeys(WMUserDefaults * database)
 419 {
 420         return WMGetPLDictionaryKeys(database->appDomain);
 421 }
 422
 423 WMPropList *WMGetUDObjectForKey(WMUserDefaults * database, char *defaultName)
 424 {
 425         WMPropList *domainName, *domain;
 426         WMPropList *object = NULL;
 427         WMPropList *key = WMCreatePLString(defaultName);
 428         int i = 0;
 429
 430         while (database->searchList[i] && !object) {
 431                 domainName = database->searchList[i];
 432                 domain = WMGetFromPLDictionary(database->defaults, domainName);
 433                 if (domain) {
 434                         object = WMGetFromPLDictionary(domain, key);
 435                 }
 436                 i++;
 437         }
 438         WMReleasePropList(key);
 439
 440         return object;
 441 }
 442
 443 void WMSetUDObjectForKey(WMUserDefaults * database, WMPropList * object, char *defaultName)
 444 {
 445         WMPropList *key = WMCreatePLString(defaultName);
 446
 447         database->dirty = 1;
 448
 449         WMPutInPLDictionary(database->appDomain, key, object);
 450         WMReleasePropList(key);
 451 }
 452
 453 void WMRemoveUDObjectForKey(WMUserDefaults * database, char *defaultName)
 454 {
 455         WMPropList *key = WMCreatePLString(defaultName);
 456
 457         database->dirty = 1;
 458
 459         WMRemoveFromPLDictionary(database->appDomain, key);
 460
 461         WMReleasePropList(key);
 462 }
 463
 464 char *WMGetUDStringForKey(WMUserDefaults * database, char *defaultName)
 465 {
 466         WMPropList *val;
 467
 468         val = WMGetUDObjectForKey(database, defaultName);
 469
 470         if (!val)
 471                 return NULL;
 472
 473         if (!WMIsPLString(val))
 474                 return NULL;
 475
 476         return WMGetFromPLString(val);
 477 }
 478
 479 int WMGetUDIntegerForKey(WMUserDefaults * database, char *defaultName)
 480 {
 481         WMPropList *val;
 482         char *str;
 483         int value;
 484
 485         val = WMGetUDObjectForKey(database, defaultName);
 486
 487         if (!val)
 488                 return 0;
 489
 490         if (!WMIsPLString(val))
 491                 return 0;
 492
 493         str = WMGetFromPLString(val);
 494         if (!str)
 495                 return 0;
 496
 497         if (sscanf(str, "%i", &value) != 1)
 498                 return 0;
 499
 500         return value;
 501 }
 502
 503 float WMGetUDFloatForKey(WMUserDefaults * database, char *defaultName)
 504 {
 505         WMPropList *val;
 506         char *str;
 507         float value;
 508
 509         val = WMGetUDObjectForKey(database, defaultName);
 510
 511         if (!val || !WMIsPLString(val))
 512                 return 0.0;
 513
 514         if (!(str = WMGetFromPLString(val)))
 515                 return 0.0;
 516
 517         if (sscanf(str, "%f", &value) != 1)
 518                 return 0.0;
 519
 520         return value;
 521 }
 522
 523 Bool WMGetUDBoolForKey(WMUserDefaults * database, char *defaultName)
 524 {
 525         WMPropList *val;
 526         int value;
 527         char *str;
 528
 529         val = WMGetUDObjectForKey(database, defaultName);
 530
 531         if (!val)
 532                 return False;
 533
 534         if (!WMIsPLString(val))
 535                 return False;
 536
 537         str = WMGetFromPLString(val);
 538         if (!str)
 539                 return False;
 540
 541         if (sscanf(str, "%i", &value) == 1 && value != 0)
 542                 return True;
 543
 544         if (strcasecmp(str, "YES") == 0)
 545                 return True;
 546
 547         if (strcasecmp(str, "Y") == 0)
 548                 return True;
 549
 550         return False;
 551 }
 552
 553 void WMSetUDIntegerForKey(WMUserDefaults * database, int value, char *defaultName)
 554 {
 555         WMPropList *object;
 556         char buffer[128];
 557
 558         sprintf(buffer, "%i", value);
 559         object = WMCreatePLString(buffer);
 560
 561         WMSetUDObjectForKey(database, object, defaultName);
 562         WMReleasePropList(object);
 563 }
 564
 565 void WMSetUDStringForKey(WMUserDefaults * database, char *value, char *defaultName)
 566 {
 567         WMPropList *object;
 568
 569         object = WMCreatePLString(value);
 570
 571         WMSetUDObjectForKey(database, object, defaultName);
 572         WMReleasePropList(object);
 573 }
 574
 575 void WMSetUDFloatForKey(WMUserDefaults * database, float value, char *defaultName)
 576 {
 577         WMPropList *object;
 578         char buffer[128];
 579
 580         sprintf(buffer, "%f", value);
 581         object = WMCreatePLString(buffer);
 582
 583         WMSetUDObjectForKey(database, object, defaultName);
 584         WMReleasePropList(object);
 585 }
 586
 587 void WMSetUDBoolForKey(WMUserDefaults * database, Bool value, char *defaultName)
 588 {
 589         static WMPropList *yes = NULL, *no = NULL;
 590
 591         if (!yes) {
 592                 yes = WMCreatePLString("YES");
 593                 no = WMCreatePLString("NO");
 594         }
 595
 596         WMSetUDObjectForKey(database, value ? yes : no, defaultName);
 597 }
 598
 599 WMPropList *WMGetUDSearchList(WMUserDefaults * database)
 600 {
 601         return database->searchListArray;
 602 }
 603
 604 void WMSetUDSearchList(WMUserDefaults * database, WMPropList * list)
 605 {
 606         int i, c;
 607
 608         if (database->searchList) {
 609                 i = 0;
 610                 while (database->searchList[i]) {
 611                         WMReleasePropList(database->searchList[i]);
 612                         i++;
 613                 }
 614                 wfree(database->searchList);
 615         }
 616         if (database->searchListArray) {
 617                 WMReleasePropList(database->searchListArray);
 618         }
 619
 620         c = WMGetPropListItemCount(list);
 621         database->searchList = wmalloc(sizeof(WMPropList *) * (c + 1));
 622
 623         for (i = 0; i < c; i++) {
 624                 database->searchList[i] = WMGetFromPLArray(list, i);
 625         }
 626         database->searchList[c] = NULL;
 627
 628         database->searchListArray = WMDeepCopyPropList(list);
 629 }