httpd.h

Go to the documentation of this file.

/*
  Copyright (c) Mircea Neacsu (2014-2025) Licensed under MIT License.
  This 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 HTTPD_MAX_HEADER 8192

#define HTTP_OK         0     
#define HTTP_ERR_WRITE  -1    
#define HTTP_ERR_FOPEN  -2    
#define HTTP_ERR_FREAD  -3    
#define HTTP_NO_HANDLER -4    
 
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;

  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);

  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);
  int do_auth ();
  void serve401 (const char* realm);
  bool should_close ();
 
  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;
 
  struct user
  {
    std::string name;
    std::string pwd;
  };
  std::multimap<std::string, user> auth; // authenticated users
 
};

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);
  bool add_user (const char* realm, const char* username, const char* pwd);
  bool remove_user (const char* realm, const char* username);
  void add_realm (const char* realm, const char* 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 char* nam);
  void docroot (const std::string& 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)
  {
    defuri = name;
  };
  const std::string& default_uri ()
  {
    return defuri;
  };
 
  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);
  bool authenticate (const std::string& realm, const std::string& user, const std::string& pwd);
 
  friend class connection;
 
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);
  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; 
  str_pairs realms;               
 
  struct handle_info
  {
    handle_info (uri_handler h_, void* info_);
 
    uri_handler h;
    void* nfo;
    std::shared_ptr<mlib::criticalsection> in_use;
  };
  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
  {
    std::string name;
    std::string pwd;
  };
  std::multimap<std::string, user> credentials;
 
  std::filesystem::path root;
  std::string defuri;
};
 
/*==================== 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
{
  lock l (parent.hdr_lock);
  return parent.out_headers.find (hdr) != parent.out_headers.end()
    || (oheaders.find(hdr) != oheaders.end());
}

inline
const std::string& connection::get_ohdr (const std::string& hdr) const
{
  lock l (parent.hdr_lock);
  auto idx = parent.out_headers.find (hdr);
  if (idx != parent.out_headers.end ())
    return idx->second;
 
  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
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;
}
 
 
//------------------------ http::server inline functions ----------------------
inline
const std::filesystem::path& server::docroot () const
{
  return root;
}

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

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

inline
bool server::try_varlock ()
{
  return varlock.try_enter ();
}
 
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