#define TRACE_MODULE _testnetlib
#include "core_debug.h"
#include "core_net.h"
#include "testutil.h"

#define TEST_SERVER_PORT    5121
#define TEST_BUFFER_SIZE    1024

#define TEST_MAX_NUM     4

#define DISABLE_FTPTEST  1
#define DISABLE_LINKTEST 1

static char buffer[TEST_BUFFER_SIZE];
static int tcp_server_started = 0;
static int udp_server_started = 0;
static int sctp_stream_server_started = 0;
static int sctp_seq_server_started = 0;

pthread_t tserver_tid,userver_tid,streamserver_tid, seqserver_tid;
net_sock_t *tserver_sock,*userver_sock,*streamserver_sock,*seqserver_sock;

static void *tcp_session_main(void *param)
{
    int rc;

    net_sock_t *net_sock = (net_sock_t *)param;
    while (1)
    {
        rc = net_read(net_sock, buffer, TEST_BUFFER_SIZE, 1);
        if (rc > 0)
        {
            if (!strncmp(buffer, "QUIT",4))
            {
                break;
            }
            else
            {
                /* Send received data */
                rc = net_send(net_sock, buffer, rc);
            }
        }
        else if (rc == 0)
        {
            /* Timeout */
        }
        else
        {
            printf("error = %d\n", net_sock->sndrcv_errno);
            break;
        }
    }

    net_close(net_sock);

    return NULL;
}

static void start_tcp_session(net_sock_t *net_sock)
{
    pthread_t tid;

    pthread_create(&tid, NULL, tcp_session_main, (void *)net_sock);
    pthread_detach(tid);
    return;
}

static void *tcp_server_main(void *param)
{
    int rc;
    net_sock_t *new_sock;

    rc = net_listen(&tserver_sock, SOCK_STREAM, IPPROTO_TCP, TEST_SERVER_PORT);
    if (rc != 0)
    {
        d_error("net_tcp_listen Error(rc = %d)\n",rc);
        return NULL;
    }

    tcp_server_started = 1;

    while (1)
    {
        rc = net_accept(&new_sock, tserver_sock, 1);
        if (rc >0)
        {
            /* New connection arrived. Start session */
            start_tcp_session(new_sock);
        }
        else if (rc == 0)
        {
            /* Timeout */
        }
        else
        {
            /* Error occured */
            break;
        }
    }

    return NULL;
}

static void start_tcp_server()
{
    pthread_create(&tserver_tid, NULL, tcp_server_main, NULL);
    while (tcp_server_started == 0)
    {
        sleep(1);
    }
    return;
}

static void stop_tcp_server()
{
    net_close(tserver_sock);
    pthread_join(tserver_tid, NULL);
}

static void *udp_server_main(void *param)
{
    int rc;

    rc = net_listen(&userver_sock, 
            SOCK_DGRAM, IPPROTO_UDP, TEST_SERVER_PORT);
    if (rc != 0)
    {
        d_error("net_udp Error(rc = %d)\n",rc);
        return NULL;
    }

    udp_server_started = 1;

    while (1)
    {
        d_trace(1,"Wait for data....\n");
        rc = net_read(userver_sock, buffer, TEST_BUFFER_SIZE, 2);
        if (rc >0)
        {
            d_trace(1,"RECV %d bytes\n", rc);
            if (!strncmp(buffer, "QUIT",4))
            {
                break;
            }
            else
            {
                /* Send received data */
                rc = net_send(userver_sock, buffer, rc);
                d_trace(1,"SEND %d bytes\n", rc);
                if (rc == -1)
                {
                    printf("error = %d\n", userver_sock->sndrcv_errno);
                }
            }
        }
        else if (rc == 0)
        {
            /* Timeout */
        }
        else
        {
            /* Error occured */
            break;
        }
    }

    return NULL;
}

static void start_udp_server()
{
    pthread_create(&userver_tid, NULL, udp_server_main, NULL);
    while (udp_server_started == 0)
    {
        sleep(1);
    }
    return;
}

static void stop_udp_server()
{
    net_close(userver_sock);
    pthread_join(userver_tid, NULL);
}

