path: root/tinyHTTP/test/test_transport.h

#ifndef _TEST_HTTP_TRANSPORT_H_
#define _TEST_HTTP_TRANSPORT_H_

#define TEST_HTTP_CAT_(A, B) A ## B
#define TEST_HTTP_CAT(A, B) TEST_HTTP_CAT_(A, B)
#define TEST_HTTP_STRING_(A) #A
#define TEST_HTTP_STRING(A) TEST_HTTP_STRING_(A)

#define TEST_HTTP_LOCAL_IP				"0.0.0.0"
#define TEST_HTTP_LOCAL_PORT			8080
#define TEST_HTTP_REMOTE_IP				"google.com"
#define TEST_HTTP_REMOTE_PORT			80
#define TEST_HTTP_MIN_STREAM_CHUNCK_SIZE	0x32
#define TEST_HTTP_GET "GET / HTTP/1.1\r\n" \
	"Host: " TEST_HTTP_REMOTE_IP ":" TEST_HTTP_STRING(TEST_HTTP_REMOTE_PORT) "\r\n" \
	"Connection: keep-alive\r\n" \
	"Cache-Control: max-age=0\r\n" \
	"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n" \
	"User-Agent: Mozilla/5.0 (Windows NT 6.0) AppleWebKit/537.36 (KHTML, like Gecko)\r\n" \
	"Doubango 2.0\r\n" \
	"Accept-Encoding: gzip,deflate,sdch\r\n" \
	"Accept-Language: en-US,en;q=0.8\r\n" \
	"\r\n" \
 
static int test_http_transport_callback(const tnet_transport_event_t* e);

/************************************************
* test_http_peer_t
************************************************/
typedef struct test_http_peer_s {
    TSK_DECLARE_OBJECT;
    tnet_fd_t fd;
    tsk_buffer_t* buff;
}
test_http_peer_t;
typedef tsk_list_t test_http_peers_L_t;

static tsk_object_t* test_http_peer_ctor(tsk_object_t * self, va_list * app)
{
    return self;
}
static tsk_object_t* test_http_peer_dtor(tsk_object_t * self)
{
    test_http_peer_t *peer = self;
    if (peer) {
        TSK_OBJECT_SAFE_FREE(peer->buff);
    }

    return self;
}
static const tsk_object_def_t test_http_peer_def_s = {
    sizeof(test_http_peer_t),
    test_http_peer_ctor,
    test_http_peer_dtor,
    tsk_null,
};

static test_http_peer_t* test_http_peer_create(tnet_fd_t fd)
{
    test_http_peer_t* peer = tsk_object_new(&test_http_peer_def_s);
    peer->fd = fd;
    peer->buff = tsk_buffer_create_null();
    return peer;
}

static int test_http_peer_pred_fd_cmp(const tsk_list_item_t* item, const void* data)
{
    return ((test_http_peer_t*)item->data)->fd - *((const tnet_fd_t*)data);
}


/************************************************
* test_http_transport_t
************************************************/
typedef struct test_http_transport_s {
    TSK_DECLARE_OBJECT;

    test_http_peers_L_t* peers;
    tnet_transport_handle_t* handle;
}
test_http_transport_t;

static tsk_object_t* test_http_transport_ctor(tsk_object_t * self, va_list * app)
{
    test_http_transport_t *transport = self;
    if (transport) {
    }
    return self;
}
static tsk_object_t* test_http_transport_dtor(tsk_object_t * self)
{
    test_http_transport_t *transport = self;
    if(transport) {
        TSK_OBJECT_SAFE_FREE(transport->handle);
        TSK_OBJECT_SAFE_FREE(transport->peers);
    }

    return self;
}
static const tsk_object_def_t test_http_transport_def_s = {
    sizeof(test_http_transport_t),
    test_http_transport_ctor,
    test_http_transport_dtor,
    tsk_null,
};

static test_http_transport_t* test_http_transport_create(const char* local_ip, tnet_port_t local_port, enum tnet_socket_type_e socket_type)
{
    test_http_transport_t *transport = tsk_object_new(&test_http_transport_def_s);
    if (transport) {
        transport->peers = tsk_list_create();
        transport->handle = tnet_transport_create(local_ip, local_port, socket_type, "HTTP Transport");
        if (!transport->handle) {
            TSK_OBJECT_SAFE_FREE(transport);
            return tsk_null;
        }
        tnet_transport_set_callback(transport->handle, test_http_transport_callback, transport);
    }
    return transport;
}

static int test_http_transport_start(test_http_transport_t* self)
{
    if (self) {
        return tnet_transport_start(self->handle);
    }
    return -1;
}

// Up to the caller to free the returned object using TSK_OBJECT_SAFREE(peer)
static test_http_peer_t* test_http_transport_connect_to(test_http_transport_t* self, const char* dst_host, tnet_port_t dst_port)
{
    tnet_fd_t fd = tnet_transport_connectto_2(self->handle, dst_host, dst_port);
    if (fd > 0) {
        return test_http_peer_create(fd);
    }
    return tsk_null;
}

