FTPUpload.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/>.
 *
 * ---
 *
 * FTPUpload.hpp
 *
 *  Created on: Jan 25, 2022
 *      Author: ans
 */

#ifndef NETWORK_FTPUPLOAD_HPP_
#define NETWORK_FTPUPLOAD_HPP_

#include "../Wrapper/Curl.hpp"

#ifndef CRAWLSERVPP_TESTING

#include "../Helper/Portability/curl.h"

#else

#include "FakeCurl/FakeCurl.hpp"

#endif

#include <cstddef>      // std::size_t
#include <cstring>      // std::memcpy
#include <stdexcept>    // std::runtime_error
#include <string>       // std::string

namespace crawlservpp::Network::FTPUpload {

    /*
     * DECLARATION
     */


    void write(
            const std::string& content,
            const std::string& url,
            const std::string& proxy = std::string{},
            bool verbose = false
    );


    std::size_t read(char * bufptr, std::size_t size, std::size_t nitems, void * userp);


    void check(CURLcode code);

    /*
     * STRUCTURE
     */

    struct State {
        State() = default;

        const char * content{nullptr};

        std::size_t size{};

        std::size_t transferred{};

        State(State&) = delete;

        State(State&&) = delete;

        State& operator=(State&) = delete;

        State& operator=(State&&) = delete;
    };

    /*
     * IMPLEMENTATION
     */

    void inline write(
            const std::string& content,
            const std::string& url,
            const std::string& proxy,
            bool verbose
    ) {
        Wrapper::Curl curl;
        State state;

        state.content = content.c_str();
        state.size = content.size();

        if(!curl.valid()) {
            throw std::runtime_error("Could not initialize libcurl wrapper");
        }

        FTPUpload::check(curl_easy_setopt(curl.get(), CURLOPT_URL, url.c_str()));
        FTPUpload::check(curl_easy_setopt(curl.get(), CURLOPT_USE_SSL, CURLUSESSL_TRY));
        FTPUpload::check(curl_easy_setopt(curl.get(), CURLOPT_UPLOAD, 1L));
        FTPUpload::check(curl_easy_setopt(curl.get(), CURLOPT_READFUNCTION, FTPUpload::read));
        FTPUpload::check(curl_easy_setopt(curl.get(), CURLOPT_READDATA, &state));
        FTPUpload::check(
                curl_easy_setopt(
                        curl.get(),
                        CURLOPT_INFILESIZE_LARGE,
                        static_cast<curl_off_t>(state.size)
                )
        );

        if(!proxy.empty()) {
            FTPUpload::check(curl_easy_setopt(curl.get(), CURLOPT_PROXY, proxy.c_str()));
        }

        if(verbose) {
            FTPUpload::check(curl_easy_setopt(curl.get(), CURLOPT_VERBOSE, 1L));
        }

        FTPUpload::check(curl_easy_perform(curl.get()));
    }

    inline std::size_t read(char * bufptr, std::size_t size, std::size_t nitems, void * userp) {
        auto toRead{size * nitems};
        auto * state{static_cast<State *>(userp)};
        const auto restSize{state->size - state->transferred};

        if(toRead > restSize) {
            toRead = restSize;
        }

        if(toRead == 0) {
            return 0;
        }

        std::memcpy(bufptr, state->content + state->transferred, toRead);

        state->transferred += toRead;

        return toRead;
    }

    inline void check(CURLcode code) {
        if(code != CURLE_OK) {
            throw std::runtime_error(curl_easy_strerror(code));
        }
    }

} /* namespace crawlservpp::Network::FTPUpload */

#endif /* NETWORK_FTPUPLOAD_HPP_ */