discord-internal.h

Go to the documentation of this file.

 
#ifndef DISCORD_INTERNAL_H
#define DISCORD_INTERNAL_H
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
#include <pthread.h>
 
#define JSONB_HEADER
#include "json-build.h"
#define JSMN_STRICT
#define JSMN_HEADER
#include "jsmn.h"
#include "jsmn-find.h"
#define LOGMOD_HEADER
#include "logmod.h"
 
#include "user-agent.h"
#include "websockets.h"
#include "cog-utils.h"
#include "io_poller.h"
#include "queue.h"
#include "priority_queue.h"
#include "attributes.h"
 
#define NOT_EMPTY_STR(_str) ((_str) && *(_str))
#define CONTAINEROF(_ptr, _type, _path)                                       \
    ((_type *)((char *)(_ptr) - offsetof(_type, _path)))
 
#define CLIENT(_ptr, _path) CONTAINEROF(_ptr, struct discord, _path)
 
#define CCORD_EXPECT(_client, _expect, _code, _reason)                        \
    do {                                                                      \
        if (!(_expect)) {                                                     \
            logmod_log(ERROR, (_client)->logger,                              \
                       "Expected: " #_expect " | %s (%s)",                    \
                       discord_strerror(_code, _client),                      \
                       discord_code_as_string(_code));                        \
            return _code;                                                     \
        }                                                                     \
    } while (0)
 
#define CCORD_DATA_TO_JSON(_client, _type, _body, _params)                    \
    do {                                                                      \
        struct reflectc_wrap *w_params =                                      \
            reflectc_from_##_type((_client)->registry, _params, NULL);        \
        CCORDcode code = discord_data_wrap_to_json(w_params, &(_body)->start, \
                                                   &(_body)->size);           \
        reflectc_cleanup((_client)->registry, w_params);                      \
        if (code != CCORD_OK) {                                               \
            logmod_log(ERROR, (_client)->logger,                              \
                       "Expected: CCORD_OK == discord_data_wrap_to_json | "   \
                       "%s (%s)",                                             \
                       discord_strerror(code, _client),                       \
                       discord_code_as_string(code));                         \
            return code;                                                      \
        }                                                                     \
    } while (0)
 
#define DISCORD_ENDPT_LEN 512
#define DISCORD_ROUTE_LEN 256
 
struct discord_timers {
    priority_queue *q;
    struct io_poller *io;
    struct {
        bool is_active;
        pthread_t thread;
        struct discord_timer *timer;
        bool skip_update_phase;
    } active;
    pthread_mutex_t lock;
    pthread_cond_t cond;
};
 
CCORDcode discord_timers_init(struct discord_timers *timers,
                              struct io_poller *io);
 
void discord_timers_cleanup(struct discord *client,
                            struct discord_timers *timers);
 
int64_t discord_timers_get_next_trigger(struct discord_timers *const timers[],
                                        size_t n,
                                        int64_t now,
                                        int64_t max_time);
 
void discord_timers_run(struct discord *client, struct discord_timers *timers);
 
unsigned _discord_timer_ctl(struct discord *client,
                            struct discord_timers *timers,
                            struct discord_timer *timer);
 
unsigned discord_internal_timer_ctl(struct discord *client,
                                    struct discord_timer *timer);
 
unsigned discord_internal_timer(struct discord *client,
                                discord_ev_timer on_tick_cb,
                                discord_ev_timer on_status_changed_cb,
                                void *data,
                                int64_t delay);
 
#define DISCORD_BUCKET_TIMEOUT (void *)(0xf)
 
struct discord_ratelimiter {
    struct logmod_logger *logger;
    int length;
    int capacity;
    struct _discord_route *routes;
    struct discord_bucket *null;
    struct discord_bucket *miss;
 
    /* client-wide global ratelimiting */
    u64unix_ms *global_wait_tstamp;
 
    struct {
        QUEUE(struct discord_bucket) pending;
    } queues;
};
 
CCORDcode discord_ratelimiter_init(struct discord_ratelimiter *rl);
 
void discord_ratelimiter_cleanup(struct discord_ratelimiter *rl);
 
void discord_ratelimiter_build_key(enum http_method method,
                                   char key[DISCORD_ROUTE_LEN],
                                   const char endpoint_fmt[],
                                   va_list args);
 
void discord_ratelimiter_build(struct discord_ratelimiter *rl,
                               struct discord_bucket *bucket,
                               const char key[],
                               struct ua_info *info);
 
void discord_ratelimiter_set_global_timeout(struct discord_ratelimiter *rl,
                                            struct discord_bucket *bucket,
                                            u64unix_ms wait_ms);
 
struct discord_bucket {
    char hash[64];
    long limit;
    long remaining;
    u64unix_ms reset_tstamp;
 
    struct discord_request *busy_req;
 
    struct {
        QUEUE(struct discord_request) next;
    } queues;
    QUEUE entry;
};
 
void discord_bucket_set_timeout(struct discord_bucket *bucket,
                                u64unix_ms wait_ms);
 
struct discord_bucket *discord_bucket_get(struct discord_ratelimiter *rl,
                                          const char key[]);
 
