http.h

Go to the documentation of this file.

/*
 * http.h
 *
 * HyperText Transport Protocol classes.
 *
 * Portable Windows Library
 *
 * Copyright (c) 1993-2002 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 22915 $
 * $Author: rjongbloed $
 * $Date: 2009-06-18 04:13:31 +0000 (Thu, 18 Jun 2009) $
 */

#ifndef PTLIB_HTTP_H
#define PTLIB_HTTP_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#if P_HTTP

#include <ptclib/inetprot.h>
#include <ptclib/mime.h>
#include <ptclib/url.h>
#include <ptlib/ipsock.h>


#include <ptclib/html.h>

// PHTTPSpace

class PHTTPResource;

class PHTTPSpace : public PContainer
{
  PCONTAINERINFO(PHTTPSpace, PContainer)
  public:
    PHTTPSpace();


  // New functions for class.
    enum AddOptions {
      ErrorOnExist,
      Overwrite
    };


    PBoolean AddResource(
      PHTTPResource * resource, 
      AddOptions overwrite = ErrorOnExist
    );

    PBoolean DelResource(
      const PURL & url          
    );

    PHTTPResource * FindResource(
      const PURL & url   
    );

    void StartRead() const
      { mutex->StartRead(); }

    void EndRead() const
      { mutex->EndRead(); }

    void StartWrite() const
      { mutex->StartWrite(); }

    void EndWrite() const
      { mutex->EndWrite(); }


  protected:
    PReadWriteMutex * mutex;

    class Node;
    PSORTED_LIST(ChildList, Node);
    class Node : public PString
    {
      PCLASSINFO(Node, PString)
      public:
        Node(const PString & name, Node * parentNode);
        ~Node();

        Node          * parent;
        ChildList       children;
        PHTTPResource * resource;
    } * root;

  private:
    PBoolean SetSize(PINDEX) { return PFalse; }
};

#ifdef _WIN32_WCE
#undef TRACE
#endif

// PHTTP

class PHTTP : public PInternetProtocol
{
  PCLASSINFO(PHTTP, PInternetProtocol)

  public:
  // New functions for class.
    enum Commands {
      // HTTP/1.0 commands
      GET, HEAD, POST,
      // HTTP/1.1 commands
      PUT, DELETE, TRACE, OPTIONS,
      // HTTPS command
      CONNECT,
      NumCommands
    };

    enum StatusCode {
      Continue = 100,              
      SwitchingProtocols,          
      RequestOK = 200,             
      Created,                     
      Accepted,                    
      NonAuthoritativeInformation, 
      NoContent,                   
      ResetContent,                
      PartialContent,              
      MultipleChoices = 300,       
      MovedPermanently,            
      MovedTemporarily,            
      SeeOther,                    
      NotModified,                 
      UseProxy,                    
      BadRequest = 400,            
      UnAuthorised,                
      PaymentRequired,             
      Forbidden,                   
      NotFound,                    
      MethodNotAllowed,            
      NoneAcceptable,              
      ProxyAuthenticationRequired, 
      RequestTimeout,              
      Conflict,                    
      Gone,                        
      LengthRequired,              
      UnlessTrue,                  
      InternalServerError = 500,   
      NotImplemented,              
      BadGateway,                  
      ServiceUnavailable,          
      GatewayTimeout               
    };

    // Common MIME header tags
    static const PString & AllowTag();
    static const PString & AuthorizationTag();
    static const PString & ContentEncodingTag();
    static const PString & ContentLengthTag();
    static const PString & ContentTypeTag();
    static const PString & DateTag();
    static const PString & ExpiresTag();
    static const PString & FromTag();
    static const PString & IfModifiedSinceTag();
    static const PString & LastModifiedTag();
    static const PString & LocationTag();
    static const PString & PragmaTag();
    static const PString & PragmaNoCacheTag();
    static const PString & RefererTag();
    static const PString & ServerTag();
    static const PString & UserAgentTag();
    static const PString & WWWAuthenticateTag();
    static const PString & MIMEVersionTag();
    static const PString & ConnectionTag();
    static const PString & KeepAliveTag();
    static const PString & TransferEncodingTag();
    static const PString & ChunkedTag();
    static const PString & ProxyConnectionTag();
    static const PString & ProxyAuthorizationTag();
    static const PString & ProxyAuthenticateTag();
    static const PString & ForwardedTag();
    static const PString & SetCookieTag();
    static const PString & CookieTag();

