/* This driver implementation is derived from Erlang crypto_drv.c code.
 * Driver adds missed crypto functions (MD4, DES in ECB mode).
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "erl_driver.h"

#define OPENSSL_THREAD_DEFINES
#include <openssl/opensslconf.h>
#ifndef OPENSSL_THREADS
#ifdef __GNUC__
#warning No thread support by openssl. Driver will use coarse grain locking.
#endif
#endif

#include <openssl/des.h>
#include <openssl/md4.h>

#ifdef DEBUG
#define ASSERT(e) \
    ((void) ((e) ? 1 : (fprintf(stderr,"Assert '%s' failed at %s:%d\n",\
        #e, __FILE__, __LINE__), abort(), 0)))
#else
#define ASSERT(e) ((void) 1)
#endif

#ifdef __GNUC__
#define INLINE __inline__
#else
#define INLINE
#endif

#define get_int32(s) ((((unsigned char*) (s))[0] << 24) |\
                      (((unsigned char*) (s))[1] << 16) |\
                      (((unsigned char*) (s))[2] << 8)  |\
                      (((unsigned char*) (s))[3]))

#define put_int32(s, i)\
{ (s)[0] = (char)(((i) >> 24) & 0xff);\
  (s)[1] = (char)(((i) >> 16) & 0xff);\
  (s)[2] = (char)(((i) >> 8) & 0xff);\
  (s)[3] = (char)((i) & 0xff);\
}

/* Driver interface declarations */
static int init(void);
static void finish(void);
static ErlDrvData start(ErlDrvPort port, char *command);
static void stop(ErlDrvData drv_data);
static int control(ErlDrvData drv_data, unsigned int command, char *buf,
        int len, char **rbuf, int rlen);

/* OpenSSL callbacks */
#ifdef OPENSSL_THREADS
static void locking_function(int mode, int n, const char *file, int line);
static unsigned long id_function(void);
static struct CRYPTO_dynlock_value* dyn_create_function(const char *file, int line);
static void dyn_lock_function(int mode, struct CRYPTO_dynlock_value* ptr,
        const char *file, int line);
static void dyn_destroy_function(struct CRYPTO_dynlock_value *ptr,
        const char *file, int line);
#endif /* OPENSSL_THREADS */

static ErlDrvEntry crypto_driver_entry = {
    init,
    start,
    stop,
    NULL, /* output */
    NULL, /* ready_input */
    NULL, /* ready_output */
    "netspire_crypto_drv",
    finish,
    NULL, /* handle */
    control,
    NULL, /* timeout */
    NULL, /* outputv */

    NULL, /* ready_async */
    NULL, /* flush */
    NULL, /* call */
    NULL, /* event */
    ERL_DRV_EXTENDED_MARKER,
    ERL_DRV_EXTENDED_MAJOR_VERSION,
    ERL_DRV_EXTENDED_MINOR_VERSION,
#ifdef OPENSSL_THREADS
    ERL_DRV_FLAG_USE_PORT_LOCKING,
#else
    0,
#endif
    NULL, /* handle2 */
    NULL /* process_exit */
};

/* Keep the following definitions in alignment with the FUNC_LIST
 * in netspire_crypto.erl
 */
#define DRV_INFO                0
#define DRV_MD4                 1
#define DRV_MD4_INIT            2
#define DRV_MD4_UPDATE          3
#define DRV_MD4_FINAL           4
#define DRV_ECB_DES_ENCRYPT     5
#define DRV_ECB_DES_DECRYPT     6
#define DRV_DES_SET_PARITY      7
#define DRV_INFO_LIB            8

#define NUM_CRYPTO_FUNCS        9

#define MD4_CTX_LEN             (sizeof(MD4_CTX))
#define MD4_LEN                 16

/* INITIALIZATION AFTER LOADING */

/*
 * This is the init function called after this driver has been loaded.
 * It must *not* be declared static.  Must return the address to
 * the driver entry.
 */
DRIVER_INIT(crypto_drv) {
    return &crypto_driver_entry;
}

/* Static locks used by OpenSSL. */
static ErlDrvRWLock** lock_vec = NULL;

