coyote/client.cpp

247 lines
7.3 KiB
C++
Raw Normal View History

2023-11-22 08:39:24 +00:00
#include <cassert>
#include <stdexcept>
#include <nlohmann/json.hpp>
#include "client.h"
#include "models.h"
MastodonClient mastodon_client;
2023-11-23 23:46:47 +00:00
static void handle_post_server(Post& post, const std::string& host);
2023-11-22 08:39:24 +00:00
static void share_lock(CURL* curl, curl_lock_data data, curl_lock_access access, void* clientp);
static void share_unlock(CURL* curl, curl_lock_data data, void* clientp);
static size_t curl_write_cb(char* ptr, size_t size, size_t nmemb, void* userdata);
template<typename A>
void setopt(CURLSH* share, CURLSHoption option, A parameter) {
CURLSHcode code = curl_share_setopt(share, option, parameter);
if (code) {
throw CurlShareException(code);
}
}
template<typename A>
void setopt(CURL* curl, CURLoption option, A parameter) {
CURLcode code = curl_easy_setopt(curl, option, parameter);
if (code) {
throw CurlException(code);
}
}
MastodonClient::MastodonClient() {
this->_share = curl_share_init();
if (!this->_share) {
throw std::bad_alloc();
}
try {
setopt(this->_share, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
setopt(this->_share, CURLSHOPT_SHARE, CURL_LOCK_DATA_SSL_SESSION);
setopt(this->_share, CURLSHOPT_SHARE, CURL_LOCK_DATA_CONNECT);
setopt(this->_share, CURLSHOPT_SHARE, CURL_LOCK_DATA_PSL);
setopt(this->_share, CURLSHOPT_SHARE, CURL_LOCK_DATA_HSTS);
setopt(this->_share, CURLSHOPT_LOCKFUNC, share_lock);
setopt(this->_share, CURLSHOPT_UNLOCKFUNC, share_unlock);
setopt(this->_share, CURLSHOPT_USERDATA, this->_share_locks);
} catch (const std::exception& e) {
curl_share_cleanup(this->_share);
throw;
}
int err = pthread_key_create(&this->_easy_key, curl_easy_cleanup);
if (err) {
curl_share_cleanup(this->_share);
throw std::system_error(err, std::generic_category(), "pthread_key_create()");
}
}
MastodonClient::~MastodonClient() {
curl_share_cleanup(this->_share);
int err = pthread_key_delete(this->_easy_key);
if (err) {
perror("pthread_key_delete()");
}
}
std::optional<Account> MastodonClient::get_account_by_username(const std::string& host, const std::string& username) {
using namespace std::string_literals;
try {
Account account = this->_send_request("https://"s + host + "/api/v1/accounts/lookup?acct=" + username);
account.same_server = host == account.server;
return account;
} catch (const MastodonException& e) {
if (e.response_code != 404) {
2023-11-23 06:05:17 +00:00
throw;
}
return std::nullopt;
}
}
2023-11-23 13:43:55 +00:00
std::vector<Post> MastodonClient::get_pinned_posts(const std::string& host, const std::string& account_id) {
using namespace std::string_literals;
std::vector<Post> posts = this->_send_request("https://"s + host + "/api/v1/accounts/" + account_id + "/statuses?pinned=true");
2023-11-23 13:43:55 +00:00
for (Post& post : posts) {
2023-11-23 23:46:47 +00:00
handle_post_server(post, host);
2023-11-23 13:43:55 +00:00
}
return posts;
}
2023-11-23 08:49:27 +00:00
std::vector<Post> MastodonClient::get_posts(const std::string& host, const std::string& account_id, PostSortingMethod sorting_method, std::optional<std::string> max_id) {
using namespace std::string_literals;
const char* sorting_parameters[3] = {"exclude_replies=true", "", "only_media=true"};
std::string query = sorting_parameters[sorting_method];
if (max_id) {
if (!query.empty()) {
query += '&';
}
query += "max_id=";
query += std::move(*max_id);
}
std::string url = "https://"s + host + "/api/v1/accounts/" + account_id + "/statuses";
if (!query.empty()) {
url += '?';
url += query;
}
std::vector<Post> posts = this->_send_request(url);
2023-11-23 08:49:27 +00:00
for (Post& post : posts) {
2023-11-23 23:46:47 +00:00
handle_post_server(post, host);
2023-11-23 08:49:27 +00:00
}
return posts;
}
2023-11-23 23:46:47 +00:00
std::optional<Post> MastodonClient::get_post(const std::string& host, const std::string& id) {
using namespace std::string_literals;
try {
Post post = this->_send_request("https://"s + host + "/api/v1/statuses/" + id);
2023-11-23 23:46:47 +00:00
handle_post_server(post, host);
return post;
} catch (const MastodonException& e) {
if (e.response_code != 404) {
2023-11-23 23:46:47 +00:00
throw;
}
return std::nullopt;
}
}
PostContext MastodonClient::get_post_context(const std::string& host, const std::string& id) {
using namespace std::string_literals;
PostContext context = this->_send_request("https://"s + host + "/api/v1/statuses/" + id + "/context");
2023-11-23 23:46:47 +00:00
for (Post& post : context.ancestors) {
handle_post_server(post, host);
}
for (Post& post : context.descendants) {
handle_post_server(post, host);
}
return context;
}
2023-11-22 08:39:24 +00:00
CURL* MastodonClient::_get_easy() {
CURL* curl = pthread_getspecific(this->_easy_key);
if (!curl) {
curl = curl_easy_init();
if (!curl) {
throw std::bad_alloc();
}
try {
setopt(curl, CURLOPT_TIMEOUT_MS, 10000L);
2023-11-22 10:54:56 +00:00
setopt(curl, CURLOPT_PROTOCOLS_STR, "https");
setopt(curl, CURLOPT_USERAGENT, "Coyote (https://gitlab.com/blankX/coyote; blankie@nixnetmail.com)");
setopt(curl, CURLOPT_SHARE, this->_share);
2023-11-22 08:39:24 +00:00
} catch (const std::exception& e) {
curl_easy_cleanup(curl);
throw;
}
int err = pthread_setspecific(this->_easy_key, curl);
if (err) {
curl_easy_cleanup(curl);
throw std::system_error(err, std::generic_category(), "pthread_setspecific()");
}
}
return curl;
}
nlohmann::json MastodonClient::_send_request(const std::string& url) {
2023-11-22 08:39:24 +00:00
std::string res;
CURL* curl = this->_get_easy();
setopt(curl, CURLOPT_URL, url.c_str());
setopt(curl, CURLOPT_WRITEFUNCTION, curl_write_cb);
setopt(curl, CURLOPT_WRITEDATA, &res);
CURLcode code = curl_easy_perform(curl);
if (code) {
throw CurlException(code);
}
long response_code = this->_response_status_code();
nlohmann::json j = nlohmann::json::parse(std::move(res));
if (response_code != 200) {
throw MastodonException(response_code, j.at("error").get<std::string>());
}
return j;
2023-11-22 08:39:24 +00:00
}
long MastodonClient::_response_status_code() {
long response_code;
CURLcode code = curl_easy_getinfo(this->_get_easy(), CURLINFO_RESPONSE_CODE, &response_code);
if (code) {
throw CurlException(code);
}
return response_code;
}
2023-11-23 23:46:47 +00:00
static void handle_post_server(Post& post, const std::string& host) {
post.account.same_server = host == post.account.server;
if (post.reblog) {
post.reblog->account.same_server = host == post.reblog->account.server;
}
}
2023-11-22 08:39:24 +00:00
static void share_lock(CURL* curl, curl_lock_data data, curl_lock_access access, void* clientp) {
(void)curl;
(void)access;
std::mutex* mutexes = reinterpret_cast<std::mutex*>(clientp);
assert(CURL_LOCK_DATA_LAST > data);
mutexes[data].lock();
}
static void share_unlock(CURL* curl, curl_lock_data data, void* clientp) {
(void)curl;
std::mutex* mutexes = reinterpret_cast<std::mutex*>(clientp);
assert(CURL_LOCK_DATA_LAST > data);
mutexes[data].unlock();
}
static size_t curl_write_cb(char* ptr, size_t size, size_t nmemb, void* userdata) {
size_t realsize = size * nmemb;
std::string* str = reinterpret_cast<std::string*>(userdata);
// XXX should we bother with exceptions
str->append(ptr, realsize);
return realsize;
}