path: root/src/api.c

#pragma once
#define _XOPEN_SOURCE
#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, m, ...) dc_push_error(e, s, __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, 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"
/*
	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
	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 and when appending to the array shall be incremented **after** the element is appended, so reading threads may function normally
	- keep arrays as arrays of pointers, not direct structs, as that allows reading an array when appending is in progress by another thread
	- threading and races 101: when popping arrays, always lock in a non-shared way, same obviously applies for sorting, but not necessarily for appending (when only a shared lock is needed)
	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, you also shared lock it when appending
	- 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 and appending to arrays and other types
	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) {
	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;
	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) {
	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 */
	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) {
	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]);
	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 */
};
int dc_guild_free (struct dc_guild * g) {
	free(g->name); g->name = NULL;
	g->id = 0;
	for (int i = 0; i < g->channels_sizeof; i++)
		dc_channel_free(g->channels[i]);
	g->channels_sizeof = 0;
	free(g);
}
struct dc_client {
	CURL * curl; /* noui */
	struct curl_slist * curl_headers; /* noui */
	char * authorization; /* noui */
	char * email; /* yesfree, noapiw */
	char * password; /* yesfree, noapiw */
	char * username; /* yesfree, nouiw */
	int discriminator; /* nouiw */
	struct dc_guild ** guilds; /* yesfree, nouiw */
	_Atomic(size_t) guilds_sizeof; /* nouiw */
	struct dc_channel * joinedchannel; /* nofree, nouiw */
	struct dc_error ** errors; /* yesfree */
	_Atomic(size_t) errors_sizeof;
	struct dc_message ** sent_messages; /* yesfree - ui appends, api pops and moves to messages */
	_Atomic(size_t) sent_messages_sizeof;
};
int dc_client_free (struct dc_client * c) {
	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]);
	c->guilds_sizeof = 0;
	for (int i = 0; i < c->errors_sizeof; i++)
		dc_error_free(c->errors[i]);
	c->errors_sizeof = 0;
	for (int i = 0; i < c->sent_messages_sizeof; c++)
		dc_message_free(c->sent_messages[i]);
	c->sent_messages_sizeof = 0;
	free(c);
}
int dc_push_error (struct dc_error * e, size_t * s, const char * c, char * f, size_t l, unsigned short int isfmt, char * m, ...) {
	e = realloc(e, sizeof(struct dc_error)*++*s); /* note: format arguments are evaluated twice */
	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;
	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) {
	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;
	}
	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);
	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 = -7;
		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 = -8;
		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 = -9;
		goto rc;
	}
	c->username = realloc(c->username, strlen(token->valuestring)+1);
	strcpy(c->username, token->valuestring);
	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->username || !c->username[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;
	}
	for (int i = 0; i < c->guilds_sizeof; i++)
		dc_guild_free(&c->guilds[i]);
	c->guilds = NULL;
	c->guilds_sizeof = 0;
	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;
		}
		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 = strtoull(value2, NULL, 10);
		c->guilds[c->guilds_sizeof-1].channels_sizeof = 0;
		c->guilds[c->guilds_sizeof-1].channels = NULL;
	}
	rc:
	free(s.ptr); s.ptr = NULL;
	cJSON_Delete(json); json = NULL;
	return rs;
}
int dc_fetch_channels (struct dc_client * c, struct dc_guild * g) {
	int rs = 1;
	if (!c)
		return -1;
	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 -2;
		} else rs = 1;
	if (!g || !g->id) {
		DC_CLIENT_ERROR(c, "!g || !g->id");
		return -3;
	}
	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);
	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;
	for (int i = 0; i < g->channels_sizeof; i++)
		dc_channel_free(&g->channels[i]);
	g->channels_sizeof = 0;
	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 = "";
		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;
	}
	rc:
	free(s.ptr); s.ptr = NULL;
	free(url); url = NULL;
	cJSON_Delete(json); json = NULL;
	return rs;
}
int dc_send_message (struct dc_client * c, struct dc_message * m) {
	int rs = 1;
	struct tm tm; /* not used at all, you can delete it, I am autistic xD */
	if (!c)
		return -1;
	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 -2;
		} else rs = 1;
	/* it'd be bad to assume joinedchannel if the following is false though */
	if (!m) {
		DC_CLIENT_ERROR(c, "!m");
		return -3;
	}
	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);
	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_client * c, struct dc_channel * ch) {
	int rs = 1;
	struct tm tm;
	if (!c)
		return -1;
	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 -2;
		} else rs = 1;
	/* it'd be bad to assume joinedchannel if the following is false though */
	if (!ch || !ch->id) {
		DC_CLIENT_ERROR(c, "!ch || !ch->id");
		return -3;
	}
	cJSON * json = DC_API(c->curl, NULL, DC_API_PREFIX "channels/%llu/messages?limit=100&_=", 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;
	}
	cJSON * message = NULL;
	/*
	 for (int i = 0; i < ch->messages_sizeof; i++)
		dc_message_free(&ch->messages[i]);
		ch->messages_sizeof = 0;
	*/ /* we'll rather add messages to existing ones */
	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 */
	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! */
	size_t dc_clients_sizeof;
};
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 */