static void *sctp_stream_session_main(void *param)
{
    int rc;

    net_sock_t *net_sock = (net_sock_t *)param;
    while (1)
    {
        rc = net_read(net_sock, buffer, TEST_BUFFER_SIZE, 1);
        if (rc > 0)
        {
            if (!strncmp(buffer, "QUIT",4))
            {
                break;
            }
            else
            {
                /* Send received data */
                rc = net_send(net_sock, buffer, rc);
            }
        }
        else if (rc == 0)
        {
            /* Timeout */
        }
        else
        {
            if (rc != -2 && net_sock->sndrcv_errno != EAGAIN)
                break;
        }
    }

    net_close(net_sock);

    return NULL;
}

static void start_stream_sctp_session(net_sock_t *net_sock)
{
    pthread_t tid;

    pthread_create(&tid, NULL, sctp_stream_session_main, (void *)net_sock);
    pthread_detach(tid);
    return;
}

static void *sctp_stream_server_main(void *param)
{
    int rc;
    net_sock_t *new_sock;

    rc = net_listen(&streamserver_sock, 
            SOCK_STREAM, IPPROTO_SCTP, TEST_SERVER_PORT);
    if (rc != 0)
    {
        d_error("net_sctp_listen Error(rc = %d)\n",rc);
        return NULL;
    }

    sctp_stream_server_started = 1;

    while (1)
    {
        rc = net_accept(&new_sock, streamserver_sock, 1);
        if (rc >0)
        {
            /* New connection arrived. Start session */
            start_stream_sctp_session(new_sock);
        }
        else if (rc == 0)
        {
            /* Timeout */
        }
        else
        {
            /* Error occured */
            break;
        }
    }

    return NULL;
}

static void start_stream_sctp_server()
{
    pthread_create(&streamserver_tid, NULL, sctp_stream_server_main, NULL);
    while (sctp_stream_server_started == 0)
    {
        sleep(1);
    }
    return;
}

static void stop_stream_sctp_server()
{
    net_close(streamserver_sock);
    pthread_join(streamserver_tid, NULL);
}

static void *sctp_seq_server_main(void *param)
{
    int rc;

    rc = net_listen(&seqserver_sock, 
            SOCK_SEQPACKET, IPPROTO_SCTP, TEST_SERVER_PORT);
    if (rc != 0)
    {
        d_error("net_sctp Error(rc = %d)\n",rc);
        return NULL;
    }

    sctp_seq_server_started = 1;

    while (1)
    {
        d_trace(1,"Wait for data....\n");
        rc = net_read(seqserver_sock, buffer, TEST_BUFFER_SIZE, 2);
        if (rc >0)
        {
            d_trace(1,"RECV %d bytes\n", rc);
            if (!strncmp(buffer, "QUIT",4))
            {
                break;
            }
            else
            {
                /* Send received data */
                rc = net_send(seqserver_sock, buffer, rc);
                d_trace(1,"SEND %d bytes\n", rc);
                if (rc == -1)
                {
                    printf("error = %d\n", seqserver_sock->sndrcv_errno);
                }
            }
        }
        else if (rc == 0)
        {
            /* Timeout */
        }
        else
        {
            /* Error occured */
            if (rc != -2 && seqserver_sock->sndrcv_errno != EAGAIN)
                break;
        }
    }

    return NULL;
}

static void start_seq_sctp_server()
{
    pthread_create(&seqserver_tid, NULL, sctp_seq_server_main, NULL);
    while (sctp_seq_server_started == 0)
    {
        sleep(1);
    }
    return;
}

static void stop_seq_sctp_server()
{
    net_close(seqserver_sock);
    pthread_join(seqserver_tid, NULL);
}

