caniadd/src/api.c

#include <stdbool.h>
#include <string.h>
#include <assert.h>
#include <printf.h>
#include <time.h>
#include <pthread.h>
#include <errno.h>

#include <md5.h>
#include <aes.h>

#include "api.h"
#include "net.h"
#include "uio.h"
#include "config.h"
#include "ed2k.h"
#include "util.h"

/* Needed, bcuz of custom %B format */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat"
#pragma GCC diagnostic ignored "-Wformat-extra-args"

#ifdef CLOCK_MONOTONIC_COARSE
    #define API_CLOCK CLOCK_MONOTONIC_COARSE
#elif defined(CLOCK_MONOTONIC)
    #warn "No coarse monotonic clock"
    #define API_CLOCK CLOCK_MONOTONIC
#else
    #error "No monotonic clock"
#endif

#define MS_TO_TIMESPEC(ts, ms) { \
    ts->tv_sec = ms / 1000; \
    ts->tv_nsec = (ms % 1000) * 1000000; \
}

#define MS_TO_TIMESPEC_L(ts, ms) { \
    ts.tv_sec = ms / 1000; \
    ts.tv_nsec = (ms % 1000) * 1000000; \
}

static enum error api_cmd_logout(struct api_result *res);
static enum error api_cmd_auth(const char *uname, const char *pass,
        struct api_result *res);

static bool api_authed = false;
static char api_session[API_SMAXSIZE] = {0}; /* No escaping is needed */
static uint8_t e_key[16] = {0};
static bool api_encryption = false;

static pthread_t api_ka_thread = 0;
static pthread_mutex_t api_work_mx;
static bool api_ka_now = false; /* Are we doing keepalive now? */

static struct timespec api_last_packet = {0}; /* Last packet time */
static int32_t api_packet_count = 0; /* Only increment */
//static int32_t api_fast_packet_count = 0; /* Increment or decrement */

static int api_escaped_string(FILE *io, const struct printf_info *info,
        const void *const *args)
{
    /* Ignore newline escapes for now */
    char *str = *(char**)args[0];
    char *and_pos = strchr(str, '&');
    size_t w_chars = 0;

    if (and_pos == NULL)
        return fprintf(io, "%s", str);

    while (and_pos) {
        w_chars += fprintf(io, "%.*s", (int)(and_pos - str), str);
        w_chars += fprintf(io, "&amp;");

        str = and_pos + 1;
        and_pos = strchr(str, '&');
    }
    if (*str)
        w_chars += fprintf(io, "%s", str);

    return w_chars;
}

static int api_escaped_sring_info(const struct printf_info *info, size_t n,
        int *argtypes, int *size)
{
    if (n > 0) {
        argtypes[0] = PA_STRING;
        size[0] = sizeof(const char*);
    }
    return 1;
}

static enum error api_init_encrypt(const char *api_key, const char *uname)
{
    char buffer[API_BUFSIZE];
    MD5Context md5_ctx;
    char *salt_start = buffer + 4 /* 209 [salt here] ... */, *salt_end;
    ssize_t r_len, salt_len;

    if (net_send(buffer, snprintf(buffer, sizeof(buffer),
                "ENCRYPT user=%s&type=1", uname)) == -1) {
        return ERR_API_COMMFAIL;
    }
    r_len = net_read(buffer, sizeof(buffer));

    if (strncmp(buffer, "209", 3) != 0) {
        uio_error("We expected 209 response, but got: %.*s",
                (int)r_len, buffer);
        return ERR_API_ENCRYPTFAIL;
    }

    salt_end = strchr(salt_start, ' ');
    if (!salt_end) {
        uio_error("Cannot find space after salt in response");
        return ERR_API_ENCRYPTFAIL;
    }
    salt_len = salt_end - salt_start;

