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): ______________________________________.
 */

#ifndef PTLIB_HTTP_H
#define PTLIB_HTTP_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <ptlib_config.h>

#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,     
      TransportConnectError,       
      TransportWriteError,         
      TransportReadError,          
      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 & UpgradeTag();
    static const PCaselessString & WebSocketTag();
    static const PCaselessString & WebSocketKeyTag();
    static const PCaselessString & WebSocketAcceptTag();
    static const PCaselessString & WebSocketProtocolTag();
    static const PCaselessString & WebSocketVersionTag();
    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();

    static const PCaselessString & FormUrlEncoded();

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

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


class PHTTPContentProcessor
{
public:
  PHTTPContentProcessor(bool reader) : m_reader(reader) { }
  virtual ~PHTTPContentProcessor() { }
  virtual void * GetBuffer(PINDEX & size) = 0;
  virtual bool Process(const void * /*data*/, PINDEX /*length*/) { return true; }
  virtual void Reset() { }
protected:
  bool m_reader;
};


class PHTTPClientAuthentication : public PObject
{
  PCLASSINFO(PHTTPClientAuthentication, PObject);
  public:
    class AuthObject {
      public:
        virtual ~AuthObject() { }
        virtual PMIMEInfo & GetMIME() = 0;
        virtual PString GetURI() = 0;
        virtual PString GetEntityBody() { return PString::Empty(); }
        virtual PHTTPContentProcessor * GetContentProcessor() { return NULL; }
        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(const PMessageDigest::Result & digest) const { return digest.AsHex(); }
    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, 
      PHTTPContentProcessor & processor
    );
    virtual PMIMEInfo & GetMIME();
    virtual PString GetURI();
    virtual PHTTPContentProcessor * GetContentProcessor();
    virtual PString GetMethod();
  protected:
    PString m_method;
    PString m_uri;
    PMIMEInfo & m_mime;
    PHTTPContentProcessor & m_contentProcessor;
};


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 atomic<uint32_t> nonceCount;
};


// PHTTPClient

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

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


  // New functions for class.
    bool ConnectURL(
      const PURL & url
    );

    typedef PHTTPContentProcessor ContentProcessor;

    int ExecuteCommand(
      Commands cmd,
      const PURL & url,
      PMIMEInfo & outMIME,
      const PString & dataBody,
      PMIMEInfo & replyMime
    );
    int ExecuteCommand(
      Commands cmd,
      const PURL & url,
      PMIMEInfo & outMIME,
      const PBYTEArray & dataBody,
      PMIMEInfo & replyMime
    );
    int ExecuteCommand(
      Commands cmd,
      const PURL & url,
      PMIMEInfo & outMIME,
      ContentProcessor & processor,
      PMIMEInfo & replyMime
    );

    bool WriteCommand(
      Commands cmd,
      const PString & url,
      PMIMEInfo & outMIME,
      ContentProcessor & processor
    );

    bool ReadResponse(
      PMIMEInfo & replyMIME
    );

    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,              
      const PStringToString & data,  
      PMIMEInfo & replyMIME,         
      PString & replyBody            
    );

    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 PutDocument(
      const PURL & url,           
      const PString & document,  
      const PString & contentType = PMIMEInfo::TextPlain(), 
      const PMIMEInfo & mime = PMIMEInfo()   
    );

    bool PutDocument(
      const PURL & url,             
      const PBYTEArray & document,  
      const PString & contentType,  
      const PMIMEInfo & mime = PMIMEInfo()   
    );

    bool PutDocument(
      const PURL & url,             
      const PFilePath & document,   
      const PString & contentType = PString::Empty(), 
      const PMIMEInfo & mime = PMIMEInfo()   
    );

    // For backward compatibility
    bool PutTextDocument(const PURL & url, const PString & document, const PString & contentType = PMIMEInfo::TextPlain())
    { return PutDocument(url, document, contentType); }

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

    void SetMaxRedirects(
      unsigned maxRedirects
    ) { m_maxRedirects = maxRedirects; }

    unsigned GetMaxRedirects() const { return m_maxRedirects; }

#if PTRACING
    static PINDEX MaxTraceContentSize;
#endif

  protected:
    PString  m_userAgentName;
    bool     m_persist;
    unsigned m_maxRedirects;
    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;
};


// PWebSocket

#if P_SSL

class PWebSocket : public PIndirectChannel
{
    PCLASSINFO(PWebSocket, PIndirectChannel)
  public:
    PWebSocket();

  // Overrides from PChannel
    virtual PBoolean Read(
      void * buf,   
      PINDEX len    
    );

    virtual PBoolean Write(
      const void * buf, 
      PINDEX len        
    );


    virtual bool Connect(
      const PURL & url,                  
      const PStringArray & protocols,    
      PString * selectedProtocol = NULL  
    );


    virtual bool ReadMessage(
      PBYTEArray & msg
    );

    // Read complete WebSocket text message
    virtual bool ReadText(
      PString & msg
    );