static void netlib1(abts_case *tc, void *data)
{
    int rc = 0;
    net_sock_t *net_sock;
    char inputbuf[TEST_MAX_NUM][20];
    char outputbuf[TEST_MAX_NUM][20];
    int i;

    /* Start TCP server */
    start_tcp_server();

    rc = net_open(&net_sock, "127.0.0.1", 0,
            TEST_SERVER_PORT, SOCK_STREAM, IPPROTO_TCP, 0);
    ABTS_INT_EQUAL(tc, 0, rc);
    for (i=0; i< TEST_MAX_NUM; i++)
    {
        sprintf(inputbuf[i],"asdf%d",i);
        rc = net_send(net_sock, inputbuf[i], strlen(inputbuf[i])+1);
        ABTS_INT_EQUAL(tc, strlen(inputbuf[i])+1, rc);
    }

    for (i=0; i< TEST_MAX_NUM; i++)
    {
        memset(outputbuf[i], 0, sizeof(outputbuf[i]));
        rc = 0;
        while (1)
        {
            int n;
            n = net_read(net_sock, outputbuf[i], 6, 1);
            rc += n;
            if (n == 0 || n == 6)
                break;
        }
        ABTS_INT_EQUAL(tc, 6, rc);
        ABTS_INT_EQUAL(tc, 6, strlen(outputbuf[i])+1);
        ABTS_STR_EQUAL(tc, inputbuf[i], outputbuf[i]);
    }
    /* Send QUIT */
    rc = net_send(net_sock, "QUIT", 4);
    ABTS_INT_EQUAL(tc, 4, rc);

    /* Close */
    rc = net_close(net_sock);
    ABTS_INT_EQUAL(tc, 0, rc);

    /* Stop TCP server */
    stop_tcp_server();
}

static void netlib2(abts_case *tc, void *data)
{
    int rc = 0;
    net_sock_t *net_sock[TEST_MAX_NUM];
    char inputbuf[TEST_MAX_NUM][20];
    char outputbuf[TEST_MAX_NUM][20];
    int i;

    /* Start TCP server */
    start_tcp_server();

    /* Connect to invalid port */
    for (i =0 ; i<TEST_MAX_NUM; i++)
    {
        net_sock[i] = NULL;
        rc = net_open(&net_sock[i], "127.0.0.1", 0,TEST_SERVER_PORT + 1,
                SOCK_STREAM, IPPROTO_TCP, 0);
        ABTS_INT_EQUAL(tc, -1, rc);
        ABTS_PTR_NULL(tc, net_sock[i]);
    }

    /* Connect to valid port */
    for (i =0 ; i<TEST_MAX_NUM; i++)
    {
        net_sock[i] = NULL;
        rc = net_open(&net_sock[i], "127.0.0.1", 0,TEST_SERVER_PORT,
                SOCK_STREAM, IPPROTO_TCP, 0);
        ABTS_INT_EQUAL(tc, 0, rc);
        ABTS_PTR_NOTNULL(tc, net_sock[i]);
    }

    for (i=0; i< TEST_MAX_NUM; i++)
    {
        sprintf(inputbuf[i],"asdf%d",i);
        memset(outputbuf[i], 0, sizeof(outputbuf[i]));
        rc = net_send(net_sock[i], inputbuf[i], strlen(inputbuf[i])+1);
        ABTS_INT_EQUAL(tc, strlen(inputbuf[i])+1, rc);
        rc = 0;
        while (1)
        {
            int n;
            n = net_read(net_sock[i], outputbuf[i], 6, 1);
            rc += n;
            if (n == 0 || n == 6)
                break;
        }
        ABTS_INT_EQUAL(tc, 6, rc);
        ABTS_INT_EQUAL(tc, 6, strlen(outputbuf[i])+1);
        ABTS_STR_EQUAL(tc, inputbuf[i], outputbuf[i]);
    }

    for (i = 0 ; i< TEST_MAX_NUM; i++)
    {
        rc = net_close(net_sock[i]);
        ABTS_INT_EQUAL(tc, 0, rc);
    }

    /* Stop TCP server */
    stop_tcp_server();
}

