http.h

Go to the documentation of this file.

/*
  Copyright (c) Mircea Neacsu (2014-2025) Licensed under MIT License.
  This file is part of MLIB project. See LICENSE file for full license terms.
*/

#pragma once
 
#include "tcpserver.h"
#include <string>
#include <map>
#include <deque>
#include <typeindex>
#include <filesystem>

#define HTTP_MAX_HEADER 8192

#define HTTP_TIMEOUT 30

#define HTTP_OK         0     
#define HTTP_ERR_WRITE  -1    
#define HTTP_ERR_FOPEN  -2    
#define HTTP_ERR_FREAD  -3    
#define HTTP_NO_HANDLER -4    
#define HTTP_CONTINUE   1     
 
namespace mlib::http {
 
class connection;

struct ci_less : public std::function<bool (std::string, std::string)>
{
  bool operator() (const std::string& lhs, const std::string& rhs) const
  {
    return _stricmp (lhs.c_str (), rhs.c_str ()) < 0;
  }
};

typedef std::map<std::string, std::string, ci_less> str_pairs;

typedef std::function<int (connection& client, void* info)> uri_handler;

class connection : public thread
{
  friend class server;
 
public:

  const std::string& get_path () const;

  const std::string& get_method () const;

  const std::string& get_query () const;

  const std::string& get_body () const;
 
  void add_ohdr (const std::string& hdr, const std::string& value);

  bool has_ihdr (const std::string& hdr) const;

  const std::string& get_ihdr (const std::string& hdr) const;

  const str_pairs& get_request_headers () const;

  const str_pairs& get_response_headers () const;

  bool has_ohdr (const std::string& hdr) const;

  const std::string& get_ohdr (const std::string& hdr) const;

  bool has_qparam (const std::string& key);

  const std::string& get_qparam (const std::string& key);

  bool has_bparam (const std::string& key);

  const std::string& get_bparam (const std::string& key);

  const std::string& get_auth_user ();

  int get_content_length () const;
 
  sockstream& out ();
  
  void respond (unsigned int code, const std::string& reason = std::string());
  void redirect (const std::string& uri, unsigned int code = 303);
  void serve404 (const char* text = 0);
  int serve_file (const std::filesystem::path& file);
  int serve_shtml (const std::filesystem::path& file);
  int serve_buffer (const BYTE* buffer, size_t sz);
  int serve_buffer (const std::string& str);
 
protected:
  connection (sock& socket, server& server);

  void run () override;

  void term () override;

  server& parent;

  sockstream ws;
 
private:
  bool parse_request (const std::string& req);
  bool parse_headers (const std::string& hdrs);
  bool parse_body ();
  void parse_query ();
  void process_valid_request ();
  void process_ssi (const char* request);
  bool do_auth ();
  void serve401 (const std::string& realm);
  bool should_close ();
  void request_init ();
  void serve_options ();
 
 
  std::string path_;         
  std::string query_;        
  std::string method_;       
  std::string http_version;  
  std::string body;          
  int content_len;           
  std::string part_boundary; 
  bool response_sent;        
  str_pairs oheaders;
  str_pairs iheaders;
  str_pairs qparams;
  str_pairs bparams;
  bool query_parsed, body_parsed;
  std::string auth_user;  
  std::string auth_realm; 
 
  friend struct UnitTest_connection;
};

class server : public tcpserver
{
public:
  explicit server (unsigned short port = 0, unsigned int maxconn = 0);
  ~server ();
 
  void add_ohdr (const std::string& hdr, const std::string& value);
  void remove_ohdr (const std::string& hdr);

  void add_handler (const std::string& uri, uri_handler func, void* info = 0);

  void add_post_handler (const std::string& uri, uri_handler func, void* info = 0);

  void add_user (const std::string& realm, const std::string& username, const std::string& pwd);

  void remove_user (const std::string& realm, const std::string& username);

  void add_secured_path (const std::string& realm, const std::string& uri);

  template <typename T>
  void add_var (const std::string& name, const T* addr, const char* fmt = nullptr)
  {
    constexpr vtype t = std::is_same_v<T, bool>             ? VT_BOOL
                        : std::is_same_v<T, char>           ? VT_CHAR
                        : std::is_same_v<T, std::string>    ? VT_STRING
                        : std::is_same_v<T, short>          ? VT_SHORT
                        : std::is_same_v<T, unsigned short> ? VT_USHORT
                        : std::is_same_v<T, int>            ? VT_INT
                        : std::is_same_v<T, unsigned int>   ? VT_UINT
                        : std::is_same_v<T, long>           ? VT_LONG
                        : std::is_same_v<T, unsigned long>  ? VT_ULONG
                                                            : VT_UNKNOWN;
    static_assert (t != VT_UNKNOWN);
    add_var (name, t, addr, fmt);
  }

  template <typename T>
  std::enable_if_t<std::is_floating_point_v<T>> add_var (const std::string& name, const T* addr,
                                                          const char* fmt = nullptr,
                                                          double multiplier = 1.)
  {
    constexpr vtype t = std::is_same_v<T, float>   ? VT_FLOAT
                        : std::is_same_v<T, float> ? VT_DOUBLE
                                                    : VT_UNKNOWN;
    static_assert (t != VT_UNKNOWN);
    add_var (name, t, addr, fmt, multiplier);
  }
 
  const std::string get_var (const std::string& name);
  void aquire_varlock ();
  void release_varlock ();
  bool try_varlock ();
 
  void name (const std::string& name_);
  void docroot (const std::filesystem::path& path);
  const std::filesystem::path& docroot () const;
  void add_alias (const std::string& uri, const std::string& path);
 
