mgr.c

/*
 * mgr.c
 */

#define LIBNFSNAPI_BUILDING_LIB

#include <curl/curl.h>
#include <limits.h>
#include <openssl/sha.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <time.h>
#include "config.h"
#include "error.h"
#include "mgr.h"


static size_t libnfsnapi_mgr_write_header(void *buffer, size_t size, size_t nmemb, void *userp);
static size_t libnfsnapi_mgr_write_data(void *buffer, size_t size, size_t nmemb, void *userp);


libnfsnapi_mgr_t *libnfsnapi_mgr_create(const char *login, const char *api_key,
                                        int *error_out)
{
        libnfsnapi_mgr_t *mgr;
        struct timeval tp;
        int err = 0;

        mgr = (libnfsnapi_mgr_t *) malloc(sizeof(libnfsnapi_mgr_t));
        mgr->error = 0;
        if (!mgr) {
                if (error_out)
                        *error_out = LIBNFSNAPI_ERROR_MEMORY;
                return NULL;
        }

        mgr->login = strdup(login);
        if (!mgr->login) {
                if (error_out)
                        *error_out = LIBNFSNAPI_ERROR_MEMORY;
                free(mgr);
                return NULL;
        }
        mgr->api_key = strdup(api_key);
        if (!mgr->api_key) {
                if (error_out)
                        *error_out = LIBNFSNAPI_ERROR_MEMORY;
                free(mgr->login);
                free(mgr);
                return NULL;
        }

        mgr->nudge = 0;
        mgr->buf = NULL;
        mgr->buf_read = mgr->buf_sz = 0;
        mgr->headers = NULL;


        /* Initialise libcurl */
        mgr->curl = NULL;
        if (curl_global_init(CURL_GLOBAL_SSL) != 0) {
                libnfsnapi_mgr_destroy(mgr);
                if (error_out)
                        *error_out = LIBNFSNAPI_ERROR_LIBCURL;
                return NULL;
        }
        mgr->curl = curl_easy_init();
        if (!mgr->curl) {
                curl_global_cleanup();
                libnfsnapi_mgr_destroy(mgr);
                if (error_out)
                        *error_out = LIBNFSNAPI_ERROR_LIBCURL;
                return NULL;
        }
        /* err += curl_easy_setopt(mgr->curl, CURLOPT_VERBOSE, 1); */
        err += curl_easy_setopt(mgr->curl, CURLOPT_HEADER, 0);
        err += curl_easy_setopt(mgr->curl, CURLOPT_NOPROGRESS, 1);

        err += curl_easy_setopt(mgr->curl, CURLOPT_USERAGENT,
                        "libNFSNapi/" PACKAGE_VERSION);

        /* XXX: SSL certs aren't verified yet */
        err += curl_easy_setopt(mgr->curl, CURLOPT_SSL_VERIFYPEER, 0);
        err += curl_easy_setopt(mgr->curl, CURLOPT_SSL_VERIFYHOST, 0);

        err += curl_easy_setopt(mgr->curl, CURLOPT_WRITEFUNCTION,
                         libnfsnapi_mgr_write_data);
        err += curl_easy_setopt(mgr->curl, CURLOPT_WRITEDATA, mgr);
        err += curl_easy_setopt(mgr->curl, CURLOPT_HEADERFUNCTION,
                         libnfsnapi_mgr_write_header);
        err += curl_easy_setopt(mgr->curl, CURLOPT_HEADERDATA, mgr);

        if (err != 0) {
                /* XXX: should we be more explicit, or remember which error? */
                libnfsnapi_mgr_destroy(mgr);
                if (error_out)
                        *error_out = LIBNFSNAPI_ERROR_LIBCURL;
                return NULL;
        }

        /* Seed PRNG */
        gettimeofday(&tp, NULL);
        srandom(tp.tv_usec);

        /* Anything else to initialise? */

        return mgr;
}

void libnfsnapi_mgr_destroy(libnfsnapi_mgr_t *mgr)
{
        free(mgr->login);
        free(mgr->api_key);
        if (mgr->buf)
                free(mgr->buf);
        if (mgr->headers)
                curl_slist_free_all(mgr->headers);

        if (mgr->curl) {
                curl_easy_cleanup(mgr->curl);
                curl_global_cleanup();
        }

        free(mgr);
}

int libnfsnapi_mgr_error(libnfsnapi_mgr_t *mgr)
{
        return mgr->error;
}

const char *libnfsnapi_mgr_strerror(libnfsnapi_mgr_t *mgr)
{
        return libnfsnapi_strerror(mgr->error);
}

