Mastodon::API::http Class Reference

http class. Do not use this directly. More...

#include <mastodon-cpp.hpp>

Public Types
enum	method {   GET, PATCH, POST, PUT,   DELETE, GET_STREAM }
	HTTP methods.

Public Member Functions
	http (const API &api, const string &instance, const string &access_token)
const uint_fast16_t	request (const method &meth, const string &path, string &answer)
const uint_fast16_t	request (const method &meth, const string &path, const curlpp::Forms &formdata, string &answer)
	HTTP Request. More...
const void	get_headers (string &headers) const
	Get all headers in a string.
const void	cancel_stream ()
	Cancels the stream. Use only with streams. More...
const void	abort_stream ()
std::mutex &	get_mutex ()
	Gets the mutex guarding the string that is written to. More...

Detailed Description

http class. Do not use this directly.

Member Function Documentation

cancel_stream()

const void API::http::cancel_stream

(

)

Cancels the stream. Use only with streams.

Cancels the stream next time data comes in. Can take a few seconds. This works only with streams, because only streams have an own http object.

Since

0.12.2

{
    _cancel_stream = true;
}

get_mutex()

std::mutex & API::http::get_mutex

(

)

Gets the mutex guarding the string that is written to.

The mutex guards the function that writes to the string you specified in get_stream().

Returns

A reference of the mutex.

{
    return _mutex;
}

request()

const uint_fast16_t API::http::request	(	const method &	meth,
		const string &	path,
		const curlpp::Forms &	formdata,
		string &	answer
	)

HTTP Request.

Parameters

meth	The method defined in http::method
path	The api call as string
formdata	The form data for PATCH and POST requests.
answer	The answer from the server

Returns

Error code. If the URL has permanently changed, 13 is returned and answer is set to the new URL.

{
    using namespace std::placeholders;  // _1, _2, _3

    uint_fast16_t ret = 0;
    ttdebug << "Path is: " << path << '\n';
    
    try
    {
        curlpp::Easy request;
        std::list<string> headers;

        request.setOpt<curlopts::Url>("https://" + _instance + path);
        ttdebug << "User-Agent: " << parent.get_useragent() << "\n";
        request.setOpt<curlopts::UserAgent>(parent.get_useragent());

        {
            string proxy;
            string userpw;
            parent.get_proxy(proxy, userpw);
            if (!proxy.empty())
            {
                request.setOpt<curlopts::Proxy>(proxy);
                if (!userpw.empty())
                {
                    request.setOpt<curlopts::ProxyUserPwd>(userpw);
                }
            }
        }

        if (!_access_token.empty())
        {
            headers.push_back("Authorization: Bearer " + _access_token);
        }
        if (meth != http::method::GET_STREAM)
        {
            headers.push_back("Connection: close");
            // Get headers from server
            request.setOpt<curlpp::options::Header>(true);
        }

        request.setOpt<curlopts::HttpHeader>(headers);
        request.setOpt<curlopts::FollowLocation>(true);
        request.setOpt<curlopts::WriteFunction>
            (std::bind(&http::callback_write, this, _1, _2, _3, &answer));
        request.setOpt<curlopts::ProgressFunction>
            (std::bind(&http::callback_progress, this, _1, _2, _3, _4));
        request.setOpt<curlopts::NoProgress>(0);
        if (!formdata.empty())
        {
            request.setOpt<curlopts::HttpPost>(formdata);
        }

        switch (meth)
        {
            case http::method::GET:
                break;
            case http::method::PATCH:
                request.setOpt<curlopts::CustomRequest>("PATCH");
                break;
            case http::method::POST:
                request.setOpt<curlopts::CustomRequest>("POST");
                break;
            case http::method::PUT:
                request.setOpt<curlopts::CustomRequest>("PUT");
            case http::method::DELETE:
                request.setOpt<curlopts::CustomRequest>("DELETE");
            default:
                break;
        }
        
        //request.setOpt<curlopts::Verbose>(true);

        answer.clear();
        request.perform();
        ret = curlpp::infos::ResponseCode::get(request);
        ttdebug << "Response code: " << ret << '\n';
        // Work around "HTTP/1.1 100 Continue\r\n\r\nHTTP/1.1 200 OK"
        size_t pos = answer.find("\r\n\r\n", 25);
        _headers = answer.substr(0, pos);
        // Only return body
        answer = answer.substr(pos + 4);

        if (ret == 200 || ret == 302 || ret == 307)
        {   // OK or Found or Temporary Redirect
            return 0;
        }
        else if (ret == 301 || ret == 308)
        {   // Moved Permanently or Permanent Redirect
            // return new URL
            answer = curlpp::infos::EffectiveUrl::get(request);
            return 13;
        }
        else
        {
            return ret;
        }
    }
    catch (curlpp::RuntimeError &e)
    {
        // This error is thrown if http.cancel_stream() is used.
        if ((std::strncmp(e.what(), "Callback aborted", 16) == 0) ||
            (std::strncmp(e.what(), "Failed writing body", 19) == 0))
        {
            ttdebug << "Request was cancelled by user\n";
            return 14;
        }

        if (parent.exceptions())
        {
            std::rethrow_exception(std::current_exception());
        }
        else
        {
            ttdebug << "curlpp::RuntimeError: " << e.what() << std::endl;
            return 15;
        }
    }
    catch (curlpp::LogicError &e)
    {
        if (parent.exceptions())
        {
            std::rethrow_exception(std::current_exception());
        }

        ttdebug << "curlpp::LogicError: " << e.what() << std::endl;
        return 15;
    }

    return ret;
}

---

The documentation for this class was generated from the following files:

• src/mastodon-cpp.hpp
• src/http.cpp