/*

 * This file is part of the SSH Library

 *

 * Copyright (c) 2018 by Anderson Toshiyuki Sasaki <ansasaki@redhat.com>

 *

 * The SSH Library 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 2.1 of the License, or (at your

 * option) any later version.

 *

 * The SSH Library 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 the SSH Library; see the file COPYING.  If not, write to

 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,

 * MA 02111-1307, USA.

 */

#include "config.h"

#define LIBSSH_STATIC

#include "torture.h"

#define DEBUG_BUFFER

#include "buffer.c"

#include <pthread.h>

#define NUM_THREADS 20

#define BUFFER_LIMIT (8 * 1024 * 1024)

static int run_on_threads(void *(*func)(void *))

{

    pthread_t threads[NUM_THREADS];

    int rc;

    int i;

    for (i = 0; i < NUM_THREADS; ++i) {

        rc = pthread_create(&threads[i], NULL, func, NULL);

        assert_int_equal(rc, 0);

    }

    for (i = 0; i < NUM_THREADS; ++i) {

        void *p = NULL;

        uint64_t *result = NULL;

        rc = pthread_join(threads[i], &p);

        assert_int_equal(rc, 0);

        result = (uint64_t *)p;

        assert_null(result);

    }

    return rc;

}

/*

 * Test if the continuously growing buffer size never exceeds 2 time its

 * real capacity

 */

static void *thread_growing_buffer(void *threadid)

{

    ssh_buffer buffer = NULL;

    int i;

    /* Unused */

    (void) threadid;

    /* Setup */

    buffer = ssh_buffer_new();

    if (buffer == NULL) {

        pthread_exit((void *)-1);

    }

    ssh_buffer_set_secure(buffer);

    for (i = 0; i < BUFFER_LIMIT; ++i) {

        ssh_buffer_add_data(buffer,"A",1);

        if (buffer->used >= 128) {

            if (ssh_buffer_get_len(buffer) * 2 < buffer->allocated) {

                assert_true(ssh_buffer_get_len(buffer) * 2 >= buffer->allocated);

            }

        }

    }

    /* Teardown */

    SSH_BUFFER_FREE(buffer);

    pthread_exit(NULL);

}

static void torture_growing_buffer(void **state)

{

    int rc;

    /* Unused */

    (void) state;

    rc = run_on_threads(thread_growing_buffer);

    assert_int_equal(rc, 0);

}

/*

 * Test if the continuously growing buffer size never exceeds 2 time its

 * real capacity, when we remove 1 byte after each call (sliding window)

 */

static void *thread_growing_buffer_shifting(void *threadid)

{

    ssh_buffer buffer;

    int i;

    unsigned char c;

    /* Unused */

    (void) threadid;

    /* Setup */

    buffer = ssh_buffer_new();

    if (buffer == NULL) {

        pthread_exit((void *)-1);

    }

    ssh_buffer_set_secure(buffer);

    for (i = 0; i < 1024; ++i) {

        ssh_buffer_add_data(buffer,"S",1);

    }

    for (i = 0; i < BUFFER_LIMIT; ++i) {

        ssh_buffer_get_u8(buffer,&c);

        ssh_buffer_add_data(buffer,"A",1);

        if (buffer->used >= 128) {

            if (ssh_buffer_get_len(buffer) * 4 < buffer->allocated) {

                assert_true(ssh_buffer_get_len(buffer) * 4 >= buffer->allocated);

                /* Teardown */

                SSH_BUFFER_FREE(buffer);

                pthread_exit(NULL);

            }

        }

    }

    /* Teardown */

    SSH_BUFFER_FREE(buffer);

    pthread_exit(NULL);

}

static void torture_growing_buffer_shifting(void **state)

{

    int rc;

    /* Unused */

    (void) state;

    rc = run_on_threads(thread_growing_buffer_shifting);

    assert_int_equal(rc, 0);

}

/*

 * Test the behavior of ssh_buffer_prepend_data

 */

static void *thread_buffer_prepend(void *threadid)

