webcit/paramhandling.c

   1 /*
   2  * parse urlparts and post data
   3  *
   4  * Copyright (c) 1996-2013 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                 }
 182
 183                 if (keylen < 0) {
 184                         syslog(LOG_WARNING, "%s:%d: invalid url_key of size %d", __FILE__, __LINE__, keylen);
 185                         free(u);
 186                         return;
 187                 }
 188
 189                 u = (urlcontent *) malloc(sizeof(urlcontent));
 190                 memcpy(u->url_key, up, keylen);
 191                 u->url_key[keylen] = '\0';
 192                 u->klen = keylen;
 193                 u->sub = NULL;
 194
 195                 if (strncmp(u->url_key, "__", 2) != 0)
 196                 {
 197                         len = bptr - aptr;
 198                         u->url_data = NewStrBufPlain(aptr, len);
 199                         StrBufUnescape(u->url_data, 1);
 200 #ifdef DEBUG_URLSTRINGS
 201                         syslog(LOG_DEBUG, "%s = [%d]  %s\n",
 202                                 u->url_key,
 203                                 StrLength(u->url_data),
 204                                 ChrPtr(u->url_data));
 205 #endif
 206                         PutUrlKey(WCC->Hdr->urlstrings, u, have_colon);
 207                 }
 208                 else {
 209                         len = bptr - aptr;
 210                         u->url_data = NewStrBufPlain(aptr, len);
 211                         StrBufUnescape(u->url_data, 1);
 212                         syslog(LOG_WARNING, "REJECTED because of __ is internal only: %s = [%d]  %s\n",
 213                                 u->url_key,
 214                                 StrLength(u->url_data),
 215                                 ChrPtr(u->url_data));
 216
 217                         free_url(u);
 218                 }
 219                 up = bptr;
 220                 ++up;
 221         }
 222 }
 223
 224 /*
 225  * free urlstring memory
 226  */
 227 void free_urls(void)
 228 {
 229         DeleteHash(&WC->Hdr->urlstrings);
 230 }
 231
 232 /*
 233  * Diagnostic function to display the contents of all variables
 234  */
 235
 236 void dump_vars(void)
 237 {
 238         wcsession *WCC = WC;
 239         urlcontent *u;
 240         void *U;
 241         long HKLen;
 242         const char *HKey;
 243         HashPos *Cursor;
 244
 245         Cursor = GetNewHashPos (WCC->Hdr->urlstrings, 0);
 246         while (GetNextHashPos(WCC->Hdr->urlstrings, Cursor, &HKLen, &HKey, &U)) {
 247                 u = (urlcontent*) U;
 248                 wc_printf("%38s = %s\n", u->url_key, ChrPtr(u->url_data));
 249         }
 250 }
 251
 252 /*
 253  * Return the value of a variable supplied to the current web page (from the url or a form)
 254  */
 255
 256 const char *XBstr(const char *key, size_t keylen, size_t *len)
 257 {
 258         void *U;
 259
 260         if ((WC->Hdr->urlstrings != NULL) &&
 261             GetHash(WC->Hdr->urlstrings, key, keylen, &U)) {
 262                 *len = StrLength(((urlcontent *)U)->url_data);
 263                 return ChrPtr(((urlcontent *)U)->url_data);
 264         }
 265         else {
 266                 *len = 0;
 267                 return ("");
 268         }
 269 }
 270
 271 const char *XBSTR(const char *key, size_t *len)
 272 {
 273         void *U;
 274
 275         if ((WC->Hdr->urlstrings != NULL) &&
 276             GetHash(WC->Hdr->urlstrings, key, strlen (key), &U)){
 277                 *len = StrLength(((urlcontent *)U)->url_data);
 278                 return ChrPtr(((urlcontent *)U)->url_data);
 279         }
 280         else {
 281                 *len = 0;
 282                 return ("");
 283         }
 284 }
 285
 286
 287 const char *BSTR(const char *key)
 288 {
 289         void *U;
 290
 291         if ((WC->Hdr->urlstrings != NULL) &&
 292             GetHash(WC->Hdr->urlstrings, key, strlen (key), &U))
 293                 return ChrPtr(((urlcontent *)U)->url_data);
 294         else
 295                 return ("");
 296 }
 297
 298 const char *Bstr(const char *key, size_t keylen)
 299 {
 300         void *U;
 301
 302         if ((WC->Hdr->urlstrings != NULL) &&
 303             GetHash(WC->Hdr->urlstrings, key, keylen, &U))
 304                 return ChrPtr(((urlcontent *)U)->url_data);
 305         else
 306                 return ("");
 307 }
 308
 309 const StrBuf *SBSTR(const char *key)
 310 {
 311         void *U;
 312
 313         if ((WC->Hdr->urlstrings != NULL) &&
 314             GetHash(WC->Hdr->urlstrings, key, strlen (key), &U))
 315                 return ((urlcontent *)U)->url_data;
 316         else
 317                 return NULL;
 318 }
 319
 320 const StrBuf *SBstr(const char *key, size_t keylen)
 321 {
 322         void *U;
 323
 324         if ((WC->Hdr->urlstrings != NULL) &&
 325             GetHash(WC->Hdr->urlstrings, key, keylen, &U))
 326                 return ((urlcontent *)U)->url_data;
 327         else
 328                 return NULL;
 329 }
 330
 331 long LBstr(const char *key, size_t keylen)
 332 {
 333         void *U;
 334
 335         if ((WC->Hdr->urlstrings != NULL) &&
 336             GetHash(WC->Hdr->urlstrings, key, keylen, &U))
 337                 return StrTol(((urlcontent *)U)->url_data);
 338         else
 339                 return (0);
 340 }
 341
 342 int IBstr(const char *key, size_t keylen)
 343 {
 344         void *U;
 345
 346         if ((WC->Hdr->urlstrings != NULL) &&
 347             GetHash(WC->Hdr->urlstrings, key, keylen, &U))
 348                 return StrTol(((urlcontent *)U)->url_data);
 349         else
 350                 return (0);
 351 }
 352
 353 int IBSTR(const char *key)
 354 {
 355         void *U;
 356
 357         if ((WC->Hdr->urlstrings != NULL) &&
 358             GetHash(WC->Hdr->urlstrings, key, strlen(key), &U))
 359                 return StrToi(((urlcontent *)U)->url_data);
 360         else
 361                 return (0);
 362 }
 363
 364 int HaveBstr(const char *key, size_t keylen)
 365 {
 366         void *U;
 367
 368         if ((WC->Hdr->urlstrings != NULL) &&
 369             GetHash(WC->Hdr->urlstrings, key, keylen, &U))
 370                 return (StrLength(((urlcontent *)U)->url_data) != 0);
 371         else
 372                 return (0);
 373 }
 374
 375 int YesBstr(const char *key, size_t keylen)
 376 {
 377         void *U;
 378
 379         if ((WC->Hdr->urlstrings != NULL) &&
 380             GetHash(WC->Hdr->urlstrings, key, keylen, &U))
 381                 return strcmp( ChrPtr(((urlcontent *)U)->url_data), "yes") == 0;
 382         else
 383                 return (0);
 384 }
 385
 386 int YESBSTR(const char *key)
 387 {
 388         void *U;
 389
 390         if ((WC->Hdr->urlstrings != NULL) &&
 391             GetHash(WC->Hdr->urlstrings, key, strlen(key), &U))
 392                 return strcmp( ChrPtr(((urlcontent *)U)->url_data), "yes") == 0;
 393         else
 394                 return (0);
 395 }
 396
 397
 398 /*
 399  * Return a sub array that was separated by a colon:
 400  */
 401 HashList* getSubStruct(const char *key, size_t keylen)
 402 {
 403         void *U;
 404
 405         if ((WC->Hdr->urlstrings != NULL) &&
 406             GetHash(WC->Hdr->urlstrings, key, strlen(key), &U))
 407                 return ((urlcontent *)U)->sub;
 408         else
 409                 return NULL;
 410 }
 411
 412
 413 /*
 414  * Return the value of a variable of a substruct provided by getSubStruct
 415  */
 416 const char *XSubBstr(HashList *sub, const char *key, size_t keylen, size_t *len)
 417 {
 418         void *U;
 419
 420         if ((sub != NULL) &&
 421             GetHash(sub, key, keylen, &U)) {
 422                 *len = StrLength(((urlcontent *)U)->url_data);
 423                 return ChrPtr(((urlcontent *)U)->url_data);
 424         }
 425         else {
 426                 *len = 0;
 427                 return ("");
 428         }
 429 }
 430
 431 const char *SubBstr(HashList *sub, const char *key, size_t keylen)
 432 {
 433         void *U;
 434
 435         if ((sub != NULL) &&
 436             GetHash(sub, key, keylen, &U)) {
 437                 return ChrPtr(((urlcontent *)U)->url_data);
 438         }
 439         else
 440                 return ("");
 441 }
 442
 443 const StrBuf *SSubBstr(HashList *sub, const char *key, size_t keylen)
 444 {
 445         void *U;
 446
 447         if ((sub != NULL) &&
 448             GetHash(sub, key, keylen, &U)) {
 449                 return ((urlcontent *)U)->url_data;
 450         }
 451         else
 452                 return NULL;
 453 }
 454
 455 long LSubBstr(HashList *sub, const char *key, size_t keylen)
 456 {
 457         void *U;
 458
 459         if ((sub != NULL) &&
 460             GetHash(sub, key, keylen, &U)) {
 461                 return StrTol(((urlcontent *)U)->url_data);
 462         }
 463         else
 464                 return (0);
 465 }
 466
 467 int ISubBstr(HashList *sub, const char *key, size_t keylen)
 468 {
 469         void *U;
 470
 471         if ((sub != NULL) &&
 472             GetHash(sub, key, keylen, &U)) {
 473                 return StrTol(((urlcontent *)U)->url_data);
 474         }
 475         else
 476                 return (0);
 477 }
 478
 479 int HaveSubBstr(HashList *sub, const char *key, size_t keylen)
 480 {
 481         void *U;
 482
 483         if ((sub != NULL) &&
 484             GetHash(sub, key, keylen, &U)) {
 485                 return (StrLength(((urlcontent *)U)->url_data) != 0);
 486         }
 487         else
 488                 return (0);
 489 }
 490
 491 int YesSubBstr(HashList *sub, const char *key, size_t keylen)
 492 {
 493         void *U;
 494
 495         if ((sub != NULL) &&
 496             GetHash(sub, key, keylen, &U)) {
 497                 return strcmp( ChrPtr(((urlcontent *)U)->url_data), "yes") == 0;
 498         }
 499         else
 500                 return (0);
 501 }
 502
 503
 504 /*
 505  * This function is called by the MIME parser to handle data uploaded by
 506  * the browser.  Form data, uploaded files, and the data from HTTP PUT
 507  * operations (such as those found in GroupDAV) all arrive this way.
 508  *
 509  * name         Name of the item being uploaded
 510  * filename     Filename of the item being uploaded
 511  * partnum      MIME part identifier (not needed)
 512  * disp         MIME content disposition (not needed)
 513  * content      The actual data
 514  * cbtype       MIME content-type
 515  * cbcharset    Character set
 516  * length       Content length
 517  * encoding     MIME encoding type (not needed)
 518  * cbid         Content ID (not needed)
 519  * userdata     Not used here
 520  */
 521 void upload_handler(char *name, char *filename, char *partnum, char *disp,
 522                         void *content, char *cbtype, char *cbcharset,
 523                         size_t length, char *encoding, char *cbid, void *userdata)
 524 {
 525         wcsession *WCC = WC;
 526         urlcontent *u;
 527         long keylen;
 528
 529 #ifdef DEBUG_URLSTRINGS
 530         syslog(LOG_DEBUG, "upload_handler() name=%s, type=%s, len="SIZE_T_FMT, name, cbtype, length);
 531 #endif
 532         if (WCC->Hdr->urlstrings == NULL)
 533                 WCC->Hdr->urlstrings = NewHash(1, NULL);
 534
 535         /* Form fields */
 536         if ( (length > 0) && (IsEmptyStr(cbtype)) ) {
 537                 u = (urlcontent *) malloc(sizeof(urlcontent));
 538
 539                 keylen = safestrncpy(u->url_key, name, sizeof(u->url_key));
 540                 u->url_data = NewStrBufPlain(content, length);
 541                 u->klen = keylen;
 542                 u->sub = NULL;
 543
 544                 if (strncmp(u->url_key, "__", 2) != 0)
 545                 {
 546                         PutUrlKey(WCC->Hdr->urlstrings, u, (strchr(u->url_key, ':') != NULL));
 547                 }
 548                 else {
 549                         syslog(LOG_INFO, "REJECTED because of __ is internal only: %s = [%d]  %s\n",
 550                                 u->url_key,
 551                                 StrLength(u->url_data),
 552                                 ChrPtr(u->url_data));
 553
 554                         free_url(u);
 555                 }
 556 #ifdef DEBUG_URLSTRINGS
 557                 syslog(LOG_DEBUG, "Key: <%s> len: [%d] Data: <%s>",
 558                         u->url_key,
 559                         StrLength(u->url_data),
 560                         ChrPtr(u->url_data));
 561 #endif
 562         }
 563
 564         /* Uploaded files */
 565         if ( (length > 0) && (!IsEmptyStr(cbtype)) ) {
 566                 WCC->upload = NewStrBufPlain(content, length);
 567                 WCC->upload_length = length;
 568                 WCC->upload_filename = NewStrBufPlain(filename, -1);
 569                 safestrncpy(WCC->upload_content_type, cbtype, sizeof(WC->upload_content_type));
 570 #ifdef DEBUG_URLSTRINGS
 571                 syslog(LOG_DEBUG, "File: <%s> len: [%ld]", filename, (long int)length);
 572 #endif
 573
 574         }
 575
 576 }
 577
 578 void PutBstr(const char *key, long keylen, StrBuf *Value)
 579 {
 580         urlcontent *u;
 581
 582         if(keylen >= sizeof(u->url_key)) {
 583                 syslog(LOG_WARNING, "%s:%d: invalid url_key of size %ld", __FILE__, __LINE__, keylen);
 584                 FreeStrBuf(&Value);
 585                 return;
 586         }
 587         u = (urlcontent*)malloc(sizeof(urlcontent));
 588         memcpy(u->url_key, key, keylen + 1);
 589         u->klen = keylen;
 590         u->url_data = Value;
 591         u->sub = NULL;
 592         Put(WC->Hdr->urlstrings, u->url_key, keylen, u, free_url);
 593 }
 594 void PutlBstr(const char *key, long keylen, long Value)
 595 {
 596         StrBuf *Buf;
 597
 598         Buf = NewStrBufPlain(NULL, sizeof(long) * 16);
 599         StrBufPrintf(Buf, "%ld", Value);
 600         PutBstr(key, keylen, Buf);
 601 }
 602
 603
 604
 605 int ConditionalBstr(StrBuf *Target, WCTemplputParams *TP)
 606 {
 607         if(TP->Tokens->nParameters == 3)
 608                 return HaveBstr(TKEY(2));
 609         else {
 610                 if (IS_NUMBER(TP->Tokens->Params[3]->Type))
 611                 {
 612                         return LBstr(TKEY(2)) ==
 613                                 GetTemplateTokenNumber(Target,
 614                                                        TP,
 615                                                        3,
 616                                                        0);
 617                 }
 618                 else {
 619                         const char *pch;
 620                         long len;
 621
 622                         GetTemplateTokenString (Target, TP, 3, &pch, &len);
 623                         return strcmp(Bstr(TKEY(2)), pch) == 0;
 624                 }
 625         }
 626 }
 627
 628 void tmplput_bstr(StrBuf *Target, WCTemplputParams *TP)
 629 {
 630         const StrBuf *Buf = SBstr(TKEY(0));
 631         if (Buf != NULL)
 632                 StrBufAppendTemplate(Target, TP, Buf, 1);
 633 }
 634
 635
 636 void tmplput_bstrforward(StrBuf *Target, WCTemplputParams *TP)
 637 {
 638         const StrBuf *Buf = SBstr(TKEY(0));
 639         if (Buf != NULL) {
 640                 StrBufAppendBufPlain(Target, HKEY("?"), 0);
 641                 StrBufAppendBufPlain(Target, TKEY(0), 0);
 642                 StrBufAppendBufPlain(Target, HKEY("="), 0);
 643                 StrBufAppendTemplate(Target, TP, Buf, 1);
 644         }
 645 }
 646
 647 void diagnostics(void)
 648 {
 649         output_headers(1, 1, 1, 0, 0, 0);
 650         wc_printf("Session: %d<hr />\n", WC->wc_session);
 651         wc_printf("Command: <br><PRE>\n");
 652 /*
 653 StrEscAppend(WC->WBuf, NULL, WC->UrlFragment1, 0, 0);
 654         wc_printf("<br>\n");
 655 StrEscAppend(WC->WBuf, NULL, WC->UrlFragment12 0, 0);
 656         wc_printf("<br>\n");
 657 StrEscAppend(WC->WBuf, NULL, WC->UrlFragment3, 0, 0);
 658 */
 659         wc_printf("</PRE><hr />\n");
 660         wc_printf("Variables: <br><PRE>\n");
 661         dump_vars();
 662         wc_printf("</PRE><hr />\n");
 663         wDumpContent(1);
 664 }
 665
 666
 667 void tmplput_url_part(StrBuf *Target, WCTemplputParams *TP)
 668 {
 669         StrBuf *Name = NULL;
 670         StrBuf *UrlBuf = NULL;
 671         wcsession *WCC = WC;
 672
 673         if (WCC != NULL) {
 674                 long n;
 675
 676                 n = GetTemplateTokenNumber(Target, TP, 0, 0);
 677                 if (n == 0) {
 678                         if (WCC->Hdr->HR.Handler != NULL)
 679                                 UrlBuf = Name = WCC->Hdr->HR.Handler->Name;
 680                 }
 681                 else if (n == 1) {
 682                         UrlBuf = NewStrBuf();
 683                         StrBufExtract_token(UrlBuf, WCC->Hdr->HR.ReqLine, 0, '/');
 684                 }
 685                 else {
 686                         UrlBuf = NewStrBuf();
 687                         StrBufExtract_token(UrlBuf, WCC->Hdr->HR.ReqLine, 1, '/');
 688                 }
 689
 690                 if (UrlBuf == NULL)  {
 691                         LogTemplateError(Target, "urlbuf", ERR_PARM1, TP, "not set.");
 692                 }
 693                 StrBufAppendTemplate(Target, TP, UrlBuf, 2);
 694                 if (Name == NULL) FreeStrBuf(&UrlBuf);
 695         }
 696 }
 697
 698 typedef struct __BstrPair {
 699         StrBuf *x;
 700         StrBuf *y;
 701 }BstrPair;
 702 CtxType CTX_BSTRPAIRS = CTX_NONE;
 703 void HFreeBstrPair(void *pv)
 704 {
 705         BstrPair *p = (BstrPair*) pv;
 706         FreeStrBuf(&p->x);
 707         FreeStrBuf(&p->y);
 708         free(pv);
 709 }
 710
 711 HashList *iterate_GetBstrPairs(StrBuf *Target, WCTemplputParams *TP)
 712 {
 713         StrBuf *X, *Y;
 714         const char *ch = NULL;
 715         long len;
 716         const StrBuf *TheBStr;
 717         BstrPair *OnePair;
 718         HashList *List;
 719         const char *Pos = NULL;
 720         int i = 0;
 721
 722         if (HaveTemplateTokenString(NULL, TP, 2, &ch, &len))
 723         {
 724                 GetTemplateTokenString(Target, TP, 2, &ch, &len);
 725         }
 726         else
 727         {
 728                 return NULL;
 729         }
 730
 731         TheBStr = SBstr(ch, len);
 732         if ((TheBStr == NULL) || (StrLength(TheBStr) == 0))
 733                 return NULL;
 734         List = NewHash(1, NULL);
 735         while (Pos != StrBufNOTNULL)
 736         {
 737                 X = NewStrBufPlain(NULL, StrLength(TheBStr));
 738                 StrBufExtract_NextToken(X, TheBStr, &Pos, '|');
 739                 if (Pos == StrBufNOTNULL) {
 740                         FreeStrBuf(&X);
 741                         DeleteHash(&List);
 742                         return NULL;
 743                 }
 744                 Y = NewStrBufPlain(NULL, StrLength(TheBStr));
 745                 StrBufExtract_NextToken(Y, TheBStr, &Pos, '|');
 746                 OnePair = (BstrPair*)malloc(sizeof(BstrPair));
 747                 OnePair->x = X;
 748                 OnePair->y = Y;
 749                 Put(List, IKEY(i), OnePair, HFreeBstrPair);
 750                 i++;
 751         }
 752         return List;
 753 }
 754
 755
 756 void tmplput_bstr_pair(StrBuf *Target, WCTemplputParams *TP, int XY)
 757 {
 758         BstrPair *Pair = (BstrPair*) CTX(CTX_BSTRPAIRS);
 759
 760         StrBufAppendTemplate(Target, TP, (XY)?Pair->y:Pair->x, 0);
 761 }
 762
 763 void tmplput_bstr_pair_x(StrBuf *Target, WCTemplputParams *TP)
 764 {       tmplput_bstr_pair(Target, TP, 0); }
 765 void tmplput_bstr_pair_y(StrBuf *Target, WCTemplputParams *TP)
 766 {       tmplput_bstr_pair(Target, TP, 1); }
 767
 768 void
 769 InitModule_PARAMHANDLING
 770 (void)
 771 {
 772         RegisterCTX(CTX_BSTRPAIRS);
 773         WebcitAddUrlHandler(HKEY("diagnostics"), "", 0, diagnostics, NEED_URL);
 774
 775         RegisterIterator("ITERATE:BSTR:PAIR", 1, NULL, iterate_GetBstrPairs, NULL, DeleteHash, CTX_BSTRPAIRS, CTX_NONE, IT_NOFLAG);
 776         RegisterNamespace("BSTR:PAIR:X", 1, 2, tmplput_bstr_pair_x, NULL, CTX_BSTRPAIRS);
 777         RegisterNamespace("BSTR:PAIR:Y", 1, 2, tmplput_bstr_pair_y, NULL, CTX_BSTRPAIRS);
 778
 779         RegisterConditional("COND:BSTR", 1, ConditionalBstr, CTX_NONE);
 780         RegisterNamespace("BSTR", 1, 2, tmplput_bstr, NULL, CTX_NONE);
 781         RegisterNamespace("BSTR:FORWARD", 1, 2, tmplput_bstrforward, NULL, CTX_NONE);
 782         RegisterNamespace("URLPART", 1, 2, tmplput_url_part, NULL, CTX_NONE);
 783 }
 784
 785
 786 void
 787 SessionAttachModule_PARAMHANDLING
 788 (wcsession *sess)
 789 {
 790         sess->Hdr->urlstrings = NewHash(1,NULL);
 791 }
 792
 793 void
 794 SessionDetachModule_PARAMHANDLING
 795 (wcsession *sess)
 796 {
 797         DeleteHash(&sess->Hdr->urlstrings);
 798         FreeStrBuf(&sess->upload_filename);
 799 }