static tsk_size_t test_http_transport_send_data(test_http_transport_t* self, tnet_fd_t fd, const void* data_ptr, tsk_size_t data_size)
{
    if (self && self->handle && data_ptr && data_size) {
        return tnet_transport_send(self->handle, fd, data_ptr, data_size);
    }
    return 0;
}

static void test_http_transport_add_peer(test_http_transport_t* self, test_http_peer_t* peer)
{
    tsk_list_lock(self->peers);
    tsk_list_push_back_data(self->peers, &peer);
    tsk_list_unlock(self->peers);
}

static void test_http_transport_remove_peer_by_fd(test_http_transport_t* self, tnet_fd_t fd)
{
    tsk_list_lock(self->peers);
    tsk_list_remove_item_by_pred(self->peers, test_http_peer_pred_fd_cmp, &fd);
    tsk_list_unlock(self->peers);
}

static const test_http_peer_t* test_http_transport_find_peer_by_fd(test_http_transport_t* self, tnet_fd_t fd)
{
    const tsk_list_item_t* item;
    tsk_list_lock(self->peers);
    item = tsk_list_find_item_by_pred(self->peers, test_http_peer_pred_fd_cmp, &fd);
    tsk_list_unlock(self->peers);
    if (item) {
        return (const test_http_peer_t*)item->data;
    }
    return tsk_null;
}

static void test_http_transport_process_incoming_msg(test_http_transport_t* self, const thttp_message_t* msg, tnet_fd_t fd)
{
    if (THTTP_MESSAGE_IS_REQUEST(msg)) {
        if (tsk_striequals(msg->line.request.method, "GET")) {
            char* result = tsk_null;
            const char* content = "<html><body>Hello world!</body></html>";
            int len = tsk_sprintf(
                          (char**)&result,
                          "HTTP/1.1 %u %s\r\n"
                          "Server: My test server \r\n"
                          "Access-Control-Allow-Origin: *\r\n"
                          "Content-Length: %u\r\n"
                          "Content-Type: text/html\r\n"
                          "Connection: Close\r\n"
                          "\r\n"
                          "%s", 200, "OK", tsk_strlen(content), content);
            tnet_transport_send(self, fd, result, len);
            TSK_FREE(result);
        }
    }
}

