#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include "libssh2_priv.h"

static int
ssh_host_parse_hostnames (LIBSSH2_SESSION * session,
                          LIBSSH2_KNOWNHOSTS * s,
                          char *line,
                          char *end
    );

static int
ssh_host_parse_key (LIBSSH2_SESSION * session,
                    LIBSSH2_KNOWNHOSTS * s,
                    char *line,
                    int is_base64_encoded
    );

/* Returns zero if successful, > zero for malformed data, < 0 not supported. */
LIBSSH2_API int
libssh2_new_host_entry(LIBSSH2_SESSION * session,
                       LIBSSH2_KNOWNHOSTS ** s,
                       char *line)
{
    char *tmp = NULL;
    LIBSSH2_KNOWNHOSTS *t = NULL;
    int i;

    if (line == NULL || *line == 0)
        return 1;
    if (s == NULL)
        return 2;

    tmp = strchr (line, ' ');
    if (tmp == NULL)
        return 3;


    t = (LIBSSH2_KNOWNHOSTS *)
        LIBSSH2_ALLOC(session, sizeof(LIBSSH2_KNOWNHOSTS));

    t->hostname_line = NULL;
    t->hostnames = NULL;
    t->hostnames_size = t->bits = t->exponent = -1;
    t->modulus = NULL;
    t->modulus_length = -1;
    t->ssh_version = -1;
    t->md5 = NULL;

    i = ssh_host_parse_hostnames (session, t, line, tmp);
    if (i != 0) {
        libssh2_free_host_entry (session, t);
        return ((i > 0) ? 4 : -1);
    }

    line = tmp + 1;
    tmp = strchr (line, ' ');
    if (tmp != NULL)
        tmp = strchr (tmp + 1, ' ');

    i = ssh_host_parse_key (session, t, line, tmp == NULL ? 1 : 0);
    if (i != 0) {
        libssh2_free_host_entry (session, t);
        return ((i > 0) ? 5 : -2);
    }

    *s = t;
    return 0;
}

static int
ssh_host_parse_hostnames(LIBSSH2_SESSION * session,
                         LIBSSH2_KNOWNHOSTS * s,
                         char *line,
                         char *end)
{
    char *start;
    char *comma = NULL;
    int i;

    /* TODO: we don't handle the hashed name format because the hashing
     * mechanism isnt defined (at least based on the man page)
     */
    if (*line == '|')
        return -1;
    if (line == end || *line == ' ')
        return 1;

    s->hostname_line = (char *) LIBSSH2_ALLOC (session, (end - line) + 1);
    strncpy (s->hostname_line, line, (end - line) + 1);
    start = end = s->hostname_line + (end - line);
    *end = 0;

    s->hostnames_size = 1;
    comma = s->hostname_line;
    while ((comma = strchr (comma, ',')) != NULL) {
        comma++;
        if (*comma == ',' || *comma == 0) {
            LIBSSH2_FREE (session, s->hostname_line);
            s->hostname_line = NULL;
            return 2;
        }
        s->hostnames_size++;
    }
    s->hostnames = (char **) LIBSSH2_ALLOC
        (session, sizeof (char *) * s->hostnames_size);

    start = comma = s->hostname_line;
    i = 0;
    while ((comma = strchr (comma, ',')) != NULL) {
        *comma = 0;
        s->hostnames[i] = start;

        comma++;
        start = comma;
        i++;
    }
    s->hostnames[i] = start;

    return 0;
}

/** Returns the number of bytes read or -1. */
static int
ssh_proto_str_read(LIBSSH2_SESSION * session,
                   char *line,
                   char **val,
                   char *end
    )
{
    unsigned int len;

    if (line + 4 > end)
        return -1;
    len = (line[0] << 24) + (line[1] << 16) + (line[2] << 8) + line[3];
    if (line + 4 + len > end)
        return -1;

    *val = LIBSSH2_ALLOC (session, len);
    memcpy (*val, line + 4, len);
    return len + 4;
}