{

    ssh_buffer buffer = NULL;

    uint32_t v;

    /* Unused */

    (void) threadid;

    /* Setup */

    buffer = ssh_buffer_new();

    if (buffer == NULL) {

        pthread_exit((void *)-1);

    }

    ssh_buffer_set_secure(buffer);

    ssh_buffer_add_data(buffer, "abcdef", 6);

    ssh_buffer_prepend_data(buffer, "xyz", 3);

    assert_int_equal(ssh_buffer_get_len(buffer), 9);

    assert_memory_equal(ssh_buffer_get(buffer),  "xyzabcdef", 9);

    /* Now remove 4 bytes and see if we can replace them */

    ssh_buffer_get_u32(buffer, &v);

    assert_int_equal(ssh_buffer_get_len(buffer), 5);

    assert_memory_equal(ssh_buffer_get(buffer), "bcdef", 5);

    ssh_buffer_prepend_data(buffer, "aris", 4);

    assert_int_equal(ssh_buffer_get_len(buffer), 9);

    assert_memory_equal(ssh_buffer_get(buffer), "arisbcdef", 9);

    /* same thing but we add 5 bytes now */

    ssh_buffer_get_u32(buffer, &v);

    assert_int_equal(ssh_buffer_get_len(buffer), 5);

    assert_memory_equal(ssh_buffer_get(buffer), "bcdef", 5);

    ssh_buffer_prepend_data(buffer, "12345", 5);

    assert_int_equal(ssh_buffer_get_len(buffer), 10);

    assert_memory_equal(ssh_buffer_get(buffer), "12345bcdef", 10);

    /* Teardown */

    SSH_BUFFER_FREE(buffer);

    pthread_exit(NULL);

}

static void torture_buffer_prepend(void **state)

{

    int rc;

    /* Unused */

    (void) state;

    rc = run_on_threads(thread_buffer_prepend);

    assert_int_equal(rc, 0);

}

/*

 * Test the behavior of ssh_buffer_get_ssh_string with invalid data

 */

static void *thread_ssh_buffer_get_ssh_string(void *threadid)

{

    ssh_buffer buffer = NULL;

    size_t i, j, k, l;

    int rc;

    /* some values that can go wrong */

    uint32_t values[] = {

        0xffffffff, 0xfffffffe, 0xfffffffc, 0xffffff00,

        0x80000000, 0x80000004, 0x7fffffff};

    char data[128] = {0};

    /* Unused */

    (void)threadid;

    memset(data, 'X', sizeof(data));

    for (i = 0; i < ARRAY_SIZE(values); ++i) {

        for (j = 0; j < (int)sizeof(data); ++j) {

            for (k = 1; k < 5; ++k) {

                buffer = ssh_buffer_new();

                assert_non_null(buffer);

                for (l = 0; l < k; ++l) {

                    rc = ssh_buffer_add_u32(buffer, htonl(values[i]));

                    assert_int_equal(rc, 0);

                }

                rc = ssh_buffer_add_data(buffer,data,j);

                assert_int_equal(rc, 0);

                for (l = 0; l < k; ++l) {

                    ssh_string str = ssh_buffer_get_ssh_string(buffer);

                    assert_null(str);

                    SSH_STRING_FREE(str);

                }

                SSH_BUFFER_FREE(buffer);

            }

        }

    }

    pthread_exit(NULL);

}

static void torture_ssh_buffer_get_ssh_string(void **state){

    int rc;

    /* Unused */

    (void) state;

    rc = run_on_threads(thread_ssh_buffer_get_ssh_string);

    assert_int_equal(rc, 0);

}

static void *thread_ssh_buffer_add_format(void *threadid)

{

    ssh_buffer buffer = NULL;

    uint8_t b;

    uint16_t w;

    uint32_t d;

    uint64_t q;

    ssh_string s = NULL;

    int rc;

    size_t len;

    uint8_t verif[] = "\x42\x13\x37\x0b\xad\xc0\xde\x13\x24\x35\x46"

        "\xac\xbd\xce\xdf"

        "\x00\x00\x00\x06" "libssh"

        "\x00\x00\x00\x05" "rocks"

        "So much"

        "Fun!";

    /* Unused */

    (void) threadid;

    /* Setup */

    buffer = ssh_buffer_new();

    if (buffer == NULL) {

        pthread_exit((void *)-1);

    }

    ssh_buffer_set_secure(buffer);

    b = 0x42;

    w = 0x1337;

    d = 0xbadc0de;

    q = 0x13243546acbdcedf;

    s = ssh_string_from_char("libssh");

    rc = ssh_buffer_pack(buffer,

                         "bwdqSsPt",

                         b,

                         w,

                         d,

                         q,

                         s,

                         "rocks",

                         7,

                         "So much",

                         "Fun!");

    assert_int_equal(rc, SSH_OK);

    len = ssh_buffer_get_len(buffer);

    assert_int_equal(len, sizeof(verif) - 1);

    assert_memory_equal(ssh_buffer_get(buffer), verif, sizeof(verif) -1);

    SSH_STRING_FREE(s);

    /* Teardown */

    SSH_BUFFER_FREE(buffer);

    pthread_exit(NULL);

}