void discord_bucket_insert(struct discord_ratelimiter *rl,
                           struct discord_bucket *b,
                           struct discord_request *req,
                           bool high_priority);
 
void discord_bucket_request_selector(
    struct discord_ratelimiter *rl,
    void *data,
    void (*iter)(void *data, struct discord_request *req));
 
void discord_bucket_request_unselect(struct discord_ratelimiter *rl,
                                     struct discord_bucket *b,
                                     struct discord_request *req);
 
struct discord_ret_dispatch {
    DISCORD_RET_DEFAULT_FIELDS;
    bool has_type;
 
    union {
        void (*typed)(struct discord *client,
                      struct discord_response *resp,
                      const void *ret);
        void (*typeless)(struct discord *client,
                         struct discord_response *resp);
    } done;
 
    void *sync;
};
 
struct discord_ret_response {
    void *data;
    size_t size;
    struct reflectc_wrap *(*init)(struct reflectc *registry,
                                  void *data,
                                  struct reflectc_wrap *root);
};
 
#define DISCORD_ATTRIBUTES_FIELDS                                             \
             \
    struct discord_ret_dispatch dispatch;                                     \
     \
    struct discord_ret_response response;                                     \
        \
    struct discord_attachments attachments;                                   \
                 \
    char *reason
 
struct discord_attributes {
    DISCORD_ATTRIBUTES_FIELDS;
};
 
struct discord_request {
    DISCORD_ATTRIBUTES_FIELDS;
 
    struct discord_bucket *b;
    struct ccord_szbuf body;
    enum http_method method;
    char endpoint[DISCORD_ENDPT_LEN];
    char key[DISCORD_ROUTE_LEN];
    struct ua_conn *conn;
    CCORDcode code;
    struct ccord_szbuf_readonly json;
    int retry_attempt;
    pthread_cond_t *cond;
    QUEUE entry;
};
 
struct discord_requestor {
    struct logmod_logger *logger;
    struct user_agent *ua;
    CURLM *mhandle;
    struct discord_ratelimiter ratelimiter;
 
    int retry_limit;
 
    struct {
        QUEUE(struct discord_request) recycling;
        QUEUE(struct discord_request) pending;
        QUEUE(struct discord_request) finished;
    } *queues;
 
    struct {
        pthread_mutex_t recycling;
        pthread_mutex_t pending;
        pthread_mutex_t finished;
    } *qlocks;
};
 
CCORDcode discord_requestor_init(struct discord_requestor *rqtor,
                                 const char token[]);
 
void discord_requestor_cleanup(struct discord_requestor *rqtor);
 
CCORDcode discord_requestor_start_pending(struct discord_requestor *rqtor);
 
CCORDcode discord_requestor_info_read(struct discord_requestor *rqtor);
 
void discord_requestor_dispatch_responses(struct discord_requestor *rqtor);
 
void discord_request_cancel(struct discord_requestor *rqtor,
                            struct discord_request *req);
 
CCORDcode discord_request_begin(struct discord_requestor *rqtor,
                                const struct discord_attributes *req,
                                const struct ccord_szbuf *body,
                                const enum http_method method,
                                const char endpoint[DISCORD_ENDPT_LEN],
                                const char key[DISCORD_ROUTE_LEN]);
 
struct discord_rest {
    struct logmod_logger *logger;
    struct discord_requestor requestor;
    struct discord_timers timers;
    struct io_poller *io_poller;
    struct threadpool_t *tpool;
};
 
CCORDcode discord_rest_init(struct discord_rest *rest, const char token[]);
 
void discord_rest_cleanup(struct discord_rest *rest);
 
CCORDcode discord_rest_run(struct discord_rest *rest,
                           const struct discord_attributes *req,
                           const struct ccord_szbuf *body,
                           const enum http_method method,
                           const char endpoint_fmt[],
                           ...) PRINTF_LIKE(5, 6);
 
void discord_rest_stop_buckets(struct discord_rest *rest);
 
#define DISCORD_SESSION_OFFLINE 0u
#define DISCORD_SESSION_RESUMABLE 1u << 0
#define DISCORD_SESSION_SHUTDOWN 1u << 1
struct discord_gateway_session {
    bool is_ready;
    char id[64];
    int shards;
    char base_url[256];
    char resume_url[256];
    struct discord_session_start_limit start_limit;
    int concurrent;
    int event_count;
    unsigned status;
 
    struct {
        bool enable;
        int attempt;
        int limit;
    } retry;
};
 
struct discord_gateway_payload {
    struct {
        char *start;
        size_t size;
        jsmnf_table *table;
        size_t ntable;
    } json;
 
    enum discord_gateway_opcodes opcode;
    int seq;
    char name[32];
    enum discord_gateway_events event;
    const jsmnf_pair *data;
};
 
typedef void (*discord_ev_event)(struct discord *client, const void *event);
typedef void (*discord_ev_message)(struct discord *client,
                                   const struct discord_message *event);
 
struct discord_gateway {
    struct logmod_logger *logger;
    struct websockets *ws;
    CURLM *mhandle;
 
