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