开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
httpsrvr.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：46k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

httpsrvr.cxx：源码内容
  1. /*
  2.  * httpsrvr.cxx
  3.  *
  4.  * HTTP server classes.
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 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.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: httpsrvr.cxx,v $
  30.  * Revision 1.32  2000/05/02 07:55:22  craigs
  31.  * Changed static PString to static const char * to avoid "memory leak"
  32.  *
  33.  * Revision 1.31  1999/05/13 04:04:04  robertj
  34.  * Fixed problem of initialised commandName in ConnectionInfo.
  35.  *
  36.  * Revision 1.30  1999/05/12 01:40:47  robertj
  37.  * Fixed "unknown" response codes being passed on when used with an "unknown" command.
  38.  *
  39.  * Revision 1.29  1999/05/11 12:23:22  robertj
  40.  * Fixed search for persistent connection to accept kee-alive on multile MIME fields.
  41.  *
  42.  * Revision 1.28  1999/05/04 15:26:01  robertj
  43.  * Improved HTTP/1.1 compatibility (pass through user commands).
  44.  * Fixed problems with quicktime installer.
  45.  *
  46.  * Revision 1.27  1999/04/24 11:50:11  robertj
  47.  * Changed HTTP command parser so will work if some idiot puts spaces in a URL.
  48.  *
  49.  * Revision 1.26  1999/04/21 01:58:08  robertj
  50.  * Fixed problem with reading data for request using second form of PHTTPRequestInfo constructor.
  51.  *
  52.  * Revision 1.25  1998/11/30 04:51:59  robertj
  53.  * New directory structure
  54.  *
  55.  * Revision 1.24  1998/11/14 01:11:38  robertj
  56.  * PPC linux GNU compatibility.
  57.  *
  58.  * Revision 1.23  1998/10/31 12:49:23  robertj
  59.  * Added read/write mutex to the HTTP space variable to avoid thread crashes.
  60.  *
  61.  * Revision 1.22  1998/10/25 01:02:41  craigs
  62.  * Added ability to specify per-directory authorisation for PHTTPDirectory
  63.  *
  64.  * Revision 1.21  1998/10/13 14:06:23  robertj
  65.  * Complete rewrite of memory leak detection code.
  66.  *
  67.  * Revision 1.20  1998/09/23 06:22:13  robertj
  68.  * Added open source copyright license.
  69.  *
  70.  * Revision 1.19  1998/08/06 00:54:22  robertj
  71.  * Fixed bug in sending empty files, caused endless wait in Netscape.
  72.  *
  73.  * Revision 1.18  1998/06/16 03:32:14  robertj
  74.  * Propagated persistence and proxy flags in new connection info instances.
  75.  *
  76.  * Revision 1.17  1998/04/01 01:55:16  robertj
  77.  * Fixed bug when serving HTTPFile that has zero bytes in it.
  78.  *
  79.  * Revision 1.16  1998/02/03 06:24:10  robertj
  80.  * Added local address and port to PHTTPRequest.
  81.  * Fixed bug in default entity length. should be read to EOF.
  82.  * Fixed OnError() so can detec HTML bosy tag with parameters.
  83.  *
  84.  * Revision 1.14  1998/01/26 00:42:19  robertj
  85.  * Added more information to PHTTPConnectionInfo.
  86.  * Made SetDefaultMIMEFields in HTTP Server not set those fields if already set.
  87.  *
  88.  * Revision 1.13  1997/10/30 10:22:04  robertj
  89.  * Added multiple user basic authorisation scheme.
  90.  *
  91.  * Revision 1.12  1997/10/03 13:39:25  robertj
  92.  * Fixed race condition on socket close in Select() function.
  93.  *
  94.  * Revision 1.12  1997/10/03 13:31:12  craigs
  95.  * Added ability to access client socket from within HTTP resources
  96.  *
  97.  * Revision 1.11  1997/08/04 10:44:36  robertj
  98.  * Improved receiving of a POST on a non-persistant connection, do not wait for EOF if have CRLF.
  99.  *
  100.  * Revision 1.10  1997/07/14 11:47:13  robertj
  101.  * Added "const" to numerous variables.
  102.  *
  103.  * Revision 1.9  1997/07/08 13:10:26  robertj
  104.  * Fixed bug in HTTP server where standard error text is not sent to remote client.
  105.  *
  106.  * Revision 1.8  1997/04/15 14:32:19  robertj
  107.  * Fixed case problem for HTTP version string.
  108.  *
  109.  * Revision 1.7  1997/03/20 13:01:32  robertj
  110.  * Fixed bug in proxy POST having unexpexted reset of connection.
  111.  *
  112.  * Revision 1.6  1997/02/09 04:09:30  robertj
  113.  * Fixed GCC warning
  114.  *
  115.  * Revision 1.5  1997/01/12 04:15:23  robertj
  116.  * Globalised MIME tag strings.
  117.  *
  118.  * Revision 1.4  1996/12/12 09:24:16  robertj
  119.  * Persistent proxy connection support (work in progress).
  120.  *
  121.  * Revision 1.3  1996/11/10 21:09:33  robertj
  122.  * Removed redundent GetSocket() call.
  123.  * Added flush of stream after processing request, important on persistent connections.
  124.  *
  125.  * Revision 1.2  1996/10/26 03:31:05  robertj
  126.  * Changed OnError so can pass in full HTML page as parameter.
  127.  *
  128.  * Revision 1.1  1996/09/14 13:02:18  robertj
  129.  * Initial revision
  130.  *
  131.  */
  133. #include <ptlib.h>
  134. #include <ptlib/sockets.h>
  135. #include <ptclib/http.h>
  136. #include <ctype.h>
  138. #define new PNEW
  141. // undefine to remove support for persistant connections
  142. #define HAS_PERSISTANCE
  144. // define to enable work-around for Netscape persistant connection bug
  145. // set to lifetime of suspect sockets (in seconds)
  146. #define STRANGE_NETSCAPE_BUG 3
  148. // maximum lifetime (in seconds) of persistant connections
  149. #define MAX_LIFETIME 30
  151. // maximum lifetime (in transactions) of persistant connections
  152. #define MAX_TRANSACTIONS 10
  154. // maximum delay between characters whilst reading a line of text
  155. #define READLINE_TIMEOUT 30
  157. //  filename to use for directory access directives
  158. static const char * accessFilename = "_access";
  161. //////////////////////////////////////////////////////////////////////////////
  162. // PHTTPSpace
  164. PHTTPSpace::PHTTPSpace()
  165. {
  166.   mutex = new PReadWriteMutex;
  167.   root = new Node(PString(), NULL);
  168. }
  171. void PHTTPSpace::DestroyContents()
  172. {
  173.   delete mutex;
  174.   delete root;
  175. }
  178. void PHTTPSpace::CloneContents(const PHTTPSpace * c)
  179. {
  180.   mutex = new PReadWriteMutex;
  181.   root = new Node(*c->root);
  182. }
  185. void PHTTPSpace::CopyContents(const PHTTPSpace & c)
  186. {
  187.   mutex = c.mutex;
  188.   root = c.root;
  189. }
  192. PHTTPSpace::Node::Node(const PString & nam, Node * parentNode)
  193.   : PString(nam)
  194. {
  195.   parent = parentNode;
  196.   resource = NULL;
  197. }
  200. PHTTPSpace::Node::~Node()
  201. {
  202.   delete resource;
  203. }
  206. BOOL PHTTPSpace::AddResource(PHTTPResource * res, AddOptions overwrite)
  207. {
  208.   PAssert(res != NULL, PInvalidParameter);
  209.   const PStringArray & path = res->GetURL().GetPath();
  210.   Node * node = root;
  211.   for (PINDEX i = 0; i < path.GetSize(); i++) {
  212.     if (path[i].IsEmpty())
  213.       break;
  215.     if (node->resource != NULL)
  216.       return FALSE;   // Already a resource in tree in partial path
  218.     PINDEX pos = node->children.GetValuesIndex(path[i]);
  219.     if (pos == P_MAX_INDEX)
  220.       pos = node->children.Append(new Node(path[i], node));
  222.     node = &node->children[pos];
  223.   }
  225.   if (!node->children.IsEmpty())
  226.     return FALSE;   // Already a resource in tree further down path.
  228.   if (overwrite == ErrorOnExist && node->resource != NULL)
  229.     return FALSE;   // Already a resource in tree at leaf
  231.   delete node->resource;
  232.   node->resource = res;
  234.   return TRUE;
  235. }
  238. BOOL PHTTPSpace::DelResource(const PURL & url)
  239. {
  240.   const PStringArray & path = url.GetPath();
  241.   Node * node = root;
  242.   for (PINDEX i = 0; i < path.GetSize(); i++) {
  243.     if (path[i].IsEmpty())
  244.       break;
  246.     PINDEX pos = node->children.GetValuesIndex(path[i]);
  247.     if (pos == P_MAX_INDEX)
  248.       return FALSE;
  250.     node = &node->children[pos];
  252.     if (node->resource != NULL)
  253.       return FALSE;
  254.   }
  256.   if (!node->children.IsEmpty())
  257.     return FALSE;   // Still a resource in tree further down path.
  259.   do {
  260.     Node * par = node->parent;
  261.     par->children.Remove(node);
  262.     node = par;
  263.   } while (node != NULL && node->children.IsEmpty());
  265.   return TRUE;
  266. }
  269. static const char * const HTMLIndexFiles[] = {
  270.   "Welcome.html", "welcome.html", "index.html",
  271.   "Welcome.htm",  "welcome.htm",  "index.htm"
  272. };
  274. PHTTPResource * PHTTPSpace::FindResource(const PURL & url)
  275. {
  276.   const PStringArray & path = url.GetPath();
  278.   Node * node = root;
  279.   PINDEX i;
  280.   for (i = 0; i < path.GetSize(); i++) {
  281.     if (path[i].IsEmpty())
  282.       break;
  284.     PINDEX pos = node->children.GetValuesIndex(path[i]);
  285.     if (pos == P_MAX_INDEX)
  286.       return NULL;
  288.     node = &node->children[pos];
  290.     if (node->resource != NULL)
  291.       return node->resource;
  292.   }
  294.   for (i = 0; i < PARRAYSIZE(HTMLIndexFiles); i++) {
  295.     PINDEX pos = node->children.GetValuesIndex(PString(HTMLIndexFiles[i]));
  296.     if (pos != P_MAX_INDEX)
  297.       return node->children[pos].resource;
  298.   }
  300.   return NULL;
  301. }
  304. //////////////////////////////////////////////////////////////////////////////
  305. // PHTTPServer
  307. PHTTPServer::PHTTPServer()
  308. {
  309.   Construct();
  310. }
  313. PHTTPServer::PHTTPServer(const PHTTPSpace & space)
  314.   : urlSpace(space)
  315. {
  316.   Construct();
  317. }
  320. void PHTTPServer::Construct()
  321. {
  322.   transactionCount = 0;
  323.   SetReadLineTimeout(PTimeInterval(0, READLINE_TIMEOUT));
  324. }
  327. BOOL PHTTPServer::ProcessCommand()
  328. {
  329.   PString args;
  330.   PINDEX cmd;
  332.   // if this is not the first command received by this socket, then set
  333.   // the read timeout appropriately.
  334.   if (transactionCount > 0) 
  335.     SetReadTimeout(nextTimeout);
  337.   // this will only return false upon timeout or completely invalid command
  338.   if (!ReadCommand(cmd, args))
  339.     return FALSE;
  341.   connectInfo.commandCode = (Commands)cmd;
  342.   if (cmd < NumCommands)
  343.     connectInfo.commandName = commandNames[cmd];
  344.   else {
  345.     PINDEX spacePos = args.Find(' ');
  346.     connectInfo.commandName = args.Left(spacePos);
  347.     args = args.Mid(spacePos);
  348.   }
  350.   // if no tokens, error
  351.   if (args.IsEmpty()) {
  352.     OnError(BadRequest, args, connectInfo);
  353.     return FALSE;
  354.   }
  356.   if (!connectInfo.Initialise(*this, args))
  357.       return FALSE;
  359.   // now that we've decided we did receive a HTTP request, increment the
  360.   // count of transactions
  361.   transactionCount++;
  362.   nextTimeout.SetInterval(MAX_LIFETIME*1000);
  364.   PIPSocket * socket = GetSocket();
  365.   WORD myPort = (WORD)(socket != NULL ? socket->GetPort() : 80);
  367.   // the URL that comes with Connect requests is not quite kosher, so 
  368.   // mangle it into a proper URL and do NOT close the connection.
  369.   // for all other commands, close the read connection if not persistant
  370.   if (cmd == CONNECT) 
  371.     connectInfo.url = "https://" + args;
  372.   else {
  373.     connectInfo.url = args;
  374.     if (connectInfo.url.GetPort() == 0)
  375.       connectInfo.url.SetPort(myPort);
  376.   }
  378.   BOOL persist;
  380.   // If the incoming URL is of a proxy type then call OnProxy() which will
  381.   // probably just go OnError(). Even if a full URL is provided in the
  382.   // command we should check to see if it is a local server request and process
  383.   // it anyway even though we are not a proxy. The usage of GetHostName()
  384.   // below are to catch every way of specifying the host (name, alias, any of
  385.   // several IP numbers etc).
  386.   const PURL & url = connectInfo.GetURL();
  387.   if (url.GetScheme() != "http" ||
  388.       (url.GetPort() != 0 && url.GetPort() != myPort) ||
  389.       (!url.GetHostName() && !PIPSocket::IsLocalHost(url.GetHostName())))
  390.     persist = OnProxy(connectInfo);
  391.   else {
  392.     PString entityBody = ReadEntityBody();
  394.     // Handle the local request
  395.     PStringToString postData;
  396.     switch (cmd) {
  397.       case GET :
  398.         persist = OnGET(url, connectInfo.GetMIME(), connectInfo);
  399.         break;
  401.       case HEAD :
  402.         persist = OnHEAD(url, connectInfo.GetMIME(), connectInfo);
  403.         break;
  405.       case POST :
  406.         PURL::SplitQueryVars(entityBody, postData);
  407.         persist = OnPOST(url, connectInfo.GetMIME(), postData, connectInfo);
  408.         break;
  410.       case P_MAX_INDEX:
  411.       default:
  412.         persist = OnUnknown(args, connectInfo);
  413.     }
  414.   }
  416.   flush();
  418.   // if the function just indicated that the connection is to persist,
  419.   // and so did the client, then return TRUE. Note that all of the OnXXXX
  420.   // routines above must make sure that their return value is FALSE if
  421.   // if there was no ContentLength field in the response. This ensures that
  422.   // we always close the socket so the client will get the correct end of file
  423.   if (persist &&
  424.       connectInfo.IsPersistant() &&
  425.       transactionCount < MAX_TRANSACTIONS)
  426.     return TRUE;
  428. //  if (connectInfo.IsPersistant())
  429. //    PError << "Server: connection persistance end" << endl;
  431.   // close the output stream now and return FALSE
  432.   Shutdown(ShutdownWrite);
  433.   return FALSE;
  434. }
  437. PString PHTTPServer::ReadEntityBody()
  438. {
  439.   if (connectInfo.GetMajorVersion() < 1)
  440.     return PString();
  442.   PString entityBody;
  443.   long contentLength = connectInfo.GetEntityBodyLength();
  444.   // a content length of > 0 means read explicit length
  445.   // a content length of < 0 means read until EOF
  446.   // a content length of 0 means read nothing
  447.   int count = 0;
  448.   if (contentLength > 0) {
  449.     entityBody = ReadString((PINDEX)contentLength);
  450.   } else if (contentLength == -2) {
  451.     ReadLine(entityBody, FALSE);
  452.   } else if (contentLength < 0) {
  453.     while (Read(entityBody.GetPointer(count+1000)+count, 1000))
  454.       count += GetLastReadCount();
  455.     entityBody.SetSize(count+1);
  456.   }
  458.   // close the connection, if not persistant
  459.   if (!connectInfo.IsPersistant()) {
  460.     PIPSocket * socket = GetSocket();
  461.     if (socket != NULL)
  462.       socket->Shutdown(PIPSocket::ShutdownRead);
  463.   }
  465.   return entityBody;
  466. }
  469. PString PHTTPServer::GetServerName() const
  470. {
  471.   return "PWLib-HTTP-Server/1.0 PWLib/1.0";
  472. }
  475. void PHTTPServer::SetURLSpace(const PHTTPSpace & space)
  476. {
  477.   urlSpace = space;
  478. }
  481. BOOL PHTTPServer::OnGET(const PURL & url,
  482.                    const PMIMEInfo & info,
  483.          const PHTTPConnectionInfo & connectInfo)
  484. {
  485.   urlSpace.StartRead();
  486.   PHTTPResource * resource = urlSpace.FindResource(url);
  487.   if (resource == NULL) {
  488.     urlSpace.EndRead();
  489.     return OnError(NotFound, url.AsString(), connectInfo);
  490.   }
  492.   BOOL retval = resource->OnGET(*this, url, info, connectInfo);
  493.   urlSpace.EndRead();
  494.   return retval;
  495. }
  498. BOOL PHTTPServer::OnHEAD(const PURL & url,
  499.                     const PMIMEInfo & info,
  500.           const PHTTPConnectionInfo & connectInfo)
  501. {
  502.   urlSpace.StartRead();
  503.   PHTTPResource * resource = urlSpace.FindResource(url);
  504.   if (resource == NULL) {
  505.     urlSpace.EndRead();
  506.     return OnError(NotFound, url.AsString(), connectInfo);
  507.   }
  509.   BOOL retval = resource->OnHEAD(*this, url, info, connectInfo);
  510.   urlSpace.EndRead();
  511.   return retval;
  512. }
  515. BOOL PHTTPServer::OnPOST(const PURL & url,
  516.                     const PMIMEInfo & info,
  517.               const PStringToString & data,
  518.           const PHTTPConnectionInfo & connectInfo)
  519. {
  520.   urlSpace.StartRead();
  521.   PHTTPResource * resource = urlSpace.FindResource(url);
  522.   if (resource == NULL) {
  523.     urlSpace.EndRead();
  524.     return OnError(NotFound, url.AsString(), connectInfo);
  525.   }
  527.   BOOL retval = resource->OnPOST(*this, url, info, data, connectInfo);
  528.   urlSpace.EndRead();
  529.   return retval;
  530. }
  533. BOOL PHTTPServer::OnProxy(const PHTTPConnectionInfo & connectInfo)
  534. {
  535.   return OnError(BadGateway, "Proxy not implemented.", connectInfo) &&
  536.          connectInfo.GetCommandCode() != CONNECT;
  537. }
  540. struct httpStatusCodeStruct {
  541.   const char * text;
  542.   int  code;
  543.   BOOL allowedBody;
  544.   int  majorVersion;
  545.   int  minorVersion;
  546. };
  548. static const httpStatusCodeStruct * GetStatusCodeStruct(int code)
  549. {
  550.   static const httpStatusCodeStruct httpStatusDefn[] = {
  551.     // First entry MUST be InternalServerError
  552.     { "Internal Server Error",         PHTTP::InternalServerError, 1 },
  553.     { "OK",                            PHTTP::OK, 1 },
  554.     { "Unauthorised",                  PHTTP::UnAuthorised, 1 },
  555.     { "Forbidden",                     PHTTP::Forbidden, 1 },
  556.     { "Not Found",                     PHTTP::NotFound, 1 },
  557.     { "Not Modified",                  PHTTP::NotModified },
  558.     { "No Content",                    PHTTP::NoContent },
  559.     { "Bad Gateway",                   PHTTP::BadGateway, 1 },
  560.     { "Bad Request",                   PHTTP::BadRequest, 1 },
  561.     { "Continue",                      PHTTP::Continue, 1, 1, 1 },
  562.     { "Switching Protocols",           PHTTP::SwitchingProtocols, 1, 1, 1 },
  563.     { "Created",                       PHTTP::Created, 1 },
  564.     { "Accepted",                      PHTTP::Accepted, 1 },
  565.     { "Non-Authoritative Information", PHTTP::NonAuthoritativeInformation, 1, 1, 1 },
  566.     { "Reset Content",                 PHTTP::ResetContent, 0, 1, 1 },
  567.     { "Partial Content",               PHTTP::PartialContent, 1, 1, 1 },
  568.     { "Multiple Choices",              PHTTP::MultipleChoices, 1, 1, 1 },
  569.     { "Moved Permanently",             PHTTP::MovedPermanently, 1 },
  570.     { "Moved Temporarily",             PHTTP::MovedTemporarily, 1 },
  571.     { "See Other",                     PHTTP::SeeOther, 1, 1, 1 },
  572.     { "Use Proxy",                     PHTTP::UseProxy, 1, 1, 1 },
  573.     { "Payment Required",              PHTTP::PaymentRequired, 1, 1, 1 },
  574.     { "Method Not Allowed",            PHTTP::MethodNotAllowed, 1, 1, 1 },
  575.     { "None Acceptable",               PHTTP::NoneAcceptable, 1, 1, 1 },
  576.     { "Proxy Authetication Required",  PHTTP::ProxyAuthenticationRequired, 1, 1, 1 },
  577.     { "Request Timeout",               PHTTP::RequestTimeout, 1, 1, 1 },
  578.     { "Conflict",                      PHTTP::Conflict, 1, 1, 1 },
  579.     { "Gone",                          PHTTP::Gone, 1, 1, 1 },
  580.     { "Length Required",               PHTTP::LengthRequired, 1, 1, 1 },
  581.     { "Unless True",                   PHTTP::UnlessTrue, 1, 1, 1 },
  582.     { "Not Implemented",               PHTTP::NotImplemented, 1 },
  583.     { "Service Unavailable",           PHTTP::ServiceUnavailable, 1, 1, 1 },
  584.     { "Gateway Timeout",               PHTTP::GatewayTimeout, 1, 1, 1 }
  585.   };
  587.   // make sure the error code is valid
  588.   for (PINDEX i = 0; i < PARRAYSIZE(httpStatusDefn); i++)
  589.     if (code == httpStatusDefn[i].code)
  590.       return &httpStatusDefn[i];
  592.   return httpStatusDefn;
  593. }
  596. void PHTTPServer::StartResponse(StatusCode code,
  597.                                 PMIMEInfo & headers,
  598.                                 long bodySize)
  599. {
  600.   if (connectInfo.majorVersion < 1) 
  601.     return;
  603.   httpStatusCodeStruct dummyInfo;
  604.   const httpStatusCodeStruct * statusInfo;
  605.   if (connectInfo.commandCode < NumCommands)
  606.     statusInfo = GetStatusCodeStruct(code);
  607.   else {
  608.     dummyInfo.text = "";
  609.     dummyInfo.code = code;
  610.     dummyInfo.allowedBody = TRUE;
  611.     dummyInfo.majorVersion = connectInfo.majorVersion;
  612.     dummyInfo.minorVersion = connectInfo.minorVersion;
  613.     statusInfo = &dummyInfo;
  614.   }
  616.   // output the command line
  617.   *this << "HTTP/" << connectInfo.majorVersion << '.' << connectInfo.minorVersion
  618.         << ' ' << statusInfo->code << ' ' << statusInfo->text << "rn";
  620.   // output the headers. But don't put in ContentLength if the bodysize is zero
  621.   // because that can be confused by some browsers as meaning there is no body length.
  622.   if (bodySize > 0 && !headers.Contains(ContentLengthTag))
  623.     headers.SetAt(ContentLengthTag, PString(PString::Unsigned, (PINDEX)bodySize));
  624.   *this << setfill('r') << headers;
  626. #ifdef STRANGE_NETSCAPE_BUG
  627.   // The following is a work around for a strange bug in Netscape where it
  628.   // locks up when a persistent connection is made and data less than 1k
  629.   // (including MIME headers) is sent. Go figure....
  630.   if (bodySize < 1024 && connectInfo.GetMIME()(UserAgentTag).Find("Mozilla/2.0") != P_MAX_INDEX)
  631.     nextTimeout.SetInterval(STRANGE_NETSCAPE_BUG*1000);
  632. #endif
  633. }
  636. void PHTTPServer::SetDefaultMIMEInfo(PMIMEInfo & info,
  637.                      const PHTTPConnectionInfo & connectInfo)
  638. {
  639.   PTime now;
  640.   if (!info.Contains(DateTag))
  641.     info.SetAt(DateTag, now.AsString(PTime::RFC1123, PTime::GMT));
  642.   if (!info.Contains(MIMEVersionTag))
  643.     info.SetAt(MIMEVersionTag, "1.0");
  644.   if (!info.Contains(ServerTag))
  645.     info.SetAt(ServerTag, GetServerName());
  647.   if (connectInfo.IsPersistant()) {
  648.     if (connectInfo.IsProxyConnection())
  649. //{      PError << "Server: setting proxy persistant response" << endl;
  650.       info.SetAt(ProxyConnectionTag, KeepAliveTag);
  651. //    }
  652.     else
  653. //{      PError << "Server: setting direct persistant response" << endl;
  654.       info.SetAt(ConnectionTag, KeepAliveTag);
  655. //    }
  656.   }
  657. }
  661. BOOL PHTTPServer::OnUnknown(const PCaselessString & cmd, 
  662.                         const PHTTPConnectionInfo & connectInfo)
  663. {
  664.   return OnError(NotImplemented, cmd, connectInfo);
  665. }
  668. BOOL PHTTPServer::OnError(StatusCode code,
  669.              const PCaselessString & extra,
  670.          const PHTTPConnectionInfo & connectInfo)
  671. {
  672.   const httpStatusCodeStruct * statusInfo = GetStatusCodeStruct(code);
  674.   if (!connectInfo.IsCompatible(statusInfo->majorVersion, statusInfo->minorVersion))
  675.     statusInfo = GetStatusCodeStruct((code/100)*100);
  677.   PMIMEInfo headers;
  678.   SetDefaultMIMEInfo(headers, connectInfo);
  680.   if (!statusInfo->allowedBody) {
  681.     StartResponse(code, headers, 0);
  682.     return statusInfo->code == OK;
  683.   }
  685.   PString reply;
  686.   if (extra.Find("<body") != P_MAX_INDEX)
  687.     reply = extra;
  688.   else {
  689.     PHTML html;
  690.     html << PHTML::Title()
  691.          << statusInfo->code
  692.          << ' '
  693.          << statusInfo->text
  694.          << PHTML::Body()
  695.          << PHTML::Heading(1)
  696.          << statusInfo->code
  697.          << ' '
  698.          << statusInfo->text
  699.          << PHTML::Heading(1)
  700.          << extra
  701.          << PHTML::Body();
  702.     reply = html;
  703.   }
  705.   headers.SetAt(ContentTypeTag, "text/html");
  706.   StartResponse(code, headers, reply.GetLength());
  707.   WriteString(reply);
  708.   return statusInfo->code == OK;
  709. }
  712. //////////////////////////////////////////////////////////////////////////////
  713. // PHTTPSimpleAuth
  715. void PHTTPAuthority::DecodeBasicAuthority(const PString & authInfo,
  716.                                           PString & username,
  717.                                           PString & password)
  718. {
  719.   PString decoded;
  720.   if (authInfo(0, 5) *= "Basic ")
  721.     decoded = PBase64::Decode(authInfo(6, P_MAX_INDEX));
  722.   else
  723.     decoded = PBase64::Decode(authInfo);
  725.   PINDEX colonPos = decoded.Find(':');
  726.   if (colonPos == P_MAX_INDEX) {
  727.     username = decoded;
  728.     password = PString();
  729.   }
  730.   else {
  731.     username = decoded.Left(colonPos).Trim();
  732.     password = decoded.Mid(colonPos+1).Trim();
  733.   }
  734. }
  737. BOOL PHTTPAuthority::IsActive() const
  738. {
  739.   return TRUE;
  740. }
  743. //////////////////////////////////////////////////////////////////////////////
  744. // PHTTPSimpleAuth
  746. PHTTPSimpleAuth::PHTTPSimpleAuth(const PString & realm_,
  747.                                  const PString & username_,
  748.                                  const PString & password_)
  749.   : realm(realm_), username(username_), password(password_)
  750. {
  751.   PAssert(!realm, "Must have a realm!");
  752. }
  755. PObject * PHTTPSimpleAuth::Clone() const
  756. {
  757.   return new PHTTPSimpleAuth(realm, username, password);
  758. }
  761. BOOL PHTTPSimpleAuth::IsActive() const
  762. {
  763.   return !username || !password;
  764. }
  767. PString PHTTPSimpleAuth::GetRealm(const PHTTPRequest &) const
  768. {
  769.   return realm;
  770. }
  773. BOOL PHTTPSimpleAuth::Validate(const PHTTPRequest &,
  774.                                const PString & authInfo) const
  775. {
  776.   PString user, pass;
  777.   DecodeBasicAuthority(authInfo, user, pass);
  778.   return username == user && password == pass;
  779. }
  782. //////////////////////////////////////////////////////////////////////////////
  783. // PHTTPMultiSimpAuth
  785. PHTTPMultiSimpAuth::PHTTPMultiSimpAuth(const PString & realm_)
  786.   : realm(realm_)
  787. {
  788.   PAssert(!realm, "Must have a realm!");
  789. }
  792. PHTTPMultiSimpAuth::PHTTPMultiSimpAuth(const PString & realm_,
  793.                                        const PStringToString & users_)
  794.   : realm(realm_), users(users_)
  795. {
  796.   PAssert(!realm, "Must have a realm!");
  797. }
  800. PObject * PHTTPMultiSimpAuth::Clone() const
  801. {
  802.   return new PHTTPMultiSimpAuth(realm, users);
  803. }
  806. BOOL PHTTPMultiSimpAuth::IsActive() const
  807. {
  808.   return !users.IsEmpty();
  809. }
  812. PString PHTTPMultiSimpAuth::GetRealm(const PHTTPRequest &) const
  813. {
  814.   return realm;
  815. }
  818. BOOL PHTTPMultiSimpAuth::Validate(const PHTTPRequest &,
  819.                                   const PString & authInfo) const
  820. {
  821.   PString user, pass;
  822.   DecodeBasicAuthority(authInfo, user, pass);
  823.   return users.Contains(user) && users[user] == pass;
  824. }
  827. void PHTTPMultiSimpAuth::AddUser(const PString & username, const PString & password)
  828. {
  829.   users.SetAt(username, password);
  830. }
  833. //////////////////////////////////////////////////////////////////////////////
  834. // PHTTPRequest
  836. PHTTPRequest::PHTTPRequest(const PURL & u, const PMIMEInfo & iM, PHTTPServer & server)
  837.   : url(u), inMIME(iM), origin(0), localAddr(0), localPort(0)
  838. {
  839.   code        = PHTTP::OK;
  840.   contentSize = 0;
  841.   PIPSocket * socket = server.GetSocket();
  842.   if (socket != NULL) {
  843.     socket->GetPeerAddress(origin);
  844.     socket->GetLocalAddress(localAddr, localPort);
  845.   }
  846. }
  849. //////////////////////////////////////////////////////////////////////////////
  850. // PHTTPConnectionInfo
  852. PHTTPConnectionInfo::PHTTPConnectionInfo()
  853. {
  854.   commandCode       = PHTTP::NumCommands;
  856.   majorVersion      = 0;
  857.   minorVersion      = 9;
  859.   isPersistant      = FALSE;
  860.   isProxyConnection = FALSE;
  862.   entityBodyLength  = -1;
  863. }
  866. BOOL PHTTPConnectionInfo::Initialise(PHTTPServer & server, PString & args)
  867. {
  868.   // if only one argument, then it must be a version 0.9 simple request
  869.   PINDEX lastSpacePos = args.FindLast(' ');
  870.   static const PCaselessString httpId = "HTTP/";
  871.   if (lastSpacePos == P_MAX_INDEX || httpId != args(lastSpacePos+1, lastSpacePos+5)) {
  872.     majorVersion = 0;
  873.     minorVersion = 9;
  874.     return TRUE;
  875.   }
  877.   // otherwise, attempt to extract a version number
  878.   PCaselessString verStr = args.Mid(lastSpacePos + 6);
  879.   PINDEX dotPos = verStr.Find('.');
  880.   if (dotPos == 0 || dotPos >= verStr.GetLength()) {
  881.     server.OnError(PHTTP::BadRequest, "Malformed version number: " + verStr, *this);
  882.     return FALSE;
  883.   }
  885.   // should actually check if the text contains only digits, but the
  886.   // chances of matching everything else and it not being a valid number
  887.   // are pretty small, so don't bother
  888.   majorVersion = (int)verStr.Left(dotPos).AsInteger();
  889.   minorVersion = (int)verStr.Mid(dotPos+1).AsInteger();
  890.   args.Delete(lastSpacePos, P_MAX_INDEX);
  892.   // build our connection info reading MIME info until an empty line is
  893.   // received, or EOF
  894.   if (!mimeInfo.Read(server))
  895.     return FALSE;
  897.   isPersistant      = FALSE;
  899. #ifndef HAS_PERSISTANCE
  900.   isProxyConnection = FALSE;
  901. #else
  902.   PString str;
  903.   // check for Proxy-Connection and Connection strings
  904.   isProxyConnection = mimeInfo.HasKey(PHTTP::ProxyConnectionTag);
  905.   if (isProxyConnection)
  906.     str = mimeInfo[PHTTP::ProxyConnectionTag];
  907.   else if (mimeInfo.HasKey(PHTTP::ConnectionTag))
  908.     str = mimeInfo[PHTTP::ConnectionTag];
  910.   // get any connection options
  911.   if (!str) {
  912.     PStringArray tokens = str.Tokenise(", rn", FALSE);
  913.     for (PINDEX z = 0; !isPersistant && z < tokens.GetSize(); z++)
  914.       isPersistant = isPersistant || (tokens[z] *= PHTTP::KeepAliveTag);
  915.   }
  916. #endif
  917. //    if (connectInfo.IsPersistant()) {
  918. //      if (connectInfo.IsProxyConnection())
  919. //        PError << "Server: Persistant proxy connection received" << endl;
  920. //      else
  921. //        PError << "Server: Persistant direct connection received" << endl;
  922. //    }
  924.   // If the protocol is version 1.0 or greater, there is MIME info, and the
  925.   // prescence of a an entity body is signalled by the inclusion of
  926.   // Content-Length header. If the protocol is less than version 1.0, then 
  927.   // there is no entity body!
  929.   // if the client specified a persistant connection, then use the
  930.   // ContentLength field. If there is no content length field, then
  931.   // assume a ContentLength of zero and close the connection.
  932.   // The spec actually says to read until end of file in this case,
  933.   // but Netscape hangs if this is done.
  934.   // If the client didn't specify a persistant connection, then use the
  935.   // ContentLength if there is one or read until end of file if there isn't
  936.   if (!isPersistant)
  937.     entityBodyLength = mimeInfo.GetInteger(PHTTP::ContentLengthTag,
  938.                                            (commandCode == PHTTP::POST) ? -2 : 0);
  939.   else {
  940.     entityBodyLength = mimeInfo.GetInteger(PHTTP::ContentLengthTag, -1);
  941.     if (entityBodyLength < 0) {
  942. //        PError << "Server: persistant connection has no content length" << endl;
  943.       entityBodyLength = 0;
  944.       mimeInfo.SetAt(PHTTP::ContentLengthTag, "0");
  945.     }
  946.   }
  948.   return TRUE;
  949. }
  952. void PHTTPConnectionInfo::SetMIME(const PString & tag, const PString & value)
  953. {
  954.   mimeInfo.MakeUnique();
  955.   mimeInfo.SetAt(tag, value);
  956. }
  959. void PHTTPConnectionInfo::SetPersistance(BOOL newPersist)
  960. {
  961. #ifdef HAS_PERSISTANCE
  962.   isPersistant = newPersist;
  963. #else
  964.   isPersistant = FALSE;
  965. #endif
  966. }
  969. BOOL PHTTPConnectionInfo::IsCompatible(int major, int minor) const
  970. {
  971.   if (minor == 0 && major == 0)
  972.     return TRUE;
  973.   else
  974.     return (majorVersion > major) ||
  975.            ((majorVersion == major) && (minorVersion >= minor));
  976. }
  979. //////////////////////////////////////////////////////////////////////////////
  980. // PHTTPResource
  982. PHTTPResource::PHTTPResource(const PURL & url)
  983.   : baseURL(url)
  984. {
  985.   authority = NULL;
  986.   hitCount = 0;
  987. }
  990. PHTTPResource::PHTTPResource(const PURL & url, const PHTTPAuthority & auth)
  991.   : baseURL(url)
  992. {
  993.   authority = (PHTTPAuthority *)auth.Clone();
  994.   hitCount = 0;
  995. }
  998. PHTTPResource::PHTTPResource(const PURL & url, const PString & type)
  999.   : baseURL(url), contentType(type)
  1000. {
  1001.   authority = NULL;
  1002.   hitCount = 0;
  1003. }
  1006. PHTTPResource::PHTTPResource(const PURL & url,
  1007.                              const PString & type,
  1008.                              const PHTTPAuthority & auth)
  1009.   : baseURL(url), contentType(type)
  1010. {
  1011.   authority = (PHTTPAuthority *)auth.Clone();
  1012.   hitCount = 0;
  1013. }
  1016. PHTTPResource::~PHTTPResource()
  1017. {
  1018.   delete authority;
  1019. }
  1022. BOOL PHTTPResource::OnGET(PHTTPServer & server,
  1023.                            const PURL & url,
  1024.                       const PMIMEInfo & info,
  1025.             const PHTTPConnectionInfo & connectInfo)
  1026. {
  1027.   return OnGETOrHEAD(server, url, info, connectInfo, TRUE);
  1028. }
  1031. BOOL PHTTPResource::OnHEAD(PHTTPServer & server,
  1032.                            const PURL & url,
  1033.                       const PMIMEInfo & info,
  1034.             const PHTTPConnectionInfo & connectInfo)
  1035. {
  1036.   return OnGETOrHEAD(server, url, info, connectInfo, FALSE);
  1037. }
  1040. BOOL PHTTPResource::OnGETOrHEAD(PHTTPServer & server,
  1041.                            const PURL & url,
  1042.                       const PMIMEInfo & info,
  1043.             const PHTTPConnectionInfo & connectInfo,
  1044.                                    BOOL isGET)
  1045. {
  1046.   if (isGET && info.Contains(PHTTP::IfModifiedSinceTag) &&
  1047.                            !IsModifiedSince(PTime(info[PHTTP::IfModifiedSinceTag]))) 
  1048.     return server.OnError(PHTTP::NotModified, url.AsString(), connectInfo);
  1050.   PHTTPRequest * request = CreateRequest(url, info, server);
  1052.   BOOL retVal = TRUE;
  1053.   if (CheckAuthority(server, *request, connectInfo)) {
  1054.     retVal = FALSE;
  1055.     server.SetDefaultMIMEInfo(request->outMIME, connectInfo);
  1057.     PTime expiryDate;
  1058.     if (GetExpirationDate(expiryDate))
  1059.       request->outMIME.SetAt(PHTTP::ExpiresTag,
  1060.                               expiryDate.AsString(PTime::RFC1123, PTime::GMT));
  1062.     if (!LoadHeaders(*request)) 
  1063.       retVal = server.OnError(request->code, url.AsString(), connectInfo);
  1064.     else if (!isGET)
  1065.       retVal = request->outMIME.Contains(PHTTP::ContentLengthTag);
  1066.     else {
  1067.       hitCount++;
  1068.       retVal = OnGETData(server, url, connectInfo, *request);
  1069.     }
  1070.   }
  1072.   delete request;
  1073.   return retVal;
  1074. }
  1077. BOOL PHTTPResource::OnGETData(PHTTPServer & server,
  1078.                                const PURL & /*url*/,
  1079.                 const PHTTPConnectionInfo & /*connectInfo*/,
  1080.                              PHTTPRequest & request)
  1081. {
  1082.   if (!request.outMIME.Contains(PHTTP::ContentTypeTag) && !contentType)
  1083.     request.outMIME.SetAt(PHTTP::ContentTypeTag, contentType);
  1085.   PCharArray data;
  1086.   if (LoadData(request, data)) {
  1087.     server.StartResponse(request.code, request.outMIME, request.contentSize);
  1088.     do {
  1089.       server.Write(data, data.GetSize());
  1090.       data.SetSize(0);
  1091.     } while (LoadData(request, data));
  1092.   }
  1093.   else
  1094.     server.StartResponse(request.code, request.outMIME, data.GetSize());
  1096.   server.Write(data, data.GetSize());
  1098.   return request.outMIME.Contains(PHTTP::ContentLengthTag);
  1099. }
  1102. BOOL PHTTPResource::OnPOST(PHTTPServer & server,
  1103.                             const PURL & url,
  1104.                        const PMIMEInfo & info,
  1105.                  const PStringToString & data,
  1106.              const PHTTPConnectionInfo & connectInfo)
  1107. {
  1108.   PHTTPRequest * request = CreateRequest(url, info, server);
  1110.   BOOL persist = TRUE;
  1111.   if (CheckAuthority(server, *request, connectInfo)) {
  1112.     PHTML msg;
  1113.     persist = Post(*request, data, msg);
  1115.     if (msg.IsEmpty())
  1116.       persist = server.OnError(request->code, "", connectInfo) && persist;
  1117.     else {
  1118.       if (msg.Is(PHTML::InBody))
  1119.         msg << PHTML::Body();
  1121.       request->outMIME.SetAt(PHTTP::ContentTypeTag, "text/html");
  1123.       PINDEX len = msg.GetLength();
  1124.       server.StartResponse(request->code, request->outMIME, len);
  1125.       persist = server.Write((const char *)msg, len) && persist;
  1126.     }
  1127.   }
  1129.   delete request;
  1130.   return persist;
  1131. }
  1134. BOOL PHTTPResource::CheckAuthority(PHTTPServer & server,
  1135.                             const PHTTPRequest & request,
  1136.                      const PHTTPConnectionInfo & connectInfo)
  1137. {
  1138.   if (authority == NULL)
  1139.     return TRUE;
  1141.   return CheckAuthority(*authority, server, request, connectInfo);
  1142. }
  1143.     
  1144.     
  1145. BOOL PHTTPResource::CheckAuthority(PHTTPAuthority & authority,
  1146.                                       PHTTPServer & server,
  1147.                                const PHTTPRequest & request,
  1148.                         const PHTTPConnectionInfo & connectInfo)
  1149. {
  1150.   if (!authority.IsActive())
  1151.     return TRUE;
  1154.   // if this is an authorisation request...
  1155.   if (request.inMIME.Contains(PHTTP::AuthorizationTag) &&
  1156.       authority.Validate(request, request.inMIME[PHTTP::AuthorizationTag]))
  1157.     return TRUE;
  1159.   // it must be a request for authorisation
  1160.   PMIMEInfo headers;
  1161.   server.SetDefaultMIMEInfo(headers, connectInfo);
  1162.   headers.SetAt(PHTTP::WWWAuthenticateTag,
  1163.                        "Basic realm="" + authority.GetRealm(request) + """);
  1164.   headers.SetAt(PHTTP::ContentTypeTag, "text/html");
  1166.   const httpStatusCodeStruct * statusInfo =
  1167.                                GetStatusCodeStruct(PHTTP::UnAuthorised);
  1169.   PHTML reply;
  1170.   reply << PHTML::Title()
  1171.         << statusInfo->code
  1172.         << ' '
  1173.         << statusInfo->text
  1174.         << PHTML::Body()
  1175.         << PHTML::Heading(1)
  1176.         << statusInfo->code
  1177.         << ' '
  1178.         << statusInfo->text
  1179.         << PHTML::Heading(1)
  1180.         << "Your request cannot be authorised because it requires authentication."
  1181.         << PHTML::Paragraph()
  1182.         << "This may be because you entered an incorrect username or password, "
  1183.         << "or because your browser is not performing Basic authentication."
  1184.         << PHTML::Body();
  1186.   server.StartResponse(PHTTP::UnAuthorised, headers, reply.GetLength());
  1187.   server.WriteString(reply);
  1189.   return FALSE;
  1190. }
  1193. void PHTTPResource::SetAuthority(const PHTTPAuthority & auth)
  1194. {
  1195.   delete authority;
  1196.   authority = (PHTTPAuthority *)auth.Clone();
  1197. }
  1200. void PHTTPResource::ClearAuthority()
  1201. {
  1202.   delete authority;
  1203.   authority = NULL;
  1204. }
  1207. BOOL PHTTPResource::IsModifiedSince(const PTime &)
  1208. {
  1209.   return TRUE;
  1210. }
  1213. BOOL PHTTPResource::GetExpirationDate(PTime &)
  1214. {
  1215.   return FALSE;
  1216. }
  1219. PHTTPRequest * PHTTPResource::CreateRequest(const PURL & url,
  1220.                                             const PMIMEInfo & inMIME,
  1221.             PHTTPServer & socket)
  1222. {
  1223.   return new PHTTPRequest(url, inMIME, socket);
  1224. }
  1227. BOOL PHTTPResource::LoadData(PHTTPRequest & request, PCharArray & data)
  1228. {
  1229.   PString text = LoadText(request);
  1230.   OnLoadedText(request, text);
  1231.   text.SetSize(text.GetLength());  // Lose the trailing ''
  1232.   data = text;
  1233.   return FALSE;
  1234. }
  1237. PString PHTTPResource::LoadText(PHTTPRequest &)
  1238. {
  1239.   PAssertAlways(PUnimplementedFunction);
  1240.   return PString();
  1241. }
  1244. void PHTTPResource::OnLoadedText(PHTTPRequest &, PString &)
  1245. {
  1246.   // Do nothing
  1247. }
  1250. BOOL PHTTPResource::Post(PHTTPRequest & request,
  1251.                          const PStringToString &,
  1252.                          PHTML & msg)
  1253. {
  1254.   request.code = PHTTP::MethodNotAllowed;
  1255.   msg = "Error in POST";
  1256.   msg << "Post to this resource is not allowed" << PHTML::Body();
  1257.   return TRUE;
  1258. }
  1261. //////////////////////////////////////////////////////////////////////////////
  1262. // PHTTPString
  1264. PHTTPString::PHTTPString(const PURL & url)
  1265.   : PHTTPResource(url, "text/html")
  1266. {
  1267. }
  1270. PHTTPString::PHTTPString(const PURL & url,
  1271.                          const PHTTPAuthority & auth)
  1272.   : PHTTPResource(url, "text/html", auth)
  1273. {
  1274. }
  1277. PHTTPString::PHTTPString(const PURL & url, const PString & str)
  1278.   : PHTTPResource(url, "text/html"), string(str)
  1279. {
  1280. }
  1283. PHTTPString::PHTTPString(const PURL & url,
  1284.                          const PString & str,
  1285.                          const PString & type)
  1286.   : PHTTPResource(url, type), string(str)
  1287. {
  1288. }
  1291. PHTTPString::PHTTPString(const PURL & url,
  1292.                          const PString & str,
  1293.                          const PHTTPAuthority & auth)
  1294.   : PHTTPResource(url, "text/html", auth), string(str)
  1295. {
  1296. }
  1299. PHTTPString::PHTTPString(const PURL & url,
  1300.                          const PString & str,
  1301.                          const PString & type,
  1302.                          const PHTTPAuthority & auth)
  1303.   : PHTTPResource(url, type, auth), string(str)
  1304. {
  1305. }
  1308. BOOL PHTTPString::LoadHeaders(PHTTPRequest & request)
  1309. {
  1310.   request.contentSize = string.GetLength();
  1311.   return TRUE;
  1312. }
  1315. PString PHTTPString::LoadText(PHTTPRequest &)
  1316. {
  1317.   return string;
  1318. }
  1321. //////////////////////////////////////////////////////////////////////////////
  1322. // PHTTPFile
  1324. PHTTPFile::PHTTPFile(const PURL & url, int)
  1325.   : PHTTPResource(url)
  1326. {
  1327. }
  1330. PHTTPFile::PHTTPFile(const PString & filename)
  1331.   : PHTTPResource(filename), filePath(filename)
  1332. {
  1333.   SetContentType(PMIMEInfo::GetContentType(filePath.GetType()));
  1334. }
  1337. PHTTPFile::PHTTPFile(const PString & filename, const PHTTPAuthority & auth)
  1338.   : PHTTPResource(filename, auth), filePath(filename)
  1339. {
  1340. }
  1343. PHTTPFile::PHTTPFile(const PURL & url, const PFilePath & path)
  1344.   : PHTTPResource(url), filePath(path)
  1345. {
  1346.   SetContentType(PMIMEInfo::GetContentType(path.GetType()));
  1347. }
  1350. PHTTPFile::PHTTPFile(const PURL & url,
  1351.                      const PFilePath & path,
  1352.                      const PString & type)
  1353.   : PHTTPResource(url, type), filePath(path)
  1354. {
  1355. }
  1358. PHTTPFile::PHTTPFile(const PURL & url,
  1359.                      const PFilePath & path,
  1360.                      const PHTTPAuthority & auth)
  1361.   : PHTTPResource(url, PString(), auth), filePath(path)
  1362. {
  1363.   SetContentType(PMIMEInfo::GetContentType(filePath.GetType()));
  1364. }
  1367. PHTTPFile::PHTTPFile(const PURL & url,
  1368.                      const PFilePath & path,
  1369.                      const PString & type,
  1370.                      const PHTTPAuthority & auth)
  1371.   : PHTTPResource(url, type, auth), filePath(path)
  1372. {
  1373. }
  1376. PHTTPFileRequest::PHTTPFileRequest(const PURL & url,
  1377.                                    const PMIMEInfo & inMIME,
  1378.                                    PHTTPServer & server)
  1379.   : PHTTPRequest(url, inMIME, server)
  1380. {
  1381. }
  1384. PHTTPRequest * PHTTPFile::CreateRequest(const PURL & url,
  1385.                                         const PMIMEInfo & inMIME,
  1386.         PHTTPServer & server)
  1387. {
  1388.   return new PHTTPFileRequest(url, inMIME, server);
  1389. }
  1392. BOOL PHTTPFile::LoadHeaders(PHTTPRequest & request)
  1393. {
  1394.   PFile & file = ((PHTTPFileRequest&)request).file;
  1396.   if (!file.Open(filePath, PFile::ReadOnly)) {
  1397.     request.code = PHTTP::NotFound;
  1398.     return FALSE;
  1399.   }
  1401.   request.contentSize = file.GetLength();
  1402.   return TRUE;
  1403. }
  1406. BOOL PHTTPFile::LoadData(PHTTPRequest & request, PCharArray & data)
  1407. {
  1408.   if (contentType(0, 4) == "text/")
  1409.     return PHTTPResource::LoadData(request, data);
  1411.   PFile & file = ((PHTTPFileRequest&)request).file;
  1412.   PAssert(file.IsOpen(), PLogicError);
  1414.   PINDEX count = file.GetLength() - file.GetPosition();
  1415.   if (count > 10000)
  1416.     count = 10000;
  1418.   if (count > 0)
  1419.     PAssert(file.Read(data.GetPointer(count), count), PLogicError);
  1421.   if (!file.IsEndOfFile())
  1422.     return TRUE;
  1424.   file.Close();
  1425.   return FALSE;
  1426. }
  1429. PString PHTTPFile::LoadText(PHTTPRequest & request)
  1430. {
  1431.   PFile & file = ((PHTTPFileRequest&)request).file;
  1432.   PAssert(file.IsOpen(), PLogicError);
  1433.   PINDEX count = file.GetLength();
  1434.   PString text;
  1435.   if (count > 0)
  1436.     PAssert(file.Read(text.GetPointer(count+1), count), PLogicError);
  1437.   PAssert(file.Close(), PLogicError);
  1438.   return text;
  1439. }
  1442. //////////////////////////////////////////////////////////////////////////////
  1443. // PHTTPDirectory
  1445. PHTTPDirectory::PHTTPDirectory(const PURL & url, const PDirectory & dir)
  1446.   : PHTTPFile(url, 0), basePath(dir), allowDirectoryListing(TRUE)
  1447. {
  1448. }
  1451. PHTTPDirectory::PHTTPDirectory(const PURL & url,
  1452.                                const PDirectory & dir,
  1453.                                const PHTTPAuthority & auth)
  1454.   : PHTTPFile(url, PString(), auth), basePath(dir), allowDirectoryListing(TRUE)
  1455. {
  1456. }
  1459. PHTTPDirRequest::PHTTPDirRequest(const PURL & url,
  1460.                                  const PMIMEInfo & inMIME,
  1461.                  PHTTPServer & server)
  1462.   : PHTTPFileRequest(url, inMIME, server)
  1463. {
  1464. }
  1467. PHTTPRequest * PHTTPDirectory::CreateRequest(const PURL & url,
  1468.                                         const PMIMEInfo & inMIME,
  1469.         PHTTPServer & socket)
  1470. {
  1471.   return new PHTTPDirRequest(url, inMIME, socket);
  1472. }
  1475. void PHTTPDirectory::EnableAuthorisation(const PString & realm)
  1476. {
  1477.   authorisationRealm = realm;
  1478. }
  1481. BOOL PHTTPDirectory::FindAuthorisations(const PDirectory & dir, PString & realm, PStringToString & authorisations)
  1482. {
  1483.   PFilePath fn = dir + accessFilename;
  1484.   PTextFile file;
  1485.   BOOL first = TRUE;
  1486.   if (file.Open(fn, PFile::ReadOnly)) {
  1487.     PString line;
  1488.     while (file.ReadLine(line)) {
  1489.       if (first) {
  1490.         realm = line.Trim();
  1491.         first = FALSE;
  1492.       } else {
  1493.         PStringArray tokens = line.Tokenise(':');
  1494.         if (tokens.GetSize() > 1)
  1495.           authorisations.SetAt(tokens[0].Trim(), tokens[1].Trim());
  1496.       }
  1497.     }
  1498.     return TRUE;
  1499.   }
  1500.     
  1501.   if (dir.IsRoot() || (dir == basePath))
  1502.     return FALSE;
  1504.   return FindAuthorisations(dir.GetParent(), realm, authorisations);
  1505. }
  1507. BOOL PHTTPDirectory::CheckAuthority(PHTTPServer & server,
  1508.                              const PHTTPRequest & request,
  1509.                       const PHTTPConnectionInfo & conInfo)
  1510. {
  1511.   PFilePath & realPath = ((PHTTPDirRequest&)request).realPath;
  1513.   // construct the real path name
  1514.   const PStringArray & path = request.url.GetPath();
  1515.   realPath = basePath;
  1516.   PINDEX i;
  1517.   for (i = baseURL.GetPath().GetSize(); i < path.GetSize()-1; i++)
  1518.     realPath += path[i] + PDIR_SEPARATOR;
  1520.   // append the last path element
  1521.   if (i < path.GetSize())
  1522.     realPath += path[i];
  1524.   // if access control is enabled, then search parent directories for password files
  1525.   PStringToString authorisations;
  1526.   PString newRealm;
  1527.   if (authorisationRealm.IsEmpty() ||
  1528.       !FindAuthorisations(realPath.GetDirectory(), newRealm, authorisations) ||
  1529.       authorisations.GetSize() == 0)
  1530.     return TRUE;
  1532.   PHTTPMultiSimpAuth authority(newRealm, authorisations);
  1533.   return PHTTPResource::CheckAuthority(authority, server, request, conInfo);
  1534. }
  1536. BOOL PHTTPDirectory::LoadHeaders(PHTTPRequest & request)
  1537. {
  1538.   PFilePath & realPath = ((PHTTPDirRequest&)request).realPath;
  1539.     
  1540.   // if not able to obtain resource information, then consider the resource "not found"
  1541.   PFileInfo info;
  1542.   if (!PFile::GetInfo(realPath, info)) {
  1543.     request.code = PHTTP::NotFound;
  1544.     return FALSE;
  1545.   }
  1547.   // if the resource is a file, and the file can't be opened, then return "not found"
  1548.   PFile & file = ((PHTTPDirRequest&)request).file;
  1549.   if (info.type != PFileInfo::SubDirectory) {
  1550.     if (!file.Open(realPath, PFile::ReadOnly) ||
  1551.         (!authorisationRealm.IsEmpty() && realPath.GetFileName() == accessFilename)) {
  1552.       request.code = PHTTP::NotFound;
  1553.       return FALSE;
  1554.     }
  1555.   } 
  1557.   // resource is a directory - if index files disabled, then return "not found"
  1558.   else if (!allowDirectoryListing) {
  1559.     request.code = PHTTP::NotFound;
  1560.     return FALSE;
  1561.   }
  1563.   // else look for index files
  1564.   else {
  1565.     PINDEX i;
  1566.     for (i = 0; i < PARRAYSIZE(HTMLIndexFiles); i++)
  1567.       if (file.Open(realPath +
  1568.                           PDIR_SEPARATOR + HTMLIndexFiles[i], PFile::ReadOnly))
  1569.         break;
  1570.   }
  1572.   // open the file and return information
  1573.   PString & fakeIndex = ((PHTTPDirRequest&)request).fakeIndex;
  1574.   if (file.IsOpen()) {
  1575.     contentType = PMIMEInfo::GetContentType(file.GetFilePath().GetType());
  1576.     request.contentSize = file.GetLength();
  1577.     fakeIndex = PString();
  1578.     return TRUE;
  1579.   }
  1581.   // construct a directory listing
  1582.   contentType = "text/html";
  1583.   PHTML reply("Directory of " + request.url.AsString());
  1584.   PDirectory dir = realPath;
  1585.   if (dir.Open()) {
  1586.     do {
  1587.       const char * imgName;
  1588.       if (dir.IsSubDir())
  1589.         imgName = "internal-gopher-menu";
  1590.       else if (PMIMEInfo::GetContentType(
  1591.                     PFilePath(dir.GetEntryName()).GetType())(0,4) == "text/")
  1592.         imgName = "internal-gopher-text";
  1593.       else
  1594.         imgName = "internal-gopher-unknown";
  1595.       reply << PHTML::Image(imgName) << ' '
  1596.             << PHTML::HotLink(realPath.GetFileName()+'/'+dir.GetEntryName())
  1597.             << dir.GetEntryName()
  1598.             << PHTML::HotLink()
  1599.             << PHTML::BreakLine();
  1600.     } while (dir.Next());
  1601.   }
  1602.   reply << PHTML::Body();
  1603.   fakeIndex = reply;
  1605.   return TRUE;
  1606. }
  1609. PString PHTTPDirectory::LoadText(PHTTPRequest & request)
  1610. {
  1611.   PString & fakeIndex = ((PHTTPDirRequest&)request).fakeIndex;
  1612.   if (fakeIndex.IsEmpty())
  1613.     return PHTTPFile::LoadText(request);
  1615.   return fakeIndex;
  1616. }
  1619. // End Of File ///////////////////////////////////////////////////////////////