    md5Init(&md5_ctx);
    md5Update(&md5_ctx, (uint8_t*)api_key, strlen(api_key));
    md5Update(&md5_ctx, (uint8_t*)salt_start, salt_len);
    md5Finalize(&md5_ctx);
    memcpy(e_key, md5_ctx.digest, sizeof(e_key));

#if 1
    char *buffpos = buffer;
    for (int i = 0; i < 16; i++)
        buffpos += sprintf(buffpos, "%02x", e_key[i]);
    uio_debug("Encryption key is: '%s'", buffer);
#endif

    api_encryption = true;
    return NOERR;
}

static size_t api_encrypt(char *buffer, size_t data_len)
{
    struct AES_ctx actx;
    size_t rem_data_len = data_len, ret_len = data_len;
    char pad_value;

    AES_init_ctx(&actx, e_key);
    while (rem_data_len >= AES_BLOCKLEN) {
        AES_ECB_encrypt(&actx, (uint8_t*)buffer);

        buffer += AES_BLOCKLEN;
        rem_data_len -= AES_BLOCKLEN;
    }

    /* Possible BOF here? maybe? certanly. */
    pad_value = AES_BLOCKLEN - rem_data_len;
    ret_len += pad_value;

    memset(buffer + rem_data_len, pad_value, pad_value);
    AES_ECB_encrypt(&actx, (uint8_t*)buffer);

    assert(ret_len % AES_BLOCKLEN == 0);
    return ret_len;
}

static size_t api_decrypt(char *buffer, size_t data_len)
{
    assert(data_len % AES_BLOCKLEN == 0);
    
    struct AES_ctx actx;
    size_t ret_len = data_len;
    char pad_value;

    AES_init_ctx(&actx, e_key);
    while (data_len) {
        AES_ECB_decrypt(&actx, (uint8_t*)buffer);
        
        buffer += AES_BLOCKLEN;
        data_len -= AES_BLOCKLEN;
    }

    pad_value = buffer[data_len - 1];
    ret_len -= pad_value;

    return ret_len;
}

static enum error api_auth(const char* uname, const char *passw)
{
    struct api_result res;
    enum error err = NOERR;

    if (!api_encryption)
        uio_warning("Logging in without encryption!");
    if (api_cmd_auth(uname, passw, &res) != NOERR) {
        return ERR_API_AUTH_FAIL;
    }

    switch (res.code) {
    case 201:
        uio_warning("A new client version is available!");
    case 200:
        memcpy(api_session, res.auth.session_key, sizeof(api_session));
        api_authed = true;
        uio_debug("Succesfully logged in. Session key: '%s'", api_session);
        break;
    default:
        err = ERR_API_AUTH_FAIL;
        switch (res.code) {
        case 500:
            uio_error("Login failed. Please check your credentials again");
            break;
        case 503:
            uio_error("Client is outdated. You're probably out of luck here.");
            break;
        case 504:
            uio_error("Client is banned :( Reason: %s", res.auth.banned_reason);
            free(res.auth.banned_reason);
            break;
        case 505:
            uio_error("Illegal input or access denied");
            break;
        case 601:
            uio_error("AniDB out of service");
            break;
        default:
            uio_error("Unknown error: %hu", res.code);
            break;
        }
    }

    return err;
}

enum error api_logout()
{
    struct api_result res;
    enum error err = NOERR;

    if (api_cmd_logout(&res) != NOERR) {
        return ERR_API_AUTH_FAIL;
    }

    switch (res.code) {
    case 203:
        uio_debug("Succesfully logged out");
        api_authed = false;

        break;
    case 403:
        uio_error("Cannot log out, because we aren't logged in");
        api_authed = false;
        break;
    default:
        err = ERR_API_LOGOUT;
        uio_error("Unknown error: %hu", res.code);
        break;
    }

    return err;
}

static void api_keepalive(struct timespec *out_next)
{
    struct timespec ts = {0};
    uint64_t msdiff;

    clock_gettime(API_CLOCK, &ts);
    msdiff = util_timespec_diff(&api_last_packet, &ts);

    if (msdiff >= API_TIMEOUT) {
        struct api_result r;

        MS_TO_TIMESPEC(out_next, API_TIMEOUT);

        uio_debug("Sending uptime command for keep alive");
        // TODO what if another action is already in progress?
        api_cmd_uptime(&r);
    } else {
        uint64_t msnext = API_TIMEOUT - msdiff;

        uio_debug("Got keepalive request, but time is not up yet");
        MS_TO_TIMESPEC(out_next, msnext);
    }
}