static void netlib3(abts_case *tc, void *data)
{
    int rc = 0;
    net_sock_t *net_sock[TEST_MAX_NUM];
    char inputbuf[TEST_MAX_NUM][20];
    char outputbuf[TEST_MAX_NUM][20];
    int i;

    /* Connect to invalid port.
     * In UDP cases, net_open should be success always
     */
    for (i =0 ; i<TEST_MAX_NUM; i++)
    {
        net_sock[i] = NULL;
        rc = net_open(&net_sock[i], "127.0.0.1", 0,TEST_SERVER_PORT + 1,
                SOCK_DGRAM, IPPROTO_UDP, 0);
        ABTS_INT_EQUAL(tc, 0, rc);
        ABTS_PTR_NOTNULL(tc, net_sock[i]);
    }

    for (i = 0 ; i< TEST_MAX_NUM; i++)
    {
        rc = net_close(net_sock[i]);
        ABTS_INT_EQUAL(tc, 0, rc);
    }

    /* Start UDP Server */
    start_udp_server();

    for (i =0 ; i<TEST_MAX_NUM; i++)
    {
        net_sock[i] = NULL;
        rc = net_open(&net_sock[i], "127.0.0.1", 0,TEST_SERVER_PORT,
                SOCK_DGRAM, IPPROTO_UDP, 0);
        ABTS_INT_EQUAL(tc, 0, rc);
        ABTS_PTR_NOTNULL(tc, net_sock[i]);
    }

    for (i=0; i< TEST_MAX_NUM; i++)
    {
        sprintf(inputbuf[i],"asdf%d",i);
        memset(outputbuf[i], 0, sizeof(outputbuf[i]));
        rc = net_send(net_sock[i], inputbuf[i], strlen(inputbuf[i])+1);
        ABTS_INT_EQUAL(tc, strlen(inputbuf[i])+1, rc);
        rc = 0;
        while (1)
        {
            int n;
            n = net_read(net_sock[i], outputbuf[i], 6, 1);
            rc += n;
            if (n == 0 || n == 6)
                break;
        }
        ABTS_INT_EQUAL(tc, 6, rc);
        ABTS_INT_EQUAL(tc, 6, strlen(outputbuf[i])+1);
        ABTS_STR_EQUAL(tc, inputbuf[i], outputbuf[i]);
    }

    for (i = 0 ; i< TEST_MAX_NUM; i++)
    {
        rc = net_close(net_sock[i]);
        ABTS_INT_EQUAL(tc, 0, rc);
    }

    stop_udp_server();
}

static void netlib4(abts_case *tc, void *data)
{
    int rc = 0;
    net_sock_t *net_sock[TEST_MAX_NUM];
    char inputbuf[TEST_MAX_NUM][25];
    char outputbuf[TEST_MAX_NUM][25];
    int i;

    /* Start SCTP Server */
    start_stream_sctp_server();

    /* Connect to invalid port */
    for (i =0 ; i<TEST_MAX_NUM; i++)
    {
        net_sock[i] = NULL;
        rc = net_open(&net_sock[i], "127.0.0.1", 0,TEST_SERVER_PORT + 1,
                SOCK_STREAM, IPPROTO_SCTP, 0);
        ABTS_INT_EQUAL(tc, -1, rc);
        ABTS_PTR_NULL(tc, net_sock[i]);
    }

    for (i =0 ; i<TEST_MAX_NUM; i++)
    {
        net_sock[i] = NULL;
        rc = net_open(&net_sock[i], "127.0.0.1", 0, TEST_SERVER_PORT,
                SOCK_STREAM, IPPROTO_SCTP, 0);
        ABTS_INT_EQUAL(tc, 0, rc);
        ABTS_PTR_NOTNULL(tc, net_sock[i]);
    }

    for (i=0; i< TEST_MAX_NUM; i++)
    {
        sprintf(inputbuf[i],"asdf%d",i);
        memset(outputbuf[i], 0, sizeof(outputbuf[i]));
        rc = net_send(net_sock[i], inputbuf[i], strlen(inputbuf[i])+1);
        ABTS_INT_EQUAL(tc, strlen(inputbuf[i])+1, rc);
        rc = 0;
        while (1)
        {
            int n;
            n = net_read(net_sock[i], outputbuf[i], sizeof(outputbuf[1]), 1);
            if (n < 0 && net_sock[i]->sndrcv_errno == EAGAIN)
                continue;
            rc += n;
            if (n == 0 || n == 6)
                break;
        }
        ABTS_INT_EQUAL(tc, 6, rc);
        ABTS_INT_EQUAL(tc, 6, strlen(outputbuf[i])+1);
        ABTS_STR_EQUAL(tc, inputbuf[i], outputbuf[i]);
    }

    for (i = 0 ; i< TEST_MAX_NUM; i++)
    {
        rc = net_close(net_sock[i]);
        ABTS_INT_EQUAL(tc, 0, rc);
    }

    stop_stream_sctp_server();
}