void libnfsnapi_mgr_set_timenudge(libnfsnapi_mgr_t *mgr, int nudge)
{
        mgr->nudge = nudge;
}

/* salt_dest should point to a buffer of at least 17 bytes so the
 * output salt can be NUL terminated.
 */
static void libnfsnapi_mgr_gensalt(char *salt_dest)
{
        static const char charset[62] =
                "abcdefghijklmnopqrstuvwxyz"
                "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                "0123456789";
        int i;

        for (i = 0; i < 16; ++i)
                salt_dest[i] = charset[random() % sizeof(charset)];
        salt_dest[17] = '\0';
}

/* sha1_dest should point to a buffer of at least 41 bytes so the
 * output hash can be NUL terminated.
 */
static void libnfsnapi_mgr_sha1(const char *input, char *sha1_dest)
{
        unsigned char sha1_raw[20];
        int i;
        size_t len = input ? strlen(input) : 0;

        /* Call OpenSSL's SHA1 function */
        SHA1((const unsigned char *) input, len, sha1_raw);

        /* TODO: optimise this */
        for (i = 0; i < 20; ++i)
                sprintf(&sha1_dest[i * 2], "%02x", sha1_raw[i]);
        sha1_dest[40] = '\0';
}

/* Generate the X-NFSN-Authentication HTTP header. */
static char *libnfsnapi_mgr_genauthheader(libnfsnapi_mgr_t *mgr,
                                  const char *request_uri, const char *body)
{
        time_t timestamp;
        char salt[17], hash[41], *check_str, *auth_str;

        timestamp = time(NULL);
        timestamp += mgr->nudge;
        libnfsnapi_mgr_gensalt(salt);
        /* printf("salt => \"%s\".\n", salt); */

        libnfsnapi_mgr_sha1(body, hash);
        /* printf("body_hash => \"%s\".\n", hash); */

        asprintf(&check_str, "%s;%lu;%s;%s;%s;%s",
                mgr->login, (unsigned long) timestamp, salt,
                mgr->api_key, request_uri, hash);
        if (!check_str)
                return NULL;
        libnfsnapi_mgr_sha1(check_str, hash);
        free(check_str);

        asprintf(&auth_str, "X-NFSN-Authentication: %s;%lu;%s;%s",
                mgr->login, (unsigned long) timestamp, salt, hash);

        return auth_str;
}

/* libcurl header callback; called once per HTTP header */
static size_t libnfsnapi_mgr_write_header(void *buffer, size_t size, size_t nmemb, void *userp)
{
        libnfsnapi_mgr_t *mgr = (libnfsnapi_mgr_t *) userp;
        size_t num_bytes = size * nmemb;

        char *hdr = (char *) malloc(num_bytes);
        if (!hdr) {
                /* XXX: this doesn't get propogated back! */
                mgr->error = LIBNFSNAPI_ERROR_MEMORY;
                return 0;
        }
        memcpy(hdr, buffer, num_bytes);
        hdr[num_bytes] = '\0';

        /* Trim CRs and LFs */
        while ((hdr[0] != '\0') && strchr("\r\n", hdr[strlen(hdr) - 1]))
                hdr[strlen(hdr) - 1] = '\0';

        mgr->headers = curl_slist_append(mgr->headers, hdr);

        if (strncmp(hdr, "HTTP/", 5) == 0)
                printf("HTTP header (%d bytes): %s\n", num_bytes, hdr);
        free(hdr);

        return num_bytes;
}
/* libcurl write callback */
static size_t libnfsnapi_mgr_write_data(void *buffer, size_t size, size_t nmemb, void *userp)
{
        libnfsnapi_mgr_t *mgr = (libnfsnapi_mgr_t *) userp;
        char *nbuf;
        size_t num_bytes = size * nmemb, new_sz;

        /* If there's not enough room, enlarge the buffer.
         * This will also allocate the buffer on the first read.
         * Throughout reading, we keep at least one byte free, to make
         * processing the buffer easier later on.
         */
        if ((mgr->buf_sz - mgr->buf_read) <= num_bytes) {
                new_sz = (mgr->buf_sz + 1) * 2;
                while ((new_sz - mgr->buf_read - 1) < num_bytes)
                        new_sz *= 2;
                nbuf = (char *) malloc(new_sz);
                if (!nbuf)
                        return 0;       /* Damn! */
                if (mgr->buf) {
                        memcpy(nbuf, mgr->buf, mgr->buf_read);
                        free(mgr->buf);
                }
                mgr->buf = nbuf;
                mgr->buf_sz = new_sz;
        }

        memcpy(&mgr->buf[mgr->buf_read], buffer, num_bytes);
        mgr->buf_read += num_bytes;

        return num_bytes;
}

