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: 28997 $
 * $Author: rjongbloed $
 * $Date: 2013-01-26 13:37:28 +1100 (Sat, 26 Jan 2013) $
 */

#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 <ptlib/pfactory.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 false; }
};

#ifdef TRACE
#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 {
      BadResponse = 1,             
      ContentProcessorError,       
      UnknownTransferEncoding,     
      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 PCaselessString & HostTag();
    static const PCaselessString & AllowTag();
    static const PCaselessString & AuthorizationTag();
    static const PCaselessString & ContentEncodingTag();
    static const PCaselessString & ContentLengthTag();
    static const PCaselessString & ContentTypeTag() { return PMIMEInfo::ContentTypeTag(); }
    static const PCaselessString & DateTag();
    static const PCaselessString & ExpiresTag();
    static const PCaselessString & FromTag();
    static const PCaselessString & IfModifiedSinceTag();
    static const PCaselessString & LastModifiedTag();
    static const PCaselessString & LocationTag();
    static const PCaselessString & PragmaTag();
    static const PCaselessString & PragmaNoCacheTag();
    static const PCaselessString & RefererTag();
    static const PCaselessString & ServerTag();
    static const PCaselessString & UserAgentTag();
    static const PCaselessString & WWWAuthenticateTag();
    static const PCaselessString & MIMEVersionTag();
    static const PCaselessString & ConnectionTag();
    static const PCaselessString & KeepAliveTag();
    static const PCaselessString & TransferEncodingTag();
    static const PCaselessString & ChunkedTag();
    static const PCaselessString & ProxyConnectionTag();
    static const PCaselessString & ProxyAuthorizationTag();
    static const PCaselessString & ProxyAuthenticateTag();
    static const PCaselessString & ForwardedTag();
    static const PCaselessString & SetCookieTag();
    static const PCaselessString & CookieTag();

  protected:
    PHTTP();
    PHTTP(
      const char * defaultServiceName  
    );

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



class PHTTPClientAuthentication : public PObject
{
  PCLASSINFO(PHTTPClientAuthentication, PObject);
  public:
    class AuthObject {
      public:
        virtual ~AuthObject() { }
        virtual PMIMEInfo & GetMIME() = 0;
        virtual PString GetURI() = 0;
        virtual PString GetEntityBody() = 0;
        virtual PString GetMethod() = 0;
    };

    PHTTPClientAuthentication();

    virtual Comparison Compare(
      const PObject & other
    ) const;

    virtual PBoolean Parse(
      const PString & auth,
      PBoolean proxy
    ) = 0;

    virtual PBoolean Authorise(
      AuthObject & pdu
    ) const =  0;

    virtual PBoolean IsProxy() const               { return isProxy; }

    virtual PString GetUsername() const   { return username; }
    virtual PString GetPassword() const   { return password; }
    virtual PString GetAuthRealm() const  { return PString::Empty(); }

    virtual void SetUsername(const PString & user) { username = user; }
    virtual void SetPassword(const PString & pass) { password = pass; }
    virtual void SetAuthRealm(const PString &)     { }

    PString GetAuthParam(const PString & auth, const char * name) const;
    PString AsHex(PMessageDigest5::Code & digest) const;
    PString AsHex(const PBYTEArray & data) const;

    static PHTTPClientAuthentication * ParseAuthenticationRequired(bool isProxy, const PMIMEInfo & line, PString & errorMsg);


  protected:
    PBoolean  isProxy;
    PString   username;
    PString   password;
};

typedef PFactory<PHTTPClientAuthentication> PHTTPClientAuthenticationFactory;

class PHTTPClientAuthenticator : public PHTTPClientAuthentication::AuthObject
{
  public:
    PHTTPClientAuthenticator(
      const PString & cmdName, 
      const PString & uri, 
      PMIMEInfo & mime, 
      const PString & body
    );
    virtual PMIMEInfo & GetMIME();
    virtual PString GetURI();
    virtual PString GetEntityBody();
    virtual PString GetMethod();
  protected:
    PString m_method;
    PString m_uri;
    PMIMEInfo & m_mime;
    PString m_body;
};


class PHTTPClientBasicAuthentication : public PHTTPClientAuthentication
{
  PCLASSINFO(PHTTPClientBasicAuthentication, PHTTPClientAuthentication);
  public:
    PHTTPClientBasicAuthentication();

    virtual Comparison Compare(
      const PObject & other
    ) const;

    virtual PBoolean Parse(
      const PString & auth,
      PBoolean proxy
    );

    virtual PBoolean Authorise(
      AuthObject & pdu
    ) const;
};


class PHTTPClientDigestAuthentication : public PHTTPClientAuthentication
{
  PCLASSINFO(PHTTPClientDigestAuthentication, PHTTPClientAuthentication);
  public:
    PHTTPClientDigestAuthentication();

    PHTTPClientDigestAuthentication & operator =(
      const PHTTPClientDigestAuthentication & auth
    );

    virtual Comparison Compare(
      const PObject & other
    ) const;

    virtual PBoolean Parse(
      const PString & auth,
      PBoolean proxy
    );

    virtual PBoolean Authorise(
      AuthObject & pdu
    ) const;

    virtual PString GetAuthRealm() const         { return authRealm; }
    virtual void SetAuthRealm(const PString & r) { authRealm = r; }

    enum Algorithm {
      Algorithm_MD5,
      NumAlgorithms
    };
    const PString & GetNonce() const       { return nonce; }
    Algorithm GetAlgorithm() const         { return algorithm; }
    const PString & GetOpaque() const      { return opaque; }
    bool GetStale() const                  { return stale; }

