diff options
Diffstat (limited to 'src/api.c')
| -rw-r--r-- | src/api.c | 574 |
1 files changed, 574 insertions, 0 deletions
diff --git a/src/api.c b/src/api.c new file mode 100644 index 0000000..adcdf3c --- /dev/null +++ b/src/api.c @@ -0,0 +1,574 @@ +#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> +#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 dc_error { + size_t line; + const char * function /* this is a static string, so it is not copied, do not free it */; + char * file /* this is a static string, so it is not copied, do not free it */; + char * message /* this is copied, caller can free it if it was dynamically created by it, it must be freed before destroying struct */; + 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; + int discriminator; + char * content; + time_t time; + struct dc_channel * channel; + unsigned short int tts; + unsigned long long int id; +}; +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; + char * topic; + unsigned long long int id; + struct dc_guild * guild; + struct dc_message * messages; + size_t messages_sizeof; + unsigned short int sent /* describes status, was message already sent (1) or is it to-be sent (0)? */; +}; +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; + unsigned long long id; + size_t channels_sizeof; + struct dc_channel * channels; +}; +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; + struct curl_slist * curl_headers; + char * authorization; + char * email; /* email and password are copied, even though they are sometimes static ENV vars - they are not always! */ + char * password; + char * username; + int discriminator; + struct dc_guild * guilds; + size_t guilds_sizeof; + struct dc_channel * joinedchannel; + struct dc_error * errors; + size_t errors_sizeof; + struct dc_message * sent_messages; + 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); + 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 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 */ |