/* Returns non-zero on error, setting mgr->error to the same value. */
int libnfsnapi_mgr_do(libnfsnapi_mgr_t *mgr, int method,
                        const char *request_uri, const char *data)
{
        struct curl_slist *headers = NULL;
        char *full_uri, *auth_header;
        int err = 0;
        size_t i;

        /* Reset incoming buffers */
        mgr->buf_read = 0;
        if (mgr->headers) {
                curl_slist_free_all(mgr->headers);
                mgr->headers = NULL;
        }

        asprintf(&full_uri, "https://api.nearlyfreespeech.net%s", request_uri);
        if (!full_uri) {
                mgr->error = LIBNFSNAPI_ERROR_MEMORY;
                return mgr->error;
        }
        err += curl_easy_setopt(mgr->curl, CURLOPT_URL, full_uri);

        switch (method) {
                case LIBNFSNAPI_MGR_HTTP_GET:
                        err += curl_easy_setopt(mgr->curl, CURLOPT_HTTPGET, 1);
                        break;
                case LIBNFSNAPI_MGR_HTTP_PUT:
                        mgr->error = LIBNFSNAPI_ERROR_NOTIMPLEMENTED;
                        goto cleanup;                   /* XXX: NYI */
                        err += curl_easy_setopt(mgr->curl, CURLOPT_UPLOAD, 1);
                        break;
                case LIBNFSNAPI_MGR_HTTP_POST:
                        err += curl_easy_setopt(mgr->curl, CURLOPT_POST, 1);
                        err += curl_easy_setopt(mgr->curl, CURLOPT_POSTFIELDS,
                                                data);
                        break;
        }

        if (err != 0) {
                mgr->error = LIBNFSNAPI_ERROR_LIBCURL;
                goto cleanup;
        }

        /* Generate custom HTTP headers */
        auth_header = libnfsnapi_mgr_genauthheader(mgr, request_uri, data);
        if (!auth_header) {
                mgr->error = LIBNFSNAPI_ERROR_MEMORY;
                goto cleanup;
        }
        headers = curl_slist_append(headers, auth_header);
        free(auth_header);
        if (!headers) {
                mgr->error = LIBNFSNAPI_ERROR_MEMORY;
                goto cleanup;
        }
        if (curl_easy_setopt(mgr->curl, CURLOPT_HTTPHEADER, headers)) {
                mgr->error = LIBNFSNAPI_ERROR_LIBCURL;
                goto cleanup;
        }

        /* Perform! */
        if ((err = curl_easy_perform(mgr->curl)) != 0) {
                /* Uh, oh! */
                /* TODO: make this error more precise */
                switch (err) {
                        case CURLE_COULDNT_RESOLVE_PROXY:
                        case CURLE_COULDNT_RESOLVE_HOST:
                        case CURLE_COULDNT_CONNECT:
                                mgr->error = LIBNFSNAPI_ERROR_NETWORK;
                                break;
                        default:
                                printf("--> libcurl error is %d\n", err);
                                mgr->error = LIBNFSNAPI_ERROR_LIBCURL;
                }
                goto cleanup;
        }

        if (!mgr->headers) {
                mgr->error = LIBNFSNAPI_ERROR_PROTOCOL;
                goto cleanup;
        }

        mgr->buf[mgr->buf_read] = '\0';

        /* TODO: do something useful! */
        printf("Response below: (%d bytes)\n", mgr->buf_read);
        printf("------------------------------------------\n");
        for (i = 0; i < mgr->buf_read; ++i)
                putchar(mgr->buf[i]);
        if (mgr->buf[i-1] != '\n')
                printf("[no EOL]\n");
        printf("------------------------------------------\n");

cleanup:
        curl_easy_setopt(mgr->curl, CURLOPT_URL, NULL);
        curl_easy_setopt(mgr->curl, CURLOPT_HTTPHEADER, NULL);

        if (headers)
                curl_slist_free_all(headers);
        free(full_uri);
        return mgr->error;
}

long libnfsnapi_mgr_result_long(libnfsnapi_mgr_t *mgr)
{
        return strtol(mgr->buf, NULL, 10);
}

float libnfsnapi_mgr_result_float(libnfsnapi_mgr_t *mgr)
{
        return strtof(mgr->buf, NULL);
}

char *libnfsnapi_mgr_result_string(libnfsnapi_mgr_t *mgr)
{
        return strdup(mgr->buf);
}

---