    struct {
        int64_t hbeat_interval;
        bool hbeat_acknowledged;
        u64unix_ms now;
        u64unix_ms hbeat_last;
        u64unix_ms identify_last;
        u64unix_ms event;
        unsigned hbeat_timer;
 
        int ping_ms;
        pthread_rwlock_t rwlock;
    } *timer;
 
    struct discord_identify id;
 
    struct discord_gateway_session *session;
 
    struct discord_gateway_payload payload;
    discord_ev_event cbs[2][DISCORD_EV_MAX];
    discord_ev_scheduler scheduler;
};
 
CCORDcode discord_gateway_init(struct discord_gateway *gw, const char token[]);
 
void discord_gateway_cleanup(struct discord_gateway *gw);
 
CCORDcode discord_gateway_start(struct discord_gateway *gw);
 
bool discord_gateway_end(struct discord_gateway *gw);
 
CCORDcode discord_gateway_perform(struct discord_gateway *gw);
 
void discord_gateway_shutdown(struct discord_gateway *gw);
 
void discord_gateway_reconnect(struct discord_gateway *gw, bool resume);
 
void discord_gateway_send_identify(struct discord_gateway *gw,
                                   struct discord_identify *event);
 
void discord_gateway_send_resume(struct discord_gateway *gw,
                                 struct discord_resume *event);
 
void discord_gateway_send_heartbeat(struct discord_gateway *gw, int seq);
 
void discord_gateway_send_request_guild_members(
    struct discord_gateway *gw, struct discord_request_guild_members *event);
 
void discord_gateway_send_update_voice_state(
    struct discord_gateway *gw, struct discord_update_voice_state *event);
 
void discord_gateway_send_presence_update(
    struct discord_gateway *gw, struct discord_presence_update *event);
 
void discord_gateway_dispatch(struct discord_gateway *gw);
 
struct discord_refcounter {
    struct logmod_logger *logger;
    int length;
    int capacity;
    struct _discord_ref *refs;
    pthread_mutex_t *g_lock;
};
 
CCORDcode discord_refcounter_init(struct discord_refcounter *rc);
 
void discord_refcounter_add_internal(struct discord_refcounter *rc,
                                     void *data,
                                     void (*cleanup)(void *data),
                                     bool should_free);
 
void discord_refcounter_add_client(struct discord_refcounter *rc,
                                   void *data,
                                   void (*cleanup)(struct discord *client,
                                                   void *data),
                                   bool should_free);
 
void discord_refcounter_cleanup(struct discord_refcounter *rc);
 
CCORDcode discord_refcounter_claim(struct discord_refcounter *rc,
                                   const void *data);
 
CCORDcode discord_refcounter_unclaim(struct discord_refcounter *rc,
                                     void *data);
 
CCORDcode discord_refcounter_incr(struct discord_refcounter *rc, void *data);
 
CCORDcode discord_refcounter_decr(struct discord_refcounter *rc, void *data);
 
struct discord_message_commands {
    const struct logmod_logger *logger;
    struct ccord_szbuf prefix;
    discord_ev_message fallback;
    int length;
    int capacity;
    struct _discord_message_commands_entry *entries;
};
 
CCORDcode discord_message_commands_init(struct discord_message_commands *cmds);
 
void discord_message_commands_cleanup(struct discord_message_commands *cmds);
 
discord_ev_message discord_message_commands_find(
    struct discord_message_commands *cmds,
    const char command[],
    size_t length);
 
void discord_message_commands_append(struct discord_message_commands *cmds,
                                     const char command[],
                                     size_t length,
                                     discord_ev_message callback);
 
void discord_message_commands_set_prefix(struct discord_message_commands *cmds,
                                         const char prefix[],
                                         size_t length);
 
bool discord_message_commands_try_perform(
    struct discord_message_commands *cmds,
    struct discord_gateway_payload *payload);
 
struct discord_cache {
    struct _discord_cache_data *data;
    void (*cleanup)(struct discord *client);
 
    void (*on_shard_disconnected)(struct discord *client,
                                  const struct discord_identify *ident,
                                  bool resumable);
    void (*on_shard_resumed)(struct discord *client,
                             const struct discord_identify *ident);
    void (*on_shard_reconnected)(struct discord *client,
                                 const struct discord_identify *ident);
};
 
struct discord {
    struct reflectc *registry;
    struct logmod_logger *logger;
    struct logmod_logger table[64];
    struct logmod logmod;
    struct discord_config config;
    unsigned pid;
    bool is_original;
    struct io_poller *io_poller;
 
    struct discord_message_commands commands;
    struct discord_refcounter refcounter;
 
    struct discord_rest rest;
    struct discord_gateway gw;
    struct discord_user self;
    struct discord_cache cache;
 
    int shutdown_fd;
 
    struct {
        struct discord_timers internal;
        struct discord_timers user;
    } timers;
 
    void (*on_idle)(struct discord *client);
    void (*on_cycle)(struct discord *client);
 
    void *data;
 
    struct {
        int count;
        pthread_mutex_t lock;
        pthread_cond_t cond;
    } *workers;
 
    struct ccord_szbuf file;
};
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#endif /* DISCORD_INTERNAL_H */