webcit/paramhandling.c

   1 /*
   2  * parse urlparts and post data
   3  *
   4  * Copyright (c) 1996-2019 by the citadel.org team
   5  *
   6  * This program is open source software.  You can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License, version 3.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14
  15 #include "webcit.h"
  16 #include "webserver.h"
  17
  18 /* uncomment to see all parameters sent to the server by the browser. */
  19 /* #define DEBUG_URLSTRINGS */
  20
  21
  22 void free_url(void *U)
  23 {
  24         urlcontent *u = (urlcontent*) U;
  25         FreeStrBuf(&u->url_data);
  26         if (u->sub != NULL) {
  27                 DeleteHash(&u->sub);
  28         }
  29         free(u);
  30 }
  31
  32 void PutSubstructUrlKey(HashList *list, urlcontent *u, char **keys, long *lengths, int max, int which){
  33         void *vUrl;
  34         urlcontent *subu;
  35         HashList *thisList = list;
  36         if (GetHash(list, keys[which], lengths[which], &vUrl) &&
  37             (vUrl != NULL))
  38         {
  39                 subu = (urlcontent*) vUrl;
  40                 if (subu->sub == NULL) {
  41                         subu->sub = NewHash(1, NULL);
  42                 }
  43                 thisList = subu->sub;
  44         }
  45         else if (which < max) {
  46                 subu = (urlcontent *) malloc(sizeof(urlcontent));
  47
  48                 memcpy(subu->url_key, keys[which], lengths[which]);
  49                 subu->klen = lengths[which];
  50                 subu->url_data = NULL;
  51                 subu->sub = NewHash(1, NULL);
  52
  53                 Put(list, subu->url_key, subu->klen, subu, free_url);
  54                 thisList = subu->sub;
  55         }
  56         if (which >= max) {
  57                 Put(thisList, keys[which], lengths[which], u, free_url);
  58         }
  59         else {
  60                 PutSubstructUrlKey(subu->sub, u, keys, lengths, max, which + 1);
  61         }
  62 }
  63
  64 void PutUrlKey(HashList *urlstrings, urlcontent *u, int have_colons) {
  65         if (have_colons == 0) {
  66                 Put(urlstrings, u->url_key, u->klen, u, free_url);
  67         }
  68         else {
  69                 char *keys[10];
  70                 long lengths[10];
  71                 int i = 0;
  72                 char *pch;
  73                 char *pchs;
  74                 char *pche;
  75
  76                 memset(&keys, 0, sizeof(keys));
  77                 memset(&lengths, 0, sizeof(lengths));
  78                 pchs = pch = u->url_key;
  79                 pche = u->url_key + u->klen;
  80                 while ((i < 10) && (pch <= pche)) {
  81                         if ((have_colons == 2) &&
  82                             (*pch == '%') &&
  83                             (*(pch + 1) == '3') &&
  84                             ((*(pch + 2) == 'A') ||
  85                              (*(pch + 1) == 'a')
  86                                     ))
  87                         {
  88                                 *pch = '\0';
  89
  90                                 if (i == 0) {
  91                                         /* Separate the toplevel key : */
  92                                         u->klen = pch - pchs;
  93                                 }
  94
  95                                 /* sub-section: */
  96                                 keys[i] = pchs;
  97                                 lengths[i] = pch - pchs;
  98
  99                                 pch += 3;
 100
 101                                 pchs = pch;
 102                                 i++;
 103                         }
 104                         else if ((have_colons == 1) &&
 105                                  (*pch == ':')) {
 106                                 *pch = '\0';
 107                                 if (i == 0) {
 108                                         /* Separate the toplevel key : */
 109                                         u->klen = pch - pchs;
 110                                 }
 111                                 /* sub-section: */
 112                                 keys[i] = pchs;
 113                                 lengths[i] = pch - pchs;
 114
 115                                 pch++;
 116                                 pchs = pch;
 117                                 i++;
 118                         }
 119                         else if (pch == pche){
 120                                 /* sub-section: */
 121                                 keys[i] = pchs;
 122                                 lengths[i] = pch - pchs;
 123                                 i++;
 124                                 break;
 125                         }
 126                         else {
 127                                 pch ++;
 128                         }
 129                 }
 130
 131                 PutSubstructUrlKey(urlstrings, u, keys, lengths, i - 1, 0);
 132         }
 133 }
 134
 135 /*
 136  * Extract variables from the URL.
 137  */
 138 void ParseURLParams(StrBuf *url)
 139 {
 140         const char *aptr, *bptr, *eptr, *up = NULL;
 141         int len, keylen = 0;
 142         urlcontent *u = NULL;
 143         wcsession *WCC = WC;
 144
 145         if (WCC->Hdr->urlstrings == NULL) {
 146                 WCC->Hdr->urlstrings = NewHash(1, NULL);
 147         }
 148         eptr = ChrPtr(url) + StrLength(url);
 149         up = ChrPtr(url);
 150         while ((up < eptr) && (!IsEmptyStr(up))) {
 151                 int have_colon = 0;
 152                 aptr = up;
 153                 while ((aptr < eptr) && (*aptr != '\0') && (*aptr != '=')) {
 154                         if (*aptr == ':') {
 155                                 have_colon = 1;
 156                         }
 157                         else if ((*aptr == '%') &&
 158                                  (*(aptr + 1) == '3') &&
 159                                  ((*(aptr + 2) == 'A') ||
 160                                   (*(aptr + 1) == 'a')
 161                                          ))
 162                         {
 163                                 have_colon = 2;
 164                         }
 165                         aptr++;
 166                 }
 167                 if (*aptr != '=') {
 168                         return;
 169                 }
 170                 aptr++;
 171                 bptr = aptr;
 172                 while ((bptr < eptr) && (*bptr != '\0')
 173                       && (*bptr != '&') && (*bptr != '?') && (*bptr != ' ')) {
 174                         bptr++;
 175                 }
 176                 keylen = aptr - up - 1; /* -1 -> '=' */
 177                 if (keylen > sizeof(u->url_key)) {
 178                         syslog(LOG_WARNING, "%s:%d: invalid url_key of size %d in string size %ld",
 179                                 __FILE__, __LINE__, keylen, (long)sizeof(u->url_key)
 180                         );
 181                         free(u);
 182                         return;
 183                 }
 184
 185                 if (keylen < 0) {
 186                         syslog(LOG_WARNING, "%s:%d: invalid url_key of size %d", __FILE__, __LINE__, keylen);
 187                         free(u);
 188                         return;
 189                 }
 190
 191                 u = (urlcontent *) malloc(sizeof(urlcontent));
 192                 memcpy(u->url_key, up, keylen);
 193                 u->url_key[keylen] = '\0';
 194                 u->klen = keylen;
 195                 u->sub = NULL;
 196
 197                 if (strncmp(u->url_key, "__", 2) != 0)
 198                 {
 199                         len = bptr - aptr;
 200                         u->url_data = NewStrBufPlain(aptr, len);
 201                         StrBufUnescape(u->url_data, 1);
 202 #ifdef DEBUG_URLSTRINGS
 203                         syslog(LOG_DEBUG, "%s = [%d]  %s\n",
 204                                 u->url_key,
 205                                 StrLength(u->url_data),
 206                                 ChrPtr(u->url_data));
 207 #endif
 208                         PutUrlKey(WCC->Hdr->urlstrings, u, have_colon);
 209                 }
 210                 else {
 211                         len = bptr - aptr;
 212                         u->url_data = NewStrBufPlain(aptr, len);
 213                         StrBufUnescape(u->url_data, 1);
 214                         syslog(LOG_WARNING, "REJECTED because of __ is internal only: %s = [%d]  %s\n",
 215                                 u->url_key,
 216                                 StrLength(u->url_data),
 217                                 ChrPtr(u->url_data));
 218
 219                         free_url(u);
 220                 }
 221                 up = bptr;
 222                 ++up;
 223         }
 224 }
 225
 226 /*
 227  * free urlstring memory
 228  */
 229 void free_urls(void)
 230 {
 231         DeleteHash(&WC->Hdr->urlstrings);
 232 }
 233
 234 /*
 235  * Diagnostic function to display the contents of all variables
 236  */
 237
 238 void dump_vars(void)
 239 {
 240         wcsession *WCC = WC;
 241         urlcontent *u;
 242         void *U;
 243         long HKLen;
 244         const char *HKey;
 245         HashPos *Cursor;
 246
 247         Cursor = GetNewHashPos (WCC->Hdr->urlstrings, 0);
 248         while (GetNextHashPos(WCC->Hdr->urlstrings, Cursor, &HKLen, &HKey, &U)) {
 249                 u = (urlcontent*) U;
 250                 wc_printf("%38s = %s\n", u->url_key, ChrPtr(u->url_data));
 251         }
 252 }
 253
 254 /*
 255  * Return the value of a variable supplied to the current web page (from the url or a form)
 256  */
 257
 258 const char *XBstr(const char *key, size_t keylen, size_t *len)
 259 {
 260         void *U;
 261
 262         if ((WC->Hdr->urlstrings != NULL) &&
 263             GetHash(WC->Hdr->urlstrings, key, keylen, &U)) {
 264                 *len = StrLength(((urlcontent *)U)->url_data);
 265                 return ChrPtr(((urlcontent *)U)->url_data);
 266         }
 267         else {
 268                 *len = 0;
 269                 return ("");
 270         }
 271 }
 272
 273 const char *XBSTR(const char *key, size_t *len)
 274 {
 275         void *U;
 276
 277         if ((WC->Hdr->urlstrings != NULL) &&
 278             GetHash(WC->Hdr->urlstrings, key, strlen (key), &U)){
 279                 *len = StrLength(((urlcontent *)U)->url_data);
 280                 return ChrPtr(((urlcontent *)U)->url_data);
 281         }
 282         else {
 283                 *len = 0;
 284                 return ("");
 285         }
 286 }
 287
 288
 289 const char *BSTR(const char *key)
 290 {
 291         void *U;
 292
 293         if ((WC->Hdr->urlstrings != NULL) &&
 294             GetHash(WC->Hdr->urlstrings, key, strlen (key), &U))
 295                 return ChrPtr(((urlcontent *)U)->url_data);
 296         else
 297                 return ("");
 298 }
 299
 300 const char *Bstr(const char *key, size_t keylen)
 301 {
 302         void *U;
 303
 304         if ((WC->Hdr->urlstrings != NULL) &&
 305             GetHash(WC->Hdr->urlstrings, key, keylen, &U))
 306                 return ChrPtr(((urlcontent *)U)->url_data);
 307         else
 308                 return ("");
 309 }
 310
 311 const StrBuf *SBSTR(const char *key)
 312 {
 313         void *U;
 314
 315         if ((WC->Hdr->urlstrings != NULL) &&
 316             GetHash(WC->Hdr->urlstrings, key, strlen (key), &U))
 317                 return ((urlcontent *)U)->url_data;
 318         else
 319                 return NULL;
 320 }
 321
 322 const StrBuf *SBstr(const char *key, size_t keylen)
 323 {
 324         void *U;
 325
 326         if ((WC->Hdr->urlstrings != NULL) &&
 327             GetHash(WC->Hdr->urlstrings, key, keylen, &U))
 328                 return ((urlcontent *)U)->url_data;
 329         else
 330                 return NULL;
 331 }
 332
 333 long LBstr(const char *key, size_t keylen)
 334 {
 335         void *U;
 336
 337         if ((WC->Hdr->urlstrings != NULL) &&
 338             GetHash(WC->Hdr->urlstrings, key, keylen, &U))
 339                 return StrTol(((urlcontent *)U)->url_data);
 340         else
 341                 return (0);
 342 }
 343
 344 int IBstr(const char *key, size_t keylen)
 345 {
 346         void *U;
 347
 348         if ((WC->Hdr->urlstrings != NULL) &&
 349             GetHash(WC->Hdr->urlstrings, key, keylen, &U))
 350                 return StrTol(((urlcontent *)U)->url_data);
 351         else
 352                 return (0);
 353 }
 354
 355 int IBSTR(const char *key)
 356 {
 357         void *U;
 358
 359         if ((WC->Hdr->urlstrings != NULL) &&
 360             GetHash(WC->Hdr->urlstrings, key, strlen(key), &U))
 361                 return StrToi(((urlcontent *)U)->url_data);
 362         else
 363                 return (0);
 364 }
 365
 366 int HaveBstr(const char *key, size_t keylen)
 367 {
 368         void *U;
 369
 370         if ((WC->Hdr->urlstrings != NULL) &&
 371             GetHash(WC->Hdr->urlstrings, key, keylen, &U))
 372                 return (StrLength(((urlcontent *)U)->url_data) != 0);
 373         else
 374                 return (0);
 375 }
 376
 377 int YesBstr(const char *key, size_t keylen)
 378 {
 379         void *U;
 380
 381         if ((WC->Hdr->urlstrings != NULL) &&
 382             GetHash(WC->Hdr->urlstrings, key, keylen, &U))
 383                 return strcmp( ChrPtr(((urlcontent *)U)->url_data), "yes") == 0;
 384         else
 385                 return (0);
 386 }
 387
 388 int YESBSTR(const char *key)
 389 {
 390         void *U;
 391
 392         if ((WC->Hdr->urlstrings != NULL) &&
 393             GetHash(WC->Hdr->urlstrings, key, strlen(key), &U))
 394                 return strcmp( ChrPtr(((urlcontent *)U)->url_data), "yes") == 0;
 395         else
 396                 return (0);
 397 }
 398
 399
 400 /*
 401  * Return a sub array that was separated by a colon:
 402  */
 403 HashList* getSubStruct(const char *key, size_t keylen)
 404 {
 405         void *U;
 406
 407         if ((WC->Hdr->urlstrings != NULL) &&
 408             GetHash(WC->Hdr->urlstrings, key, strlen(key), &U))
 409                 return ((urlcontent *)U)->sub;
 410         else
 411                 return NULL;
 412 }
 413
 414
 415 /*
 416  * Return the value of a variable of a substruct provided by getSubStruct
 417  */
 418 const char *XSubBstr(HashList *sub, const char *key, size_t keylen, size_t *len)
 419 {
 420         void *U;
 421
 422         if ((sub != NULL) &&
 423             GetHash(sub, key, keylen, &U)) {
 424                 *len = StrLength(((urlcontent *)U)->url_data);
 425                 return ChrPtr(((urlcontent *)U)->url_data);
 426         }
 427         else {
 428                 *len = 0;
 429                 return ("");
 430         }
 431 }
 432
 433 const char *SubBstr(HashList *sub, const char *key, size_t keylen)
 434 {
 435         void *U;
 436
 437         if ((sub != NULL) &&
 438             GetHash(sub, key, keylen, &U)) {
 439                 return ChrPtr(((urlcontent *)U)->url_data);
 440         }
 441         else
 442                 return ("");
 443 }
 444
 445 const StrBuf *SSubBstr(HashList *sub, const char *key, size_t keylen)
 446 {
 447         void *U;
 448
 449         if ((sub != NULL) &&
 450             GetHash(sub, key, keylen, &U)) {
 451                 return ((urlcontent *)U)->url_data;
 452         }
 453         else
 454                 return NULL;
 455 }
 456
 457 long LSubBstr(HashList *sub, const char *key, size_t keylen)
 458 {
 459         void *U;
 460
 461         if ((sub != NULL) &&
 462             GetHash(sub, key, keylen, &U)) {
 463                 return StrTol(((urlcontent *)U)->url_data);
 464         }
 465         else
 466                 return (0);
 467 }
 468
 469 int ISubBstr(HashList *sub, const char *key, size_t keylen)
 470 {
 471         void *U;
 472
 473         if ((sub != NULL) &&
 474             GetHash(sub, key, keylen, &U)) {
 475                 return StrTol(((urlcontent *)U)->url_data);
 476         }
 477         else
 478                 return (0);
 479 }
 480
 481 int HaveSubBstr(HashList *sub, const char *key, size_t keylen)
 482 {
 483         void *U;
 484
 485         if ((sub != NULL) &&
 486             GetHash(sub, key, keylen, &U)) {
 487                 return (StrLength(((urlcontent *)U)->url_data) != 0);
 488         }
 489         else
 490                 return (0);
 491 }
 492
 493 int YesSubBstr(HashList *sub, const char *key, size_t keylen)
 494 {
 495         void *U;
 496
 497         if ((sub != NULL) &&
 498             GetHash(sub, key, keylen, &U)) {
 499                 return strcmp( ChrPtr(((urlcontent *)U)->url_data), "yes") == 0;
 500         }
 501         else
 502                 return (0);
 503 }
 504
 505
 506 /*
 507  * This function is called by the MIME parser to handle data uploaded by
 508  * the browser.  Form data, uploaded files, and the data from HTTP PUT
 509  * operations (such as those found in GroupDAV) all arrive this way.
 510  *
 511  * name         Name of the item being uploaded
 512  * filename     Filename of the item being uploaded
 513  * partnum      MIME part identifier (not needed)
 514  * disp         MIME content disposition (not needed)
 515  * content      The actual data
 516  * cbtype       MIME content-type
 517  * cbcharset    Character set
 518  * length       Content length
 519  * encoding     MIME encoding type (not needed)
 520  * cbid         Content ID (not needed)
 521  * userdata     Not used here
 522  */
 523 void upload_handler(char *name, char *filename, char *partnum, char *disp,
 524                         void *content, char *cbtype, char *cbcharset,
 525                         size_t length, char *encoding, char *cbid, void *userdata)
 526 {
 527         wcsession *WCC = WC;
 528         urlcontent *u;
 529         long keylen;
 530
 531 #ifdef DEBUG_URLSTRINGS
 532         syslog(LOG_DEBUG, "upload_handler() name=%s, type=%s, len="SIZE_T_FMT, name, cbtype, length);
 533 #endif
 534         if (WCC->Hdr->urlstrings == NULL)
 535                 WCC->Hdr->urlstrings = NewHash(1, NULL);
 536
 537         /* Form fields */
 538         if ( (length > 0) && (IsEmptyStr(cbtype)) ) {
 539                 u = (urlcontent *) malloc(sizeof(urlcontent));
 540
 541                 keylen = safestrncpy(u->url_key, name, sizeof(u->url_key));
 542                 u->url_data = NewStrBufPlain(content, length);
 543                 u->klen = keylen;
 544                 u->sub = NULL;
 545
 546                 if (strncmp(u->url_key, "__", 2) != 0)
 547                 {
 548                         PutUrlKey(WCC->Hdr->urlstrings, u, (strchr(u->url_key, ':') != NULL));
 549                 }
 550                 else {
 551                         syslog(LOG_INFO, "REJECTED because of __ is internal only: %s = [%d]  %s\n",
 552                                 u->url_key,
 553                                 StrLength(u->url_data),
 554                                 ChrPtr(u->url_data));
 555
 556                         free_url(u);
 557                 }
 558 #ifdef DEBUG_URLSTRINGS
 559                 syslog(LOG_DEBUG, "Key: <%s> len: [%d] Data: <%s>",
 560                         u->url_key,
 561                         StrLength(u->url_data),
 562                         ChrPtr(u->url_data));
 563 #endif
 564         }
 565
 566         /* Uploaded files */
 567         if ( (length > 0) && (!IsEmptyStr(cbtype)) ) {
 568                 WCC->upload = NewStrBufPlain(content, length);
 569                 WCC->upload_length = length;
 570                 WCC->upload_filename = NewStrBufPlain(filename, -1);
 571                 safestrncpy(WCC->upload_content_type, cbtype, sizeof(WC->upload_content_type));
 572 #ifdef DEBUG_URLSTRINGS
 573                 syslog(LOG_DEBUG, "File: <%s> len: [%ld]", filename, (long int)length);
 574 #endif
 575
 576         }
 577
 578 }
 579
 580 void PutBstr(const char *key, long keylen, StrBuf *Value)
 581 {
 582         urlcontent *u;
 583
 584         if(keylen >= sizeof(u->url_key)) {
 585                 syslog(LOG_WARNING, "%s:%d: invalid url_key of size %ld", __FILE__, __LINE__, keylen);
 586                 FreeStrBuf(&Value);
 587                 return;
 588         }
 589         u = (urlcontent*)malloc(sizeof(urlcontent));
 590         memcpy(u->url_key, key, keylen + 1);
 591         u->klen = keylen;
 592         u->url_data = Value;
 593         u->sub = NULL;
 594         Put(WC->Hdr->urlstrings, u->url_key, keylen, u, free_url);
 595 }
 596 void PutlBstr(const char *key, long keylen, long Value)
 597 {
 598         StrBuf *Buf;
 599
 600         Buf = NewStrBufPlain(NULL, sizeof(long) * 16);
 601         StrBufPrintf(Buf, "%ld", Value);
 602         PutBstr(key, keylen, Buf);
 603 }
 604
 605
 606
 607 int ConditionalBstr(StrBuf *Target, WCTemplputParams *TP)
 608 {
 609         if(TP->Tokens->nParameters == 3)
 610                 return HaveBstr(TKEY(2));
 611         else {
 612                 if (IS_NUMBER(TP->Tokens->Params[3]->Type))
 613                 {
 614                         return LBstr(TKEY(2)) ==
 615                                 GetTemplateTokenNumber(Target,
 616                                                        TP,
 617                                                        3,
 618                                                        0);
 619                 }
 620                 else {
 621                         const char *pch;
 622                         long len;
 623
 624                         GetTemplateTokenString (Target, TP, 3, &pch, &len);
 625                         return strcmp(Bstr(TKEY(2)), pch) == 0;
 626                 }
 627         }
 628 }
 629
 630 void tmplput_bstr(StrBuf *Target, WCTemplputParams *TP)
 631 {
 632         const StrBuf *Buf = SBstr(TKEY(0));
 633         if (Buf != NULL)
 634                 StrBufAppendTemplate(Target, TP, Buf, 1);
 635 }
 636
 637
 638 void tmplput_bstrforward(StrBuf *Target, WCTemplputParams *TP)
 639 {
 640         const StrBuf *Buf = SBstr(TKEY(0));
 641         if (Buf != NULL) {
 642                 StrBufAppendBufPlain(Target, HKEY("?"), 0);
 643                 StrBufAppendBufPlain(Target, TKEY(0), 0);
 644                 StrBufAppendBufPlain(Target, HKEY("="), 0);
 645                 StrBufAppendTemplate(Target, TP, Buf, 1);
 646         }
 647 }
 648
 649 void diagnostics(void)
 650 {
 651         output_headers(1, 1, 1, 0, 0, 0);
 652         wc_printf("Session: %d<hr />\n", WC->wc_session);
 653         wc_printf("Command: <br><PRE>\n");
 654 /*
 655 StrEscAppend(WC->WBuf, NULL, WC->UrlFragment1, 0, 0);
 656         wc_printf("<br>\n");
 657 StrEscAppend(WC->WBuf, NULL, WC->UrlFragment12 0, 0);
 658         wc_printf("<br>\n");
 659 StrEscAppend(WC->WBuf, NULL, WC->UrlFragment3, 0, 0);
 660 */
 661         wc_printf("</PRE><hr />\n");
 662         wc_printf("Variables: <br><PRE>\n");
 663         dump_vars();
 664         wc_printf("</PRE><hr />\n");
 665         wDumpContent(1);
 666 }
 667
 668
 669 void tmplput_url_part(StrBuf *Target, WCTemplputParams *TP)
 670 {
 671         StrBuf *Name = NULL;
 672         StrBuf *UrlBuf = NULL;
 673         wcsession *WCC = WC;
 674
 675         if (WCC != NULL) {
 676                 long n;
 677
 678                 n = GetTemplateTokenNumber(Target, TP, 0, 0);
 679                 if (n == 0) {
 680                         if (WCC->Hdr->HR.Handler != NULL)
 681                                 UrlBuf = Name = WCC->Hdr->HR.Handler->Name;
 682                 }
 683                 else if (n == 1) {
 684                         UrlBuf = NewStrBuf();
 685                         StrBufExtract_token(UrlBuf, WCC->Hdr->HR.ReqLine, 0, '/');
 686                 }
 687                 else {
 688                         UrlBuf = NewStrBuf();
 689                         StrBufExtract_token(UrlBuf, WCC->Hdr->HR.ReqLine, 1, '/');
 690                 }
 691
 692                 if (UrlBuf == NULL)  {
 693                         LogTemplateError(Target, "urlbuf", ERR_PARM1, TP, "not set.");
 694                 }
 695                 StrBufAppendTemplate(Target, TP, UrlBuf, 2);
 696                 if (Name == NULL) FreeStrBuf(&UrlBuf);
 697         }
 698 }
 699
 700 typedef struct __BstrPair {
 701         StrBuf *x;
 702         StrBuf *y;
 703 }BstrPair;
 704 CtxType CTX_BSTRPAIRS = CTX_NONE;
 705 void HFreeBstrPair(void *pv)
 706 {
 707         BstrPair *p = (BstrPair*) pv;
 708         FreeStrBuf(&p->x);
 709         FreeStrBuf(&p->y);
 710         free(pv);
 711 }
 712
 713 HashList *iterate_GetBstrPairs(StrBuf *Target, WCTemplputParams *TP)
 714 {
 715         StrBuf *X, *Y;
 716         const char *ch = NULL;
 717         long len;
 718         const StrBuf *TheBStr;
 719         BstrPair *OnePair;
 720         HashList *List;
 721         const char *Pos = NULL;
 722         int i = 0;
 723
 724         if (HaveTemplateTokenString(NULL, TP, 2, &ch, &len))
 725         {
 726                 GetTemplateTokenString(Target, TP, 2, &ch, &len);
 727         }
 728         else
 729         {
 730                 return NULL;
 731         }
 732
 733         TheBStr = SBstr(ch, len);
 734         if ((TheBStr == NULL) || (StrLength(TheBStr) == 0))
 735                 return NULL;
 736         List = NewHash(1, NULL);
 737         while (Pos != StrBufNOTNULL)
 738         {
 739                 X = NewStrBufPlain(NULL, StrLength(TheBStr));
 740                 StrBufExtract_NextToken(X, TheBStr, &Pos, '|');
 741                 if (Pos == StrBufNOTNULL) {
 742                         FreeStrBuf(&X);
 743                         DeleteHash(&List);
 744                         return NULL;
 745                 }
 746                 Y = NewStrBufPlain(NULL, StrLength(TheBStr));
 747                 StrBufExtract_NextToken(Y, TheBStr, &Pos, '|');
 748                 OnePair = (BstrPair*)malloc(sizeof(BstrPair));
 749                 OnePair->x = X;
 750                 OnePair->y = Y;
 751                 Put(List, IKEY(i), OnePair, HFreeBstrPair);
 752                 i++;
 753         }
 754         return List;
 755 }
 756
 757
 758 void tmplput_bstr_pair(StrBuf *Target, WCTemplputParams *TP, int XY)
 759 {
 760         BstrPair *Pair = (BstrPair*) CTX(CTX_BSTRPAIRS);
 761
 762         StrBufAppendTemplate(Target, TP, (XY)?Pair->y:Pair->x, 0);
 763 }
 764
 765 void tmplput_bstr_pair_x(StrBuf *Target, WCTemplputParams *TP)
 766 {       tmplput_bstr_pair(Target, TP, 0); }
 767 void tmplput_bstr_pair_y(StrBuf *Target, WCTemplputParams *TP)
 768 {       tmplput_bstr_pair(Target, TP, 1); }
 769
 770 void
 771 InitModule_PARAMHANDLING
 772 (void)
 773 {
 774         RegisterCTX(CTX_BSTRPAIRS);
 775         WebcitAddUrlHandler(HKEY("diagnostics"), "", 0, diagnostics, NEED_URL);
 776
 777         RegisterIterator("ITERATE:BSTR:PAIR", 1, NULL, iterate_GetBstrPairs, NULL, DeleteHash, CTX_BSTRPAIRS, CTX_NONE, IT_NOFLAG);
 778         RegisterNamespace("BSTR:PAIR:X", 1, 2, tmplput_bstr_pair_x, NULL, CTX_BSTRPAIRS);
 779         RegisterNamespace("BSTR:PAIR:Y", 1, 2, tmplput_bstr_pair_y, NULL, CTX_BSTRPAIRS);
 780
 781         RegisterConditional("COND:BSTR", 1, ConditionalBstr, CTX_NONE);
 782         RegisterNamespace("BSTR", 1, 2, tmplput_bstr, NULL, CTX_NONE);
 783         RegisterNamespace("BSTR:FORWARD", 1, 2, tmplput_bstrforward, NULL, CTX_NONE);
 784         RegisterNamespace("URLPART", 1, 2, tmplput_url_part, NULL, CTX_NONE);
 785 }
 786
 787
 788 void
 789 SessionAttachModule_PARAMHANDLING
 790 (wcsession *sess)
 791 {
 792         sess->Hdr->urlstrings = NewHash(1,NULL);
 793 }
 794
 795 void
 796 SessionDetachModule_PARAMHANDLING
 797 (wcsession *sess)
 798 {
 799         DeleteHash(&sess->Hdr->urlstrings);
 800         FreeStrBuf(&sess->upload_filename);
 801 }