  protected:
    PHTTP();

    virtual PINDEX ParseResponse(
      const PString & line    
    );
};


// PHTTPClient

class PHTTPClient : public PHTTP
{
  PCLASSINFO(PHTTPClient, PHTTP)

  public:
    PHTTPClient();
    PHTTPClient(
      const PString & userAgentName
    );


  // New functions for class.
    int ExecuteCommand(
      Commands cmd,
      const PURL & url,
      PMIMEInfo & outMIME,
      const PString & dataBody,
      PMIMEInfo & replyMime,
      PBoolean persist = PTrue
    );
    int ExecuteCommand(
      const PString & cmdName,
      const PURL & url,
      PMIMEInfo & outMIME,
      const PString & dataBody,
      PMIMEInfo & replyMime,
      PBoolean persist = PTrue
    );

    PBoolean WriteCommand(
      Commands cmd,
      const PString & url,
      PMIMEInfo & outMIME,
      const PString & dataBody
    );
    PBoolean WriteCommand(
      const PString & cmdName,
      const PString & url,
      PMIMEInfo & outMIME,
      const PString & dataBody
    );

    PBoolean ReadResponse(
      PMIMEInfo & replyMIME
    );

    PBoolean ReadContentBody(
      PMIMEInfo & replyMIME,
      PBYTEArray & body
    );
    PBoolean ReadContentBody(
      PMIMEInfo & replyMIME,
      PString & body
    );


    PBoolean GetTextDocument(
      const PURL & url,         
      PString & document,       
      PBoolean persist = PTrue       
    );

    PBoolean GetDocument(
      const PURL & url,         
      PMIMEInfo & outMIME,      
      PMIMEInfo & replyMIME,    
      PBoolean persist = PTrue       
    );

    PBoolean GetHeader(
      const PURL & url,         
      PMIMEInfo & outMIME,      
      PMIMEInfo & replyMIME,    
      PBoolean persist = PTrue       
    );


    PBoolean PostData(
      const PURL & url,       
      PMIMEInfo & outMIME,    
      const PString & data,   
      PMIMEInfo & replyMIME,  
      PBoolean persist = PTrue     
    );

    PBoolean PostData(
      const PURL & url,       
      PMIMEInfo & outMIME,    
      const PString & data,   
      PMIMEInfo & replyMIME,  
      PString & replyBody,    
      PBoolean persist = PTrue     
    );

  protected:
    PBoolean AssureConnect(const PURL & url, PMIMEInfo & outMIME);
    PBoolean InternalReadContentBody(
      PMIMEInfo & replyMIME,
      PAbstractArray & body
    );

    PString userAgentName;
};

// PMultipartFormInfo

class PMultipartFormInfo : public PObject
{
  PCLASSINFO(PMultipartFormInfo, PObject);
  public:
    PMIMEInfo mime;
    PString body;
};

PARRAY(PMultipartFormInfoArray, PMultipartFormInfo);

// PHTTPConnectionInfo

class PHTTPServer;

class PHTTPConnectionInfo : public PObject
{
  PCLASSINFO(PHTTPConnectionInfo, PObject)
  public:
    PHTTPConnectionInfo();

    PHTTP::Commands GetCommandCode() const { return commandCode; }
    const PString & GetCommandName() const { return commandName; }

    const PURL & GetURL() const       { return url; }

    const PMIMEInfo & GetMIME() const { return mimeInfo; }
    void SetMIME(const PString & tag, const PString & value);

    PBoolean IsCompatible(int major, int minor) const;

    PBoolean IsPersistant() const         { return isPersistant; }
    PBoolean WasPersistant() const        { return wasPersistant; }
    PBoolean IsProxyConnection() const    { return isProxyConnection; }
    int  GetMajorVersion() const      { return majorVersion; }
    int  GetMinorVersion() const      { return minorVersion; }

    long GetEntityBodyLength() const  { return entityBodyLength; }

    PTimeInterval GetPersistenceTimeout() const { return persistenceTimeout; }

    void SetPersistenceTimeout(const PTimeInterval & t) { persistenceTimeout = t; }

    unsigned GetPersistenceMaximumTransations() const { return persistenceMaximum; }

    void SetPersistenceMaximumTransations(unsigned m) { persistenceMaximum = m; }

    const PMultipartFormInfoArray & GetMultipartFormInfo() const
      { return multipartFormInfoArray; }

