http_server.hpp

Go to the documentation of this file.

 
#ifndef JOIN_SERVICES_HTTP_SERVER_HPP
#define JOIN_SERVICES_HTTP_SERVER_HPP
 
// libjoin.
#include <join/http_protocol.hpp>
#include <join/http_message.hpp>
#include <join/chunk_stream.hpp>
#include <join/filesystem.hpp>
#include <join/tls_stream.hpp>
#include <join/acceptor.hpp>
#include <join/version.hpp>
#include <join/zstream.hpp>
#include <join/thread.hpp>
#include <join/cache.hpp>
 
// C++.
#include <sys/eventfd.h>
#include <thread>
#include <memory>
#include <vector>
 
// C.
#include <fnmatch.h>
 
namespace join
{
    enum HttpContentType
    {
        Root,     
        Alias,    
        Exec,     
        Redirect, 
    };
 
    template <class Protocol>
    struct BasicHttpContent
    {
        using Handler = std::function<void (typename Protocol::Worker*)>;
        using Access = std::function<bool (const std::string&, const std::string&, std::error_code&)>;
 
        HttpMethod methods;    
        HttpContentType type;  
        std::string directory; 
        std::string name;      
        std::string alias;     
        Handler handler;       
        Access access;         
    };
 
    template <class Protocol>
    class BasicHttpWorker : public Protocol::Stream
    {
    public:
        using Content = BasicHttpContent<Protocol>;
        using Server = BasicHttpServer<Protocol>;
 
        BasicHttpWorker (Server* server)
        : _server (server)
        , _thread ([this] () {
            work ();
        })
        {
        }
 
        BasicHttpWorker (const BasicHttpWorker& other) = delete;
 
        BasicHttpWorker& operator= (const BasicHttpWorker& other) = delete;
 
        BasicHttpWorker (BasicHttpWorker&& other) = delete;
 
        BasicHttpWorker& operator= (BasicHttpWorker&& other) = delete;
 
        virtual ~BasicHttpWorker ()
        {
            this->_thread.join ();
        }
 
        void sendHeaders ()
        {
            // restore concrete stream.
            this->clearEncoding ();
 
            // set missing response headers.
            if (!this->_response.hasHeader ("Date"))
            {
                std::stringstream gmt;
                std::time_t ti = std::time (nullptr);
                gmt << std::put_time (std::gmtime (&ti), "%a, %d %b %Y %H:%M:%S GMT");
                this->_response.header ("Date", gmt.str ());
            }
            if (!this->_response.hasHeader ("Server"))
            {
                this->_response.header ("Server", "join/" JOIN_VERSION);
            }
            if (!this->_response.hasHeader ("Connection"))
            {
                if (this->_max && compareNoCase (this->_request.header ("Connection"), "keep-alive"))
                {
                    std::stringstream keepAlive;
                    keepAlive << "timeout=" << this->_server->keepAliveTimeout ().count ()
                              << ", max=" << this->_server->keepAliveMax ();
                    this->_response.header ("Keep-Alive", keepAlive.str ());
                    this->_response.header ("Connection", "Keep-Alive");
                }
                else
                {
                    this->_response.header ("Connection", "close");
                    this->_max = 0;
                }
            }
            if ((this->_server->scheme () == "https") && !this->_response.hasHeader ("Strict-Transport-Security"))
            {
                this->_response.header ("Strict-Transport-Security", "max-age=31536000; includeSubDomains; preload");
            }
            if (!this->_response.hasHeader ("Content-Security-Policy"))
            {
                this->_response.header (
                    "Content-Security-Policy",
                    "default-src 'self'; object-src 'none'; script-src 'self'; style-src 'self'; img-src 'self'");
            }
            if (!this->_response.hasHeader ("X-XSS-Protection"))
            {
                this->_response.header ("X-XSS-Protection", "1; mode=block");
            }
            if (!this->_response.hasHeader ("X-Content-Type-Options"))
            {
                this->_response.header ("X-Content-Type-Options", "nosniff");
            }
            if (!this->_response.hasHeader ("X-Frame-Options"))
            {
                this->_response.header ("X-Frame-Options", "SAMEORIGIN");
            }
 
            // write response headers.
            this->_response.writeHeaders (*this);
 
            // set encoding.
            if (this->_response.hasHeader ("Transfer-Encoding"))
            {
                this->setEncoding (join::rsplit (this->_response.header ("Transfer-Encoding"), ","));
            }
            if (this->_response.hasHeader ("Content-Encoding"))
            {
                this->setEncoding (join::rsplit (this->_response.header ("Content-Encoding"), ","));
            }
        }
 
