src/ptclib/httpsrvr.cxx

   1 /*
   2  * httpsrvr.cxx
   3  *
   4  * HTTP server classes.
   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.47  2004/02/03 09:37:20  rjongbloed
  28  * Added check to text files via the type extension, thanks David Parr
  29  *
  30  * Revision 1.46  2003/03/19 01:55:26  robertj
  31  * Fixed bugs in deleteing HTTP resources from server, thanks Diego Tártara
  32  *
  33  * Revision 1.45  2002/11/06 22:47:25  robertj
  34  * Fixed header comment (copyright etc)
  35  *
  36  * Revision 1.44  2002/10/10 04:43:44  robertj
  37  * VxWorks port, thanks Martijn Roest
  38  *
  39  * Revision 1.43  2002/10/02 08:54:01  craigs
  40  * Added support for XMLRPC server
  41  *
  42  * Revision 1.42  2002/08/27 23:49:08  robertj
  43  * Fixed security hole where possible to get any file on disk when using
  44  *   PHTTPDirectory HTTP resource.
  45  *
  46  * Revision 1.41  2002/07/17 08:43:52  robertj
  47  * Fixed closing of html msg on generated post output.
  48  *
  49  * Revision 1.40  2002/05/08 05:38:54  robertj
  50  * Added PHTTPTailFile resource to do a unix 'tail -f' of a file.
  51  *
  52  * Revision 1.39  2002/04/12 08:15:23  robertj
  53  * Fixed warning on older GNU compilers, also guarantees numeric output.
  54  *
  55  * Revision 1.38  2001/10/31 01:37:13  robertj
  56  * Fixed deleting of object added to http name space if add fails.
  57  * Changes to support HTTP v1.1 chunked transfer encoding.
  58  *
  59  * Revision 1.37  2001/09/28 00:45:27  robertj
  60  * Removed HasKey() as is confusing due to ancestor Contains().
  61  *
  62  * Revision 1.36  2001/06/01 07:28:23  craigs
  63  * Added handling for binary data in multi-part MIME fields
  64  *
  65  * Revision 1.35  2001/03/14 01:49:54  craigs
  66  * Added ability to handle multi-part form POST commands
  67  *
  68  * Revision 1.34  2001/01/15 06:17:56  robertj
  69  * Set HTTP resource members to private to assure are not modified by
  70  *   dscendents in non-threadsafe manner.
  71  *
  72  * Revision 1.33  2000/09/04 03:57:58  robertj
  73  * Added ability to change the persistent connection parameters (timeout etc).
  74  *
  75  * Revision 1.32  2000/05/02 07:55:22  craigs
  76  * Changed static PString to static const char * to avoid "memory leak"
  77  *
  78  * Revision 1.31  1999/05/13 04:04:04  robertj
  79  * Fixed problem of initialised commandName in ConnectionInfo.
  80  *
  81  * Revision 1.30  1999/05/12 01:40:47  robertj
  82  * Fixed "unknown" response codes being passed on when used with an "unknown" command.
  83  *
  84  * Revision 1.29  1999/05/11 12:23:22  robertj
  85  * Fixed search for persistent connection to accept kee-alive on multile MIME fields.
  86  *
  87  * Revision 1.28  1999/05/04 15:26:01  robertj
  88  * Improved HTTP/1.1 compatibility (pass through user commands).
  89  * Fixed problems with quicktime installer.
  90  *
  91  * Revision 1.27  1999/04/24 11:50:11  robertj
  92  * Changed HTTP command parser so will work if some idiot puts spaces in a URL.
  93  *
  94  * Revision 1.26  1999/04/21 01:58:08  robertj
  95  * Fixed problem with reading data for request using second form of PHTTPRequestInfo constructor.
  96  *
  97  * Revision 1.25  1998/11/30 04:51:59  robertj
  98  * New directory structure
  99  *
 100  * Revision 1.24  1998/11/14 01:11:38  robertj
 101  * PPC linux GNU compatibility.
 102  *
 103  * Revision 1.23  1998/10/31 12:49:23  robertj
 104  * Added read/write mutex to the HTTP space variable to avoid thread crashes.
 105  *
 106  * Revision 1.22  1998/10/25 01:02:41  craigs
 107  * Added ability to specify per-directory authorisation for PHTTPDirectory
 108  *
 109  * Revision 1.21  1998/10/13 14:06:23  robertj
 110  * Complete rewrite of memory leak detection code.
 111  *
 112  * Revision 1.20  1998/09/23 06:22:13  robertj
 113  * Added open source copyright license.
 114  *
 115  * Revision 1.19  1998/08/06 00:54:22  robertj
 116  * Fixed bug in sending empty files, caused endless wait in Netscape.
 117  *
 118  * Revision 1.18  1998/06/16 03:32:14  robertj
 119  * Propagated persistence and proxy flags in new connection info instances.
 120  *
 121  * Revision 1.17  1998/04/01 01:55:16  robertj
 122  * Fixed bug when serving HTTPFile that has zero bytes in it.
 123  *
 124  * Revision 1.16  1998/02/03 06:24:10  robertj
 125  * Added local address and port to PHTTPRequest.
 126  * Fixed bug in default entity length. should be read to EOF.
 127  * Fixed OnError() so can detec HTML bosy tag with parameters.
 128  *
 129  * Revision 1.14  1998/01/26 00:42:19  robertj
 130  * Added more information to PHTTPConnectionInfo.
 131  * Made SetDefaultMIMEFields in HTTP Server not set those fields if already set.
 132  *
 133  * Revision 1.13  1997/10/30 10:22:04  robertj
 134  * Added multiple user basic authorisation scheme.
 135  *
 136  * Revision 1.12  1997/10/03 13:39:25  robertj
 137  * Fixed race condition on socket close in Select() function.
 138  *
 139  * Revision 1.12  1997/10/03 13:31:12  craigs
 140  * Added ability to access client socket from within HTTP resources
 141  *
 142  * Revision 1.11  1997/08/04 10:44:36  robertj
 143  * Improved receiving of a POST on a non-persistant connection, do not wait for EOF if have CRLF.
 144  *
 145  * Revision 1.10  1997/07/14 11:47:13  robertj
 146  * Added "const" to numerous variables.
 147  *
 148  * Revision 1.9  1997/07/08 13:10:26  robertj
 149  * Fixed bug in HTTP server where standard error text is not sent to remote client.
 150  *
 151  * Revision 1.8  1997/04/15 14:32:19  robertj
 152  * Fixed case problem for HTTP version string.
 153  *
 154  * Revision 1.7  1997/03/20 13:01:32  robertj
 155  * Fixed bug in proxy POST having unexpexted reset of connection.
 156  *
 157  * Revision 1.6  1997/02/09 04:09:30  robertj
 158  * Fixed GCC warning
 159  *
 160  * Revision 1.5  1997/01/12 04:15:23  robertj
 161  * Globalised MIME tag strings.
 162  *
 163  * Revision 1.4  1996/12/12 09:24:16  robertj
 164  * Persistent proxy connection support (work in progress).
 165  *
 166  * Revision 1.3  1996/11/10 21:09:33  robertj
 167  * Removed redundent GetSocket() call.
 168  * Added flush of stream after processing request, important on persistent connections.
 169  *
 170  * Revision 1.2  1996/10/26 03:31:05  robertj
 171  * Changed OnError so can pass in full HTML page as parameter.
 172  *
 173  * Revision 1.1  1996/09/14 13:02:18  robertj
 174  * Initial revision
 175  *
 176  */
 177
 178 #include <ptlib.h>
 179 #include <ptlib/sockets.h>
 180 #include <ptclib/http.h>
 181 #include <ctype.h>
 182
 183 #define new PNEW
 184
 185
 186 // define to enable work-around for Netscape persistant connection bug
 187 // set to lifetime of suspect sockets (in seconds)
 188 #define STRANGE_NETSCAPE_BUG    3
 189
 190 // maximum delay between characters whilst reading a line of text
 191 #define READLINE_TIMEOUT        30
 192
 193 #define DEFAULT_PERSIST_TIMEOUT 30
 194 #define DEFAULT_PERSIST_TRANSATIONS 10
 195
 196 //  filename to use for directory access directives
 197 static const char * accessFilename = "_access";
 198
 199
 200 //////////////////////////////////////////////////////////////////////////////
 201 // PHTTPSpace
 202
 203 PHTTPSpace::PHTTPSpace()
 204 {
 205   mutex = new PReadWriteMutex;
 206   root = new Node(PString(), NULL);
 207 }
 208
 209
 210 void PHTTPSpace::DestroyContents()
 211 {
 212   delete mutex;
 213   delete root;
 214 }
 215
 216
 217 void PHTTPSpace::CloneContents(const PHTTPSpace * c)
 218 {
 219   mutex = new PReadWriteMutex;
 220   root = new Node(*c->root);
 221 }
 222
 223
 224 void PHTTPSpace::CopyContents(const PHTTPSpace & c)
 225 {
 226   mutex = c.mutex;
 227   root = c.root;
 228 }
 229
 230
 231 PHTTPSpace::Node::Node(const PString & nam, Node * parentNode)
 232   : PString(nam)
 233 {
 234   parent = parentNode;
 235   resource = NULL;
 236 }
 237
 238
 239 PHTTPSpace::Node::~Node()
 240 {
 241   delete resource;
 242 }
 243
 244
 245 BOOL PHTTPSpace::AddResource(PHTTPResource * res, AddOptions overwrite)
 246 {
 247   PAssert(res != NULL, PInvalidParameter);
 248   const PStringArray & path = res->GetURL().GetPath();
 249   Node * node = root;
 250   for (PINDEX i = 0; i < path.GetSize(); i++) {
 251     if (path[i].IsEmpty())
 252       break;
 253
 254     if (node->resource != NULL) {
 255       delete res;
 256       return FALSE;   // Already a resource in tree in partial path
 257     }
 258
 259     PINDEX pos = node->children.GetValuesIndex(path[i]);
 260     if (pos == P_MAX_INDEX)
 261       pos = node->children.Append(new Node(path[i], node));
 262
 263     node = &node->children[pos];
 264   }
 265
 266   if (!node->children.IsEmpty()) {
 267     delete res;
 268     return FALSE;   // Already a resource in tree further down path.
 269   }
 270
 271   if (overwrite == ErrorOnExist && node->resource != NULL) {
 272     delete res;
 273     return FALSE;   // Already a resource in tree at leaf
 274   }
 275
 276   delete node->resource;
 277   node->resource = res;
 278
 279   return TRUE;
 280 }
 281
 282
 283 BOOL PHTTPSpace::DelResource(const PURL & url)
 284 {
 285   const PStringArray & path = url.GetPath();
 286   Node * node = root;
 287   for (PINDEX i = 0; i < path.GetSize(); i++) {
 288     if (path[i].IsEmpty())
 289       break;
 290
 291     PINDEX pos = node->children.GetValuesIndex(path[i]);
 292     if (pos == P_MAX_INDEX)
 293       return FALSE;
 294
 295     node = &node->children[pos];
 296
 297     // If have resource and not last node, then trying to remove something
 298     // further down the tree than a leaf node.
 299     if (node->resource != NULL && i < (path.GetSize()-1))
 300       return FALSE;
 301   }
 302
 303   if (!node->children.IsEmpty())
 304     return FALSE;   // Still a resource in tree further down path.
 305
 306   if (node->parent != NULL) {
 307     do {
 308       Node * par = node->parent;
 309       par->children.Remove(node);
 310       node = par;
 311     } while (node != NULL && node->children.IsEmpty());
 312   }
 313
 314   return TRUE;
 315 }
 316
 317
 318 static const char * const HTMLIndexFiles[] = {
 319   "Welcome.html", "welcome.html", "index.html",
 320   "Welcome.htm",  "welcome.htm",  "index.htm"
 321 };
 322
 323 PHTTPResource * PHTTPSpace::FindResource(const PURL & url)
 324 {
 325   const PStringArray & path = url.GetPath();
 326
 327   Node * node = root;
 328   PINDEX i;
 329   for (i = 0; i < path.GetSize(); i++) {
 330     if (path[i].IsEmpty())
 331       break;
 332
 333     PINDEX pos = node->children.GetValuesIndex(path[i]);
 334     if (pos == P_MAX_INDEX)
 335       return NULL;
 336
 337     node = &node->children[pos];
 338
 339     if (node->resource != NULL)
 340       return node->resource;
 341   }
 342
 343   for (i = 0; i < PARRAYSIZE(HTMLIndexFiles); i++) {
 344     PINDEX pos = node->children.GetValuesIndex(PString(HTMLIndexFiles[i]));
 345     if (pos != P_MAX_INDEX)
 346       return node->children[pos].resource;
 347   }
 348
 349   return NULL;
 350 }
 351
 352
 353 //////////////////////////////////////////////////////////////////////////////
 354 // PHTTPServer
 355
 356 PHTTPServer::PHTTPServer()
 357 {
 358   Construct();
 359 }
 360
 361
 362 PHTTPServer::PHTTPServer(const PHTTPSpace & space)
 363   : urlSpace(space)
 364 {
 365   Construct();
 366 }
 367
 368
 369 void PHTTPServer::Construct()
 370 {
 371   transactionCount = 0;
 372   SetReadLineTimeout(PTimeInterval(0, READLINE_TIMEOUT));
 373 }
 374
 375 void PHTTPConnectionInfo::DecodeMultipartFormInfo(const PString & type, const PString & entityBody)
 376 {
 377   // remove trailing ","
 378   PINDEX pos = type.Find(",");
 379   if (pos == P_MAX_INDEX) {
 380     pos = type.Find(";");
 381     if (pos == P_MAX_INDEX)
 382       return;
 383   }
 384   PString seperator = type.Mid(pos+1).Trim();
 385
 386   // remove "boundary"
 387   pos = seperator.Find("boundary");
 388   if (pos == P_MAX_INDEX)
 389     return;
 390   seperator = seperator.Mid(8).Trim();
 391
 392   // remove "="
 393   pos = seperator.Find("=");
 394   if (pos == P_MAX_INDEX)
 395     return;
 396   seperator = seperator.Mid(1).Trim();
 397
 398   // seperators have a "--" according to RFC 1521
 399   seperator = PString("--") + seperator;
 400
 401   PINDEX sepLen = seperator.GetLength();
 402   const char * sep = (const char *)seperator;
 403
 404   // split body into parts, assuming binary data
 405   const char * body = (const char *)entityBody;
 406   PINDEX entityOffs = 0;
 407   PINDEX entityLen = entityBody.GetSize()-1;
 408
 409   BOOL ignore = TRUE;
 410   BOOL last = FALSE;
 411
 412   PMultipartFormInfo * info = NULL;
 413
 414   while (!last && (entityOffs < entityLen)) {
 415
 416     // find end of part
 417     PINDEX partStart = entityOffs;
 418     PINDEX partLen;
 419     BOOL foundSep = FALSE;
 420
 421     // collect length of part until seperator
 422     for (partLen = 0; (partStart + partLen) < entityLen; partLen++) {
 423       if ((partLen >= sepLen) && (memcmp(body + partStart + partLen - sepLen, sep, sepLen) == 0)) {
 424         foundSep = TRUE;
 425         break;
 426       }
 427     }
 428
 429     // move entity ptr to the end of the part
 430     entityOffs = partStart + partLen;
 431
 432     // if no seperator found, then this is the last part
 433     // otherwise, look for "--" trailer on seperator and remove CRLF
 434     if (!foundSep)
 435       last = TRUE;
 436     else {
 437       partLen -= sepLen;
 438
 439       // determine if this is the last block
 440       if (((entityOffs + 2) <= entityLen) && (body[entityOffs] == '-') && (body[entityOffs+1] == '-')) {
 441         last = TRUE;
 442         entityOffs += 2;
 443       }
 444
 445       // remove crlf
 446       if (((entityOffs + 2) <= entityLen) && (body[entityOffs] == '\r') && (body[entityOffs+1] == '\n'))
 447         entityOffs += 2;
 448     }
 449
 450     // ignore everything up to the first seperator,
 451     // then adjust seperator to include leading CRLF
 452     if (ignore) {
 453       ignore = FALSE;
 454       seperator = PString("\r\n") + seperator;
 455       sepLen = seperator.GetLength();
 456       sep = (const char *)seperator;
 457       continue;
 458     }
 459
 460     // extract the MIME header, by looking for a double CRLF
 461     PINDEX ptr;
 462     PINDEX nlCount = 0;
 463     for (ptr = partStart;(ptr < (partStart + partLen)) && (nlCount < 2); ptr++) {
 464       if (body[ptr] == '\r') {
 465         nlCount++;
 466         if ((ptr < entityLen-1) && (body[ptr+1] == '\n'))
 467           ptr++;
 468       } else
 469         nlCount = 0;
 470     }
 471
 472     // create the new part info
 473     info = new PMultipartFormInfo;
 474
 475     // read MIME information
 476     PStringStream strm(PString(body + partStart, ptr - partStart));
 477     info->mime.ReadFrom(strm);
 478
 479     // save the entity body, being careful of binary files
 480     int savedLen = partStart + partLen - ptr;
 481     char * saved = info->body.GetPointer(savedLen + 1);
 482     memcpy(saved, body + ptr, savedLen);
 483     saved[savedLen] = '\0';
 484
 485     // add the data to the array
 486     multipartFormInfoArray.Append(info);
 487     info = NULL;
 488   }
 489
 490 #if 0
 491   // ignore until first separator
 492   do {
 493     data >> line;
 494     if (line.IsEmpty())
 495       return;
 496   } while (line.Find(sep) != 0);
 497
 498   PMultipartFormInfo * info = NULL;
 499
 500   // read form parts
 501   while (data.good() && (line.Right(2) != "--")) {
 502
 503     info = new PMultipartFormInfo;
 504
 505     // read MIME information
 506     info->mime.ReadFrom(data);
 507
 508     // get the content type
 509     PString type = info->mime(PHTTP::ContentTypeTag);
 510
 511     // check the encoding
 512     PString encoding = info->mime("Content-Transfer-Encoding");
 513
 514     // accumulate text until another seperator or end of data
 515     PString & buf = info->body;
 516     PINDEX len = 0;
 517     buf.SetSize(len+1);
 518     buf[0] = '\0';
 519     PINDEX sepLen = sep.GetLength();
 520     const char * sepPtr = (const char *)sep;
 521     while (data.good()) {
 522       buf.SetSize(len);
 523       data >> buf[len++];
 524       if ((len >= sepLen) && (memcmp(((const char *)buf) + len - sepLen, sepPtr, sepLen) == 0)) {
 525         char ch;
 526         data >> ch;
 527         if (ch != 0x0d)
 528           data.putback(ch);
 529         else {
 530           data >> ch;
 531           if (ch != 0x0a)
 532             data.putback(ch);
 533         }
 534         len -= sepLen;
 535         break;
 536       }
 537     }
 538     buf.SetSize(len+1);
 539     buf[len] = '\0';
 540
 541     /*
 542     while (data.good()) {
 543       data >> line;
 544       if (line.Find(sep) == 0)
 545         break;
 546       info->body += line + "\n";
 547     }
 548     */
 549
 550     multipartFormInfoArray.Append(info);
 551     info = NULL;
 552   }
 553 #endif
 554 }
 555
 556 BOOL PHTTPServer::ProcessCommand()
 557 {
 558   PString args;
 559   PINDEX cmd;
 560
 561   // if this is not the first command received by this socket, then set
 562   // the read timeout appropriately.
 563   if (transactionCount > 0)
 564     SetReadTimeout(nextTimeout);
 565
 566   // this will only return false upon timeout or completely invalid command
 567   if (!ReadCommand(cmd, args))
 568     return FALSE;
 569
 570   connectInfo.commandCode = (Commands)cmd;
 571   if (cmd < NumCommands)
 572     connectInfo.commandName = commandNames[cmd];
 573   else {
 574     PINDEX spacePos = args.Find(' ');
 575     connectInfo.commandName = args.Left(spacePos);
 576     args = args.Mid(spacePos);
 577   }
 578
 579   // if no tokens, error
 580   if (args.IsEmpty()) {
 581     OnError(BadRequest, args, connectInfo);
 582     return FALSE;
 583   }
 584
 585   if (!connectInfo.Initialise(*this, args))
 586       return FALSE;
 587
 588   // now that we've decided we did receive a HTTP request, increment the
 589   // count of transactions
 590   transactionCount++;
 591   nextTimeout = connectInfo.GetPersistenceTimeout();
 592
 593   PIPSocket * socket = GetSocket();
 594   WORD myPort = (WORD)(socket != NULL ? socket->GetPort() : 80);
 595
 596   // the URL that comes with Connect requests is not quite kosher, so
 597   // mangle it into a proper URL and do NOT close the connection.
 598   // for all other commands, close the read connection if not persistant
 599   if (cmd == CONNECT)
 600     connectInfo.url = "https://" + args;
 601   else {
 602     connectInfo.url = args;
 603     if (connectInfo.url.GetPort() == 0)
 604       connectInfo.url.SetPort(myPort);
 605   }
 606
 607   BOOL persist;
 608
 609   // make sure the form info is reset for each new operation
 610   connectInfo.ResetMultipartFormInfo();
 611
 612   // If the incoming URL is of a proxy type then call OnProxy() which will
 613   // probably just go OnError(). Even if a full URL is provided in the
 614   // command we should check to see if it is a local server request and process
 615   // it anyway even though we are not a proxy. The usage of GetHostName()
 616   // below are to catch every way of specifying the host (name, alias, any of
 617   // several IP numbers etc).
 618   const PURL & url = connectInfo.GetURL();
 619   if (url.GetScheme() != "http" ||
 620       (url.GetPort() != 0 && url.GetPort() != myPort) ||
 621       (!url.GetHostName() && !PIPSocket::IsLocalHost(url.GetHostName())))
 622     persist = OnProxy(connectInfo);
 623   else {
 624     connectInfo.entityBody = ReadEntityBody();
 625
 626     // Handle the local request
 627     PStringToString postData;
 628     switch (cmd) {
 629       case GET :
 630         persist = OnGET(url, connectInfo.GetMIME(), connectInfo);
 631         break;
 632
 633       case HEAD :
 634         persist = OnHEAD(url, connectInfo.GetMIME(), connectInfo);
 635         break;
 636
 637       case POST :
 638         {
 639           // check for multi-part form POSTs
 640           PString postType = (connectInfo.GetMIME())(ContentTypeTag);
 641           if (postType.Find("multipart/form-data") == 0)
 642             connectInfo.DecodeMultipartFormInfo(postType, connectInfo.entityBody);
 643           else  // if (postType *= "x-www-form-urlencoded)
 644             PURL::SplitQueryVars(connectInfo.entityBody, postData);
 645         }
 646         persist = OnPOST(url, connectInfo.GetMIME(), postData, connectInfo);
 647         break;
 648
 649       case P_MAX_INDEX:
 650       default:
 651         persist = OnUnknown(args, connectInfo);
 652     }
 653   }
 654
 655   flush();
 656
 657   // if the function just indicated that the connection is to persist,
 658   // and so did the client, then return TRUE. Note that all of the OnXXXX
 659   // routines above must make sure that their return value is FALSE if
 660   // if there was no ContentLength field in the response. This ensures that
 661   // we always close the socket so the client will get the correct end of file
 662   if (persist && connectInfo.IsPersistant()) {
 663     unsigned max = connectInfo.GetPersistenceMaximumTransations();
 664     if (max == 0 || transactionCount < max)
 665       return TRUE;
 666   }
 667
 668   PTRACE(5, "HTTPServer\tConnection end: " << connectInfo.IsPersistant());
 669
 670   // close the output stream now and return FALSE
 671   Shutdown(ShutdownWrite);
 672   return FALSE;
 673 }
 674
 675
 676 PString PHTTPServer::ReadEntityBody()
 677 {
 678   if (connectInfo.GetMajorVersion() < 1)
 679     return PString();
 680
 681   PString entityBody;
 682   long contentLength = connectInfo.GetEntityBodyLength();
 683   // a content length of > 0 means read explicit length
 684   // a content length of < 0 means read until EOF
 685   // a content length of 0 means read nothing
 686   int count = 0;
 687   if (contentLength > 0) {
 688     entityBody = ReadString((PINDEX)contentLength);
 689   } else if (contentLength == -2) {
 690     ReadLine(entityBody, FALSE);
 691   } else if (contentLength < 0) {
 692     while (Read(entityBody.GetPointer(count+1000)+count, 1000))
 693       count += GetLastReadCount();
 694     entityBody.SetSize(count+1);
 695   }
 696
 697   // close the connection, if not persistant
 698   if (!connectInfo.IsPersistant()) {
 699     PIPSocket * socket = GetSocket();
 700     if (socket != NULL)
 701       socket->Shutdown(PIPSocket::ShutdownRead);
 702   }
 703
 704   return entityBody;
 705 }
 706
 707
 708 PString PHTTPServer::GetServerName() const
 709 {
 710   return "PWLib-HTTP-Server/1.0 PWLib/1.0";
 711 }
 712
 713
 714 void PHTTPServer::SetURLSpace(const PHTTPSpace & space)
 715 {
 716   urlSpace = space;
 717 }
 718
 719
 720 BOOL PHTTPServer::OnGET(const PURL & url,
 721                    const PMIMEInfo & info,
 722          const PHTTPConnectionInfo & connectInfo)
 723 {
 724   urlSpace.StartRead();
 725   PHTTPResource * resource = urlSpace.FindResource(url);
 726   if (resource == NULL) {
 727     urlSpace.EndRead();
 728     return OnError(NotFound, url.AsString(), connectInfo);
 729   }
 730
 731   BOOL retval = resource->OnGET(*this, url, info, connectInfo);
 732   urlSpace.EndRead();
 733   return retval;
 734 }
 735
 736
 737 BOOL PHTTPServer::OnHEAD(const PURL & url,
 738                     const PMIMEInfo & info,
 739           const PHTTPConnectionInfo & connectInfo)
 740 {
 741   urlSpace.StartRead();
 742   PHTTPResource * resource = urlSpace.FindResource(url);
 743   if (resource == NULL) {
 744     urlSpace.EndRead();
 745     return OnError(NotFound, url.AsString(), connectInfo);
 746   }
 747
 748   BOOL retval = resource->OnHEAD(*this, url, info, connectInfo);
 749   urlSpace.EndRead();
 750   return retval;
 751 }
 752
 753
 754 BOOL PHTTPServer::OnPOST(const PURL & url,
 755                     const PMIMEInfo & info,
 756               const PStringToString & data,
 757           const PHTTPConnectionInfo & connectInfo)
 758 {
 759   urlSpace.StartRead();
 760   PHTTPResource * resource = urlSpace.FindResource(url);
 761   if (resource == NULL) {
 762     urlSpace.EndRead();
 763     return OnError(NotFound, url.AsString(), connectInfo);
 764   }
 765
 766   BOOL retval = resource->OnPOST(*this, url, info, data, connectInfo);
 767   urlSpace.EndRead();
 768   return retval;
 769 }
 770
 771
 772 BOOL PHTTPServer::OnProxy(const PHTTPConnectionInfo & connectInfo)
 773 {
 774   return OnError(BadGateway, "Proxy not implemented.", connectInfo) &&
 775          connectInfo.GetCommandCode() != CONNECT;
 776 }
 777
 778
 779 struct httpStatusCodeStruct {
 780   const char * text;
 781   int  code;
 782   BOOL allowedBody;
 783   int  majorVersion;
 784   int  minorVersion;
 785 };
 786
 787 static const httpStatusCodeStruct * GetStatusCodeStruct(int code)
 788 {
 789   static const httpStatusCodeStruct httpStatusDefn[] = {
 790     // First entry MUST be InternalServerError
 791     { "Internal Server Error",         PHTTP::InternalServerError, 1 },
 792     { "OK",                            PHTTP::RequestOK, 1 },
 793     { "Unauthorised",                  PHTTP::UnAuthorised, 1 },
 794     { "Forbidden",                     PHTTP::Forbidden, 1 },
 795     { "Not Found",                     PHTTP::NotFound, 1 },
 796     { "Not Modified",                  PHTTP::NotModified },
 797     { "No Content",                    PHTTP::NoContent },
 798     { "Bad Gateway",                   PHTTP::BadGateway, 1 },
 799     { "Bad Request",                   PHTTP::BadRequest, 1 },
 800     { "Continue",                      PHTTP::Continue, 1, 1, 1 },
 801     { "Switching Protocols",           PHTTP::SwitchingProtocols, 1, 1, 1 },
 802     { "Created",                       PHTTP::Created, 1 },
 803     { "Accepted",                      PHTTP::Accepted, 1 },
 804     { "Non-Authoritative Information", PHTTP::NonAuthoritativeInformation, 1, 1, 1 },
 805     { "Reset Content",                 PHTTP::ResetContent, 0, 1, 1 },
 806     { "Partial Content",               PHTTP::PartialContent, 1, 1, 1 },
 807     { "Multiple Choices",              PHTTP::MultipleChoices, 1, 1, 1 },
 808     { "Moved Permanently",             PHTTP::MovedPermanently, 1 },
 809     { "Moved Temporarily",             PHTTP::MovedTemporarily, 1 },
 810     { "See Other",                     PHTTP::SeeOther, 1, 1, 1 },
 811     { "Use Proxy",                     PHTTP::UseProxy, 1, 1, 1 },
 812     { "Payment Required",              PHTTP::PaymentRequired, 1, 1, 1 },
 813     { "Method Not Allowed",            PHTTP::MethodNotAllowed, 1, 1, 1 },
 814     { "None Acceptable",               PHTTP::NoneAcceptable, 1, 1, 1 },
 815     { "Proxy Authetication Required",  PHTTP::ProxyAuthenticationRequired, 1, 1, 1 },
 816     { "Request Timeout",               PHTTP::RequestTimeout, 1, 1, 1 },
 817     { "Conflict",                      PHTTP::Conflict, 1, 1, 1 },
 818     { "Gone",                          PHTTP::Gone, 1, 1, 1 },
 819     { "Length Required",               PHTTP::LengthRequired, 1, 1, 1 },
 820     { "Unless True",                   PHTTP::UnlessTrue, 1, 1, 1 },
 821     { "Not Implemented",               PHTTP::NotImplemented, 1 },
 822     { "Service Unavailable",           PHTTP::ServiceUnavailable, 1, 1, 1 },
 823     { "Gateway Timeout",               PHTTP::GatewayTimeout, 1, 1, 1 }
 824   };
 825
 826   // make sure the error code is valid
 827   for (PINDEX i = 0; i < PARRAYSIZE(httpStatusDefn); i++)
 828     if (code == httpStatusDefn[i].code)
 829       return &httpStatusDefn[i];
 830
 831   return httpStatusDefn;
 832 }
 833
 834
 835 BOOL PHTTPServer::StartResponse(StatusCode code,
 836                                 PMIMEInfo & headers,
 837                                 long bodySize)
 838 {
 839   if (connectInfo.majorVersion < 1)
 840     return FALSE;
 841
 842   httpStatusCodeStruct dummyInfo;
 843   const httpStatusCodeStruct * statusInfo;
 844   if (connectInfo.commandCode < NumCommands)
 845     statusInfo = GetStatusCodeStruct(code);
 846   else {
 847     dummyInfo.text = "";
 848     dummyInfo.code = code;
 849     dummyInfo.allowedBody = TRUE;
 850     dummyInfo.majorVersion = connectInfo.majorVersion;
 851     dummyInfo.minorVersion = connectInfo.minorVersion;
 852     statusInfo = &dummyInfo;
 853   }
 854
 855   // output the command line
 856   *this << "HTTP/" << connectInfo.majorVersion << '.' << connectInfo.minorVersion
 857         << ' ' << statusInfo->code << ' ' << statusInfo->text << "\r\n";
 858
 859   BOOL chunked = FALSE;
 860
 861   // If do not have user set content length, decide if we should add one
 862   if (!headers.Contains(ContentLengthTag)) {
 863     if (connectInfo.minorVersion < 1) {
 864       // v1.0 client, don't put in ContentLength if the bodySize is zero because
 865       // that can be confused by some browsers as meaning there is no body length.
 866       if (bodySize > 0)
 867         headers.SetAt(ContentLengthTag, bodySize);
 868     }
 869     else {
 870       // v1.1 or later, see if will use chunked output
 871       chunked = bodySize == P_MAX_INDEX;
 872       if (chunked)
 873         headers.SetAt(TransferEncodingTag, ChunkedTag);
 874       else if (bodySize >= 0 && bodySize < P_MAX_INDEX)
 875         headers.SetAt(ContentLengthTag, bodySize);
 876     }
 877   }
 878
 879   *this << setfill('\r') << headers;
 880
 881 #ifdef STRANGE_NETSCAPE_BUG
 882   // The following is a work around for a strange bug in Netscape where it
 883   // locks up when a persistent connection is made and data less than 1k
 884   // (including MIME headers) is sent. Go figure....
 885   if (bodySize < 1024 && connectInfo.GetMIME()(UserAgentTag).Find("Mozilla/2.0") != P_MAX_INDEX)
 886     nextTimeout.SetInterval(STRANGE_NETSCAPE_BUG*1000);
 887 #endif
 888
 889   return chunked;
 890 }
 891
 892
 893 void PHTTPServer::SetDefaultMIMEInfo(PMIMEInfo & info,
 894                      const PHTTPConnectionInfo & connectInfo)
 895 {
 896   PTime now;
 897   if (!info.Contains(DateTag))
 898     info.SetAt(DateTag, now.AsString(PTime::RFC1123, PTime::GMT));
 899   if (!info.Contains(MIMEVersionTag))
 900     info.SetAt(MIMEVersionTag, "1.0");
 901   if (!info.Contains(ServerTag))
 902     info.SetAt(ServerTag, GetServerName());
 903
 904   if (connectInfo.IsPersistant()) {
 905     if (connectInfo.IsProxyConnection()) {
 906       PTRACE(5, "HTTPServer\tSetting proxy persistant response");
 907       info.SetAt(ProxyConnectionTag, KeepAliveTag);
 908     }
 909     else {
 910       PTRACE(5, "HTTPServer\tSetting direct persistant response");
 911       info.SetAt(ConnectionTag, KeepAliveTag);
 912     }
 913   }
 914 }
 915
 916
 917
 918 BOOL PHTTPServer::OnUnknown(const PCaselessString & cmd,
 919                         const PHTTPConnectionInfo & connectInfo)
 920 {
 921   return OnError(NotImplemented, cmd, connectInfo);
 922 }
 923
 924
 925 BOOL PHTTPServer::OnError(StatusCode code,
 926              const PCaselessString & extra,
 927          const PHTTPConnectionInfo & connectInfo)
 928 {
 929   const httpStatusCodeStruct * statusInfo = GetStatusCodeStruct(code);
 930
 931   if (!connectInfo.IsCompatible(statusInfo->majorVersion, statusInfo->minorVersion))
 932     statusInfo = GetStatusCodeStruct((code/100)*100);
 933
 934   PMIMEInfo headers;
 935   SetDefaultMIMEInfo(headers, connectInfo);
 936
 937   if (!statusInfo->allowedBody) {
 938     StartResponse(code, headers, 0);
 939     return statusInfo->code == RequestOK;
 940   }
 941
 942   PString reply;
 943   if (extra.Find("<body") != P_MAX_INDEX)
 944     reply = extra;
 945   else {
 946     PHTML html;
 947     html << PHTML::Title()
 948          << statusInfo->code
 949          << ' '
 950          << statusInfo->text
 951          << PHTML::Body()
 952          << PHTML::Heading(1)
 953          << statusInfo->code
 954          << ' '
 955          << statusInfo->text
 956          << PHTML::Heading(1)
 957          << extra
 958          << PHTML::Body();
 959     reply = html;
 960   }
 961
 962   headers.SetAt(ContentTypeTag, "text/html");
 963   StartResponse(code, headers, reply.GetLength());
 964   WriteString(reply);
 965   return statusInfo->code == RequestOK;
 966 }
 967
 968
 969 //////////////////////////////////////////////////////////////////////////////
 970 // PHTTPSimpleAuth
 971
 972 void PHTTPAuthority::DecodeBasicAuthority(const PString & authInfo,
 973                                           PString & username,
 974                                           PString & password)
 975 {
 976   PString decoded;
 977   if (authInfo(0, 5) *= "Basic ")
 978     decoded = PBase64::Decode(authInfo(6, P_MAX_INDEX));
 979   else
 980     decoded = PBase64::Decode(authInfo);
 981
 982   PINDEX colonPos = decoded.Find(':');
 983   if (colonPos == P_MAX_INDEX) {
 984     username = decoded;
 985     password = PString();
 986   }
 987   else {
 988     username = decoded.Left(colonPos).Trim();
 989     password = decoded.Mid(colonPos+1).Trim();
 990   }
 991 }
 992
 993
 994 BOOL PHTTPAuthority::IsActive() const
 995 {
 996   return TRUE;
 997 }
 998
 999
