[HTTP_DECODER]bugfix for http header truncated

8 files changed, 297 insertions, 74 deletions

diff --git a/src/http_decoder/http_decoder.c b/src/http_decoder/http_decoder.c
index 1ce4b86..8a663ab 100644
--- a/src/http_decoder/http_decoder.c
+++ b/src/http_decoder/http_decoder.c
@@ -35,7 +35,8 @@ const char *fs_file_name = "http_decoder.fs";
 */
 struct http_message {
 	enum http_message_type type;
-	struct http_decoder_half_data *data;
+    struct http_decoder_result_queue *ref_queue;
+    size_t queue_index;
 };
 
 struct http_decoder {
@@ -61,12 +62,15 @@ struct http_decoder_context {
 };
 
 struct http_message *
-http_message_new(enum http_message_type type, void *data)
+http_message_new(enum http_message_type type,
+                 struct http_decoder_result_queue *queue,
+                 int queue_index)
 {
     struct http_message *msg = CALLOC(struct http_message, 1);
 
     msg->type = type;
-    msg->data = data;
+    msg->ref_queue = queue;
+    msg->queue_index = queue_index;
 
     return msg;
 }
@@ -86,6 +90,7 @@ static void http_event_handler(enum http_event event,
 {
     assert(ev_ctx);
 
+    size_t queue_idx = 0;
     struct http_decoder_result_queue *queue = ev_ctx->ref_queue;
     struct http_message *msg = NULL;
     struct http_decoder_half_data *half_data = NULL;
@@ -115,17 +120,25 @@ static void http_event_handler(enum http_event event,
         *data = half_data;
         break;
     case HTTP_EVENT_REQ_LINE:
-        msg = http_message_new(HTTP_MESSAGE_REQ_LINE, *data);
+        queue_idx = http_decoder_result_queue_req_index(queue);
+        msg = http_message_new(HTTP_MESSAGE_REQ_LINE, queue, queue_idx);
         session_mq_publish_message(ev_ctx->ref_session, ev_ctx->topic_id, msg);
         break;
     case HTTP_EVENT_REQ_HDR_END:
-        msg = http_message_new(HTTP_MESSAGE_REQ_HEADER, *data);
+        ret = http_decoder_half_data_has_parsed_header(*data);
+        if (0 == ret) {
+            break;
+        }
+
+        queue_idx = http_decoder_result_queue_req_index(queue);
+        msg = http_message_new(HTTP_MESSAGE_REQ_HEADER, queue, queue_idx);
         session_mq_publish_message(ev_ctx->ref_session, ev_ctx->topic_id, msg);
         break;
     case HTTP_EVENT_REQ_BODY_BEGIN:
         break;
     case HTTP_EVENT_REQ_BODY_DATA:
-        msg = http_message_new(HTTP_MESSAGE_REQ_BODY, *data);
+        queue_idx = http_decoder_result_queue_req_index(queue);
+        msg = http_message_new(HTTP_MESSAGE_REQ_BODY, queue, queue_idx);
         session_mq_publish_message(ev_ctx->ref_session, ev_ctx->topic_id, msg);
         break;
     case HTTP_EVENT_REQ_BODY_END:
@@ -161,19 +174,27 @@ static void http_event_handler(enum http_event event,
         *data = half_data;
         break;
     case HTTP_EVENT_RES_LINE:
-        msg = http_message_new(HTTP_MESSAGE_RES_LINE, *data);
+        queue_idx = http_decoder_result_queue_res_index(queue); 
+        msg = http_message_new(HTTP_MESSAGE_RES_LINE, queue, queue_idx);
         session_mq_publish_message(ev_ctx->ref_session, ev_ctx->topic_id, msg);
         break;
     case HTTP_EVENT_RES_HDR:
         break;
     case HTTP_EVENT_RES_HDR_END:
-        msg = http_message_new(HTTP_MESSAGE_RES_HEADER, *data);
+        ret = http_decoder_half_data_has_parsed_header(*data);
+        if (0 == ret) {
+            break;
+        }
+
+        queue_idx = http_decoder_result_queue_res_index(queue);
+        msg = http_message_new(HTTP_MESSAGE_RES_HEADER, queue, queue_idx);
         session_mq_publish_message(ev_ctx->ref_session, ev_ctx->topic_id, msg); 
         break;
     case HTTP_EVENT_RES_BODY_BEGIN:
         break;
     case HTTP_EVENT_RES_BODY_DATA:
-        msg = http_message_new(HTTP_MESSAGE_RES_BODY, *data);
+        queue_idx = http_decoder_result_queue_res_index(queue);
+        msg = http_message_new(HTTP_MESSAGE_RES_BODY, queue, queue_idx);
         session_mq_publish_message(ev_ctx->ref_session, ev_ctx->topic_id, msg); 
         break;
     case HTTP_EVENT_RES_BODY_END:
@@ -338,7 +359,13 @@ int http_decoder_entry(struct session *sess, int events,
         cur_half = ex_data->decoder->s2c_half;
     }
 
-    http_decoder_half_reinit(cur_half, decoder_ctx->topic_id, ex_data->queue, sess);
+    // printf("<before parse> queue:%p req_index:%zu req:%p res_index:%zu, res:%p\n",
+    //        ex_data->queue, ex_data->queue->req_index,
+    //        ex_data->queue->array[ex_data->queue->req_index].req_data,
+    //        ex_data->queue->res_index,
+    //        ex_data->queue->array[ex_data->queue->res_index].res_data);
+    http_decoder_half_reinit(cur_half, decoder_ctx->topic_id, ex_data->queue,
+                             sess);
     ret = http_decoder_half_parse(cur_half, payload, payload_len);
     if (ret < 0) {
         // fieldstat_easy_counter_incrby(decoder_ctx->fse, thread_id,
@@ -359,6 +386,12 @@ int http_decoder_entry(struct session *sess, int events,
     //                               decoder_ctx->fs_incoming_trans_id,
     //                               NULL, 0, trans_cnt);
 
+    // printf("<after parse> queue:%p req_index:%zu req:%p res_index:%zu, res:%p, counter:%d\n",
+    //        ex_data->queue, ex_data->queue->req_index,
+    //        ex_data->queue->array[ex_data->queue->req_index].req_data,
+    //        ex_data->queue->res_index,
+    //        ex_data->queue->array[ex_data->queue->res_index].res_data,
+    //        decoder_ctx->counter);
     return 0;
 }
 
@@ -510,7 +543,13 @@ int http_message_get_request_line(struct http_message *msg,
 		return -1;
 	}
 
-	return http_decoder_half_data_get_request_line(msg->data, line);
+    assert(msg->ref_queue);
+    assert(msg->queue_index < HD_RESULT_QUEUE_SIZE);
+
+    struct http_decoder_half_data *req_data =
+        msg->ref_queue->array[msg->queue_index].req_data;
+
+    return http_decoder_half_data_get_request_line(req_data, line);
 }
 
 int http_message_get_response_line(struct http_message *msg,
@@ -521,7 +560,13 @@ int http_message_get_response_line(struct http_message *msg,
 		return -1;
 	}
 
-	return http_decoder_half_data_get_response_line(msg->data, line);
+    assert(msg->ref_queue);
+    assert(msg->queue_index < HD_RESULT_QUEUE_SIZE);
+
+    struct http_decoder_half_data *res_data =
+        msg->ref_queue->array[msg->queue_index].res_data;
+
+	return http_decoder_half_data_get_response_line(res_data, line);
 }
 
 int http_message_get_request_header(struct http_message *msg, struct hstring *key,
@@ -532,7 +577,13 @@ int http_message_get_request_header(struct http_message *msg, struct hstring *ke
 		return -1;
 	}
 
-	return http_decoder_half_data_get_header(msg->data, key, hdr_array, array_size);
+    assert(msg->ref_queue);
+    assert(msg->queue_index < HD_RESULT_QUEUE_SIZE);
+
+    struct http_decoder_half_data *req_data =
+        msg->ref_queue->array[msg->queue_index].req_data;
+
+	return http_decoder_half_data_get_header(req_data, key, hdr_array, array_size);
 }
 
 int http_message_get_response_header(struct http_message *msg, struct hstring *key,
@@ -543,7 +594,13 @@ int http_message_get_response_header(struct http_message *msg, struct hstring *k
 		return -1;
 	}
 
-	return http_decoder_half_data_get_header(msg->data, key, hdr_array, array_size);
+    assert(msg->ref_queue);
+    assert(msg->queue_index < HD_RESULT_QUEUE_SIZE);
+
+    struct http_decoder_half_data *res_data =
+        msg->ref_queue->array[msg->queue_index].res_data;
+
+	return http_decoder_half_data_get_header(res_data, key, hdr_array, array_size);
 }
 
 int http_message_request_header_next(struct http_message *msg,
@@ -554,7 +611,13 @@ int http_message_request_header_next(struct http_message *msg,
 		return -1;
 	}
 
-    return http_decoder_half_data_iter_header(msg->data, hdr);
+    assert(msg->ref_queue);
+    assert(msg->queue_index < HD_RESULT_QUEUE_SIZE);
+
+    struct http_decoder_half_data *req_data =
+        msg->ref_queue->array[msg->queue_index].req_data;
+
+    return http_decoder_half_data_iter_header(req_data, hdr);
 }
 
 int http_message_response_header_next(struct http_message *msg,
@@ -565,7 +628,13 @@ int http_message_response_header_next(struct http_message *msg,
 		return -1;
 	}
 
-    return http_decoder_half_data_iter_header(msg->data, hdr);
+    assert(msg->ref_queue);
+    assert(msg->queue_index < HD_RESULT_QUEUE_SIZE);
+
+    struct http_decoder_half_data *res_data =
+        msg->ref_queue->array[msg->queue_index].res_data;
+
+    return http_decoder_half_data_iter_header(res_data, hdr);
 }
 
 int http_message_get_request_raw_body(struct http_message *msg,
@@ -576,7 +645,13 @@ int http_message_get_request_raw_body(struct http_message *msg,
         return -1;
     }
 
-    return http_decoder_half_data_get_raw_body(msg->data, body);
+    assert(msg->ref_queue);
+    assert(msg->queue_index < HD_RESULT_QUEUE_SIZE);
+
+    struct http_decoder_half_data *req_data =
+        msg->ref_queue->array[msg->queue_index].req_data;
+
+    return http_decoder_half_data_get_raw_body(req_data, body);
 }
 
 int http_message_get_response_raw_body(struct http_message *msg,
@@ -587,7 +662,13 @@ int http_message_get_response_raw_body(struct http_message *msg,
         return -1;
     }
 
-    return http_decoder_half_data_get_raw_body(msg->data, body);
+    assert(msg->ref_queue);
+    assert(msg->queue_index < HD_RESULT_QUEUE_SIZE);
+
+    struct http_decoder_half_data *res_data =
+        msg->ref_queue->array[msg->queue_index].res_data;
+
+    return http_decoder_half_data_get_raw_body(res_data, body);
 }
 
 int http_message_get_request_decompress_body(struct http_message *msg,
@@ -598,7 +679,13 @@ int http_message_get_request_decompress_body(struct http_message *msg,
         return -1;
     }
 
-    return http_decoder_half_data_get_decompress_body(msg->data, body);
+    assert(msg->ref_queue);
+    assert(msg->queue_index < HD_RESULT_QUEUE_SIZE);
+
+    struct http_decoder_half_data *req_data =
+        msg->ref_queue->array[msg->queue_index].req_data;
+
+    return http_decoder_half_data_get_decompress_body(req_data, body);
 }
 
 int http_message_get_response_decompress_body(struct http_message *msg,
@@ -609,5 +696,11 @@ int http_message_get_response_decompress_body(struct http_message *msg,
         return -1;
     }
 
-    return http_decoder_half_data_get_decompress_body(msg->data, body);
+    assert(msg->ref_queue);
+    assert(msg->queue_index < HD_RESULT_QUEUE_SIZE);
+
+    struct http_decoder_half_data *res_data =
+        msg->ref_queue->array[msg->queue_index].res_data;
+
+    return http_decoder_half_data_get_decompress_body(res_data, body);
 }
\ No newline at end of file
diff --git a/src/http_decoder/http_decoder_half.c b/src/http_decoder/http_decoder_half.c
index cc13d8e..2a8126f 100644
--- a/src/http_decoder/http_decoder_half.c
+++ b/src/http_decoder/http_decoder_half.c
@@ -364,6 +364,7 @@ static int on_header_value(llhttp_t *http, const char *at, size_t length)
     return 0;
 }
 
+#define MAX_ENCODING_STR_LEN 8
 /* Information-only callbacks, return value is ignored */
 static int on_header_value_complete(llhttp_t *http)
 {
@@ -386,8 +387,12 @@ static int on_header_value_complete(llhttp_t *http)
 
         if (http_decoder_table_get_header(half->ref_data->table, &key,
                                           &http_hdr, 1) == 1) {
-            char encoding_str[16] = {0};
-            memcpy(encoding_str, http_hdr.val.str, http_hdr.val.str_len);
+            char encoding_str[MAX_ENCODING_STR_LEN + 1] = {0};
+            size_t str_len = http_hdr.val.str_len;
+            if (str_len > MAX_ENCODING_STR_LEN) {
+                str_len = MAX_ENCODING_STR_LEN;
+            }
+            memcpy(encoding_str, http_hdr.val.str, str_len);
             half->ref_data->content_encoding = http_content_encoding_str2int(encoding_str);
         }
     }
@@ -430,6 +435,9 @@ static int on_headers_complete(llhttp_t *http)
     struct http_decoder_half *half =
         container_of(http, struct http_decoder_half, parser);
     assert(half);
+    assert(half->ref_data);
+
+    http_decoder_table_set_header_complete(half->ref_data->table);
 
     if (half->parser.type == HTTP_REQUEST) {
         half->event = HTTP_EVENT_REQ_HDR_END;
@@ -595,19 +603,28 @@ void http_decoder_half_reinit(struct http_decoder_half *half, int topic_id,
 
 static void publish_message_for_parsed_header(struct http_decoder_half *half)
 {
-    if (http_decoder_table_has_parsed_header(half->ref_data->table) <= 0) {
+    if (0 == http_decoder_table_has_parsed_header(half->ref_data->table)) {
         return;
     }
 
     // publish complete kv-header message
     struct http_message *msg = NULL;
+    size_t queue_idx = 0;
+    struct http_decoder_result_queue *queue = half->http_ev_ctx->ref_queue;
+
     if (half->parser.type == HTTP_REQUEST) {
-        msg = http_message_new(HTTP_MESSAGE_REQ_HEADER, half->ref_data);
+        queue_idx = http_decoder_result_queue_req_index(queue);
+
+        msg = http_message_new(HTTP_MESSAGE_REQ_HEADER, queue, queue_idx);
+
         session_mq_publish_message(half->http_ev_ctx->ref_session,
                                    half->http_ev_ctx->topic_id, msg);
     } else {
         // http response
-        msg = http_message_new(HTTP_MESSAGE_RES_HEADER, half->ref_data);
+        queue_idx = http_decoder_result_queue_res_index(queue);
+
+        msg = http_message_new(HTTP_MESSAGE_RES_HEADER, queue, queue_idx);
+
         session_mq_publish_message(half->http_ev_ctx->ref_session,
                                    half->http_ev_ctx->topic_id, msg);
     }
@@ -671,16 +688,42 @@ int http_decoder_half_parse(struct http_decoder_half *half,
             http_decoder_table_cache(half->ref_data->table, HTTP_ITEM_VERSION);
         }
 
-        if (http_decoder_table_state(half->ref_data->table, HTTP_ITEM_HDRKEY)
-            == STRING_STATE_REFER) {
+        if (http_decoder_table_header_complete(half->ref_data->table)) {
+            http_decoder_table_reset_header_complete(half->ref_data->table);
+        } else {
             publish_message_for_parsed_header(half);
+        }
+
+        enum string_state hdr_key_state =
+            http_decoder_table_state(half->ref_data->table, HTTP_ITEM_HDRKEY);
+        enum string_state hdr_val_state =
+            http_decoder_table_state(half->ref_data->table, HTTP_ITEM_HDRVAL);
+
+        /*  Truncated in http header key 
+            For example http header k-v => User-Agent: Chrome
+            case1: 
+                packet1: User-     hdr_key_state == STRING_STATE_REFER         
+                packet2: Agent: Chrome
+
+            case2:
+                packet1: User-Agent: hdr_key_state == STRING_STATE_COMMIT
+                                     hdr_val_state == STRING_STATE_INIT                        
+                packet2: Chrome
+        */ 
+        if (hdr_key_state == STRING_STATE_REFER ||
+            (hdr_key_state == STRING_STATE_COMMIT && hdr_val_state == STRING_STATE_INIT)) {
             http_decoder_table_cache(half->ref_data->table, HTTP_ITEM_HDRKEY);
         }
 
+        /* Truncated in http header value 
+           For example http header k-v => User-Agent: Chrome
+           packet1: User-Agent: Ch   hdr_key_state == STRING_STATE_COMMIT
+                                     hdr_val_state == STRING_STATE_REFER                        
+
+           packet2: rome
+        */
         if (http_decoder_table_state(half->ref_data->table, HTTP_ITEM_HDRVAL)
             == STRING_STATE_REFER) {
-            publish_message_for_parsed_header(half);
-
             /* Header key should have been committed
                If it's not cached, cache it for next packet to use
             */
@@ -783,10 +826,12 @@ int http_decoder_half_data_get_response_line(struct http_decoder_half_data *data
 }
 
 int http_decoder_half_data_get_header(struct http_decoder_half_data *data,
-                                      struct hstring *key, struct http_header *hdr_array,
+                                      struct hstring *key,
+                                      struct http_header *hdr_array,
                                       size_t array_size)
 {
-    if (NULL == data) {
+    if (NULL == data || NULL == key ||
+        NULL == hdr_array || 0 == array_size) {
         return -1;
     }
 
@@ -803,6 +848,15 @@ int http_decoder_half_data_iter_header(struct http_decoder_half_data *data,
     return http_decoder_table_iter_header(data->table, header);
 }
 
+int http_decoder_half_data_has_parsed_header(struct http_decoder_half_data *data)
+{
+    if (NULL == data) {
+        return 0;
+    }
+
+    return http_decoder_table_has_parsed_header(data->table);
+}
+
 int http_decoder_half_data_get_raw_body(struct http_decoder_half_data *data,
                                         struct hstring *body)
 {
diff --git a/src/http_decoder/http_decoder_half.h b/src/http_decoder/http_decoder_half.h
index 99cc260..f77cbd1 100644
--- a/src/http_decoder/http_decoder_half.h
+++ b/src/http_decoder/http_decoder_half.h
@@ -89,6 +89,8 @@ int http_decoder_half_data_get_header(struct http_decoder_half_data *data,
 int http_decoder_half_data_iter_header(struct http_decoder_half_data *data,
                                        struct http_header *header);
 
+int http_decoder_half_data_has_parsed_header(struct http_decoder_half_data *data);
+
 int http_decoder_half_data_get_raw_body(struct http_decoder_half_data *data,
                                         struct hstring *body);
 
diff --git a/src/http_decoder/http_decoder_inc.h b/src/http_decoder/http_decoder_inc.h
index fd39d6e..21688da 100644
--- a/src/http_decoder/http_decoder_inc.h
+++ b/src/http_decoder/http_decoder_inc.h
@@ -16,8 +16,15 @@ extern "C"
 {
 #endif
 
+#include "http_decoder.h"
+#include "http_decoder_result_queue.h"
+
 struct http_message;
-struct http_message *http_message_new(enum http_message_type type, void *data);
+
+struct http_message *
+http_message_new(enum http_message_type type,
+                 struct http_decoder_result_queue *queue,
+                 int queue_index);
 
 #ifdef __cplusplus
 }
diff --git a/src/http_decoder/http_decoder_result_queue.c b/src/http_decoder/http_decoder_result_queue.c
index eb7b2d1..dd2a13a 100644
--- a/src/http_decoder/http_decoder_result_queue.c
+++ b/src/http_decoder/http_decoder_result_queue.c
@@ -72,6 +72,20 @@ void http_decoder_result_queue_inc_res_index(struct http_decoder_result_queue *q
     queue->res_index = queue->res_index % queue->queue_size;
 }
 
+size_t http_decoder_result_queue_req_index(struct http_decoder_result_queue *queue)
+{
+    assert(queue);
+
+    return queue->req_index;
+}
+
+size_t http_decoder_result_queue_res_index(struct http_decoder_result_queue *queue)
+{
+    assert(queue);
+
+    return queue->res_index;
+}
+
 int http_decoder_result_queue_push_req(struct http_decoder_result_queue *queue,
                                        struct http_decoder_half_data *req_data)
 {
diff --git a/src/http_decoder/http_decoder_result_queue.h b/src/http_decoder/http_decoder_result_queue.h
index eef68ba..7aa4790 100644
--- a/src/http_decoder/http_decoder_result_queue.h
+++ b/src/http_decoder/http_decoder_result_queue.h
@@ -42,6 +42,10 @@ void http_decoder_result_queue_inc_req_index(struct http_decoder_result_queue *q
 
 void http_decoder_result_queue_inc_res_index(struct http_decoder_result_queue *queue);
 
+size_t http_decoder_result_queue_req_index(struct http_decoder_result_queue *queue);
+
+size_t http_decoder_result_queue_res_index(struct http_decoder_result_queue *queue);
+
 struct http_decoder_half_data *
 http_decoder_result_queue_pop_req(struct http_decoder_result_queue *queue);
 
diff --git a/src/http_decoder/http_decoder_table.c b/src/http_decoder/http_decoder_table.c
index ac12296..ca077d5 100644
--- a/src/http_decoder/http_decoder_table.c
+++ b/src/http_decoder/http_decoder_table.c
@@ -18,13 +18,13 @@
 #include "http_decoder_string.h"
 #include "stellar/utils.h"
 
-#define MAX_HEADER_SIZE 16
-#define MAX_URI_CACHE_SIZE 1024
+#define INIT_HEADER_CNT 16
+#define MAX_URI_CACHE_SIZE 2048
 #define MAX_STATUS_CACHE_SIZE 32
 #define MAX_METHOD_CACHE_SIZE 8
 #define MAX_VERSION_CACHE_SIZE 4
-#define MAX_HEADER_KEY_CACHE_SIZE 128
-#define MAX_HEADER_VALUE_CACHE_SIZE 1024
+#define MAX_HEADER_KEY_CACHE_SIZE 4096
+#define MAX_HEADER_VALUE_CACHE_SIZE 4096
 
 struct http_decoder_header {
     struct http_decoder_string key;
@@ -38,7 +38,8 @@ struct http_decoder_table {
     struct http_decoder_string version;
     struct http_decoder_string body;
 
-    size_t header_size;
+    int header_complete; //flag for all headers parsed completely
+    size_t header_cnt;
     size_t header_index;
     size_t header_iter;
     struct http_decoder_header *headers;
@@ -58,7 +59,7 @@ static void http_decoder_table_init(struct http_decoder_table *table)
     http_decoder_string_init(&table->method, MAX_METHOD_CACHE_SIZE);
     http_decoder_string_init(&table->version, MAX_METHOD_CACHE_SIZE);
 
-    for (size_t i = 0; i < table->header_size; i++) {
+    for (size_t i = 0; i < table->header_cnt; i++) {
         header = &table->headers[i];
         http_decoder_string_init(&header->key, MAX_HEADER_KEY_CACHE_SIZE);
         http_decoder_string_init(&header->val, MAX_HEADER_VALUE_CACHE_SIZE);
@@ -72,8 +73,8 @@ struct http_decoder_table *http_decoder_table_new()
     struct http_decoder_table *table = CALLOC(struct http_decoder_table, 1);
     assert(table);
 
-    table->header_size = MAX_HEADER_SIZE;
-    table->headers = CALLOC(struct http_decoder_header, table->header_size);
+    table->header_cnt = INIT_HEADER_CNT;
+    table->headers = CALLOC(struct http_decoder_header, table->header_cnt);
 
     http_decoder_table_init(table);
 
@@ -107,7 +108,7 @@ void http_decoder_table_free(struct http_decoder_table *table)
     }
 
     if (table->headers != NULL) {
-        for (size_t i = 0; i < table->header_size; i++) {
+        for (size_t i = 0; i < table->header_cnt; i++) {
             if (table->headers[i].key.cache.str != NULL) {
                 FREE(table->headers[i].key.cache.str);
             }
@@ -148,12 +149,12 @@ http_decoder_table_state(struct http_decoder_table *table, enum http_item type)
         state = http_decoder_string_state(&table->version);
         break;
     case HTTP_ITEM_HDRKEY:
-        assert(table->header_index < table->header_size);
+        assert(table->header_index < table->header_cnt);
         header = &table->headers[table->header_index];
         state = http_decoder_string_state(&header->key);
         break;
     case HTTP_ITEM_HDRVAL:
-        assert(table->header_index < table->header_size);
+        assert(table->header_index < table->header_cnt);
         header = &table->headers[table->header_index];
         state = http_decoder_string_state(&header->val);
         break;
@@ -192,12 +193,12 @@ void http_decoder_table_refer(struct http_decoder_table *table, enum http_item t
         http_decoder_string_refer(&table->version, at, len);
         break;
     case HTTP_ITEM_HDRKEY:
-        assert(table->header_index < table->header_size);
+        assert(table->header_index < table->header_cnt);
         header = &table->headers[table->header_index];
         http_decoder_string_refer(&header->key, at, len);
         break;
     case HTTP_ITEM_HDRVAL:
-        assert(table->header_index < table->header_size);
+        assert(table->header_index < table->header_cnt);
         header = &table->headers[table->header_index];
         http_decoder_string_refer(&header->val, at, len);
         break;
@@ -233,12 +234,12 @@ void http_decoder_table_cache(struct http_decoder_table *table, enum http_item t
         http_decoder_string_cache(&table->version);
         break;
     case HTTP_ITEM_HDRKEY:
-        assert(table->header_index < table->header_size);
+        assert(table->header_index < table->header_cnt);
         header = &table->headers[table->header_index];
         http_decoder_string_cache(&header->key);
         break;
     case HTTP_ITEM_HDRVAL:
-        assert(table->header_index < table->header_size);
+        assert(table->header_index < table->header_cnt);
         header = &table->headers[table->header_index];
         http_decoder_string_cache(&header->val);
         break;
@@ -274,7 +275,7 @@ void http_decoder_table_commit(struct http_decoder_table *table, enum http_item
         http_decoder_string_commit(&table->version);
         break;
     case HTTP_ITEM_HDRKEY:
-        assert(table->header_index < table->header_size);
+        assert(table->header_index < table->header_cnt);
         header = &table->headers[table->header_index];
         http_decoder_string_commit(&header->key);
         break;
@@ -282,13 +283,15 @@ void http_decoder_table_commit(struct http_decoder_table *table, enum http_item
         header = &table->headers[table->header_index];
         http_decoder_string_commit(&header->val);
         // inc index
-        if ((table->header_index + 1) >= table->header_size) {
+        if ((table->header_index + 1) >= table->header_cnt) {
             table->headers = REALLOC(struct http_decoder_header, table->headers,
-                                     table->header_size * 2);
-            table->header_size *= 2;
-            for (size_t i = table->header_index + 1; i < table->header_size; i++) {
+                                     table->header_cnt * 2);
+            table->header_cnt *= 2;
+            for (size_t i = table->header_index + 1; i < table->header_cnt; i++) {
                 header = &table->headers[i];
                 memset(header, 0, sizeof(struct http_decoder_header));
+                http_decoder_string_init(&header->key, MAX_HEADER_KEY_CACHE_SIZE);
+                http_decoder_string_init(&header->val, MAX_HEADER_VALUE_CACHE_SIZE);
             }
         }
         table->header_index++;
@@ -375,7 +378,7 @@ void http_decoder_table_dump(struct http_decoder_table *table)
     http_decoder_string_dump(&table->version, "version");
     http_decoder_string_dump(&table->body, "body");
 
-    for (size_t i = 0; i < table->header_size; i++) {
+    for (size_t i = 0; i < table->header_cnt; i++) {
         struct http_decoder_header *header = &table->headers[i];
         if (NULL == header) {
             continue;
@@ -431,21 +434,6 @@ int http_decoder_table_get_body(struct http_decoder_table *table, struct hstring
     return http_decoder_string_get(&table->body, out);
 }
 
-int http_decoder_table_has_parsed_header(struct http_decoder_table *table)
-{
-    if (NULL == table) {
-        return 0;
-    }
-
-    struct http_decoder_header *tmp_header = &table->headers[table->header_iter];
-    if (http_decoder_string_state(&tmp_header->key) == STRING_STATE_COMMIT &&
-        http_decoder_string_state(&tmp_header->val) == STRING_STATE_COMMIT) {
-        return 1;
-    }
-
-    return 0;
-}
-
 int http_decoder_table_get_header(struct http_decoder_table *table, struct hstring *key,
                                   struct http_header *hdr_array, size_t array_size)
 {
@@ -454,7 +442,7 @@ int http_decoder_table_get_header(struct http_decoder_table *table, struct hstri
     }
 
     int header_cnt = 0;
-    for (int i = 0; i < table->header_size && header_cnt < array_size; i++) {
+    for (size_t i = 0; i < table->header_cnt && header_cnt < array_size; i++) {
         struct http_decoder_header *tmp_header = &table->headers[i];
         if (tmp_header->key.commit.str_len != key->str_len) {
             continue;
@@ -465,8 +453,8 @@ int http_decoder_table_get_header(struct http_decoder_table *table, struct hstri
             struct hstring tmp_key;
             http_decoder_string_get(&tmp_header->key, &tmp_key);
 
-            if (tmp_key.str_len == key->str_len
-                && (0 == strncasecmp(tmp_key.str, key->str, key->str_len))) {
+            if (tmp_key.str_len == key->str_len &&
+                (0 == strncasecmp(tmp_key.str, key->str, key->str_len))) {
                 http_decoder_string_get(&tmp_header->key, &hdr_array[header_cnt].key);
                 http_decoder_string_get(&tmp_header->val, &hdr_array[header_cnt].val);
                 header_cnt++;
@@ -484,7 +472,7 @@ int http_decoder_table_iter_header(struct http_decoder_table *table,
         return -1;
     }
 
-    if (table->header_iter >= table->header_size) {
+    if (table->header_iter >= table->header_cnt) {
         return 0;
     }
 
@@ -508,4 +496,46 @@ int http_decoder_table_iter_header(struct http_decoder_table *table,
     hdr->val.str_len = 0;
 
     return 0;
+}
+
+int http_decoder_table_has_parsed_header(struct http_decoder_table *table)
+{
+    if (NULL == table || (table->header_iter == table->header_index)) {
+        return 0;
+    }
+
+    struct http_decoder_header *tmp_header = &table->headers[table->header_iter];
+    if (http_decoder_string_state(&tmp_header->key) == STRING_STATE_COMMIT &&
+        http_decoder_string_state(&tmp_header->val) == STRING_STATE_COMMIT) {
+        return 1;
+    }
+
+    return 0;
+}
+
+int http_decoder_table_header_complete(struct http_decoder_table *table)
+{
+    if (NULL == table) {
+        return -1;
+    }
+
+    return table->header_complete;
+}
+
+void http_decoder_table_set_header_complete(struct http_decoder_table *table)
+{
+    if (NULL == table) {
+        return;
+    }
+
+    table->header_complete = 1;
+}
+
+void http_decoder_table_reset_header_complete(struct http_decoder_table *table)
+{
+    if (NULL == table) {
+        return;
+    }
+
+    table->header_complete = 0;
 }
\ No newline at end of file
diff --git a/src/http_decoder/http_decoder_table.h b/src/http_decoder/http_decoder_table.h
index a600110..f3ed2d4 100644
--- a/src/http_decoder/http_decoder_table.h
+++ b/src/http_decoder/http_decoder_table.h
@@ -62,8 +62,6 @@ int http_decoder_table_get_version(struct http_decoder_table *table, struct hstr
 
 int http_decoder_table_get_body(struct http_decoder_table *table, struct hstring *out);
 
-int http_decoder_table_has_parsed_header(struct http_decoder_table *table);
-
 int http_decoder_table_get_header(struct http_decoder_table *table,
                                   struct hstring *key,
                                   struct http_header *hdr_array,
@@ -72,6 +70,27 @@ int http_decoder_table_get_header(struct http_decoder_table *table,
 int http_decoder_table_iter_header(struct http_decoder_table *table,
                                    struct http_header *hdr);
 
+/**
+ * @brief Is there a parsed header
+ * 
+ * @retval yes(1) no(0)
+*/
+int http_decoder_table_has_parsed_header(struct http_decoder_table *table);
+
+/**
+ * @brief If headers have been parsed completely
+ *
+ * @retval yes(1) no(0)
+ */
+int http_decoder_table_header_complete(struct http_decoder_table *table);
+
+/**
+ * @brief set flag for headers parsed completely
+*/
+void http_decoder_table_set_header_complete(struct http_decoder_table *table);
+
+void http_decoder_table_reset_header_complete(struct http_decoder_table *table);
+
 #ifdef __cplusplus
 }
 #endif