        void sendError (const std::string& status, const std::string& reason)
        {
            // set error response.
            this->_response.response (status, reason);
 
            // stop keepalive.
            this->_response.header ("Connection", "close");
            this->_max = 0;
 
            // send headers.
            this->sendHeaders ();
 
            // flush data.
            this->flush ();
        }
 
        void sendRedirect (const std::string& status, const std::string& reason, const std::string& location = {})
        {
            std::string payload;
 
            // set redirect response.
            this->_response.response (status, reason);
 
            // set redirect message payload.
            if (!location.empty ())
            {
                payload += "<html>";
                payload += "<head>";
                payload += "<meta http-equiv=\"content-type\" content=\"text/html;charset=utf-8\">";
                payload += "<title>" + status + " " + reason + "</title>";
                payload += "</head>";
                payload += "<body>";
                payload += "<h1>" + status + " " + reason + "</h1>";
                payload += "The document has moved <a href=\"" + location + "\">here</a>";
                payload += "</body>";
                payload += "</html>";
            }
 
            // set content.
            if (payload.size ())
            {
                this->_response.header ("Content-Length", std::to_string (payload.size ()));
                this->_response.header ("Content-Type", "text/html");
                this->_response.header ("Cache-Control", "no-cache");
            }
 
            // send headers.
            this->sendHeaders ();
 
            // send payload.
            if (payload.size ())
            {
                this->write (payload.c_str (), payload.size ());
            }
 
            // flush data.
            this->flush ();
        }
 
        void sendFile (const std::string& path)
        {
            struct stat sbuf;
 
            // get file.
            void* addr = this->_server->_cache.get (path, sbuf);
            if (addr == nullptr || S_ISDIR (sbuf.st_mode))
            {
                this->sendError ("404", "Not Found");
                return;
            }
 
            // check modif time.
            std::stringstream modifTime;
            modifTime << std::put_time (std::gmtime (&sbuf.st_ctime), "%a, %d %b %Y %H:%M:%S GMT");
            if (compareNoCase (this->_request.header ("If-Modified-Since"), modifTime.str ()))
            {
                this->sendRedirect ("304", "Not Modified");
                return;
            }
 
            // set modif time.
            this->_response.header ("Last-Modified", modifTime.str ());
 
            // set content.
            this->_response.header ("Content-Length", std::to_string (sbuf.st_size));
            this->_response.header ("Content-Type", join::mime (path));
            this->_response.header ("Cache-Control", "no-cache");
 
            // send headers.
            this->sendHeaders ();
 
            // check method.
            if (this->_request.method () == HttpMethod::Get)
            {
                // send file.
                this->write (static_cast<char*> (addr), sbuf.st_size);
            }
 
            // flush data.
            this->flush ();
        }
 
        bool hasHeader (const std::string& name) const
        {
            return this->_request.hasHeader (name);
        }
 
        std::string header (const std::string& name) const
        {
            return this->_request.header (name);
        }
 
        size_t contentLength () const
        {
            return this->_request.contentLength ();
        }
 
        void header (const std::string& name, const std::string& val)
        {
            return this->_response.header (name, val);
        }
 
    protected:
        void work ()
        {
            fd_set setfd;
            FD_ZERO (&setfd);
            int fdmax = -1;
 
            FD_SET (this->_server->_event, &setfd);
            fdmax = std::max (fdmax, this->_server->_event);
            FD_SET (this->_server->_acceptor.handle (), &setfd);
            fdmax = std::max (fdmax, this->_server->_acceptor.handle ());
 
            for (;;)
            {
                {
                    ScopedLock<Mutex> lock (this->_server->_mutex);
 
                    fd_set fdset = setfd;
                    int nset = ::select (fdmax + 1, &fdset, nullptr, nullptr, nullptr);
                    if (nset > 0)
                    {
                        if (FD_ISSET (this->_server->_event, &fdset))
                        {
                            uint64_t val = 0;
                            [[maybe_unused]] ssize_t bytes = ::read (this->_server->_event, &val, sizeof (uint64_t));
                            return;
                        }
 
                        if (FD_ISSET (this->_server->_acceptor.handle (), &fdset))
                        {
                            this->_sockbuf.socket () = this->_server->accept ();
                            this->_sockbuf.timeout (this->_server->keepAliveTimeout ());
                        }
                    }
                }
 
                this->processRequest ();
            }
        }
 
