src/ptclib/httpform.cxx

   1 /*
   2  * httpform.cxx
   3  *
   4  * Forms using HTTP user interface.
   5  *
   6  * Portable Windows Library
   7  *
   8  * Copyright (c) 1993-2002 Equivalence Pty. Ltd.
   9  *
  10  * The contents of this file are subject to the Mozilla Public License
  11  * Version 1.0 (the "License"); you may not use this file except in
  12  * compliance with the License. You may obtain a copy of the License at
  13  * http://www.mozilla.org/MPL/
  14  *
  15  * Software distributed under the License is distributed on an "AS IS"
  16  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17  * the License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * The Original Code is Portable Windows Library.
  21  *
  22  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23  *
  24  * Contributor(s): ______________________________________.
  25  *
  26  * $Log$
  27  * Revision 1.49  2004/04/24 06:27:56  rjongbloed
  28  * Fixed GCC 3.4.0 warnings about PAssertNULL and improved recoverability on
  29  *   NULL pointer usage in various bits of code.
  30  *
  31  * Revision 1.48  2004/04/03 08:22:20  csoutheren
  32  * Remove pseudo-RTTI and replaced with real RTTI
  33  *
  34  * Revision 1.47  2003/03/24 04:31:03  robertj
  35  * Added function to set and get strings from PConfig in correct format for
  36  *   use with HTTP form array contsructs.
  37  *
  38  * Revision 1.46  2002/11/22 06:20:26  robertj
  39  * Added extra space around data entry fields.
  40  * Added borders around arrays and composite fields.
  41  * Added multi-line data entry for HTTPStringField > 128 characters.
  42  *
  43  * Revision 1.45  2002/11/06 22:47:25  robertj
  44  * Fixed header comment (copyright etc)
  45  *
  46  * Revision 1.44  2002/10/10 04:43:44  robertj
  47  * VxWorks port, thanks Martijn Roest
  48  *
  49  * Revision 1.43  2002/07/17 08:44:58  robertj
  50  * Added links back to page and home page on accepted data html.
  51  * Fixed display of validation error text if page not accepted.
  52  *
  53  * Revision 1.42  2001/10/10 08:07:48  robertj
  54  * Fixed large memory leak of strings when doing POST to a form.
  55  *
  56  * Revision 1.41  2001/05/16 06:03:14  craigs
  57  * Changed to allow access to absolute registry paths from within subforms
  58  *
  59  * Revision 1.40  2001/02/07 04:44:47  robertj
  60  * Added ability to use check box to add/delete fields from arrays.
  61  *
  62  * Revision 1.39  2001/01/08 04:13:23  robertj
  63  * Fixed bug with skipping every second option in determining the selected
  64  *   option in a SELECT field. No longer requires a </option> to work.
  65  *
  66  * Revision 1.38  2000/12/20 02:23:39  robertj
  67  * Fixed variable array size value (caused extra blank entry ever commit).
  68  *
  69  * Revision 1.37  2000/12/18 12:13:08  robertj
  70  * Fixed bug in auto-generated HTML in fixed size arrays, should not have add/delete box.
  71  *
  72  * Revision 1.36  2000/12/18 11:41:01  robertj
  73  * Fixed bug in auto-generated HTML in non-array composite fields
  74  *
  75  * Revision 1.35  2000/12/18 07:14:30  robertj
  76  * Added ability to have fixed length array fields.
  77  * Fixed regular expressions so can have single '-' in field name.
  78  * Fixed use of non-array subforprefix based compsite fields.
  79  *
  80  * Revision 1.34  2000/12/12 07:21:35  robertj
  81  * Added ability to expand fields based on regex into repeated chunks of HTML.
  82  *
  83  * Revision 1.33  2000/11/02 21:55:28  craigs
  84  * Added extra constructor
  85  *
  86  * Revision 1.32  2000/09/05 09:52:24  robertj
  87  * Fixed bug in HTTP form updating SELECT fields from registry.
  88  *
  89  * Revision 1.31  2000/06/19 11:35:01  robertj
  90  * Fixed bug in setting current value of options in select form fields.
  91  *
  92  * Revision 1.30  1999/02/10 13:19:45  robertj
  93  * Fixed PConfig update problem when POSTing to the form. Especiall with arrays.
  94  *
  95  * Revision 1.29  1998/11/30 04:51:57  robertj
  96  * New directory structure
  97  *
  98  * Revision 1.28  1998/11/14 11:11:06  robertj
  99  * PPC GNU compiler compatibility.
 100  *
 101  * Revision 1.27  1998/10/01 09:05:11  robertj
 102  * Fixed bug in nested composite field names, array indexes not being set correctly.
 103  *
 104  * Revision 1.26  1998/09/23 06:22:11  robertj
 105  * Added open source copyright license.
 106  *
 107  * Revision 1.25  1998/08/20 05:51:06  robertj
 108  * Fixed bug where substitutions did not always occur if near end of macro block.
 109  * Improved internationalisation. Allow HTML override of strings in macros.
 110  *
 111  * Revision 1.24  1998/08/09 11:25:51  robertj
 112  * GNU C++ warning removal.
 113  *
 114  * Revision 1.23  1998/08/09 10:35:11  robertj
 115  * Changed array control so can have language override.
 116  *
 117  * Revision 1.22  1998/07/24 06:56:05  robertj
 118  * Fixed case significance problem in HTTP forms.
 119  * Improved detection of VALUE= fields with and without quotes.
 120  *
 121  * Revision 1.21  1998/03/20 03:16:43  robertj
 122  * Fixed bug in beaing able to reset a check box field.
 123  *
 124  * Revision 1.20  1998/02/03 06:26:09  robertj
 125  * Fixed propagation of inital values in arrays subfields.
 126  * Fixed problem where hidden fields were being relaced with default values from PHTTPForm.
 127  *
 128  * Revision 1.19  1998/01/26 02:49:17  robertj
 129  * GNU support.
 130  *
 131  * Revision 1.18  1998/01/26 01:51:37  robertj
 132  * Fixed uninitialised variable.
 133  *
 134  * Revision 1.17  1998/01/26 00:25:25  robertj
 135  * Major rewrite of HTTP forms management.
 136  *
 137  * Revision 1.16  1997/12/18 05:06:51  robertj
 138  * Added missing braces to kill GNU compiler warning.
 139  *
 140  * Revision 1.15  1997/10/10 10:43:43  robertj
 141  * Fixed bug in password encryption, missing string terminator.
 142  *
 143  * Revision 1.14  1997/08/28 12:48:29  robertj
 144  * Changed array fields to allow for reordering.
 145  *
 146  * Revision 1.13  1997/08/21 12:44:10  robertj
 147  * Fixed bug in HTTP form array size field.
 148  * Fixed bug where section list was only replacing first instance of macro.
 149  *
 150  * Revision 1.12  1997/08/09 07:46:52  robertj
 151  * Fixed problems with value of SELECT fields in form
 152  *
 153  * Revision 1.11  1997/08/04 10:41:13  robertj
 154  * Fixed bug in new section list page for names with special characters in them.
 155  *
 156  * Revision 1.10  1997/07/26 11:38:20  robertj
 157  * Support for overridable pages in HTTP service applications.
 158  *
 159  * Revision 1.9  1997/07/14 11:49:51  robertj
 160  * Put "Add" and "Keep" on check boxes in array fields.
 161  *
 162  * Revision 1.8  1997/07/08 13:12:29  robertj
 163  * Major HTTP form enhancements for lists and arrays of fields.
 164  *
 165  * Revision 1.7  1997/06/08 04:47:27  robertj
 166  * Adding new llist based form field.
 167  *
 168  * Revision 1.6  1997/04/12 02:07:26  robertj
 169  * Fixed boolean check boxes being more flexible on string values.
 170  *
 171  * Revision 1.5  1997/04/01 06:00:53  robertj
 172  * Changed PHTTPConfig so if section empty string, does not write PConfig parameters.
 173  *
 174  * Revision 1.4  1996/10/08 13:10:34  robertj
 175  * Fixed bug in boolean (checkbox) html forms, cannot be reset.
 176  *
 177  * Revision 1.3  1996/09/14 13:09:31  robertj
 178  * Major upgrade:
 179  *   rearranged sockets to help support IPX.
 180  *   added indirect channel class and moved all protocols to descend from it,
 181  *   separating the protocol from the low level byte transport.
 182  *
 183  * Revision 1.2  1996/08/08 13:34:10  robertj
 184  * Removed redundent call.
 185  *
 186  * Revision 1.1  1996/06/28 12:56:20  robertj
 187  * Initial revision
 188  *
 189  */
 190
 191 #ifdef __GNUC__
 192 #pragma implementation "httpform.h"
 193 #endif
 194
 195 #include <ptlib.h>
 196 #include <ptclib/httpform.h>
 197 #include <ptclib/cypher.h>
 198
 199
 200 //////////////////////////////////////////////////////////////////////////////
 201 // PHTTPField
 202
 203 PHTTPField::PHTTPField(const char * nam, const char * titl, const char * hlp)
 204   : baseName(nam), fullName(nam),
 205     title(titl != NULL ? titl : nam),
 206     help(hlp != NULL ? hlp : "")
 207 {
 208   notInHTML = TRUE;
 209 }
 210
 211
 212 PObject::Comparison PHTTPField::Compare(const PObject & obj) const
 213 {
 214   PAssert(PIsDescendant(&obj, PHTTPField), PInvalidCast);
 215   return fullName.Compare(((const PHTTPField &)obj).fullName);
 216 }
 217
 218
 219 void PHTTPField::SetName(const PString & newName)
 220 {
 221   fullName = newName;
 222 }
 223
 224
 225 const PHTTPField * PHTTPField::LocateName(const PString & name) const
 226 {
 227   if (fullName == name)
 228     return this;
 229
 230   return NULL;
 231 }
 232
 233
 234 void PHTTPField::SetHelp(const PString & hotLinkURL,
 235                          const PString & linkText)
 236 {
 237   help = "<A HREF=\"" + hotLinkURL + "\">" + linkText + "</A>\r\n";
 238 }
 239
 240
 241 void PHTTPField::SetHelp(const PString & hotLinkURL,
 242                          const PString & imageURL,
 243                          const PString & imageText)
 244 {
 245   help = "<A HREF=\"" + hotLinkURL + "\"><IMG SRC=\"" +
 246              imageURL + "\" ALT=\"" + imageText + "\" ALIGN=absmiddle></A>\r\n";
 247 }
 248
 249
 250 static BOOL FindSpliceBlock(const PRegularExpression & startExpr,
 251                             const PRegularExpression & endExpr,
 252                             const PString & text,
 253                             PINDEX offset,
 254                             PINDEX & pos,
 255                             PINDEX & len,
 256                             PINDEX & start,
 257                             PINDEX & finish)
 258 {
 259   start = finish = P_MAX_INDEX;
 260
 261   if (!text.FindRegEx(startExpr, pos, len, offset))
 262     return FALSE;
 263
 264   PINDEX endpos, endlen;
 265   if (!text.FindRegEx(endExpr, endpos, endlen, pos+len))
 266     return TRUE;
 267
 268   start = pos + len;
 269   finish = endpos - 1;
 270   len = endpos - pos + endlen;
 271   return TRUE;
 272 }
 273
 274
 275 static BOOL FindSpliceBlock(const PRegularExpression & startExpr,
 276                             const PString & text,
 277                             PINDEX offset,
 278                             PINDEX & pos,
 279                             PINDEX & len,
 280                             PINDEX & start,
 281                             PINDEX & finish)
 282 {
 283   static PRegularExpression EndBlock("<?!--#form[ \t\r\n]+end[ \t\r\n]*-->?",
 284                                      PRegularExpression::Extended|PRegularExpression::IgnoreCase);
 285   return FindSpliceBlock(startExpr, EndBlock, text, offset, pos, len, start, finish);
 286 }
 287
 288
 289 static BOOL FindSpliceName(const PCaselessString & text,
 290                            PINDEX start,
 291                            PINDEX finish,
 292                            PINDEX & pos,
 293                            PINDEX & end)
 294 {
 295   if (text[start+1] != '!') {
 296     static PRegularExpression NameExpr("name[ \t\r\n]*=[ \t\r\n]*\"[^\"]*\"",
 297                                        PRegularExpression::Extended|PRegularExpression::IgnoreCase);
 298     if ((pos = text.FindRegEx(NameExpr, start)) == P_MAX_INDEX)
 299       return FALSE;
 300
 301     if (pos >= finish)
 302       return FALSE;
 303
 304     pos = text.Find('"', pos) + 1;
 305     end = text.Find('"', pos) - 1;
 306   }
 307   else {
 308     pos = start + 9;            // Skip over the <!--#form
 309     while (isspace(text[pos]))  // Skip over blanks
 310       pos++;
 311     while (pos < finish && !isspace(text[pos])) // Skip over keyword
 312       pos++;
 313     while (isspace(text[pos]))  // Skip over more blanks
 314       pos++;
 315
 316     end = text.Find("--", pos) - 1;
 317   }
 318
 319   return end < finish;
 320 }
 321
 322
 323 static BOOL FindSpliceFieldName(const PString & text,
 324                             PINDEX offset,
 325                             PINDEX & pos,
 326                             PINDEX & len,
 327                             PString & name)
 328 {
 329   static PRegularExpression FieldName("<?!--#form[ \t\r\n]+[a-z0-9]+[ \t\r\n]+(-?[^-])+-->?"
 330                                       "|"
 331                                       "<[a-z]+[ \t\r\n][^>]*name[ \t\r\n]*=[ \t\r\n]*\"[^\"]*\"[^>]*>",
 332                                       PRegularExpression::Extended|PRegularExpression::IgnoreCase);
 333   if (!text.FindRegEx(FieldName, pos, len, offset))
 334     return FALSE;
 335
 336   PINDEX nameStart, nameEnd;
 337   if (!FindSpliceName(text, pos, pos+len-1, nameStart, nameEnd))
 338     return FALSE;
 339
 340   name = text(nameStart, nameEnd);
 341   pos = nameStart;
 342   len = nameEnd - nameStart + 1;
 343   return TRUE;
 344 }
 345
 346
 347 static void SpliceAdjust(const PString & str,
 348                          PString & text,
 349                          PINDEX pos,
 350                          PINDEX & len,
 351                          PINDEX & finish)
 352 {
 353   text.Splice(str, pos, len);
 354   PINDEX newLen = str.GetLength();
 355   if (finish != P_MAX_INDEX)
 356     finish += newLen - len;
 357   len = newLen;
 358 }
 359
 360
 361 void PHTTPField::ExpandFieldNames(PString & text, PINDEX start, PINDEX & finish) const
 362 {
 363   PString name;
 364   PINDEX pos, len;
 365   while (start < finish && FindSpliceFieldName(text, start, pos, len, name)) {
 366     if (pos > finish)
 367       break;
 368     if (baseName == name)
 369       SpliceAdjust(fullName, text, pos, len, finish);
 370     start = pos + len;
 371   }
 372 }
 373
 374
 375 static BOOL FindInputValue(const PString & text, PINDEX & before, PINDEX & after)
 376 {
 377   static PRegularExpression Value("value[ \t\r\n]*=[ \t\r\n]*(\"[^\"]*\"|[^> \t\r\n]+)",
 378                                   PRegularExpression::Extended|PRegularExpression::IgnoreCase);
 379   PINDEX pos = text.FindRegEx(Value);
 380   if (pos == P_MAX_INDEX)
 381     return FALSE;
 382
 383   before = text.Find('"', pos);
 384   if (before != P_MAX_INDEX)
 385     after = text.Find('"', before+1);
 386   else {
 387     before = text.Find('=', pos);
 388     while (isspace(text[before+1]))
 389       before++;
 390     after = before + 1;
 391     while (text[after] != '\0' && text[after] != '>' && !isspace(text[after]))
 392       after++;
 393   }
 394   return TRUE;
 395 }
 396
 397
 398 PString PHTTPField::GetHTMLInput(const PString & input) const
 399 {
 400   PINDEX before, after;
 401   if (FindInputValue(input, before, after))
 402     return input(0, before) + GetValue(FALSE) + input.Mid(after);
 403
 404   return "<input value=\"" + GetValue(FALSE) + "\"" + input.Mid(6);
 405 }
 406
 407
 408 static void AdjustSelectOptions(PString & text, PINDEX begin, PINDEX end,
 409                                 const PString & myValue, PStringList & validValues,
 410                                 PINDEX & finishAdjust)
 411 {
 412   PINDEX start, finish;
 413   PINDEX pos = begin;
 414   PINDEX len = 0;
 415   static PRegularExpression StartOption("<[ \t\r\n]*option[^>]*>",
 416                                         PRegularExpression::IgnoreCase);
 417   static PRegularExpression EndOption("<[ \t\r\n]*/?option[^>]*>",
 418                                       PRegularExpression::Extended|PRegularExpression::IgnoreCase);
 419   while (FindSpliceBlock(StartOption, EndOption, text, pos+len, pos, len, start, finish) && pos < end) {
 420     if (start == P_MAX_INDEX)
 421       start = text.Find('>', pos)+1;
 422     else {
 423       // Check for if option was not closed by </option> but another <option>
 424       PINDEX optpos = text.FindRegEx(StartOption, start);
 425       if (optpos < pos+len) // Adjust back to before <option> if so.
 426         len = optpos-pos;
 427     }
 428     PCaselessString option = text(pos, start-1);
 429     PINDEX before, after;
 430     if (FindInputValue(option, before, after)) {
 431       start = pos + before + 1;
 432       finish = pos + after - 1;
 433     }
 434     PINDEX selpos = option.Find("selected");
 435     PString thisValue = text(start, finish).Trim();
 436     if (thisValue == myValue) {
 437       if (selpos == P_MAX_INDEX) {
 438         text.Splice(" selected", pos+7, 0);
 439         if (finishAdjust != P_MAX_INDEX)
 440           finishAdjust += 9;
 441         if (end != P_MAX_INDEX)
 442           end += 9;
 443         len += 9;
 444       }
 445     }
 446     else {
 447       if (validValues.GetSize() > 0) {
 448         PINDEX valid;
 449         for (valid = 0; valid < validValues.GetSize(); valid++) {
 450           if (thisValue == validValues[valid])
 451             break;
 452         }
 453         if (valid >= validValues.GetSize()) {
 454           text.Delete(pos, len);
 455           selpos = P_MAX_INDEX;
 456           if (finishAdjust != P_MAX_INDEX)
 457             finishAdjust -= len;
 458           if (end != P_MAX_INDEX)
 459             end -= len;
 460           len = 0;
 461         }
 462       }
 463       if (selpos != P_MAX_INDEX) {
 464         selpos += pos;
 465         PINDEX sellen = 8;
 466         if (text[selpos-1] == ' ') {
 467           selpos--;
 468           sellen++;
 469         }
 470         text.Delete(selpos, sellen);
 471         if (finishAdjust != P_MAX_INDEX)
 472           finishAdjust -= sellen;
 473         if (end != P_MAX_INDEX)
 474           end -= sellen;
 475         len -= sellen;
 476       }
 477     }
 478   }
 479 }
 480
 481 PString PHTTPField::GetHTMLSelect(const PString & selection) const
 482 {
 483   PString text = selection;
 484   PStringList dummy1;
 485   PINDEX dummy2 = P_MAX_INDEX;
 486   AdjustSelectOptions(text, 0, P_MAX_INDEX, GetValue(FALSE), dummy1, dummy2);
 487   return text;
 488 }
 489
 490
 491 void PHTTPField::GetHTMLHeading(PHTML &) const
 492 {
 493 }
 494
 495
 496 static int SplitConfigKey(const PString & fullName,
 497                           PString & section, PString & key)
 498 {
 499   if (fullName.IsEmpty())
 500     return 0;
 501
 502   PINDEX slash = fullName.FindLast('\\');
 503   if (slash == 0 || slash >= fullName.GetLength()-1) {
 504     key = fullName;
 505     return 1;
 506   }
 507
 508   section = fullName.Left(slash);
 509   key = fullName.Mid(slash+1);
 510   if (section.IsEmpty() || key.IsEmpty())
 511     return 0;
 512
 513   return 2;
 514 }
 515
 516
 517 void PHTTPField::LoadFromConfig(PConfig & cfg)
 518 {
 519   PString section, key;
 520   switch (SplitConfigKey(fullName, section, key)) {
 521     case 1 :
 522       SetValue(cfg.GetString(key, GetValue(TRUE)));
 523       break;
 524     case 2 :
 525       SetValue(cfg.GetString(section, key, GetValue(TRUE)));
 526   }
 527 }
 528
 529
 530 void PHTTPField::SaveToConfig(PConfig & cfg) const
 531 {
 532   PString section, key;
 533   switch (SplitConfigKey(fullName, section, key)) {
 534     case 1 :
 535       cfg.SetString(key, GetValue());
 536       break;
 537     case 2 :
 538       cfg.SetString(section, key, GetValue());
 539   }
 540 }
 541
 542
 543 BOOL PHTTPField::Validated(const PString &, PStringStream &) const
 544 {
 545   return TRUE;
 546 }
 547
 548
 549 void PHTTPField::GetAllNames(PStringList & list) const
 550 {
 551   list.AppendString(fullName);
 552 }
 553
 554
 555 void PHTTPField::SetAllValues(const PStringToString & data)
 556 {
 557   if (!baseName && data.Contains(fullName))
 558     SetValue(data[fullName]);
 559 }
 560
 561
 562 BOOL PHTTPField::ValidateAll(const PStringToString & data, PStringStream & msg) const
 563 {
 564   if (data.Contains(fullName))
 565     return Validated(data[fullName], msg);
 566   return TRUE;
 567 }
 568
 569
 570 //////////////////////////////////////////////////////////////////////////////
 571 // PHTTPCompositeField
 572
 573 PHTTPCompositeField::PHTTPCompositeField(const char * nam,
 574                                          const char * titl,
 575                                          const char * hlp)
 576   : PHTTPField(nam, titl, hlp)
 577 {
 578 }
 579
 580
 581 void PHTTPCompositeField::SetName(const PString & newName)
 582 {
 583   if (fullName.IsEmpty() || newName.IsEmpty())
 584     return;
 585
 586   for (PINDEX i = 0; i < fields.GetSize(); i++) {
 587     PHTTPField & field = fields[i];
 588
 589     PString firstPartOfName = psprintf(fullName, i+1);
 590     PString subFieldName;
 591     if (field.GetName().Find(firstPartOfName) == 0)
 592       subFieldName = field.GetName().Mid(firstPartOfName.GetLength());
 593     else
 594       subFieldName = field.GetName();
 595
 596     firstPartOfName = psprintf(newName, i+1);
 597     if (subFieldName[0] == '\\' || firstPartOfName[firstPartOfName.GetLength()-1] == '\\')
 598       field.SetName(firstPartOfName + subFieldName);
 599     else
 600       field.SetName(firstPartOfName & subFieldName);
 601   }
 602
 603   PHTTPField::SetName(newName);
 604 }
 605
 606
 607 const PHTTPField * PHTTPCompositeField::LocateName(const PString & name) const
 608 {
 609   if (fullName == name)
 610     return this;
 611
 612   for (PINDEX i = 0; i < fields.GetSize(); i++) {
 613     const PHTTPField * field = fields[i].LocateName(name);
 614     if (field != NULL)
 615       return field;
 616   }
 617
 618   return NULL;
 619 }
 620
 621
 622 PHTTPField * PHTTPCompositeField::NewField() const
 623 {
 624   PHTTPCompositeField * fld = new PHTTPCompositeField(baseName, title, help);
 625   for (PINDEX i = 0; i < fields.GetSize(); i++)
 626     fld->Append(fields[i].NewField());
 627   return fld;
 628 }
 629
 630
 631 void PHTTPCompositeField::GetHTMLTag(PHTML & html) const
 632 {
 633   for (PINDEX i = 0; i < fields.GetSize(); i++) {
 634     if (i != 0 && html.Is(PHTML::InTable))
 635       html << PHTML::TableData("NOWRAP ALIGN=CENTER");
 636     fields[i].GetHTMLTag(html);
 637   }
 638 }
 639
 640
 641 PString PHTTPCompositeField::GetHTMLInput(const PString & input) const
 642 {
 643   return input;
 644 }
 645
 646
 647 void PHTTPCompositeField::ExpandFieldNames(PString & text, PINDEX start, PINDEX & finish) const
 648 {
 649   static PRegularExpression FieldName( "!--#form[ \t\r\n]+(-?[^-])+[ \t\r\n]+(-?[^-])+--"
 650                                        "|"
 651                                        "<[a-z]*[ \t\r\n][^>]*name[ \t\r\n]*=[ \t\r\n]*\"[^\"]*\"[^>]*>",
 652                                        PRegularExpression::IgnoreCase);
 653
 654   PString name;
 655   PINDEX pos, len;
 656   while (start < finish && FindSpliceFieldName(text, start, pos, len, name)) {
 657     if (pos > finish)
 658       break;
 659     for (PINDEX fld = 0; fld < fields.GetSize(); fld++) {
 660       if (fields[fld].GetBaseName() *= name) {
 661         SpliceAdjust(fields[fld].GetName(), text, pos, len, finish);
 662         break;
 663       }
 664     }
 665     start = pos + len;
 666   }
 667 }
 668
 669
 670 void PHTTPCompositeField::GetHTMLHeading(PHTML & html) const
 671 {
 672   html << PHTML::TableRow();
 673   for (PINDEX i = 0; i < fields.GetSize(); i++)
 674     html << PHTML::TableHeader() << fields[i].GetTitle();
 675 }
 676
 677
 678 PString PHTTPCompositeField::GetValue(BOOL dflt) const
 679 {
 680   PStringStream value;
 681   for (PINDEX i = 0; i < fields.GetSize(); i++)
 682     value << fields[i].GetValue(dflt) << '\n';
 683   return value;
 684 }
 685
 686
 687 void PHTTPCompositeField::SetValue(const PString &)
 688 {
 689   PAssertAlways(PLogicError);
 690 }
 691
 692
 693 void PHTTPCompositeField::LoadFromConfig(PConfig & cfg)
 694 {
 695   SetName(fullName);
 696   for (PINDEX i = 0; i < GetSize(); i++)
 697     fields[i].LoadFromConfig(cfg);
 698 }
 699
 700
 701 void PHTTPCompositeField::SaveToConfig(PConfig & cfg) const
 702 {
 703   for (PINDEX i = 0; i < GetSize(); i++)
 704     fields[i].SaveToConfig(cfg);
 705 }
 706
 707
 708 void PHTTPCompositeField::GetAllNames(PStringList & list) const
 709 {
 710   for (PINDEX i = 0; i < GetSize(); i++)
 711     fields[i].GetAllNames(list);
 712 }
 713
 714
 715 void PHTTPCompositeField::SetAllValues(const PStringToString & data)
 716 {
 717   for (PINDEX i = 0; i < fields.GetSize(); i++)
 718     fields[i].SetAllValues(data);
 719 }
 720
 721
 722 BOOL PHTTPCompositeField::ValidateAll(const PStringToString & data,
 723                                       PStringStream & msg) const
 724 {
 725   for (PINDEX i = 0; i < fields.GetSize(); i++)
 726     if (!fields[i].ValidateAll(data, msg))
 727       return FALSE;
 728
 729   return TRUE;
 730 }
 731
 732
 733 PINDEX PHTTPCompositeField::GetSize() const
 734 {
 735   return fields.GetSize();
 736 }
 737
 738
 739 void PHTTPCompositeField::Append(PHTTPField * fld)
 740 {
 741   fields.Append(fld);
 742 }
 743
 744
 745 //////////////////////////////////////////////////////////////////////////////
 746 // PHTTPSubForm
 747
 748 PHTTPSubForm::PHTTPSubForm(const PString & subForm,
 749                            const char * name,
 750                            const char * title,
 751                            PINDEX prim,
 752                            PINDEX sec)
 753   : PHTTPCompositeField(name, title, NULL),
 754     subFormName(subForm)
 755 {
 756   primary = prim;
 757   secondary = sec;
 758 }
 759
 760
 761 PHTTPField * PHTTPSubForm::NewField() const
 762 {
 763   PHTTPCompositeField * fld = new PHTTPSubForm(subFormName, baseName, title, primary, secondary);
 764   for (PINDEX i = 0; i < fields.GetSize(); i++)
 765     fld->Append(fields[i].NewField());
 766   return fld;
 767 }
 768
 769
 770 void PHTTPSubForm::GetHTMLTag(PHTML & html) const
 771 {
 772   PString value = fields[primary].GetValue();
 773   if (value.IsEmpty())
 774     value = "New";
 775   html << PHTML::HotLink(subFormName +
 776             "?subformprefix=" + PURL::TranslateString(fullName, PURL::QueryTranslation))
 777        << value << PHTML::HotLink();
 778
 779   if (secondary != P_MAX_INDEX)
 780     html << PHTML::TableData("NOWRAP") << fields[secondary].GetValue();
 781 }
 782
 783
 784 void PHTTPSubForm::GetHTMLHeading(PHTML &) const
 785 {
 786 }
 787
 788
 789 //////////////////////////////////////////////////////////////////////////////
 790 // PHTTPFieldArray
 791
 792 PHTTPFieldArray::PHTTPFieldArray(PHTTPField * fld, BOOL ordered, PINDEX fixedSize)
 793   : PHTTPCompositeField(fld->GetName(), fld->GetTitle(), fld->GetHelp()),
 794     baseField(fld)
 795 {
 796   orderedArray = ordered;
 797   canAddElements = fixedSize == 0;
 798   SetSize(fixedSize);
 799 }
 800
 801
 802 PHTTPFieldArray::~PHTTPFieldArray()
 803 {
 804   delete baseField;
 805 }
 806
 807
 808 void PHTTPFieldArray::SetSize(PINDEX newSize)
 809 {
 810   while (fields.GetSize() > newSize)
 811     fields.RemoveAt(fields.GetSize()-1);
 812   while (fields.GetSize() < newSize)
 813     AddBlankField();
 814   if (canAddElements)
 815     AddBlankField();
 816 }
 817
 818
 819 PHTTPField * PHTTPFieldArray::NewField() const
 820 {
 821   return new PHTTPFieldArray(baseField->NewField(), orderedArray);
 822 }
 823
 824
 825 static const char ArrayControlBox[] = " Array Control";
 826 static const char ArrayControlKeep[] = "Keep";
 827 static const char ArrayControlRemove[] = "Remove";
 828 static const char ArrayControlMoveUp[] = "Move Up";
 829 static const char ArrayControlMoveDown[] = "Move Down";
 830 static const char ArrayControlToTop[] = "To Top";
 831 static const char ArrayControlToBottom[] = "To Bottom";
 832 static const char ArrayControlIgnore[] = "Ignore";
 833 static const char ArrayControlAddTop[] = "Add Top";
 834 static const char ArrayControlAddBottom[] = "Add Bottom";
 835 static const char ArrayControlAdd[] = "Add";
 836
 837 static PStringList GetArrayControlOptions(PINDEX fld, PINDEX size, BOOL orderedArray)
 838 {
 839   PStringList options;
 840
 841   if (fld >= size) {
 842     options.AppendString(ArrayControlIgnore);
 843     if (size == 0 || !orderedArray)
 844       options.AppendString(ArrayControlAdd);
 845     else {
 846       options.AppendString(ArrayControlAddTop);
 847       options.AppendString(ArrayControlAddBottom);
 848     }
 849   }
 850   else {
 851     options.AppendString(ArrayControlKeep);
 852     options.AppendString(ArrayControlRemove);
 853     if (orderedArray) {
 854       if (fld > 0)
 855         options.AppendString(ArrayControlMoveUp);
 856       if (fld < size-1)
 857         options.AppendString(ArrayControlMoveDown);
 858       if (fld > 0)
 859         options.AppendString(ArrayControlToTop);
 860       if (fld < size-1)
 861         options.AppendString(ArrayControlToBottom);
 862     }
 863   }
 864
 865   return options;
 866 }
 867
 868 void PHTTPFieldArray::AddArrayControlBox(PHTML & html, PINDEX fld) const
 869 {
 870   PStringList options = GetArrayControlOptions(fld, fields.GetSize()-1, orderedArray);
 871   html << PHTML::Select(fields[fld].GetName() + ArrayControlBox);
 872   for (PINDEX i = 0; i < options.GetSize(); i++)
 873     html << PHTML::Option(i == 0 ? PHTML::Selected : PHTML::NotSelected) << options[i];
 874   html << PHTML::Select();
 875 }
 876
 877
 878 void PHTTPFieldArray::GetHTMLTag(PHTML & html) const
 879 {
 880   html << PHTML::TableStart("border=1 cellspacing=0 cellpadding=8");
 881   baseField->GetHTMLHeading(html);
 882   for (PINDEX i = 0; i < fields.GetSize(); i++) {
 883     html << PHTML::TableRow() << PHTML::TableData("NOWRAP");
 884     fields[i].GetHTMLTag(html);
 885     html << PHTML::TableData("NOWRAP");
 886     if (canAddElements)
 887       AddArrayControlBox(html, i);
 888   }
 889   html << PHTML::TableEnd();
 890 }
 891
 892
 893 void PHTTPFieldArray::ExpandFieldNames(PString & text, PINDEX start, PINDEX & finish) const
 894 {
 895   PString original = text(start, finish);
 896   PINDEX origFinish = finish;
 897   PINDEX finalFinish = finish;
 898
 899   PINDEX fld = fields.GetSize();
 900   while (fld > 0) {
 901     fields[--fld].ExpandFieldNames(text, start, finish);
 902
 903     PINDEX pos,len;
 904     static PRegularExpression RowNum("<?!--#form[ \t\r\n]+rownum[ \t\r\n]*-->?",
 905                                      PRegularExpression::Extended|PRegularExpression::IgnoreCase);
 906     while (text.FindRegEx(RowNum, pos, len, start, finish))
 907       SpliceAdjust(psprintf("%u", fld+1), text, pos, len, finish);
 908
 909     static PRegularExpression SubForm("<?!--#form[ \t\r\n]+subform[ \t\r\n]*-->?",
 910                                       PRegularExpression::Extended|PRegularExpression::IgnoreCase);
 911     while (text.FindRegEx(SubForm, pos, len, start, finish)) {
 912       PString fmt = fullName;
 913       if (fmt.Find("%u") == P_MAX_INDEX)
 914         fmt += " %u";
 915       SpliceAdjust("subformprefix=" + PURL::TranslateString(psprintf(fmt, fld+1), PURL::QueryTranslation),
 916                    text, pos, len, finish);
 917     }
 918
 919     static PRegularExpression RowControl("<?!--#form[ \t\r\n]+rowcontrol[ \t\r\n]*-->?",
 920                                          PRegularExpression::Extended|PRegularExpression::IgnoreCase);
 921     while (text.FindRegEx(RowControl, pos, len, start, finish)) {
 922       PHTML html(PHTML::InForm);
 923       if (canAddElements)
 924         AddArrayControlBox(html, fld);
 925       SpliceAdjust(html, text, pos, len, finish);
 926     }
 927
 928     static PRegularExpression RowCheck("<?!--#form[ \t\r\n]+row(add|delete)[ \t\r\n]*(-?[^-])*-->?",
 929                                          PRegularExpression::Extended|PRegularExpression::IgnoreCase);
 930     while (text.FindRegEx(RowCheck, pos, len, start, finish)) {
 931       PStringStream checkbox;
 932       if (canAddElements) {
 933         PINDEX titlepos = text.Find("row", start)+3;
 934         BOOL adding = text[titlepos] == 'a';
 935         if (( adding && fld >= fields.GetSize()-1) ||
 936             (!adding && fld <  fields.GetSize()-1)) {
 937           titlepos += adding ? 3 : 6;
 938           PINDEX dashes = text.Find("--", titlepos);
 939           PString title = text(titlepos, dashes-1).Trim();
 940           if (title.IsEmpty() && adding)
 941             title = "Add";
 942           checkbox << title
 943                    << "<INPUT TYPE=checkbox NAME=\""
 944                    << fields[fld].GetName()
 945                    << ArrayControlBox
 946                    << "\" VALUE="
 947                    << (adding ? ArrayControlAdd : ArrayControlRemove)
 948                    << '>';
 949         }
 950       }
 951       SpliceAdjust(checkbox, text, pos, len, finish);
 952     }
 953
 954     static PRegularExpression SelectRow("<select[ \t\r\n][^>]*name[ \t\r\n]*=[ \t\r\n]*\"!--#form[ \t\r\n]+rowselect[ \t\r\n]*--\"[^>]*>",
 955                                         PRegularExpression::Extended|PRegularExpression::IgnoreCase);
 956     static PRegularExpression SelEndRegEx("</select[^>]*>",
 957                                           PRegularExpression::Extended|PRegularExpression::IgnoreCase);
 958     PINDEX begin, end;
 959     while (FindSpliceBlock(SelectRow, SelEndRegEx, text, 0, pos, len, begin, end)) {
 960       PStringList options = GetArrayControlOptions(fld, fields.GetSize()-1, orderedArray);
 961       AdjustSelectOptions(text, begin, end, options[0], options, finish);
 962       static PRegularExpression RowSelect("!--#form[ \t\r\n]+rowselect[ \t\r\n]*--",
 963                                           PRegularExpression::Extended|PRegularExpression::IgnoreCase);
 964       if (text.FindRegEx(RowSelect, pos, len, pos, begin))
 965         SpliceAdjust(fields[fld].GetName() + ArrayControlBox, text, pos, len, finish);
 966     }
 967
 968     finalFinish += finish - origFinish;
 969
 970     if (fld > 0) {
 971       text.Splice(original, start, 0);
 972       finish = origFinish;
 973       finalFinish += finish - start;
 974     }
 975   }
 976
 977   finish = finalFinish;
 978 }
 979
 980
 981 static int SplitArraySizeKey(const PString & fullName,
 982                              PString & section, PString & key)
 983 {
 984   static const char ArraySize[] = "Array Size";
 985   PINDEX pos = fullName.Find("%u");
 986   if (pos == P_MAX_INDEX)
 987     return SplitConfigKey(fullName & ArraySize, section, key);
 988
 989   PINDEX endPos = fullName.GetLength() - 1;
 990   if (fullName[endPos] == '\\')
 991     endPos--;
 992   return SplitConfigKey(fullName.Left(pos) & ArraySize & fullName(pos+2, endPos), section, key);
 993 }
 994
 995
 996 void PHTTPFieldArray::LoadFromConfig(PConfig & cfg)
 997 {
 998   if (canAddElements) {
 999     PString section, key;
1000     switch (SplitArraySizeKey(fullName, section, key)) {
1001       case 1 :
1002         SetSize(cfg.GetInteger(key, GetSize()));
1003         break;
1004       case 2 :
1005         SetSize(cfg.GetInteger(section, key, GetSize()));
1006     }
1007   }
1008   PHTTPCompositeField::LoadFromConfig(cfg);
1009 }
1010
1011
1012 void PHTTPFieldArray::SaveToConfig(PConfig & cfg) const
1013 {
1014   if (canAddElements) {
1015     PString section, key;
1016     switch (SplitArraySizeKey(fullName, section, key)) {
1017       case 1 :
1018         cfg.SetInteger(key, GetSize());
1019         break;
1020       case 2 :
1021         cfg.SetInteger(section, key, GetSize());
1022     }
1023   }
1024   PHTTPCompositeField::SaveToConfig(cfg);
1025 }
1026
1027
1028 void PHTTPFieldArray::SetArrayFieldName(PINDEX idx) const
1029 {
1030   PString fmt = fullName;
1031   if (fmt.Find("%u") == P_MAX_INDEX)
1032     fmt += " %u";
1033   fields[idx].SetName(psprintf(fmt, idx+1));
1034 }
1035
1036
1037 void PHTTPFieldArray::SetAllValues(const PStringToString & data)
1038 {
1039   PHTTPFieldList newFields;
1040   newFields.DisallowDeleteObjects();
1041   PINDEX i;
1042   for (i = 0; i < fields.GetSize(); i++)
1043     newFields.Append(fields.GetAt(i));
1044
1045   BOOL lastFieldIsSet = FALSE;
1046   PINDEX size = fields.GetSize();
1047   for (i = 0; i < size; i++) {
1048     PHTTPField * fieldPtr = &fields[i];
1049     PINDEX pos = newFields.GetObjectsIndex(fieldPtr);
1050     fieldPtr->SetAllValues(data);
1051
1052     PString control = data(fieldPtr->GetName() + ArrayControlBox);
1053     if (control == ArrayControlMoveUp) {
1054       if (pos > 0) {
1055         newFields.SetAt(pos, newFields.GetAt(pos-1));
1056         newFields.SetAt(pos-1, fieldPtr);
1057       }
1058     }
1059     else if (control == ArrayControlMoveDown) {
1060       if (size > 2 && pos < size-2) {
1061         newFields.SetAt(pos, newFields.GetAt(pos+1));
1062         newFields.SetAt(pos+1, fieldPtr);
1063       }
1064     }
1065     else if (control == ArrayControlToTop) {
1066       newFields.RemoveAt(pos);
1067       newFields.InsertAt(0, fieldPtr);
1068     }
1069     else if (control == ArrayControlToBottom) {
1070       newFields.RemoveAt(pos);
1071       newFields.Append(fieldPtr);
1072     }
1073     else if (control == ArrayControlAddTop) {
1074       if (i == size-1) {
1075         newFields.RemoveAt(pos);
1076         newFields.InsertAt(0, fieldPtr);
1077         lastFieldIsSet = TRUE;
1078       }
1079     }
1080     else if (control == ArrayControlAddBottom || control == ArrayControlAdd) {
1081       if (i == size-1) {
1082         newFields.RemoveAt(pos);
1083         newFields.Append(fieldPtr);
1084         lastFieldIsSet = TRUE;
1085       }
1086     }
1087     else if (control == ArrayControlIgnore) {
1088       newFields.RemoveAt(pos);
1089       newFields.Append(fieldPtr);
1090     }
1091     else if (control == ArrayControlRemove)
1092       newFields.RemoveAt(pos);
1093   }
1094
1095   fields.DisallowDeleteObjects();
1096   for (i = 0; i < newFields.GetSize(); i++)
1097     fields.Remove(newFields.GetAt(i));
1098   fields.AllowDeleteObjects();
1099   fields.RemoveAll();
1100
1101   for (i = 0; i < newFields.GetSize(); i++) {
1102     fields.Append(newFields.GetAt(i));
1103     SetArrayFieldName(i);
1104   }
1105
1106   if (lastFieldIsSet && canAddElements)
1107     AddBlankField();
1108 }
1109
1110
1111 PINDEX PHTTPFieldArray::GetSize() const
1112 {
1113   PINDEX size = fields.GetSize();
1114   PAssert(size > 0, PLogicError);
1115   if (canAddElements)
1116     size--;
1117   return size;
1118 }
1119
1120
1121 void PHTTPFieldArray::AddBlankField()
1122 {
1123   fields.Append(baseField->NewField());
1124   SetArrayFieldName(fields.GetSize()-1);
1125 }
1126
1127
1128 PStringArray PHTTPFieldArray::GetStrings(PConfig & cfg)
1129 {
1130   LoadFromConfig(cfg);
1131
1132   PStringArray values(GetSize());
1133
1134   for (PINDEX i = 0; i < GetSize(); i++)
1135     values[i] = fields[i].GetValue(FALSE);
1136
1137   return values;
1138 }
1139
1140
1141 void PHTTPFieldArray::SetStrings(PConfig & cfg, const PStringArray & values)
1142 {
1143   SetSize(values.GetSize());
1144   for (PINDEX i = 0; i < values.GetSize(); i++)
1145     fields[i].SetValue(values[i]);
1146
1147   SaveToConfig(cfg);
1148 }
1149
1150
1151 //////////////////////////////////////////////////////////////////////////////
1152 // PHTTPStringField
1153
1154 PHTTPStringField::PHTTPStringField(const char * name,
1155                                    PINDEX siz,
1156                                    const char * initVal,
1157                                    const char * help)
1158   : PHTTPField(name, NULL, help),
1159     value(initVal != NULL ? initVal : ""),
1160     initialValue(value)
1161 {
1162   size = siz;
1163 }
1164
1165
1166 PHTTPStringField::PHTTPStringField(const char * name,
1167                                    const char * title,
1168                                    PINDEX siz,
1169                                    const char * initVal,
1170                                    const char * help)
1171   : PHTTPField(name, title, help),
1172     value(initVal != NULL ? initVal : ""),
1173     initialValue(value)
1174 {
1175   size = siz;
1176 }
1177
1178
1179 PHTTPField * PHTTPStringField::NewField() const
1180 {
1181   return new PHTTPStringField(baseName, title, size, initialValue, help);
1182 }
1183
1184
1185 void PHTTPStringField::GetHTMLTag(PHTML & html) const
1186 {
1187   if (size < 128)
1188     html << PHTML::InputText(fullName, size, value);
1189   else
1190     html << PHTML::TextArea(fullName, (size+79)/80, 80) << value << PHTML::TextArea(fullName);
1191 }
1192
1193
1194 void PHTTPStringField::SetValue(const PString & newVal)
1195 {
1196   value = newVal;
1197 }
1198
1199
1200 PString PHTTPStringField::GetValue(BOOL dflt) const
1201 {
1202   if (dflt)
1203     return initialValue;
1204   else
1205     return value;
1206 }
1207
1208
1209 //////////////////////////////////////////////////////////////////////////////
1210 // PHTTPPasswordField
1211
1212 PHTTPPasswordField::PHTTPPasswordField(const char * name,
1213                                        PINDEX siz,
1214                                        const char * initVal,
1215                                        const char * help)
1216   : PHTTPStringField(name, siz, initVal, help)
1217 {
1218 }
1219
1220
1221 PHTTPPasswordField::PHTTPPasswordField(const char * name,
1222                                        const char * title,
1223                                        PINDEX siz,
1224                                        const char * initVal,
1225                                        const char * help)
1226   : PHTTPStringField(name, title, siz, initVal, help)
1227 {
1228 }
1229
1230
1231 PHTTPField * PHTTPPasswordField::NewField() const
1232 {
1233   return new PHTTPPasswordField(baseName, title, size, initialValue, help);
1234 }
1235
1236
1237 void PHTTPPasswordField::GetHTMLTag(PHTML & html) const
1238 {
1239   html << PHTML::InputPassword(fullName, size, value);
1240 }
1241
1242
1243 static const PTEACypher::Key PasswordKey = {
1244   {
1245     103,  60, 222,  17, 128, 157,  31, 137,
1246     133,  64,  82, 148,  94, 136,   4, 209
1247   }
1248 };
1249
1250 void PHTTPPasswordField::SetValue(const PString & newVal)
1251 {
1252   value = Decrypt(newVal);
1253 }
1254
1255
1256 PString PHTTPPasswordField::GetValue(BOOL dflt) const
1257 {
1258   if (dflt)
1259     return initialValue;
1260
1261   PTEACypher crypt(PasswordKey);
1262   return crypt.Encode(value);
1263 }
1264
1265
1266 PString PHTTPPasswordField::Decrypt(const PString & pword)
1267 {
1268   PString clear;
1269   PTEACypher crypt(PasswordKey);
1270   return crypt.Decode(pword, clear) ? clear : pword;
1271 }
1272
1273
1274 //////////////////////////////////////////////////////////////////////////////
1275 // PHTTPIntegerField
1276
1277 PHTTPIntegerField::PHTTPIntegerField(const char * nam,
1278                                      int lo, int hig,
1279                                      int initVal,
1280                                      const char * unit,
1281                                      const char * help)
1282   : PHTTPField(nam, NULL, help), units(unit != NULL ? unit : "")
1283 {
1284   low = lo;
1285   high = hig;
1286   value = initialValue = initVal;
1287 }
1288
1289 PHTTPIntegerField::PHTTPIntegerField(const char * nam,
1290                                      const char * titl,
1291                                      int lo, int hig,
1292                                      int initVal,
1293                                      const char * unit,
1294                                      const char * help)
1295   : PHTTPField(nam, titl, help), units(unit != NULL ? unit : "")
1296 {
1297   low = lo;
1298   high = hig;
1299   value = initialValue = initVal;
1300 }
1301
1302
1303 PHTTPField * PHTTPIntegerField::NewField() const
1304 {
1305   return new PHTTPIntegerField(baseName, title, low, high, initialValue, units, help);
1306 }
1307
1308
1309 void PHTTPIntegerField::GetHTMLTag(PHTML & html) const
1310 {
1311   html << PHTML::InputRange(fullName, low, high, value) << "  " << units;
1312 }
1313
1314
1315 void PHTTPIntegerField::SetValue(const PString & newVal)
1316 {
1317   value = newVal.AsInteger();
1318 }
1319
1320
1321 PString PHTTPIntegerField::GetValue(BOOL dflt) const
1322 {
1323   return PString(PString::Signed, dflt ? initialValue : value);
1324 }
1325
1326
1327 void PHTTPIntegerField::LoadFromConfig(PConfig & cfg)
1328 {
1329   PString section, key;
1330   switch (SplitConfigKey(fullName, section, key)) {
1331     case 1 :
1332       value = cfg.GetInteger(key, initialValue);
1333       break;
1334     case 2 :
1335       value = cfg.GetInteger(section, key, initialValue);
1336   }
1337 }
1338
1339
1340 void PHTTPIntegerField::SaveToConfig(PConfig & cfg) const
1341 {
1342   PString section, key;
1343   switch (SplitConfigKey(fullName, section, key)) {
1344     case 1 :
1345       cfg.SetInteger(key, value);
1346       break;
1347     case 2 :
1348       cfg.SetInteger(section, key, value);
1349   }
1350 }
1351
1352
1353 BOOL PHTTPIntegerField::Validated(const PString & newVal, PStringStream & msg) const
1354 {
1355   int val = newVal.AsInteger();
1356   if (val >= low && val <= high)
1357     return TRUE;
1358
1359   msg << "The field \"" << GetName() << "\" should be between "
1360       << low << " and " << high << ".<BR>";
1361   return FALSE;
1362 }
1363
1364
1365 //////////////////////////////////////////////////////////////////////////////
1366 // PHTTPBooleanField
1367
1368 PHTTPBooleanField::PHTTPBooleanField(const char * name,
1369                                      BOOL initVal,
1370                                    const char * help)
1371   : PHTTPField(name, NULL, help)
1372 {
1373   value = initialValue = initVal;
1374 }
1375
1376
1377 PHTTPBooleanField::PHTTPBooleanField(const char * name,
1378                                      const char * title,
1379                                      BOOL initVal,
1380                                      const char * help)
1381   : PHTTPField(name, title, help)
1382 {
1383   value = initialValue = initVal;
1384 }
1385
1386
1387 PHTTPField * PHTTPBooleanField::NewField() const
1388 {
1389   return new PHTTPBooleanField(baseName, title, initialValue, help);
1390 }
1391
1392
1393 void PHTTPBooleanField::GetHTMLTag(PHTML & html) const
1394 {
1395   html << PHTML::HiddenField(fullName, "FALSE")
1396        << PHTML::CheckBox(fullName, value ? PHTML::Checked : PHTML::UnChecked);
1397 }
1398
1399
1400 static void SpliceChecked(PString & text, BOOL value)
1401 {
1402   PINDEX pos = text.Find("checked");
1403   if (value) {
1404     if (pos == P_MAX_INDEX)
1405       text.Splice(" checked", 6, 0);
1406   }
1407   else {
1408     if (pos != P_MAX_INDEX) {
1409       PINDEX len = 7;
1410       if (text[pos-1] == ' ') {
1411         pos--;
1412         len++;
1413       }
1414       text.Delete(pos, len);
1415     }
1416   }
1417 }
1418
1419
1420 PString PHTTPBooleanField::GetHTMLInput(const PString & input) const
1421 {
1422   static PRegularExpression checkboxRegEx("type[ \t\r\n]*=[ \t\r\n]*\"?checkbox\"?",
1423                                           PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1424   if (input.FindRegEx(checkboxRegEx) != P_MAX_INDEX) {
1425     PCaselessString text;
1426     PINDEX before, after;
1427     if (FindInputValue(input, before, after))
1428       text = input(0, before) + "TRUE" + input.Mid(after);
1429     else
1430       text = "<input value=\"TRUE\"" + input.Mid(6);
1431     SpliceChecked(text, value);
1432     return "<input type=hidden name=\"" + fullName + "\">" + text;
1433   }
1434
1435   static PRegularExpression radioRegEx("type[ \t\r\n]*=[ \t\r\n]*\"?radio\"?",
1436                                        PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1437   if (input.FindRegEx(radioRegEx) != P_MAX_INDEX) {
1438     PINDEX before, after;
1439     if (FindInputValue(input, before, after)) {
1440       PCaselessString text = input;
1441       PString val = input(before+1, after-1);
1442       SpliceChecked(text, (value && (val *= "TRUE")) || (!value && (val *= "FALSE")));
1443       return text;
1444     }
1445     return input;
1446   }
1447
1448   return PHTTPField::GetHTMLInput(input);
1449 }
1450
1451
1452 void PHTTPBooleanField::SetValue(const PString & val)
1453 {
1454   value = toupper(val[0]) == 'T' || toupper(val[0]) == 'y' ||
1455           val.AsInteger() != 0 || val.Find("TRUE") != P_MAX_INDEX;
1456 }
1457
1458
1459 PString PHTTPBooleanField::GetValue(BOOL dflt) const
1460 {
1461   return ((dflt ? initialValue : value) ? "True" : "False");
1462 }
1463
1464
1465 void PHTTPBooleanField::LoadFromConfig(PConfig & cfg)
1466 {
1467   PString section, key;
1468   switch (SplitConfigKey(fullName, section, key)) {
1469     case 1 :
1470       value = cfg.GetBoolean(key, initialValue);
1471       break;
1472     case 2 :
1473       value = cfg.GetBoolean(section, key, initialValue);
1474   }
1475 }
1476
1477
1478 void PHTTPBooleanField::SaveToConfig(PConfig & cfg) const
1479 {
1480   PString section, key;
1481   switch (SplitConfigKey(fullName, section, key)) {
1482     case 1 :
1483       cfg.SetBoolean(key, value);
1484       break;
1485     case 2 :
1486       cfg.SetBoolean(section, key, value);
1487   }
1488 }
1489
1490
1491 //////////////////////////////////////////////////////////////////////////////
1492 // PHTTPRadioField
1493
1494 PHTTPRadioField::PHTTPRadioField(const char * name,
1495                                  const PStringArray & valueArray,
1496                                  PINDEX initVal,
1497                                  const char * help)
1498   : PHTTPField(name, NULL, help),
1499     values(valueArray),
1500     titles(valueArray),
1501     value(valueArray[initVal]),
1502     initialValue(value)
1503 {
1504 }
1505
1506
1507 PHTTPRadioField::PHTTPRadioField(const char * name,
1508                                  const PStringArray & valueArray,
1509                                  const PStringArray & titleArray,
1510                                  PINDEX initVal,
1511                                  const char * help)
1512   : PHTTPField(name, NULL, help),
1513     values(valueArray),
1514     titles(titleArray),
1515     value(valueArray[initVal]),
1516     initialValue(value)
1517 {
1518 }
1519
1520
1521 PHTTPRadioField::PHTTPRadioField(const char * name,
1522                                  PINDEX count,
1523                                  const char * const * valueStrings,
1524                                  PINDEX initVal,
1525                                  const char * help)
1526   : PHTTPField(name, NULL, help),
1527     values(count, valueStrings),
1528     titles(count, valueStrings),
1529     value(valueStrings[initVal]),
1530     initialValue(value)
1531 {
1532 }
1533
1534
1535 PHTTPRadioField::PHTTPRadioField(const char * name,
1536                                  PINDEX count,
1537                                  const char * const * valueStrings,
1538                                  const char * const * titleStrings,
1539                                  PINDEX initVal,
1540                                  const char * help)
1541   : PHTTPField(name, NULL, help),
1542     values(count, valueStrings),
1543     titles(count, titleStrings),
1544     value(valueStrings[initVal]),
1545     initialValue(value)
1546 {
1547 }
1548
1549
1550 PHTTPRadioField::PHTTPRadioField(const char * name,
1551                                  const char * groupTitle,
1552                                  const PStringArray & valueArray,
1553                                  PINDEX initVal,
1554                                  const char * help)
1555   : PHTTPField(name, groupTitle, help),
1556     values(valueArray),
1557     titles(valueArray),
1558     value(valueArray[initVal]),
1559     initialValue(value)
1560 {
1561 }
1562
1563
1564 PHTTPRadioField::PHTTPRadioField(const char * name,
1565                                  const char * groupTitle,
1566                                  const PStringArray & valueArray,
1567                                  const PStringArray & titleArray,
1568                                  PINDEX initVal,
1569                                  const char * help)
1570   : PHTTPField(name, groupTitle, help),
1571     values(valueArray),
1572     titles(titleArray),
1573     value(valueArray[initVal]),
1574     initialValue(value)
1575 {
1576 }
1577
1578
1579 PHTTPRadioField::PHTTPRadioField(const char * name,
1580                                  const char * groupTitle,
1581                                  PINDEX count,
1582                                  const char * const * valueStrings,
1583                                  PINDEX initVal,
1584                                  const char * help)
1585   : PHTTPField(name, groupTitle, help),
1586     values(count, valueStrings),
1587     titles(count, valueStrings),
1588     value(valueStrings[initVal]),
1589     initialValue(value)
1590 {
1591 }
1592
1593
1594 PHTTPRadioField::PHTTPRadioField(const char * name,
1595                                  const char * groupTitle,
1596                                  PINDEX count,
1597                                  const char * const * valueStrings,
1598                                  const char * const * titleStrings,
1599                                  PINDEX initVal,
1600                                  const char * help)
1601   : PHTTPField(name, groupTitle, help),
1602     values(count, valueStrings),
1603     titles(count, titleStrings),
1604     value(valueStrings[initVal]),
1605     initialValue(value)
1606 {
1607 }
1608
1609
1610 PHTTPField * PHTTPRadioField::NewField() const
1611 {
1612   return new PHTTPRadioField(*this);
1613 }
1614
1615
1616 void PHTTPRadioField::GetHTMLTag(PHTML & html) const
1617 {
1618   for (PINDEX i = 0; i < values.GetSize(); i++)
1619     html << PHTML::RadioButton(fullName, values[i],
1620                         values[i] == value ? PHTML::Checked : PHTML::UnChecked)
1621          << titles[i]
1622          << PHTML::BreakLine();
1623 }
1624
1625
1626 PString PHTTPRadioField::GetHTMLInput(const PString & input) const
1627 {
1628   PString inval;
1629   PINDEX before, after;
1630   if (FindInputValue(input, before, after))
1631     inval = input(before+1, after-1);
1632   else
1633     inval = baseName;
1634
1635   if (inval != value)
1636     return input;
1637
1638   return "<input checked" + input.Mid(6);
1639 }
1640
1641
1642 PString PHTTPRadioField::GetValue(BOOL dflt) const
1643 {
1644   if (dflt)
1645     return initialValue;
1646   else
1647     return value;
1648 }
1649
1650
1651 void PHTTPRadioField::SetValue(const PString & newVal)
1652 {
1653   value = newVal;
1654 }
1655
1656
1657 //////////////////////////////////////////////////////////////////////////////
1658 // PHTTPSelectField
1659
1660 PHTTPSelectField::PHTTPSelectField(const char * name,
1661                                    const PStringArray & valueArray,
1662                                    PINDEX initVal,
1663                                    const char * help)
1664   : PHTTPField(name, NULL, help),
1665     values(valueArray)
1666 {
1667   initialValue = initVal;
1668   if (initVal < values.GetSize())
1669     value = values[initVal];
1670 }
1671
1672
1673 PHTTPSelectField::PHTTPSelectField(const char * name,
1674                                    PINDEX count,
1675                                    const char * const * valueStrings,
1676                                    PINDEX initVal,
1677                                    const char * help)
1678   : PHTTPField(name, NULL, help),
1679     values(count, valueStrings)
1680 {
1681   initialValue = initVal;
1682   if (initVal < count)
1683     value = values[initVal];
1684 }
1685
1686
1687 PHTTPSelectField::PHTTPSelectField(const char * name,
1688                                    const char * title,
1689                                    const PStringArray & valueArray,
1690                                    PINDEX initVal,
1691                                    const char * help)
1692   : PHTTPField(name, title, help),
1693     values(valueArray)
1694 {
1695   initialValue = initVal;
1696   if (initVal < values.GetSize())
1697     value = values[initVal];
1698 }
1699
1700
1701 PHTTPSelectField::PHTTPSelectField(const char * name,
1702                                    const char * title,
1703                                    PINDEX count,
1704                                    const char * const * valueStrings,
1705                                    PINDEX initVal,
1706                                    const char * help)
1707   : PHTTPField(name, title, help),
1708     values(count, valueStrings)
1709 {
1710   initialValue = initVal;
1711   if (initVal < values.GetSize())
1712     value = values[initVal];
1713 }
1714
1715
1716 PHTTPField * PHTTPSelectField::NewField() const
1717 {
1718   return new PHTTPSelectField(baseName, title, values, initialValue, help);
1719 }
1720
1721
1722 void PHTTPSelectField::GetHTMLTag(PHTML & html) const
1723 {
1724   html << PHTML::Select(fullName);
1725   for (PINDEX i = 0; i < values.GetSize(); i++)
1726     html << PHTML::Option(values[i] == value ? PHTML::Selected : PHTML::NotSelected)
1727          << values[i];
1728   html << PHTML::Select();
1729 }
1730
1731
1732 PString PHTTPSelectField::GetValue(BOOL dflt) const
1733 {
1734   if (dflt)
1735     if (initialValue < values.GetSize())
1736       return values[initialValue];
1737     else
1738       return PString();
1739   else
1740     return value;
1741 }
1742
1743
1744 void PHTTPSelectField::SetValue(const PString & newVal)
1745 {
1746   value = newVal;
1747 }
1748
1749
1750
1751 //////////////////////////////////////////////////////////////////////////////
1752 // PHTTPForm
1753
1754 PHTTPForm::PHTTPForm(const PURL & url)
1755   : PHTTPString(url),
1756     fields("")
1757 {
1758 }
1759
1760 PHTTPForm::PHTTPForm(const PURL & url, const PHTTPAuthority & auth)
1761   : PHTTPString(url, auth),
1762     fields("")
1763 {
1764 }
1765
1766 PHTTPForm::PHTTPForm(const PURL & url, const PString & html)
1767   : PHTTPString(url, html),
1768     fields("")
1769 {
1770 }
1771
1772 PHTTPForm::PHTTPForm(const PURL & url,
1773                      const PString & html,
1774                      const PHTTPAuthority & auth)
1775   : PHTTPString(url, html, auth),
1776     fields("")
1777 {
1778 }
1779
1780
1781 static BOOL FindSpliceAccepted(const PString & text,
1782                               PINDEX offset,
1783                               PINDEX & pos,
1784                               PINDEX & len,
1785                               PINDEX & start,
1786                               PINDEX & finish)
1787 {
1788   static PRegularExpression Accepted("<?!--#form[ \t\r\n]+accepted[ \t\r\n]*-->?",
1789                                      PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1790   return FindSpliceBlock(Accepted, text, offset, pos, len, start, finish);
1791 }
1792
1793
1794 static BOOL FindSpliceErrors(const PString & text,
1795                             PINDEX offset,
1796                             PINDEX & pos,
1797                             PINDEX & len,
1798                             PINDEX & start,
1799                             PINDEX & finish)
1800 {
1801   static PRegularExpression Errors("<?!--#form[ \t\r\n]+errors[ \t\r\n]*-->?",
1802                                      PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1803   return FindSpliceBlock(Errors, text, offset, pos, len, start, finish);
1804 }
1805
1806
1807 static BOOL FindSpliceField(const PRegularExpression & startExpr,
1808                             const PRegularExpression & endExpr,
1809                             const PString & text,
1810                             PINDEX offset,
1811                             const PHTTPField & rootField,
1812                             PINDEX & pos,
1813                             PINDEX & len,
1814                             PINDEX & start,
1815                             PINDEX & finish,
1816                             const PHTTPField * & field)
1817 {
1818   field = NULL;
1819
1820   if (!FindSpliceBlock(startExpr, endExpr, text, offset, pos, len, start, finish))
1821     return FALSE;
1822
1823   PINDEX endBlock = start != finish ? (start-1) : (pos+len-1);
1824   PINDEX namePos, nameEnd;
1825   if (FindSpliceName(text, pos, endBlock, namePos, nameEnd))
1826     field = rootField.LocateName(text(namePos, nameEnd));
1827   return TRUE;
1828 }
1829
1830
1831 static const char ListFieldDeleteBox[] = "List Row Delete ";
1832
1833 void PHTTPForm::OnLoadedText(PHTTPRequest & request, PString & text)
1834 {
1835   PINDEX pos, len, start, finish;
1836   const PHTTPField * field;
1837
1838   // Remove the subsections for POST command
1839   pos = 0;
1840   while (FindSpliceAccepted(text, pos, pos, len, start, finish))
1841     text.Delete(pos, len);
1842
1843   pos = 0;
1844   while (FindSpliceErrors(text, pos, pos, len, start, finish))
1845     text.Delete(pos, len);
1846
1847   // See if are a subform, set root composite field accordingly
1848   PString prefix = request.url.GetQueryVars()("subformprefix");
1849   if (!prefix) {
1850     static PRegularExpression SubFormPrefix("<?!--#form[ \t\r\n]+subformprefix[ \t\r\n]*-->?",
1851                                             PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1852     while (text.FindRegEx(SubFormPrefix, pos, len))
1853       text.Splice("subformprefix=" +
1854                   PURL::TranslateString(prefix, PURL::QueryTranslation),
1855                   pos, len);
1856     field = fields.LocateName(prefix);
1857     if (field != NULL) {
1858       finish = P_MAX_INDEX;
1859       field->ExpandFieldNames(text, 0, finish);
1860     }
1861   }
1862
1863   // Locate <!--#form list name--> macros and expand them
1864   static PRegularExpression ListRegEx("<!--#form[ \t\r\n]+listfields[ \t\r\n]+(-?[^-])+-->",
1865                                        PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1866   static PRegularExpression EndBlock("<?!--#form[ \t\r\n]+end[ \t\r\n]+(-?[^-])+-->?",
1867                                      PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1868   pos = len = 0;
1869   while (FindSpliceBlock(ListRegEx, EndBlock, text, pos+len, pos, len, start, finish)) {
1870     if (start != finish) {
1871       PString repeat = text(start, finish);
1872
1873       PINDEX namePos, nameEnd;
1874       PRegularExpression fieldsRegEx;
1875       if (FindSpliceName(text, pos, start-1, namePos, nameEnd))
1876         fieldsRegEx.Compile(text(namePos, nameEnd), PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1877       else
1878         fieldsRegEx.Compile(".*");
1879
1880       PString insert;
1881       for (PINDEX f = 0; f < fields.GetSize(); f++) {
1882         if (fields[f].GetName().FindRegEx(fieldsRegEx) != P_MAX_INDEX) {
1883           PString iteration = repeat;
1884           PINDEX npos, nlen;
1885
1886           static PRegularExpression FieldNameRegEx("<?!--#form[ \t\r\n]+fieldname[ \t\r\n]*-->?",
1887                                                    PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1888           while (iteration.FindRegEx(FieldNameRegEx, npos, nlen))
1889             iteration.Splice(fields[f].GetName(), npos, nlen);
1890
1891           static PRegularExpression RowDeleteRegEx("<?!--#form[ \t\r\n]+rowdelete[ \t\r\n]*-->?",
1892                                                    PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1893           while (iteration.FindRegEx(RowDeleteRegEx, npos, nlen)) {
1894             PHTML html(PHTML::InForm);
1895             html << PHTML::CheckBox(ListFieldDeleteBox + fields[f].GetName());
1896             iteration.Splice(html, npos, nlen);
1897           }
1898
1899           insert += iteration;
1900         }
1901       }
1902       text.Splice(insert, pos, len);
1903     }
1904   }
1905
1906   // Locate <!--#form array name--> macros and expand them
1907   static PRegularExpression ArrayRegEx("<!--#form[ \t\r\n]+array[ \t\r\n]+(-?[^-])+-->",
1908                                        PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1909   pos = len = 0;
1910   while (FindSpliceField(ArrayRegEx, EndBlock, text, pos+len, fields, pos, len, start, finish, field)) {
1911     if (start != finish && field != NULL)
1912       field->ExpandFieldNames(text, start, finish);
1913   }
1914
1915   // Have now expanded all field names to be fully qualified
1916
1917   static PRegularExpression HTMLRegEx("<!--#form[ \t\r\n]+html[ \t\r\n]+(-?[^-])+-->",
1918                                       PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1919   while (FindSpliceField(HTMLRegEx, "", text, 0, fields, pos, len, start, finish, field)) {
1920     if (field != NULL) {
1921       PHTML html(PHTML::InForm);
1922       field->GetHTMLTag(html);
1923       text.Splice(html, pos, len);
1924     }
1925   }
1926
1927   pos = len = 0;
1928   static PRegularExpression ValueRegEx("<!--#form[ \t\r\n]+value[ \t\r\n]+(-?[^-])+-->",
1929                                        PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1930   while (FindSpliceField(ValueRegEx, "", text, pos+len, fields, pos, len, start, finish, field)) {
1931     if (field != NULL)
1932       text.Splice(field->GetValue(), pos, len);
1933   }
1934
1935   pos = len = 0;
1936   static PRegularExpression InputRegEx("<input[ \t\r\n][^>]*name[ \t\r\n]*=[ \t\r\n]*\"[^\"]*\"[^>]*>",
1937                                        PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1938   while (FindSpliceField(InputRegEx, "", text, pos+len, fields, pos, len, start, finish, field)) {
1939     if (field != NULL) {
1940       static PRegularExpression HiddenRegEx("type[ \t\r\n]*=[ \t\r\n]*\"?hidden\"?",
1941                                             PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1942       PString substr = text.Mid(pos, len);
1943       if (substr.FindRegEx(HiddenRegEx) == P_MAX_INDEX)
1944         text.Splice(field->GetHTMLInput(substr), pos, len);
1945     }
1946   }
1947
1948   pos = len = 0;
1949   static PRegularExpression SelectRegEx("<select[ \t\r\n][^>]*name[ \t\r\n]*=[ \t\r\n]*\"[^\"]*\"[^>]*>",
1950                                         PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1951   static PRegularExpression SelEndRegEx("</select[^>]*>",
1952                                         PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1953   while (FindSpliceField(SelectRegEx, SelEndRegEx, text, pos+len, fields, pos, len, start, finish, field)) {
1954     if (field != NULL)
1955       text.Splice(field->GetHTMLSelect(text(start, finish)), start, finish-start+1);
1956   }
1957
1958   pos = len = 0;
1959   static PRegularExpression TextRegEx("<textarea[ \t\r\n][^>]*name[ \t\r\n]*=[ \t\r\n]*\"[^\"]*\"[^>]*>",
1960                                       PRegularExpression::Extended|PRegularExpression::IgnoreCase);
1961   static PRegularExpression TextEndRegEx("</textarea[^>]*>", PRegularExpression::IgnoreCase);
1962   while (FindSpliceField(TextRegEx, TextEndRegEx, text, pos+len, fields, pos, len, start, finish, field)) {
1963     if (field != NULL)
1964       text.Splice(field->GetValue(), start, finish-start+1);
1965   }
1966 }
1967
1968
1969 PHTTPField * PHTTPForm::Add(PHTTPField * fld)
1970 {
1971   if (PAssertNULL(fld) == NULL)
1972     return NULL;
1973
1974   PAssert(!fieldNames[fld->GetName()], "Field already on form!");
1975   fieldNames += fld->GetName();
1976   fields.Append(fld);
1977   return fld;
1978 }
1979
1980
1981 void PHTTPForm::BuildHTML(const char * heading)
1982 {
1983   PHTML html(heading);
1984   BuildHTML(html);
1985 }
1986
1987
1988 void PHTTPForm::BuildHTML(const PString & heading)
1989 {
1990   PHTML html(heading);
1991   BuildHTML(html);
1992 }
1993
1994
1995 void PHTTPForm::BuildHTML(PHTML & html, BuildOptions option)
1996 {
1997   if (!html.Is(PHTML::InForm))
1998     html << PHTML::Form("POST");
1999
2000   html << PHTML::TableStart("cellspacing=8");
2001   for (PINDEX fld = 0; fld < fields.GetSize(); fld++) {
2002     PHTTPField & field = fields[fld];
2003     if (field.NotYetInHTML()) {
2004       html << PHTML::TableRow()
2005            << PHTML::TableData("align=right")
2006            << field.GetTitle()
2007            << PHTML::TableData("align=left")
2008            << "<!--#form html " << field.GetName() << "-->"
2009            << PHTML::TableData()
2010            << field.GetHelp();
2011       field.SetInHTML();
2012     }
2013   }
2014   html << PHTML::TableEnd();
2015   if (option != InsertIntoForm)
2016     html << PHTML::Paragraph()
2017          << ' ' << PHTML::SubmitButton("Accept")
2018          << ' ' << PHTML::ResetButton("Reset")
2019          << PHTML::Form();
2020
2021   if (option == CompleteHTML) {
2022     html << PHTML::Body();
2023     string = html;
2024   }
2025 }
2026
2027
2028 BOOL PHTTPForm::Post(PHTTPRequest & request,
2029                      const PStringToString & data,
2030                      PHTML & msg)
2031 {
2032   //PString prefix = request.url.GetQueryVars()("subformprefix");
2033   const PHTTPField * field = NULL;
2034   //if (!prefix)
2035   //  field = fields.LocateName(prefix);
2036   //if (field == NULL)
2037     field = &fields;
2038
2039   PStringStream errors;
2040   if (field->ValidateAll(data, errors)) {
2041     ((PHTTPField *)field)->SetAllValues(data);
2042
2043     if (msg.IsEmpty()) {
2044       msg << PHTML::Title() << "Accepted New Configuration" << PHTML::Body()
2045           << PHTML::Heading(1) << "Accepted New Configuration" << PHTML::Heading(1)
2046           << PHTML::HotLink(request.url.AsString()) << "Reload page" << PHTML::HotLink()
2047           << "&nbsp;&nbsp;&nbsp;&nbsp;"
2048           << PHTML::HotLink("/") << "Home page" << PHTML::HotLink();
2049     }
2050     else {
2051       PString block;
2052       PINDEX pos = 0;
2053       PINDEX len, start, finish;
2054       while (FindSpliceAccepted(msg, pos, pos, len, start, finish))
2055         msg.Splice(msg(start, finish), pos, len);
2056       pos = 0;
2057       while (FindSpliceErrors(msg, pos, pos, len, start, finish))
2058         msg.Delete(pos, len);
2059     }
2060   }
2061   else {
2062     if (msg.IsEmpty()) {
2063       msg << PHTML::Title() << "Validation Error in Request" << PHTML::Body()
2064           << PHTML::Heading(1) << "Validation Error in Request" << PHTML::Heading(1)
2065           << errors
2066           << PHTML::Paragraph()
2067           << PHTML::HotLink(request.url.AsString()) << "Reload page" << PHTML::HotLink()
2068           << "&nbsp;&nbsp;&nbsp;&nbsp;"
2069           << PHTML::HotLink("/") << "Home page" << PHTML::HotLink();
2070     }
2071     else {
2072       PINDEX pos = 0;
2073       PINDEX len, start, finish;
2074       while (FindSpliceAccepted(msg, pos, pos, len, start, finish))
2075         msg.Delete(pos, len);
2076
2077       BOOL appendErrors = TRUE;
2078       pos = 0;
2079       while (FindSpliceErrors(msg, pos, pos, len, start, finish)) {
2080         PString block = msg(start, finish);
2081         PINDEX vPos, vLen;
2082         static PRegularExpression Validation("<?!--#form[ \t\r\n]+validation[ \t\r\n]*-->?",
2083                                              PRegularExpression::Extended|PRegularExpression::IgnoreCase);
2084         if (block.FindRegEx(Validation, vPos, vLen))
2085           block.Splice(errors, vPos, vLen);
2086         else
2087           block += errors;
2088         msg.Splice(block, pos, len);
2089         appendErrors = FALSE;
2090       }
2091
2092       if (appendErrors)
2093         msg << errors;
2094     }
2095   }
2096
2097   return TRUE;
2098 }
2099
2100
2101 //////////////////////////////////////////////////////////////////////////////
2102 // PHTTPConfig
2103
2104 PHTTPConfig::PHTTPConfig(const PURL & url,
2105                          const PString & sect)
2106   : PHTTPForm(url), section(sect)
2107 {
2108   Construct();
2109 }
2110
2111
2112 PHTTPConfig::PHTTPConfig(const PURL & url,
2113                          const PString & sect,
2114                          const PHTTPAuthority & auth)
2115   : PHTTPForm(url, auth), section(sect)
2116 {
2117   Construct();
2118 }
2119
2120
2121 PHTTPConfig::PHTTPConfig(const PURL & url,
2122                          const PString & html,
2123                          const PString & sect)
2124   : PHTTPForm(url, html), section(sect)
2125 {
2126   Construct();
2127 }
2128
2129
2130 PHTTPConfig::PHTTPConfig(const PURL & url,
2131                          const PString & html,
2132                          const PString & sect,
2133                          const PHTTPAuthority & auth)
2134   : PHTTPForm(url, html, auth), section(sect)
2135 {
2136   Construct();
2137 }
2138
2139
2140 void PHTTPConfig::Construct()
2141 {
2142   sectionField = NULL;
2143   keyField = NULL;
2144   valField = NULL;
2145 }
2146
2147
2148 void PHTTPConfig::LoadFromConfig()
2149 {
2150   PConfig cfg(section);
2151   fields.LoadFromConfig(cfg);
2152 }
2153
2154
2155 void PHTTPConfig::OnLoadedText(PHTTPRequest & request, PString & text)
2156 {
2157   if (sectionField == NULL) {
2158     PString sectionName = request.url.GetQueryVars()("section", section);
2159     if (!sectionName) {
2160       section = sectionName;
2161       LoadFromConfig();
2162     }
2163   }
2164
2165   PHTTPForm::OnLoadedText(request, text);
2166 }
2167
2168
2169 BOOL PHTTPConfig::Post(PHTTPRequest & request,
2170                        const PStringToString & data,
2171                        PHTML & msg)
2172 {
2173   // Make sure the internal structure is up to date before accepting new data
2174   if (!section)
2175     LoadFromConfig();
2176
2177
2178   PSortedStringList oldValues;
2179
2180   // Remember fields that are here now, so can delete removed array fields
2181   PINDEX fld;
2182   for (fld = 0; fld < fields.GetSize(); fld++) {
2183     PHTTPField & field = fields[fld];
2184     if (&field != keyField && &field != valField && &field != sectionField) {
2185       PStringList names;
2186       field.GetAllNames(names);
2187       oldValues = names;
2188     }
2189   }
2190
2191   PHTTPForm::Post(request, data, msg);
2192   if (request.code != PHTTP::RequestOK)
2193     return TRUE;
2194
2195   if (sectionField != NULL)
2196     section = sectionPrefix + sectionField->GetValue() + sectionSuffix;
2197
2198   PString sectionName = request.url.GetQueryVars()("section", section);
2199   if (sectionName.IsEmpty())
2200     return TRUE;
2201
2202   PConfig cfg(sectionName);
2203
2204   for (fld = 0; fld < fields.GetSize(); fld++) {
2205     PHTTPField & field = fields[fld];
2206     if (&field == keyField) {
2207       PString key = field.GetValue();
2208       if (!key)
2209         cfg.SetString(key, valField->GetValue());
2210     }
2211     else if (&field != valField && &field != sectionField)
2212       field.SaveToConfig(cfg);
2213   }
2214
2215   // Find out which fields have been removed (arrays elements deleted)
2216   for (fld = 0; fld < fields.GetSize(); fld++) {
2217     PHTTPField & field = fields[fld];
2218     if (&field != keyField && &field != valField && &field != sectionField) {
2219       PStringList names;
2220       field.GetAllNames(names);
2221       for (PINDEX i = 0; i < names.GetSize(); i++) {
2222         PINDEX idx = oldValues.GetStringsIndex(names[i]);
2223         if (idx != P_MAX_INDEX)
2224           oldValues.RemoveAt(idx);
2225       }
2226     }
2227   }
2228
2229   for (fld = 0; fld < oldValues.GetSize(); fld++) {
2230     PString section, key;
2231     switch (SplitConfigKey(oldValues[fld], section, key)) {
2232       case 1 :
2233         cfg.DeleteKey(key);
2234         break;
2235       case 2 :
2236         cfg.DeleteKey(section, key);
2237         if (cfg.GetKeys(section).IsEmpty())
2238           cfg.DeleteSection(section);
2239     }
2240   }
2241
2242   section = sectionName;
2243   return TRUE;
2244 }
2245
2246
2247 PHTTPField * PHTTPConfig::AddSectionField(PHTTPField * sectionFld,
2248                                           const char * prefix,
2249                                           const char * suffix)
2250 {
2251   sectionField = PAssertNULL(sectionFld);
2252   PAssert(!PIsDescendant(sectionField, PHTTPCompositeField), "Section field is composite");
2253   Add(sectionField);
2254
2255   if (prefix != NULL)
2256     sectionPrefix = prefix;
2257   if (suffix != NULL)
2258     sectionSuffix = suffix;
2259
2260   return sectionField;
2261 }
2262
2263
2264 void PHTTPConfig::AddNewKeyFields(PHTTPField * keyFld,
2265                                   PHTTPField * valFld)
2266 {
2267   keyField = PAssertNULL(keyFld);
2268   Add(keyFld);
2269   valField = PAssertNULL(valFld);
2270   Add(valFld);
2271 }
2272
2273
2274 //////////////////////////////////////////////////////////////////////////////
2275 // PHTTPConfigSectionList
2276
2277 static const char FormListInclude[] = "<!--#form pagelist-->";
2278
2279 PHTTPConfigSectionList::PHTTPConfigSectionList(const PURL & url,
2280                                                const PHTTPAuthority & auth,
2281                                                const PString & prefix,
2282                                                const PString & valueName,
2283                                                const PURL & editSection,
2284                                                const PURL & newSection,
2285                                                const PString & newTitle,
2286                                                PHTML & heading)
2287   : PHTTPString(url, auth),
2288     sectionPrefix(prefix),
2289     additionalValueName(valueName),
2290     newSectionLink(newSection.AsString(PURL::URIOnly)),
2291     newSectionTitle(newTitle),
2292     editSectionLink(editSection.AsString(PURL::URIOnly) +
2293                       "?section=" + PURL::TranslateString(prefix, PURL::QueryTranslation))
2294 {
2295   if (heading.Is(PHTML::InBody))
2296     heading << FormListInclude << PHTML::Body();
2297   SetString(heading);
2298 }
2299
2300
2301 void PHTTPConfigSectionList::OnLoadedText(PHTTPRequest &, PString & text)
2302 {
2303   PConfig cfg;
2304   PStringList nameList = cfg.GetSections();
2305
2306   PINDEX pos = text.Find(FormListInclude);
2307   if (pos != P_MAX_INDEX) {
2308     PINDEX endpos = text.Find(FormListInclude, pos + sizeof(FormListInclude)-1);
2309     if (endpos == P_MAX_INDEX) {
2310       PHTML html(PHTML::InBody);
2311       html << PHTML::Form("POST") << PHTML::TableStart();
2312
2313       PINDEX i;
2314       for (i = 0; i < nameList.GetSize(); i++) {
2315         if (nameList[i].Find(sectionPrefix) == 0) {
2316           PString name = nameList[i].Mid(sectionPrefix.GetLength());
2317           html << PHTML::TableRow()
2318                << PHTML::TableData()
2319                << PHTML::HotLink(editSectionLink + PURL::TranslateString(name, PURL::QueryTranslation))
2320                << name
2321                << PHTML::HotLink();
2322           if (!additionalValueName)
2323             html << PHTML::TableData()
2324                  << PHTML::HotLink(editSectionLink + PURL::TranslateString(name, PURL::QueryTranslation))
2325                  << cfg.GetString(nameList[i], additionalValueName, "")
2326                  << PHTML::HotLink();
2327           html << PHTML::TableData() << PHTML::SubmitButton("Remove", name);
2328         }
2329       }
2330
2331       html << PHTML::TableRow()
2332            << PHTML::TableData()
2333            << PHTML::HotLink(newSectionLink)
2334            << newSectionTitle
2335            << PHTML::HotLink()
2336            << PHTML::TableEnd()
2337            << PHTML::Form();
2338
2339       text.Splice(html, pos, sizeof(FormListInclude)-1);
2340     }
2341     else {
2342       PString repeat = text(pos + sizeof(FormListInclude)-1, endpos-1);
2343       text.Delete(pos, endpos - pos);
2344
2345       PINDEX i;
2346       for (i = 0; i < nameList.GetSize(); i++) {
2347         if (nameList[i].Find(sectionPrefix) == 0) {
2348           PString name = nameList[i].Mid(sectionPrefix.GetLength());
2349           text.Splice(repeat, pos, 0);
2350           text.Replace("<!--#form hotlink-->",
2351                        editSectionLink + PURL::TranslateString(name, PURL::QueryTranslation),
2352                        TRUE, pos);
2353           if (!additionalValueName)
2354             text.Replace("<!--#form additional-->",
2355                          cfg.GetString(nameList[i], additionalValueName, ""),
2356                          TRUE, pos);
2357           text.Replace("<!--#form section-->", name, TRUE, pos);
2358           pos = text.Find(FormListInclude, pos);
2359         }
2360       }
2361       text.Delete(text.Find(FormListInclude, pos), sizeof(FormListInclude)-1);
2362     }
2363   }
2364 }
2365
2366
2367 BOOL PHTTPConfigSectionList::Post(PHTTPRequest &,
2368                                   const PStringToString & data,
2369                                   PHTML & replyMessage)
2370 {
2371   PConfig cfg;
2372   PStringList nameList = cfg.GetSections();
2373   PINDEX i;
2374   for (i = 0; i < nameList.GetSize(); i++) {
2375     if (nameList[i].Find(sectionPrefix) == 0) {
2376       PString name = nameList[i].Mid(sectionPrefix.GetLength());
2377       if (data.Contains(name)) {
2378         cfg.DeleteSection(nameList[i]);
2379         replyMessage << name << " removed.";
2380       }
2381     }
2382   }
2383
2384   return TRUE;
2385 }
2386
2387
2388
2389 // End Of File ///////////////////////////////////////////////////////////////