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