        void processRequest ()
        {
            this->_max = this->_server->keepAliveMax ();
 
            do
            {
                if (this->readRequest () == -1)
                {
                    this->cleanUp ();
                    break;
                }
 
                this->writeResponse ();
                this->cleanUp ();
            }
            while ((this->_max < 0) || (--this->_max != 0));
 
            this->endRequest ();
        }
 
        int readRequest ()
        {
            // restore concrete stream.
            this->clearEncoding ();
 
            // prepare a standard response.
            this->_response.response ("200", "OK");
 
            // read request headers.
            if (this->_request.readHeaders (*this) == -1)
            {
                if (join::lastError == HttpErrc::BadRequest)
                {
                    this->sendError ("400", "Bad Request");
                }
                else if (join::lastError == HttpErrc::Unsupported)
                {
                    this->sendError ("405", "Method Not Allowed");
                }
                else if (join::lastError == HttpErrc::HeaderTooLarge)
                {
                    this->sendError ("494", "Request Header Too Large");
                }
                return -1;
            }
 
            // check host.
            if (this->_request.host ().empty ())
            {
                this->sendError ("400", "Bad Request");
                return -1;
            }
 
            // set encoding.
            if (this->_request.hasHeader ("Transfer-Encoding"))
            {
                this->setEncoding (join::rsplit (this->_request.header ("Transfer-Encoding"), ","));
            }
            if (this->_request.hasHeader ("Content-Encoding"))
            {
                this->setEncoding (join::rsplit (this->_request.header ("Content-Encoding"), ","));
            }
 
            return 0;
        }
 
        void writeResponse ()
        {
            Content* content = this->_server->findContent (this->_request.method (), this->_request.path ());
            if (content == nullptr)
            {
                this->sendError ("404", "Not Found");
                return;
            }
 
            if (content->access != nullptr)
            {
                if (!this->_request.hasHeader ("Authorization"))
                {
                    this->sendError ("401", "Unauthorized");
                    return;
                }
 
                std::error_code err;
                if (!content->access (this->_request.auth (), this->_request.credentials (), err))
                {
                    if (err == HttpErrc::Unauthorized)
                    {
                        this->sendError ("401", "Unauthorized");
                    }
                    else if (err == HttpErrc::Forbidden)
                    {
                        this->sendError ("403", "Forbidden");
                    }
                    return;
                }
            }
 
            std::string alias (content->alias);
            if (!alias.empty ())
            {
                join::replaceAll (alias, "$root", this->_server->baseLocation ());
                join::replaceAll (alias, "$scheme", this->_server->scheme ());
                join::replaceAll (alias, "$host", this->_request.host ());
                join::replaceAll (alias, "$port", std::to_string (this->localEndpoint ().port ()));
                join::replaceAll (alias, "$path", this->_request.path ());
                join::replaceAll (alias, "$query", this->_request.query ());
                join::replaceAll (alias, "$urn", this->_request.urn ());
            }
 
            if (content->type == HttpContentType::Root)
            {
                this->sendFile (this->_server->baseLocation () + this->_request.path ());
            }
            else if (content->type == HttpContentType::Alias)
            {
                this->sendFile (alias);
            }
            else if (content->type == HttpContentType::Exec)
            {
                if (content->handler == nullptr)
                {
                    this->sendError ("500", "Internal Server Error");
                    return;
                }
                content->handler (this);
            }
            else if (content->type == HttpContentType::Redirect)
            {
                if (this->_request.version () == "HTTP/1.1")
                {
                    this->sendRedirect ("307", "Temporary Redirect", alias);
                }
                else
                {
                    this->sendRedirect ("302", "Found", alias);
                }
            }
        }
 
        void cleanUp ()
        {
            this->_request.clear ();
            this->_response.clear ();
        }
 
        void endRequest ()
        {
            this->disconnect ();
            this->close ();
        }
 