static int test_http_transport_callback(const tnet_transport_event_t* e)
{
    test_http_transport_t* transport = (test_http_transport_t*)e->callback_data;
    const test_http_peer_t* _peer;
    thttp_message_t *message = tsk_null;
    int endOfheaders = -1;
    tsk_ragel_state_t state;
    tsk_bool_t have_all_content = tsk_false;
    int ret;
    switch (e->type) {
    case event_closed: {
        test_http_transport_remove_peer_by_fd(transport, e->local_fd);
        return 0;
    }

    case event_connected:
    case event_accepted: {
        _peer = test_http_transport_find_peer_by_fd(transport, e->local_fd);
        if (!_peer) {
            _peer = test_http_peer_create(e->local_fd);
            test_http_transport_add_peer(transport, (test_http_peer_t*)_peer);
        }
        return 0;
    }

    case event_data: {
        TSK_DEBUG_INFO("\n\nRECV: %.*s\n\n", e->size, (const char*)e->data);
        break;
    }
    default:
        return 0;
    }


    _peer = test_http_transport_find_peer_by_fd(transport, e->local_fd);
    if(!_peer) {
        TSK_DEBUG_ERROR("Data event but no peer found!");
        return -1;
    }

    /* Append new content. */
    tsk_buffer_append(_peer->buff, e->data, e->size);

    /* Check if we have all HTTP headers. */
parse_buffer:
    if ((endOfheaders = tsk_strindexOf(TSK_BUFFER_DATA(_peer->buff), TSK_BUFFER_SIZE(_peer->buff), "\r\n\r\n"/*2CRLF*/)) < 0) {
        TSK_DEBUG_INFO("No all HTTP headers in the TCP buffer.");
        goto bail;
    }

    /* If we are here this mean that we have all HTTP headers.
    *	==> Parse the HTTP message without the content.
    */
    tsk_ragel_state_init(&state, TSK_BUFFER_DATA(_peer->buff), endOfheaders + 4/*2CRLF*/);
    if (!(ret = thttp_message_parse(&state, &message, tsk_false/* do not extract the content */))) {
        const thttp_header_Transfer_Encoding_t* transfer_Encoding;

        /* chunked? */
        if((transfer_Encoding = (const thttp_header_Transfer_Encoding_t*)thttp_message_get_header(message, thttp_htype_Transfer_Encoding)) && tsk_striequals(transfer_Encoding->encoding, "chunked")) {
            const char* start = (const char*)(TSK_BUFFER_TO_U8(_peer->buff) + (endOfheaders + 4/*2CRLF*/));
            const char* end = (const char*)(TSK_BUFFER_TO_U8(_peer->buff) + TSK_BUFFER_SIZE(_peer->buff));
            int index;

            TSK_DEBUG_INFO("CHUNKED transfer.");
            while(start < end) {
                /* RFC 2616 - 19.4.6 Introduction of Transfer-Encoding */
                // read chunk-size, chunk-extension (if any) and CRLF
                tsk_size_t chunk_size = (tsk_size_t)tsk_atox(start);
                if((index = tsk_strindexOf(start, (end-start), "\r\n")) >=0) {
                    start += index + 2/*CRLF*/;
                }
                else {
                    TSK_DEBUG_INFO("Parsing chunked data has failed.");
                    break;
                }

                if(chunk_size == 0 && ((start + 2) <= end) && *start == '\r' && *(start+ 1) == '\n') {
                    int parsed_len = (start - (const char*)(TSK_BUFFER_TO_U8(_peer->buff))) + 2/*CRLF*/;
                    tsk_buffer_remove(_peer->buff, 0, parsed_len);
                    have_all_content = tsk_true;
                    break;
                }

                thttp_message_append_content(message, start, chunk_size);
                start += chunk_size + 2/*CRLF*/;
            }
        }
        else {
            tsk_size_t clen = THTTP_MESSAGE_CONTENT_LENGTH(message); /* MUST have content-length header. */
            if(clen == 0) { /* No content */
                tsk_buffer_remove(_peer->buff, 0, (endOfheaders + 4/*2CRLF*/)); /* Remove HTTP headers and CRLF ==> must never happen */
                have_all_content = tsk_true;
            }
            else { /* There is a content */
                if((endOfheaders + 4/*2CRLF*/ + clen) > TSK_BUFFER_SIZE(_peer->buff)) { /* There is content but not all the content. */
                    TSK_DEBUG_INFO("No all HTTP content in the TCP buffer.");
                    goto bail;
                }
                else {
                    /* Add the content to the message. */
                    thttp_message_add_content(message, tsk_null, TSK_BUFFER_TO_U8(_peer->buff) + endOfheaders + 4/*2CRLF*/, clen);
                    /* Remove HTTP headers, CRLF and the content. */
                    tsk_buffer_remove(_peer->buff, 0, (endOfheaders + 4/*2CRLF*/ + clen));
                    have_all_content = tsk_true;
                }
            }
        }
    }

    /* Alert the dialog (FSM) */
    if(message) {
        if (have_all_content) { /* only if we have all data */
            test_http_transport_process_incoming_msg(transport, message, e->local_fd);
            /* Parse next chunck */
            if (TSK_BUFFER_SIZE(_peer->buff) >= TEST_HTTP_MIN_STREAM_CHUNCK_SIZE) {
                TSK_OBJECT_SAFE_FREE(message);
                goto parse_buffer;
            }
        }
    }

bail:
    TSK_OBJECT_SAFE_FREE(message);

    return 0;
}


/************************************************
* Main
************************************************/
static void test_transport()
{
    test_http_transport_t* p_transport = tsk_null;
    test_http_peer_t* peer = tsk_null;
    int ret;
    static const char* __get_msg = TEST_HTTP_GET;

    p_transport = test_http_transport_create(TEST_HTTP_LOCAL_IP, TEST_HTTP_LOCAL_PORT, tnet_socket_type_tcp_ipv4);
    if (!p_transport) {
        TSK_DEBUG_ERROR("Failed to HTTP transport");
        goto bail;
    }

    ret = test_http_transport_start(p_transport);
    if (ret) {
        TSK_DEBUG_ERROR("Failed to start HTTP transport with error code = %d", ret);
        goto bail;
    }

    getchar();

    // Send data to google.com
    peer = test_http_transport_connect_to(p_transport, TEST_HTTP_REMOTE_IP, TEST_HTTP_REMOTE_PORT);
    ret = tnet_sockfd_waitUntilWritable(peer->fd, 1000); // you should use the callback function instead of blocking the process
    if (ret) {
        TSK_DEBUG_ERROR("Failed to connect to(%s,%d) with error code = %d", TEST_HTTP_REMOTE_IP, TEST_HTTP_REMOTE_PORT, ret);
        goto bail;
    }
    ret = test_http_transport_send_data(p_transport, peer->fd, __get_msg, tsk_strlen(__get_msg));
    TSK_DEBUG_INFO("Sent %d bytes", ret);

    getchar();


bail:
    TSK_OBJECT_SAFE_FREE(p_transport); // stop server and free memory
    TSK_OBJECT_SAFE_FREE(peer);
}

#endif /* _TEST_HTTP_TRANSPORT_H_ */