void *api_keepalive_main(void *arg)
{
    struct timespec ka_time;
    MS_TO_TIMESPEC_L(ka_time, API_TIMEOUT);
    uio_debug("Hi from keepalie thread");

    for (;;) {
        if (nanosleep(&ka_time, NULL) != 0) {
            int e = errno;
            uio_error("Nanosleep failed: %s", strerror(e));
        }
        /* Needed, because the thread could be canceled while in recv or send
         * and in that case, the mutex will remain locked
         * Could be replaced with a pthread_cleanup_push ? */
        pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
        pthread_mutex_lock(&api_work_mx);
        api_ka_now = true;

        uio_debug("G'moooooning! Is it time to keep our special connection alive?");

        api_keepalive(&ka_time);
        uio_debug("Next wakey-wakey in %ld seconds", ka_time.tv_sec);
        api_ka_now = false;
        pthread_mutex_unlock(&api_work_mx);
        pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
    }
    return NULL;
}

enum error api_clock_init()
{
    struct timespec ts;
    memset(&api_last_packet, 0, sizeof(api_last_packet));
    api_packet_count = 0;

    if (clock_getres(API_CLOCK, &ts) != 0) {
        uio_error("Cannot get clock resolution: %s", strerror(errno));
        return ERR_API_CLOCK;
    }
    uio_debug("Clock resolution: %f ms",
            (ts.tv_sec * 1000) + (ts.tv_nsec / 1000000.0));

    return NOERR;
}

enum error api_init(bool auth)
{
    enum error err = NOERR;
    const char **api_key, **uname, **passwd;

    err = api_clock_init();
    if (err != NOERR)
        return err;

    err = net_init();
    if (err != NOERR)
        return err;

    if (config_get("api-key", (void**)&api_key) == NOERR) {
        if (config_get("username", (void**)&uname) != NOERR) {
            uio_error("Api key is specified, but that also requires "
                    "the username!");
            err = ERR_OPT_REQUIRED;
            goto fail;
        }
        err = api_init_encrypt(*api_key, *uname);
        if (err != NOERR) {
            uio_error("Cannot init api encryption");
            goto fail;
        }
    }

    /* Define an escaped string printf type */
    if (register_printf_specifier('B', api_escaped_string,
                api_escaped_sring_info) != 0) {
        uio_error("Failed to register escaped printf string function");
        err = ERR_API_PRINTFFUNC;
        goto fail;
    }

    if (auth) {
        if (config_get("username", (void**)&uname) != NOERR) {
            uio_error("Username is not specified, but it is required!");
            err = ERR_OPT_REQUIRED;
            goto fail;
        }
        if (config_get("password", (void**)&passwd) != NOERR) {
            uio_error("Password is not specified, but it is required!");
            err = ERR_OPT_REQUIRED;
            goto fail;
        }
        err = api_auth(*uname, *passwd);
        if (err != NOERR)
            goto fail;

        /* Only do keep alive if we have a session */
        if (pthread_mutex_init(&api_work_mx, NULL) != 0) {
            uio_error("Cannot create mutex");
            err = ERR_THRD;
            goto fail;
        }
        if (pthread_create(&api_ka_thread, NULL, api_keepalive_main, NULL) != 0) {
            uio_error("Cannot create api keepalive thread");
            err = ERR_THRD;
            goto fail;
        }

    }

#if 0
    printf("Testings: %B\n", "oi&ha=hi&wooooowz&");
    printf("Testings: %B\n", "oi&ha=hi&wooooowz");
    printf("Testings: %B\n", "&oi&ha=hi&wooooowz");
    printf("Testings: %B\n", "oooooooooiiiiii");
#endif

    return err;
fail:
    api_free();
    return err;
}

