WINGs/userdefaults.c

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