        void setEncoding (const std::vector<std::string>& encodings)
        {
            for (auto const& encoding : encodings)
            {
                if (encoding.find ("gzip") != std::string::npos)
                {
                    this->_streambuf = new Zstreambuf (this->_streambuf, Zstream::Gzip, this->_wrapped);
                    this->_wrapped = true;
                }
                else if (encoding.find ("deflate") != std::string::npos)
                {
                    this->_streambuf = new Zstreambuf (this->_streambuf, Zstream::Deflate, this->_wrapped);
                    this->_wrapped = true;
                }
                else if (encoding.find ("chunked") != std::string::npos)
                {
                    this->_streambuf = new Chunkstreambuf (this->_streambuf, this->_wrapped);
                    this->_wrapped = true;
                }
            }
 
            this->set_rdbuf (this->_streambuf);
        }
 
        void clearEncoding ()
        {
            if (this->_wrapped && this->_streambuf)
            {
                delete this->_streambuf;
                this->_streambuf = nullptr;
            }
 
            this->_streambuf = &this->_sockbuf;
            this->_wrapped = false;
 
            this->set_rdbuf (this->_streambuf);
        }
 
        int _max = 0;
 
        HttpRequest _request;
 
        HttpResponse _response;
 
        std::streambuf* _streambuf = nullptr;
 
        bool _wrapped = false;
 
        Server* _server;
 
        Thread _thread;
    };
 
    template <class Protocol>
    class BasicHttpServer
    {
    public:
        using Worker = BasicHttpWorker<Protocol>;
        using Content = BasicHttpContent<Protocol>;
        using Handler = typename Content::Handler;
        using Access = typename Content::Access;
        using Endpoint = typename Protocol::Endpoint;
        using Socket = typename Protocol::Socket;
        using Acceptor = typename Protocol::Acceptor;
 
        BasicHttpServer (size_t workers = std::thread::hardware_concurrency ())
        : _event (eventfd (0, EFD_NONBLOCK | EFD_CLOEXEC | EFD_SEMAPHORE))
        , _nworkers (workers)
        , _baseLocation ("/var/www")
        , _keepTimeout (10)
        {
            [[maybe_unused]] int res = chdir (this->_baseLocation.c_str ());
        }
 
        BasicHttpServer (const BasicHttpServer& other) = delete;
 
        BasicHttpServer& operator= (const BasicHttpServer& other) = delete;
 
        BasicHttpServer (BasicHttpServer&& other) = delete;
 
        BasicHttpServer& operator= (BasicHttpServer&& other) = delete;
 
        virtual ~BasicHttpServer ()
        {
            this->_acceptor.close ();
            this->_contents.clear ();
            ::close (this->_event);
        }
 
        int create (const Endpoint& endpoint) noexcept
        {
            if (this->_acceptor.create (endpoint) == -1)
            {
                return -1;
            }
 
            for (size_t nworkers = 0; nworkers < this->_nworkers; ++nworkers)
            {
                this->_workers.emplace_back (new Worker (this));
            }
 
            return 0;
        }
 
        void close () noexcept
        {
            uint64_t val = this->_nworkers;
            [[maybe_unused]] ssize_t bytes = ::write (this->_event, &val, sizeof (uint64_t));
            this->_workers.clear ();
            this->_acceptor.close ();
        }
 
        virtual Socket accept () const
        {
            return Socket (this->_acceptor.accept ());
        }
 
        void baseLocation (const std::string& path)
        {
            this->_baseLocation = path;
 
            if (*this->_baseLocation.rbegin () == '/')
            {
                this->_baseLocation.pop_back ();
            }
 
            [[maybe_unused]] int res = chdir (this->_baseLocation.c_str ());
        }
 
        const std::string& baseLocation () const
        {
            return this->_baseLocation;
        }
 
        void keepAlive (std::chrono::seconds timeout, int max = 1000)
        {
            this->_keepTimeout = timeout;
            this->_keepMax = max;
        }
 
        std::chrono::seconds keepAliveTimeout () const
        {
            return this->_keepTimeout;
        }
 
        int keepAliveMax () const
        {
            return this->_keepMax;
        }
 
        virtual std::string scheme () const
        {
            return "http";
        }
 