    bool IsMessageComplete() const;

    void SetWriteFragmentation(
      bool frag
    ) { m_fragmentingWrite = frag; }

    void SetBinaryMode(
      bool bin = true
    ) { m_binaryWrite = bin; }

    void SetTextMode(
      bool txt = true
    ) { m_binaryWrite = !txt; }

    void SetSSLCredentials(
      const PString & authority,
      const PString & certificate,
      const PString & privateKey
    );


  protected:
    enum OpCodes
    {
      Continuation = 0x0,
      TextFrame = 0x1,
      BinaryFrame = 0x2,
      ConnectionClose = 0x8,
      Ping = 0x9,
      Pong = 0xA
    };

    virtual bool ReadHeader(
      OpCodes  & opCode,
      bool     & fragment,
      uint64_t & payloadLength,
      int64_t  & masking
    );

    virtual bool WriteHeader(
      OpCodes  opCode,
      bool     fragment,
      uint64_t payloadLength,
      int64_t  masking
    );

    bool InternalRead(void * buf, PINDEX len);
    bool ReadMasked(void * buf, PINDEX len);

    bool InternalWrite(OpCodes  opCode, bool fragmenting, const void * data, PINDEX len);
    bool WriteMasked(const uint32_t * data, PINDEX len, uint32_t mask);

    bool     m_client;
    bool     m_fragmentingWrite;
    bool     m_binaryWrite;
    PDECLARE_MUTEX(m_writeMutex);

    uint64_t m_remainingPayload;
    int64_t  m_currentMask;
    bool     m_fragmentedRead;

    bool     m_recursiveRead;

    PString  m_authority;    // Directory, file or data
    PString  m_certificate;  // File or data
    PString  m_privateKey;   // File or data
};

#endif // P_SSL


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

    void DisablePersistence() { isPersistent = false; }

    PTimeInterval GetPersistenceTimeout() const { return PTimeInterval(0,persistenceSeconds); }

    void SetPersistenceTimeout(const PTimeInterval & t) { persistenceSeconds = t.GetSeconds(); }

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

    bool IsWebSocket() const { return m_isWebSocket; }
    void ClearWebSocket() { m_isWebSocket = false; }

  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;
    bool            m_isWebSocket;
    int             majorVersion;
    int             minorVersion;
    PString         entityBody;        // original entity body (POST only)
    long            entityBodyLength;
    unsigned        persistenceSeconds;
    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 m_urlSpace; }

    void SetURLSpace(
      const PHTTPSpace & space   
    );


    virtual PBoolean ProcessCommand();

    virtual bool OnGET(
      const PHTTPConnectionInfo & conInfo  
    );

    virtual bool OnHEAD(
      const PHTTPConnectionInfo & conInfo 
    );

    virtual bool OnPOST(
      const PHTTPConnectionInfo & conInfo 
    );

    virtual PBoolean OnProxy(
      const PHTTPConnectionInfo & conInfo   
    );


    virtual PString ReadEntityBody();

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

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

    bool SendResponse(
      StatusCode code,      
      const PString & body = PString::Empty()  
    );
    bool SendResponse(
      StatusCode code,      
      PMIMEInfo & headers,  
      const PString & body = PString::Empty()  
    );

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

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

    PHTTPConnectionInfo & GetConnectionInfo() { return m_connectInfo; }

    virtual bool OnCommand(
      PINDEX cmd,
      const PURL & url, 
      const PString & args,
      PHTTPConnectionInfo & connectInfo
    );

    virtual bool OnWebSocket(
      PHTTPConnectionInfo & connectInfo
    );

    typedef PNotifierTemplate<PHTTPConnectionInfo> WebSocketNotifier;

    void SetWebSocketNotifier(
      const PString & protocol,
      const WebSocketNotifier & notifier
    );

    void ClearWebSocketNotifier(
      const PString & protocol
    );

    void SetServiceStartTime(const PTime & startTime) { m_serviceStartTime = startTime; }

    const PTime & GetServiceStartTime() const { return m_serviceStartTime; }

    const PTime & GetLastCommandTime() const { return m_lastCommandTime; }

  protected:
    void Construct();
#if P_SSL
    void SwitchToWebSocket(const PString & protocol, const PString & key);
#endif

    PTime               m_serviceStartTime;
    PTime               m_lastCommandTime;
    PHTTPSpace          m_urlSpace;
    PHTTPConnectionInfo m_connectInfo;
    unsigned            m_transactionCount;
    PTimeInterval       m_nextTimeout;

    typedef std::map<std::string, WebSocketNotifier> WebSocketNotifierMap;
    WebSocketNotifierMap m_webSocketNotifiers;

    P_REMOVE_VIRTUAL(PBoolean,OnGET(const PURL&,const PMIMEInfo&, const PHTTPConnectionInfo&),false);
    P_REMOVE_VIRTUAL(PBoolean,OnHEAD(const PURL&,const PMIMEInfo&,const PHTTPConnectionInfo&),false);
    P_REMOVE_VIRTUAL(PBoolean,OnPOST(const PURL&,const PMIMEInfo&,const PStringToString&,const PHTTPConnectionInfo&),false);
};


