webcit/preferences.c

   1 /*
   2  * $Id$
   3  *
   4  * Manage user preferences with a little help from the Citadel server.
   5  *
   6  */
   7
   8 #include "webcit.h"
   9 #include "webserver.h"
  10 #include "groupdav.h"
  11
  12 HashList *PreferenceHooks;
  13 extern HashList *HandlerHash;
  14
  15 typedef struct _PrefDef {
  16         long Type;
  17         StrBuf *Setting;
  18         const char *PrefStr;
  19         PrefEvalFunc OnLoad;
  20         StrBuf *OnLoadName;
  21 } PrefDef;
  22
  23 typedef struct _Preference {
  24         StrBuf *Key;
  25         StrBuf *Val;
  26         PrefDef *Type;
  27
  28         long lval;
  29         long decoded;
  30         StrBuf *DeQPed;
  31 }Preference;
  32
  33 void DestroyPrefDef(void *vPrefDef)
  34 {
  35         PrefDef *Prefdef = (PrefDef*) vPrefDef;
  36         FreeStrBuf(&Prefdef->Setting);
  37         FreeStrBuf(&Prefdef->OnLoadName);
  38         free(Prefdef);
  39 }
  40
  41 void DestroyPreference(void *vPref)
  42 {
  43         Preference *Pref = (Preference*) vPref;
  44         FreeStrBuf(&Pref->Key);
  45         FreeStrBuf(&Pref->Val);
  46         FreeStrBuf(&Pref->DeQPed);
  47         free(Pref);
  48
  49 }
  50 void _RegisterPreference(const char *Setting, long SettingLen,
  51                          const char *PrefStr,
  52                          long Type,
  53                          PrefEvalFunc OnLoad,
  54                          const char *OnLoadName)
  55 {
  56         PrefDef *Newpref = (PrefDef*) malloc(sizeof(PrefDef));
  57         Newpref->Setting = NewStrBufPlain(Setting, SettingLen);
  58         Newpref->PrefStr = PrefStr;
  59         Newpref->Type = Type;
  60         Newpref->OnLoad = OnLoad;
  61         if (Newpref->OnLoad != NULL) {
  62                 Newpref->OnLoadName = NewStrBufPlain(OnLoadName, -1);
  63         }
  64         else
  65                 Newpref->OnLoadName = NULL;
  66         Put(PreferenceHooks, Setting, SettingLen, Newpref, DestroyPrefDef);
  67 }
  68
  69 const char *PrefGetLocalStr(const char *Setting, long len)
  70 {
  71         void *hash_value;
  72         if (GetHash(PreferenceHooks, Setting, len, &hash_value) != 0) {
  73                 PrefDef *Newpref = (PrefDef*) hash_value;
  74                 return _(Newpref->PrefStr);
  75
  76         }
  77         return "";
  78 }
  79
  80 #ifdef DBG_PREFS_HASH
  81 inline const char *PrintPref(void *vPref)
  82 {
  83         Preference *Pref = (Preference*) vPref;
  84         if (Pref->DeQPed != NULL)
  85                 return ChrPtr(Pref->DeQPed);
  86         else
  87                 return ChrPtr(Pref->Val);
  88 }
  89 #endif
  90
  91 void GetPrefTypes(HashList *List)
  92 {
  93         HashPos *It;
  94         long len;
  95         const char *Key;
  96         void *vSetting;
  97         void *vPrefDef;
  98         Preference *Pref;
  99         PrefDef *PrefType;
 100
 101         It = GetNewHashPos(List, 0);
 102         while (GetNextHashPos(List, It, &len, &Key, &vSetting))
 103         {
 104                 Pref = (Preference*) vSetting;
 105                 if (GetHash(PreferenceHooks, SKEY(Pref->Key), &vPrefDef) &&
 106                     (vPrefDef != NULL))
 107                 {
 108                         PrefType = (PrefDef*) vPrefDef;
 109                         Pref->Type = PrefType;
 110
 111                         lprintf(1, "Loading [%s]with type [%ld] [\"%s\"]\n",
 112                                 ChrPtr(Pref->Key),
 113                                 Pref->Type->Type,
 114                                 ChrPtr(Pref->Val));
 115
 116                         switch (Pref->Type->Type)
 117                         {
 118
 119                         case PRF_STRING:
 120                                 break;
 121                         case PRF_INT:
 122                                 Pref->lval = StrTol(Pref->Val);
 123                                 Pref->decoded = 1;
 124                                 break;
 125                         case PRF_QP_STRING:
 126                                 Pref->DeQPed = NewStrBufPlain(NULL, StrLength(Pref->Val));
 127                                 StrBufEUid_unescapize(Pref->DeQPed, Pref->Val);
 128                                 Pref->decoded = 1;
 129                                 break;
 130                         case PRF_YESNO:
 131                                 Pref->lval = strcmp(ChrPtr(Pref->Val), "yes") == 0;
 132                                 Pref->decoded = 1;
 133                                 break;
 134                         }
 135
 136                         if (PrefType->OnLoad != NULL){
 137
 138                                 lprintf(1, "Loading with: -> %s(\"%s\", %ld)\n",
 139                                         ChrPtr(PrefType->OnLoadName),
 140                                         ChrPtr(Pref->Val),
 141                                         Pref->lval);
 142                                 PrefType->OnLoad(Pref->Val, Pref->lval);
 143                         }
 144                 }
 145         }
 146         DeleteHashPos(&It);
 147 }
 148
 149 void ParsePref(HashList **List, StrBuf *ReadBuf)
 150 {
 151         int Done = 0;
 152         Preference *Data = NULL;
 153         Preference *LastData = NULL;
 154
 155         while (!Done) {
 156                 StrBuf_ServGetln(ReadBuf);
 157                 if ( (StrLength(ReadBuf)==3) &&
 158                      !strcmp(ChrPtr(ReadBuf), "000")) {
 159                         Done = 1;
 160                         break;
 161                 }
 162
 163                 if ((ChrPtr(ReadBuf)[0] == ' ') &&
 164                     (LastData != NULL)) {
 165                         StrBufAppendBuf(LastData->Val, ReadBuf, 1);
 166                 }
 167                 else {
 168                         LastData = Data = malloc(sizeof(Preference));
 169                         memset(Data, 0, sizeof(Preference));
 170                         Data->Key = NewStrBuf();
 171                         Data->Val = NewStrBuf();
 172                         StrBufExtract_token(Data->Key, ReadBuf, 0, '|');
 173                         StrBufExtract_token(Data->Val, ReadBuf, 1, '|');
 174                         if (!IsEmptyStr(ChrPtr(Data->Key)))
 175                         {
 176                                 Put(*List,
 177                                     SKEY(Data->Key),
 178                                     Data,
 179                                     DestroyPreference);
 180                         }
 181                         else
 182                         {
 183                                 StrBufTrim(ReadBuf);
 184                                 lprintf(1, "ignoring spurious preference line: [%s]\n",
 185                                         ChrPtr(ReadBuf));
 186                                 DestroyPreference(Data);
 187                                 LastData = NULL;
 188                         }
 189                         Data = NULL;
 190                 }
 191         }
 192         GetPrefTypes(*List);
 193 }
 194
 195
 196 /*
 197  * display preferences dialog
 198  */
 199 void load_preferences(void)
 200 {
 201         folder Room;
 202         wcsession *WCC = WC;
 203         int Done = 0;
 204         StrBuf *ReadBuf;
 205         long msgnum = 0L;
 206
 207         memset(&Room, 0, sizeof(folder));
 208         ReadBuf = NewStrBufPlain(NULL, SIZ * 4);
 209         if (goto_config_room(ReadBuf, &Room) != 0) {
 210                 FreeStrBuf(&ReadBuf);
 211                 FlushFolder(&Room);
 212
 213                 return; /* oh well. */
 214         }
 215
 216         serv_puts("MSGS ALL|0|1");
 217         StrBuf_ServGetln(ReadBuf);
 218         if (GetServerStatus(ReadBuf, NULL) == 8) {
 219                 serv_puts("subj|__ WebCit Preferences __");
 220                 serv_puts("000");
 221         }
 222         while (!Done &&
 223                StrBuf_ServGetln(ReadBuf)) {
 224                 if ( (StrLength(ReadBuf)==3) &&
 225                      !strcmp(ChrPtr(ReadBuf), "000")) {
 226                         Done = 1;
 227                         break;
 228                 }
 229                 msgnum = StrTol(ReadBuf);
 230         }
 231
 232         if (msgnum > 0L) {
 233                 serv_printf("MSG0 %ld", msgnum);
 234                 StrBuf_ServGetln(ReadBuf);
 235                 if (GetServerStatus(ReadBuf, NULL) == 1) {
 236                         while (StrBuf_ServGetln(ReadBuf),
 237                                (strcmp(ChrPtr(ReadBuf), "text") &&
 238                                 strcmp(ChrPtr(ReadBuf), "000"))) {
 239                         }
 240                         if (!strcmp(ChrPtr(ReadBuf), "text")) {
 241                                 ParsePref(&WCC->hash_prefs, ReadBuf);
 242                         }
 243                 }
 244         }
 245
 246         /* Go back to the room we're supposed to be in */
 247         if (StrLength(WCC->CurRoom.name) > 0) {
 248                 serv_printf("GOTO %s", ChrPtr(WCC->CurRoom.name));
 249                 StrBuf_ServGetln(ReadBuf);
 250                 GetServerStatus(ReadBuf, NULL);
 251         }
 252         FreeStrBuf(&ReadBuf);
 253         FlushFolder(&Room);
 254 }
 255
 256 /*
 257  * Goto the user's configuration room, creating it if necessary.
 258  * returns 0 on success or nonzero upon failure.
 259  */
 260 int goto_config_room(StrBuf *Buf, folder *Room)
 261 {
 262         serv_printf("GOTO %s", USERCONFIGROOM);
 263         StrBuf_ServGetln(Buf);
 264         if (GetServerStatus(Buf, NULL) != 2) {  /* try to create the config room if not there */
 265                 serv_printf("CRE8 1|%s|4|0", USERCONFIGROOM);
 266                 StrBuf_ServGetln(Buf);
 267                 GetServerStatus(Buf, NULL);
 268
 269                 serv_printf("GOTO %s", USERCONFIGROOM);
 270                 StrBuf_ServGetln(Buf);
 271                 if (GetServerStatus(Buf, NULL) != 2) {
 272                         return(1);
 273                 }
 274         }
 275         ParseGoto(Room, Buf);
 276         return(0);
 277 }
 278
 279 void WritePrefsToServer(HashList *Hash)
 280 {
 281         wcsession *WCC = WC;
 282         long len;
 283         HashPos *HashPos;
 284         void *vPref;
 285         const char *Key;
 286         Preference *Pref;
 287         StrBuf *SubBuf = NULL;
 288
 289         Hash = WCC->hash_prefs;
 290 #ifdef DBG_PREFS_HASH
 291         dbg_PrintHash(Hash, PrintPref, NULL);
 292 #endif
 293         HashPos = GetNewHashPos(Hash, 0);
 294         while (GetNextHashPos(Hash, HashPos, &len, &Key, &vPref)!=0)
 295         {
 296                 size_t nchars;
 297                 if (vPref == NULL)
 298                         continue;
 299                 Pref = (Preference*) vPref;
 300                 nchars = StrLength(Pref->Val);
 301                 if (nchars > 80){
 302                         int n = 0;
 303                         size_t offset, nchars;
 304                         if (SubBuf == NULL)
 305                                 SubBuf = NewStrBufPlain(NULL, SIZ);
 306                         nchars = 1;
 307                         offset = 0;
 308                         while (nchars > 0) {
 309                                 if (n == 0)
 310                                         nchars = 70;
 311                                 else
 312                                         nchars = 80;
 313
 314                                 nchars = StrBufSub(SubBuf, Pref->Val, offset, nchars);
 315
 316                                 if (n == 0)
 317                                         serv_printf("%s|%s", ChrPtr(Pref->Key), ChrPtr(SubBuf));
 318                                 else
 319                                         serv_printf(" %s", ChrPtr(SubBuf));
 320
 321                                 offset += nchars;
 322                                 nchars = StrLength(Pref->Val) - offset;
 323                                 n++;
 324                         }
 325
 326                 }
 327                 else
 328                         serv_printf("%s|%s", ChrPtr(Pref->Key), ChrPtr(Pref->Val));
 329
 330         }
 331         FreeStrBuf(&SubBuf);
 332         DeleteHashPos(&HashPos);
 333 }
 334
 335 /**
 336  * \brief save the modifications
 337  */
 338 void save_preferences(void)
 339 {
 340         folder Room;
 341         wcsession *WCC = WC;
 342         int Done = 0;
 343         StrBuf *ReadBuf;
 344         long msgnum = 0L;
 345
 346         ReadBuf = NewStrBuf();
 347         memset(&Room, 0, sizeof(folder));
 348         if (goto_config_room(ReadBuf, &Room) != 0) {
 349                 FreeStrBuf(&ReadBuf);
 350                 FlushFolder(&Room);
 351
 352                 return; /* oh well. */
 353         }
 354
 355         /* make shure the config room has the right type, else it might reject our config */
 356         if (Room.view != VIEW_BBS) {
 357                 serv_printf("VIEW %d", VIEW_BBS);
 358                 StrBuf_ServGetln(ReadBuf);
 359                 if (GetServerStatus(ReadBuf, NULL) != 2) {
 360                         /* UPS? */
 361                 }
 362                 else if (goto_config_room(ReadBuf, &Room) != 0) {
 363                         FreeStrBuf(&ReadBuf);
 364                         FlushFolder(&Room);
 365
 366                         return; /* oh well. */
 367                 }
 368         }
 369
 370         serv_puts("MSGS ALL|0|1");
 371         StrBuf_ServGetln(ReadBuf);
 372         if (GetServerStatus(ReadBuf, NULL) == 8) {
 373                 serv_puts("subj|__ WebCit Preferences __");
 374                 serv_puts("000");
 375         }
 376         while (!Done &&
 377                StrBuf_ServGetln(ReadBuf)) {
 378                 if ( (StrLength(ReadBuf)==3) &&
 379                      !strcmp(ChrPtr(ReadBuf), "000")) {
 380                         Done = 1;
 381                         break;
 382                 }
 383                 msgnum = StrTol(ReadBuf);
 384         }
 385
 386         if (msgnum > 0L) {
 387                 serv_printf("DELE %ld", msgnum);
 388                 StrBuf_ServGetln(ReadBuf);
 389                 GetServerStatus(ReadBuf, NULL);
 390         }
 391
 392         serv_printf("ENT0 1||0|1|__ WebCit Preferences __|");
 393         StrBuf_ServGetln(ReadBuf);
 394         if (GetServerStatus(ReadBuf, NULL) == 4) {
 395
 396                 WritePrefsToServer(WCC->hash_prefs);
 397                 serv_puts("");
 398                 serv_puts("000");
 399         }
 400
 401         /** Go back to the room we're supposed to be in */
 402         if (StrLength(WCC->CurRoom.name) > 0) {
 403                 serv_printf("GOTO %s", ChrPtr(WCC->CurRoom.name));
 404                 StrBuf_ServGetln(ReadBuf);
 405                 GetServerStatus(ReadBuf, NULL);
 406         }
 407         FreeStrBuf(&ReadBuf);
 408         FlushFolder(&Room);
 409 }
 410
 411 /**
 412  * \brief query the actual setting of key in the citadel database
 413  * \param key config key to query
 414  * \param keylen length of the key string
 415  * \param value StrBuf-value to the key to get
 416  * \returns found?
 417  */
 418 int get_pref_backend(const char *key, size_t keylen, Preference **Pref)
 419 {
 420         void *hash_value = NULL;
 421 #ifdef DBG_PREFS_HASH
 422         dbg_PrintHash(WC->hash_prefs, PrintPref, NULL);
 423 #endif
 424         if (GetHash(WC->hash_prefs, key, keylen, &hash_value) == 0) {
 425                 *Pref = NULL;
 426                 return 0;
 427         }
 428         else {
 429                 *Pref = (Preference*) hash_value;
 430                 return 1;
 431         }
 432 }
 433
 434 int get_PREFERENCE(const char *key, size_t keylen, StrBuf **value)
 435 {
 436         Preference *Pref;
 437         int Ret;
 438
 439         Ret = get_pref_backend(key, keylen, &Pref);
 440         if (Ret != 0)
 441                 *value = Pref->Val;
 442         else
 443                 *value = NULL;
 444         return Ret;
 445 }
 446
 447 /**
 448  * \brief       Write a key into the webcit preferences database for this user
 449  *
 450  * \params      key             key whichs value is to be modified
 451  * \param keylen length of the key string
 452  * \param       value           value to set
 453  * \param       save_to_server  1 = flush all data to the server, 0 = cache it for now
 454  */
 455 void set_preference_backend(const char *key, size_t keylen,
 456                             long lvalue,
 457                             StrBuf *value,
 458                             long lPrefType,
 459                             int save_to_server,
 460                             PrefDef *PrefType)
 461 {
 462         wcsession *WCC = WC;
 463         void *vPrefDef;
 464         Preference *Pref;
 465
 466         Pref = (Preference*) malloc(sizeof(Preference));
 467         memset(Pref, 0, sizeof(Preference));
 468         Pref->Key = NewStrBufPlain(key, keylen);
 469
 470         if ((PrefType == NULL) &&
 471             GetHash(PreferenceHooks, SKEY(Pref->Key), &vPrefDef) &&
 472             (vPrefDef != NULL))
 473                 PrefType = (PrefDef*) vPrefDef;
 474
 475         if (PrefType != NULL)
 476         {
 477                 Pref->Type = PrefType;
 478                 if (Pref->Type->Type != lPrefType)
 479                         lprintf(1, "warning: saving preference with wrong type [%s] %ld != %ld \n",
 480                                 key, Pref->Type->Type, lPrefType);
 481                 switch (Pref->Type->Type)
 482                 {
 483                 case PRF_STRING:
 484                         Pref->Val = value;
 485                         Pref->decoded = 1;
 486                         break;
 487                 case PRF_INT:
 488                         Pref->lval = lvalue;
 489                         Pref->Val = value;
 490                         if (Pref->Val == NULL)
 491                                 Pref->Val = NewStrBufPlain(NULL, 64);
 492                         StrBufPrintf(Pref->Val, "%ld", lvalue);
 493                         Pref->decoded = 1;
 494                         break;
 495                 case PRF_QP_STRING:
 496                         Pref->DeQPed = value;
 497                         Pref->Val = NewStrBufPlain(NULL, StrLength(Pref->DeQPed) * 3);
 498                         StrBufEUid_escapize(Pref->Val, Pref->DeQPed);
 499                         Pref->decoded = 1;
 500                         break;
 501                 case PRF_YESNO:
 502                         Pref->lval = lvalue;
 503                         if (lvalue)
 504                                 Pref->Val = NewStrBufPlain(HKEY("yes"));
 505                         else
 506                                 Pref->Val = NewStrBufPlain(HKEY("no"));
 507                         Pref->decoded = 1;
 508                         break;
 509                 }
 510                 if (Pref->Type->OnLoad != NULL)
 511                         Pref->Type->OnLoad(Pref->Val, Pref->lval);
 512         }
 513         else {
 514                 switch (lPrefType)
 515                 {
 516                 case PRF_STRING:
 517                         Pref->Val = value;
 518                         Pref->decoded = 1;
 519                         break;
 520                 case PRF_INT:
 521                         Pref->lval = lvalue;
 522                         Pref->Val = value;
 523                         if (Pref->Val == NULL)
 524                                 Pref->Val = NewStrBufPlain(NULL, 64);
 525                         StrBufPrintf(Pref->Val, "%ld", lvalue);
 526                         Pref->decoded = 1;
 527                         break;
 528                 case PRF_QP_STRING:
 529                         Pref->DeQPed = value;
 530                         Pref->Val = NewStrBufPlain(NULL, StrLength(Pref->DeQPed) * 3);
 531                         StrBufEUid_escapize(Pref->Val, Pref->DeQPed);
 532                         Pref->decoded = 1;
 533                         break;
 534                 case PRF_YESNO:
 535                         Pref->lval = lvalue;
 536                         if (lvalue)
 537                                 Pref->Val = NewStrBufPlain(HKEY("yes"));
 538                         else
 539                                 Pref->Val = NewStrBufPlain(HKEY("no"));
 540                         Pref->decoded = 1;
 541                         break;
 542                 }
 543         }
 544         Put(WCC->hash_prefs, key, keylen, Pref, DestroyPreference);
 545
 546         if (save_to_server) WCC->SavePrefsToServer = 1;
 547 }
 548
 549 void set_PREFERENCE(const char *key, size_t keylen, StrBuf *value, int save_to_server)
 550 {
 551         set_preference_backend(key, keylen, 0, value, PRF_STRING, save_to_server, NULL);
 552 }
 553
 554 int get_PREF_LONG(const char *key, size_t keylen, long *value, long Default)
 555 {
 556         Preference *Pref;
 557         int Ret;
 558
 559         Ret = get_pref_backend(key, keylen, &Pref);
 560         if (Ret == 0) {
 561                 *value = Default;
 562                 return 0;
 563         }
 564
 565         if (Pref->decoded)
 566                 *value = Pref->lval;
 567         else {
 568                 *value = Pref->lval = atol(ChrPtr(Pref->Val));
 569                 Pref->decoded = 1;
 570         }
 571         return Ret;
 572 }
 573
 574
 575 void set_PREF_LONG(const char *key, size_t keylen, long value, int save_to_server)
 576 {
 577         set_preference_backend(key, keylen, value, NULL, PRF_INT, save_to_server, NULL);
 578 }
 579
 580 int get_PREF_YESNO(const char *key, size_t keylen, int *value, int Default)
 581 {
 582         Preference *Pref;
 583         int Ret;
 584
 585         Ret = get_pref_backend(key, keylen, &Pref);
 586         if (Ret == 0) {
 587                 *value = Default;
 588                 return 0;
 589         }
 590
 591         if (Pref->decoded)
 592                 *value = Pref->lval;
 593         else {
 594                 *value = Pref->lval = strcmp(ChrPtr(Pref->Val), "yes") == 0;
 595                 Pref->decoded = 1;
 596         }
 597         return Ret;
 598 }
 599
 600 void set_PREF_YESNO(const char *key, size_t keylen, long value, int save_to_server)
 601 {
 602         set_preference_backend(key, keylen, value, NULL, PRF_YESNO, save_to_server, NULL);
 603 }
 604
 605 int get_room_prefs_backend(const char *key, size_t keylen,
 606                            Preference **Pref)
 607 {
 608         StrBuf *pref_name;
 609         int Ret;
 610
 611         pref_name = NewStrBufPlain (HKEY("ROOM:"));
 612         StrBufAppendBuf(pref_name, WC->CurRoom.name, 0);
 613         StrBufAppendBufPlain(pref_name, HKEY(":"), 0);
 614         StrBufAppendBufPlain(pref_name, key, keylen, 0);
 615         Ret = get_pref_backend(SKEY(pref_name), Pref);
 616         FreeStrBuf(&pref_name);
 617
 618         return Ret;
 619 }
 620
 621 const StrBuf *get_X_PREFS(const char *key, size_t keylen,
 622                           const char *xkey, size_t xkeylen)
 623 {
 624         int ret;
 625         StrBuf *pref_name;
 626         Preference *Prf;
 627
 628         pref_name = NewStrBufPlain (HKEY("XPREF:"));
 629         StrBufAppendBufPlain(pref_name, xkey, xkeylen, 0);
 630         StrBufAppendBufPlain(pref_name, HKEY(":"), 0);
 631         StrBufAppendBufPlain(pref_name, key, keylen, 0);
 632
 633         ret = get_pref_backend(SKEY(pref_name), &Prf);
 634         FreeStrBuf(&pref_name);
 635
 636         if (ret)
 637                 return Prf->Val;
 638         else return NULL;
 639 }
 640
 641 void set_X_PREFS(const char *key, size_t keylen, const char *xkey, size_t xkeylen, StrBuf *value, int save_to_server)
 642 {
 643         StrBuf *pref_name;
 644
 645         pref_name = NewStrBufPlain (HKEY("XPREF:"));
 646         StrBufAppendBufPlain(pref_name, xkey, xkeylen, 0);
 647         StrBufAppendBufPlain(pref_name, HKEY(":"), 0);
 648         StrBufAppendBufPlain(pref_name, key, keylen, 0);
 649
 650         set_preference_backend(SKEY(pref_name), 0, value, PRF_STRING, save_to_server, NULL);
 651         FreeStrBuf(&pref_name);
 652 }
 653
 654
 655 long get_ROOM_PREFS_LONG(const char *key, size_t keylen, long *value, long Default)
 656 {
 657         Preference *Pref;
 658         int Ret;
 659
 660         Ret = get_room_prefs_backend(key, keylen, &Pref);
 661
 662         if (Ret == 0) {
 663                 *value = Default;
 664                 return 0;
 665         }
 666
 667         if (Pref->decoded)
 668                 *value = Pref->lval;
 669         else {
 670                 *value = Pref->lval = atol(ChrPtr(Pref->Val));
 671                 Pref->decoded = 1;
 672         }
 673         return Ret;
 674 }
 675
 676
 677 StrBuf *get_ROOM_PREFS(const char *key, size_t keylen)
 678 {
 679         Preference *Pref;
 680         int Ret;
 681
 682         Ret = get_room_prefs_backend(key, keylen, &Pref);
 683
 684         if (Ret == 0) {
 685                 return NULL;
 686         }
 687         else
 688                 return Pref->Val;
 689 }
 690
 691 void set_ROOM_PREFS(const char *key, size_t keylen, StrBuf *value, int save_to_server)
 692 {
 693         StrBuf *pref_name;
 694
 695         pref_name = NewStrBufPlain (HKEY("ROOM:"));
 696         StrBufAppendBuf(pref_name, WC->CurRoom.name, 0);
 697         StrBufAppendBufPlain(pref_name, HKEY(":"), 0);
 698         StrBufAppendBufPlain(pref_name, key, keylen, 0);
 699         set_preference_backend(SKEY(pref_name), 0, value, PRF_STRING, save_to_server, NULL);
 700         FreeStrBuf(&pref_name);
 701 }
 702
 703
 704 void GetPreferences(HashList *Setting)
 705 {
 706         wcsession *WCC = WC;
 707         HashPos *It;
 708         long len;
 709         const char *Key;
 710         void *vSetting;
 711         PrefDef *PrefType;
 712         StrBuf *Buf;
 713         long lval;
 714         HashList *Tmp;
 715
 716         Tmp = WCC->hash_prefs;
 717         WCC->hash_prefs = Setting;
 718
 719         It = GetNewHashPos(PreferenceHooks, 0);
 720         while (GetNextHashPos(PreferenceHooks, It, &len, &Key, &vSetting)) {
 721                 PrefType = (PrefDef*) vSetting;
 722
 723                 if (!HaveBstr(SKEY(PrefType->Setting)))
 724                         continue;
 725                 switch (PrefType->Type) {
 726                 case PRF_STRING:
 727                         Buf = NewStrBufDup(SBstr(SKEY(PrefType->Setting)));
 728                         set_preference_backend(SKEY(PrefType->Setting),
 729                                                0,
 730                                                Buf,
 731                                                PRF_STRING,
 732                                                1,
 733                                                PrefType);
 734                         break;
 735                 case PRF_INT:
 736                         lval = LBstr(SKEY(PrefType->Setting));
 737                         set_preference_backend(SKEY(PrefType->Setting),
 738                                                lval,
 739                                                NULL,
 740                                                PRF_INT,
 741                                                1,
 742                                                PrefType);
 743                         break;
 744                 case PRF_QP_STRING:
 745                         Buf = NewStrBufDup(SBstr(SKEY(PrefType->Setting)));
 746                         set_preference_backend(SKEY(PrefType->Setting),
 747                                                0,
 748                                                Buf,
 749                                                PRF_QP_STRING,
 750                                                1,
 751                                                PrefType);
 752                         break;
 753                 case PRF_YESNO:
 754                         lval = YesBstr(SKEY(PrefType->Setting));
 755                         set_preference_backend(SKEY(PrefType->Setting),
 756                                                lval,
 757                                                NULL,
 758                                                PRF_YESNO,
 759                                                1,
 760                                                PrefType);
 761                         break;
 762                 }
 763         }
 764         WCC->hash_prefs = Tmp;
 765         DeleteHashPos(&It);
 766 }
 767
 768
 769 /**
 770  * \brief Commit new preferences and settings
 771  */
 772 void set_preferences(void)
 773 {
 774         if (!havebstr("change_button")) {
 775                 safestrncpy(WC->ImportantMessage,
 776                             _("Cancelled.  No settings were changed."),
 777                             sizeof WC->ImportantMessage);
 778                 display_main_menu();
 779                 return;
 780         }
 781         GetPreferences(WC->hash_prefs);
 782         display_main_menu();
 783 }
 784
 785
 786 void tmplput_CFG_Value(StrBuf *Target, WCTemplputParams *TP)
 787 {
 788         Preference *Pref;
 789         if (get_pref_backend(TKEY(0), &Pref))
 790         {
 791                 if (Pref->Type == NULL) {
 792                         StrBufAppendTemplate(Target, TP, Pref->Val, 1);
 793                 }
 794                 switch (Pref->Type->Type)
 795                 {
 796                 case PRF_STRING:
 797                         StrBufAppendTemplate(Target, TP, Pref->Val, 1);
 798                         break;
 799                 case PRF_INT:
 800                         if (Pref->decoded != 1) {
 801                                 if (Pref->Val == NULL)
 802                                         Pref->Val = NewStrBufPlain(NULL, 64);
 803                                 StrBufPrintf(Pref->Val, "%ld", Pref->lval);
 804                                 Pref->decoded = 1;
 805                         }
 806                         StrBufAppendTemplate(Target, TP, Pref->Val, 1);
 807                         break;
 808                 case PRF_QP_STRING:
 809                         if (Pref->decoded != 1) {
 810                                 if (Pref->DeQPed == NULL)
 811                                         Pref->DeQPed = NewStrBufPlain(NULL, StrLength(Pref->Val));
 812
 813                                 StrBufEUid_unescapize(Pref->DeQPed, Pref->Val);
 814                                 Pref->decoded = 1;
 815                         }
 816                         StrBufAppendTemplate(Target, TP, Pref->DeQPed, 1);
 817                         break;
 818                 case PRF_YESNO:
 819                         if (Pref->decoded != 1) {
 820                                 Pref->lval = strcmp(ChrPtr(Pref->Val), "yes") == 0;
 821                                 Pref->decoded = 1;
 822                         }
 823                         StrBufAppendTemplate(Target, TP, Pref->Val, 1);
 824                         break;
 825                 }
 826         }
 827 }
 828
 829 void tmplput_CFG_Descr(StrBuf *Target, WCTemplputParams *TP)
 830 {
 831         const char *SettingStr;
 832         SettingStr = PrefGetLocalStr(TKEY(0));
 833         if (SettingStr != NULL)
 834                 StrBufAppendBufPlain(Target, SettingStr, -1, 0);
 835 }
 836 void tmplput_CFG_RoomValueLong(StrBuf *Target, WCTemplputParams *TP)
 837 {
 838         long lvalue;
 839         long defval = 0;
 840
 841         if (HAVE_PARAM(1))
 842                 defval = GetTemplateTokenNumber(Target, TP, 1, 0);
 843         get_ROOM_PREFS_LONG(TKEY(0), &lvalue, defval);
 844         StrBufAppendPrintf(Target, "%ld", lvalue);
 845 }
 846 void tmplput_CFG_RoomValue(StrBuf *Target, WCTemplputParams *TP)
 847 {
 848         StrBuf *pref = get_ROOM_PREFS(TKEY(0));
 849         if (pref != NULL)
 850                 StrBufAppendBuf(Target, pref, 0);
 851 }
 852 int ConditionalHasRoomPreference(StrBuf *Target, WCTemplputParams *TP)
 853 {
 854         if (get_ROOM_PREFS(TP->Tokens->Params[0]->Start,
 855                            TP->Tokens->Params[0]->len) != NULL)
 856                 return 1;
 857
 858         return 0;
 859 }
 860
 861 int ConditionalPreference(StrBuf *Target, WCTemplputParams *TP)
 862 {
 863         StrBuf *Pref;
 864
 865         if (!get_PREFERENCE(TKEY(2), &Pref))
 866                 return 0;
 867
 868         if (!HAVE_PARAM(3)) {
 869                 return 1;
 870         }
 871         else if (TP->Tokens->Params[3]->Type == TYPE_STR)
 872                 return ((TP->Tokens->Params[3]->len == StrLength(Pref)) &&
 873                         (strcmp(TP->Tokens->Params[3]->Start, ChrPtr(Pref)) == 0));
 874         else
 875                 return (StrTol(Pref) == TP->Tokens->Params[3]->lvalue);
 876 }
 877
 878 int ConditionalHasPreference(StrBuf *Target, WCTemplputParams *TP)
 879 {
 880         StrBuf *Pref;
 881
 882         if (!get_PREFERENCE(TKEY(2), &Pref) ||
 883             (Pref == NULL))
 884                 return 0;
 885         else
 886                 return 1;
 887 }
 888
 889
 890 /********************************************************************************
 891  *                 preferences stored discrete in citserver
 892  ********************************************************************************/
 893 HashList *GetGVEAHash(StrBuf *Target, WCTemplputParams *TP)
 894 {
 895         StrBuf *Rcp;
 896         HashList *List = NULL;
 897         int Done = 0;
 898         int i, n = 1;
 899         char N[64];
 900
 901         Rcp = NewStrBuf();
 902         serv_puts("GVEA");
 903         StrBuf_ServGetln(Rcp);
 904         if (GetServerStatus(Rcp, NULL) == 1) {
 905                 FlushStrBuf(Rcp);
 906                 List = NewHash(1, NULL);
 907                 while (!Done && (StrBuf_ServGetln(Rcp)>=0)) {
 908                         if ( (StrLength(Rcp)==3) &&
 909                              !strcmp(ChrPtr(Rcp), "000"))
 910                         {
 911                                 Done = 1;
 912                         }
 913                         else {
 914                                 i = snprintf(N, sizeof(N), "%d", n);
 915                                 StrBufTrim(Rcp);
 916                                 Put(List, N, i, Rcp, HFreeStrBuf);
 917                                 Rcp = NewStrBuf();
 918                         }
 919                         n++;
 920                 }
 921         }
 922         FreeStrBuf(&Rcp);
 923         return List;
 924 }
 925 void DeleteGVEAHash(HashList **KillMe)
 926 {
 927         DeleteHash(KillMe);
 928 }
 929
 930 HashList *GetGVSNHash(StrBuf *Target, WCTemplputParams *TP)
 931 {
 932         StrBuf *Rcp;
 933         HashList *List = NULL;
 934         int Done = 0;
 935         int i, n = 1;
 936         char N[64];
 937
 938         Rcp = NewStrBuf();
 939         serv_puts("GVSN");
 940         StrBuf_ServGetln(Rcp);
 941         if (GetServerStatus(Rcp, NULL) == 1) {
 942                 FlushStrBuf(Rcp);
 943                 List = NewHash(1, NULL);
 944                 while (!Done && (StrBuf_ServGetln(Rcp)>=0)) {
 945                         if ( (StrLength(Rcp)==3) &&
 946                              !strcmp(ChrPtr(Rcp), "000"))
 947                         {
 948                                 Done = 1;
 949                         }
 950                         else {
 951                                 i = snprintf(N, sizeof(N), "%d", n);
 952                                 StrBufTrim(Rcp);
 953                                 Put(List, N, i, Rcp, HFreeStrBuf);
 954                                 Rcp = NewStrBuf();
 955                         }
 956                         n++;
 957                 }
 958         }
 959         FreeStrBuf(&Rcp);
 960         return List;
 961 }
 962 void DeleteGVSNHash(HashList **KillMe)
 963 {
 964         DeleteHash(KillMe);
 965 }
 966
 967
 968
 969
 970 /*
 971  * Offer to make any page the user's "start page."
 972  */
 973 void offer_start_page(StrBuf *Target, WCTemplputParams *TP)
 974 {
 975         wc_printf("<a href=\"change_start_page?startpage=");
 976         urlescputs(ChrPtr(WC->Hdr->this_page));
 977         wc_printf("\">");
 978         wc_printf(_("Make this my start page"));
 979         wc_printf("</a>");
 980 }
 981
 982
 983 /*
 984  * Change the user's start page
 985  */
 986 void change_start_page(void)
 987 {
 988         wcsession *WCC = WC;
 989         const char *pch;
 990         void *vHandler;
 991         int ProhibitSave = 0;
 992         const StrBuf *pStartPage = sbstr("startpage");
 993
 994         if (pStartPage != NULL) {
 995                 pch = strchr(ChrPtr(pStartPage), '?');
 996
 997                 if ((pch != NULL) && (
 998                             GetHash(HandlerHash, ChrPtr(pStartPage), pch - ChrPtr(pStartPage), &vHandler),
 999                             (vHandler != NULL) &&
1000                             ((((WebcitHandler*)vHandler)->Flags & PROHIBIT_STARTPAGE) != 0)))
1001                 { /* OK, This handler doesn't want to be set as start page, prune it. */
1002                         ProhibitSave = 1;
1003                 }
1004         }
1005
1006         if ((pStartPage == NULL) ||
1007             (ProhibitSave == 1))
1008         {
1009                 set_preference_backend(HKEY("startpage"),
1010                                        0,
1011                                        NewStrBufPlain(HKEY("")),
1012                                        PRF_STRING,
1013                                        1,
1014                                        NULL);
1015                 if (ProhibitSave == 1)
1016                         StrBufAppendBufPlain(WCC->ImportantMsg,
1017                                              _("This isn't allowed to become the start page."),
1018                                              -1, 0);
1019                 else
1020                         StrBufAppendBufPlain(WCC->ImportantMsg,
1021                                              _("You no longer have a start page selected."),
1022                                              -1, 0);
1023                 display_main_menu();
1024                 return;
1025         }
1026
1027
1028
1029         set_preference_backend(HKEY("startpage"),
1030                                0,
1031                                NewStrBufDup(pStartPage),
1032                                PRF_STRING,
1033                                1,
1034                                NULL);
1035
1036         output_headers(1, 1, 0, 0, 0, 0);
1037         do_template("newstartpage", NULL);
1038         wDumpContent(1);
1039 }
1040
1041
1042 void LoadStartpage(StrBuf *URL, long lvalue)
1043 {
1044         const char *pch;
1045         void *vHandler;
1046         pch = strchr(ChrPtr(URL), '?');
1047         if (pch == NULL) {
1048                 /* purge the sins of the past... */
1049                 pch = strchr(ChrPtr(URL), '&');
1050                 if (pch != NULL) {
1051                         StrBufPeek(URL, pch, -1, '?');
1052                         WC->SavePrefsToServer = 1;
1053                 }
1054         }
1055         else if (GetHash(HandlerHash, ChrPtr(URL), pch - ChrPtr(URL), &vHandler),
1056                  (vHandler != NULL) &&
1057                  ((((WebcitHandler*)vHandler)->Flags & PROHIBIT_STARTPAGE) != 0))
1058         { /* OK, This handler doesn't want to be set as start page, prune it. */
1059                 FlushStrBuf(URL);
1060                 WC->SavePrefsToServer = 1;
1061         }
1062 }
1063
1064
1065 void
1066 InitModule_PREFERENCES
1067 (void)
1068 {
1069         WebcitAddUrlHandler(HKEY("set_preferences"), "", 0, set_preferences, 0);
1070         WebcitAddUrlHandler(HKEY("change_start_page"), "", 0, change_start_page, 0);
1071
1072         RegisterPreference("startpage", _("Prefered startpage"), PRF_STRING, LoadStartpage);
1073
1074         RegisterNamespace("OFFERSTARTPAGE", 0, 0, offer_start_page, NULL, CTX_NONE);
1075         RegisterNamespace("PREF:ROOM:VALUE", 1, 2, tmplput_CFG_RoomValue,  NULL, CTX_NONE);
1076         RegisterNamespace("PREF:ROOM:VALUE:INT", 1, 2, tmplput_CFG_RoomValueLong,  NULL, CTX_NONE);
1077         RegisterNamespace("PREF:VALUE", 1, 2, tmplput_CFG_Value, NULL, CTX_NONE);
1078
1079         RegisterNamespace("PREF:DESCR", 1, 1, tmplput_CFG_Descr, NULL, CTX_NONE);
1080
1081         RegisterConditional(HKEY("COND:PREF"), 4, ConditionalPreference, CTX_NONE);
1082         RegisterConditional(HKEY("COND:PREF:SET"), 4, ConditionalHasPreference, CTX_NONE);
1083         RegisterConditional(HKEY("COND:ROOM:SET"), 4, ConditionalHasRoomPreference, CTX_NONE);
1084
1085         RegisterIterator("PREF:VALID:EMAIL:ADDR", 0, NULL,
1086                          GetGVEAHash, NULL, DeleteGVEAHash, CTX_STRBUF, CTX_NONE, IT_NOFLAG);
1087         RegisterIterator("PREF:VALID:EMAIL:NAME", 0, NULL,
1088                          GetGVSNHash, NULL, DeleteGVSNHash, CTX_STRBUF, CTX_NONE, IT_NOFLAG);
1089
1090 }
1091
1092
1093 void
1094 ServerStartModule_PREFERENCES
1095 (void)
1096 {
1097         PreferenceHooks = NewHash(1, NULL);
1098 }
1099
1100
1101
1102 void
1103 ServerShutdownModule_PREFERENCES
1104 (void)
1105 {
1106         DeleteHash(&PreferenceHooks);
1107 }
1108
1109 void
1110 SessionDetachModule__PREFERENCES
1111 (wcsession *sess)
1112 {
1113         if (sess->SavePrefsToServer) {
1114                 save_preferences();
1115                 sess->SavePrefsToServer = 0;
1116         }
1117 }
1118
1119 void
1120 SessionNewModule_PREFERENCES
1121 (wcsession *sess)
1122 {
1123         sess->hash_prefs = NewHash(1,NULL);
1124 }
1125
1126 void
1127 SessionDestroyModule_PREFERENCES
1128 (wcsession *sess)
1129 {
1130         DeleteHash(&sess->hash_prefs);
1131 }
1132
1133
1134
1135 /*@}*/