/* DRIVER INTERFACE */
static int init(void) {
    ErlDrvSysInfo sys_info;
    int i;

    CRYPTO_set_mem_functions(driver_alloc, driver_realloc, driver_free);

#ifdef OPENSSL_THREADS
    driver_system_info(&sys_info, sizeof (sys_info));

    if (sys_info.scheduler_threads > 1) {
        lock_vec = driver_alloc(CRYPTO_num_locks() * sizeof (*lock_vec));
        if (lock_vec == NULL) return -1;
        memset(lock_vec, 0, CRYPTO_num_locks() * sizeof (*lock_vec));

        for (i = CRYPTO_num_locks() - 1; i >= 0; --i) {
            lock_vec[i] = erl_drv_rwlock_create("netspire_crypto_drv_stat");
            if (lock_vec[i] == NULL) return -1;
        }
        CRYPTO_set_locking_callback(locking_function);
        CRYPTO_set_id_callback(id_function);
        CRYPTO_set_dynlock_create_callback(dyn_create_function);
        CRYPTO_set_dynlock_lock_callback(dyn_lock_function);
        CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function);
    }
    /* else no need for locks */
#endif /* OPENSSL_THREADS */
    return 0;
}

static void finish(void) {
    /* Moved here from control() as it's not thread safe */
    CRYPTO_cleanup_all_ex_data();

    if (lock_vec != NULL) {
        int i;
        for (i = CRYPTO_num_locks() - 1; i >= 0; --i) {
            if (lock_vec[i] != NULL) {
                erl_drv_rwlock_destroy(lock_vec[i]);
            }
        }
        driver_free(lock_vec);
    }
}

static ErlDrvData start(ErlDrvPort port, char *command) {
    set_port_control_flags(port, PORT_CONTROL_FLAG_BINARY);
    return 0; /* not used */
}

static void stop(ErlDrvData drv_data) {
    return;
}

void des_set_parity(char *input, char *output) {
    int i;
    unsigned char next = 0;
    unsigned char current = 0;

    for (i = 0; i < 7; i++) {
        current = input[i];
        output[i] = (current >> i) | next | 1;
        current = input[i];
        next = (current << (7 - i));
    }
    output[i] = next | 1;
}

/* Since we are operating in binary mode, the return value from control
 * is irrelevant, as long as it is not negative
 */
