dscrd.h

Go to the documentation of this file.

/*
 *     dscrd: Discord C library
 *     Copyright (C) 2018 Jakub Wasylków
 *
 *     This program is free software: you can redistribute it and/or modify
 *     it under the terms of the GNU Lesser General Public License as published by
 *     the Free Software Foundation, either version 3 of the License, or
 *     (at your option) any later version.
 *
 *     This program is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *     GNU Lesser General Public License for more details.
 *
 *     You should have received a copy of the GNU Lesser General Public License
 *     along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
// This file was autogenerated by gen_dscrd_h.sh.

// common.h

#ifndef uint8_t
#include <stdint.h>
#endif
#ifndef bool
#include <stdbool.h>
#endif

#define DISCORD_API 6

// needed for types which come before client.h
struct DiscordClient_s;

// http methods already defined by rest library
#ifndef REST_CLIENT_H_

enum http_method {
    HTTP_POST, HTTP_GET, HTTP_PUT, HTTP_DELETE, HTTP_HEAD, HTTP_OPTIONS, HTTP_PATCH
};
#endif

typedef enum dscrd_type_e {
    DSCRD_TYPE_FIRST,
    DSCRD_GUILD,
    DSCRD_CHANNEL,
    DSCRD_USER,
    DSCRD_WEBHOOK,
    DSCRD_CLIENT,
    DSCRD_REST_RESP,
    // ignoring list types
    DSCRD_FILE,
    DSCRD_MESSAGE,
    DSCRD_TYPE_LAST,
    DSCRD_TYPE_LIST = 256
} dscrd_type;

int dscrd_has_gateway (void);

const char * dscrd_error (void);

const char * dscrd_error_long (void);

void dscrd_overwrite_api (int api);

int dscrd_initialize (void);

int dscrd_terminate (void);

//
// Things which hard to assign somewhere else...
//

enum dscrd_verification_level {
    NONE,
    LOW,
    MEDIUM,
    HIGH,
    VERY_HIGH
};

typedef enum permissions_e {
    CREATE_INSTANT_INVITE   =   0x00000001,
    KICK_MEMBERS            =   0x00000002,
    BAN_MEMBERS             =   0x00000004,
    ADMINISTRATOR           =   0x00000008,
    MANAGE_CHANNELS         =   0x00000010,
    MANAGE_GUILD            =   0x00000020,
    ADD_REACTIONS           =   0x00000040,
    VIEW_AUDIT_LOG          =   0x00000080,
    VIEW_CHANNEL            =   0x00000400,
    SEND_MESSAGES           =   0x00000800,
    SEND_TTS_MESSAGES       =   0x00001000,
    MANAGE_MESSAGES         =   0x00002000,
    EMBED_LINKS             =   0x00004000,
    ATTACH_FILES            =   0x00008000,
    READ_MESSAGE_HISTORY    =   0x00010000,
    MENTION_EVERYONE        =   0x00020000,
    USE_EXTERNAL_EMOJIS     =   0x00040000,
    CONNECT                 =   0x00100000,
    SPEAK                   =   0x00200000,
    MUTE_MEMBERS            =   0x00400000,
    DEAFEN_MEMBERS          =   0x00800000,
    MOVE_MEMBERS            =   0x01000000,
    USE_VAD                 =   0x02000000,
    PRIORITY_SPEAKER        =   0x00000100,
    CHANGE_NICKNAME         =   0x04000000,
    MANAGE_NICKNAMES        =   0x08000000,
    MANAGE_ROLES            =   0x10000000,
    MANAGE_WEBHOOKS         =   0x20000000,
    MANAGE_EMOJI            =   0x40000000
} permissions;

#define ID(X) X ## "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

// activity.h

enum activity_types {
    ACTIVITY_GAME,
    ACTIVITY_STREAMING,
    ACTIVITY_LISTENING
};

typedef struct DiscordActivity_s {
    char application_id[21];
    uint8_t _type;
    char *name;
    int type;
    char *url;
    int timestamp_start;

    int timestamp_stop;

    char *details;
    char *state;

    // information for the current party of the player
    // party object

    // images for the presence and their hover texts
    // assets object

    // secrets for Rich Presence joining and spectating
    // secrets object

    bool instance;
    int flags;
} DiscordActivity;
// user.h

enum dscrd_user_status {
    STATUS_ONLINE,
    STATUS_DND,
    STATUS_IDLE,
    STATUS_INVISIBLE,
    STATUS_OFFLINE
};

typedef struct DiscordUser_s {
    char id[21];
    uint8_t _type;
    char * username;
    char discriminator[5];
    char *avatar;
    bool bot;
    bool mfa_enabled;
    bool verified;
    char *email;

    struct DiscordClient_s *discord_client;
} DiscordUser;

DiscordUser * DiscordUser_me (struct DiscordClient_s *client);

DiscordUser * DiscordUser_get (struct DiscordClient_s *client, char * user_id);
void DiscordUser_destroy (DiscordUser *user);

// client.h

typedef enum token_type_e {
    Bearer, Bot, User, Anonymous
} token_type;

#define TOKEN_TO_STR(X) (X == Bearer) ? "Bearer" : (X == Bot) ? "Bot" : (X == User) ? "User" : ""

typedef struct DiscordClient_s {
    char _name[21];
    //
    uint8_t _type;
    void *c;
    unsigned char api;
    token_type type;
    char * token;
    char * auth_string;

    struct DiscordUser_s me;
    struct DiscordUser_s *user;

    unsigned char user_status;

    bool temporary;
    // ref-count, numebers equal entries dscrd_type_e
    short refc[DSCRD_TYPE_LAST];
    void *gateway;
    int gateway_flags;
} DiscordClient;

DiscordClient * DiscordClient_open (token_type type, const char * token);

#define DiscordClient_open_auth(X) DiscordClient_open((X)->type, (X)->token)

void DiscordClient_close (DiscordClient *d);

enum gateway_flags {
    LAZYLOAD_GUILDS = 1,
    // last flags
    GATEWAY_FLAGS_LAST = 2
};

int DiscordClient_gateway (DiscordClient *client, int flags);

int DiscordClient_set_status (DiscordClient *client, enum dscrd_user_status status);

int DiscordClient_set_game (DiscordClient *client, DiscordActivity *activity);

// dscrdd.h

typedef struct DscrdAuth_s {
    char token[64];
    token_type type;
} DscrdAuth;


int dscrdd_auth (DscrdAuth *auth, const char *app_name);

// guild.h

typedef struct DiscordGuild_s {
    char id[21];
    //
    uint8_t _type;
    char * name;
    char * icon;
    char * splash;
    bool owner;
    char owner_id[21];
    int permissions;
    char * region;
    char afk_channel_id[21];
    int afk_timeout;
    bool embed_enabled;
    char embed_channel_id[21];
    int verification_level;
    int default_message_notifications;
    int explicit_content_filter;
    /*TODO*/ //
    /*TODO*/ //
    char **features;
    int mfa_level;
    char application_id[21];
    bool widget_enabled;
    char widget_channel_id[21];
    char system_channel_id[21];
    // These fields are only sent within the GUILD_CREATE event:
    /*
    joined_at? *    ISO8601 timestamp   when this guild was joined at
    large? *    bool    whether this is considered a large guild
    unavailable? *  bool    is this guild unavailable
    member_count? * integer total number of members in this guild
    voice_states? * array of partial voice state objects    (without the guild_id key)
    members? *  array of guild member objects   users in the guild
    channels? * array of channel objects    channels in the guild
    presences? *
    */
    struct DiscordClient_s *discord_client;
} DiscordGuild;