void api_free()
{
    if (api_authed) {
        if (pthread_cancel(api_ka_thread) != 0) {
            uio_error("Cannot cancel api keepalive thread");
        } else {
            int je = pthread_join(api_ka_thread, NULL);
            if (je != 0) {
                uio_error("Cannot join api keepalive thread: %s",
                        strerror(je));
            }
            if (pthread_mutex_destroy(&api_work_mx) != 0)
                uio_error("Cannot destroy api work mutex");
        }

        api_logout();
        memset(api_session, 0, sizeof(api_session));
        api_authed = false; /* duplicate */
    }
    if (api_encryption) {
        api_encryption = false;
        memset(e_key, 0, sizeof(e_key));
    }

    register_printf_specifier('B', NULL, NULL);
    net_free();
}

/*
 * We just sent a packet, so update the last packet time here
 */
static void api_ratelimit_sent()
{
    api_packet_count++;
    clock_gettime(API_CLOCK, &api_last_packet);
}

static void api_ratelimit()
{
    struct timespec ts = {0};
    uint64_t msdiff, mswait;
    uint64_t msrate = api_packet_count >= API_LONGTERM_PACKETS ?
        API_SENDWAIT_LONG : API_SENDWAIT;

    /* First of all, the first N packets are unmetered */
    if (api_packet_count <= API_FREESEND) {
        uio_debug("This packet is for free! Yay :D (%d/%d)",
                api_packet_count, API_FREESEND);
        return;
    }

    clock_gettime(API_CLOCK, &ts);
    msdiff = util_timespec_diff(&api_last_packet, &ts);
    uio_debug("Time since last packet: %ld ms", msdiff);

    if (msdiff >= msrate)
        return; /* No ratelimiting is needed */

    /* Need ratelimit, so do it here for now */
    mswait = msrate - msdiff;
    uio_debug("Ratelimit is needed, sleeping for %ld ms", mswait);

    MS_TO_TIMESPEC_L(ts, mswait);
    if (nanosleep(&ts, NULL) == -1) {
        if (errno == EINTR)
            uio_error("Nanosleep got interrupted");
        else
            uio_error("Nanosleep failed");
    }
}

static ssize_t api_send(char *buffer, size_t data_len, size_t buf_size)
{
    ssize_t read_len;

    api_ratelimit();
    uio_debug("{Api}: Sending: %.*s", (int)data_len, buffer);
    if (api_encryption)
        data_len = api_encrypt(buffer, data_len);

    if (net_send(buffer, data_len) == -1) {
        uio_error("Cannot send data: %s", strerror(errno));
        return -1;
    }

    read_len = net_read(buffer, buf_size);
    api_ratelimit_sent();

    if (api_encryption)
        read_len = api_decrypt(buffer, read_len);
    uio_debug("{Api}: Reading: %.*s", (int)read_len, buffer);

    return read_len;
}

long api_res_code(const char *buffer)
{
    char *end;
    long res = strtol(buffer, &end, 10);
    if (res == 0 && buffer == end) {
        uio_error("No error codes in the response");
        return -1;
    }
    assert(*end == ' ');
    return res;
}

static bool api_get_fl(const char *buffer, int32_t index, const char *delim,
        char **const out_start, size_t *const out_len)
{
    assert(index > 0);

    size_t len = strcspn(buffer, delim);

    while (--index > 0) {
        buffer += len + 1;
        len = strcspn(buffer, delim);
    }

    *out_start = (char*)buffer;
    *out_len = len;
    return true;
}

static bool api_get_line(const char *buffer, int32_t line_num,
        char **const out_line_start, size_t *const out_line_len)
{
    return api_get_fl(buffer, line_num, "\n", out_line_start, out_line_len);
}

static bool api_get_field(const char *buffer, int32_t field_num,
        char **const out_field_start, size_t *const out_field_len)
{
    return api_get_fl(buffer, field_num, " |\n", out_field_start, out_field_len);
}

