ulxr_http_server.h

Go to the documentation of this file.

/***************************************************************************
                    ulxr_http_server.h  -  a simple http server
                             -------------------
    begin                : Sam Apr 20 2002
    copyright            : (C) 2002-2007 by Ewald Arnold
    email                : ulxmlrpcpp@ewald-arnold.de

    $Id: ulxr_http_server.h 948 2007-01-13 17:50:05Z ewald-arnold $

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

/**************************************************************************
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2 of the License,
 * or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 ***************************************************************************/

#ifndef ULXR_HTTP_SERVER_H
#define ULXR_HTTP_SERVER_H

#ifndef ULXR_OMIT_TCP_STUFF

#include <ulxmlrpcpp/ulxmlrpcpp.h>  // always first header

#include <vector>
#include <map>
#include <cstdio>


namespace ulxr {


class HttpProtocol;
class Dispatcher;
class Exception;
class MethodHandler;
class CachedResource;

class ULXR_API_DECL0 HttpServer
{
 public:

   class ThreadData;

   HttpServer (HttpProtocol* prot, bool wbxml = false);

#ifdef ULXR_MULTITHREADED

   HttpServer (HttpProtocol* prot, unsigned num, bool wbxml = false);

#endif

   virtual ~HttpServer ();

   std::size_t runPicoHttpd();

   void setHttpRoot(const CppString &root);

   virtual void addRealm(const CppString &path, const CppString &realm);

   virtual CppString getRealm(const CppString &path) const;

   void addHttpHandler(const CppString &name,
                       MethodHandler *handler);
 /*
   void removeHttpHandler(const CppString &name,
                          MethodHandler *handler);
*/

   void addResource(CachedResource *cache);

   CachedResource * getResource(const CppString& name);

   void setRpcDispatcher(Dispatcher *disp);

   void requestTermination();

   void addAuthentication(const CppString &user,
                          const CppString &pass,
                          const CppString &realm);

#ifdef ULXR_MULTITHREADED

    unsigned numThreads() const;

    void terminateAllThreads(unsigned time = 0);

    void shutdownAllThreads(unsigned time = 0);

    void waitAsync(bool term, bool stat = false);

#endif // ULXR_MULTITHREADED

 protected:

#ifdef ULXR_MULTITHREADED

    void printStatistics() const;

#endif // ULXR_MULTITHREADED

    virtual void forwardThreadedError(const Exception &ex) const;

   virtual void executeHttpMethod(HttpProtocol *prot,
                                  Cpp8BitString &conn_pending_data,
                                  const CppString& name,
                                  const CppString& resource);

   virtual void executeUnknownHttpMethod(HttpProtocol *prot,
                                         Cpp8BitString &conn_pending_data,
                                         const CppString& name,
                                         const CppString& resource);

   virtual void executeHttpGET(HttpProtocol *prot,
                               const CppString& resource);

   virtual void executeHttpPUT(HttpProtocol *prot,
                               Cpp8BitString &conn_pending_data,
                               const CppString& resource);

   virtual void executeHttpPOST(HttpProtocol *prot,
                                Cpp8BitString &conn_pending_data,
                                const CppString& resource);

   virtual void executeHttpRPC(HttpProtocol *prot,
                               Cpp8BitString &conn_pending_data);

   virtual void executeHttpDELETE(HttpProtocol *prot,
                                  const CppString& resource);

   void performHttpTransaction(HttpProtocol *prot);

   virtual void interpreteHttpHeader(HttpProtocol *prot,
                                     CppString &head_resource,
                                     CppString &head_method,
                                     CppString &head_version);

   CppString stripResource(const CppString &resource);

   virtual void checkValidPath(const CppString &resource);

   CppString createLocalName(const CppString &resource);

   virtual CppString guessMimeType(const CppString &name) const;

  private:

   virtual void beforeHttpTransaction();

   virtual void afterHttpTransaction();

   std::size_t runPicoHttpd(HttpProtocol *prot, ThreadData *td = 0);

#ifdef ULXR_MULTITHREADED