    void ResetMultipartFormInfo()
      { multipartFormInfoArray.RemoveAll(); }

    PString GetEntityBody() const   { return entityBody; }

  protected:
    PBoolean Initialise(PHTTPServer & server, PString & args);
    void DecodeMultipartFormInfo(const PString & type, const PString & entityBody);

    PHTTP::Commands commandCode;
    PString         commandName;
    PURL            url;
    PMIMEInfo       mimeInfo;
    PBoolean            isPersistant;
    PBoolean            wasPersistant;
    PBoolean            isProxyConnection;
    int             majorVersion;
    int             minorVersion;
    PString         entityBody;        // original entity body (POST only)
    long            entityBodyLength;
    PTimeInterval   persistenceTimeout;
    unsigned        persistenceMaximum;
    PMultipartFormInfoArray multipartFormInfoArray;

  friend class PHTTPServer;
};


// PHTTPServer

class PHTTPServer : public PHTTP
{
  PCLASSINFO(PHTTPServer, PHTTP)

  public:
    PHTTPServer();
    PHTTPServer(
     const PHTTPSpace & urlSpace  
    );


  // New functions for class.
    virtual PString GetServerName() const;

    PHTTPSpace & GetURLSpace() { return urlSpace; }

    void SetURLSpace(
      const PHTTPSpace & space   
    );


    virtual PBoolean ProcessCommand();

    virtual PBoolean OnGET(
      const PURL & url,                    
      const PMIMEInfo & info,              
      const PHTTPConnectionInfo & conInfo  
    );



    virtual PBoolean OnHEAD(
      const PURL & url,                   
      const PMIMEInfo & info,             
      const PHTTPConnectionInfo & conInfo 
    );

    virtual PBoolean OnPOST(
      const PURL & url,                   
      const PMIMEInfo & info,             
      const PStringToString & data,       
      const PHTTPConnectionInfo & conInfo 
    );

    virtual PBoolean OnProxy(
      const PHTTPConnectionInfo & conInfo   
    );


    virtual PString ReadEntityBody();

    virtual PBoolean OnUnknown(
      const PCaselessString & command,         
      const PHTTPConnectionInfo & connectInfo  
    );

    PBoolean StartResponse(
      StatusCode code,      
      PMIMEInfo & headers,  
      long bodySize         
    );

    virtual PBoolean OnError(
      StatusCode code,                         
      const PCaselessString & extra,           
      const PHTTPConnectionInfo & connectInfo  
    );

    void SetDefaultMIMEInfo(
      PMIMEInfo & info,      
      const PHTTPConnectionInfo & connectInfo
    );

    PHTTPConnectionInfo & GetConnectionInfo() { return connectInfo; }

  protected:
    void Construct();

    PHTTPSpace          urlSpace;
    PHTTPConnectionInfo connectInfo;
    unsigned            transactionCount;
    PTimeInterval       nextTimeout;
};


// PHTTPRequest

class PHTTPRequest : public PObject
{
  PCLASSINFO(PHTTPRequest, PObject)

  public:
    PHTTPRequest(
      const PURL & url,             
      const PMIMEInfo & inMIME,     
      const PMultipartFormInfoArray & multipartFormInfo, 
      PHTTPResource * resource,     
      PHTTPServer & server          
    );

    PHTTPServer & server;           
    const PURL & url;               
    const PMIMEInfo & inMIME;       
    const PMultipartFormInfoArray & multipartFormInfo; 
    PHTTP::StatusCode code;         
    PMIMEInfo outMIME;              
    PString entityBody;             
    PINDEX contentSize;             
    PIPSocket::Address origin;      
    PIPSocket::Address localAddr;   
    WORD               localPort;   
    PHTTPResource    * m_resource;  
};


// PHTTPAuthority

class PHTTPAuthority : public PObject
{
  PCLASSINFO(PHTTPAuthority, PObject)

  public:
  // New functions for class.
    virtual PString GetRealm(
      const PHTTPRequest & request   
    ) const = 0;

    virtual PBoolean Validate(
      const PHTTPRequest & request,  
      const PString & authInfo       
    ) const = 0;

    virtual PBoolean IsActive() const;

  protected:
    static void DecodeBasicAuthority(
      const PString & authInfo,   
      PString & username,         
      PString & password          
    );
};


// PHTTPSimpleAuth