#if 0
static char *api_get_field_mod(char *buffer, int32_t field_num)
{
    char *sptr = NULL;
    char *f_start;

    f_start = strtok_r(buffer, " ", &sptr);
    if (!f_start)
        return NULL;

    while (field_num --> 0) {
        f_start = strtok_r(NULL, " ", &sptr);
        if (!f_start)
            return NULL;
    }

    return f_start;
}
#endif

enum error api_cmd_version(struct api_result *res)
{
    char buffer[API_BUFSIZE] = "VERSION";
    size_t res_len = api_send(buffer, strlen(buffer), sizeof(buffer));
    long code;
    enum error err = NOERR;
    pthread_mutex_lock(&api_work_mx);

    if (res_len == -1) {
        err = ERR_API_COMMFAIL;
        goto end;
    }

    code = api_res_code(buffer);
    if (code == -1) {
        err = ERR_API_RESP_INVALID;
        goto end;
    }

    if (code == 998) {
        char *ver_start;
        size_t ver_len;
        bool glr = api_get_line(buffer, 2, &ver_start, &ver_len);

        assert(glr);
        (void)glr;
        assert(ver_len < sizeof(res->version.version_str));
        memcpy(res->version.version_str, ver_start, ver_len);
        res->version.version_str[ver_len] = '\0';
    }
    res->code = (uint16_t)code;
    
end:
    pthread_mutex_unlock(&api_work_mx);
    return err;
}

static enum error api_cmd_auth(const char *uname, const char *pass,
        struct api_result *res)
{
    pthread_mutex_lock(&api_work_mx);
    char buffer[API_BUFSIZE];
    long code;
    size_t res_len = api_send(buffer, snprintf(buffer, sizeof(buffer),
                "AUTH user=%s&pass=%B&protover=" API_VERSION "&client=caniadd&"
                "clientver=" PROG_VERSION "&enc=UTF-8", uname, pass),
            sizeof(buffer));
    enum error err = NOERR;

    if (res_len == -1) {
        err = ERR_API_COMMFAIL;
        goto end;
    }

    code = api_res_code(buffer);
    if (code == -1) {
        err = ERR_API_RESP_INVALID;
        goto end;
    }

    if (code == 200 || code == 201) {
        char *sess;
        size_t sess_len;
        bool gfr = api_get_field(buffer, 2, &sess, &sess_len);

        assert(gfr);
        (void)gfr;
        assert(sess_len < sizeof(res->auth.session_key));
        memcpy(res->auth.session_key, sess, sess_len);
        res->auth.session_key[sess_len] = '\0';
    } else if (code == 504) {
        char *reason;
        size_t reason_len;
        bool gfr = api_get_field(buffer, 5, &reason, &reason_len);

        assert(gfr);
        (void)gfr;
        res->auth.banned_reason = strndup(reason, reason_len);
    }
    res->code = (uint16_t)code;

end:
    pthread_mutex_unlock(&api_work_mx);
    return err;
}

static enum error api_cmd_logout(struct api_result *res)
{
    pthread_mutex_lock(&api_work_mx);
    char buffer[API_BUFSIZE];
    size_t res_len = api_send(buffer, snprintf(buffer, sizeof(buffer),
                "LOGOUT s=%s", api_session), sizeof(buffer));
    long code;
    enum error err = NOERR;

    if (res_len == -1) {
        err = ERR_API_COMMFAIL;
        goto end;
    }

    code = api_res_code(buffer);
    if (code == -1) {
        err = ERR_API_RESP_INVALID;
        goto end;
    }

    res->code = (uint16_t)code;

end:
    pthread_mutex_unlock(&api_work_mx);
    return err;
}

enum error api_cmd_uptime(struct api_result *res)
{
    /* If mutex is not already locked from the keepalive thread */
    /* Or we could use a recursive mutex? */
    if (!api_ka_now)
        pthread_mutex_lock(&api_work_mx);
    char buffer[API_BUFSIZE];
    size_t res_len = api_send(buffer, snprintf(buffer, sizeof(buffer),
                "UPTIME s=%s", api_session), sizeof(buffer));
    long code;
    enum error err = NOERR;

    if (res_len == -1) {
        err = ERR_API_COMMFAIL;
        goto end;
    }