static int control(ErlDrvData drv_data, unsigned int command, char *buf,
        int len, char **rbuf, int rlen) {
    ErlDrvBinary *bin;
    MD4_CTX md4_ctx;
    char *p;
    const unsigned char *des_dbuf;
    const_DES_cblock *des_key;
    DES_key_schedule schedule;
    int i, dlen;

    switch (command) {
        case DRV_INFO:
            *rbuf = (char*) (bin = driver_alloc_binary(NUM_CRYPTO_FUNCS));
            for (i = 0; i < NUM_CRYPTO_FUNCS; i++) {
                bin->orig_bytes[i] = i + 1;
            }
            return NUM_CRYPTO_FUNCS;

        case DRV_MD4:
            *rbuf = (char*) (bin = driver_alloc_binary(MD4_LEN));
            MD4((unsigned char *)buf, len, (unsigned char *)bin->orig_bytes);
            return MD4_LEN;
            break;

        case DRV_MD4_INIT:
            *rbuf = (char*) (bin = driver_alloc_binary(MD4_CTX_LEN));
            MD4_Init((MD4_CTX *) bin->orig_bytes);
            return MD4_CTX_LEN;
            break;

        case DRV_MD4_UPDATE:
            if (len < MD4_CTX_LEN)
                return -1;
            *rbuf = (char*) (bin = driver_alloc_binary(MD4_CTX_LEN));
            memcpy(bin->orig_bytes, buf, MD4_CTX_LEN);
            MD4_Update((MD4_CTX *) bin->orig_bytes, buf + MD4_CTX_LEN, len - MD4_CTX_LEN);
            return MD4_CTX_LEN;
            break;

        case DRV_MD4_FINAL:
            if (len != MD4_CTX_LEN)
                return -1;
            memcpy(&md4_ctx, buf, MD4_CTX_LEN); /* XXX Use buf only? */
            *rbuf = (char *) (bin = driver_alloc_binary(MD4_LEN));
            MD4_Final((unsigned char *)bin->orig_bytes, &md4_ctx);
            return MD4_LEN;
            break;

        case DRV_DES_SET_PARITY:
            /* buf = 7 octets data */
            if (len != 7)
                return -1;
            *rbuf = (char *) (bin = driver_alloc_binary(8));
            des_set_parity(buf, bin->orig_bytes);
            return 8;
            break;

        case DRV_ECB_DES_ENCRYPT:
        case DRV_ECB_DES_DECRYPT:
            /* buf = key[8] data */
            dlen = len - 8;
            if (dlen < 0)
                return -1;
            if (dlen % 8 != 0)
                return -1;
            des_key = (const_DES_cblock*) buf;
            des_dbuf = (unsigned char *)buf + 8;
            *rbuf = (char *) (bin = driver_alloc_binary(dlen));
            DES_set_key(des_key, &schedule);
            DES_ecb_encrypt((const_DES_cblock*) des_dbuf,
                    (DES_cblock*) bin->orig_bytes, &schedule,
                    (command == DRV_ECB_DES_ENCRYPT));
            return dlen;
            break;

        case DRV_INFO_LIB:
            /* <<DrvVer:8, NameSize:8, Name:NameSize/binary, VerNum:32, VerStr/binary>> */
        {
            static const char libname[] = "OpenSSL";
            unsigned name_sz = strlen(libname);
            const char* ver = SSLeay_version(SSLEAY_VERSION);
            unsigned ver_sz = strlen(ver);
            *rbuf = (char*) (bin = driver_alloc_binary(1 + 1 + name_sz + 4 + ver_sz));
            p = bin->orig_bytes;
            *p++ = 0; /* "driver version" for future use */
            *p++ = name_sz;
            memcpy(p, libname, name_sz);
            p += name_sz;
            put_int32(p, SSLeay()); /* OPENSSL_VERSION_NUMBER */
            p += 4;
            memcpy(p, ver, ver_sz);
        }
            return bin->orig_size;

        default:
            break;
    }
    return -1;
}

#ifdef OPENSSL_THREADS

static INLINE void locking(int mode, ErlDrvRWLock* lock) {
    switch (mode) {
        case CRYPTO_LOCK | CRYPTO_READ :
                    erl_drv_rwlock_rlock(lock);
            break;
        case CRYPTO_LOCK | CRYPTO_WRITE :
                    erl_drv_rwlock_rwlock(lock);
            break;
        case CRYPTO_UNLOCK | CRYPTO_READ :
                    erl_drv_rwlock_runlock(lock);
            break;
        case CRYPTO_UNLOCK | CRYPTO_WRITE :
                    erl_drv_rwlock_rwunlock(lock);
            break;
        default:
            ASSERT(!"Invalid lock mode");
    }
}

/* Callback from openssl for static locking
 */
static void locking_function(int mode, int n, const char *file, int line) {
    ASSERT(n >= 0 && n < CRYPTO_num_locks());
    locking(mode, lock_vec[n]);
}

/* Callback from openssl for thread id
 */
static unsigned long id_function(void) {
    return (unsigned long) erl_drv_thread_self();
}

/* Callbacks for dynamic locking, not used by current OpenSSL version (0.9.8)
 */
static struct CRYPTO_dynlock_value* dyn_create_function(const char *file, int line) {
    return (struct CRYPTO_dynlock_value*) erl_drv_rwlock_create("netspire_crypto_drv_dyn");
}

static void dyn_lock_function(int mode, struct CRYPTO_dynlock_value* ptr, const char *file, int line) {
    locking(mode, (ErlDrvRWLock*) ptr);
}

static void dyn_destroy_function(struct CRYPTO_dynlock_value *ptr, const char *file, int line) {
    return erl_drv_rwlock_destroy((ErlDrvRWLock*) ptr);
}

#endif /* OPENSSL_THREADS */