Как отправить POST запрос на C++?

libastral_namespace::send_post(mega_structure_with_cool_data_which_was_created_automatically_by_some_cpp_gods);

std::string post = "POST / HTTP/1.1\r\nHost: example.com\r\n\r\n";
post+= "blablabla=123\r\n\r\n";//тут содержимое запроса, подставить по вкусу

int bs = 0;

while (bs < post.size())
{
  bs+= send(socket, post.c_str() + bs, post.size() - bs, 0);
  //обработку ошибок сокета прикрутить самостоятельно
}

//PROFIT :)

#include <cstdio>
#include <cstdlib>
#include <cstring>

#include <unistd.h>

#include <curl/curl.h>

struct Chunk {

    size_t size_;
    char *memory_;

    Chunk() : size_(0), memory_(0) {}
    ~Chunk() { free(memory_); }

    size_t add(const void *from, const size_t size, const size_t n)
    {
        const size_t diff = size * n;
        memory_ = static_cast<char*>(realloc(memory_, size_ + diff));
        memcpy(memory_ + size_, from, diff);
        size_ += diff;
        return diff;
    }

};

Chunk *global_chunk;

class Client {

    Chunk chunk_;
    const char *uri_;
    CURL *handle_;

  public:

    Client(const char *uri) : uri_(uri)
    {
        global_chunk = &chunk_;
        curl_global_init(CURL_GLOBAL_ALL);
        handle_ = curl_easy_init();
    }

    ~Client()
    {
        curl_easy_cleanup(handle_);
        curl_global_cleanup();
        global_chunk = 0;
    }

    char* fetch() const { return fetch(0); }

    char* fetch(const char *post_data) const
    {
        auto callback = *[](const void *from, const size_t size, const size_t n) {
            return global_chunk->add(from, size, n);
        };

        curl_easy_setopt(handle_, CURLOPT_URL, uri_);
        if (post_data)
            curl_easy_setopt(handle_, CURLOPT_POSTFIELDS, post_data);
        curl_easy_setopt(handle_, CURLOPT_WRITEFUNCTION, callback);
        curl_easy_setopt(handle_, CURLOPT_WRITEDATA, &chunk_);
        curl_easy_setopt(handle_, CURLOPT_USERAGENT, "curl");

        const CURLcode res = curl_easy_perform(handle_);
        if (res != CURLE_OK) {
            const char *error = curl_easy_strerror(res);
            const char *fmt = "{\"error\":\"%s\"}";
            char *result = static_cast<char*>(calloc(strlen(error) + strlen(fmt) + 1, 1));
            sprintf(result, fmt, error);
            return result;
        } else {
            char *result = static_cast<char*>(calloc(chunk_.size_ + 1, 1));
            memcpy(result, chunk_.memory_, chunk_.size_);
            return result;
        }

    }

};

extern "C" char* get(const char *uri)
{
    return Client { uri }.fetch();
}

extern "C" char* post(const char *uri, const char *post_data)
{
    return Client { uri }.fetch(post_data);
}

#include <string>

#include <curl/curl.h>

class Client {

    const std::string uri_;
    std::string reply_;

    CURL *curl_;

    enum Method { GET, POST };

    std::string fetch(const Method method, const std::string &data = "") const
    {
        curl_easy_setopt(curl_, CURLOPT_URL, uri_.c_str());
        if (method == POST)
            curl_easy_setopt(curl_, CURLOPT_POSTFIELDS, data.c_str());
        curl_easy_setopt(
            curl_, CURLOPT_WRITEFUNCTION,
            *[](const char *from, const size_t size, const size_t n, std::string *to) {
                const size_t diff = size * n;
                to->append(from, diff);
                return diff;
            }
        );
        curl_easy_setopt(curl_, CURLOPT_WRITEDATA, &reply_);
        curl_easy_setopt(curl_, CURLOPT_USERAGENT, "curl");

        const CURLcode res = curl_easy_perform(curl_);
        return
            res == CURLE_OK ?
            reply_ :
            "{\"error\":\"" + std::string { curl_easy_strerror(res) } + "\"}";
    }

  public:

    Client(const std::string &uri) : uri_(uri)
    {
        curl_global_init(CURL_GLOBAL_ALL);
        curl_ = curl_easy_init();
    }

    ~Client()
    {
        curl_easy_cleanup(curl_);
        curl_global_cleanup();
    }

    std::string get() const { return fetch(GET); }

    std::string post(const std::string &data) const { return fetch(POST, data); }

};

#include <iostream>

int main()
{
    std::cout << Client { "http://www.linux.org.ru/" }.get() << std::endl
              << Client { "http://.../..." }.post("...") << std::endl;
}