static int
ssh_host_parse_key(LIBSSH2_SESSION * session,
                   LIBSSH2_KNOWNHOSTS * s,
                   char *line,
                   int is_base64_encoded)
{
    int i, j;
    char *tmp, *tmp2;
    /* workaround for the MD5 stuff */
    libssh2_md5_ctx ctx;

    /* the bits, exponent, modulus format */
    if (is_base64_encoded == 0) {
        s->ssh_version = 1;
        s->key_type = 0;
        if (!isdigit (*line))
            return -1;
        if (sscanf (line, "%hu %hu ", &(s->bits), &(s->exponent)) != 2)
            return -2;
        /* TODO:
         * There's probably an acceptable range...
         */
        if (s->bits <= 0 || s->exponent <= 0)
            return 1;

        line = strchr (line, ' ');
        if (line == NULL)
            return -3;
        line++;
        line = strchr (line, ' ');
        if (line == NULL)
            return -4;
        line++;
        /* TODO:
         * figure out what format modulus is in since its not clear
         * from the man page
         */
        return -5;
    }
    else {
        s->ssh_version = 2;
        /* we only handle the rsa type */
        if (strstr (line, "ssh-rsa") != line)
            return -6;
        s->key_type = 0;
        line += 7;
        if (*line != ' ')
            return 2;
        line++;
        i = 0;
        while (*line) {
            if ((line[i] >= 0x30 && line[i] <= 0x39) ||
                (line[i] >= 0x41 && line[i] <= 0x5a) ||
                (line[i] >= 0x61 && line[i] <= 0x7a) ||
                (line[i] == '+') || (line[i] == '/') || (line[i] == '='))
                i++;
            else
                break;
        }
        if (i == 0)
            return 3;
        tmp = LIBSSH2_ALLOC (session, sizeof (char) * (i + 5));
        strncpy (tmp, line, i);
        /* this should hopefully avoid any issues with reading
         * past the array if its malformed */
        tmp[i] = tmp[i + 1] = tmp[i + 2] = tmp[i + 3] = tmp[i + 4] = 0;

        {
            /* TODO: rework the api interface instead of making a local
               instance */
            i = libssh2_base64_decode(session, &tmp2, (unsigned int *)&j,
                                      tmp, strlen(tmp));
            LIBSSH2_FREE(session, tmp);
            if (i != 0)
                return 4;

        }

        /* printf("Decode Size: %d\n", i); */
        /* free (tmp); */


#if LIBSSH2_MD5
        s->md5 = LIBSSH2_ALLOC (session, 16);

        libssh2_md5_init (&ctx);
        libssh2_md5_update (ctx, tmp2, j);
        libssh2_md5_final (ctx, s->md5);
#endif


        line = tmp2;
        i = ssh_proto_str_read (session, line, &tmp, tmp2 + j);
        if (i < 0) {
            LIBSSH2_FREE (session, tmp2);
            return 5;
        }
        /* TODO: verify that its ssh-rsa -- its the only one
         * supported
         */
        if (!(i == 11 && tmp[0] == 's' && tmp[1] == 's' &&
              tmp[2] == 'h' && tmp[3] == '-' && tmp[4] == 'r' &&
              tmp[5] == 's' && tmp[6] == 'a')) {
            free (tmp);
            free (tmp2);
            return 8;
        }

        LIBSSH2_FREE (session, tmp);
        line += i;
        i = ssh_proto_str_read (session, line, &tmp, tmp2 + j);
        if (i < 0) {
            LIBSSH2_FREE (session, tmp2);
            return 6;
        }
        /* TODO: verify that the exponent is valid */
        if (i == 5)
            s->exponent = (unsigned short) ((unsigned char) *tmp);
        else {
            LIBSSH2_FREE (session, tmp);
            LIBSSH2_FREE (session, tmp2);
            return 9;
        }

        LIBSSH2_FREE (session, tmp);
        line += i;
        i = ssh_proto_str_read (session, line, &tmp, tmp2 + j);
        if (i < 0) {
            LIBSSH2_FREE (session, tmp2);
            return 7;
        }

        /* TODO: the modulus may need to be converted to
         * big integer format
         */
        s->modulus_length = i - 4;
        s->modulus = tmp;

        s->bits = (s->modulus_length - 1) * 8;

        LIBSSH2_FREE (session, tmp2);
        return 0;
    }
}

