path: root/src/api.c

#define _XOPEN_SOURCE 600
#define _POSIX_C_SOURCE 200809L
#include <sys/types.h>
#include <stdlib.h>
#include <stdio.h>
#include <curl/curl.h>
#include <unistd.h>
#include <i18n.h>
#include <string.h>
#include <lib.c>
#include <cJSON.h>
#include <cJSON.c>
#include <time.h>
#include <stdarg.h>
#include <printf.h>
#include <pthread.h>
#include <stdatomic.h>
#define DC_API_PREFIX "https://discord.com/api/v8/" /* this can be a format string, DO NOT use format characters inside */
#define DC_LOGIN_FORMAT "{\"login\":\"%s\",\"password\":\"%s\",\"undelete\":false,\"captcha_key\":null,\"login_source\":null,\"gift_code_sku_id\":null}"
#define DC_USER_AGENT "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.131 Safari/537.36"
#define DC_ERROR(e, s, l, m, ...) dc_push_error(e, s, l, __func__, __FILE__, __LINE__, 0##__VA_OPT__(1), m __VA_OPT__(,) __VA_ARGS__)
#define DC_CLIENT_ERROR(c, m, ...) DC_ERROR(c->errors, &c->errors_sizeof, c->errors_lock, m __VA_OPT__(,) __VA_ARGS__) /* yeah, that m is not a typo */
#define DC_API(curl, body, endpoint, ...) dc_api(curl, body, 0##__VA_OPT__(1), endpoint __VA_OPT__(,) __VA_ARGS__)
#define cJSON_GetObjectItem2(root, name1, name2) (cJSON_GetObjectItem(root, name1) ? cJSON_GetObjectItem(cJSON_GetObjectItem(root, name1), name2) : NULL)
#define DC_TIMESTAMP_FORMAT "%Y-%m-%dT%H:%M:%S.XXXXXX%z"
#define DC_CWLE(c, name) (pthread_rwlock_wrlock(name) ? (DC_CLIENT_ERROR(c, DC_I18N_LOCKING " " #name " " DC_I18N_FAILED) || 1) : 0)
#define DC_CRLE(c, name) (pthread_rwlock_rdlock(name) ? (DC_CLIENT_ERROR(c, DC_I18N_LOCKING " " #name " " DC_I18N_FAILED) || 1) : 0)
#define DC_CUE(c, name) (pthread_rwlock_unlock(name) ?(DC_CLIENT_ERROR(c, DC_I18N_UNLOCKING " " #name " " DC_I18N_FAILED) || 1) : 0)
/*
	struct members comment information:
	- noui: the ui thread must not use the member (for example curl pointers are noui)
	- noapi: the api thread must not use the member
	- nofree: the (string) pointer is of a static string, do not attempt to free it (for example function, file, message in dc_error)
	- yesfree: the (string) pointer is of a dynamically-allocated string, free it before losing pointer to the struct (most strings)
	- nouiw: ui must not write
	- noapiw: api must not write
	- nolock: no lock is required if only reading is done after a single write to the memory area or only one thread accesses it
	guidelines:
	- when threading, you must use mutexes to prevent accessing structs (and their pointers because of realloc!) (optionaly with timeouts that are optionaly reported with DC_CLIENT_ERROR)
	- error reporting function shall not report an error to itself when mutex lock times out for obvious reasons
	- _sizeofs shall represent the size of arrays in atomic types
	- keep arrays as arrays of pointers, not direct structs, as that allows pointing to individual elements without them changing pointer addresses
	- threading and races 101: when popping arrays, always lock in a non-shared way, same obviously applies for sorting, writing, appending (because of reallocs of pointer arrays)
	mutexes:
	- mutexes for child members are kept in the struct with the object that is being modified. if realloc is used on strings or those child objects (pointers change), the whole struct must be locked.
	- when reading arrays of pointers, you shared lock it
	- when writing, lock the memory in a non shared way, take note of the pointer in case of realloc
	struct pointed to from multiple sections (a great example is a channel)
	- when a channel is created, DO NOT destroy it - never free channels if you don't free messages, never free guilds if you don't free channels. that's because channels in guilds are backpointed to parent guilds and messages are backpointed to channels, realloc would lead to a segfault.
	- use posixes pthread_rwlock_init(3POSIX) mutexes to allow reading to arrays and other types
	- do not have the illusion that you can append to an array of pointers without non-shared locking, because you realloc that array of pointers, appending must also be non-shared locked
	- _free functions shall never fail - do not use timed locks
	TODO: make it work.
	- i changed arrays from type arrays to type pointer arrays, so code that allocates must be reimplemented, also struct free functions and -> instead of . in array elements
	- make mutex locks in api and ui thread
	- make the ui thread
*/
struct dc_error {
	size_t line;
	const char * function; /* nofree */
	char * file; /* nofree */
	char * message; /* yesfree */
	time_t time;
	short unsigned int reported /* 0: error was not yet shown to the user, 1: error was already shown to the user */;
};
int dc_error_free(struct dc_error * e) { /* noui, noapi, nolock - only called by dc_client_free */
	free(e->message); e->message = NULL; /* other strings are static */
	e->line = 0;
	e->function = NULL;
	e->file = NULL;
	e->reported = 0;
	free(e);
};
struct dc_message {
	char * username; /* yesfree */
	int discriminator;
	char * content; /* yesfree */
	time_t time;
	_Atomic(struct dc_channel *) channel; /* nofree */
	unsigned short int tts;
	unsigned long long int id; /* nouiw */
	unsigned short int status; /* noapiw - 0 if it was not yet printed on the display, 1 if it was */
};
int dc_message_free (struct dc_message * m) { /* noui, noapi, nolock - only called by dc_channel_free */
	free(m->username); m->username = NULL;
	free(m->content); m->content = NULL;
	m->channel = NULL;
	m->tts = 0;
	m->discriminator = -1;
	m->id = 0;
	/* i'm not sure how to "unset" time_t ... */
	free(m);
}
int dc_message_compare (const void * a, const void * b) {
	struct dc_message * c = *(struct dc_message **) a;
	struct dc_message * d = *(struct dc_message **) b;
	/* strežnik v arrayu najprej pošlje sporočila iz sedanjosti, nato tista iz preteklosti, zato bo tudi sortiran array takšen */
	return c->time > d->time ? -1 : c->time < d->time ? 1 : 0;
}
struct dc_channel {
	char * name; /* yesfree, nouiw */
	char * topic; /* yesfree, nouiw */
	unsigned long long int id; /* nouiw */
	_Atomic(struct dc_guild *) guild; /* nofree, nouiw */
	struct dc_message ** messages; /* yesfree, nouiw */
	_Atomic(size_t) messages_sizeof; /* nouiw */
};
int dc_channel_free (struct dc_channel * ch) { /* noui, noapi, nolock - only called by dc_guild_free */
	free(ch->name); ch->name = NULL;
	free(ch->topic); ch->topic = NULL;
	ch->guild = NULL;
	ch->id = 0;
	for (int i = 0; i < ch->messages_sizeof; i++)
		dc_message_free(ch->messages[i]);
	free(ch->messages);
	ch->messages_sizeof = 0;
	free(ch);
}
struct dc_guild {
	char * name; /* nouiw, yesfree */
	unsigned long long id; /* nouiw */
	_Atomic(size_t) channels_sizeof; /* nouiw */
	struct dc_channel ** channels; /* yesfree, nouiw */
	_Atomic(struct dc_client *) client; /* nofree - obviously */
};
int dc_guild_free (struct dc_guild * g) { /* noui, noapi, nolock - only called by dc_client_free */
	free(g->name); g->name = NULL;
	g->id = 0;
	for (int i = 0; i < g->channels_sizeof; i++)
		dc_channel_free(g->channels[i]);
	free(g->channels);
	g->channels_sizeof = 0;
	free(g);
}
struct dc_client {
	CURL * curl; /* noui, nolock */
	struct curl_slist * curl_headers; /* noui, nolock */
	char * authorization; /* nouiw */
	pthread_rwlock_t * authorization_lock;
	char * email; /* yesfree, noapiw, nolock */
	char * password; /* yesfree, noapiw, nolock */
	char * username; /* yesfree, nouiw */ 
	pthread_rwlock_t * username_lock;
	_Atomic(int) discriminator; /* nouiw - < 0 indicates that the user is not logged in - set last in login procedure */
	struct dc_guild ** guilds; /* yesfree, nouiw */
	_Atomic(size_t) guilds_sizeof; /* nouiw */
	pthread_rwlock_t * guilds_lock;
	_Atomic(struct dc_channel *) joinedchannel; /* nofree, noapiw */
	struct dc_error ** errors; /* yesfree */
	_Atomic(size_t) errors_sizeof;
	pthread_rwlock_t * errors_lock;
	struct dc_message ** sent_messages; /* yesfree - ui appends, api pops and moves to messages */
	_Atomic(size_t) sent_messages_sizeof;
	pthread_rwlock_t * sent_messages_lock;
};
struct dc_client * dc_client_init () { /* gives you a prepared dc_client */
	struct dc_client * c = calloc(1, sizeof(struct dc_client));
	c->discriminator = -1;
#define DC_CILI(name) /* Client Init Lock Init */ if (pthread_rwlock_init(name##_lock, NULL)) goto fuck;
	DC_CILI(c->authorization);
	DC_CILI(c->username);
	DC_CILI(c->guilds);
	DC_CILI(c->errors);
	DC_CILI(c->sent_messages);
	return c;
	fuck:
#define DC_CILD(name) if (name##_lock) pthread_rwlock_destroy(name##_lock)
	DC_CILD(c->authorization);
	DC_CILD(c->username);
	DC_CILD(c->guilds);
	DC_CILD(c->errors);
	DC_CILD(c->sent_messages);
	free(c);
	return NULL; /* don't even check for this, if pthread_rwlock_init fails we'll segfault */
}
int dc_client_free (struct dc_client * c) { /* noui, noapi, nolock - only called by main on exit */
	curl_easy_cleanup(c->curl);
	curl_slist_free_all(c->curl_headers);
	free(c->authorization); c->authorization = NULL;
	free(c->email); c->email = NULL;
	free(c->password); c->password = NULL;
	free(c->username); c->username = NULL;
	c->discriminator = -1;
	c->joinedchannel = NULL;
	for (int i = 0; i < c->guilds_sizeof; i++)
		dc_guild_free(c->guilds[i]);
	free(c->guilds);
	c->guilds_sizeof = 0;
	for (int i = 0; i < c->errors_sizeof; i++)
		dc_error_free(c->errors[i]);
	free(c->errors);
	c->errors_sizeof = 0;
	for (int i = 0; i < c->sent_messages_sizeof; c++)
		dc_message_free(c->sent_messages[i]);
	free(c->sent_messages);
	c->sent_messages_sizeof = 0;
	free(c);
}
int dc_push_error (struct dc_error ** e, _Atomic size_t * s, pthread_rwlock_t * lock, const char * c, char * f, size_t l, unsigned short int isfmt, char * m, ...) {
	if (lock && pthread_rwlock_wrlock(lock))
		return -1; /* does not report an error as that may make things even worse. I could try writing to stderr here but meh */
	e = realloc(e, sizeof(struct dc_error *)*++*s); /* note: format arguments are evaluated twice */
	e[*s-1] = malloc(sizeof(struct dc_error));
	size_t strlenm = strlen(m);
	size_t va_count = parse_printf_format(m, 0, NULL);
	if (isfmt && va_count > 0) {
		va_list ap, ap2;
		va_start(ap, m);
		va_copy(ap2, ap);
		strlenm = vsnprintf(NULL, 0, m, ap);
		e[*s-1]->message = malloc(sizeof(char)*strlenm+1);
		vsnprintf(e[*s-1]->message, strlenm+1, m, ap2);
		va_end(ap);
		va_end(ap2);
	} else {
		e[*s-1]->message = malloc(sizeof(char)*strlenm+1);
		strcpy(e[*s-1]->message, m);
	}
	e[*s-1]->file = f;
	e[*s-1]->line = l;
	e[*s-1]->function = c /* Caller */;
	e[*s-1]->time = time(NULL);
	e[*s-1]->reported = 0;
	if (lock && pthread_rwlock_unlock(lock))
		return -2;
	return 1;
}
cJSON * dc_api (CURL * curl, char * body, int isfmt, char * endpoint, ...) { /* note: format arguments are evaluated twice */
	if (!curl)
		return NULL;
	if (!endpoint)
		return NULL;
	cJSON * json = NULL;
	struct writefunc_string s;
	init_writefunc_string(&s);
	size_t va_count = parse_printf_format(endpoint, 0, NULL);
	char * endpoint_formatted = NULL;
	if (isfmt && va_count > 0) {
		va_list ap, ap2;
		va_start(ap, endpoint);
		va_copy(ap2, ap);
		size_t strlenm = vsnprintf(NULL, 0, endpoint, ap);
		endpoint_formatted = malloc(sizeof(char)*strlenm+1);
		vsnprintf(endpoint_formatted, strlenm, endpoint_formatted, ap2); /* sn instead of s because double evaulation may produce */
		va_end(ap); /* larger output the next time and lead to overflow */
		va_end(ap2);
	}
	curl_easy_setopt(curl, CURLOPT_URL, endpoint_formatted ? endpoint_formatted : endpoint);
	if (!body)
		curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);
	else
		curl_easy_setopt(curl, CURLOPT_POSTFIELDS, body);
	curl_easy_setopt(curl, CURLOPT_WRITEDATA, &s);
	if (curl_easy_perform(curl) != CURLE_OK)
		goto rc;
	json = cJSON_Parse(s.ptr);
	rc:
	free(endpoint_formatted);
	free(s.ptr); s.ptr = NULL;
	return json;
}
int dc_login (struct dc_client * c) { /* noui */
	int rs = 1;
	struct writefunc_string s;
	char * data = NULL;
	cJSON * json = NULL;
	if (!c)
		return -1;
	if (!c->email || !c->password) {
		DC_CLIENT_ERROR(c, DC_I18N_MISSING_EP);
		return -2;
	}
	if (!c->curl)
		c->curl = curl_easy_init();
	if (!c->curl) {
		DC_CLIENT_ERROR(c, "curl_easy_init() " DC_I18N_FAILED);
		return -3;
	}
	init_writefunc_string(&s);
	data = malloc(strlen(DC_LOGIN_FORMAT)+strlen(c->email)+strlen(c->password)+1);
	CURLcode res;
	sprintf(data, DC_LOGIN_FORMAT, c->email, c->password);
	c->curl_headers = curl_slist_append(c->curl_headers, "Content-Type: application/json");
	c->curl_headers = curl_slist_append(c->curl_headers, "User-Agent: " DC_USER_AGENT);
	curl_easy_setopt(c->curl, CURLOPT_URL, DC_API_PREFIX "auth/login");
	curl_easy_setopt(c->curl, CURLOPT_FOLLOWLOCATION, 1L);
	curl_easy_setopt(c->curl, CURLOPT_POSTFIELDS, data);
	curl_easy_setopt(c->curl, CURLOPT_WRITEFUNCTION, writefunc);
	curl_easy_setopt(c->curl, CURLOPT_HTTPHEADER, c->curl_headers);
	curl_easy_setopt(c->curl, CURLOPT_WRITEDATA, &s);
	res = curl_easy_perform(c->curl);
	if (res != CURLE_OK) {
		DC_CLIENT_ERROR(c, "curl_easy_perform() " DC_I18N_FAILED ": %s", curl_easy_strerror(res)); /* yeah, format strings are supported */
		rs = -4;
		goto rc;
	}
	json = cJSON_Parse(s.ptr);
	if (!json) {
		const char *error_ptr = cJSON_GetErrorPtr();
		if (!error_ptr) {
			DC_CLIENT_ERROR(c, "cJSON_Parse " DC_I18N_FAILED ": " DC_I18N_JSON_ERROR_BEFORE ": %s", error_ptr);
		} else {
			DC_CLIENT_ERROR(c, "cJSON_Parse " DC_I18N_FAILED);
		}
		rs = -5;
		goto rc;
	}
	cJSON * token = cJSON_GetObjectItem(json, "token");
	if (!cJSON_IsString(token)) {
		DC_CLIENT_ERROR(c, "!cJSON_IsString(token)");
		rs = -6;
		goto rc;
	}
	if (DC_CWLE(c, c->authorization_lock)) {rs = -7; goto rc;}
	c->authorization = realloc(c->authorization, strlen(token->valuestring)+1);
	strcpy(c->authorization, token->valuestring);
	data = realloc(data, strlen(c->authorization)+strlen("Authorization: ")+1);
	strcpy(data, "Authorization: ");
	strcat(data, c->authorization);
	if (DC_CUE(c, c->authorization_lock)) {rs = -8; goto rc;}
	free(s.ptr); s.ptr = NULL;
	init_writefunc_string(&s);
	curl_easy_setopt(c->curl, CURLOPT_URL, DC_API_PREFIX "users/@me");
	curl_easy_setopt(c->curl, CURLOPT_HTTPGET, 1L);
	curl_easy_setopt(c->curl, CURLOPT_WRITEDATA, &s);
	c->curl_headers = curl_slist_append(c->curl_headers, data);
	res = curl_easy_perform(c->curl);
	if (res != CURLE_OK) {
		DC_CLIENT_ERROR(c, "curl_easy_perform() " DC_I18N_FAILED ": %s", curl_easy_strerror(res));
		rs = -9;
		goto rc;
	}
	cJSON_Delete(json);
	json = cJSON_Parse(s.ptr);
	if (!json) {
		const char *error_ptr = cJSON_GetErrorPtr();
		if (!error_ptr) {
			DC_CLIENT_ERROR(c, "cJSON_Parse " DC_I18N_FAILED ": " DC_I18N_JSON_ERROR_BEFORE ": %s", error_ptr);
		} else {
			DC_CLIENT_ERROR(c, "cJSON_Parse " DC_I18N_FAILED);
		}
		rs = -10;
		goto rc;
	}
	token = cJSON_GetObjectItem(json, "username");
	cJSON * token2 = cJSON_GetObjectItem(json, "discriminator");
	if (!cJSON_IsString(token) || !cJSON_IsString(token2)) {
		DC_CLIENT_ERROR(c, "!cJSON_IsString(token) || !cJSON_IsString(token2)");
		rs = -11;
		goto rc;
	}
	if (DC_CWLE(c, c->username_lock)) {rs = -11; goto rc;}
	c->username = realloc(c->username, strlen(token->valuestring)+1);
	strcpy(c->username, token->valuestring);
	if (DC_CUE(c, c->username_lock)) {rs = -12; goto rc;}
	c->discriminator = strtol(token2->valuestring, NULL, 10);
	rc:
	free(s.ptr); s.ptr = NULL;
	free(data); data = NULL;
	cJSON_Delete(json);
	return rs;
}
int dc_fetch_guilds (struct dc_client * c) {
	if (!c)
		return -5;
	int rs = 1;
	struct writefunc_string s;
	char * value = NULL;
	char * value2 = NULL;
	CURLcode res;
	cJSON * json = NULL;
	if (c->discriminator < 0)
		if ((rs = dc_login(c)) < 0) {
			DC_CLIENT_ERROR(c, "dc_login(c) " DC_I18N_FAILED " (%d)", rs);
			return -1;
		} else rs = 1;
	curl_easy_setopt(c->curl, CURLOPT_URL, DC_API_PREFIX "users/@me/guilds");
	curl_easy_setopt(c->curl, CURLOPT_HTTPGET, 1L);
	curl_easy_setopt(c->curl, CURLOPT_WRITEDATA, &s);
	init_writefunc_string(&s);
	res = curl_easy_perform(c->curl);
	if (res != CURLE_OK) {
		DC_CLIENT_ERROR(c, "curl_easy_perform(c->curl) " DC_I18N_FAILED ": %s", curl_easy_strerror(res));
		rs = -2;
		goto rc;
	}
	json = cJSON_Parse(s.ptr);
	if (!json) {
		const char *error_ptr = cJSON_GetErrorPtr();
		if (!error_ptr) {
			DC_CLIENT_ERROR(c, "cJSON_Parse " DC_I18N_FAILED ": " DC_I18N_JSON_ERROR_BEFORE ": %s", error_ptr);
		} else {
			DC_CLIENT_ERROR(c, "cJSON_Parse " DC_I18N_FAILED);
		}
		rs = -3;
		goto rc;
	}
	if (!cJSON_IsArray(json)) {
		DC_CLIENT_ERROR(c, "!cJSON_IsArray(json)");
		rs = -4;
		goto rc;
	}
	if(DC_CWLE(c, c->guilds_lock)) {rs = -5; goto rc;}
	cJSON * guild = NULL;
	cJSON_ArrayForEach(guild, json) {
		value = cJSON_GetStringValue(cJSON_GetObjectItem(json, "id"));
		value2 = cJSON_GetStringValue(cJSON_GetObjectItem(json, "name"));
		if (!value || !value2) {
			DC_CLIENT_ERROR(c, "!cJSON_GetStringValue(cJSON_GetObjectItem(json, \"id\" || \"name\"))");
			continue;
		}
		unsigned long long int idull = strtoull(value2, NULL, 10);
		for (int i = 0; i < c->guilds_sizeof; i++)
			if (idull == c->guilds[i]->id)
				continue; /* remove duplicates */
		c->guilds = realloc(c->guilds, ++c->guilds_sizeof);
		c->guilds[c->guilds_sizeof-1]->name = malloc(strlen(value)+1);
		strcpy(c->guilds[c->guilds_sizeof-1]->name, value);
		c->guilds[c->guilds_sizeof-1]->id = idull;
		c->guilds[c->guilds_sizeof-1]->channels_sizeof = 0;
		c->guilds[c->guilds_sizeof-1]->channels = NULL;
		c->guilds[c->guilds_sizeof-1]->client = c;
	}
	if(DC_CUE(c, c->guilds_lock)) {rs = -6; goto rc;}
	rc:
	free(s.ptr); s.ptr = NULL;
	cJSON_Delete(json); json = NULL;
	return rs;
}
int dc_fetch_channels (struct dc_guild * g) {
	int rs = 1;
	if (!g || !g->id) {
		return -1;
	}
	struct dc_client * c = g->client;
	if (!c)
		return -2;
	if (c->discriminator < 0)
		if ((rs = dc_login(c)) < 0) {
			DC_CLIENT_ERROR(c, "dc_login(c) " DC_I18N_FAILED " (%d)", rs);
			return -3;
		} else rs = 1;
	CURLcode res;
	struct writefunc_string s;
	init_writefunc_string(&s);
	cJSON * json = NULL;
	char * url = malloc(strlen(DC_API_PREFIX "guilds/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx/channels")+1);
	sprintf(url, DC_API_PREFIX "guilds/%llu/channels", g->id); /* only api thread writes ids, so this is safe without locks */
	curl_easy_setopt(c->curl, CURLOPT_URL, url);
	curl_easy_setopt(c->curl, CURLOPT_HTTPGET, 1L);
	curl_easy_setopt(c->curl, CURLOPT_WRITEDATA, &s);
	res = curl_easy_perform(c->curl);
	if (res != CURLE_OK) {
		DC_CLIENT_ERROR(c, "curl_easy_perform(c->curl) " DC_I18N_FAILED ": %s", curl_easy_strerror(res));
		rs = -4;
		goto rc;
	}
	json = cJSON_Parse(s.ptr);
	if (!json) {
		const char *error_ptr = cJSON_GetErrorPtr();
		if (!error_ptr) {
			DC_CLIENT_ERROR(c, "cJSON_Parse " DC_I18N_FAILED ": " DC_I18N_JSON_ERROR_BEFORE ": %s", error_ptr);
		} else {
			DC_CLIENT_ERROR(c, "cJSON_Parse " DC_I18N_FAILED);
		}
		rs = -5;
		goto rc;
	}
	if (!cJSON_IsArray(json)) {
		DC_CLIENT_ERROR(c, "!cJSON_IsArray(json), s.ptr = %s", s.ptr);
		rs = -6;
		goto rc;
	}
	cJSON * channel = NULL;
	/* we lock all client guilds when doing stuff with channels */
	if (DC_CWLE(c, c->guilds_lock)) {rs = -7; goto rc;}
	cJSON_ArrayForEach(channel, json) {
		char * topic = cJSON_GetStringValue(cJSON_GetObjectItem(json, "topic"));
		char * name = cJSON_GetStringValue(cJSON_GetObjectItem(json, "name"));
		char * id = cJSON_GetStringValue(cJSON_GetObjectItem(json, "id"));
		double type = cJSON_GetNumberValue(cJSON_GetObjectItem(json, "type"));
		if (!id || !name || type == NAN) {
			DC_CLIENT_ERROR(c, "!id || !name || type == NAN");
			continue;
		}
		if (type != 0) /* if it's not a text channel (z. B. voice channel, category, ...) */
			continue;
		if (!topic)
			topic = "";
		unsigned long long int idull = strtoull(id, NULL, 10);
		for (int i = 0; i < g->channels_sizeof; i++)
			if (idull == g->channels[i]->id)
				continue; /* remove duplicates */
		g->channels = realloc(g->channels, ++g->channels_sizeof);
		g->channels[g->channels_sizeof-1]->name = malloc(strlen(name)+1);
		strcpy(g->channels[g->channels_sizeof-1]->name, name);
		g->channels[g->channels_sizeof-1]->topic = malloc(strlen(topic)+1);
		strcpy(g->channels[g->channels_sizeof-1]->topic, topic);
		g->channels[g->channels_sizeof-1]->id = strtoull(id, NULL, 10);
		g->channels[g->channels_sizeof-1]->guild = g;
		g->channels[g->channels_sizeof-1]->messages = NULL;
		g->channels[g->channels_sizeof-1]->messages_sizeof = 0;
	}
	if (DC_CUE(c, c->guilds_lock)) {rs = -8; goto rc;}
	rc:
	free(s.ptr); s.ptr = NULL;
	free(url); url = NULL;
	cJSON_Delete(json); json = NULL;
	return rs;
}
int dc_send_message (struct dc_message * m) { /* nolock - once message is appended to the c->sent_messages queue you must not remove it or alter it */
	int rs = 1;
	if (!m)
		return -1;
	struct dc_client * c = m->channel->guild->client; /* segfault senpai */
	if (!c)
		return -2;
	if (!c->username || !c->username[0])
		if ((rs = dc_login(c)) < 0) {
			DC_CLIENT_ERROR(c, "dc_login(c) " DC_I18N_FAILED " (%d)", rs);
			return -3;
		} else rs = 1;
	cJSON * json = cJSON_CreateObject();
	cJSON * nons = cJSON_CreateNumber(rand());
	cJSON_AddItemToObject(json, "nonce", nons);
	cJSON * content = cJSON_CreateString(m->content);
	cJSON_AddItemToObject(json, "content", content);
	cJSON * tts = m->tts ? cJSON_CreateTrue() : cJSON_CreateFalse();
	cJSON_AddItemToObject(json, "tts", tts);
	char * body = cJSON_Print(json);
	if (!body) {
		DC_CLIENT_ERROR(c, "cJSON_Print " DC_I18N_FAILED);
		rs = -4;
		goto rc;
	}
	cJSON_Delete(json); json = NULL;
	/* {content: "yeet", nonce: "820762917392613376", tts: false} */
	json = DC_API(c->curl, body, DC_API_PREFIX "channels/%llu/messages", m->channel->id); /* ids are only written by api thread, nolock */
	if (!json) {
		const char *error_ptr = cJSON_GetErrorPtr();
		if (!error_ptr) {
			DC_CLIENT_ERROR(c, "cJSON_Parse " DC_I18N_FAILED ": " DC_I18N_JSON_ERROR_BEFORE ": %s", error_ptr);
		} else {
			DC_CLIENT_ERROR(c, "cJSON_Parse " DC_I18N_FAILED);
		}
		rs = -5;
		goto rc;
	}
	char * discriminator = cJSON_GetStringValue(cJSON_GetObjectItem2(json, "author", "discriminator"));
	if (!discriminator) {
		DC_CLIENT_ERROR(c, "!discriminator");
		rs = -6;
		goto rc;
	}
	m->discriminator = strtol(discriminator, NULL, 10);
	char * username = cJSON_GetStringValue(cJSON_GetObjectItem2(json, "author", "username"));
	if (!username) {
		DC_CLIENT_ERROR(c, "!username");
		rs = -6;
		goto rc;
	}
	m->username = malloc(strlen(username)+1);
	strcpy(m->username, username); /* we don't directly point as that changes when we delete */
	rc:
	free(body); body = NULL;
	cJSON_Delete(json); json = NULL;
	return rs;
}
int dc_fetch_messages (struct dc_channel * ch) {
	int rs = 1;
	struct tm tm;
	if (!ch || !ch->id)
		return -1;
	struct dc_guild * g = ch->guild;
	if (!g || !g->client)
		return -2;
	struct dc_client * c = g->client;
	if (!c)
		return -3;
	if (c->discriminator < 0)
		if ((rs = dc_login(c)) < 0) {
			DC_CLIENT_ERROR(c, "dc_login(c) " DC_I18N_FAILED " (%d)", rs);
			return -4;
		} else rs = 1;
	cJSON * json = DC_API(c->curl, NULL, DC_API_PREFIX "channels/%llu/messages?limit=100&_=%d", ch->id, rand());
	if (!json) {
		const char *error_ptr = cJSON_GetErrorPtr();
		if (!error_ptr) {
			DC_CLIENT_ERROR(c, "cJSON_Parse " DC_I18N_FAILED ": " DC_I18N_JSON_ERROR_BEFORE ": %s", error_ptr);
		} else {
			DC_CLIENT_ERROR(c, "cJSON_Parse " DC_I18N_FAILED);
		}
		rs = -5;
		goto rc;
	}
	if (!cJSON_IsArray(json)) {
		DC_CLIENT_ERROR(c, "!cJSON_IsArray(json)");
		rs = -6;
		goto rc;
	}
	if (DC_CWLE(c, c->guilds_lock)) {rs = -7; goto rc;} /* we lock all guilds of a client when writing messages */
	cJSON * message = NULL;
	cJSON_ArrayForEach(message, json) {
		char * timestamp = cJSON_GetStringValue(cJSON_GetObjectItem(json, "timestamp"));
		char * content = cJSON_GetStringValue(cJSON_GetObjectItem(json, "content"));
		char * id = cJSON_GetStringValue(cJSON_GetObjectItem(json, "id"));
		char * discriminator = cJSON_GetStringValue(cJSON_GetObjectItem2(json, "author", "discriminator"));
		char * username = cJSON_GetStringValue(cJSON_GetObjectItem2(json, "author", "username"));
		if (!id || !timestamp || !content || !username || !discriminator) {
			DC_CLIENT_ERROR(c, "!id || !timestamp || !content || !username || discriminator < 0");
			continue;
		}
		if (strlen(timestamp) < 26) {
			DC_CLIENT_ERROR(c, "strlen(timestamp) < 26");
			continue;
		}
		for (int i = 20; i <= 25; i++)
			timestamp[i] == 'X'; /* because strptime does not have wildcard support and those numbers are sub-second fractions */
		if (!strptime(timestamp, DC_TIMESTAMP_FORMAT, &tm)) {
			DC_CLIENT_ERROR(c, "strptime(timestamp, DC_TIMESTAMP_FORMAT, &tm) " DC_I18N_FAILED);
			continue;
		}
		unsigned long long int idull = strtoull(id, NULL, 10);
		for (int i = 0; i < ch->messages_sizeof; i++)
			if (idull == ch->messages[i]->id)
				continue; /* remove duplicates */
		ch->messages = realloc(ch->messages, ++ch->messages_sizeof);
#define DC_FMTM /* fetch messages this message */ ch->messages[ch->messages_sizeof-1]
		DC_FMTM->time = mktime(&tm);
		DC_FMTM->content = malloc(strlen(content)+1);
		strcpy(DC_FMTM->content, content);
		DC_FMTM->username = malloc(strlen(username)+1);
		strcpy(DC_FMTM->username, username);
		DC_FMTM->id = idull;
		DC_FMTM->discriminator = strtol(discriminator, NULL, 10);
		DC_FMTM->channel = ch;
	}
	qsort(ch->messages, ch->messages_sizeof, sizeof(struct dc_message), dc_message_compare); /* we sort so that present messages are in the start of the array and old messages are to the end of the array */
	if (DC_CUE(c, c->guilds_lock)) {rs = -8; goto rc;}
	rc:
	cJSON_Delete(json); json = NULL;
	return rs;
}
struct dc_api_thread_control {
	unsigned short int power; /* 1 if the thread should run, set it to 0 for the thread to return at the end of the loop */
	struct dc_client ** clients; /* "array" of pointers to clients the thread should manage, ONLY ONE dc_api_thread PER PROCESS! */
	_Atomic(size_t) dc_clients_sizeof;
	pthread_rwlock_t * clients_lock;
};
int dc_api_thread (struct dc_api_thread_control * t) { /* updates messages and sends messages when they are in the outbox */
	return 1;
} /* the thread shall use mutexes when doing things with shared memory - client structs */