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         gspath = getenv("GNUSTEP_USER_ROOT");
  62         if (gspath) {
  63                 gspath = wexpandpath(gspath);
  64                 if (gspath) {
  65                         path = gspath;
  66                         return path;
  67                 }
  68                 wwarning(_("variable GNUSTEP_USER_ROOT defined with invalid path, not used"));
  69         }
  70
  71         h = wgethomedir();
  72         if (!h)
  73                 return NULL;
  74
  75         pathlen = strlen(h);
  76         path = wmalloc(pathlen + sizeof(subdir));
  77         strcpy(path, h);
  78         strcpy(path + pathlen, subdir);
  79
  80         return path;
  81 }
  82
  83 char *wdefaultspathfordomain(const char *domain)
  84 {
  85         char *path;
  86         const 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         strcpy(path, gspath);
  94         strcat(path, DEFAULTS_DIR);
  95         strcat(path, "/");
  96         strcat(path, domain);
  97
  98         return path;
  99 }
 100
 101 /* XXX: doesn't quite belong to *user*defaults.c */
 102 #ifndef GLOBAL_DEFAULTS_SUBDIR
 103 #define GLOBAL_DEFAULTS_SUBDIR "WindowMaker"
 104 #endif
 105 char *wglobaldefaultspathfordomain(const char *domain)
 106 {
 107         char *t = NULL;
 108         size_t len;
 109
 110         len = strlen( SYSCONFDIR ) + strlen( GLOBAL_DEFAULTS_SUBDIR ) + strlen(domain) + 3;
 111         t = wmalloc(len);
 112         snprintf(t, len, "%s/%s/%s", SYSCONFDIR, GLOBAL_DEFAULTS_SUBDIR, domain);
 113
 114         return t;
 115 }
 116
 117 void w_save_defaults_changes(void)
 118 {
 119         if (WMApplication.applicationName == NULL) {
 120                 /*
 121                  * This means that the user has properly exited by calling the
 122                  * function 'WMReleaseApplication' (which has already called us)
 123                  * but we're being called again by the fallback 'atexit' method
 124                  * (the legacy way of saving changes on exit which is kept for
 125                  * application that would forget to call 'WMReleaseApplication')
 126                  */
 127                 return;
 128         }
 129
 130         /* save the user defaults databases */
 131         synchronizeUserDefaults(NULL);
 132 }
 133
 134 /* set to save changes in defaults when program is exited */
 135 static void registerSaveOnExit(void)
 136 {
 137         static Bool registeredSaveOnExit = False;
 138
 139         if (!registeredSaveOnExit) {
 140                 atexit(w_save_defaults_changes);
 141                 registeredSaveOnExit = True;
 142         }
 143 }
 144
 145 static void synchronizeUserDefaults(void *foo)
 146 {
 147         UserDefaults *database = sharedUserDefaults;
 148
 149         /* Parameter not used, but tell the compiler that it is ok */
 150         (void) foo;
 151
 152         while (database) {
 153                 if (!database->dontSync)
 154                         WMSynchronizeUserDefaults(database);
 155                 database = database->next;
 156         }
 157 }
 158
 159 #ifndef HAVE_INOTIFY
 160 static void addSynchronizeTimerHandler(void)
 161 {
 162         static Bool initialized = False;
 163
 164         if (!initialized) {
 165                 WMAddPersistentTimerHandler(UD_SYNC_INTERVAL,
 166                     synchronizeUserDefaults, NULL);
 167                 initialized = True;
 168         }
 169 }
 170 #endif
 171
 172 void WMEnableUDPeriodicSynchronization(WMUserDefaults * database, Bool enable)
 173 {
 174         database->dontSync = !enable;
 175 }
 176
 177 void WMSynchronizeUserDefaults(WMUserDefaults * database)
 178 {
 179         Bool fileIsNewer = False, release = False, notify = False;
 180         WMPropList *plF, *key;
 181         char *path;
 182         struct stat stbuf;
 183
 184         if (!database->path) {
 185                 path = wdefaultspathfordomain(WMGetApplicationName());
 186                 release = True;
 187         } else {
 188                 path = database->path;
 189         }
 190
 191         if (stat(path, &stbuf) >= 0 && stbuf.st_mtime > database->timestamp)
 192                 fileIsNewer = True;
 193
 194         if (database->appDomain && (database->dirty || fileIsNewer)) {
 195                 if (database->dirty && fileIsNewer) {
 196                         plF = WMReadPropListFromFile(path);
 197                         if (plF) {
 198                                 plF = WMMergePLDictionaries(plF, database->appDomain, False);
 199                                 WMReleasePropList(database->appDomain);
 200                                 database->appDomain = plF;
 201                                 key = database->searchList[0];
 202                                 WMPutInPLDictionary(database->defaults, key, plF);
 203                                 notify = True;
 204                         } else {
 205                                 /* something happened with the file. just overwrite it */
 206                                 wwarning(_("cannot read domain from file '%s' when syncing"), path);
 207                                 WMWritePropListToFile(database->appDomain, path);
 208                         }
 209                 } else if (database->dirty) {
 210                         WMWritePropListToFile(database->appDomain, path);
 211                 } else if (fileIsNewer) {
 212                         plF = WMReadPropListFromFile(path);
 213                         if (plF) {
 214                                 WMReleasePropList(database->appDomain);
 215                                 database->appDomain = plF;
 216                                 key = database->searchList[0];
 217                                 WMPutInPLDictionary(database->defaults, key, plF);
 218                                 notify = True;
 219                         } else {
 220                                 /* something happened with the file. just overwrite it */
 221                                 wwarning(_("cannot read domain from file '%s' when syncing"), path);
 222                                 WMWritePropListToFile(database->appDomain, path);
 223                         }
 224                 }
 225
 226                 database->dirty = 0;
 227
 228                 if (stat(path, &stbuf) >= 0)
 229                         database->timestamp = stbuf.st_mtime;
 230
 231                 if (notify) {
 232                         WMPostNotificationName(WMUserDefaultsDidChangeNotification, database, NULL);
 233                 }
 234         }
 235
 236         if (release)
 237                 wfree(path);
 238
 239 }
 240
 241 void WMSaveUserDefaults(WMUserDefaults * database)
 242 {
 243         if (database->appDomain) {
 244                 struct stat stbuf;
 245                 char *path;
 246                 Bool release = False;
 247
 248                 if (!database->path) {
 249                         path = wdefaultspathfordomain(WMGetApplicationName());
 250                         release = True;
 251                 } else {
 252                         path = database->path;
 253                 }
 254                 WMWritePropListToFile(database->appDomain, path);
 255                 database->dirty = 0;
 256                 if (stat(path, &stbuf) >= 0)
 257                         database->timestamp = stbuf.st_mtime;
 258                 if (release)
 259                         wfree(path);
 260         }
 261 }
 262
 263 WMUserDefaults *WMGetStandardUserDefaults(void)
 264 {
 265         WMUserDefaults *defaults;
 266         WMPropList *domain;
 267         WMPropList *key;
 268         struct stat stbuf;
 269         char *path;
 270         int i;
 271
 272         if (sharedUserDefaults) {
 273                 defaults = sharedUserDefaults;
 274                 while (defaults) {
 275                         /* path == NULL only for StandardUserDefaults db */
 276                         if (defaults->path == NULL)
 277                                 return defaults;
 278                         defaults = defaults->next;
 279                 }
 280         }
 281
 282         /* we didn't found the database we are looking for. Go read it. XXX: wtf? */
 283         defaults = wmalloc(sizeof(WMUserDefaults));
 284         defaults->defaults = WMCreatePLDictionary(NULL, NULL);
 285         defaults->searchList = wmalloc(sizeof(WMPropList *) * 3);
 286
 287         /* application domain */
 288         key = WMCreatePLString(WMGetApplicationName());
 289         defaults->searchList[0] = key;
 290
 291         /* temporary kluge. wmaker handles synchronization itself */
 292         if (strcmp(WMGetApplicationName(), "WindowMaker") == 0) {
 293                 defaults->dontSync = 1;
 294         }
 295
 296         path = wdefaultspathfordomain(WMGetFromPLString(key));
 297
 298         if (stat(path, &stbuf) >= 0)
 299                 defaults->timestamp = stbuf.st_mtime;
 300
 301         domain = WMReadPropListFromFile(path);
 302
 303         if (!domain)
 304                 domain = WMCreatePLDictionary(NULL, NULL);
 305
 306         if (path)
 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", 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 }