class PHTTPSimpleAuth : public PHTTPAuthority
{
  PCLASSINFO(PHTTPSimpleAuth, PHTTPAuthority)

  public:
    PHTTPSimpleAuth(
      const PString & realm,      
      const PString & username,   
      const PString & password    
    );
    // Construct the simple authorisation structure.


  // Overrides from class PObject.
    virtual PObject * Clone() const;


  // Overrides from class PHTTPAuthority.
    virtual PString GetRealm(
      const PHTTPRequest & request   
    ) const;

    virtual PBoolean Validate(
      const PHTTPRequest & request,  
      const PString & authInfo       
    ) const;

    virtual PBoolean IsActive() const;

    const PString & GetUserName() const { return username; }

    const PString & GetPassword() const { return password; }


  protected:
    PString realm;
    PString username;
    PString password;
};


// PHTTPMultiSimpAuth

class PHTTPMultiSimpAuth : public PHTTPAuthority
{
  PCLASSINFO(PHTTPMultiSimpAuth, PHTTPAuthority)

  public:
    PHTTPMultiSimpAuth(
      const PString & realm      
    );
    PHTTPMultiSimpAuth(
      const PString & realm,           
      const PStringToString & userList 
    );
    // Construct the simple authorisation structure.


  // Overrides from class PObject.
    virtual PObject * Clone() const;


  // Overrides from class PHTTPAuthority.
    virtual PString GetRealm(
      const PHTTPRequest & request   
    ) const;

    virtual PBoolean Validate(
      const PHTTPRequest & request,  
      const PString & authInfo       
    ) const;

    virtual PBoolean IsActive() const;

    void AddUser(
      const PString & username,   
      const PString & password    
    );


  protected:
    PString realm;
    PStringToString users;
};


// PHTTPResource

class PHTTPResource : public PObject
{
  PCLASSINFO(PHTTPResource, PObject)

  protected:
    PHTTPResource(
      const PURL & url               
    );
    PHTTPResource(
      const PURL & url,              
      const PHTTPAuthority & auth    
    );
    PHTTPResource(
      const PURL & url,              
      const PString & contentType    
    );
    PHTTPResource(
      const PURL & url,              
      const PString & contentType,   
      const PHTTPAuthority & auth    
    );
    // Create a new HTTP Resource.


  public:
    virtual ~PHTTPResource();
    // Destroy the HTTP Resource.


  // New functions for class.
    const PURL & GetURL() const { return baseURL; }

    const PString & GetContentType() const { return contentType; }

    PHTTPAuthority * GetAuthority() const { return authority; }

    void SetAuthority(
      const PHTTPAuthority & auth      
    );

    void ClearAuthority();

    DWORD GetHitCount() const { return hitCount; }

    void ClearHitCount() { hitCount = 0; }
    // Clear the hit count for the resource.


    virtual PBoolean OnGET(
      PHTTPServer & server,       
      const PURL & url,           
      const PMIMEInfo & info,     
      const PHTTPConnectionInfo & conInfo   
    );

    virtual PBoolean OnGETData(
      PHTTPServer & server,                       
      const PURL & url,                           
      const PHTTPConnectionInfo & connectInfo,    
      PHTTPRequest & request                      
    );

    virtual PBoolean OnHEAD(
      PHTTPServer & server,       
      const PURL & url,           
      const PMIMEInfo & info,     
      const PHTTPConnectionInfo & conInfo  
    );

    virtual PBoolean OnPOST(
      PHTTPServer & server,         
      const PURL & url,             
      const PMIMEInfo & info,       
      const PStringToString & data, 
      const PHTTPConnectionInfo & conInfo  
    );

    virtual PBoolean OnPOSTData(
      PHTTPRequest & request,        
      const PStringToString & data   
    );

    virtual PBoolean IsModifiedSince(
      const PTime & when    
    );

    virtual PBoolean GetExpirationDate(
      PTime & when          
    );

    virtual PHTTPRequest * CreateRequest(
      const PURL & url,                   
      const PMIMEInfo & inMIME,           
      const PMultipartFormInfoArray & multipartFormInfo,  
      PHTTPServer & socket                                
    );

    virtual PBoolean LoadHeaders(
      PHTTPRequest & request    
    ) = 0;

    virtual void SendData(
      PHTTPRequest & request    
    );

    virtual PBoolean LoadData(
      PHTTPRequest & request,    
      PCharArray & data          
    );

