webcit/paramhandling.c

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