DiscordGuild * DiscordGuild_get (DiscordClient *client, char *guild_id);

DiscordGuild * DiscordGuild_by_name (DiscordClient *client, char *guild_name);

DiscordGuild ** DiscordGuilds_get (DiscordClient *client);

void DiscordGuilds_destroy (DiscordGuild **guilds);

void DiscordGuild_destroy (DiscordGuild *guild);

// channel.h

typedef struct DiscordChannel_s {
    char id[21];
    uint8_t _type;
    int type;
    char guild_id[21];
    int position;
    // todo permission overwrites
    char *name;
    char *topic;

    bool nsfw;
    char last_message_id[21];

    int bitrate;
    int user_limit;
    // recipients?
    char *icon;
    char owner_id[21];
    char application_id[21];
    char parent_id[21];
    char *last_pin_timestamp;

    DiscordClient *discord_client;
} DiscordChannel;

typedef struct DiscordChannelList_s {
    int count;
    DiscordChannel **c;
} DiscordChannelList;

enum channel_types {
    GUILD_TEXT, DM, GUILD_VOICE, GROUP_DM, GUILD_CATEGORY
};


DiscordChannel * DiscordChannel_get (DiscordClient *client, char *channel_id);

DiscordChannel * DiscordChannel_get_fast (DiscordClient *client, char *channel_id);

int DiscordChannel_modify (DiscordChannel *channel, ...);