static void netlib5(abts_case *tc, void *data)
{
    int rc = 0;
    net_sock_t *net_sock[TEST_MAX_NUM];
    char inputbuf[TEST_MAX_NUM][25];
    char outputbuf[TEST_MAX_NUM][25];
    int i;

    /* Connect to invalid port.
     * In SCTP cases, net_open should be success always
     */
    for (i =0 ; i<TEST_MAX_NUM; i++)
    {
        net_sock[i] = NULL;
        rc = net_open(&net_sock[i], "127.0.0.1", 0, TEST_SERVER_PORT + 1,
                SOCK_SEQPACKET, IPPROTO_SCTP, 0);
        ABTS_INT_EQUAL(tc, 0, rc);
        ABTS_PTR_NOTNULL(tc, net_sock[i]);
    }

    for (i = 0 ; i< TEST_MAX_NUM; i++)
    {
        rc = net_close(net_sock[i]);
        ABTS_INT_EQUAL(tc, 0, rc);
    }

    /* Start SCTP Server */
    start_seq_sctp_server();

    for (i =0 ; i<TEST_MAX_NUM; i++)
    {
        net_sock[i] = NULL;
        rc = net_open(&net_sock[i], "127.0.0.1", 0, TEST_SERVER_PORT,
                SOCK_SEQPACKET, IPPROTO_SCTP, 0);
        ABTS_INT_EQUAL(tc, 0, rc);
        ABTS_PTR_NOTNULL(tc, net_sock[i]);
    }

    for (i=0; i< TEST_MAX_NUM; i++)
    {
        sprintf(inputbuf[i],"asdf%d",i);
        memset(outputbuf[i], 0, sizeof(outputbuf[i]));
        rc = net_send(net_sock[i], inputbuf[i], strlen(inputbuf[i])+1);
        ABTS_INT_EQUAL(tc, strlen(inputbuf[i])+1, rc);
        rc = 0;
        while (1)
        {
            int n;
            n = net_read(net_sock[i], outputbuf[i], sizeof(outputbuf[i]), 1);
            if (n < 0 && net_sock[i]->sndrcv_errno == EAGAIN)
                continue;
            rc += n;
            if (n == 0 || n == 6)
                break;
        }
        ABTS_INT_EQUAL(tc, 6, rc);
        ABTS_INT_EQUAL(tc, 6, strlen(outputbuf[i])+1);
        ABTS_STR_EQUAL(tc, inputbuf[i], outputbuf[i]);
    }

    for (i = 0 ; i< TEST_MAX_NUM; i++)
    {
        rc = net_close(net_sock[i]);
        ABTS_INT_EQUAL(tc, 0, rc);
    }

    stop_seq_sctp_server();
}

static void netlib6(abts_case *tc, void *data)
{
    int rc;
    net_ftp_t *ftp_session = NULL;
    char *homedir = NULL;
    int remote_size = 0;
    int local_size = 0;
    char host[] = "127.0.0.1:21";
    int i;

#if DISABLE_FTPTEST
    return;
#endif
    rc = net_ftp_open(host,
            "susia",
            "ich3lie",
            0,&ftp_session);
    ABTS_INT_EQUAL(tc, 0, rc);
    ABTS_PTR_NOTNULL(tc, ftp_session);

    homedir = getenv("HOME");
    if (homedir)
    {
        char filename[100];
        struct stat statbuff;
        sprintf(filename,"%s/.bashrc",homedir);

        if (stat(filename, &statbuff) == 0)
        {
            remote_size= statbuff.st_size;
        }
    }
    rc = net_ftp_get(ftp_session,".bashrc",NULL);
    ABTS_INT_EQUAL(tc, 0, rc);
    {
        struct stat statbuff;

        rc = stat(".bashrc", &statbuff);
        ABTS_INT_EQUAL(tc, 0, rc);
        local_size= statbuff.st_size;
        ABTS_INT_EQUAL(tc, local_size, remote_size);
    }

    for (i=0; i < 20; i++)
    {
        rc = net_ftp_get(ftp_session,".bashrc","bashrc");
        ABTS_INT_EQUAL(tc, 0, rc);
        {
            struct stat statbuff;
            rc = stat("bashrc", &statbuff);
            ABTS_INT_EQUAL(tc, 0, rc);
            local_size= statbuff.st_size;
            ABTS_INT_EQUAL(tc, local_size, remote_size);
        }
        rc = net_ftp_put(ftp_session,"bashrc", NULL);
        ABTS_INT_EQUAL(tc, 0, rc);

        unlink("bashrc");
    }

    rc = net_ftp_quit(ftp_session);
    ABTS_INT_EQUAL(tc, 0, rc);

    rc = net_ftp_close(ftp_session);
    ABTS_INT_EQUAL(tc, 0, rc);
}