1000 //////////////////////////////////////////////////////////////////////////////
1001 // PHTTPSimpleAuth
1002
1003 PHTTPSimpleAuth::PHTTPSimpleAuth(const PString & realm_,
1004                                  const PString & username_,
1005                                  const PString & password_)
1006   : realm(realm_), username(username_), password(password_)
1007 {
1008   PAssert(!realm, "Must have a realm!");
1009 }
1010
1011
1012 PObject * PHTTPSimpleAuth::Clone() const
1013 {
1014   return new PHTTPSimpleAuth(realm, username, password);
1015 }
1016
1017
1018 BOOL PHTTPSimpleAuth::IsActive() const
1019 {
1020   return !username || !password;
1021 }
1022
1023
1024 PString PHTTPSimpleAuth::GetRealm(const PHTTPRequest &) const
1025 {
1026   return realm;
1027 }
1028
1029
1030 BOOL PHTTPSimpleAuth::Validate(const PHTTPRequest &,
1031                                const PString & authInfo) const
1032 {
1033   PString user, pass;
1034   DecodeBasicAuthority(authInfo, user, pass);
1035   return username == user && password == pass;
1036 }
1037
1038
1039 //////////////////////////////////////////////////////////////////////////////
1040 // PHTTPMultiSimpAuth
1041
1042 PHTTPMultiSimpAuth::PHTTPMultiSimpAuth(const PString & realm_)
1043   : realm(realm_)
1044 {
1045   PAssert(!realm, "Must have a realm!");
1046 }
1047
1048
1049 PHTTPMultiSimpAuth::PHTTPMultiSimpAuth(const PString & realm_,
1050                                        const PStringToString & users_)
1051   : realm(realm_), users(users_)
1052 {
1053   PAssert(!realm, "Must have a realm!");
1054 }
1055
1056
1057 PObject * PHTTPMultiSimpAuth::Clone() const
1058 {
1059   return new PHTTPMultiSimpAuth(realm, users);
1060 }
1061
1062
1063 BOOL PHTTPMultiSimpAuth::IsActive() const
1064 {
1065   return !users.IsEmpty();
1066 }
1067
1068
1069 PString PHTTPMultiSimpAuth::GetRealm(const PHTTPRequest &) const
1070 {
1071   return realm;
1072 }
1073
1074
1075 BOOL PHTTPMultiSimpAuth::Validate(const PHTTPRequest &,
1076                                   const PString & authInfo) const
1077 {
1078   PString user, pass;
1079   DecodeBasicAuthority(authInfo, user, pass);
1080   return users.Contains(user) && users[user] == pass;
1081 }
1082
1083
1084 void PHTTPMultiSimpAuth::AddUser(const PString & username, const PString & password)
1085 {
1086   users.SetAt(username, password);
1087 }
1088
1089
1090 //////////////////////////////////////////////////////////////////////////////
1091 // PHTTPRequest
1092
1093 PHTTPRequest::PHTTPRequest(const PURL & _url,
1094                       const PMIMEInfo & _mime,
1095         const PMultipartFormInfoArray & _multipartFormInfo,
1096                           PHTTPServer & _server)
1097   : server(_server),
1098     url(_url),
1099     inMIME(_mime),
1100     multipartFormInfo(_multipartFormInfo),
1101     origin(0),
1102     localAddr(0),
1103     localPort(0)
1104 {
1105   code        = PHTTP::RequestOK;
1106   contentSize = P_MAX_INDEX;
1107
1108   PIPSocket * socket = server.GetSocket();
1109   if (socket != NULL) {
1110     socket->GetPeerAddress(origin);
1111     socket->GetLocalAddress(localAddr, localPort);
1112   }
1113 }
1114
1115
1116 //////////////////////////////////////////////////////////////////////////////
1117 // PHTTPConnectionInfo
1118
1119 PHTTPConnectionInfo::PHTTPConnectionInfo()
1120   : persistenceTimeout(0, DEFAULT_PERSIST_TIMEOUT) // maximum lifetime (in seconds) of persistant connections
1121 {
1122   // maximum lifetime (in transactions) of persistant connections
1123   persistenceMaximum = DEFAULT_PERSIST_TRANSATIONS;
1124
1125   commandCode       = PHTTP::NumCommands;
1126
1127   majorVersion      = 0;
1128   minorVersion      = 9;
1129
1130   isPersistant      = FALSE;
1131   wasPersistant     = FALSE;
1132   isProxyConnection = FALSE;
1133
1134   entityBodyLength  = -1;
1135
1136   multipartFormInfoArray.AllowDeleteObjects();
1137 }
1138
1139
1140 BOOL PHTTPConnectionInfo::Initialise(PHTTPServer & server, PString & args)
1141 {
1142   // if only one argument, then it must be a version 0.9 simple request
1143   PINDEX lastSpacePos = args.FindLast(' ');
1144   static const PCaselessString httpId = "HTTP/";
1145   if (lastSpacePos == P_MAX_INDEX || httpId != args(lastSpacePos+1, lastSpacePos+5)) {
1146     majorVersion = 0;
1147     minorVersion = 9;
1148     return TRUE;
1149   }
1150
1151   // otherwise, attempt to extract a version number
1152   PCaselessString verStr = args.Mid(lastSpacePos + 6);
1153   PINDEX dotPos = verStr.Find('.');
1154   if (dotPos == 0 || dotPos >= verStr.GetLength()) {
1155     server.OnError(PHTTP::BadRequest, "Malformed version number: " + verStr, *this);
1156     return FALSE;
1157   }
1158
1159   // should actually check if the text contains only digits, but the
1160   // chances of matching everything else and it not being a valid number
1161   // are pretty small, so don't bother
1162   majorVersion = (int)verStr.Left(dotPos).AsInteger();
1163   minorVersion = (int)verStr.Mid(dotPos+1).AsInteger();
1164   args.Delete(lastSpacePos, P_MAX_INDEX);
1165
1166   // build our connection info reading MIME info until an empty line is
1167   // received, or EOF
1168   if (!mimeInfo.Read(server))
1169     return FALSE;
1170
1171   wasPersistant = isPersistant;
1172   isPersistant = FALSE;
1173
1174   PString str;
1175
1176   // check for Proxy-Connection and Connection strings
1177   isProxyConnection = mimeInfo.Contains(PHTTP::ProxyConnectionTag);
1178   if (isProxyConnection)
1179     str = mimeInfo[PHTTP::ProxyConnectionTag];
1180   else if (mimeInfo.Contains(PHTTP::ConnectionTag))
1181     str = mimeInfo[PHTTP::ConnectionTag];
1182
1183   // get any connection options
1184   if (!str) {
1185     PStringArray tokens = str.Tokenise(", \r\n", FALSE);
1186     for (PINDEX z = 0; !isPersistant && z < tokens.GetSize(); z++)
1187       isPersistant = isPersistant || (tokens[z] *= PHTTP::KeepAliveTag);
1188   }
1189
1190   // If the protocol is version 1.0 or greater, there is MIME info, and the
1191   // prescence of a an entity body is signalled by the inclusion of
1192   // Content-Length header. If the protocol is less than version 1.0, then
1193   // there is no entity body!
1194
1195   // if the client specified a persistant connection, then use the
1196   // ContentLength field. If there is no content length field, then
1197   // assume a ContentLength of zero and close the connection.
1198   // The spec actually says to read until end of file in this case,
1199   // but Netscape hangs if this is done.
1200   // If the client didn't specify a persistant connection, then use the
1201   // ContentLength if there is one or read until end of file if there isn't
1202   if (!isPersistant)
1203     entityBodyLength = mimeInfo.GetInteger(PHTTP::ContentLengthTag,
1204                                            (commandCode == PHTTP::POST) ? -2 : 0);
1205   else {
1206     entityBodyLength = mimeInfo.GetInteger(PHTTP::ContentLengthTag, -1);
1207     if (entityBodyLength < 0) {
1208       PTRACE(5, "HTTPServer\tPersistant connection has no content length");
1209       entityBodyLength = 0;
1210       mimeInfo.SetAt(PHTTP::ContentLengthTag, "0");
1211     }
1212   }
1213
1214   return TRUE;
1215 }
1216
1217
1218 void PHTTPConnectionInfo::SetMIME(const PString & tag, const PString & value)
1219 {
1220   mimeInfo.MakeUnique();
1221   mimeInfo.SetAt(tag, value);
1222 }
1223
1224
1225 BOOL PHTTPConnectionInfo::IsCompatible(int major, int minor) const
1226 {
1227   if (minor == 0 && major == 0)
1228     return TRUE;
1229   else
1230     return (majorVersion > major) ||
1231            ((majorVersion == major) && (minorVersion >= minor));
1232 }
1233
1234
1235 //////////////////////////////////////////////////////////////////////////////
1236 // PHTTPResource
1237
1238 PHTTPResource::PHTTPResource(const PURL & url)
1239   : baseURL(url)
1240 {
1241   authority = NULL;
1242   hitCount = 0;
1243 }
1244
1245
1246 PHTTPResource::PHTTPResource(const PURL & url, const PHTTPAuthority & auth)
1247   : baseURL(url)
1248 {
1249   authority = (PHTTPAuthority *)auth.Clone();
1250   hitCount = 0;
1251 }
1252
1253
1254 PHTTPResource::PHTTPResource(const PURL & url, const PString & type)
1255   : baseURL(url), contentType(type)
1256 {
1257   authority = NULL;
1258   hitCount = 0;
1259 }
1260
1261
1262 PHTTPResource::PHTTPResource(const PURL & url,
1263                              const PString & type,
1264                              const PHTTPAuthority & auth)
1265   : baseURL(url), contentType(type)
1266 {
1267   authority = (PHTTPAuthority *)auth.Clone();
1268   hitCount = 0;
1269 }
1270
1271
1272 PHTTPResource::~PHTTPResource()
1273 {
1274   delete authority;
1275 }
1276
1277
1278 BOOL PHTTPResource::OnGET(PHTTPServer & server,
1279                            const PURL & url,
1280                       const PMIMEInfo & info,
1281             const PHTTPConnectionInfo & connectInfo)
1282 {
1283   return OnGETOrHEAD(server, url, info, connectInfo, TRUE);
1284 }
1285
1286
1287 BOOL PHTTPResource::OnHEAD(PHTTPServer & server,
1288                            const PURL & url,
1289                       const PMIMEInfo & info,
1290             const PHTTPConnectionInfo & connectInfo)
1291 {
1292   return OnGETOrHEAD(server, url, info, connectInfo, FALSE);
1293 }
1294
1295
1296 BOOL PHTTPResource::OnGETOrHEAD(PHTTPServer & server,
1297                            const PURL & url,
1298                       const PMIMEInfo & info,
1299             const PHTTPConnectionInfo & connectInfo,
1300                                    BOOL isGET)
1301 {
1302   // Nede to split songle if into 2 so the Tornado compiler won't end with
1303   // 'internal compiler error'
1304   if (isGET && info.Contains(PHTTP::IfModifiedSinceTag))
1305     if (!IsModifiedSince(PTime(info[PHTTP::IfModifiedSinceTag])))
1306       return server.OnError(PHTTP::NotModified, url.AsString(), connectInfo);
1307
1308   PHTTPRequest * request = CreateRequest(url,
1309                                          info,
1310                                          connectInfo.GetMultipartFormInfo(),
1311                                          server);
1312
1313   BOOL retVal = TRUE;
1314   if (CheckAuthority(server, *request, connectInfo)) {
1315     retVal = FALSE;
1316     server.SetDefaultMIMEInfo(request->outMIME, connectInfo);
1317
1318     PTime expiryDate;
1319     if (GetExpirationDate(expiryDate))
1320       request->outMIME.SetAt(PHTTP::ExpiresTag,
1321                               expiryDate.AsString(PTime::RFC1123, PTime::GMT));
1322
1323     if (!LoadHeaders(*request))
1324       retVal = server.OnError(request->code, url.AsString(), connectInfo);
1325     else if (!isGET)
1326       retVal = request->outMIME.Contains(PHTTP::ContentLengthTag);
1327     else {
1328       hitCount++;
1329       retVal = OnGETData(server, url, connectInfo, *request);
1330     }
1331   }
1332
1333   delete request;
1334   return retVal;
1335 }
1336
1337
1338 BOOL PHTTPResource::OnGETData(PHTTPServer & /*server*/,
1339                                const PURL & /*url*/,
1340                 const PHTTPConnectionInfo & /*connectInfo*/,
1341                              PHTTPRequest & request)
1342 {
1343   SendData(request);
1344   return request.outMIME.Contains(PHTTP::ContentLengthTag) ||
1345          request.outMIME.Contains(PHTTP::TransferEncodingTag);
1346 }
1347
1348
1349 BOOL PHTTPResource::OnPOST(PHTTPServer & server,
1350                             const PURL & url,
1351                        const PMIMEInfo & info,
1352                  const PStringToString & data,
1353              const PHTTPConnectionInfo & connectInfo)
1354 {
1355   PHTTPRequest * request = CreateRequest(url,
1356                                          info,
1357                                          connectInfo.GetMultipartFormInfo(),
1358                                          server);
1359
1360   request->entityBody = connectInfo.GetEntityBody();
1361
1362   BOOL persist = TRUE;
1363   if (CheckAuthority(server, *request, connectInfo)) {
1364     server.SetDefaultMIMEInfo(request->outMIME, connectInfo);
1365     persist = OnPOSTData(*request, data);
1366     if (request->code != PHTTP::RequestOK)
1367       persist = server.OnError(request->code, "", connectInfo) && persist;
1368   }
1369
1370   delete request;
1371   return persist;
1372 }
1373
1374
1375 BOOL PHTTPResource::OnPOSTData(PHTTPRequest & request,
1376                                const PStringToString & data)
1377 {
1378   PHTML msg;
1379   BOOL persist = Post(request, data, msg);
1380
1381   if (msg.Is(PHTML::InBody))
1382     msg << PHTML::Body();
1383
1384   if (request.code != PHTTP::RequestOK)
1385     return persist;
1386
1387   if (msg.IsEmpty())
1388     msg << PHTML::Title()    << (unsigned)PHTTP::RequestOK << " OK" << PHTML::Body()
1389         << PHTML::Heading(1) << (unsigned)PHTTP::RequestOK << " OK" << PHTML::Heading(1)
1390         << PHTML::Body();
1391
1392   request.outMIME.SetAt(PHTTP::ContentTypeTag, "text/html");
1393
1394   PINDEX len = msg.GetLength();
1395   request.server.StartResponse(request.code, request.outMIME, len);
1396   return request.server.Write((const char *)msg, len) && persist;
1397 }
1398
1399
1400 BOOL PHTTPResource::CheckAuthority(PHTTPServer & server,
1401                             const PHTTPRequest & request,
1402                      const PHTTPConnectionInfo & connectInfo)
1403 {
1404   if (authority == NULL)
1405     return TRUE;
1406
1407   return CheckAuthority(*authority, server, request, connectInfo);
1408 }
1409
1410
1411 BOOL PHTTPResource::CheckAuthority(PHTTPAuthority & authority,
1412                                       PHTTPServer & server,
1413                                const PHTTPRequest & request,
1414                         const PHTTPConnectionInfo & connectInfo)
1415 {
1416   if (!authority.IsActive())
1417     return TRUE;
1418
1419
1420   // if this is an authorisation request...
1421   if (request.inMIME.Contains(PHTTP::AuthorizationTag) &&
1422       authority.Validate(request, request.inMIME[PHTTP::AuthorizationTag]))
1423     return TRUE;
1424
1425   // it must be a request for authorisation
1426   PMIMEInfo headers;
1427   server.SetDefaultMIMEInfo(headers, connectInfo);
1428   headers.SetAt(PHTTP::WWWAuthenticateTag,
1429                        "Basic realm=\"" + authority.GetRealm(request) + "\"");
1430   headers.SetAt(PHTTP::ContentTypeTag, "text/html");
1431
1432   const httpStatusCodeStruct * statusInfo =
1433                                GetStatusCodeStruct(PHTTP::UnAuthorised);
1434
1435   PHTML reply;
1436   reply << PHTML::Title()
1437         << statusInfo->code
1438         << ' '
1439         << statusInfo->text
1440         << PHTML::Body()
1441         << PHTML::Heading(1)
1442         << statusInfo->code
1443         << ' '
1444         << statusInfo->text
1445         << PHTML::Heading(1)
1446         << "Your request cannot be authorised because it requires authentication."
1447         << PHTML::Paragraph()
1448         << "This may be because you entered an incorrect username or password, "
1449         << "or because your browser is not performing Basic authentication."
1450         << PHTML::Body();
1451
1452   server.StartResponse(PHTTP::UnAuthorised, headers, reply.GetLength());
1453   server.WriteString(reply);
1454
1455   return FALSE;
1456 }
1457
1458
1459 void PHTTPResource::SetAuthority(const PHTTPAuthority & auth)
1460 {
1461   delete authority;
1462   authority = (PHTTPAuthority *)auth.Clone();
1463 }
1464
1465
1466 void PHTTPResource::ClearAuthority()
1467 {
1468   delete authority;
1469   authority = NULL;
1470 }
1471
1472
1473 BOOL PHTTPResource::IsModifiedSince(const PTime &)
1474 {
1475   return TRUE;
1476 }
1477
1478
1479 BOOL PHTTPResource::GetExpirationDate(PTime &)
1480 {
1481   return FALSE;
1482 }
1483
1484
1485 PHTTPRequest * PHTTPResource::CreateRequest(const PURL & url,
1486                                             const PMIMEInfo & inMIME,
1487                                             const PMultipartFormInfoArray & multipartFormInfo,
1488                                             PHTTPServer & socket)
1489 {
1490   return new PHTTPRequest(url, inMIME, multipartFormInfo, socket);
1491 }
1492
1493
1494 static void WriteChunkedDataToServer(PHTTPServer & server, PCharArray & data)
1495 {
1496   if (data.GetSize() == 0)
1497     return;
1498
1499   server << data.GetSize() << "\r\n";
1500   server.Write(data, data.GetSize());
1501   server << "\r\n";
1502   data.SetSize(0);
1503 }
1504
1505
1506 void PHTTPResource::SendData(PHTTPRequest & request)
1507 {
1508   if (!request.outMIME.Contains(PHTTP::ContentTypeTag) && !contentType)
1509     request.outMIME.SetAt(PHTTP::ContentTypeTag, contentType);
1510
1511   PCharArray data;
1512   if (LoadData(request, data)) {
1513     if (request.server.StartResponse(request.code, request.outMIME, request.contentSize)) {
1514       // Chunked transfer encoding
1515       request.outMIME.RemoveAll();
1516       do {
1517         WriteChunkedDataToServer(request.server, data);
1518       } while (LoadData(request, data));
1519       WriteChunkedDataToServer(request.server, data);
1520       request.server << "0\r\n" << request.outMIME;
1521     }
1522     else {
1523       do {
1524         request.server.Write(data, data.GetSize());
1525         data.SetSize(0);
1526       } while (LoadData(request, data));
1527       request.server.Write(data, data.GetSize());
1528     }
1529   }
1530   else {
1531     request.server.StartResponse(request.code, request.outMIME, data.GetSize());
1532     request.server.Write(data, data.GetSize());
1533   }
1534 }
1535
1536
1537 BOOL PHTTPResource::LoadData(PHTTPRequest & request, PCharArray & data)
1538 {
1539   PString text = LoadText(request);
1540   OnLoadedText(request, text);
1541   text.SetSize(text.GetLength());  // Lose the trailing '\0'
1542   data = text;
1543   return FALSE;
1544 }
1545
1546
1547 PString PHTTPResource::LoadText(PHTTPRequest &)
1548 {
1549   PAssertAlways(PUnimplementedFunction);
1550   return PString();
1551 }
1552
1553
1554 void PHTTPResource::OnLoadedText(PHTTPRequest &, PString &)
1555 {
1556   // Do nothing
1557 }
1558
1559
1560 BOOL PHTTPResource::Post(PHTTPRequest & request,
1561                          const PStringToString &,
1562                          PHTML & msg)
1563 {
1564   request.code = PHTTP::MethodNotAllowed;
1565   msg = "Error in POST";
1566   msg << "Post to this resource is not allowed" << PHTML::Body();
1567   return TRUE;
1568 }
1569
1570
1571 //////////////////////////////////////////////////////////////////////////////
1572 // PHTTPString
1573
1574 PHTTPString::PHTTPString(const PURL & url)
1575   : PHTTPResource(url, "text/html")
1576 {
1577 }
1578
1579
1580 PHTTPString::PHTTPString(const PURL & url,
1581                          const PHTTPAuthority & auth)
1582   : PHTTPResource(url, "text/html", auth)
1583 {
1584 }
1585
1586
1587 PHTTPString::PHTTPString(const PURL & url, const PString & str)
1588   : PHTTPResource(url, "text/html"), string(str)
1589 {
1590 }
1591
1592
1593 PHTTPString::PHTTPString(const PURL & url,
1594                          const PString & str,
1595                          const PString & type)
1596   : PHTTPResource(url, type), string(str)
1597 {
1598 }
1599
1600
1601 PHTTPString::PHTTPString(const PURL & url,
1602                          const PString & str,
1603                          const PHTTPAuthority & auth)
1604   : PHTTPResource(url, "text/html", auth), string(str)
1605 {
1606 }
1607
1608
1609 PHTTPString::PHTTPString(const PURL & url,
1610                          const PString & str,
1611                          const PString & type,
1612                          const PHTTPAuthority & auth)
1613   : PHTTPResource(url, type, auth), string(str)
1614 {
1615 }
1616
1617
1618 BOOL PHTTPString::LoadHeaders(PHTTPRequest & request)
1619 {
1620   request.contentSize = string.GetLength();
1621   return TRUE;
1622 }
1623
1624
1625 PString PHTTPString::LoadText(PHTTPRequest &)
1626 {
1627   return string;
1628 }
1629
1630
1631 //////////////////////////////////////////////////////////////////////////////
1632 // PHTTPFile
1633
1634 PHTTPFile::PHTTPFile(const PURL & url, int)
1635   : PHTTPResource(url)
1636 {
1637 }
1638
1639
1640 PHTTPFile::PHTTPFile(const PString & filename)
1641   : PHTTPResource(filename, PMIMEInfo::GetContentType(PFilePath(filename).GetType())),
1642     filePath(filename)
1643 {
1644 }
1645
1646
1647 PHTTPFile::PHTTPFile(const PString & filename, const PHTTPAuthority & auth)
1648   : PHTTPResource(filename, auth), filePath(filename)
1649 {
1650 }
1651
1652
1653 PHTTPFile::PHTTPFile(const PURL & url, const PFilePath & path)
1654   : PHTTPResource(url, PMIMEInfo::GetContentType(path.GetType())),
1655     filePath(path)
1656 {
1657 }
1658
1659
1660 PHTTPFile::PHTTPFile(const PURL & url,
1661                      const PFilePath & path,
1662                      const PString & type)
1663   : PHTTPResource(url, type), filePath(path)
1664 {
1665 }
1666
1667
1668 PHTTPFile::PHTTPFile(const PURL & url,
1669                      const PFilePath & path,
1670                      const PHTTPAuthority & auth)
1671   : PHTTPResource(url, PMIMEInfo::GetContentType(path.GetType()), auth),
1672     filePath(path)
1673 {
1674 }
1675
1676
1677 PHTTPFile::PHTTPFile(const PURL & url,
1678                      const PFilePath & path,
1679                      const PString & type,
1680                      const PHTTPAuthority & auth)
1681   : PHTTPResource(url, type, auth), filePath(path)
1682 {
1683 }
1684
1685
1686 PHTTPFileRequest::PHTTPFileRequest(const PURL & url,
1687                                    const PMIMEInfo & inMIME,
1688                                    const PMultipartFormInfoArray & multipartFormInfo,
1689                                    PHTTPServer & server)
1690   : PHTTPRequest(url, inMIME, multipartFormInfo, server)
1691 {
1692 }
1693
1694
1695 PHTTPRequest * PHTTPFile::CreateRequest(const PURL & url,
1696                                         const PMIMEInfo & inMIME,
1697                           const PMultipartFormInfoArray & multipartFormInfo,
1698                                         PHTTPServer & server)
1699 {
1700   return new PHTTPFileRequest(url, inMIME, multipartFormInfo, server);
1701 }
1702
1703
1704 BOOL PHTTPFile::LoadHeaders(PHTTPRequest & request)
1705 {
1706   PFile & file = ((PHTTPFileRequest&)request).file;
1707
1708   if (!file.Open(filePath, PFile::ReadOnly)) {
1709     request.code = PHTTP::NotFound;
1710     return FALSE;
1711   }
1712
1713   request.contentSize = file.GetLength();
1714   return TRUE;
1715 }
1716
1717
1718 BOOL PHTTPFile::LoadData(PHTTPRequest & request, PCharArray & data)
1719 {
1720   PFile & file = ((PHTTPFileRequest&)request).file;
1721
1722   PString contentType = GetContentType();
1723   if (contentType.IsEmpty())
1724     contentType = PMIMEInfo::GetContentType(file.GetFilePath().GetType());
1725
1726   if (contentType(0, 4) *= "text/")
1727     return PHTTPResource::LoadData(request, data);
1728
1729   PAssert(file.IsOpen(), PLogicError);
1730
1731   PINDEX count = file.GetLength() - file.GetPosition();
1732   if (count > 10000)
1733     count = 10000;
1734
1735   if (count > 0)
1736     PAssert(file.Read(data.GetPointer(count), count), PLogicError);
1737
1738   if (!file.IsEndOfFile())
1739     return TRUE;
1740
1741   file.Close();
1742   return FALSE;
1743 }
1744
1745
1746 PString PHTTPFile::LoadText(PHTTPRequest & request)
1747 {
1748   PFile & file = ((PHTTPFileRequest&)request).file;
1749   PAssert(file.IsOpen(), PLogicError);
1750   PINDEX count = file.GetLength();
1751   PString text;
1752   if (count > 0)
1753     PAssert(file.Read(text.GetPointer(count+1), count), PLogicError);
1754   PAssert(file.Close(), PLogicError);
1755   return text;
1756 }
1757
1758
1759 //////////////////////////////////////////////////////////////////////////////
1760 // PHTTPTailFile
1761
1762 PHTTPTailFile::PHTTPTailFile(const PString & filename)
1763   : PHTTPFile(filename)
1764 {
1765 }
1766
1767
1768 PHTTPTailFile::PHTTPTailFile(const PString & filename,
1769                              const PHTTPAuthority & auth)
1770   : PHTTPFile(filename, auth)
1771 {
1772 }
1773
1774
1775 PHTTPTailFile::PHTTPTailFile(const PURL & url,
1776                              const PFilePath & file)
1777   : PHTTPFile(url, file)
1778 {
1779 }
1780
1781
1782 PHTTPTailFile::PHTTPTailFile(const PURL & url,
1783                              const PFilePath & file,
1784                              const PString & contentType)
1785   : PHTTPFile(url, file, contentType)
1786 {
1787 }
1788
1789
1790 PHTTPTailFile::PHTTPTailFile(const PURL & url,
1791                              const PFilePath & file,
1792                              const PHTTPAuthority & auth)
1793   : PHTTPFile(url, file, auth)
1794 {
1795 }
1796
1797
1798 PHTTPTailFile::PHTTPTailFile(const PURL & url,
1799                              const PFilePath & file,
1800                              const PString & contentType,
1801                              const PHTTPAuthority & auth)
1802   : PHTTPFile(url, file, contentType, auth)
1803 {
1804 }
1805
1806
1807 BOOL PHTTPTailFile::LoadHeaders(PHTTPRequest & request)
1808 {
1809   if (!PHTTPFile::LoadHeaders(request))
1810     return FALSE;
1811
1812   request.contentSize = P_MAX_INDEX;
1813   return TRUE;
1814 }
1815
1816
1817 BOOL PHTTPTailFile::LoadData(PHTTPRequest & request, PCharArray & data)
1818 {
1819   PFile & file = ((PHTTPFileRequest&)request).file;
1820
1821   if (file.GetPosition() == 0)
1822     file.SetPosition(file.GetLength()-request.url.GetQueryVars()("offset", "10000").AsUnsigned());
1823
1824   while (file.GetPosition() >= file.GetLength()) {
1825     if (!request.server.Write(NULL, 0))
1826       return FALSE;
1827     PThread::Sleep(200);
1828   }
1829
1830   PINDEX count = file.GetLength() - file.GetPosition();
1831   return file.Read(data.GetPointer(count), count);
1832 }
1833
1834
1835 //////////////////////////////////////////////////////////////////////////////
1836 // PHTTPDirectory
1837
1838 PHTTPDirectory::PHTTPDirectory(const PURL & url, const PDirectory & dir)
1839   : PHTTPFile(url, 0), basePath(dir), allowDirectoryListing(TRUE)
1840 {
1841 }
1842
1843
1844 PHTTPDirectory::PHTTPDirectory(const PURL & url,
1845                                const PDirectory & dir,
1846                                const PHTTPAuthority & auth)
1847   : PHTTPFile(url, PString(), auth), basePath(dir), allowDirectoryListing(TRUE)
1848 {
1849 }
1850
1851
1852 PHTTPDirRequest::PHTTPDirRequest(const PURL & url,
1853                                  const PMIMEInfo & inMIME,
1854                                  const PMultipartFormInfoArray & multipartFormInfo,
1855                                  PHTTPServer & server)
1856   : PHTTPFileRequest(url, inMIME, multipartFormInfo, server)
1857 {
1858 }
1859
1860
1861 PHTTPRequest * PHTTPDirectory::CreateRequest(const PURL & url,
1862                                         const PMIMEInfo & inMIME,
1863                           const PMultipartFormInfoArray & multipartFormInfo,
1864                                             PHTTPServer & socket)
1865 {
1866   PHTTPDirRequest * request = new PHTTPDirRequest(url, inMIME, multipartFormInfo, socket);
1867
1868   const PStringArray & path = url.GetPath();
1869   request->realPath = basePath;
1870   PINDEX i;
1871   for (i = GetURL().GetPath().GetSize(); i < path.GetSize()-1; i++)
1872     request->realPath += path[i] + PDIR_SEPARATOR;
1873
1874   // append the last path element
1875   if (i < path.GetSize())
1876     request->realPath += path[i];
1877
1878   if (request->realPath.Find(basePath) != 0)
1879     request->realPath = basePath;
1880
1881   return request;
1882 }
1883
1884
1885 void PHTTPDirectory::EnableAuthorisation(const PString & realm)
1886 {
1887   authorisationRealm = realm;
1888 }
1889
1890
1891 BOOL PHTTPDirectory::FindAuthorisations(const PDirectory & dir, PString & realm, PStringToString & authorisations)
1892 {
1893   PFilePath fn = dir + accessFilename;
1894   PTextFile file;
1895   BOOL first = TRUE;
1896   if (file.Open(fn, PFile::ReadOnly)) {
1897     PString line;
1898     while (file.ReadLine(line)) {
1899       if (first) {
1900         realm = line.Trim();
1901         first = FALSE;
1902       } else {
1903         PStringArray tokens = line.Tokenise(':');
1904         if (tokens.GetSize() > 1)
1905           authorisations.SetAt(tokens[0].Trim(), tokens[1].Trim());
1906       }
1907     }
1908     return TRUE;
1909   }
1910
1911   if (dir.IsRoot() || (dir == basePath))
1912     return FALSE;
1913
1914   return FindAuthorisations(dir.GetParent(), realm, authorisations);
1915 }
1916
1917 BOOL PHTTPDirectory::CheckAuthority(PHTTPServer & server,
1918                              const PHTTPRequest & request,
1919                       const PHTTPConnectionInfo & conInfo)
1920 {
1921   // if access control is enabled, then search parent directories for password files
1922   PStringToString authorisations;
1923   PString newRealm;
1924   if (authorisationRealm.IsEmpty() ||
1925       !FindAuthorisations(((PHTTPDirRequest&)request).realPath.GetDirectory(), newRealm, authorisations) ||
1926       authorisations.GetSize() == 0)
1927     return TRUE;
1928
1929   PHTTPMultiSimpAuth authority(newRealm, authorisations);
1930   return PHTTPResource::CheckAuthority(authority, server, request, conInfo);
1931 }
1932
1933 BOOL PHTTPDirectory::LoadHeaders(PHTTPRequest & request)
1934 {
1935   PFilePath & realPath = ((PHTTPDirRequest&)request).realPath;
1936
1937   // if not able to obtain resource information, then consider the resource "not found"
1938   PFileInfo info;
1939   if (!PFile::GetInfo(realPath, info)) {
1940     request.code = PHTTP::NotFound;
1941     return FALSE;
1942   }
1943
1944   // if the resource is a file, and the file can't be opened, then return "not found"
1945   PFile & file = ((PHTTPDirRequest&)request).file;
1946   if (info.type != PFileInfo::SubDirectory) {
1947     if (!file.Open(realPath, PFile::ReadOnly) ||
1948         (!authorisationRealm.IsEmpty() && realPath.GetFileName() == accessFilename)) {
1949       request.code = PHTTP::NotFound;
1950       return FALSE;
1951     }
1952   }
1953
1954   // resource is a directory - if index files disabled, then return "not found"
1955   else if (!allowDirectoryListing) {
1956     request.code = PHTTP::NotFound;
1957     return FALSE;
1958   }
1959
1960   // else look for index files
1961   else {
1962     PINDEX i;
1963     for (i = 0; i < PARRAYSIZE(HTMLIndexFiles); i++)
1964       if (file.Open(realPath +
1965                           PDIR_SEPARATOR + HTMLIndexFiles[i], PFile::ReadOnly))
1966         break;
1967   }
1968
1969   // open the file and return information
1970   PString & fakeIndex = ((PHTTPDirRequest&)request).fakeIndex;
1971   if (file.IsOpen()) {
1972     request.outMIME.SetAt(PHTTP::ContentTypeTag,
1973                           PMIMEInfo::GetContentType(file.GetFilePath().GetType()));
1974     request.contentSize = file.GetLength();
1975     fakeIndex = PString();
1976     return TRUE;
1977   }
1978
1979   // construct a directory listing
1980   request.outMIME.SetAt(PHTTP::ContentTypeTag, "text/html");
1981   PHTML reply("Directory of " + request.url.AsString());
1982   PDirectory dir = realPath;
1983   if (dir.Open()) {
1984     do {
1985       const char * imgName;
1986       if (dir.IsSubDir())
1987         imgName = "internal-gopher-menu";
1988       else if (PMIMEInfo::GetContentType(
1989                     PFilePath(dir.GetEntryName()).GetType())(0,4) == "text/")
1990         imgName = "internal-gopher-text";
1991       else
1992         imgName = "internal-gopher-unknown";
1993       reply << PHTML::Image(imgName) << ' '
1994             << PHTML::HotLink(realPath.GetFileName()+'/'+dir.GetEntryName())
1995             << dir.GetEntryName()
1996             << PHTML::HotLink()
1997             << PHTML::BreakLine();
1998     } while (dir.Next());
1999   }
2000   reply << PHTML::Body();
2001   fakeIndex = reply;
2002
2003   return TRUE;
2004 }
2005
2006
2007 PString PHTTPDirectory::LoadText(PHTTPRequest & request)
2008 {
2009   PString & fakeIndex = ((PHTTPDirRequest&)request).fakeIndex;
2010   if (fakeIndex.IsEmpty())
2011     return PHTTPFile::LoadText(request);
2012
2013   return fakeIndex;
2014 }
2015
2016
2017 // End Of File ///////////////////////////////////////////////////////////////