  void default_uri (const std::string& name);
  const std::string& default_uri () const;
 
  void keep_alive (unsigned int seconds);
  unsigned int keep_alive () const;
 
  static void add_mime_type (const std::string& ext, const std::string& type, bool shtml = false);
  static void delete_mime_type (const std::string& ext);
 
  bool is_protected (const std::string& uri, std::string& realm);
  virtual bool verify_authorization (const std::string& realm, const std::string& user,
                                     const std::string& password);
protected:
  enum vtype
  {
    VT_UNKNOWN, 
    VT_BOOL,    
    VT_CHAR,    
    VT_STRING,  
    VT_SHORT,   
    VT_USHORT,  
    VT_INT,     
    VT_UINT,    
    VT_LONG,    
    VT_ULONG,   
    VT_FLOAT,   
    VT_DOUBLE   
  };
  int invoke_handler (connection& client);
 
  int invoke_post_handler (connection& client);
 
  bool find_alias (const std::string& res, std::filesystem::path& path);
  virtual bool locate_resource (const std::string& res, std::filesystem::path& path);
 
  const std::string& guess_mimetype (const std::filesystem::path& fn, bool& shtml);
  connection* make_thread (sock& connection);
  void add_var (const std::string& name, vtype t, const void* addr, const char* fmt = nullptr,
                double multiplier = 1.);
private:
 
  str_pairs out_headers;          
  mlib::criticalsection hdr_lock; 
 
  struct handle_info
  {
    handle_info (uri_handler h_, void* info_);
 
    uri_handler h;
    void* nfo;
    std::shared_ptr<mlib::criticalsection> in_use;
  };
 
  bool locate_handler (const std::string& res, handle_info** ptr);
 
  std::map<std::string, handle_info> handlers;
  std::map<std::string, handle_info> post_handlers;
 
  std::map<std::string, std::string> aliases;

  struct var_info
  {
    std::string fmt;
    vtype type;
    const void* addr;
    double multiplier;
  };

  std::map<std::string, var_info> variables;
  mlib::criticalsection varlock;

  struct user_inf
  {
    std::string name;
    std::string pwd;
  };

  struct realm_descr
  {
    std::vector<std::string> paths; 
    std::vector<user_inf> credentials;  
  };

  std::map<std::string, realm_descr> realms; 
  mlib::criticalsection realmlock;
 
  std::filesystem::path root;
  std::string defuri;
  unsigned int timeout;
 
  friend class connection;
};
 
/*==================== INLINE FUNCTIONS ===========================*/

inline
const std::string& connection::get_path () const
{
  return path_;
};

inline
const std::string& connection::get_method () const
{
  return method_;
};

inline
const std::string& connection::get_query () const
{
  return query_;
};

inline
const std::string& connection::get_body () const
{
  return body;
};

inline
void connection::add_ohdr (const std::string& hdr, const std::string& value)
{
  oheaders[hdr] = value;
}

inline
bool connection::has_ihdr (const std::string& hdr) const
{
  return iheaders.find (hdr) != iheaders.end();
}

inline
const std::string& connection::get_ihdr (const std::string& hdr) const
{
  return iheaders.at(hdr);
}

inline 
bool connection::has_ohdr (const std::string& hdr) const
{
  return oheaders.find(hdr) != oheaders.end();
}

inline
const std::string& connection::get_ohdr (const std::string& hdr) const
{
  return oheaders.at (hdr);
}

inline
bool connection::has_qparam (const std::string& key)
{
  if (!query_parsed)
    parse_query ();
  return qparams.find (key) != qparams.end ();
}

inline
const std::string& connection::get_qparam (const std::string& key)
{
  if (!query_parsed)
    parse_query ();
  return qparams.at (key);
}

inline
bool connection::has_bparam (const std::string& key)
{
  if (!body_parsed)
    parse_body ();
  return bparams.find (key) != bparams.end ();
}

inline
const std::string& connection::get_bparam (const std::string& key)
{
  static const std::string empty;
  if (!body_parsed)
    parse_body ();
  
  return bparams.at (key);
}
 
inline const std::string& connection::get_auth_user ()
{
  return auth_user;
}

inline
int connection::get_content_length () const
{
  return content_len;
}

inline
sockstream& connection::out ()
{
  return ws;
}
 
inline
const str_pairs& connection::get_request_headers () const
{
  return iheaders;
}
 
inline const str_pairs& connection::get_response_headers () const
{
  return oheaders;
}
 
 
//------------------------ http::server inline functions ----------------------

inline
const std::filesystem::path& server::docroot () const
{
  return root;
}

inline
void server::docroot (const std::filesystem::path& path)
{
  root = std::filesystem::absolute (path);
}
 

inline
void server::aquire_varlock ()
{
  varlock.enter ();
}

inline
void server::release_varlock ()
{
  varlock.leave ();
}

inline
bool server::try_varlock ()
{
  return varlock.try_enter ();
}

inline
void server::default_uri (const std::string& name)
{
  defuri = name;
}

inline
const std::string& server::default_uri () const
{
  return defuri;
}

inline 
void server::keep_alive (unsigned int seconds)
{
  timeout = seconds;
}

inline
unsigned int server::keep_alive () const
{
  return timeout;
}
 
inline
server::handle_info::handle_info (uri_handler h_, void* info_)
  : h (h_)
  , nfo (info_)
  , in_use{std::make_shared<criticalsection> ()}
{}

inline std::ostream& operator<< (std::ostream& os, const str_pairs& hdrs)
{
  for (auto& hdr : hdrs)
  {
    os << hdr.first << ": " << hdr.second << "\r\n";
  }
  return os;
}
 
} // namespace mlib::http