#if LINUX == 1
static void filter_updu(char *buf, int len)
{
    unsigned short proto = 0x88B6;
    struct ethhdr *eth_hdr = NULL;

    eth_hdr = (struct ethhdr *)buf;
    if (ntohs(eth_hdr->h_proto) == proto)
    {
        d_print_hex(buf, len);
    }
}

static void netlib7(abts_case *tc, void *data)
{
    net_link_t *net_link = NULL;
    int promisc = 1;
    int rc;
    int max_count = 10;
    char buf[1024];

#if DISABLE_LINKTEST
    return;
#endif
    rc = net_link_open(&net_link, "eth0", ETH_P_ALL);
    ABTS_INT_EQUAL(tc, 0, rc);
    ABTS_PTR_NOTNULL(tc, net_link);
    rc = net_link_promisc(net_link, promisc);
    ABTS_INT_EQUAL(tc, 0, rc);
#if 0
    d_print("HW addr of %s : ",net_link->ifname);
    d_print_hex(net_link->hwaddr.sa_data, 6);
#endif
    while (max_count-- > 0)
    {
        rc = net_link_read(net_link, buf, 1024, 1);
        ABTS_TRUE(tc, rc > 0);
        filter_updu(buf, rc);
    }
    rc = net_link_close(net_link);
    ABTS_INT_EQUAL(tc, 0, rc);
}

static int make_test_updu(char *src_addr, char *dst_addr, char *buf, int len)
{
    unsigned short proto = 0x88B6;
    struct ethhdr *eth_hdr = NULL;
    int rc = sizeof(struct ethhdr);
    char *ptr = buf;

    eth_hdr = (struct ethhdr *)buf;
    memcpy(eth_hdr->h_source, src_addr, 6);
    memcpy(eth_hdr->h_dest, dst_addr, 6);
    eth_hdr->h_proto = htons(proto);
    /* Fill the data */
    rc += sprintf(ptr+rc,"Hellow World");
    d_print_hex(buf, rc);
    return rc;
}

static void netlib8(abts_case *tc, void *data)
{
    net_link_t *net_link = NULL;
    int promisc = 1;
    int rc;
    int max_count = 1;
    char buf[1024];
#if 0
    char dst_addr[6] = {'\x00','\x00','\x00','\x11','\x22','\x33'};
#else
    char dst_addr[6] = {'\xff','\xff','\xff','\xff','\xff','\xff'};
#endif

#if DISABLE_LINKTEST
    return;
#endif

    rc = net_link_open(&net_link, "eth0", ETH_P_ALL);
    ABTS_INT_EQUAL(tc, 0, rc);
    ABTS_PTR_NOTNULL(tc, net_link);
    rc = net_link_promisc(net_link, promisc);
    ABTS_INT_EQUAL(tc, 0, rc);
    while (max_count-- > 0)
    {
        rc = make_test_updu(net_link->hwaddr.sa_data, dst_addr,buf,1024);

        rc = net_link_write(net_link, buf, rc);
        ABTS_TRUE(tc, rc > 0);
    }
    rc = net_link_close(net_link);
    ABTS_INT_EQUAL(tc, 0, rc);
}
#endif

abts_suite *testnetlib(abts_suite *suite)
{
    suite = ADD_SUITE(suite);

    abts_run_test(suite, netlib1, NULL);
    abts_run_test(suite, netlib2, NULL);
    abts_run_test(suite, netlib3, NULL);
    abts_run_test(suite, netlib4, NULL);
    abts_run_test(suite, netlib5, NULL);
    abts_run_test(suite, netlib6, NULL);
#if LINUX == 1
    abts_run_test(suite, netlib7, NULL);
    abts_run_test(suite, netlib8, NULL);
#endif

    return suite;
}