    virtual PString LoadText(
      PHTTPRequest & request    
    );

    virtual void OnLoadedText(
      PHTTPRequest & request,    
      PString & text             
    );

    virtual PBoolean Post(
      PHTTPRequest & request,       
      const PStringToString & data, 
      PHTML & replyMessage          
    );


  protected:
    virtual PBoolean CheckAuthority(
      PHTTPServer & server,               
      const PHTTPRequest & request,       
      const PHTTPConnectionInfo & conInfo 
    );
    static PBoolean CheckAuthority(
                   PHTTPAuthority & authority,
                      PHTTPServer & server,
               const PHTTPRequest & request,
        const PHTTPConnectionInfo & connectInfo
    );


    virtual PBoolean OnGETOrHEAD(
      PHTTPServer & server,       
      const PURL & url,           
      const PMIMEInfo & info,     
      const PHTTPConnectionInfo & conInfo,
      PBoolean  IsGet
    );

    PURL             baseURL;
    PString          contentType;
    PHTTPAuthority * authority;
    volatile DWORD   hitCount;
};


// PHTTPString

class PHTTPString : public PHTTPResource
{
  PCLASSINFO(PHTTPString, PHTTPResource)

  public:
    PHTTPString(
      const PURL & url             // Name of the resource in URL space.
    );
    PHTTPString(
      const PURL & url,            // Name of the resource in URL space.
      const PHTTPAuthority & auth  // Authorisation for the resource.
    );
    PHTTPString(
      const PURL & url,            // Name of the resource in URL space.
      const PString & str          // String to return in this resource.
    );
    PHTTPString(
      const PURL & url,            // Name of the resource in URL space.
      const PString & str,         // String to return in this resource.
      const PString & contentType  // MIME content type for the file.
    );
    PHTTPString(
      const PURL & url,            // Name of the resource in URL space.
      const PString & str,         // String to return in this resource.
      const PHTTPAuthority & auth  // Authorisation for the resource.
    );
    PHTTPString(
      const PURL & url,            // Name of the resource in URL space.
      const PString & str,         // String to return in this resource.
      const PString & contentType, // MIME content type for the file.
      const PHTTPAuthority & auth  // Authorisation for the resource.
    );


  // Overrides from class PHTTPResource
    virtual PBoolean LoadHeaders(
      PHTTPRequest & request    // Information on this request.
    );

    virtual PString LoadText(
      PHTTPRequest & request    // Information on this request.
    );

  // New functions for class.
    const PString & GetString() { return string; }

    void SetString(
      const PString & str   // New string for the resource.
    ) { string = str; }


  protected:
    PString string;
};


// PHTTPFile

class PHTTPFile : public PHTTPResource
{
  PCLASSINFO(PHTTPFile, PHTTPResource)

  public:
    PHTTPFile(
      const PString & filename     // file in file system and URL name.
    );
    PHTTPFile(
      const PString & filename,    // file in file system and URL name.
      const PHTTPAuthority & auth  // Authorisation for the resource.
    );
    PHTTPFile(
      const PURL & url,            // Name of the resource in URL space.
      const PFilePath & file       // Location of file in file system.
    );
    PHTTPFile(
      const PURL & url,            // Name of the resource in URL space.
      const PFilePath & file,      // Location of file in file system.
      const PString & contentType  // MIME content type for the file.
    );
    PHTTPFile(
      const PURL & url,            // Name of the resource in URL space.
      const PFilePath & file,      // Location of file in file system.
      const PHTTPAuthority & auth  // Authorisation for the resource.
    );
    PHTTPFile(
      const PURL & url,            // Name of the resource in URL space.
      const PFilePath & file,      // Location of file in file system.
      const PString & contentType, // MIME content type for the file.
      const PHTTPAuthority & auth  // Authorisation for the resource.
    );


  // Overrides from class PHTTPResource
    virtual PHTTPRequest * CreateRequest(
      const PURL & url,                  // Universal Resource Locator for document.
      const PMIMEInfo & inMIME,          // Extra MIME information in command.
      const PMultipartFormInfoArray & multipartFormInfo,
      PHTTPServer & socket
    );

    virtual PBoolean LoadHeaders(
      PHTTPRequest & request    // Information on this request.
    );

    virtual PBoolean LoadData(
      PHTTPRequest & request,    // Information on this request.
      PCharArray & data          // Data used in reply.
    );

