core.hpp

Go to the documentation of this file.

//*************************************************************************
// File core.hpp
// Date 24.04.2018
// Copyright (c) 2018-2019 by Patrick Fial
//-------------------------------------------------------------------------
// cex Library core definitions
//*************************************************************************

#ifndef __CORE_HPP__
#define __CORE_HPP__

//***************************************************************************
// includes
//***************************************************************************

#include <evhtp/evhtp.h>
#include <event2/thread.h>

#include <thread>
#include <condition_variable>
#include <mutex>
#include <string>
#include <vector>
#include <regex>

#include <plist.hpp>
#include <cex/cex_config.h>

#define IO_BUFFER_SIZE 128*1024

namespace cex
{

//***************************************************************************
// definitions
//***************************************************************************

enum ReturnValues
{
   na=      -1,
   fail=    na,
   yes=     1,
   no=      0,
   success= 0,
   done=    0
};

enum Method
{
   unknownMethod= na,

   methodGET,         // 0 /*!< HTTP GET method */
   methodHEAD,        // 1
   methodPOST,        // 2
   methodPUT,         // 3MaMa
   methodDELETE,      // 4
   methodOPTIONS,     // 5
   methodTRACE,       // 6
   methodCONNECT,     // 7
   methodPATCH,       // 8
   methodMKCOL,       // 9
   methodCOPY,        // 10
   methodMOVE,        // 11
   methodPROPFIND,    // 12
   methodPROPPATCH,   // 13
   methodLOCK,        // 14
   methodUNLOCK,      // 15

   nMethods
};

enum Protocol
{
   unknownProtocol= na,

   protocol10,        // 0
   protocol11,        // 1

   nProtocols
};

class Request;
class Response;

const char* getLibraryVersion();

//***************************************************************************
// types
//***************************************************************************

typedef std::shared_ptr<Request> ReqPtr;
typedef std::shared_ptr<Response> ResPtr;

typedef std::function<void(Request* req, Response* res, std::function<void()> next)> MiddlewareFunction;

typedef std::function<void(Request* req, const char* data, size_t len)> UploadFunction;

typedef std::function<bool(const char* name, const char* value)> PairCallbackFunction;

typedef std::pair<std::string,bool> MimeType;
typedef std::unordered_map<std::string, MimeType> MimeTypes;
typedef std::unique_ptr<std::thread, std::function<void(std::thread* t)>> ThreadPtr;
typedef std::unique_ptr<event_base, std::function<void(event_base*)>> EventBasePtr;

//***************************************************************************
// class Request
//***************************************************************************
class Request
{
   friend class Server;
   friend class Response;
   friend class Middleware;

   public:

      Request(evhtp_request* req);

     // base request info

      Method getMethod();      
      Protocol getProtocol();  
      int getPort();           
      const char* getHost();   
      const char* getUrl();    
      const char* getPath();   
      const char* getFile();   
      const char* getMiddlewarePath();   
      // HTTP header related

      void eachHeader(PairCallbackFunction cb); 

      const char* get(const char* name);

      // URL query parameter related

      void eachQueryParam(PairCallbackFunction cb);
      
      const char* getQueryParam(const char* name);

      // request body

      const char* getBody();     
      size_t getBodyLength();    
      // CEX properties (sessionId, sslClientCert, ...)

      PropertyList properties;

   private:

      void parse();

      static int keyValueIteratorCb(evhtp_kv_t * kv, void * arg);

      evhtp_request* req;
      evhtp_path_t* uri;
      evhtp_authority_t* authority;

      int evhtp_method;
      int port;
      std::string host;
      Method method;
      Protocol protocol;
      std::string middlewarePath;
      std::vector<char> body;
};

//***************************************************************************
// class Response
//***************************************************************************
class Response
{
   public:

      enum State
      {
         stInit, 
         stDone  
      };

      enum Flags
      {
         fNoFlags=         0x0000,

         fCompression=     0x000F,
         fCompressGZip=    0x0001,  
         fCompressDeflate= 0x0002   
      };

      Response(evhtp_request* req);

      void set(const char* name, const char* value);
      
      void set(const char* name, int value);

      int end(const char* string, int status);

      int end(const char* buffer, size_t bufLen, int status);
      
      int end(int status);

      int stream(int status, std::istream* stream);

      bool isState(State aState) { return state == aState; }

      bool isDone() { return isState(stDone); }

      bool isPending() { return !isState(stDone); }

      void setFlags(int newFlags) { flags= newFlags; }

      int getFlags() { return flags; };

   private:

      static evhtp_res sendChunk(evhtp_connection_t* conn, void* arg);

      evhtp_request* req;
      State state;
      int flags;
};

//***************************************************************************
// class Middleware
//***************************************************************************
class Middleware
{
   friend class Server;

   public:

      enum Flags
      {
         fMatchContain= 0x001,  
         fMatchCompare= 0x002,  
         fMatchRegex=   0x004,  
         fMatching=     0x00F
      };

      enum Type
      {
         tpStandard, 
         tpUpload    
      };

      Middleware(const char* path, MiddlewareFunction func, int method= na, int flags= fMatchContain);
      Middleware(const char* path, UploadFunction func, int method= na, int flags= fMatchContain);

