WebServer.hpp

Go to the documentation of this file.

/*
 *
 * ---
 *
 *  Copyright (C) 2022 Anselm Schmidt (ans[ät]ohai.su)
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version in addition to the terms of any
 *  licences already herein identified.
 *
 *  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 General Public License
 *  along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * ---
 *
 * WebServer.hpp
 *
 * Embedded web server using mongoose.
 *
 *  Created on: Feb 1, 2019
 *      Author: ans
 */

#ifndef MAIN_WEBSERVER_HPP_
#define MAIN_WEBSERVER_HPP_

#include "../Data/Compression/Gzip.hpp"
#include "../Helper/FileSystem.hpp"
#include "../Helper/Memory.hpp"
#include "../Helper/Strings.hpp"
#include "../Main/Exception.hpp"

extern "C" {
    #include "../_extern/mongoose/mongoose.h"
}

#include <algorithm>    // std::copy, std::swap, std::transform
#include <array>        // std::array
#include <cctype>       // std::tolower
#include <cstddef>      // std::size_t
#include <cstdint>      // std::uint16_t, std::uint64_t
#include <fstream>      // std::ofstream
#include <functional>   // std::function
#include <ios>          // std::ios_base
#include <stdexcept>    // std::logic_error
#include <string>       // std::stoull, std::string
#include <string_view>  // std::string_view, std::string_view_literals
#include <utility>      // std::pair
#include <vector>       // std::vector

namespace crawlservpp::Main {

    using std::string_view_literals::operator""sv;

    /*
     * CONSTANTS
     */



    inline constexpr auto listenToAddress{"tcp://0.0.0.0:"sv};

    inline constexpr auto headerContentType{"content-type"sv};

    inline constexpr auto headerContentSize{"content-length"sv};

    inline constexpr auto headerContentEncoding{"content-encoding"sv};

    inline constexpr auto headerContentTypeValue{"multipart/form-data"sv};

    inline constexpr auto headerBoundaryBegin{"boundary="sv};

    inline constexpr auto httpOk{200};

    inline constexpr auto filePartHeaderBegin{"content-"sv};

    inline constexpr auto filePartBoundaryBegin{"--"sv};

    inline constexpr auto filePartBoundaryFinalEnd{"--"sv};

    inline constexpr auto filePartUploadHeader{"content-disposition"sv};

    inline constexpr auto filePartUploadName{"name="sv};

    inline constexpr auto filePartUploadFileName{"filename="sv};

    inline constexpr auto filePartUploadField{"filetoupload"sv};

    inline constexpr auto randFileNameLength{64};

    inline constexpr auto quotesLength{2};

    inline constexpr auto gzipMinBytes{2000};


    /*
     * DECLARATION
     */


    class WebServer final {
        // for convenience
        using ConnectionPtr = mg_connection *;
        using ConstConnectionPtr = const mg_connection *;
        using StringString = std::pair<std::string, std::string>;

        using AcceptCallback =
                std::function<void(
                        ConnectionPtr
                )>;
        using LogCallback = std::function<void(const std::string&)>;
        using RequestCallback =
                std::function<void(
                        ConnectionPtr,
                        const std::string&,
                        const std::string&,
                        void *
                )>;

    public:

        explicit WebServer(std::string_view fileCacheDirectory);
        virtual ~WebServer();


        void initHTTP(const std::string& port);


        void setAcceptCallback(AcceptCallback callback);
        void setLogCallback(LogCallback callback);
        void setRequestCallback(RequestCallback callback);


        void poll(int timeOut);
        void send(
                ConnectionPtr connection,
                uint16_t code,
                const std::string& type,
                const std::string& content
        );
        void sendFile(
                ConnectionPtr connection,
                const std::string& fileName,
                bool isGzipped,
                void * data
        );
        static void sendError(
                ConnectionPtr connection,
                const std::string& error
        );
        static void close(
                ConnectionPtr connection,
                bool immediately
        );


        static std::string getIP(ConstConnectionPtr connection);


        MAIN_EXCEPTION_CLASS();


        WebServer(WebServer&) = delete;

        WebServer& operator=(WebServer&) = delete;

        WebServer(WebServer&&) = delete;

        WebServer& operator=(WebServer&&) = delete;


    private:
        const std::string fileCache;
        mg_mgr eventManager{};
        bool isShutdown{false};

        // callback functions
        AcceptCallback onAccept;
        LogCallback onLog;
        RequestCallback onRequest;

        // event handlers
        static void eventHandler(
                ConnectionPtr connection,
                int event,
                void * data,
                void * arg
        );
        void eventHandlerInClass(
                ConnectionPtr connection,
                int event,
                void * data
        );
        void uploadHandler(ConnectionPtr connection, mg_http_message * msg);
        void requestHandler(ConnectionPtr connection, mg_http_message * msg, void * data);

        // internal helper functions
        void fileReceived(ConnectionPtr from, const std::string& name, const std::string& content);

        // static internal helper functions
        static void parseHttpHeaders(
                const std::array<mg_http_header, MG_MAX_HTTP_HEADERS>& headers,
                std::string& contentEncodingTo
        );
        [[nodiscard]] static bool parseHttpHeaders(
                const std::array<mg_http_header, MG_MAX_HTTP_HEADERS>& headers,
                std::string& boundaryTo,
                std::uint64_t& sizeTo,
                std::string& contentEncodingTo
        );
        [[nodiscard]] static bool getLine(struct mg_str& str, std::size_t& pos, std::string& to);
        [[nodiscard]] static bool isBoundary(const std::string& line, const std::string& boundary);
        [[nodiscard]] static bool isFinalBoundary(const std::string& line, const std::string& boundary);
        [[nodiscard]] static bool getUploadHeaders(struct mg_str& str, std::size_t& pos, std::vector<StringString>& to);
        [[nodiscard]] static bool getUploadHeader(const std::string& from, StringString& to);

        [[nodiscard]] static bool parseContentType(
                const std::string& headerName,
                const struct mg_str& headerValue,
                std::string& boundaryTo,
                bool& isBoundaryFoundTo
        );
        [[nodiscard]] static bool parseContentSize(
                const std::string& headerName,
                const struct mg_str& headerValue,
                std::uint64_t& sizeTo,
                bool& isFoundSizeTo
        );
        static void parseContentEncoding(
                const std::string& headerName,
                const struct mg_str& headerValue,
                std::string& contentEncodingTo
        );

        [[nodiscard]] static bool parseContentTypeHeader(const std::string& value, std::string& boundaryTo);
        [[nodiscard]] static bool parseUploadHeaders(const std::vector<StringString>& uploadHeaders, std::string& fileNameTo);
        [[nodiscard]] static bool parseNextHeaderPart(const std::string& value, std::size_t& pos, std::string& to);

        [[nodiscard]] static bool checkFileName(bool inFile, const std::string& currentFile, std::string& fileName);

        [[nodiscard]] static std::string getDefaultHeaders();
        [[nodiscard]] static std::string getCorsHeaders();
        [[nodiscard]] static std::string toString(const struct mg_str& str);
        static void removeQuotes(std::string& str);

        [[nodiscard]] static const char * statusCodeToString(int status_code);
    };

} /* namespace crawlservpp::Main */

#endif /* MAIN_WEBSERVER_HPP_ */