LIBSSH2_API void
libssh2_free_host_entry(LIBSSH2_SESSION * session, LIBSSH2_KNOWNHOSTS * s)
{
    /* int i; */
    if (s == NULL)
        return;

    if (s->hostname_line != NULL) {
        LIBSSH2_FREE (session, s->hostname_line);
        s->hostname_line = NULL;
    }

    if (s->hostnames != NULL && s->hostnames_size > 0) {
        LIBSSH2_FREE (session, s->hostnames);
        s->hostnames = NULL;
    }
    s->hostnames_size = s->bits = s->exponent = -1;

    if (s->modulus != NULL) {
        LIBSSH2_FREE (session, s->modulus);
        s->modulus = NULL;
    }
    s->modulus_length = -1;
    s->ssh_version = -1;

    if (s->md5 != NULL) {
        LIBSSH2_FREE (session, s->md5);
        s->md5 = NULL;
    }

    LIBSSH2_FREE (session, s);
}

#ifdef SSH_HOSTNAME_TESTS
int
ssh_unit_tests (int argc, char **argv)
{
    char *l[] = {
        "closenet,...,192.0.2.53 1024 37 159...93 closenet.example.net",
        "cvs.example.net,192.0.2.10 ssh-rsa AAAA1234.....=",
        " cvs.example.net,192.0.2.10 ssh-rsa AAAA1234.....=",
        "",
        ",",
        "f, ",
        "cvs.example.net ssh-rsa AAAA1234.....=",
        "192.168.30.118 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAwWVqxKm2Biwilakq9Ex8/tzHVQjRrzEkwlrWTDneptodVgqAzXUFQSa6Oj9AwzdDPhKe71vTv7RhXYg0ZvB1a5dIkzgCdoF/mIuTb80LvK7f0NxCaAHWODuHbwlJeMmjHV0WFsjsdOf690fPqeinD/8jfBQB950M1K3Qesib9H75gsnawF06MzZ52nC1HHi8mG2tGy2PMyP+mJs7KN1v4T+nobZ10ePe1dMqYXMdro/PB0JQmuGL7bBR5GRDEkK6nFcp2HsvuzXSeWZJcmWDdo+1n0cNg2th5VEIxrrFG5iy0CA2AXVPMqkf3VrAXGXV66dJTGtBqZ5GoxJCxDgW6w==",
        "|1|JfKTdBh7rNbXkVAQCRp4OQoPfmI=|USECr3SWf1JUPsms5AqfD5QfxkM= ssh-rsaAAAA1234.....="
    };
    int s;
    int cases = sizeof (l) / sizeof (char *);

    if (argc == 2) {
        s = atoi (argv[1]);
        if (s >= 0 && s < cases) {
            LIBSSH2_KNOWNHOSTS *x = NULL;
            printf ("%d\n", s = new_ssh_host_entry (&x, l[s]));
            libssh2_free_host_entry (x);
            return s;
        }
    }
}
#endif

/** Returns 0 for a match, non-zero otherwise. */
LIBSSH2_API int
libssh2_host_entry_match(LIBSSH2_KNOWNHOSTS * x, char *host)
{
    /* TODO: Add pattern matching and/or DNS matching against
     * to entries found in x
     */
    int i;
    if (host == NULL || x == NULL)
        return -1;

    /* FIXME: this should use a case-insensitive compare as dns hostnames
     * are generally case insensitive anyways
     */
    for (i = 0; i < x->hostnames_size; i++)
        if (!strcmp (x->hostnames[i], host))
            return 0;

    return 1;
}