        Content* addDocumentRoot (const std::string& dir, const std::string& name, const Access& access = nullptr)
        {
            Content* newEntry = new Content;
            if (newEntry != nullptr)
            {
                newEntry->methods = Head | Get;
                newEntry->type = Root;
                newEntry->directory = dir;
                newEntry->name = name;
                newEntry->handler = nullptr;
                newEntry->access = access;
                this->_contents.emplace_back (newEntry);
            }
 
            return newEntry;
        }
 
        Content* addAlias (const std::string& dir, const std::string& name, const std::string& alias,
                           const Access& access = nullptr)
        {
            Content* newEntry = new Content;
            if (newEntry != nullptr)
            {
                newEntry->methods = Head | Get;
                newEntry->type = Alias;
                newEntry->directory = dir;
                newEntry->name = name;
                newEntry->alias = alias;
                newEntry->handler = nullptr;
                newEntry->access = access;
                this->_contents.emplace_back (newEntry);
            }
 
            return newEntry;
        }
 
        Content* addExecute (const HttpMethod methods, const std::string& dir, const std::string& name,
                             const Handler& handler, const Access& access = nullptr)
        {
            Content* newEntry = new Content;
            if (newEntry != nullptr)
            {
                newEntry->methods = methods;
                newEntry->type = Exec;
                newEntry->directory = dir;
                newEntry->name = name;
                newEntry->handler = handler;
                newEntry->access = access;
                this->_contents.emplace_back (newEntry);
            }
 
            return newEntry;
        }
 
        Content* addRedirect (const std::string& dir, const std::string& name, const std::string& location,
                              const Access& access = nullptr)
        {
            Content* newEntry = new Content;
            if (newEntry != nullptr)
            {
                newEntry->methods = Head | Get | Put | Post | Delete;
                newEntry->type = Redirect;
                newEntry->directory = dir;
                newEntry->name = name;
                newEntry->alias = location;
                newEntry->handler = nullptr;
                newEntry->access = access;
                this->_contents.emplace_back (newEntry);
            }
 
            return newEntry;
        }
 
    protected:
        Content* findContent (HttpMethod method, const std::string& path) const
        {
            std::string directory = join::base (path);
            std::string name = join::filename (path);
 
            for (auto const& content : this->_contents)
            {
                if (content->methods & method)
                {
                    if (fnmatch (content->directory.c_str (), directory.c_str (), FNM_CASEFOLD) == 0)
                    {
                        if (fnmatch (content->name.c_str (), name.c_str (), FNM_CASEFOLD) == 0)
                        {
                            return content.get ();
                        }
                    }
                }
            }
 
            return nullptr;
        }
 
        Acceptor _acceptor;
 
        int _event = -1;
 
        size_t _nworkers;
 
        std::vector<std::unique_ptr<Worker>> _workers;
 
        Mutex _mutex;
 
        std::vector<std::unique_ptr<Content>> _contents;
 
        std::string _baseLocation;
 
        std::chrono::seconds _keepTimeout;
 
        int _keepMax = 1000;
 
        Cache _cache;
 
        friend Worker;
    };
 
    template <class Protocol>
    class BasicHttpSecureServer : public BasicHttpServer<Protocol>
    {
    public:
        using Worker = BasicHttpWorker<Protocol>;
        using Socket = typename Protocol::Socket;
 
        BasicHttpSecureServer (TlsContext ctx, size_t workers = std::thread::hardware_concurrency ())
        : BasicHttpServer<Protocol> (workers)
        , _ctx (std::move (ctx))
        {
        }
 
        BasicHttpSecureServer (const BasicHttpSecureServer& other) = delete;
 
        BasicHttpSecureServer& operator= (const BasicHttpSecureServer& other) = delete;
 
        BasicHttpSecureServer (BasicHttpSecureServer&& other) = delete;
 
        BasicHttpSecureServer& operator= (BasicHttpSecureServer&& other) = delete;
 
        virtual ~BasicHttpSecureServer ()
        {
            // join the workers while the context they use is still alive.
            this->close ();
        }
 
        Socket accept () const override
        {
            Socket sock (this->_acceptor.accept (), this->_ctx);
            if (sock.deferHandshake () == -1)
            {
                sock.close ();
            }
            return sock;
        }
 
        virtual std::string scheme () const override
        {
            return "https";
        }
 
        TlsContext _ctx;
 
        friend Worker;
    };
}
 
#endif