httpsvc.h

Go to the documentation of this file.

/*
 * httpsvc.h
 *
 * Common classes for service applications using HTTP as the user interface.
 *
 * 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_HTTPSVC_H
#define PTLIB_HTTPSVC_H

#if P_HTTPFORMS

#include <ptlib/svcproc.h>
#include <ptlib/sockets.h>
#include <ptclib/httpform.h>
#include <ptclib/cypher.h>


class PHTTPServiceProcess;
class PConfigPage;



class PHTTPServiceProcess : public PServiceProcess, public PHTTPListener
{
  PCLASSINFO(PHTTPServiceProcess, PServiceProcess)

  public:
    enum {
      MaxSecuredKeys = 10
    };
    struct Info {
      const char * productName;
      const char * manufacturerName;

      WORD majorVersion;
      WORD minorVersion;
      CodeStatus buildStatus;    
      WORD patchVersion;
      const char * compilationDate;

      PTEACypher::Key productKey;  
      const char * securedKeys[MaxSecuredKeys]; 
      PINDEX securedKeyCount;

      PTEACypher::Key signatureKey;   

      const char * manufHomePage; 
      const char * email;         
      const char * productHTML;   
      const char * gifHTML;       
      const char * gifFilename;   
      int gifWidth;               
      int gifHeight;              

      const char * copyrightHolder;   
      const char * copyrightHomePage; 
      const char * copyrightEmail;    

      WORD oemVersion;
    };

    PHTTPServiceProcess(const Info & inf);
    ~PHTTPServiceProcess();

    PBoolean OnStart();
    void OnStop();
    PBoolean OnPause();
    void OnContinue();
    const char * GetServiceDependencies() const;

    virtual void OnConfigChanged() = 0;
    virtual PBoolean Initialise(const char * initMsg) = 0;

    static const PString & GetDefaultSection();

    class ClearLogPage;

    struct Params
    {
      Params(
        const char * configPageName,
        const char * section = GetDefaultSection()
      );
      virtual ~Params() { }

      const char  * m_configPageName;
      const char  * m_section;
      PConfigPage * m_configPage;   // Output

      // Authentication
      const char    * m_realmKey;
      const char    * m_usernameKey;
      const char    * m_passwordKey;
      PHTTPSimpleAuth m_authority;  // Output

      // Logging
      bool         m_forceRotate;
      const char * m_logLevelKey;
      const char * m_logFileKey;
      const char * m_logOptionsKey;
      const char * m_rotateDirKey;
      const char * m_rotatePrefixKey;
      const char * m_rotateTemplateKey;
      const char * m_rotateSizeKey;
      const char * m_rotateCountKey;
      const char * m_rotateAgeKey;
      const char * m_fullLogPageName;
      const char * m_clearLogPageName;
      const char * m_tailLogPageName;

      PHTTPFile     * m_fullLogPage;    // Output
      ClearLogPage  * m_clearLogPage;   // Output
      PHTTPTailFile * m_tailLogPage;    // Output

      // HTTP access
      const char *  m_httpPortKey;
      const char *  m_httpInterfacesKey;
      WORD          m_httpPort;         // Output
      PString       m_httpInterfaces;
    };
    virtual bool InitialiseBase(
      Params & params
    );


    virtual PString GetPageGraphic();
    void GetPageHeader(PHTML &);
    void GetPageHeader(PHTML &, const PString & title);

    virtual PString GetCopyrightText();

    const PString & GetMacroKeyword() const { return m_macroKeyword; }
    const PTime & GetCompilationDate() const { return m_compilationDate; }
    const PString & GetHomePage() const { return m_manufacturersHomePage; }
    const PString & GetEMailAddress() const { return m_manufacturersEmail; }
    const PString & GetProductName() const { return m_productNameHTML; }
    const PString & GetGifHTML() const { return m_gifHTML; }
    const PString & GetCopyrightHolder() const { return m_copyrightHolder; }
    const PString & GetCopyrightHomePage() const { return m_copyrightHomePage; }
    const PString & GetCopyrightEmail() const { return m_copyrightEmail; }
    const PTEACypher::Key & GetProductKey() const { return m_productKey; }
    const PStringArray & GetSecuredKeys() const { return m_securedKeys; }
    const PTEACypher::Key & GetSignatureKey() const { return m_signatureKey; }
    bool ShouldIgnoreSignatures() const { return m_ignoreSignatures; }
    void SetIgnoreSignatures(bool ig) { m_ignoreSignatures = ig; }

    static PHTTPServiceProcess & Current();

    virtual void AddRegisteredText(PHTML & html);
    virtual void AddUnregisteredText(PHTML & html);
    virtual PBoolean SubstituteEquivalSequence(PHTTPRequest & request, const PString &, PString &);

  protected:
    PString         m_macroKeyword;
    PTEACypher::Key m_productKey;
    PStringArray    m_securedKeys;
    PTEACypher::Key m_signatureKey;
    bool            m_ignoreSignatures;

    PTime      m_compilationDate;
    PString    m_manufacturersHomePage;
    PString    m_manufacturersEmail;
    PString    m_productNameHTML;
    PString    m_gifFilename;
    unsigned   m_gifWidth;
    unsigned   m_gifHeight;
    PString    m_gifHTML;
    PString    m_copyrightHolder;
    PString    m_copyrightHomePage;
    PString    m_copyrightEmail;

    void BeginRestartSystem();
    void EndRestartSystem();
    virtual void OnHTTPEnded(PHTTPServer & server);

    atomic<PThread *> m_restartThread;

  friend class PConfigPage;
  friend class PConfigSectionsPage;
  P_REMOVE_VIRTUAL(PHTTPServer*, CreateHTTPServer(PChannel &),0);
  P_REMOVE_VIRTUAL(PHTTPServer*, OnCreateHTTPServer(const PHTTPSpace &),0);
};




class PConfigPage : public PHTTPConfig
{
  PCLASSINFO(PConfigPage, PHTTPConfig)
  public:
    PConfigPage(
      PHTTPServiceProcess & app,
      const PString & section,
      const PHTTPAuthority & auth
    );
    PConfigPage(
      PHTTPServiceProcess & app,
      const PString & url,
      const PString & section,
      const PHTTPAuthority & auth
    );

    void OnLoadedText(PHTTPRequest &, PString & text);

    virtual PBoolean OnPOST(
      PHTTPServer & server,
      const PHTTPConnectionInfo & connectInfo
    );

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

  protected:
    virtual PBoolean GetExpirationDate(
      PTime & when          
    );

    PHTTPServiceProcess & process;
};



class PConfigSectionsPage : public PHTTPConfigSectionList
{
  PCLASSINFO(PConfigSectionsPage, PHTTPConfigSectionList)
  public:
    PConfigSectionsPage(
      PHTTPServiceProcess & app,
      const PURL & url,
      const PHTTPAuthority & auth,
      const PString & prefix,
      const PString & valueName,
      const PURL & editSection,
      const PURL & newSection,
      const PString & newTitle,
      PHTML & heading
    );

    void OnLoadedText(PHTTPRequest &, PString & text);

    virtual PBoolean OnPOST(
      PHTTPServer & server,
      const PHTTPConnectionInfo & connectInfo
    );

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

  protected:
    virtual PBoolean GetExpirationDate(
      PTime & when          
    );

    PHTTPServiceProcess & process;
};



class PRegisterPage : public PConfigPage
{
  PCLASSINFO(PRegisterPage, PConfigPage)
  public:
    PRegisterPage(
      PHTTPServiceProcess & app,
      const PHTTPAuthority & auth
    );

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

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

    virtual void AddFields(
      const PString & prefix        
    ) = 0;

  protected:
    PHTTPServiceProcess & process;
};



class PServiceHTML : public PHTML
{
  PCLASSINFO(PServiceHTML, PHTML)
  public:
    PServiceHTML(const char * title,
                 const char * help = NULL,
                 const char * helpGif = "help.gif");

    PString ExtractSignature(PString & out);
    static PString ExtractSignature(const PString & html,
                                    PString & out,
                                    const char * keyword = "#equival");

    PString CalculateSignature();
    static PString CalculateSignature(const PString & out);
    static PString CalculateSignature(const PString & out, const PTEACypher::Key & sig);

    PBoolean CheckSignature();
    static PBoolean CheckSignature(const PString & html);

    enum MacroOptions {
      NoOptions           = 0,
      NeedSignature       = 1,
      LoadFromFile        = 2,
      NoURLOverride       = 4,
      NoSignatureForFile  = 8
    };
    static bool ProcessMacros(
      PHTTPRequest & request,
      PString & text,
      const PString & filename,
      unsigned options
    );
    static bool SpliceMacro(
      PString & text,
      const PString & tokens,
      const PString & value
    );
};



class PServiceMacro : public PObject
{
  public:
    PServiceMacro(const char * name, PBoolean isBlock);
    PServiceMacro(const PCaselessString & name, PBoolean isBlock);
    Comparison Compare(const PObject & obj) const;
    virtual PString Translate(
      PHTTPRequest & request,
      const PString & args,
      const PString & block
    ) const;
  protected:
    const char * macroName;
    PBoolean isMacroBlock;
    PServiceMacro * link;
    static PServiceMacro * list;
  friend class PServiceMacros_list;
};


#define P_EMPTY

#define PCREATE_SERVICE_MACRO(name, request, args) \
  class PServiceMacro_##name : public PServiceMacro { \
    public: \
      PServiceMacro_##name() : PServiceMacro(#name, false) { } \
      PString Translate(PHTTPRequest &, const PString &, const PString &) const; \
  }; \
  static const PServiceMacro_##name serviceMacro_##name; \
  PString PServiceMacro_##name::Translate(PHTTPRequest & request, const PString & args, const PString &) const



#define PCREATE_SERVICE_MACRO_BLOCK(name, request, args, block) \
  class PServiceMacro_##name : public PServiceMacro { \
    public: \
      PServiceMacro_##name() : PServiceMacro(#name, true) { } \
      PString Translate(PHTTPRequest &, const PString &, const PString &) const; \
  }; \
  static const PServiceMacro_##name serviceMacro_##name; \
  PString PServiceMacro_##name::Translate(PHTTPRequest & request, const PString & args, const PString & block) const




class PServiceHTTPString : public PHTTPString
{
  PCLASSINFO(PServiceHTTPString, PHTTPString)
  public:
    PServiceHTTPString(const PURL & url, const PString & string)
      : PHTTPString(url, string) { }

    PServiceHTTPString(const PURL & url, const PHTTPAuthority & auth)
      : PHTTPString(url, auth) { }

    PServiceHTTPString(const PURL & url, const PString & string, const PHTTPAuthority & auth)
      : PHTTPString(url, string, auth) { }

    PServiceHTTPString(const PURL & url, const PString & string, const PString & contentType)
      : PHTTPString(url, string, contentType) { }

    PServiceHTTPString(const PURL & url, const PString & string, const PString & contentType, const PHTTPAuthority & auth)
      : PHTTPString(url, string, contentType, auth) { }

    PString LoadText(PHTTPRequest &);

  protected:
    virtual PBoolean GetExpirationDate(
      PTime & when          
    );
};


class PServiceHTTPFile : public PHTTPFile
{
  PCLASSINFO(PServiceHTTPFile, PHTTPFile)
  public:
    PServiceHTTPFile(const PString & filename, PBoolean needSig = false)
      : PHTTPFile(filename) { needSignature = needSig; }
    PServiceHTTPFile(const PString & filename, const PFilePath & file, PBoolean needSig = false)
      : PHTTPFile(filename, file) { needSignature = needSig; }
    PServiceHTTPFile(const PString & filename, const PString & file, PBoolean needSig = false)
      : PHTTPFile(filename, file) { needSignature = needSig; }
    PServiceHTTPFile(const PString & filename, const PHTTPAuthority & auth, PBoolean needSig = false)
      : PHTTPFile(filename, auth) { needSignature = needSig; }
    PServiceHTTPFile(const PString & filename, const PFilePath & file, const PHTTPAuthority & auth, PBoolean needSig = false)
      : PHTTPFile(filename, file, auth) { needSignature = needSig; }

    void OnLoadedText(PHTTPRequest &, PString & text);

  protected:
    virtual PBoolean GetExpirationDate(
      PTime & when          
    );

    PBoolean needSignature;
};

class PServiceHTTPDirectory : public PHTTPDirectory
{
  PCLASSINFO(PServiceHTTPDirectory, PHTTPDirectory)
  public:
    PServiceHTTPDirectory(const PURL & url, const PDirectory & dirname, PBoolean needSig = false)
      : PHTTPDirectory(url, dirname) { needSignature = needSig; }

    PServiceHTTPDirectory(const PURL & url, const PDirectory & dirname, const PHTTPAuthority & auth, PBoolean needSig = false)
      : PHTTPDirectory(url, dirname, auth) { needSignature = needSig; }

    void OnLoadedText(PHTTPRequest &, PString & text);

  protected:
    virtual PBoolean GetExpirationDate(
      PTime & when          
    );

    PBoolean needSignature;
};


class PHTTPServiceProcess::ClearLogPage : public PServiceHTTPString
{
    PCLASSINFO(ClearLogPage, PServiceHTTPString);
  public:
    ClearLogPage(PHTTPServiceProcess & process, const PURL & url, const PHTTPAuthority & auth);

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

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

  protected:
    PHTTPServiceProcess & m_process;
};


#endif // P_HTTPFORMS

#endif // PTLIB_HTTPSVC_H


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