      bool match(Request* req);
      const char* getPath() { return path.c_str(); }

   private:

      int type;
      int method;
      int flags;
      std::regex rep;
      std::string path;
      MiddlewareFunction func;
      UploadFunction uploadFunc; 
};

//***************************************************************************
// class Server
//***************************************************************************
class Server
{
   public:

      struct Context
      {
         Context(evhtp_request_t* request, Server* serv)
            : req(new Request(request)), res(new Response(request)), serv(serv) {}

         ReqPtr req;
         ResPtr res;
         Server* serv;
      };

      struct Config
      {
         Config();
         Config(Config& other);
         virtual ~Config();

         int port;              
         std::string address;   
         bool compress;         
         bool parseSslInfo;     
         bool sslEnabled;       
         int threadCount;       
#ifdef CEX_WITH_SSL
         int sslVerifyMode;
         evhtp_ssl_cfg_t* sslConfig;
#endif
      };

      Server();

      Server(Config& config);
      virtual ~Server();

      // server

      int listen(bool block= true);

      int listen(std::string address, int port, bool block= true);

      int stop();

      // router

      void reset() { middleWares.clear(); }

      void use(MiddlewareFunction func);

      void use(const char* path, MiddlewareFunction func, int flags= Middleware::fMatchContain);

      void get(MiddlewareFunction func);

      void get(const char* path, MiddlewareFunction func, int flags= Middleware::fMatchContain);

      void put(MiddlewareFunction func);

      void put(const char* path, MiddlewareFunction func, int flags= Middleware::fMatchContain);

      void post(MiddlewareFunction func);

      void post(const char* path, MiddlewareFunction func, int flags= Middleware::fMatchContain);

      void head(MiddlewareFunction func);

      void head(const char* path, MiddlewareFunction func, int flags= Middleware::fMatchContain);

      void del(MiddlewareFunction func);

      void del(const char* path, MiddlewareFunction func, int flags= Middleware::fMatchContain);

      void connect(MiddlewareFunction func);

      void connect(const char* path, MiddlewareFunction func, int flags= Middleware::fMatchContain);

      void options(MiddlewareFunction func);

      void options(const char* path, MiddlewareFunction func, int flags= Middleware::fMatchContain);


      void trace(MiddlewareFunction func);

      void trace(const char* path, MiddlewareFunction func, int flags= Middleware::fMatchContain);

      void patch(MiddlewareFunction func);

      void patch(const char* path, MiddlewareFunction func, int flags= Middleware::fMatchContain);

      // WEBDAV HTTP methods

      void mkcol(MiddlewareFunction func);

      void mkcol(const char* path, MiddlewareFunction func, int flags= Middleware::fMatchContain);

      void copy(MiddlewareFunction func);

      void copy(const char* path, MiddlewareFunction func, int flags= Middleware::fMatchContain);

      void move(MiddlewareFunction func);

      void move(const char* path, MiddlewareFunction func, int flags= Middleware::fMatchContain);

      void propfind(MiddlewareFunction func);

      void propfind(const char* path, MiddlewareFunction func, int flags= Middleware::fMatchContain);

      void proppatch(MiddlewareFunction func);

      void proppatch(const char* path, MiddlewareFunction func, int flags= Middleware::fMatchContain);

      void lock(MiddlewareFunction func);

      void lock(const char* path, MiddlewareFunction func, int flags= Middleware::fMatchContain);

      void unlock(MiddlewareFunction func);

      void unlock(const char* path, MiddlewareFunction func, int flags= Middleware::fMatchContain);

      // upload hooks to catch file uploads w/ streaming

      void uploads(UploadFunction func);

      void uploads(const char* path, UploadFunction func, Method method= methodPOST, int flags= Middleware::fMatchContain);
 
      // tools

      static MimeTypes* getMimeTypes() { return mimeTypes.get(); }
      static void registerMimeType(const char* ext, const char* mime, bool binary);

      // SSL/TLS

#ifdef CEX_WITH_SSL
      void setSslOption(const char* option, const char* value);
      void getSslClientInfo(Request* req);
#endif

      static void libraryInit();

   private:

      int start(bool block);

      static int initMimeTypes();

      static void handleRequest(evhtp_request* req, void* arg);
      static evhtp_res handleHeaders(evhtp_request_t* request, evhtp_headers_t* hdr, void* arg);
      static evhtp_res handleBody(evhtp_request_t* req, struct evbuffer* buf, void* arg);
      static evhtp_res handleFinished(evhtp_request_t* req, void* arg);

#ifdef CEX_WITH_SSL
      static int verifyCert(int ok, X509_STORE_CTX* store);
#endif

      // members

      std::vector<std::unique_ptr<Middleware>> middleWares;
      std::vector<std::unique_ptr<Middleware>> uploadWares;

      Config serverConfig;

      // server control

      EventBasePtr eventBase;
      ThreadPtr backgroundThread;
      std::mutex startMutex;
      std::condition_variable startCond;
      bool startSignaled;
      bool started;

      // global/static stuff

      static bool initialized;
      static std::mutex initMutex;
      static std::unique_ptr<MimeTypes> mimeTypes;
};

//***************************************************************************
} // namespace cex

#endif // __CORE_HPP_