mi32/httpserver.h

Go to the documentation of this file.

/******************************************************************************
 *
 * \file mi32/httpserver.h
 * \brief HTTP Server
 *
 * \if NODOC
 * $Log: httpserver.h_v $
 * Revision 1.5  2005/07/15 16:33:22  mju
 * Fix ending endif.
 *
 * Revision 1.4  2005/04/12 14:48:34  dwilliss
 * Renamed our class to avoid name conflict with Windows includes
 * Made destructor virtual
 *
 * Revision 1.3  2004/01/29 18:19:40  dwilliss
 * *** empty log message ***
 *
 * Revision 1.2  2004/01/08 16:41:43  dwilliss
 * More complete now
 *
 * Revision 1.1  2004/01/02 22:58:03  dwilliss
 * Initial revision
 *
 * \endif
 *
 *****************************************************************************/

#ifndef INC_MI32_HTTPSERVER_H
#define INC_MI32_HTTPSERVER_H

#ifndef INC_MI32_HTTPCLIENT_H
#include <mi32/httpclient.h>
#endif

#ifndef INC_MI32_FILEPATH_H
#include <mi32/filepath.h>
#endif

#ifdef MISYSTEMDLL
   #define CLASSLIBEXPORT MI_DLLCLASSEXPORT
#else
   #define CLASSLIBEXPORT MI_DLLCLASSIMPORT
#endif


class CLASSLIBEXPORT HTTPSERVER {
   public:
   
      class PATH;
      class HANDLER;
      class FILEHANDLER;
      class UPLOADHANDLER;
      class CLIENT;

      HTTPSERVER();
      virtual ~HTTPSERVER();

      ERRVALUE AddListenSocket (
         const MISOCKET::ADDR& address
         );

      ERRVALUE AddListenSocket (
         MISOCKET* sock,
         bool bTakeOwnership = true
         );

      ERRVALUE AddMIMEType (
         const char* extn,       
         const char* mimetype    
         );

      ERRVALUE AddHandler (
         HANDLER* handler
         );

      ERRVALUE AddPath (
         PATH* path
         );

      void GenerateStatusPage (
         MISTRING& mistr
         );


      // Find the MIME type for a given file.
      // \return a MIME type string if know, NULL if not
      const char* FindMIMEType (
         const FILEPATH& filepath
         );

      PATH* FindPath (
         const HTTPMESSAGE& msg
         );

      void Shutdown (
         );

   private:
#ifndef GENERATING_DOXYGEN_OUTPUT
      struct MIMEEXTN {
         char* extn;
         char* mime;
         };

      class LISTENER;
      friend class LISTENER;  // Needs access to RemoveListener()
      friend class CLIENT;    // Needs access to RemoveClient()
      friend class PATH;      // Needs access to handler list

      // Add a new client.  Only called by a listener
      void AddClient (
         CLIENT* client
         );

      // Remove a client.  Only called by clients in their OnClose methods
      void RemoveClient (
         CLIENT* client
         );

      // Remove a listener.  Only called by listeners in their distructors
      void RemoveListener (
         LISTENER* listener
         );
#endif

      virtual HTTPSERVER::CLIENT* v_AllocateClient (
         MISOCKET* sock
         );

      virtual void v_OnClientConnect (
         CLIENT* client
         );

      virtual void v_OnClientDisconnect (
         CLIENT* client
         );
#ifndef GENERATING_DOXYGEN_OUTPUT

      // copy const and assignment operator private and unimplemented.
      HTTPSERVER(const HTTPSERVER&);
      HTTPSERVER& operator=(const HTTPSERVER&);

      static const MIMEEXTN s_BuiltInMIMETypes[];
      SIMPLE_ARRAY<LISTENER*> m_Listeners;
      SIMPLE_ARRAY<CLIENT*> m_Clients;
      SIMPLE_ARRAY<PATH*> m_Paths;
      SIMPLE_ARRAY<HANDLER*> m_Handlers;
      SIMPLE_ARRAY<MIMEEXTN> m_MIMETypes;
      bool m_bShuttingDown;

#endif

   };


/****************************************************************************/

class CLASSLIBEXPORT HTTPSERVER::PATH {
   public:
      PATH (
         HTTPSERVER& server,
         const char* virtualpath
         );

      virtual ~PATH();

      ERRVALUE AddHandler (
         HTTPSERVER::HANDLER* handler
         );

      bool Matches (
         const char* path
         ) const;

      HTTPSERVER& GetServer (
         );

      const char* GetVirtualPath (
         ) const;

