webcit/sieve.c

   1 /*
   2  * Copyright (c) 1996-2020 by the citadel.org team
   3  *
   4  * This program is open source software.  You can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License version 3.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  *
  13  * Implementation note: this was kind of hacked up when we switched from Sieve to custom rules.
  14  * As a result there's probably some cruft in here...
  15  * ajc 2020jul12
  16  *
  17  */
  18
  19 #include "webcit.h"
  20
  21 CtxType CTX_SIEVELIST = CTX_NONE;
  22 CtxType CTX_SIEVESCRIPT = CTX_NONE;
  23
  24 #define MAX_SCRIPTS     100
  25 #define MAX_RULES       50
  26 #define RULES_SCRIPT    "__WebCit_Generated_Script__"
  27
  28
  29 /*
  30  * Translate the fields from the rule editor into something we can save...
  31  */
  32 void parse_fields_from_rule_editor(void) {
  33
  34         int active;
  35         char hfield[256];
  36         char compare[32];
  37         char htext[256];
  38         char sizecomp[32];
  39         int sizeval;
  40         char action[32];
  41         char fileinto[128];
  42         char redirect[256];
  43         char automsg[1024];
  44         char final[32];
  45         int i;
  46         char buf[256];
  47         char fname[256];
  48         char rule[2048];
  49         char encoded_rule[4096];
  50         char my_addresses[4096];
  51
  52         /* Enumerate my email addresses in case they are needed for a vacation rule */
  53         my_addresses[0] = 0;
  54         serv_puts("GVEA");
  55         serv_getln(buf, sizeof buf);
  56         if (buf[0] == '1') while (serv_getln(buf, sizeof buf), strcmp(buf, "000")) {
  57                 if (!IsEmptyStr(my_addresses)) {
  58                         strcat(my_addresses, ",\n");
  59                 }
  60                 strcat(my_addresses, "\"");
  61                 strcat(my_addresses, buf);
  62                 strcat(my_addresses, "\"");
  63         }
  64
  65         /* Now generate the script and write it to the Citadel server */
  66         serv_printf("PIBR");
  67         serv_getln(buf, sizeof buf);
  68         if (buf[0] != '4') {
  69                 return;
  70         }
  71
  72         for (i=0; i<MAX_RULES; ++i) {
  73
  74                 strcpy(rule, "");
  75
  76                 sprintf(fname, "active%d", i);
  77                 active = !strcasecmp(BSTR(fname), "on") ;
  78
  79                 if (active) {
  80
  81                         sprintf(fname, "hfield%d", i);
  82                         safestrncpy(hfield, BSTR(fname), sizeof hfield);
  83
  84                         sprintf(fname, "compare%d", i);
  85                         safestrncpy(compare, BSTR(fname), sizeof compare);
  86
  87                         sprintf(fname, "htext%d", i);
  88                         safestrncpy(htext, BSTR(fname), sizeof htext);
  89
  90                         sprintf(fname, "sizecomp%d", i);
  91                         safestrncpy(sizecomp, BSTR(fname), sizeof sizecomp);
  92
  93                         sprintf(fname, "sizeval%d", i);
  94                         sizeval = IBSTR(fname);
  95
  96                         sprintf(fname, "action%d", i);
  97                         safestrncpy(action, BSTR(fname), sizeof action);
  98
  99                         sprintf(fname, "fileinto%d", i);
 100                         safestrncpy(fileinto, BSTR(fname), sizeof fileinto);
 101
 102                         sprintf(fname, "redirect%d", i);
 103                         safestrncpy(redirect, BSTR(fname), sizeof redirect);
 104
 105                         sprintf(fname, "automsg%d", i);
 106                         safestrncpy(automsg, BSTR(fname), sizeof automsg);
 107
 108                         sprintf(fname, "final%d", i);
 109                         safestrncpy(final, BSTR(fname), sizeof final);
 110
 111                         snprintf(rule, sizeof rule, "%d|%s|%s|%s|%s|%d|%s|%s|%s|%s|%s",
 112                                 active, hfield, compare, htext, sizecomp, sizeval, action, fileinto,
 113                                 redirect, automsg, final
 114                         );
 115
 116                         size_t len = CtdlEncodeBase64(encoded_rule, rule, strlen(rule)+1, 0);
 117                         if (encoded_rule[len - 1] == '\n') {
 118                                 encoded_rule[len - 1] = '\0';
 119                         }
 120                         serv_printf("rule|%d|%s|", i, encoded_rule);
 121                         serv_puts("");
 122                 }
 123         }
 124
 125         serv_puts("000");
 126 }
 127
 128
 129 /*
 130  * save sieve config
 131  */
 132 void save_sieve(void) {
 133
 134         if (!havebstr("save_button")) {
 135                 AppendImportantMessage(_("Cancelled.  Changes were not saved."), -1);
 136                 display_main_menu();
 137                 return;
 138         }
 139
 140         parse_fields_from_rule_editor();
 141
 142         AppendImportantMessage(_("Your changes have been saved."), -1);
 143         display_main_menu();
 144         return;
 145 }
 146
 147
 148 void display_sieve_add_or_delete(void) {
 149         output_headers(1, 1, 2, 0, 0, 0);
 150         do_template("sieve_add");
 151         wDumpContent(1);
 152 }
 153
 154
 155
 156 /*
 157  * dummy panel indicating to the user that the server doesn't support Sieve
 158  */
 159 void display_no_sieve(void) {
 160
 161         output_headers(1, 1, 1, 0, 0, 0);
 162         do_template("sieve_none");
 163         wDumpContent(1);
 164 }
 165
 166
 167 typedef struct __SieveListing {
 168         int IsActive;
 169         int IsRulesScript;
 170         StrBuf *Name;
 171         StrBuf *Content;
 172 } SieveListing;
 173
 174 int ConditionalSieveScriptIsActive(StrBuf *Target, WCTemplputParams *TP)
 175 {
 176         SieveListing     *SieveList = (SieveListing *)CTX(CTX_SIEVELIST);
 177         return SieveList->IsActive;
 178 }
 179 int ConditionalSieveScriptIsRulesScript(StrBuf *Target, WCTemplputParams *TP)
 180 {
 181         SieveListing     *SieveList = (SieveListing *)CTX(CTX_SIEVELIST);
 182         return SieveList->IsActive;
 183 }
 184 void tmplput_SieveScriptName(StrBuf *Target, WCTemplputParams *TP)
 185 {
 186         SieveListing     *SieveList = (SieveListing *)CTX(CTX_SIEVELIST);
 187         StrBufAppendTemplate(Target, TP, SieveList->Name, 0);
 188 }
 189 void tmplput_SieveScriptContent(StrBuf *Target, WCTemplputParams *TP)
 190 {
 191         SieveListing     *SieveList = (SieveListing *)CTX(CTX_SIEVELIST);
 192         StrBufAppendTemplate(Target, TP, SieveList->Content, 0);
 193 }
 194 void FreeSieveListing(void *vSieveListing)
 195 {
 196         SieveListing *List = (SieveListing*) vSieveListing;
 197
 198         FreeStrBuf(&List->Name);
 199         free(List);
 200 }
 201
 202 HashList *GetSieveScriptListing(StrBuf *Target, WCTemplputParams *TP)
 203 {
 204         wcsession *WCC = WC;
 205         StrBuf *Line;
 206         int num_scripts = 0;
 207         int rules_script_active = 0;
 208         int have_rules_script = 0;
 209         const char *pch;
 210         HashPos  *it;
 211         int Done = 0;
 212         SieveListing *Ruleset;
 213
 214         if (WCC->KnownSieveScripts != NULL) {
 215                 return WCC->KnownSieveScripts;
 216         }
 217
 218         serv_puts("MSIV listscripts");
 219         Line = NewStrBuf();
 220         StrBuf_ServGetln(Line);
 221         if (GetServerStatus(Line, NULL) == 1)
 222         {
 223                 WCC->KnownSieveScripts = NewHash(1, Flathash);
 224
 225                 while(!Done && (StrBuf_ServGetln(Line) >= 0) )
 226                         if ( (StrLength(Line)==3) &&
 227                              !strcmp(ChrPtr(Line), "000"))
 228                         {
 229                                 Done = 1;
 230                         }
 231                         else
 232                         {
 233                                 pch = NULL;
 234                                 Ruleset = (SieveListing *) malloc(sizeof(SieveListing));
 235                                 Ruleset->Name = NewStrBufPlain(NULL, StrLength(Line));
 236                                 StrBufExtract_NextToken(Ruleset->Name, Line, &pch, '|');
 237                                 Ruleset->IsActive = StrBufExtractNext_int(Line, &pch, '|');
 238                                 Ruleset->Content = NULL;
 239
 240                                 if (!strcasecmp(ChrPtr(Ruleset->Name), RULES_SCRIPT))
 241                                 {
 242                                         Ruleset->IsRulesScript = 1;
 243                                         have_rules_script = 1;
 244                                         if (Ruleset->IsActive)
 245                                         {
 246                                                 rules_script_active = 1;
 247                                                 PutBstr(HKEY("__SIEVE:RULESSCRIPT"), NewStrBufPlain(HKEY("1")));
 248                                         }
 249                                 }
 250                                 Put(WCC->KnownSieveScripts, IKEY(num_scripts), Ruleset, FreeSieveListing);
 251
 252                                 ++num_scripts;
 253                         }
 254         }
 255
 256         if ((num_scripts > 0) && (rules_script_active == 0)) {
 257                 PutBstr(HKEY("__SIEVE:EXTERNAL_SCRIPT"), NewStrBufPlain(HKEY("1")));
 258         }
 259
 260         if (num_scripts > have_rules_script)
 261         {
 262                 long rc = 0;
 263                 long len;
 264                 const char *Key;
 265                 void *vRuleset;
 266
 267                 /*
 268                  * ok; we have custom scripts, expose that via bstr, and load the payload.
 269                  */
 270                 PutBstr(HKEY("__SIEVE:HAVE_EXTERNAL_SCRIPT"), NewStrBufPlain(HKEY("1")));
 271
 272                 it = GetNewHashPos(WCC->KnownSieveScripts, 0);
 273                 while (GetNextHashPos(WCC->KnownSieveScripts, it, &len, &Key, &vRuleset) &&
 274                        (vRuleset != NULL))
 275                 {
 276                         Ruleset = (SieveListing *) vRuleset;
 277                         serv_printf("MSIV getscript|%s", ChrPtr(Ruleset->Name));
 278                         StrBuf_ServGetln(Line);
 279                         if (GetServerStatus(Line, NULL) == 1)
 280                         {
 281                                 Ruleset->Content = NewStrBuf();
 282                                 Done = 0;
 283                                 while(!Done && (rc = StrBuf_ServGetln(Line), rc >= 0) )
 284                                         if ( (StrLength(Line)==3) &&
 285                                              !strcmp(ChrPtr(Line), "000"))
 286                                         {
 287                                                 Done = 1;
 288                                         }
 289                                         else
 290                                         {
 291                                                 if (StrLength(Ruleset->Content)>0)
 292                                                         StrBufAppendBufPlain(Ruleset->Content, HKEY("\n"), 0);
 293                                                 StrBufAppendBuf(Ruleset->Content, Line, 0);
 294                                         }
 295                                 if (rc < 0) break;
 296                         }
 297                 }
 298         }
 299         FreeStrBuf(&Line);
 300         return WCC->KnownSieveScripts;
 301 }
 302
 303
 304 typedef enum __eSieveHfield
 305 {
 306         from,
 307         tocc,
 308         subject,
 309         replyto,
 310         sender,
 311         resentfrom,
 312         resentto,
 313         envfrom,
 314         envto,
 315         xmailer,
 316         xspamflag,
 317         xspamstatus,
 318         listid,
 319         size,
 320         all
 321 } eSieveHfield;
 322
 323 typedef enum __eSieveCompare {
 324         contains,
 325         notcontains,
 326         is,
 327         isnot,
 328         matches,
 329         notmatches
 330 } eSieveCompare;
 331
 332 typedef enum __eSieveAction {
 333         keep,
 334         discard,
 335         reject,
 336         fileinto,
 337         redirect,
 338         vacation
 339 } eSieveAction;
 340
 341
 342 typedef enum __eSieveSizeComp {
 343         larger,
 344         smaller
 345 } eSieveSizeComp;
 346
 347 typedef enum __eSieveFinal {
 348         econtinue,
 349         estop
 350 } eSieveFinal;
 351
 352
 353 typedef struct __SieveRule {
 354         int active;
 355         int sizeval;
 356         eSieveHfield hfield;
 357         eSieveCompare compare;
 358         StrBuf *htext;
 359         eSieveSizeComp sizecomp;
 360         eSieveAction Action;
 361         StrBuf *fileinto;
 362         StrBuf *redirect;
 363         StrBuf *automsg;
 364         eSieveFinal final;
 365 }SieveRule;
 366
 367
 368
 369 int ConditionalSieveRule_hfield(StrBuf *Target, WCTemplputParams *TP)
 370 {
 371         SieveRule     *Rule = (SieveRule *)CTX(CTX_SIEVESCRIPT);
 372
 373         return GetTemplateTokenNumber(Target,
 374                                       TP,
 375                                       3,
 376                                       from)
 377                 ==
 378                 Rule->hfield;
 379 }
 380 int ConditionalSieveRule_compare(StrBuf *Target, WCTemplputParams *TP)
 381 {
 382         SieveRule     *Rule = (SieveRule *)CTX(CTX_SIEVESCRIPT);
 383         return GetTemplateTokenNumber(Target,
 384                                       TP,
 385                                       3,
 386                                       contains)
 387                 ==
 388                 Rule->compare;
 389 }
 390 int ConditionalSieveRule_action(StrBuf *Target, WCTemplputParams *TP)
 391 {
 392         SieveRule     *Rule = (SieveRule *)CTX(CTX_SIEVESCRIPT);
 393         return GetTemplateTokenNumber(Target,
 394                                       TP,
 395                                       3,
 396                                       keep)
 397                 ==
 398                 Rule->Action;
 399 }
 400 int ConditionalSieveRule_sizecomp(StrBuf *Target, WCTemplputParams *TP)
 401 {
 402         SieveRule     *Rule = (SieveRule *)CTX(CTX_SIEVESCRIPT);
 403         return GetTemplateTokenNumber(Target,
 404                                       TP,
 405                                       3,
 406                                       larger)
 407                 ==
 408                 Rule->sizecomp;
 409 }
 410 int ConditionalSieveRule_final(StrBuf *Target, WCTemplputParams *TP)
 411 {
 412         SieveRule     *Rule = (SieveRule *)CTX(CTX_SIEVESCRIPT);
 413         return GetTemplateTokenNumber(Target,
 414                                       TP,
 415                                       3,
 416                                       econtinue)
 417                 ==
 418                 Rule->final;
 419 }
 420 int ConditionalSieveRule_ThisRoom(StrBuf *Target, WCTemplputParams *TP)
 421 {
 422         SieveRule     *Rule = (SieveRule *)CTX(CTX_SIEVESCRIPT);
 423         return GetTemplateTokenNumber(Target,
 424                                       TP,
 425                                       3,
 426                                       econtinue)
 427                 ==
 428                 Rule->final;
 429 }
 430 int ConditionalSieveRule_Active(StrBuf *Target, WCTemplputParams *TP)
 431 {
 432         SieveRule     *Rule = (SieveRule *)CTX(CTX_SIEVESCRIPT);
 433         return Rule->active;
 434 }
 435 void tmplput_SieveRule_htext(StrBuf *Target, WCTemplputParams *TP)
 436 {
 437         SieveRule     *Rule = (SieveRule *)CTX(CTX_SIEVESCRIPT);
 438         StrBufAppendTemplate(Target, TP, Rule->htext, 0);
 439 }
 440 void tmplput_SieveRule_fileinto(StrBuf *Target, WCTemplputParams *TP)
 441 {
 442         SieveRule     *Rule = (SieveRule *)CTX(CTX_SIEVESCRIPT);
 443         StrBufAppendTemplate(Target, TP, Rule->fileinto, 0);
 444 }
 445 void tmplput_SieveRule_redirect(StrBuf *Target, WCTemplputParams *TP)
 446 {
 447         SieveRule     *Rule = (SieveRule *)CTX(CTX_SIEVESCRIPT);
 448         StrBufAppendTemplate(Target, TP, Rule->redirect, 0);
 449 }
 450 void tmplput_SieveRule_automsg(StrBuf *Target, WCTemplputParams *TP)
 451 {
 452         SieveRule     *Rule = (SieveRule *)CTX(CTX_SIEVESCRIPT);
 453         StrBufAppendTemplate(Target, TP, Rule->automsg, 0);
 454 }
 455 void tmplput_SieveRule_sizeval(StrBuf *Target, WCTemplputParams *TP)
 456 {
 457         SieveRule     *Rule = (SieveRule *)CTX(CTX_SIEVESCRIPT);
 458         StrBufAppendPrintf(Target, "%d", Rule->sizeval);
 459 }
 460
 461 void tmplput_SieveRule_lookup_FileIntoRoom(StrBuf *Target, WCTemplputParams *TP)
 462 {
 463         void *vRoom;
 464         SieveRule     *Rule = (SieveRule *)CTX(CTX_SIEVESCRIPT);
 465         wcsession *WCC = WC;
 466         HashList *Rooms = GetRoomListHashLKRA(Target, TP);
 467
 468         GetHash(Rooms, SKEY(Rule->fileinto), &vRoom);
 469         WCC->ThisRoom = (folder*) vRoom;
 470 }
 471
 472 void FreeSieveRule(void *vRule)
 473 {
 474         SieveRule *Rule = (SieveRule*) vRule;
 475
 476         FreeStrBuf(&Rule->htext);
 477         FreeStrBuf(&Rule->fileinto);
 478         FreeStrBuf(&Rule->redirect);
 479         FreeStrBuf(&Rule->automsg);
 480
 481         free(Rule);
 482 }
 483
 484 #define WC_RULE_HEADER "rule|"
 485 HashList *GetSieveRules(StrBuf *Target, WCTemplputParams *TP)
 486 {
 487         StrBuf *Line = NULL;
 488         StrBuf *EncodedRule = NULL;
 489         int n = 0;
 490         const char *pch = NULL;
 491         HashList *SieveRules = NULL;
 492         int Done = 0;
 493         SieveRule *Rule = NULL;
 494
 495         SieveRules = NewHash(1, Flathash);
 496         serv_printf("GIBR");
 497         Line = NewStrBuf();
 498         EncodedRule = NewStrBuf();
 499         StrBuf_ServGetln(Line);
 500         if (GetServerStatus(Line, NULL) == 1)
 501         {
 502                 while(!Done && (StrBuf_ServGetln(Line) >= 0) )
 503                         if ( (StrLength(Line)==3) &&
 504                              !strcmp(ChrPtr(Line), "000"))
 505                         {
 506                                 Done = 1;
 507                         }
 508                         else
 509                         {
 510                                 pch = NULL;
 511                                 /* We just care for our encoded header and skip everything else */
 512                                 if ((StrLength(Line) > sizeof(WC_RULE_HEADER) - 1) && (!strncasecmp(ChrPtr(Line), HKEY(WC_RULE_HEADER))))
 513                                 {
 514                                         StrBufSkip_NTokenS(Line, &pch, '|', 1);
 515                                         n = StrBufExtractNext_int(Line, &pch, '|');
 516                                         StrBufExtract_NextToken(EncodedRule, Line, &pch, '|');
 517                                         StrBufDecodeBase64(EncodedRule);
 518
 519                                         Rule = (SieveRule*) malloc(sizeof(SieveRule));
 520
 521                                         Rule->htext = NewStrBufPlain (NULL, StrLength(EncodedRule));
 522
 523                                         Rule->fileinto = NewStrBufPlain (NULL, StrLength(EncodedRule));
 524                                         Rule->redirect = NewStrBufPlain (NULL, StrLength(EncodedRule));
 525                                         Rule->automsg = NewStrBufPlain (NULL, StrLength(EncodedRule));
 526
 527                                         /* Grab our existing values to populate */
 528                                         pch = NULL;
 529                                         Rule->active = StrBufExtractNext_int(EncodedRule, &pch, '|');
 530                                         StrBufExtract_NextToken(Line, EncodedRule, &pch, '|');
 531
 532                                         Rule->hfield = (eSieveHfield) GetTokenDefine(SKEY(Line), tocc);
 533                                         StrBufExtract_NextToken(Line, EncodedRule, &pch, '|');
 534                                         Rule->compare = (eSieveCompare) GetTokenDefine(SKEY(Line), contains);
 535                                         StrBufExtract_NextToken(Rule->htext, EncodedRule, &pch, '|');
 536                                         StrBufExtract_NextToken(Line, EncodedRule, &pch, '|');
 537                                         Rule->sizecomp = (eSieveSizeComp) GetTokenDefine(SKEY(Line), larger);
 538                                         Rule->sizeval = StrBufExtractNext_int(EncodedRule, &pch, '|');
 539                                         StrBufExtract_NextToken(Line, EncodedRule, &pch, '|');
 540                                         Rule->Action = (eSieveAction) GetTokenDefine(SKEY(Line), keep);
 541                                         StrBufExtract_NextToken(Rule->fileinto, EncodedRule, &pch, '|');
 542                                         StrBufExtract_NextToken(Rule->redirect, EncodedRule, &pch, '|');
 543                                         StrBufExtract_NextToken(Rule->automsg, EncodedRule, &pch, '|');
 544                                         StrBufExtract_NextToken(Line, EncodedRule, &pch, '|');
 545                                         Rule->final = (eSieveFinal) GetTokenDefine(SKEY(Line), econtinue);
 546                                         Put(SieveRules, IKEY(n), Rule, FreeSieveRule);
 547                                         n++;
 548                                 }
 549                         }
 550         }
 551
 552         while (n < MAX_RULES) {
 553                 Rule = (SieveRule*) malloc(sizeof(SieveRule));
 554                 memset(Rule, 0, sizeof(SieveRule));
 555                 Put(SieveRules, IKEY(n), Rule, FreeSieveRule);
 556
 557                 n++;
 558         }
 559
 560
 561         FreeStrBuf(&EncodedRule);
 562         FreeStrBuf(&Line);
 563         return SieveRules;
 564 }
 565
 566 void
 567 SessionDetachModule_SIEVE
 568 (wcsession *sess)
 569 {
 570         DeleteHash(&sess->KnownSieveScripts);
 571 }
 572
 573 void
 574 InitModule_SIEVE
 575 (void)
 576 {
 577         RegisterCTX(CTX_SIEVELIST);
 578         RegisterCTX(CTX_SIEVESCRIPT);
 579         REGISTERTokenParamDefine(from);
 580         REGISTERTokenParamDefine(tocc);
 581         REGISTERTokenParamDefine(subject);
 582         REGISTERTokenParamDefine(replyto);
 583         REGISTERTokenParamDefine(sender);
 584         REGISTERTokenParamDefine(resentfrom);
 585         REGISTERTokenParamDefine(resentto);
 586         REGISTERTokenParamDefine(envfrom);
 587         REGISTERTokenParamDefine(envto);
 588         REGISTERTokenParamDefine(xmailer);
 589         REGISTERTokenParamDefine(xspamflag);
 590         REGISTERTokenParamDefine(xspamstatus);
 591         REGISTERTokenParamDefine(listid);
 592         REGISTERTokenParamDefine(size);
 593         REGISTERTokenParamDefine(all);
 594
 595         REGISTERTokenParamDefine(contains);
 596         REGISTERTokenParamDefine(notcontains);
 597         REGISTERTokenParamDefine(is);
 598         REGISTERTokenParamDefine(isnot);
 599         REGISTERTokenParamDefine(matches);
 600         REGISTERTokenParamDefine(notmatches);
 601
 602         REGISTERTokenParamDefine(keep);
 603         REGISTERTokenParamDefine(discard);
 604         REGISTERTokenParamDefine(reject);
 605         REGISTERTokenParamDefine(fileinto);
 606         REGISTERTokenParamDefine(redirect);
 607         REGISTERTokenParamDefine(vacation);
 608
 609         REGISTERTokenParamDefine(larger);
 610         REGISTERTokenParamDefine(smaller);
 611
 612         /* these are c-keyworads, so do it by hand. */
 613         RegisterTokenParamDefine(HKEY("continue"), econtinue);
 614         RegisterTokenParamDefine(HKEY("stop"), estop);
 615
 616         RegisterIterator("SIEVE:SCRIPTS", 0, NULL, GetSieveScriptListing, NULL, NULL, CTX_SIEVELIST, CTX_NONE, IT_NOFLAG);
 617
 618         RegisterConditional("COND:SIEVE:SCRIPT:ACTIVE", 0, ConditionalSieveScriptIsActive, CTX_SIEVELIST);
 619         RegisterConditional("COND:SIEVE:SCRIPT:ISRULES", 0, ConditionalSieveScriptIsRulesScript, CTX_SIEVELIST);
 620         RegisterNamespace("SIEVE:SCRIPT:NAME", 0, 1, tmplput_SieveScriptName, NULL, CTX_SIEVELIST);
 621         RegisterNamespace("SIEVE:SCRIPT:CONTENT", 0, 1, tmplput_SieveScriptContent, NULL, CTX_SIEVELIST);
 622
 623
 624         RegisterIterator("SIEVE:RULES", 0, NULL, GetSieveRules, NULL, DeleteHash, CTX_SIEVESCRIPT, CTX_NONE, IT_NOFLAG);
 625
 626         RegisterConditional("COND:SIEVE:ACTIVE", 1, ConditionalSieveRule_Active, CTX_SIEVESCRIPT);
 627         RegisterConditional("COND:SIEVE:HFIELD", 1, ConditionalSieveRule_hfield, CTX_SIEVESCRIPT);
 628         RegisterConditional("COND:SIEVE:COMPARE", 1, ConditionalSieveRule_compare, CTX_SIEVESCRIPT);
 629         RegisterConditional("COND:SIEVE:ACTION", 1, ConditionalSieveRule_action, CTX_SIEVESCRIPT);
 630         RegisterConditional("COND:SIEVE:SIZECOMP", 1, ConditionalSieveRule_sizecomp, CTX_SIEVESCRIPT);
 631         RegisterConditional("COND:SIEVE:FINAL", 1, ConditionalSieveRule_final, CTX_SIEVESCRIPT);
 632         RegisterConditional("COND:SIEVE:THISROOM", 1, ConditionalSieveRule_ThisRoom, CTX_SIEVESCRIPT);
 633
 634         RegisterNamespace("SIEVE:SCRIPT:HTEXT", 0, 1, tmplput_SieveRule_htext, NULL, CTX_SIEVESCRIPT);
 635         RegisterNamespace("SIEVE:SCRIPT:SIZE", 0, 1, tmplput_SieveRule_sizeval, NULL, CTX_SIEVESCRIPT);
 636         RegisterNamespace("SIEVE:SCRIPT:FILEINTO", 0, 1, tmplput_SieveRule_fileinto, NULL, CTX_SIEVESCRIPT);
 637         RegisterNamespace("SIEVE:SCRIPT:REDIRECT", 0, 1, tmplput_SieveRule_redirect, NULL, CTX_SIEVESCRIPT);
 638         RegisterNamespace("SIEVE:SCRIPT:AUTOMSG", 0, 1, tmplput_SieveRule_automsg, NULL, CTX_SIEVESCRIPT);
 639
 640         /* fetch our room into WCC->ThisRoom, to evaluate while iterating over rooms with COND:THIS:THAT:ROOM */
 641         RegisterNamespace("SIEVE:SCRIPT:LOOKUP_FILEINTO", 0, 1, tmplput_SieveRule_lookup_FileIntoRoom, NULL, CTX_SIEVESCRIPT);
 642         WebcitAddUrlHandler(HKEY("save_sieve"), "", 0, save_sieve, 0);
 643         WebcitAddUrlHandler(HKEY("display_sieve_add_or_delete"), "", 0, display_sieve_add_or_delete, 0);
 644 }