    code = api_res_code(buffer);
    if (code == -1) {
        err = ERR_API_RESP_INVALID;
        goto end;
    }

    if (code == 208) {
        char *ls;
        size_t ll;
        bool glf = api_get_line(buffer, 2, &ls, &ll);

        assert(glf);
        (void)glf;
        res->uptime.ms = strtol(ls, NULL, 10);
    }

    res->code = (uint16_t)code;

end:
    if (!api_ka_now)
        pthread_mutex_unlock(&api_work_mx);
    return err;
}

enum error api_cmd_mylistadd(int64_t size, const uint8_t *hash,
        enum mylist_state ml_state, bool watched, struct api_result *res)
{
    char buffer[API_BUFSIZE];
    char hash_str[ED2K_HASH_SIZE * 2 + 1];
    size_t res_len;
    enum error err = NOERR;
    long code;
    pthread_mutex_lock(&api_work_mx);

    util_byte2hex(hash, ED2K_HASH_SIZE, false, hash_str);
    /* Wiki says file size is 4 bytes, but no way that's true lol */
    res_len = api_send(buffer, snprintf(buffer, sizeof(buffer),
                "MYLISTADD s=%s&size=%ld&ed2k=%s&state=%hu&viewed=%d",
                api_session, size, hash_str, ml_state, watched),
            sizeof(buffer));

    if (res_len == -1) {
        err = ERR_API_COMMFAIL;
        goto end;
    }

    code = api_res_code(buffer);
    if (code == -1) {
        err = ERR_API_RESP_INVALID;
        goto end;
    }

    if (code == 210) {
        char *ls, id_str[12];
        size_t ll;
        bool glr = api_get_line(buffer, 2, &ls, &ll);

        assert(glr);
        (void)glr;
        assert(sizeof(id_str) > ll);
        memcpy(id_str, ls, ll);
        id_str[ll] = '\0';
        res->mylistadd.new_id = strtoll(id_str, NULL, 10);
        /* Wiki says these id's are 4 bytes, which is untrue...
         * that page may be a little out of date (or they just
         * expect us to use common sense lmao */
    } else if (code == 310) {
        /* {int4 lid}|{int4 fid}|{int4 eid}|{int4 aid}|{int4 gid}|
         * {int4 date}|{int2 state}|{int4 viewdate}|{str storage}|
         * {str source}|{str other}|{int2 filestate} */
        char *ls;
        size_t ll;
        struct api_mylistadd_result *mr = &res->mylistadd;
        bool glr = api_get_line(buffer, 2, &ls, &ll);
        assert(glr);
        assert(ll < API_BUFSIZE - 1);
        (void)glr;

        ls[ll] = '\0';
        void *fptrs[] = {
            &mr->lid, &mr->fid, &mr->eid, &mr->aid, &mr->gid, &mr->date,
            &mr->state, &mr->viewdate, &mr->storage, &mr->source,
            &mr->other, &mr->filestate,
        };
        for (int idx = 1; idx <= 12; idx++) {
            char *fs, *endptr;
            size_t fl;
            bool pr;
            uint64_t val;
            size_t cpy_size = sizeof(mr->lid);

            if (idx == 7)
                cpy_size = sizeof(mr->state);
            if (idx == 12)
                cpy_size = sizeof(mr->filestate);

            pr = api_get_field(ls, idx, &fs, &fl);
            assert(pr);
            (void)pr;
            
            if (idx == 9 || idx == 10 || idx == 11) { /* string fields */
                if (fl == 0)
                    *(char**)fptrs[idx-1] = NULL;
                else
                    *(char**)fptrs[idx-1] = strndup(fs, fl);
                continue;
            }

            val = strtoull(fs, &endptr, 10);
            assert(!(val == 0 && fs == endptr));
            memcpy(fptrs[idx-1], &val, cpy_size);
        }
    }

    res->code = (uint16_t)code;

end:
    pthread_mutex_unlock(&api_work_mx);
    return err;
}

#pragma GCC diagnostic pop