  protected:
    PString   authRealm;
    PString   nonce;
    Algorithm algorithm;
    PString   opaque;

    bool    qopAuth;
    bool    qopAuthInt;
    bool    stale;
    PString cnonce;
    mutable PAtomicInteger nonceCount;
};


// PHTTPClient

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

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


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

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

    bool ReadResponse(
      PMIMEInfo & replyMIME
    );

    struct ContentProcessor
    {
      virtual ~ContentProcessor() { }
      virtual void * GetBuffer(PINDEX & size) = 0;
      virtual bool Process(const void * data, PINDEX length) = 0;
    };

    bool ReadContentBody(
      PMIMEInfo & replyMIME,        
      ContentProcessor & processor  
    );

    bool ReadContentBody(
      PMIMEInfo & replyMIME   
    );

    bool ReadContentBody(
      PMIMEInfo & replyMIME,        
      PString & body                
    );

    bool ReadContentBody(
      PMIMEInfo & replyMIME,        
      PBYTEArray & body             
    );


    bool GetDocument(
      const PURL & url,             
      ContentProcessor & processor  
    );

    bool GetDocument(
      const PURL & url,         
      PMIMEInfo & outMIME,      
      PMIMEInfo & replyMIME     
    );
    bool GetDocument(
      const PURL & url,         
      PMIMEInfo & replyMIME     
    );


    bool GetTextDocument(
      const PURL & url,         
      PString & document,       
      const PString & contentType = PString::Empty() 
    );

    bool GetBinaryDocument(
      const PURL & url,         
      PBYTEArray & document,    
      const PString & contentType = PString::Empty() 
    );


    bool GetHeader(
      const PURL & url,         
      PMIMEInfo & outMIME,      
      PMIMEInfo & replyMIME     
    );
    bool GetHeader(
      const PURL & url,         
      PMIMEInfo & replyMIME     
    );


    bool PostData(
      const PURL & url,         
      const PStringToString & data  
    );

    bool PostData(
      const PURL & url,         
      PMIMEInfo & outMIME,      
      const PString & data    
    );

    bool PostData(
      const PURL & url,       
      PMIMEInfo & outMIME,    
      const PString & data,   
      PMIMEInfo & replyMIME   
    );

    bool PostData(
      const PURL & url,       
      PMIMEInfo & outMIME,    
      const PString & data,   
      PMIMEInfo & replyMIME,  
      PString & replyBody     
    );

    bool PutTextDocument(
      const PURL & url,         
      const PString & document,       
      const PString & contentType = PMIMEInfo::TextPlain() 
    );

    bool PutDocument(
      const PURL & url,         
      PMIMEInfo & outMIME,      
      PMIMEInfo & replyMIME     
    );

    bool DeleteDocument(
      const PURL & url        
    );

    void SetAuthenticationInfo(
      const PString & userName,
      const PString & password
    );

#if P_SSL
    void SetSSLCredentials(
      const PString & authority,
      const PString & certificate,
      const PString & privateKey
    );
#endif

    void SetPersistent(
      bool persist = true
    ) { m_persist = persist; }

    bool GetPersistent() const { return m_persist; }

  protected:
    bool AssureConnect(const PURL & url, PMIMEInfo & outMIME);

    PString m_userAgentName;
    bool    m_persist;
    PString m_userName;
    PString m_password;
#if P_SSL
    PString m_authority;    // Directory, file or data
    PString m_certificate;  // File or data
    PString m_privateKey;   // File or data
#endif
    PHTTPClientAuthentication * m_authentication;
};


// 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;

    bool IsPersistent() const         { return isPersistent; }
    bool WasPersistent() const        { return wasPersistent; }
    bool 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 PMultiPartList & GetMultipartFormInfo() const
      { return m_multipartFormInfo; }

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

    PString GetEntityBody() const   { return entityBody; }

  protected:
    PBoolean Initialise(PHTTPServer & server, PString & args);
    bool DecodeMultipartFormInfo() { return mimeInfo.DecodeMultiPartList(m_multipartFormInfo, entityBody); }

    PHTTP::Commands commandCode;
    PString         commandName;
    PURL            url;
    PMIMEInfo       mimeInfo;
    bool            isPersistent;
    bool            wasPersistent;
    bool            isProxyConnection;
    int             majorVersion;
    int             minorVersion;
    PString         entityBody;        // original entity body (POST only)
    long            entityBodyLength;
    PTimeInterval   persistenceTimeout;
    unsigned        persistenceMaximum;
    PMultiPartList  m_multipartFormInfo;

  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; }

    virtual bool OnCommand(
      PINDEX cmd,
      const PURL & url, 
      const PString & args,
      PHTTPConnectionInfo & 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 PMultiPartList & multipartFormInfo, 
      PHTTPResource * resource,     
      PHTTPServer & server          
    );

    PHTTPServer & server;           
    const PURL & url;               
    const PMIMEInfo & inMIME;       
    const PMultiPartList & 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; }

    PString GetHotLink() const { return baseURL.AsString(PURL::PathOnly); }

    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 PMultiPartList & 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 PMultiPartList & 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 PMultiPartList & 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 PMultiPartList & multipartFormInfo,
      PHTTPServer & socket
    );

    virtual PBoolean LoadHeaders(
      PHTTPRequest & request    
    );

    virtual PString LoadText(
      PHTTPRequest & request    
    );

    void EnableAuthorisation(const PString & realm);

    void AllowDirectories(PBoolean enable = true);

  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 PMultiPartList & multipartFormInfo, 
      PHTTPResource * resource,
      PHTTPServer & server
    );

    PString fakeIndex;
    PFilePath realPath;
};


#endif // P_HTTP

#endif // PTLIB_HTTP_H


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