DiscordChannel * DiscordChannel_by_name (DiscordGuild *guild, char *channel_name);

int DiscordChannel_send_message_simple (DiscordChannel *channel, const char *message);

DiscordChannelList * DiscordChannels_in_guild (DiscordGuild *guild);

DiscordChannel * DiscordChannelList_pop (DiscordChannelList *list, int i);

void DiscordChannelList_destroy (DiscordChannelList *channels);

void DiscordChannel_destroy (DiscordChannel * channel);

// file.h

#define DSCRD_FILE_NULL ((DscrdFile *) "dummy")

typedef struct DscrdFile_s {
    char head[13];
    uint32_t data_len;
    uint32_t data_base64_len;
    uint8_t _type;
    char *mime;
    char *filename;
    char *data;
    char *data_base64;
    char *encoded;
} DscrdFile;

DscrdFile * DscrdFile_get (const char *filename);

DscrdFile * DscrdFile_get_mime (const char *filename, const char *mime_type);

void DscrdFile_destroy (DscrdFile *file);

// message.h

typedef struct DiscordMessage_s {
    char id[21];
    uint8_t _type;
    char channel_id[21];
    DiscordUser *author;
    char *content;
    char *timestamp;
    char *edited_timestamp;
    bool tts;
    bool mention_everyone;
    DiscordUser **mentions;
    // TODO roles type //mention_roles
    // todo //attachments
    // embeds
    // reactions
    char nonce[21];
    bool pinned;
    char webhook_id[21];
    int type;

    // sent with Rich Presence-related chat embeds:
    // activity
    // application

    DiscordClient *discord_client;

} DiscordMessage;

enum message_types {
DEFAULT, RECIPIENT_ADD, RECIPIENT_REMOVE, CALL,
CHANNEL_NAME_CHANGE, CHANNEL_ICON_CHANGE, CHANNEL_PINNED_MESSAGE, GUILD_MEMBER_JOIN
};

int DiscordMessage_callback_all (DiscordClient *client, int (*callback)(DiscordMessage *));

int DiscordMessage_callback_mentions (DiscordClient *client, int (*callback)(DiscordMessage *));

int DiscordMessage_delete_id (DiscordClient *client, const char *channel_id, const char *message_id);

int DiscordMessage_delete (DiscordMessage *message);

DiscordMessage * DiscordMessage_new_simple (DiscordChannel *channel, const char *message);

void DiscordMessage_destroy (DiscordMessage *msg);

DiscordMessage * DiscordMessage_get (DiscordChannel *channel, char *message_id);

// webhook.h

typedef struct Webhook_s {
    // id is in snowflake format, 64-bit -> uint64 -> strlen(uint64_max) == 20 bytes + terminating char
    char id[21];
    //
    uint8_t _type;
    char guild_id[21];
    char channel_id[21];
    DiscordUser user;
    DiscordUser *user_p;
    char * name;
    char * avatar;
    char token[128];
    bool use_token;
    DiscordClient *discord_client;
} Webhook;

typedef struct WebhookList_s {
    int count;
    Webhook **w;
} WebhookList;

Webhook * Webhook_get (DiscordClient *client, char * id);

Webhook * Webhook_get_no_auth (char * id, char * token);

Webhook * Webhook_get_no_auth_url (const char * url);

Webhook * Webhook_create (DiscordChannel * channel, char * name, DscrdFile * avatar);

void Webhook_destroy (Webhook * webhook);

int Webhook_execute (Webhook * webhook, const char * message, const char * username, const char * avatar_url);

int Webhook_execute_simple (Webhook * webhook, const char * message);

int Webhook_delete (Webhook * webhook);

int Webhook_modify (Webhook *webhook, const char *name, DscrdFile *avatar);

int Webhook_move (Webhook *webhook, DiscordChannel *channel);

WebhookList * Webhooks_in_channel (DiscordClient *client, DiscordChannel * channel);

WebhookList * Webhooks_in_guild (DiscordClient *client, DiscordGuild *guild);

void WebhookList_destroy (WebhookList *list);

// con/gateway.h

struct DiscordGuild_s;


struct DiscordGuild_s ** DiscordClient_lazy_guilds (DiscordClient *client);


typedef struct GatewayResp_s {
    char *event;
    void *data;
    int data_type;
    unsigned char terminate;
    void *userdata;
} GatewayResp;

enum gateway_callback_resp {
    CALLBACK_OK,
    CALLBACK_ABORT
};


int DiscordGateway_callback (DiscordClient *client, char *event, int (*func)(GatewayResp *), void *userdata);