    virtual PString LoadText(
      PHTTPRequest & request    // Information on this request.
    );


  protected:
    PHTTPFile(
      const PURL & url,       // Name of the resource in URL space.
      int dummy
    );
    // Constructor used by PHTTPDirectory


    PFilePath filePath;
};


class PHTTPFileRequest : public PHTTPRequest
{
  PCLASSINFO(PHTTPFileRequest, PHTTPRequest)
  public:
    PHTTPFileRequest(
      const PURL & url,             // Universal Resource Locator for document.
      const PMIMEInfo & inMIME,     // Extra MIME information in command.
      const PMultipartFormInfoArray & multipartFormInfo,
      PHTTPResource * resource,
      PHTTPServer & server
    );

    PFile file;
};


// PHTTPTailFile

class PHTTPTailFile : public PHTTPFile
{
  PCLASSINFO(PHTTPTailFile, PHTTPFile)

  public:
    PHTTPTailFile(
      const PString & filename     // file in file system and URL name.
    );
    PHTTPTailFile(
      const PString & filename,    // file in file system and URL name.
      const PHTTPAuthority & auth  // Authorisation for the resource.
    );
    PHTTPTailFile(
      const PURL & url,            // Name of the resource in URL space.
      const PFilePath & file       // Location of file in file system.
    );
    PHTTPTailFile(
      const PURL & url,            // Name of the resource in URL space.
      const PFilePath & file,      // Location of file in file system.
      const PString & contentType  // MIME content type for the file.
    );
    PHTTPTailFile(
      const PURL & url,            // Name of the resource in URL space.
      const PFilePath & file,      // Location of file in file system.
      const PHTTPAuthority & auth  // Authorisation for the resource.
    );
    PHTTPTailFile(
      const PURL & url,            // Name of the resource in URL space.
      const PFilePath & file,      // Location of file in file system.
      const PString & contentType, // MIME content type for the file.
      const PHTTPAuthority & auth  // Authorisation for the resource.
    );


  // Overrides from class PHTTPResource
    virtual PBoolean LoadHeaders(
      PHTTPRequest & request    // Information on this request.
    );

    virtual PBoolean LoadData(
      PHTTPRequest & request,    // Information on this request.
      PCharArray & data          // Data used in reply.
    );
};


// PHTTPDirectory

class PHTTPDirectory : public PHTTPFile
{
  PCLASSINFO(PHTTPDirectory, PHTTPFile)

  public:
    PHTTPDirectory(
      const PURL & url,            
      const PDirectory & dir       
    );
    PHTTPDirectory(
      const PURL & url,            
      const PDirectory & dir,      
      const PHTTPAuthority & auth  
    );
    // Construct a new directory resource for HTTP.


  // Overrides from class PHTTPResource
    virtual PHTTPRequest * CreateRequest(
      const PURL & url,                  // Universal Resource Locator for document.
      const PMIMEInfo & inMIME,          // Extra MIME information in command.
      const PMultipartFormInfoArray & multipartFormInfo,
      PHTTPServer & socket
    );

    virtual PBoolean LoadHeaders(
      PHTTPRequest & request    
    );

    virtual PString LoadText(
      PHTTPRequest & request    
    );

    void EnableAuthorisation(const PString & realm);

    void AllowDirectories(PBoolean enable = PTrue);

  protected:
    PBoolean CheckAuthority(
      PHTTPServer & server,               // Server to send response to.
      const PHTTPRequest & request,       // Information on this request.
      const PHTTPConnectionInfo & conInfo // Information on the connection
    );

    PBoolean FindAuthorisations(const PDirectory & dir, PString & realm, PStringToString & authorisations);

    PDirectory basePath;
    PString authorisationRealm;
    PBoolean allowDirectoryListing;
};


class PHTTPDirRequest : public PHTTPFileRequest
{
  PCLASSINFO(PHTTPDirRequest, PHTTPFileRequest)
  public:
    PHTTPDirRequest(
      const PURL & url,             // Universal Resource Locator for document.
      const PMIMEInfo & inMIME,     // Extra MIME information in command.
      const PMultipartFormInfoArray & multipartFormInfo, 
      PHTTPResource * resource,
      PHTTPServer & server
    );

    PString fakeIndex;
    PFilePath realPath;
};

#endif // P_HTTP

#endif // PTLIB_HTTP_H


// End Of File ///////////////////////////////////////////////////////////////

---