      bool ProcessRequest (
         HTTPSERVER::CLIENT* client,
         const HTTPMESSAGE& request
         );

      void SetMethodAllowed (
         HTTPMESSAGE::METHOD method,
         bool bIsAllowed = true
         );

   private:

      HTTPSERVER& m_Server;
      STRUTF8 m_VirtualPath;  // Path relative to server root
      SIMPLE_ARRAY<HTTPSERVER::HANDLER*> m_Handlers;
      bool m_AllowedMethods[HTTPMESSAGE::METHOD_NUM_METHODS];  // 

      virtual bool v_ProcessRequest (
         HTTPSERVER::CLIENT* client,
         const HTTPMESSAGE& request
         );

   };

/****************************************************************************/
class CLASSLIBEXPORT HTTPSERVER::HANDLER {
   public:
      HANDLER (
         HTTPSERVER& server,
         const char* name     
         );

      virtual ~HANDLER();

      // Get name used for configuration file settings
      const char* GetName (
         );

      HTTPSERVER& GetServer (
         );

      int Matches (
         const HTTPMESSAGE& request
         ) const;

      bool ProcessRequest (
         HTTPSERVER::CLIENT* client,
         const HTTPMESSAGE& request
         );

      // Determine if this handler can handle a specific method
      bool CanHandleMethod (
         HTTPMESSAGE::METHOD method
         ) const;

   protected:

   private:

      // Should return if this handler can handle a specific method.
      // Returns false otherwise.
      // This does not need to worry about permissions set on the virtual
      // path - that's handled by the caller.
      virtual bool v_CanHandleMethod (
         HTTPMESSAGE::METHOD method
         )  const = 0;

      virtual int v_Matches (
         const HTTPMESSAGE& request
         ) const = 0;

      virtual bool v_ProcessRequest (
         HTTPSERVER::CLIENT* client,
         const HTTPMESSAGE& request
         ) = 0;

      HTTPSERVER& m_Server;
      const char* m_name;

   };

/****************************************************************************/
class CLASSLIBEXPORT HTTPSERVER::FILEHANDLER : public HTTPSERVER::HANDLER {
   public:

      FILEHANDLER (
         HTTPSERVER& server,
         const FILEPATH& DocumentRoot
         );

      virtual ~FILEHANDLER();

   private:
#ifndef GENERATING_DOXYGEN_OUTPUT
      virtual int v_Matches (
         const HTTPMESSAGE& request
         ) const;

      virtual bool v_CanHandleMethod (
         HTTPMESSAGE::METHOD method
         ) const;

      virtual bool v_ProcessRequest (
         HTTPSERVER::CLIENT* client,
         const HTTPMESSAGE& request
         );

      FILEPATH m_DocumentRoot;
#endif
   };

/****************************************************************************/
class CLASSLIBEXPORT HTTPSERVER::UPLOADHANDLER : public HTTPSERVER::HANDLER {
   public:

      UPLOADHANDLER (
         HTTPSERVER& server,
         const FILEPATH& DocumentRoot
         );

      virtual ~UPLOADHANDLER();

   private:
#ifndef GENERATING_DOXYGEN_OUTPUT
      virtual int v_Matches (
         const HTTPMESSAGE& request
         ) const;

      virtual bool v_CanHandleMethod (
         HTTPMESSAGE::METHOD method
         ) const;

      virtual bool v_ProcessRequest (
         HTTPSERVER::CLIENT* client,
         const HTTPMESSAGE& request
         );

      FILEPATH m_DocumentRoot;
#endif
   };


/****************************************************************************/

class CLASSLIBEXPORT HTTPSERVER::CLIENT : public HTTPCLIENT {
   public:
      CLIENT (
         HTTPSERVER& server,
         MISOCKET* sock
         );

      ~CLIENT();

      // Send an error message back to the client.
      // If err is < 0, the MicroImages error message will be included
      void SendErrorReply (
         HTTPMESSAGE::STATUS status,
         const HTTPMESSAGE& request,
         ERRVALUE err = 0
         );


   private:

      // virtual, Implemented from MISOCKET::CLIENT, but derived class cannot
      // override it
      void v_OnClose (
         );

      // virtual, Implemented from MISOCKET::CLIENT, but derived class cannot
      // override it
      void v_OnMessage (
         const HTTPMESSAGE&
         );

      HTTPSERVER& m_Server;
      bool m_bDestroying;
   };


#undef CLASSLIBEXPORT


#endif // INC_MI32_HTTPSERVER_H

---