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)
uint_fast16_t	request (const method &meth, const string &path, string &answer)
uint_fast16_t	request (const method &meth, const string &path, const curlpp::Forms &formdata, string &answer)
	HTTP Request. More...
void	get_headers (string &headers) const
	Get all headers in a string.
void	cancel_stream ()
	Cancels the stream. Use only with streams. More...
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.

Since

before 0.11.0

Member Function Documentation

cancel_stream()

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.

Since

0.12.3

{
    return _mutex;
}

request()

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.

Since

before 0.11.0

{
    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");
                break;
            case http::method::DELETE:
                request.setOpt<curlopts::CustomRequest>("DELETE");
                break;
            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 if (ret == 0)
        {
            return 0xffff;
        }
        else
        {
            return ret;
        }
    }
    catch (curlpp::RuntimeError &e)
    {
        const string what = e.what();
        // This error is thrown if http.cancel_stream() is used.
        if ((what.compare(0, 16, "Callback aborted") == 0) ||
            (what.compare(0, 19, "Failed writing body") == 0))
        {
            ttdebug << "Request was cancelled by user\n";
            return 14;
        }
        else if (what.compare(what.size() - 20, 20, "Connection timed out") == 0)
        {
            ttdebug << "Timeout\n";
            return 16;
        }

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

---

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

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