static void torture_ssh_buffer_add_format(void **state){

    int rc;

    /* Unused */

    (void) state;

    rc = run_on_threads(thread_ssh_buffer_add_format);

    assert_int_equal(rc, 0);

}

static void *thread_ssh_buffer_get_format(void *threadid) {

    ssh_buffer buffer;

    uint8_t b = 0;

    uint16_t w = 0;

    uint32_t d = 0;

    uint64_t q = 0;

    ssh_string s = NULL;

    char *s1 = NULL, *s2 = NULL;

    int rc;

    size_t len;

    uint8_t verif[] = "\x42\x13\x37\x0b\xad\xc0\xde\x13\x24\x35\x46"

        "\xac\xbd\xce\xdf"

        "\x00\x00\x00\x06" "libssh"

        "\x00\x00\x00\x05" "rocks"

        "So much";

    /* Unused */

    (void) threadid;

    /* Setup */

    buffer = ssh_buffer_new();

    if (buffer == NULL) {

        pthread_exit((void *)-1);

    }

    ssh_buffer_set_secure(buffer);

    rc = ssh_buffer_add_data(buffer, verif, sizeof(verif) - 1);

    assert_int_equal(rc, SSH_OK);

    rc = ssh_buffer_unpack(buffer,

                           "bwdqSsP",

                           &b,

                           &w,

                           &d,

                           &q,

                           &s,

                           &s1,

                           (size_t)7,

                           &s2;;

    assert_int_equal(rc, SSH_OK);

    assert_int_equal(b, 0x42);

    assert_int_equal(w, 0x1337);

    assert_true(d == 0xbadc0de);

    assert_true(q == 0x13243546acbdcedf);

    assert_non_null(s);

    assert_int_equal(ssh_string_len(s), 6);

    assert_memory_equal(ssh_string_data(s), "libssh", 6);

    assert_non_null(s1);

    assert_string_equal(s1, "rocks");

    assert_non_null(s2);

    assert_memory_equal(s2, "So much", 7);

    len = ssh_buffer_get_len(buffer);

    assert_int_equal(len, 0);

    SAFE_FREE(s);

    SAFE_FREE(s1);

    SAFE_FREE(s2);

    /* Teardown */

    SSH_BUFFER_FREE(buffer);

    pthread_exit(NULL);

}

static void torture_ssh_buffer_get_format(void **state)

{

    int rc;

    /* Unused */

    (void) state;

    rc = run_on_threads(thread_ssh_buffer_get_format);

    assert_int_equal(rc, 0);

}

static void *thread_ssh_buffer_get_format_error(void *threadid)

{

    ssh_buffer buffer = NULL;

    uint8_t b = 0;

    uint16_t w = 0;

    uint32_t d = 0;

    uint64_t q = 0;

    ssh_string s = NULL;

    char *s1 = NULL, *s2 = NULL;

    int rc;

    uint8_t verif[] = "\x42\x13\x37\x0b\xad\xc0\xde\x13\x24\x35\x46"

        "\xac\xbd\xce\xdf"

        "\x00\x00\x00\x06" "libssh"

        "\x00\x00\x00\x05" "rocks"

        "So much";

    /* Unused */

    (void) threadid;

    /* Setup */

    buffer = ssh_buffer_new();

    if (buffer == NULL) {

        pthread_exit((void *)-1);

    }

    ssh_buffer_set_secure(buffer);

    rc = ssh_buffer_add_data(buffer, verif, sizeof(verif) - 1);

    assert_int_equal(rc, SSH_OK);

    rc = ssh_buffer_unpack(buffer,

                           "bwdqSsPb",

                           &b,

                           &w,

                           &d,

                           &q,

                           &s,

                           &s1,

                           (size_t)7,

                           &s2,

                           &b);

    assert_int_equal(rc, SSH_ERROR);

    assert_null(s);

    assert_null(s1);

    assert_null(s2);

    /* Teardown */

    SSH_BUFFER_FREE(buffer);

    pthread_exit(NULL);

}

static void torture_ssh_buffer_get_format_error(void **state)

{

    int rc;

    /* Unused */

    (void) state;

    rc = run_on_threads(thread_ssh_buffer_get_format_error);

    assert_int_equal(rc, 0);

}

static void *thread_buffer_pack_badformat(void *threadid)

{

    ssh_buffer buffer = NULL;

    uint8_t b = 42;

    int rc;

    /* Unused */

    (void) threadid;

    /* Setup */

    buffer = ssh_buffer_new();

    if (buffer == NULL) {

        pthread_exit((void *)-1);

    }

    ssh_buffer_set_secure(buffer);

    /* first with missing format */

    rc = ssh_buffer_pack(buffer, "b", b, b);

    assert_int_equal(rc, SSH_ERROR);

    ssh_buffer_reinit(buffer);

    /* with additional format */

    rc = ssh_buffer_pack(buffer, "bb", b);

    /* check that we detect the missing parameter */

    assert_int_equal(rc, SSH_ERROR);

    /* unpack with missing format */

    ssh_buffer_reinit(buffer);

    rc = ssh_buffer_pack(buffer, "bb", 42, 43);

    assert_int_equal(rc, SSH_OK);

    rc = ssh_buffer_unpack(buffer, "b", &b, &b);

    assert_int_equal(rc, SSH_ERROR);

    /* not doing the test with additional format as

     * it could crash the process */

    /* Teardown */

    SSH_BUFFER_FREE(buffer);

    pthread_exit(NULL);

}

static void torture_buffer_pack_badformat(void **state)

{

    int rc;

    /* Unused */

    (void) state;

    rc = run_on_threads(thread_buffer_pack_badformat);

    assert_int_equal(rc, 0);

}

#define NUM_TESTS 8

static void torture_mixed(void **state)

{

    pthread_t threads[NUM_TESTS][NUM_THREADS];

    int i;

    int f;

    int rc;

    /* Array of functions to run on threads */

    static void *(*funcs[NUM_TESTS])(void *) = {

        thread_growing_buffer,

        thread_growing_buffer_shifting,

        thread_buffer_prepend,

        thread_ssh_buffer_get_ssh_string,

        thread_ssh_buffer_add_format,

        thread_ssh_buffer_get_format,

        thread_ssh_buffer_get_format_error,

        thread_buffer_pack_badformat

    };

    (void) state;

    /* Call tests in a round-robin fashion */

    for (i = 0; i < NUM_THREADS; ++i) {

        for (f = 0; f < NUM_TESTS; f++) {

            rc = pthread_create(&threads[f][i], NULL, funcs[f], NULL);

            assert_int_equal(rc, 0);

        }

    }

    for (f = 0; f < NUM_TESTS; f++) {

        for (i = 0; i < NUM_THREADS; ++i) {

            void *p = NULL;

            uint64_t *result = NULL;

            rc = pthread_join(threads[f][i], &p);

            assert_int_equal(rc, 0);

            result = (uint64_t *)p;

            assert_null(result);

        }

    }

}

int torture_run_tests(void)

{

    int rc;

    struct CMUnitTest tests[] = {

        cmocka_unit_test(torture_growing_buffer),

        cmocka_unit_test(torture_growing_buffer_shifting),

        cmocka_unit_test(torture_buffer_prepend),

        cmocka_unit_test(torture_ssh_buffer_get_ssh_string),

        cmocka_unit_test(torture_ssh_buffer_add_format),

        cmocka_unit_test(torture_ssh_buffer_get_format),

        cmocka_unit_test(torture_ssh_buffer_get_format_error),

        cmocka_unit_test(torture_buffer_pack_badformat),

        cmocka_unit_test(torture_mixed),

    };

    /*

     * If the library is statically linked, ssh_init() is not called

     * automatically

     */

    ssh_init();

    torture_filter_tests(tests);

    rc = cmocka_run_group_tests(tests, NULL, NULL);

    ssh_finalize();

    return rc;

}