// PHTTPListener

class PTCPSocket;

class PHTTPListener
{
public:
  PHTTPListener(
    unsigned maxWorkers = 10
  );

  ~PHTTPListener();

  bool ListenForHTTP(
    WORD port,                
    PSocket::Reusability reuse = PSocket::CanReuseAddress,  
    unsigned queueSize = 10   
  );
  bool ListenForHTTP(
    const PString & interfaces, 
    WORD port,                  
    PSocket::Reusability reuse = PSocket::CanReuseAddress,  
    unsigned queueSize = 10     
  );

  void ShutdownListeners();

  bool IsListening() const { return !m_httpListeningSockets.IsEmpty() && m_httpListeningSockets.front().IsOpen(); }

  WORD GetPort() const { return m_httpListeningSockets.IsEmpty() ? 0 : m_httpListeningSockets.front().GetPort(); }

  virtual PChannel * CreateChannelForHTTP(PChannel * channel);
  virtual PHTTPServer * CreateServerForHTTP();

  virtual void OnHTTPStarted(PHTTPServer & server);

  virtual void OnHTTPEnded(PHTTPServer & server);

  struct Worker
  {
    Worker(PHTTPListener & listener, PTCPSocket * socket);
    ~Worker();
    void Work();

    PHTTPListener & m_listener;
    PTCPSocket    * m_socket;
    PHTTPServer   * m_httpServer; 
    PTime           m_queuedTime;
  };
  typedef PQueuedThreadPool<Worker> ThreadPool;

  const ThreadPool & GetThreadPool() const { return m_threadPool; }
        ThreadPool & GetThreadPool()       { return m_threadPool; }

  const PHTTPSpace & GetSpace() const { return m_httpNameSpace; }
        PHTTPSpace & GetSpace()       { return m_httpNameSpace; }

protected:
  void ListenMain();

  PHTTPSpace         m_httpNameSpace;
  PString            m_listenerInterfaces;
  WORD               m_listenerPort;
  PThread          * m_listenerThread;
  PSocketList        m_httpListeningSockets;
  PList<PHTTPServer> m_httpServers;
  PDECLARE_MUTEX(    m_httpServersMutex);
  ThreadPool         m_threadPool;
};


// 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;  
    PTime              m_arrivalTime; 
};


// 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 & GetLocalRealm() const { return m_realm; }

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

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


  protected:
    PString m_realm;
    PString m_username;
    PString m_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         m_realm;
    PStringToString m_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 m_baseURL; }

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

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

    PHTTPAuthority * GetAuthority() const { return m_authority; }

    void SetAuthority(
      const PHTTPAuthority & auth      
    );

    void ClearAuthority();

    DWORD GetHitCount() const { return m_hitCount; }

    void ClearHitCount() { m_hitCount = 0; }

    virtual bool SupportsWebSocketProtocol(
      const PString & protocol    
    ) const;

    virtual bool OnWebSocket(
      PHTTPServer & server,       
      PHTTPConnectionInfo & connectInfo   
    );

    virtual bool OnGET(
      PHTTPServer & server,       
      const PHTTPConnectionInfo & conInfo  
    );

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

    virtual bool OnHEAD(
      PHTTPServer & server,       
      const PHTTPConnectionInfo & conInfo 
    );

    virtual bool OnPOST(
      PHTTPServer & server,       
      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    
    );

    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 bool InternalOnCommand(
      PHTTPServer & server,       
      const PHTTPConnectionInfo & conInfo,  
      PHTTP::Commands cmd              
    );


    PURL             m_baseURL;     
    PString          m_contentType; 
    PHTTPAuthority * m_authority;   
    atomic<unsigned> m_hitCount;    

    P_REMOVE_VIRTUAL(PBoolean,OnGET(PHTTPServer&,const PURL&,const PMIMEInfo&,const PHTTPConnectionInfo&),false);
    P_REMOVE_VIRTUAL(PBoolean,OnHEAD(PHTTPServer&,const PURL&,const PMIMEInfo&,const PHTTPConnectionInfo &),false);
    P_REMOVE_VIRTUAL(PBoolean,OnGETOrHEAD(PHTTPServer&,const PURL&,const PMIMEInfo&,const PHTTPConnectionInfo&,PBoolean),false);
    P_REMOVE_VIRTUAL(PBoolean,OnPOST(PHTTPServer&,const PURL&,const PMIMEInfo&,const PStringToString&,const PHTTPConnectionInfo&),false);
};


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

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


  protected:
    PString m_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 m_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 m_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 m_basePath;
    PString    m_authorisationRealm;
    bool       m_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   m_fakeIndex;
    PFilePath m_realPath;
};


#endif // P_HTTP

#endif // PTLIB_HTTP_H


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