   static void *startThread(ThreadData *td);

   void releaseThreads();

   unsigned dispatchAsync();

#endif // ULXR_MULTITHREADED

   void releaseHandlers(std::vector<MethodHandler*> &handlers);

   void init();

 private:

   CppString    rpc_resource_root;
   CppString    http_root_dir;
   bool         pico_shall_run;
   bool         wbxml_mode;

   Dispatcher                  *rpc_dispatcher;
   HttpProtocol                *base_protocol;
#ifdef ULXR_MULTITHREADED
   std::vector<ThreadData*>     threads;
#endif

   std::vector<MethodHandler*>  getHandlers;
   std::vector<MethodHandler*>  putHandlers;
   std::vector<MethodHandler*>  postHandlers;
   std::vector<MethodHandler*>  deleteHandlers;

   std::vector<CachedResource*>  resources;

   std::map<CppString, CppString>  realmXrefs;

 private:

   // forbid them all due to internal pointers
   HttpServer(const HttpServer&);
   HttpServer& operator=(const HttpServer&);
};


namespace hidden {


class ULXR_API_DECL0 MethodHandlerWrapperBase
{
  public:


    virtual ~MethodHandlerWrapperBase()
    {}

    virtual bool handle(HttpProtocol *prot,
                        const CppString &method,
                        const CppString &resource,
                        const Cpp8BitString &conn_data) const = 0;
};


template <class T>
class MethodHandlerWrapper : public MethodHandlerWrapperBase
{
  public:

   typedef bool (T::*PMF)(HttpProtocol *prot,
                          const CppString &method,
                          const CppString &resource,
                          const Cpp8BitString &conn_data);

   virtual ~MethodHandlerWrapper()
   {
   }

   virtual bool handle(HttpProtocol *prot,
                       const CppString &method,
                       const CppString &resource,
                       const Cpp8BitString &conn_data) const
   {
      return (obj->*adr) (prot, method, resource, conn_data);
   }

  public:

   MethodHandlerWrapper(T *o, PMF a)
     : obj(o), adr(a)
   {
   }

  private:
   T    *obj;
   PMF   adr ;
};

typedef bool (*StaticMethodHandler)(HttpProtocol *prot,
                                    const CppString &method,
                                    const CppString &resource,
                                    const Cpp8BitString &conn_data);

typedef MethodHandlerWrapperBase *DynamicMethodHandler;    // call Wrappers handler


} // namspace hidden


class ULXR_API_DECL0 MethodHandler
{
 public:
    MethodHandler(hidden::StaticMethodHandler handler);

    MethodHandler(hidden::DynamicMethodHandler handler);

    virtual ~MethodHandler();

    bool handle(HttpProtocol *prot,
                const CppString &method,
                const CppString &resource,
                const Cpp8BitString &conn_data);

  private:

    hidden::StaticMethodHandler    static_handler;
    hidden::DynamicMethodHandler   dynamic_handler;

    // forbid them all due to internal pointers
    const MethodHandler& operator= (const MethodHandler&);
    MethodHandler (const MethodHandler&);
};


#ifndef _MSC_VER

template <class T>
inline MethodHandler*
make_methodhandler(T &w, typename hidden::MethodHandlerWrapper<T>::PMF pmf)
{
  return new MethodHandler(new hidden::MethodHandlerWrapper<T> (&w, pmf));
}

#else // work around m$vc bug

template <class T, class U>
inline MethodHandler*
make_methodhandler(T &w, U pmf)
{
  return new MethodHandler(new hidden::MethodHandlerWrapper<T> (&w, pmf));
}

#endif

inline ULXR_API_IMPL(MethodHandler*)
make_methodhandler(hidden::StaticMethodHandler ptr)
{
  return new MethodHandler(ptr);
}


}  // namespace ulxr


#endif // ULXR_OMIT_TCP_STUFF


#endif // ULXR_HTTP_SERVER_H

---