Adding upstream version 1.44.3.upstream/1.44.3upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

23 files changed, 11302 insertions, 0 deletions

diff --git a/fluent-bit/lib/monkey/mk_server/CMakeLists.txt b/fluent-bit/lib/monkey/mk_server/CMakeLists.txt
new file mode 100644
index 00000000..457525e6
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/CMakeLists.txt
@@ -0,0 +1,57 @@
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+set(src
+  monkey.c
+  mk_lib.c
+  mk_fifo.c
+  mk_mimetype.c
+  mk_vhost.c
+  mk_header.c
+  mk_config.c
+  mk_user.c
+  mk_utils.c
+  mk_stream.c
+  mk_scheduler.c
+  mk_http.c
+  mk_http_parser.c
+  mk_http_thread.c
+  mk_socket.c
+  mk_net.c
+  mk_clock.c
+  mk_cache.c
+  mk_server.c
+  mk_kernel.c
+  mk_plugin.c
+  )
+
+if(MK_HTTP2)
+  set(src
+    ${src}
+    "mk_http2.c"
+    )
+endif()
+
+# Always build a static library, thats our core :)
+add_library(monkey-core-static STATIC ${src})
+set_target_properties(monkey-core-static PROPERTIES OUTPUT_NAME monkey)
+target_link_libraries(monkey-core-static mk_core ${CMAKE_THREAD_LIBS_INIT} ${STATIC_PLUGINS_LIBS} ${CMAKE_DL_LIBS} rbtree co)
+
+message(STATUS "LINKING ${STATIC_PLUGINS_LIBS}")
+
+if(NOT DEFINED MK_HAVE_REGEX)
+ target_link_libraries(monkey-core-static regex)
+endif()
+
+# Linux Kqueue emulation
+if(MK_HAVE_LINUX_KQUEUE)
+  target_link_libraries(monkey-core-static kqueue)
+endif()
+
+# FreeBSD backtrace
+if (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
+  target_link_libraries(monkey-core-static execinfo)
+endif()
+
+if (CMAKE_SYSTEM_NAME MATCHES "SunOS")
+  target_link_libraries(monkey-core-static socket nsl)
+endif()
diff --git a/fluent-bit/lib/monkey/mk_server/mk_cache.c b/fluent-bit/lib/monkey/mk_server/mk_cache.c
new file mode 100644
index 00000000..c678afa8
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_cache.c
@@ -0,0 +1,81 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#define _GNU_SOURCE
+
+#include <monkey/mk_core.h>
+#include <monkey/mk_cache.h>
+#include <monkey/mk_cache_tls.h>
+#include <monkey/mk_config.h>
+#include <monkey/mk_utils.h>
+#include <monkey/mk_vhost.h>
+#include <monkey/mk_tls.h>
+
+/* This function is called when a thread is created */
+void mk_cache_worker_init()
+{
+    char *cache_error;
+    mk_ptr_t *p_tmp;
+
+    /* Cache header request -> last modified */
+    p_tmp = mk_mem_alloc_z(sizeof(mk_ptr_t));
+    p_tmp->data = mk_mem_alloc_z(32);
+    p_tmp->len = -1;
+    MK_TLS_SET(mk_tls_cache_header_lm, p_tmp);
+
+    /* Cache header request -> content length */
+    p_tmp = mk_mem_alloc_z(sizeof(mk_ptr_t));
+    p_tmp->data = mk_mem_alloc_z(MK_UTILS_INT2MKP_BUFFER_LEN);
+    p_tmp->len = -1;
+    MK_TLS_SET(mk_tls_cache_header_cl, p_tmp);
+
+    /* Cache gmtime buffer */
+    MK_TLS_SET(mk_tls_cache_gmtime, mk_mem_alloc(sizeof(struct tm)));
+
+    /* Cache the most used text representations of utime2gmt */
+    MK_TLS_SET(mk_tls_cache_gmtext,
+                  mk_mem_alloc_z(sizeof(struct mk_gmt_cache) * MK_GMT_CACHES));
+
+    /* Cache buffer for strerror_r(2) */
+    cache_error = mk_mem_alloc(MK_UTILS_ERROR_SIZE);
+    pthread_setspecific(mk_utils_error_key, (void *) cache_error);
+}
+
+void mk_cache_worker_exit()
+{
+    char *cache_error;
+
+    /* Cache header request -> last modified */
+    mk_ptr_free(MK_TLS_GET(mk_tls_cache_header_lm));
+    mk_mem_free(MK_TLS_GET(mk_tls_cache_header_lm));
+
+    /* Cache header request -> content length */
+    mk_ptr_free(MK_TLS_GET(mk_tls_cache_header_cl));
+    mk_mem_free(MK_TLS_GET(mk_tls_cache_header_cl));
+
+    /* Cache gmtime buffer */
+    mk_mem_free(MK_TLS_GET(mk_tls_cache_gmtime));
+
+    /* Cache the most used text representations of utime2gmt */
+    mk_mem_free(MK_TLS_GET(mk_tls_cache_gmtext));
+
+    /* Cache buffer for strerror_r(2) */
+    cache_error = pthread_getspecific(mk_utils_error_key);
+    mk_mem_free(cache_error);
+}
diff --git a/fluent-bit/lib/monkey/mk_server/mk_clock.c b/fluent-bit/lib/monkey/mk_server/mk_clock.c
new file mode 100644
index 00000000..3a45512f
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_clock.c
@@ -0,0 +1,171 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include <mk_core/mk_pthread.h>
+#include <mk_core/mk_unistd.h>
+
+#include <monkey/mk_core.h>
+#include <monkey/mk_config.h>
+#include <monkey/mk_clock.h>
+#include <monkey/mk_utils.h>
+#include <monkey/mk_tls.h>
+
+#ifdef _WIN32
+static struct tm* localtime_r(const time_t* timep, struct tm* result)
+{
+    localtime_s(result, timep);
+
+    return result;
+}
+
+static struct tm* gmtime_r(const time_t* timep, struct tm* result)
+{
+    gmtime_s(result, timep);
+
+    return result;
+}
+#endif
+
+
+/*
+ * The mk_ptr_ts have two buffers for avoid in half-way access from
+ * another thread while a buffer is being modified. The function below returns
+ * one of two buffers to work with.
+ */
+static inline char *_next_buffer(mk_ptr_t *pointer, char **buffers)
+{
+    if (pointer->data == buffers[0]) {
+        return buffers[1];
+    }
+    else {
+        return buffers[0];
+    }
+}
+
+static void mk_clock_log_set_time(time_t utime, struct mk_server *server)
+{
+    char *time_string;
+    struct tm result;
+
+    time_string = _next_buffer(&server->clock_context->log_current_time, server->clock_context->log_time_buffers);
+    server->clock_context->log_current_utime = utime;
+
+    strftime(time_string, LOG_TIME_BUFFER_SIZE, "[%d/%b/%G %T %z]",
+             localtime_r(&utime, &result));
+
+    server->clock_context->log_current_time.data = time_string;
+}
+
+static void mk_clock_headers_preset(time_t utime, struct mk_server *server)
+{
+    int len1;
+    int len2;
+    struct tm *gmt_tm;
+    struct tm result;
+    char *buffer;
+
+    buffer = _next_buffer(&server->clock_context->headers_preset,
+                          server->clock_context->header_time_buffers);
+
+    gmt_tm = gmtime_r(&utime, &result);
+
+    len1 = snprintf(buffer,
+                    HEADER_TIME_BUFFER_SIZE,
+                    "%s",
+                    server->server_signature_header);
+
+    len2 = strftime(buffer + len1,
+                    HEADER_PRESET_SIZE - len1,
+                    MK_CLOCK_GMT_DATEFORMAT,
+                    gmt_tm);
+
+    server->clock_context->headers_preset.data = buffer;
+    server->clock_context->headers_preset.len  = len1 + len2;
+}
+
+void *mk_clock_worker_init(void *data)
+{
+    time_t cur_time;
+    struct mk_server *server = data;
+
+    mk_utils_worker_rename("monkey: clock");
+    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+
+    server->clock_context->mk_clock_tid = pthread_self();
+
+    while (1) {
+        cur_time = time(NULL);
+
+        if(cur_time != ((time_t)-1)) {
+            mk_clock_log_set_time(cur_time, server);
+            mk_clock_headers_preset(cur_time, server);
+        }
+        sleep(1);
+    }
+
+    return NULL;
+}
+
+void mk_clock_exit(struct mk_server *server)
+{
+    pthread_cancel(server->clock_context->mk_clock_tid);
+    pthread_join(server->clock_context->mk_clock_tid, NULL);
+
+    mk_mem_free(server->clock_context->header_time_buffers[0]);
+    mk_mem_free(server->clock_context->header_time_buffers[1]);
+    mk_mem_free(server->clock_context->log_time_buffers[0]);
+    mk_mem_free(server->clock_context->log_time_buffers[1]);
+
+    mk_mem_free(server->clock_context);
+}
+
+/* This function must be called before any threads are created */
+void mk_clock_sequential_init(struct mk_server *server)
+{
+    server->clock_context = mk_mem_alloc_z(sizeof(struct mk_clock_context));
+
+    if (server->clock_context == NULL) {
+        return;
+    }
+
+    /* Time when monkey was started */
+    server->clock_context->monkey_init_time = time(NULL);
+
+    server->clock_context->log_current_time.len = LOG_TIME_BUFFER_SIZE - 2;
+    server->clock_context->headers_preset.len = HEADER_PRESET_SIZE - 1;
+
+    server->clock_context->header_time_buffers[0] = mk_mem_alloc_z(HEADER_PRESET_SIZE);
+    server->clock_context->header_time_buffers[1] = mk_mem_alloc_z(HEADER_PRESET_SIZE);
+
+    server->clock_context->log_time_buffers[0] = mk_mem_alloc_z(LOG_TIME_BUFFER_SIZE);
+    server->clock_context->log_time_buffers[1] = mk_mem_alloc_z(LOG_TIME_BUFFER_SIZE);
+
+    /* Set the time once */
+    time_t cur_time = time(NULL);
+
+    if (cur_time != ((time_t)-1)) {
+        mk_clock_log_set_time(cur_time, server);
+        mk_clock_headers_preset(cur_time, server);
+    }
+}
diff --git a/fluent-bit/lib/monkey/mk_server/mk_config.c b/fluent-bit/lib/monkey/mk_server/mk_config.c
new file mode 100644
index 00000000..f8dc9c00
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_config.c
@@ -0,0 +1,636 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <monkey/monkey.h>
+#include <monkey/mk_kernel.h>
+#include <monkey/mk_config.h>
+#include <monkey/mk_utils.h>
+#include <monkey/mk_mimetype.h>
+#include <monkey/mk_info.h>
+#include <monkey/mk_core.h>
+#include <monkey/mk_server.h>
+#include <monkey/mk_plugin.h>
+#include <monkey/mk_vhost.h>
+#include <monkey/mk_mimetype.h>
+#include <monkey/mk_info.h>
+
+#include <ctype.h>
+#include <limits.h>
+#include <mk_core/mk_dirent.h>
+#include <sys/stat.h>
+
+struct mk_server_config *mk_config;
+
+static int mk_config_key_have(struct mk_list *list, const char *value)
+{
+    struct mk_list *head;
+    struct mk_string_line *entry;
+
+    mk_list_foreach(head, list) {
+        entry = mk_list_entry(head, struct mk_string_line, _head);
+        if (strcasecmp(entry->val, value) == 0) {
+            return MK_TRUE;
+        }
+    }
+    return MK_FALSE;
+}
+
+void mk_config_listeners_free(struct mk_server *server)
+{
+    struct mk_list *tmp;
+    struct mk_list *head;
+    struct mk_config_listener *l;
+
+    mk_list_foreach_safe(head, tmp, &server->listeners) {
+        l = mk_list_entry(head, struct mk_config_listener, _head);
+        mk_list_del(&l->_head);
+        mk_mem_free(l->address);
+        mk_mem_free(l->port);
+        mk_mem_free(l);
+    }
+}
+
+void mk_config_free_all(struct mk_server *server)
+{
+    mk_vhost_free_all(server);
+    mk_mimetype_free_all(server);
+
+    if (server->config) {
+        mk_rconf_free(server->config);
+    }
+
+    if (server->path_conf_root) {
+        mk_mem_free(server->path_conf_root);
+    }
+
+    if (server->path_conf_pidfile) {
+        mk_mem_free(server->path_conf_pidfile);
+    }
+
+    if (server->conf_user_pub) {
+        mk_mem_free(server->conf_user_pub);
+    }
+
+    /* free config->index_files */
+    if (server->index_files) {
+        mk_string_split_free(server->index_files);
+    }
+
+    if (server->user) {
+        mk_mem_free(server->user);
+    }
+
+    if (server->transport_layer) {
+        mk_mem_free(server->transport_layer);
+    }
+
+    mk_config_listeners_free(server);
+
+    mk_ptr_free(&server->server_software);
+    mk_mem_free(server);
+}
+
+/* Print a specific error */
+static void mk_config_print_error_msg(char *variable, char *path)
+{
+    mk_err("[config] %s at %s has an invalid value",
+           variable, path);
+    mk_mem_free(path);
+    exit(EXIT_FAILURE);
+}
+
+/*
+ * Check if at least one of the Listen interfaces are being used by another
+ * process.
+ */
+int mk_config_listen_check_busy(struct mk_server *server)
+{
+    int fd;
+    struct mk_list *head;
+    struct mk_plugin *p;
+    struct mk_config_listener *listen;
+
+    p = mk_plugin_cap(MK_CAP_SOCK_PLAIN, server);
+    if (!p) {
+        mk_warn("Listen check: consider build monkey with basic socket handling!");
+        return MK_FALSE;
+    }
+
+    mk_list_foreach(head, &server->listeners) {
+        listen = mk_list_entry(head, struct mk_config_listener, _head);
+
+        fd = mk_socket_connect(listen->address, atol(listen->port), MK_FALSE);
+        if (fd != -1) {
+            close(fd);
+            return MK_TRUE;
+        }
+    }
+
+    return MK_FALSE;
+}
+
+int mk_config_listen_parse(char *value, struct mk_server *server)
+{
+    int ret = -1;
+    int flags = 0;
+    long port_num;
+    char *address = NULL;
+    char *port = NULL;
+    char *divider;
+    struct mk_list *list = NULL;
+    struct mk_string_line *listener;
+
+    list = mk_string_split_line(value);
+    if (!list) {
+        goto error;
+    }
+
+    if (mk_list_is_empty(list) == 0) {
+        goto error;
+    }
+
+    /* Parse the listener interface */
+    listener = mk_list_entry_first(list, struct mk_string_line, _head);
+    if (listener->val[0] == '[') {
+        /* IPv6 address */
+        divider = strchr(listener->val, ']');
+        if (divider == NULL) {
+            mk_err("[config] Expected closing ']' in IPv6 address.");
+            goto error;
+        }
+        if (divider[1] != ':' || divider[2] == '\0') {
+            mk_err("[config] Expected ':port' after IPv6 address.");
+            goto error;
+        }
+
+        address = mk_string_copy_substr(listener->val + 1, 0,
+                                        divider - listener->val - 1);
+        port = mk_string_dup(divider + 2);
+    }
+    else if (strchr(listener->val, ':') != NULL) {
+        /* IPv4 address */
+        divider = strrchr(listener->val, ':');
+        if (divider == NULL || divider[1] == '\0') {
+            mk_err("[config] Expected ':port' after IPv4 address.");
+            goto error;
+        }
+
+        address = mk_string_copy_substr(listener->val, 0,
+                                        divider - listener->val);
+        port = mk_string_dup(divider + 1);
+    }
+    else {
+        /* Port only */
+        address = NULL;
+        port = mk_string_dup(listener->val);
+    }
+
+    errno = 0;
+    port_num = strtol(port, NULL, 10);
+    if (errno != 0 || port_num == LONG_MAX || port_num == LONG_MIN) {
+        mk_warn("Using defaults, could not understand \"Listen %s\"",
+                listener->val);
+        port = NULL;
+    }
+
+    /* Check extra properties of the listener */
+    flags = MK_CAP_HTTP;
+    if (mk_config_key_have(list, "!http")) {
+        flags |= ~MK_CAP_HTTP;
+    }
+
+#ifdef MK_HAVE_HTTP2
+    if (mk_config_key_have(list, "h2")) {
+        flags |= (MK_CAP_HTTP2 | MK_CAP_SOCK_TLS);
+    }
+
+    if (mk_config_key_have(list, "h2c")) {
+        flags |= MK_CAP_HTTP2;
+    }
+#endif
+
+    if (mk_config_key_have(list, "tls")) {
+        flags |= MK_CAP_SOCK_TLS;
+    }
+
+    /* register the new listener */
+    mk_config_listener_add(address, port, flags, server);
+    mk_string_split_free(list);
+    list = NULL;
+    ret = 0;
+
+error:
+    if (address) {
+        mk_mem_free(address);
+    }
+    if (port) {
+        mk_mem_free(port);
+    }
+    if (list) {
+        mk_string_split_free(list);
+    }
+
+    return ret;
+}
+
+static int mk_config_listen_read(struct mk_rconf_section *section,
+                                 struct mk_server *server)
+{
+    int ret;
+    struct mk_list *cur;
+    struct mk_rconf_entry *entry;
+
+    mk_list_foreach(cur, &section->entries) {
+        entry = mk_list_entry(cur, struct mk_rconf_entry, _head);
+        if (strcasecmp(entry->key, "Listen")) {
+            continue;
+        }
+
+        ret = mk_config_listen_parse(entry->val, server);
+        if (ret != 0) {
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+/* Read configuration files */
+static int mk_config_read_files(char *path_conf, char *file_conf,
+                                struct mk_server *server)
+{
+    unsigned long len;
+    char *tmp = NULL;
+    struct stat checkdir;
+    struct mk_rconf *cnf;
+    struct mk_rconf_section *section;
+
+    if (!path_conf) {
+        return -1;
+    }
+
+    if (!file_conf) {
+        file_conf = "monkey.conf";
+    }
+
+    server->path_conf_root = mk_string_dup(path_conf);
+
+    if (stat(server->path_conf_root, &checkdir) == -1) {
+        mk_err("ERROR: Cannot find/open '%s'", server->path_conf_root);
+        return -1;
+    }
+
+    mk_string_build(&tmp, &len, "%s/%s", path_conf, file_conf);
+    cnf = mk_rconf_open(tmp);
+    if (!cnf) {
+        mk_mem_free(tmp);
+        mk_err("Cannot read '%s'", server->conf_main);
+        return -1;
+    }
+    section = mk_rconf_section_get(cnf, "SERVER");
+    if (!section) {
+        mk_err("ERROR: No 'SERVER' section defined");
+        return -1;
+    }
+
+    /* Map source configuration */
+    server->config = cnf;
+
+    /* Listen */
+    if (!server->port_override) {
+        /* Process each Listen entry */
+        if (mk_config_listen_read(section, server)) {
+            mk_err("[config] Failed to read listen sections.");
+        }
+        if (mk_list_is_empty(&server->listeners) == 0) {
+            mk_warn("[config] No valid Listen entries found, set default");
+            mk_config_listener_add(NULL, NULL, MK_CAP_HTTP, server);
+        }
+    }
+    else {
+        mk_config_listener_add(NULL, server->port_override,
+                               MK_CAP_HTTP, server);
+    }
+
+    /* Number of thread workers */
+    if (server->workers == -1) {
+        server->workers = (size_t) mk_rconf_section_get_key(section,
+                                                               "Workers",
+                                                               MK_RCONF_NUM);
+    }
+
+    if (server->workers < 1) {
+        server->workers = mk_utils_get_system_core_count();
+
+        if (server->workers < 1) {
+            mk_config_print_error_msg("Workers", tmp);
+        }
+    }
+
+    /* Timeout */
+    server->timeout = (size_t) mk_rconf_section_get_key(section,
+                                                           "Timeout", MK_RCONF_NUM);
+    if (server->timeout < 1) {
+        mk_config_print_error_msg("Timeout", tmp);
+    }
+
+    /* KeepAlive */
+    server->keep_alive = (size_t) mk_rconf_section_get_key(section,
+                                                              "KeepAlive",
+                                                              MK_RCONF_BOOL);
+    if (server->keep_alive == MK_ERROR) {
+        mk_config_print_error_msg("KeepAlive", tmp);
+    }
+
+    /* MaxKeepAliveRequest */
+    server->max_keep_alive_request = (size_t)
+        mk_rconf_section_get_key(section,
+                                 "MaxKeepAliveRequest",
+                                 MK_RCONF_NUM);
+
+    if (server->max_keep_alive_request == 0) {
+        mk_config_print_error_msg("MaxKeepAliveRequest", tmp);
+    }
+
+    /* KeepAliveTimeout */
+    server->keep_alive_timeout = (size_t) mk_rconf_section_get_key(section,
+                                                                      "KeepAliveTimeout",
+                                                                      MK_RCONF_NUM);
+    if (server->keep_alive_timeout == 0) {
+        mk_config_print_error_msg("KeepAliveTimeout", tmp);
+    }
+
+    /* Pid File */
+    if (!server->path_conf_pidfile) {
+        server->path_conf_pidfile = mk_rconf_section_get_key(section,
+                                                                "PidFile",
+                                                                MK_RCONF_STR);
+    }
+
+    /* Home user's directory /~ */
+    server->conf_user_pub = mk_rconf_section_get_key(section,
+                                                        "UserDir",
+                                                        MK_RCONF_STR);
+
+    /* Index files */
+    server->index_files = mk_rconf_section_get_key(section,
+                                                      "Indexfile", MK_RCONF_LIST);
+
+    /* HideVersion Variable */
+    server->hideversion = (size_t) mk_rconf_section_get_key(section,
+                                                         "HideVersion",
+                                                         MK_RCONF_BOOL);
+    if (server->hideversion == MK_ERROR) {
+        mk_config_print_error_msg("HideVersion", tmp);
+    }
+
+    /* User Variable */
+    server->user = mk_rconf_section_get_key(section, "User", MK_RCONF_STR);
+
+    /* Resume */
+    server->resume = (size_t) mk_rconf_section_get_key(section,
+                                                          "Resume", MK_RCONF_BOOL);
+    if (server->resume == MK_ERROR) {
+        mk_config_print_error_msg("Resume", tmp);
+    }
+
+    /* Max Request Size */
+    server->max_request_size = (size_t) mk_rconf_section_get_key(section,
+                                                              "MaxRequestSize",
+                                                              MK_RCONF_NUM);
+    if (server->max_request_size <= 0) {
+        mk_config_print_error_msg("MaxRequestSize", tmp);
+    }
+    else {
+        server->max_request_size *= 1024;
+    }
+
+    /* Symbolic Links */
+    server->symlink = (size_t) mk_rconf_section_get_key(section,
+                                                     "SymLink", MK_RCONF_BOOL);
+    if (server->symlink == MK_ERROR) {
+        mk_config_print_error_msg("SymLink", tmp);
+    }
+
+    /* Transport Layer plugin */
+    if (!server->transport_layer) {
+        server->transport_layer = mk_rconf_section_get_key(section,
+                                                              "TransportLayer",
+                                                              MK_RCONF_STR);
+    }
+
+    /* Default Mimetype */
+    mk_mem_free(tmp);
+    tmp = mk_rconf_section_get_key(section, "DefaultMimeType", MK_RCONF_STR);
+    if (tmp) {
+        mk_string_build(&server->mimetype_default_str, &len, "%s\r\n", tmp);
+    }
+
+    /* File Descriptor Table (FDT) */
+    server->fdt = (size_t) mk_rconf_section_get_key(section,
+                                                    "FDT",
+                                                    MK_RCONF_BOOL);
+
+    /* FIXME: Overcapacity not ready */
+    server->fd_limit = (size_t) mk_rconf_section_get_key(section,
+                                                           "FDLimit",
+                                                           MK_RCONF_NUM);
+    /* Get each worker clients capacity based on FDs system limits */
+    server->server_capacity = mk_server_capacity(server);
+
+
+    if (!server->one_shot) {
+        mk_vhost_init(path_conf, server);
+    }
+    else {
+        mk_vhost_set_single(server->one_shot, server);
+    }
+
+    mk_mem_free(tmp);
+    return 0;
+}
+
+void mk_config_signature(struct mk_server *server)
+{
+    unsigned long len;
+
+    /* Server Signature */
+    if (server->hideversion == MK_FALSE) {
+        snprintf(server->server_signature,
+                 sizeof(server->server_signature) - 1,
+                 "Monkey/%s", MK_VERSION_STR);
+    }
+    else {
+        snprintf(server->server_signature,
+                 sizeof(server->server_signature) - 1,
+                 "Monkey");
+    }
+    len = snprintf(server->server_signature_header,
+                   sizeof(server->server_signature_header) - 1,
+                   "Server: %s\r\n", server->server_signature);
+    server->server_signature_header_len = len;
+}
+
+/* read main configuration from monkey.conf */
+void mk_config_start_configure(struct mk_server *server)
+{
+    int ret;
+    unsigned long len;
+
+    ret = mk_config_read_files(server->path_conf_root,
+                               server->conf_main, server);
+    if (ret != 0) {
+        return;
+    }
+
+    /* Load mimes */
+    mk_mimetype_read_config(server);
+
+    mk_ptr_reset(&server->server_software);
+
+    /* Basic server information */
+    if (server->hideversion == MK_FALSE) {
+        mk_string_build(&server->server_software.data,
+                        &len, "Monkey/%s (%s)", MK_VERSION_STR, MK_BUILD_OS);
+        server->server_software.len = len;
+    }
+    else {
+        mk_string_build(&server->server_software.data, &len, "Monkey Server");
+        server->server_software.len = len;
+    }
+}
+
+/* Register a new listener into the main configuration */
+struct mk_config_listener *mk_config_listener_add(char *address,
+                                                  char *port, int flags,
+                                                  struct mk_server *server)
+{
+    struct mk_list *head;
+    struct mk_config_listener *check;
+    struct mk_config_listener *listen = NULL;
+
+    listen = mk_mem_alloc(sizeof(struct mk_config_listener));
+    if (!listen) {
+        mk_err("[listen_add] malloc() failed");
+        return NULL;
+    }
+
+    if (!address) {
+        listen->address = mk_string_dup(MK_DEFAULT_LISTEN_ADDR);
+    }
+    else {
+        listen->address = mk_string_dup(address);
+    }
+
+    /* Set the port */
+    if (!port) {
+        mk_err("[listen_add] TCP port not defined");
+        exit(EXIT_FAILURE);
+    }
+
+    listen->port = mk_string_dup(port);
+    listen->flags = flags;
+
+    /* Before to add a new listener, lets make sure it's not a duplicated */
+    mk_list_foreach(head, &server->listeners) {
+        check = mk_list_entry(head, struct mk_config_listener, _head);
+        if (strcmp(listen->address, check->address) == 0 &&
+            strcmp(listen->port, check->port) == 0) {
+            mk_warn("Listener: duplicated %s:%s, skip.",
+                    listen->address, listen->port);
+
+            /* free resources */
+            mk_mem_free(listen->address);
+            mk_mem_free(listen->port);
+            mk_mem_free(listen);
+            return NULL;
+        }
+    }
+
+    mk_list_add(&listen->_head, &server->listeners);
+    return listen;
+}
+
+void mk_config_set_init_values(struct mk_server *server)
+{
+    /* Init values */
+    server->is_seteuid = MK_FALSE;
+    server->timeout = 15;
+    server->hideversion = MK_FALSE;
+    server->keep_alive = MK_TRUE;
+    server->keep_alive_timeout = 15;
+    server->max_keep_alive_request = 50;
+    server->resume = MK_TRUE;
+    server->standard_port = 80;
+    server->symlink = MK_FALSE;
+    server->nhosts = 0;
+    mk_list_init(&server->hosts);
+    server->user = NULL;
+    server->open_flags = O_RDONLY; /* The only place this is effectively used (other than the sanity check) 
+                                    * is mk_http.c where it's used to test for file existence and the fd is apparently leaked */
+    server->index_files = NULL;
+    server->conf_user_pub = NULL;
+    server->workers = 1;
+
+    /* TCP REUSEPORT: available on Linux >= 3.9 */
+    if (server->scheduler_mode == -1) {
+        if (server->kernel_features & MK_KERNEL_SO_REUSEPORT) {
+            server->scheduler_mode = MK_SCHEDULER_REUSEPORT;
+        }
+        else {
+            server->scheduler_mode = MK_SCHEDULER_FAIR_BALANCING;
+        }
+    }
+
+    /* Max request buffer size allowed
+     * right now, every chunk size is 4KB (4096 bytes),
+     * so we are setting a maximum request size to 32 KB */
+    server->max_request_size = MK_REQUEST_CHUNK * 8;
+
+    /* Internals */
+    server->safe_event_write = MK_FALSE;
+
+    /* Init plugin list */
+    mk_list_init(&server->plugins);
+
+    /* Init listeners */
+    mk_list_init(&server->listeners);
+}
+
+void mk_config_sanity_check(struct mk_server *server)
+{
+    /* Check O_NOATIME for current user, flag will just be used
+     * if running user is allowed to.
+     */
+    int fd;
+    int flags;
+
+    if (!server->path_conf_root) {
+        return;
+    }
+
+    flags = server->open_flags;
+    flags |= O_NOATIME;
+    fd = open(server->path_conf_root, flags);
+
+    if (fd > -1) {
+        server->open_flags = flags;
+        close(fd);
+    }
+}
diff --git a/fluent-bit/lib/monkey/mk_server/mk_fifo.c b/fluent-bit/lib/monkey/mk_server/mk_fifo.c
new file mode 100644
index 00000000..fd148db7
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_fifo.c
@@ -0,0 +1,463 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <monkey/mk_fifo.h>
+#include <monkey/mk_scheduler.h>
+
+#ifdef _WIN32
+#include <event.h>
+#endif
+
+static struct mk_fifo_worker *mk_fifo_worker_create(struct mk_fifo *ctx,
+                                                    void *data)
+{
+    int id;
+    int ret;
+    struct mk_fifo_worker *fw;
+
+    /* Get an ID */
+    id = mk_list_size(&ctx->workers);
+
+    fw = mk_mem_alloc_z(sizeof(struct mk_fifo_worker));
+    if (!fw) {
+        perror("malloc");
+        return NULL;
+    }
+    MK_EVENT_NEW(&fw->event);
+
+    fw->worker_id = id;
+    fw->data = data;
+    fw->fifo = ctx;
+
+    fw->buf_data = mk_mem_alloc(MK_FIFO_BUF_SIZE);
+    if (!fw->buf_data) {
+        perror("malloc");
+        mk_mem_free(fw);
+        return NULL;
+    }
+    fw->buf_len = 0;
+    fw->buf_size = MK_FIFO_BUF_SIZE;
+
+#ifdef _WIN32
+    ret = evutil_socketpair(AF_INET, SOCK_STREAM, 0, fw->channel);
+    if (ret == -1) {
+        perror("socketpair");
+        mk_mem_free(fw);
+        return NULL;
+    }
+#else
+    ret = pipe(fw->channel);
+    if (ret == -1) {
+        perror("pipe");
+        mk_mem_free(fw);
+        return NULL;
+    }
+#endif
+
+    mk_list_add(&fw->_head, &ctx->workers);
+    return fw;
+}
+
+/*
+ * Function used as a callback triggered by mk_worker_callback() or
+ * through a mk_sched_worker_cb_add(). It purpose is to prepare the
+ * channels on the final worker thread so it can consume pushed
+ * messages.
+ */
+void mk_fifo_worker_setup(void *data)
+{
+    struct mk_fifo_worker *mw = NULL;
+    struct mk_fifo *ctx = data;
+
+    pthread_mutex_lock(&ctx->mutex_init);
+
+    mw = mk_fifo_worker_create(ctx, data);
+    if (!mw) {
+        mk_err("[msg] error configuring msg-worker context ");
+        pthread_mutex_unlock(&ctx->mutex_init);
+        return;
+    }
+
+    /* Make the current worker context available */
+    pthread_setspecific(*ctx->key, mw);
+    pthread_mutex_unlock(&ctx->mutex_init);
+}
+
+struct mk_fifo *mk_fifo_create(pthread_key_t *key, void *data)
+{
+    struct mk_fifo *ctx;
+
+    ctx = mk_mem_alloc(sizeof(struct mk_fifo));
+    if (!ctx) {
+        perror("malloc");
+        return NULL;
+    }
+    ctx->data = data;
+
+    /* Lists */
+    mk_list_init(&ctx->queues);
+    mk_list_init(&ctx->workers);
+
+
+    /* Pthread specifics */
+
+    /* We need to isolate this because there is a key that's shared between monkey
+     * instances by design.
+     */
+    if (key != NULL) {
+        ctx->key = key;
+        pthread_key_create(ctx->key, NULL);
+    }
+
+    pthread_mutex_init(&ctx->mutex_init, NULL);
+
+    return ctx;
+}
+
+int mk_fifo_queue_create(struct mk_fifo *ctx, char *name,
+                         void (*cb)(struct mk_fifo_queue *, void *,
+                                    size_t, void *),
+                         void *data)
+
+{
+    int id = -1;
+    int len;
+    struct mk_list *head;
+    struct mk_fifo_queue *q;
+
+    /* Get ID for the new queue */
+    if (mk_list_is_empty(&ctx->queues) == 0) {
+        id = 0;
+    }
+    else {
+        q = mk_list_entry_last(&ctx->queues, struct mk_fifo_queue, _head);
+        id = q->id + 1;
+    }
+
+    /* queue name might need to be truncated if is too long */
+    len = strlen(name);
+    if (len > (int) sizeof(q->name) - 1) {
+        len = sizeof(q->name) - 1;
+    }
+
+    /* Validate that name is not a duplicated */
+    mk_list_foreach(head, &ctx->queues) {
+        q = mk_list_entry(head, struct mk_fifo_queue, _head);
+        if (strlen(q->name) != (unsigned int) len) {
+            continue;
+        }
+
+        if (strncmp(q->name, name, len) == 0) {
+            return -1;
+        }
+    }
+
+    /* Allocate and register queue */
+    q = mk_mem_alloc(sizeof(struct mk_fifo_queue));
+    if (!q) {
+        perror("malloc");
+        return -1;
+    }
+    q->id = id;
+    q->cb_message = cb;
+    q->data = data;
+
+    strncpy(q->name, name, len);
+    q->name[len] = '\0';
+    mk_list_add(&q->_head, &ctx->queues);
+
+    return id;
+}
+
+struct mk_fifo_queue *mk_fifo_queue_get(struct mk_fifo *ctx, int id)
+{
+    struct mk_list *head;
+    struct mk_fifo_queue *q = NULL;
+
+    mk_list_foreach(head, &ctx->queues) {
+        q = mk_list_entry(head, struct mk_fifo_queue, _head);
+        if (q->id == id) {
+            return q;
+        }
+    }
+
+    return NULL;
+}
+
+int mk_fifo_queue_destroy(struct mk_fifo *ctx, struct mk_fifo_queue *q)
+{
+    (void) ctx;
+
+    mk_list_del(&q->_head);
+    mk_mem_free(q);
+    return 0;
+}
+
+int mk_fifo_queue_id_destroy(struct mk_fifo *ctx, int id)
+{
+    struct mk_fifo_queue *q;
+
+    q = mk_fifo_queue_get(ctx, id);
+    if (!q) {
+        return -1;
+    }
+
+    mk_fifo_queue_destroy(ctx, q);
+    return 0;
+}
+
+static int mk_fifo_queue_destroy_all(struct mk_fifo *ctx)
+{
+    int c = 0;
+    struct mk_list *tmp;
+    struct mk_list *head;
+    struct mk_fifo_queue *q;
+
+    mk_list_foreach_safe(head, tmp, &ctx->queues) {
+        q = mk_list_entry(head, struct mk_fifo_queue, _head);
+        mk_fifo_queue_destroy(ctx, q);
+        c++;
+    }
+
+    return c;
+}
+
+static int mk_fifo_worker_destroy_all(struct mk_fifo *ctx)
+{
+    int c = 0;
+    struct mk_list *tmp;
+    struct mk_list *head;
+    struct mk_fifo_worker *fw;
+
+    mk_list_foreach_safe(head, tmp, &ctx->workers) {
+        fw = mk_list_entry(head, struct mk_fifo_worker, _head);
+
+#ifdef _WIN32
+        evutil_closesocket(fw->channel[0]);
+        evutil_closesocket(fw->channel[1]);
+#else
+        close(fw->channel[0]);
+        close(fw->channel[1]);
+#endif
+        mk_list_del(&fw->_head);
+        mk_mem_free(fw->buf_data);
+        mk_mem_free(fw);
+        c++;
+    }
+
+    return c;
+}
+
+static int msg_write(int fd, void *buf, size_t count)
+{
+    ssize_t bytes;
+    size_t total = 0;
+
+    do {
+#ifdef _WIN32
+        bytes = send(fd, (uint8_t *)buf + total, count - total, 0);
+#else
+        bytes = write(fd, (uint8_t *)buf + total, count - total);
+#endif
+        if (bytes == -1) {
+            if (errno == EAGAIN) {
+                /*
+                 * This could happen, since this function goal is not to
+                 * return until all data have been read, just sleep a little
+                 * bit (0.05 seconds)
+                 */
+
+#ifdef _WIN32
+                Sleep(5);
+#else
+                usleep(50000);
+#endif
+                continue;
+            }
+        }
+        else if (bytes == 0) {
+            /* Broken pipe ? */
+            perror("write");
+            return -1;
+        }
+        total += bytes;
+
+    } while (total < count);
+
+    return total;
+}
+
+/*
+ * Push a message into a queue: this function runs from the parent thread
+ * so it needs to write the message to every thread pipe channel.
+ */
+int mk_fifo_send(struct mk_fifo *ctx, int id, void *data, size_t size)
+{
+    int ret;
+    struct mk_list *head;
+    struct mk_fifo_msg msg;
+    struct mk_fifo_queue *q;
+    struct mk_fifo_worker *fw;
+
+    /* Validate queue ID */
+    q = mk_fifo_queue_get(ctx, id);
+    if (!q) {
+        return -1;
+    }
+
+    pthread_mutex_lock(&ctx->mutex_init);
+
+    mk_list_foreach(head, &ctx->workers) {
+        fw = mk_list_entry(head, struct mk_fifo_worker, _head);
+
+        msg.length = size;
+        msg.flags = 0;
+        msg.queue_id = (uint16_t) id;
+
+        ret = msg_write(fw->channel[1], &msg, sizeof(struct mk_fifo_msg));
+        if (ret == -1) {
+            pthread_mutex_unlock(&ctx->mutex_init);
+            perror("write");
+            fprintf(stderr, "[msg] error writing message header\n");
+            return -1;
+        }
+
+        ret = msg_write(fw->channel[1], data, size);
+        if (ret == -1) {
+            pthread_mutex_unlock(&ctx->mutex_init);
+            perror("write");
+            fprintf(stderr, "[msg] error writing message body\n");
+            return -1;
+        }
+    }
+
+    pthread_mutex_unlock(&ctx->mutex_init);
+
+    return 0;
+}
+
+static inline void consume_bytes(char *buf, int bytes, int length)
+{
+    memmove(buf, buf + bytes, length - bytes);
+}
+
+static inline int fifo_drop_msg(struct mk_fifo_worker *fw)
+{
+    size_t drop_bytes;
+    struct mk_fifo_msg *msg;
+
+    msg = (struct mk_fifo_msg *) fw->buf_data;
+    drop_bytes = (sizeof(struct mk_fifo_msg) + msg->length);
+    consume_bytes(fw->buf_data, drop_bytes, fw->buf_len);
+    fw->buf_len -= drop_bytes;
+
+    return 0;
+}
+
+static inline int fifo_is_msg_ready(struct mk_fifo_worker *fw)
+{
+    struct mk_fifo_msg *msg;
+
+    msg = (struct mk_fifo_msg *) fw->buf_data;
+    if (fw->buf_len >= (msg->length + sizeof(struct mk_fifo_msg))) {
+        return MK_TRUE;
+    }
+
+    return MK_FALSE;
+}
+
+int mk_fifo_worker_read(void *event)
+{
+    int available;
+    char *tmp;
+    size_t size;
+    ssize_t bytes;
+    struct mk_fifo_msg *fm;
+    struct mk_fifo_worker *fw;
+    struct mk_fifo_queue *fq;
+
+    fw = (struct mk_fifo_worker *) event;
+
+    /* Check available space */
+    available = fw->buf_size - fw->buf_len;
+    if (available <= 1) {
+        size = fw->buf_size + (MK_FIFO_BUF_SIZE / 2);
+        tmp = mk_mem_realloc(fw->buf_data, size);
+        if (!tmp) {
+            perror("realloc");
+            return -1;
+        }
+        fw->buf_data = tmp;
+        fw->buf_size = size;
+        available = fw->buf_size - fw->buf_len;
+    }
+
+    /* Read data from pipe */
+#ifdef _WIN32
+    bytes = recv(fw->channel[0], fw->buf_data + fw->buf_len, available, 0);
+#else
+    bytes = read(fw->channel[0], fw->buf_data + fw->buf_len, available);
+#endif
+
+    if (bytes == 0) {
+        return -1;
+    }
+    else if (bytes == -1){
+        perror("read");
+        return -1;
+    }
+
+    fw->buf_len += bytes;
+
+    /* Find messages and trigger callbacks */
+    while (fw->buf_len > 0) {
+        if (fifo_is_msg_ready(fw) == MK_TRUE) {
+            /* we got a complete message */
+            fm = (struct mk_fifo_msg *) fw->buf_data;
+            fq = mk_fifo_queue_get(fw->fifo, fm->queue_id);
+            if (!fq) {
+                /* Invalid queue */
+                fprintf(stderr, "[fifo worker read] invalid queue id %i\n",
+                        fm->queue_id);
+                fifo_drop_msg(fw);
+                continue;
+            }
+
+            /* Trigger callback if any */
+            if (fq->cb_message) {
+                fq->cb_message(fq, fm->data, fm->length, fq->data);
+            }
+            fifo_drop_msg(fw);
+        }
+        else {
+            /* msg not ready */
+            break;
+        }
+    }
+
+    return 0;
+}
+
+int mk_fifo_destroy(struct mk_fifo *ctx)
+{
+    mk_fifo_queue_destroy_all(ctx);
+    mk_fifo_worker_destroy_all(ctx);
+    mk_mem_free(ctx);
+    return 0;
+}
diff --git a/fluent-bit/lib/monkey/mk_server/mk_header.c b/fluent-bit/lib/monkey/mk_server/mk_header.c
new file mode 100644
index 00000000..cd8f77bd
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_header.c
@@ -0,0 +1,451 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <monkey/monkey.h>
+#include <monkey/mk_server.h>
+#include <monkey/mk_header.h>
+#include <monkey/mk_core.h>
+#include <monkey/mk_http_status.h>
+#include <monkey/mk_config.h>
+#include <monkey/mk_socket.h>
+#include <monkey/mk_utils.h>
+#include <monkey/mk_clock.h>
+#include <monkey/mk_cache.h>
+#include <monkey/mk_http.h>
+#include <monkey/mk_vhost.h>
+#include <monkey/mk_tls.h>
+
+#define MK_HEADER_SHORT_DATE       "Date: "
+#define MK_HEADER_SHORT_LOCATION   "Location: "
+#define MK_HEADER_SHORT_CT         "Content-Type: "
+#define MK_HEADER_ACCEPT_RANGES    "Accept-Ranges: bytes" MK_CRLF
+#define MK_HEADER_ALLOWED_METHODS  "Allow: "
+#define MK_HEADER_CONN_KA          "Connection: Keep-Alive" MK_CRLF
+#define MK_HEADER_CONN_CLOSE       "Connection: Close" MK_CRLF
+#define MK_HEADER_CONN_UPGRADE     "Connection: Upgrade" MK_CRLF
+#define MK_HEADER_CONTENT_LENGTH   "Content-Length: "
+#define MK_HEADER_CONTENT_ENCODING "Content-Encoding: "
+#define MK_HEADER_TE_CHUNKED       "Transfer-Encoding: chunked" MK_CRLF
+#define MK_HEADER_LAST_MODIFIED    "Last-Modified: "
+#define MK_HEADER_UPGRADE_H2C      "Upgrade: h2c" MK_CRLF
+
+const mk_ptr_t mk_header_short_date = mk_ptr_init(MK_HEADER_SHORT_DATE);
+const mk_ptr_t mk_header_short_location = mk_ptr_init(MK_HEADER_SHORT_LOCATION);
+const mk_ptr_t mk_header_short_ct = mk_ptr_init(MK_HEADER_SHORT_CT);
+const mk_ptr_t mk_header_allow = mk_ptr_init(MK_HEADER_ALLOWED_METHODS);
+
+const mk_ptr_t mk_header_conn_ka = mk_ptr_init(MK_HEADER_CONN_KA);
+const mk_ptr_t mk_header_conn_close = mk_ptr_init(MK_HEADER_CONN_CLOSE);
+const mk_ptr_t mk_header_conn_upgrade = mk_ptr_init(MK_HEADER_CONN_UPGRADE);
+const mk_ptr_t mk_header_content_length = mk_ptr_init(MK_HEADER_CONTENT_LENGTH);
+const mk_ptr_t mk_header_content_encoding = mk_ptr_init(MK_HEADER_CONTENT_ENCODING);
+const mk_ptr_t mk_header_accept_ranges = mk_ptr_init(MK_HEADER_ACCEPT_RANGES);
+const mk_ptr_t mk_header_te_chunked = mk_ptr_init(MK_HEADER_TE_CHUNKED);
+const mk_ptr_t mk_header_last_modified = mk_ptr_init(MK_HEADER_LAST_MODIFIED);
+const mk_ptr_t mk_header_upgrade_h2c = mk_ptr_init(MK_HEADER_UPGRADE_H2C);
+
+#define status_entry(num, str) {num, sizeof(str) - 1, str}
+
+static const struct header_status_response status_response[] = {
+
+    /*
+     * The most used first:
+     *
+     *  - HTTP/1.1 200 OK
+     *  - HTTP/1.1 404 Not Found
+     */
+    status_entry(MK_HTTP_OK, MK_RH_HTTP_OK),
+    status_entry(MK_CLIENT_NOT_FOUND, MK_RH_CLIENT_NOT_FOUND),
+
+    /* Informational */
+    status_entry(MK_INFO_CONTINUE, MK_RH_INFO_CONTINUE),
+    status_entry(MK_INFO_SWITCH_PROTOCOL, MK_RH_INFO_SWITCH_PROTOCOL),
+
+    /* Successful */
+    status_entry(MK_HTTP_CREATED, MK_RH_HTTP_CREATED),
+    status_entry(MK_HTTP_ACCEPTED, MK_RH_HTTP_ACCEPTED),
+    status_entry(MK_HTTP_NON_AUTH_INFO, MK_RH_HTTP_NON_AUTH_INFO),
+    status_entry(MK_HTTP_NOCONTENT, MK_RH_HTTP_NOCONTENT),
+    status_entry(MK_HTTP_RESET, MK_RH_HTTP_RESET),
+    status_entry(MK_HTTP_PARTIAL, MK_RH_HTTP_PARTIAL),
+
+    /* Redirections */
+    status_entry(MK_REDIR_MULTIPLE, MK_RH_REDIR_MULTIPLE),
+    status_entry(MK_REDIR_MOVED, MK_RH_REDIR_MOVED),
+    status_entry(MK_REDIR_MOVED_T, MK_RH_REDIR_MOVED_T),
+    status_entry(MK_REDIR_SEE_OTHER, MK_RH_REDIR_SEE_OTHER),
+    status_entry(MK_NOT_MODIFIED, MK_RH_NOT_MODIFIED),
+    status_entry(MK_REDIR_USE_PROXY, MK_RH_REDIR_USE_PROXY),
+
+    /* Client side errors */
+    status_entry(MK_CLIENT_BAD_REQUEST, MK_RH_CLIENT_BAD_REQUEST),
+    status_entry(MK_CLIENT_UNAUTH, MK_RH_CLIENT_UNAUTH),
+    status_entry(MK_CLIENT_PAYMENT_REQ, MK_RH_CLIENT_PAYMENT_REQ),
+    status_entry(MK_CLIENT_FORBIDDEN, MK_RH_CLIENT_FORBIDDEN),
+    status_entry(MK_CLIENT_METHOD_NOT_ALLOWED, MK_RH_CLIENT_METHOD_NOT_ALLOWED),
+    status_entry(MK_CLIENT_NOT_ACCEPTABLE, MK_RH_CLIENT_NOT_ACCEPTABLE),
+    status_entry(MK_CLIENT_PROXY_AUTH, MK_RH_CLIENT_PROXY_AUTH),
+    status_entry(MK_CLIENT_REQUEST_TIMEOUT, MK_RH_CLIENT_REQUEST_TIMEOUT),
+    status_entry(MK_CLIENT_CONFLICT, MK_RH_CLIENT_CONFLICT),
+    status_entry(MK_CLIENT_GONE, MK_RH_CLIENT_GONE),
+    status_entry(MK_CLIENT_LENGTH_REQUIRED, MK_RH_CLIENT_LENGTH_REQUIRED),
+    status_entry(MK_CLIENT_PRECOND_FAILED, MK_RH_CLIENT_PRECOND_FAILED),
+    status_entry(MK_CLIENT_REQUEST_ENTITY_TOO_LARGE,
+                 MK_RH_CLIENT_REQUEST_ENTITY_TOO_LARGE),
+    status_entry(MK_CLIENT_REQUEST_URI_TOO_LONG,
+                 MK_RH_CLIENT_REQUEST_URI_TOO_LONG),
+    status_entry(MK_CLIENT_UNSUPPORTED_MEDIA, MK_RH_CLIENT_UNSUPPORTED_MEDIA),
+    status_entry(MK_CLIENT_REQUESTED_RANGE_NOT_SATISF,
+                 MK_RH_CLIENT_REQUESTED_RANGE_NOT_SATISF),
+
+    /* Server side errors */
+    status_entry(MK_SERVER_INTERNAL_ERROR, MK_RH_SERVER_INTERNAL_ERROR),
+    status_entry(MK_SERVER_NOT_IMPLEMENTED, MK_RH_SERVER_NOT_IMPLEMENTED),
+    status_entry(MK_SERVER_BAD_GATEWAY, MK_RH_SERVER_BAD_GATEWAY),
+    status_entry(MK_SERVER_SERVICE_UNAV, MK_RH_SERVER_SERVICE_UNAV),
+    status_entry(MK_SERVER_GATEWAY_TIMEOUT, MK_RH_SERVER_GATEWAY_TIMEOUT),
+    status_entry(MK_SERVER_HTTP_VERSION_UNSUP, MK_RH_SERVER_HTTP_VERSION_UNSUP)
+};
+
+static const int status_response_len =
+    (sizeof(status_response)/(sizeof(status_response[0])));
+
+static void mk_header_cb_finished(struct mk_stream_input *in)
+{
+    struct mk_iov *iov = in->buffer;
+
+    mk_iov_free_marked(iov);
+
+#if defined(__APPLE__)
+        /*
+         * Disable TCP_CORK right away, according to:
+         *
+         *  ---
+         *  commit 81e8b869d70f9da93ddfbfb17ec7f12ce3c28fc6
+         *  Author: Sonny Karlsson <ksonny@lotrax.org>
+         *  Date:   Sat Oct 18 12:11:49 2014 +0200
+         *
+         *  http: Remove cork before first call to sendfile().
+         *
+         *  This removes a large delay on Mac OS X when headers and file content
+         *  does not fill a single frame.
+         *  Deactivating TCP_NOPUSH does not cause pending frames to be sent until
+         *  the next write operation.
+         *  ---
+         */
+
+    mk_server_cork_flag(in->stream->channel->fd, TCP_CORK_OFF);
+#endif
+}
+
+static void cb_stream_iov_extended_free(struct mk_stream_input *in)
+{
+    struct mk_iov *iov;
+
+    iov = in->buffer;
+    mk_iov_free(iov);
+}
+
+/* Send response headers */
+int mk_header_prepare(struct mk_http_session *cs, struct mk_http_request *sr,
+                      struct mk_server *server)
+{
+    int i = 0;
+    unsigned long len = 0;
+    char *buffer = 0;
+    mk_ptr_t response;
+    struct response_headers *sh;
+    struct mk_iov *iov;
+
+    sh = &sr->headers;
+    iov = &sh->headers_iov;
+
+    /* HTTP Status Code */
+    if (sh->status == MK_CUSTOM_STATUS) {
+        response.data = sh->custom_status.data;
+        response.len = sh->custom_status.len;
+    }
+    else {
+        for (i = 0; i < status_response_len; i++) {
+            if (status_response[i].status == sh->status) {
+                response.data = status_response[i].response;
+                response.len  = status_response[i].length;
+                break;
+            }
+        }
+    }
+
+    /* Invalid status set */
+    mk_bug(i == status_response_len);
+
+    mk_iov_add(iov, response.data, response.len, MK_FALSE);
+
+    /*
+     * Preset headers (mk_clock.c):
+     *
+     * - Server
+     * - Date
+     */
+    mk_iov_add(iov,
+               server->clock_context->headers_preset.data,
+               server->clock_context->headers_preset.len,
+               MK_FALSE);
+
+    /* Last-Modified */
+    if (sh->last_modified > 0) {
+        mk_ptr_t *lm = MK_TLS_GET(mk_tls_cache_header_lm);
+        lm->len = mk_utils_utime2gmt(&lm->data, sh->last_modified);
+
+        mk_iov_add(iov,
+                   mk_header_last_modified.data,
+                   mk_header_last_modified.len,
+                   MK_FALSE);
+        mk_iov_add(iov,
+                   lm->data,
+                   lm->len,
+                   MK_FALSE);
+    }
+
+    /* Connection */
+    if (sh->connection == 0) {
+        if (cs->close_now == MK_FALSE) {
+            if (sr->connection.len > 0) {
+                if (sr->protocol != MK_HTTP_PROTOCOL_11) {
+                    mk_iov_add(iov,
+                               mk_header_conn_ka.data,
+                               mk_header_conn_ka.len,
+                               MK_FALSE);
+                }
+            }
+        }
+        else {
+            mk_iov_add(iov,
+                       mk_header_conn_close.data,
+                       mk_header_conn_close.len,
+                       MK_FALSE);
+        }
+    }
+    else if (sh->connection == MK_HEADER_CONN_UPGRADED) {
+             mk_iov_add(iov,
+                        mk_header_conn_upgrade.data,
+                        mk_header_conn_upgrade.len,
+                        MK_FALSE);
+    }
+
+    /* Location */
+    if (sh->location != NULL) {
+        mk_iov_add(iov,
+                   mk_header_short_location.data,
+                   mk_header_short_location.len,
+                   MK_FALSE);
+
+        mk_iov_add(iov,
+                   sh->location,
+                   strlen(sh->location),
+                   MK_TRUE);
+    }
+
+    /* allowed methods */
+    if (sh->allow_methods.len > 0) {
+        mk_iov_add(iov,
+                   mk_header_allow.data,
+                   mk_header_allow.len,
+                   MK_FALSE);
+        mk_iov_add(iov,
+                   sh->allow_methods.data,
+                   sh->allow_methods.len,
+                   MK_FALSE);
+    }
+
+    /* Content type */
+    if (sh->content_type.len > 0) {
+        mk_iov_add(iov,
+                   sh->content_type.data,
+                   sh->content_type.len,
+                   MK_FALSE);
+    }
+
+    /*
+     * Transfer Encoding: the transfer encoding header is just sent when
+     * the response has some content defined by the HTTP status response
+     */
+    switch (sh->transfer_encoding) {
+    case MK_HEADER_TE_TYPE_CHUNKED:
+        mk_iov_add(iov,
+                   mk_header_te_chunked.data,
+                   mk_header_te_chunked.len,
+                   MK_FALSE);
+        break;
+    }
+
+    /* E-Tag */
+    if (sh->etag_len > 0) {
+        mk_iov_add(iov, sh->etag_buf, sh->etag_len, MK_FALSE);
+    }
+
+    /* Content-Encoding */
+    if (sh->content_encoding.len > 0) {
+        mk_iov_add(iov, mk_header_content_encoding.data,
+                   mk_header_content_encoding.len,
+                   MK_FALSE);
+        mk_iov_add(iov, sh->content_encoding.data,
+                   sh->content_encoding.len,
+                   MK_FALSE);
+    }
+
+    /* Content-Length */
+    if (sh->content_length >= 0 && sh->transfer_encoding != 0) {
+        /* Map content length to MK_POINTER */
+        mk_ptr_t *cl = MK_TLS_GET(mk_tls_cache_header_cl);
+        mk_string_itop(sh->content_length, cl);
+
+        /* Set headers */
+        mk_iov_add(iov,
+                   mk_header_content_length.data,
+                   mk_header_content_length.len,
+                   MK_FALSE);
+        mk_iov_add(iov,
+                   cl->data,
+                   cl->len,
+                   MK_FALSE);
+    }
+
+    if ((sh->content_length != 0 && (sh->ranges[0] >= 0 || sh->ranges[1] >= 0)) &&
+        server->resume == MK_TRUE) {
+        buffer = 0;
+
+        /* yyy- */
+        if (sh->ranges[0] >= 0 && sh->ranges[1] == -1) {
+            mk_string_build(&buffer,
+                            &len,
+                            "%s bytes %d-%ld/%ld\r\n",
+                            RH_CONTENT_RANGE,
+                            sh->ranges[0],
+                            (sh->real_length - 1), sh->real_length);
+            mk_iov_add(iov, buffer, len, MK_TRUE);
+        }
+
+        /* yyy-xxx */
+        if (sh->ranges[0] >= 0 && sh->ranges[1] >= 0) {
+            mk_string_build(&buffer,
+                            &len,
+                            "%s bytes %d-%d/%ld\r\n",
+                            RH_CONTENT_RANGE,
+                            sh->ranges[0], sh->ranges[1], sh->real_length);
+
+            mk_iov_add(iov, buffer, len, MK_TRUE);
+        }
+
+        /* -xxx */
+        if (sh->ranges[0] == -1 && sh->ranges[1] > 0) {
+            mk_string_build(&buffer,
+                            &len,
+                            "%s bytes %ld-%ld/%ld\r\n",
+                            RH_CONTENT_RANGE,
+                            (sh->real_length - sh->ranges[1]),
+                            (sh->real_length - 1), sh->real_length);
+            mk_iov_add(iov, buffer, len, MK_TRUE);
+        }
+    }
+
+    if (sh->upgrade == MK_HEADER_UPGRADED_H2C) {
+        mk_iov_add(iov, mk_header_upgrade_h2c.data, mk_header_upgrade_h2c.len,
+                   MK_FALSE);
+    }
+
+
+    if (sh->cgi == SH_NOCGI || sh->breakline == MK_HEADER_BREAKLINE) {
+        if (!sr->headers._extra_rows) {
+            mk_iov_add(iov, mk_iov_crlf.data, mk_iov_crlf.len,
+                       MK_FALSE);
+        }
+        else {
+            mk_iov_add(sr->headers._extra_rows, mk_iov_crlf.data,
+                       mk_iov_crlf.len, MK_FALSE);
+        }
+    }
+
+    /*
+     * Configure the Stream to dispatch the headers
+     */
+
+    /* Set the IOV input stream */
+    sr->in_headers.buffer      = iov;
+    sr->in_headers.bytes_total = iov->total_len;
+    sr->in_headers.cb_finished = mk_header_cb_finished;
+
+    if (sr->headers._extra_rows) {
+        /* Our main sr->stream contains the main headers (header_iov)
+         * and 'may' have already some linked data. If we have some
+         * extra headers rows we need to link this IOV right after
+         * the main header_iov.
+         */
+        struct mk_stream_input *in = &sr->in_headers_extra;
+        in->type        = MK_STREAM_IOV;
+        in->dynamic     = MK_FALSE;
+        in->cb_consumed = NULL;
+        in->cb_finished = cb_stream_iov_extended_free;
+        in->stream      = &sr->stream;
+        in->buffer      = sr->headers._extra_rows;
+        in->bytes_total = sr->headers._extra_rows->total_len;
+
+        mk_list_add_after(&sr->in_headers_extra._head,
+                          &sr->in_headers._head,
+                          &sr->stream.inputs);
+    }
+
+    sh->sent = MK_TRUE;
+
+    return 0;
+}
+
+void mk_header_set_http_status(struct mk_http_request *sr, int status)
+{
+    mk_bug(!sr);
+    sr->headers.status = status;
+
+    MK_TRACE("Set HTTP status = %i", status);
+}
+
+void mk_header_response_reset(struct response_headers *header)
+{
+    struct mk_iov *iov;
+
+    header->status = -1;
+    header->sent = MK_FALSE;
+    header->ranges[0] = -1;
+    header->ranges[1] = -1;
+    header->content_length = -1;
+    header->connection = 0;
+    header->transfer_encoding = -1;
+    header->last_modified = -1;
+    header->upgrade = -1;
+    header->cgi = SH_NOCGI;
+    mk_ptr_reset(&header->content_type);
+    mk_ptr_reset(&header->content_encoding);
+    header->location = NULL;
+    header->_extra_rows = NULL;
+    header->allow_methods.len = 0;
+
+    /* Initialize headers IOV */
+    iov = &header->headers_iov;
+    iov->io          = (struct iovec *) &header->__iov_io;
+    iov->buf_to_free = (void *) &header->__iov_buf;
+    mk_iov_init(&header->headers_iov, MK_HEADER_IOV, 0);
+}
diff --git a/fluent-bit/lib/monkey/mk_server/mk_http.c b/fluent-bit/lib/monkey/mk_server/mk_http.c
new file mode 100644
index 00000000..1e2d219d
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_http.c
@@ -0,0 +1,1638 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <sys/stat.h>
+#include <fcntl.h>
+//#include <regex.h>
+#include <re.h>
+
+#include <monkey/monkey.h>
+#include <monkey/mk_user.h>
+#include <monkey/mk_core.h>
+#include <monkey/mk_http.h>
+#include <monkey/mk_http_status.h>
+#include <monkey/mk_http_thread.h>
+#include <monkey/mk_clock.h>
+#include <monkey/mk_utils.h>
+#include <monkey/mk_config.h>
+#include <monkey/mk_socket.h>
+#include <monkey/mk_mimetype.h>
+#include <monkey/mk_header.h>
+#include <monkey/mk_plugin.h>
+#include <monkey/mk_vhost.h>
+#include <monkey/mk_server.h>
+#include <monkey/mk_plugin_stage.h>
+
+const mk_ptr_t mk_http_method_get_p = mk_ptr_init(MK_METHOD_GET_STR);
+const mk_ptr_t mk_http_method_post_p = mk_ptr_init(MK_METHOD_POST_STR);
+const mk_ptr_t mk_http_method_head_p = mk_ptr_init(MK_METHOD_HEAD_STR);
+const mk_ptr_t mk_http_method_put_p = mk_ptr_init(MK_METHOD_PUT_STR);
+const mk_ptr_t mk_http_method_delete_p = mk_ptr_init(MK_METHOD_DELETE_STR);
+const mk_ptr_t mk_http_method_options_p = mk_ptr_init(MK_METHOD_OPTIONS_STR);
+const mk_ptr_t mk_http_method_null_p = { NULL, 0 };
+
+const mk_ptr_t mk_http_protocol_09_p = mk_ptr_init(MK_HTTP_PROTOCOL_09_STR);
+const mk_ptr_t mk_http_protocol_10_p = mk_ptr_init(MK_HTTP_PROTOCOL_10_STR);
+const mk_ptr_t mk_http_protocol_11_p = mk_ptr_init(MK_HTTP_PROTOCOL_11_STR);
+const mk_ptr_t mk_http_protocol_null_p = { NULL, 0 };
+
+/* Create a memory allocation in order to handle the request data */
+void mk_http_request_init(struct mk_http_session *session,
+                          struct mk_http_request *request,
+                          struct mk_server *server)
+{
+    struct mk_list *host_list = &server->hosts;
+
+    request->port = 0;
+    request->status = MK_TRUE;
+    request->uri.data = NULL;
+    request->method = MK_METHOD_UNKNOWN;
+    request->protocol = MK_HTTP_PROTOCOL_UNKNOWN;
+    request->connection.len = -1;
+    request->file_fd        = -1;
+    request->file_info.size = -1;
+    request->vhost_fdt_id = 0;
+    request->vhost_fdt_hash = 0;
+    request->vhost_fdt_enabled = MK_FALSE;
+    request->host.data = NULL;
+    request->stage30_blocked = MK_FALSE;
+    request->session = session;
+    request->host_conf = mk_list_entry_first(host_list, struct mk_vhost, _head);
+    request->uri_processed.data = NULL;
+    request->real_path.data = NULL;
+    request->handler_data = NULL;
+
+    request->in_file.fd = -1;
+
+    /* Response Headers */
+    mk_header_response_reset(&request->headers);
+
+    /* Reset callbacks for headers stream */
+    mk_stream_set(&request->stream,
+                  session->channel,
+                  NULL,
+                  NULL, NULL, NULL);
+}
+
+static inline int mk_http_point_header(mk_ptr_t *h,
+                                       struct mk_http_parser *parser, int key)
+{
+    struct mk_http_header *header;
+
+    header = &parser->headers[key];
+    if (header->type == key) {
+        h->data = header->val.data;
+        h->len  = header->val.len;
+        return 0;
+    }
+    else {
+        h->data = NULL;
+        h->len  = -1;
+    }
+
+    return -1;
+}
+
+static int mk_http_request_prepare(struct mk_http_session *cs,
+                                   struct mk_http_request *sr,
+                                   struct mk_server *server)
+{
+    int ret;
+    int status = 0;
+    char *temp;
+    struct mk_list *hosts = &server->hosts;
+    struct mk_list *alias;
+    struct mk_http_header *header;
+
+    /*
+     * Process URI, if it contains ASCII encoded strings like '%20',
+     * it will return a new memory buffer with the decoded string, otherwise
+     * it returns NULL
+     */
+    temp = mk_utils_url_decode(sr->uri);
+
+    if (temp) {
+        sr->uri_processed.data = temp;
+        sr->uri_processed.len  = strlen(temp);
+    }
+    else {
+        sr->uri_processed.data = sr->uri.data;
+        sr->uri_processed.len  = sr->uri.len;
+    }
+
+    /* Always assign the default vhost' */
+    sr->host_conf = mk_list_entry_first(hosts, struct mk_vhost, _head);
+    sr->user_home = MK_FALSE;
+
+    /* Valid request URI? */
+    if (sr->uri_processed.data[0] != '/') {
+        mk_http_error(MK_CLIENT_BAD_REQUEST, cs, sr, server);
+        return MK_EXIT_OK;
+    }
+
+    /* Check if we have a Host header: Hostname ; port */
+    mk_http_point_header(&sr->host, &cs->parser, MK_HEADER_HOST);
+
+    /* Header: Connection */
+    mk_http_point_header(&sr->connection, &cs->parser, MK_HEADER_CONNECTION);
+
+    /* Header: Range */
+    mk_http_point_header(&sr->range, &cs->parser, MK_HEADER_RANGE);
+
+    /* Header: If-Modified-Since */
+    mk_http_point_header(&sr->if_modified_since,
+                         &cs->parser,
+                         MK_HEADER_IF_MODIFIED_SINCE);
+
+    /* HTTP/1.1 needs Host header */
+    if (!sr->host.data && sr->protocol == MK_HTTP_PROTOCOL_11) {
+        mk_http_error(MK_CLIENT_BAD_REQUEST, cs, sr, server);
+        return MK_EXIT_OK;
+    }
+
+    /* Should we close the session after this request ? */
+    mk_http_keepalive_check(cs, sr, server);
+
+    /* Content Length */
+    header = &cs->parser.headers[MK_HEADER_CONTENT_LENGTH];
+    if (header->type == MK_HEADER_CONTENT_LENGTH) {
+        sr->_content_length.data = header->val.data;
+        sr->_content_length.len  = header->val.len;
+    }
+    else {
+        sr->_content_length.data = NULL;
+    }
+
+    /* Assign the first node alias */
+    alias = &sr->host_conf->server_names;
+    sr->host_alias = mk_list_entry_first(alias,
+                                         struct mk_vhost_alias, _head);
+
+    if (sr->host.data) {
+        /* Set the given port */
+        if (cs->parser.header_host_port > 0) {
+            sr->port = cs->parser.header_host_port;
+        }
+
+        /* Match the virtual host */
+        mk_vhost_get(sr->host, &sr->host_conf, &sr->host_alias, server);
+
+        /* Check if this virtual host have some redirection */
+        if (sr->host_conf->header_redirect.data) {
+            mk_header_set_http_status(sr, MK_REDIR_MOVED);
+            sr->headers.location = mk_string_dup(sr->host_conf->header_redirect.data);
+            sr->headers.content_length = 0;
+            sr->headers.location = NULL;
+            mk_header_prepare(cs, sr, server);
+            return 0;
+        }
+    }
+
+    /* Is requesting an user home directory ? */
+    if (server->conf_user_pub &&
+        sr->uri_processed.len > 2 &&
+        sr->uri_processed.data[1] == MK_USER_HOME) {
+
+        if (mk_user_init(cs, sr, server) != 0) {
+            mk_http_error(MK_CLIENT_NOT_FOUND, cs, sr, server);
+            return MK_EXIT_ABORT;
+        }
+    }
+
+    /* Plugins Stage 20 */
+    ret = mk_plugin_stage_run_20(cs, sr, server);
+    if (ret == MK_PLUGIN_RET_CLOSE_CONX) {
+        MK_TRACE("STAGE 20 requested close conexion");
+        return MK_EXIT_ABORT;
+    }
+
+    /* Normal HTTP process */
+    status = mk_http_init(cs, sr, server);
+
+    MK_TRACE("[FD %i] HTTP Init returning %i", cs->socket, status);
+    return status;
+}
+
+/*
+ * This function allow the core to invoke the closing connection process
+ * when some connection was not proceesed due to a premature close or similar
+ * exception, it also take care of invoke the STAGE_40 and STAGE_50 plugins events
+ */
+static void mk_request_premature_close(int http_status, struct mk_http_session *cs,
+                                       struct mk_server *server)
+{
+    struct mk_http_request *sr;
+    struct mk_list *sr_list = &cs->request_list;
+    struct mk_list *host_list = &server->hosts;
+
+    /*
+     * If the connection is too premature, we need to allocate a temporal session_request
+     * to do not break the plugins stages
+     */
+    if (mk_list_is_empty(sr_list) == 0) {
+        sr = &cs->sr_fixed;
+        memset(sr, 0, sizeof(struct mk_http_request));
+        mk_http_request_init(cs, sr, server);
+        mk_list_add(&sr->_head, &cs->request_list);
+    }
+    else {
+        sr = mk_list_entry_first(sr_list, struct mk_http_request, _head);
+    }
+
+    /* Raise error */
+    if (http_status > 0) {
+        if (!sr->host_conf) {
+            sr->host_conf = mk_list_entry_first(host_list,
+                                                struct mk_vhost, _head);
+        }
+        mk_http_error(http_status, cs, sr, server);
+
+        /* STAGE_40, request has ended */
+        mk_plugin_stage_run_40(cs, sr, server);
+    }
+
+    /* STAGE_50, connection closed and remove the http_session */
+    mk_plugin_stage_run_50(cs->socket, server);
+    mk_http_session_remove(cs, server);
+}
+
+int mk_http_handler_read(struct mk_sched_conn *conn, struct mk_http_session *cs,
+                         struct mk_server *server)
+{
+    int bytes;
+    int max_read;
+    int available = 0;
+    int new_size;
+    int total_bytes = 0;
+    char *tmp = 0;
+
+#ifdef MK_HAVE_TRACE
+    int socket = conn->event.fd;
+#endif
+
+    MK_TRACE("MAX REQUEST SIZE: %i", server->max_request_size);
+
+ try_pending:
+
+    available = cs->body_size - cs->body_length;
+    if (available <= 0) {
+        /* Reallocate buffer size if pending data does not have space */
+        new_size = cs->body_size + conn->net->buffer_size;
+        if (new_size > server->max_request_size) {
+            MK_TRACE("Requested size is > mk_config->max_request_size");
+            mk_request_premature_close(MK_CLIENT_REQUEST_ENTITY_TOO_LARGE, cs,
+                                       server);
+            return -1;
+        }
+
+        /*
+         * Check if the body field still points to the initial body_fixed, if so,
+         * allow the new space required in body, otherwise perform a realloc over
+         * body.
+         */
+        if (cs->body == cs->body_fixed) {
+            cs->body = mk_mem_alloc(new_size + 1);
+            cs->body_size = new_size;
+            memcpy(cs->body, cs->body_fixed, cs->body_length);
+            MK_TRACE("[FD %i] New size: %i, length: %i",
+                     socket, new_size, cs->body_length);
+        }
+        else {
+            MK_TRACE("[FD %i] Realloc from %i to %i",
+                     socket, cs->body_size, new_size);
+            tmp = mk_mem_realloc(cs->body, new_size + 1);
+            if (tmp) {
+                cs->body = tmp;
+                cs->body_size = new_size;
+            }
+            else {
+                mk_request_premature_close(MK_SERVER_INTERNAL_ERROR, cs,
+                                           server);
+                return -1;
+            }
+        }
+    }
+
+    /* Read content */
+    max_read = (cs->body_size - cs->body_length);
+    bytes = mk_sched_conn_read(conn, cs->body + cs->body_length, max_read);
+    MK_TRACE("[FD %i] read %i", socket, bytes);
+
+    if (bytes == 0) {
+        MK_TRACE("[FD %i] broken pipe?", socket);
+        errno = 0;
+        return -1;
+    }
+    else if (bytes == -1) {
+        return -1;
+    }
+
+    if (bytes > max_read) {
+        MK_TRACE("[FD %i] Buffer still have data: %i",
+                 socket, bytes - max_read);
+        cs->body_length += max_read;
+        cs->body[cs->body_length] = '\0';
+        total_bytes += max_read;
+
+        goto try_pending;
+    }
+    else {
+        cs->body_length += bytes;
+        cs->body[cs->body_length] = '\0';
+
+        total_bytes += bytes;
+    }
+
+    MK_TRACE("[FD %i] Retry total bytes: %i", socket, total_bytes);
+    return total_bytes;
+}
+
+/* Build error page */
+static int mk_http_error_page(char *title, mk_ptr_t *message, char *signature,
+                              char **out_buf, unsigned long *out_size)
+{
+    char *temp;
+
+    *out_buf = NULL;
+
+    if (message) {
+        temp = mk_ptr_to_buf(*message);
+    }
+    else {
+        temp = mk_string_dup("");
+    }
+
+    mk_string_build(out_buf, out_size,
+                    MK_REQUEST_DEFAULT_PAGE, title, temp, signature);
+    mk_mem_free(temp);
+    return 0;
+}
+
+static int mk_http_range_set(struct mk_http_request *sr, size_t file_size,
+                             struct mk_server *server)
+{
+    struct response_headers *sh = &sr->headers;
+    struct mk_stream_input *in;
+
+    in = &sr->in_file;
+    in->bytes_total  = file_size;
+    in->bytes_offset = 0;
+
+    if (server->resume == MK_TRUE && sr->range.data) {
+        /* yyy- */
+        if (sh->ranges[0] >= 0 && sh->ranges[1] == -1) {
+            in->bytes_offset = sh->ranges[0];
+            in->bytes_total = file_size - in->bytes_offset;
+        }
+
+        /* yyy-xxx */
+        if (sh->ranges[0] >= 0 && sh->ranges[1] >= 0) {
+            in->bytes_offset = sh->ranges[0];
+            in->bytes_total  = labs(sh->ranges[1] - sh->ranges[0]) + 1;
+        }
+
+        /* -xxx */
+        if (sh->ranges[0] == -1 && sh->ranges[1] > 0) {
+            in->bytes_total = sh->ranges[1];
+            in->bytes_offset = file_size - sh->ranges[1];
+        }
+
+        if ((size_t) in->bytes_offset >= file_size ||
+            in->bytes_total > file_size) {
+            return -1;
+        }
+
+        lseek(in->fd, in->bytes_offset, SEEK_SET);
+    }
+    return 0;
+}
+
+static int mk_http_range_parse(struct mk_http_request *sr)
+{
+    int eq_pos, sep_pos, len;
+    char *buffer = 0;
+    struct response_headers *sh;
+
+    if (!sr->range.data)
+        return -1;
+
+    if ((eq_pos = mk_string_char_search(sr->range.data, '=', sr->range.len)) < 0)
+        return -1;
+
+    if (strncasecmp(sr->range.data, "Bytes", eq_pos) != 0)
+        return -1;
+
+    if ((sep_pos = mk_string_char_search(sr->range.data, '-', sr->range.len)) < 0)
+        return -1;
+
+    len = sr->range.len;
+    sh = &sr->headers;
+
+    /* =-xxx */
+    if (eq_pos + 1 == sep_pos) {
+        sh->ranges[0] = -1;
+        sh->ranges[1] = (unsigned long) atol(sr->range.data + sep_pos + 1);
+
+        if (sh->ranges[1] <= 0) {
+            return -1;
+        }
+
+        sh->content_length = sh->ranges[1];
+        return 0;
+    }
+
+    /* =yyy-xxx */
+    if ((eq_pos + 1 != sep_pos) && (len > sep_pos + 1)) {
+        buffer = mk_string_copy_substr(sr->range.data, eq_pos + 1, sep_pos);
+        sh->ranges[0] = (unsigned long) atol(buffer);
+        mk_mem_free(buffer);
+
+        buffer = mk_string_copy_substr(sr->range.data, sep_pos + 1, len);
+        sh->ranges[1] = (unsigned long) atol(buffer);
+        mk_mem_free(buffer);
+
+        if (sh->ranges[1] < 0 || (sh->ranges[0] > sh->ranges[1])) {
+            return -1;
+        }
+
+        sh->content_length = abs(sh->ranges[1] - sh->ranges[0]) + 1;
+        return 0;
+    }
+    /* =yyy- */
+    if ((eq_pos + 1 != sep_pos) && (len == sep_pos + 1)) {
+        buffer = mk_string_copy_substr(sr->range.data, eq_pos + 1, len);
+        sr->headers.ranges[0] = (unsigned long) atol(buffer);
+        mk_mem_free(buffer);
+
+        sh->content_length = (sh->content_length - sh->ranges[0]);
+        return 0;
+    }
+
+    return -1;
+}
+
+static int mk_http_directory_redirect_check(struct mk_http_session *cs,
+                                            struct mk_http_request *sr,
+                                            struct mk_server *server)
+{
+    int port_redirect = 0;
+    char *host;
+    char *location = 0;
+    char *real_location = 0;
+    char *protocol = "http";
+    unsigned long len;
+
+    /*
+     * We have to check if there is a slash at the end of
+     * this string. If it doesn't exist, we send a redirection header.
+     */
+    if (sr->uri_processed.data[sr->uri_processed.len - 1] == '/') {
+        return 0;
+    }
+
+    host = mk_ptr_to_buf(sr->host);
+
+    /*
+     * Add ending slash to the location string
+     */
+    location = mk_mem_alloc(sr->uri_processed.len + 2);
+    memcpy(location, sr->uri_processed.data, sr->uri_processed.len);
+    location[sr->uri_processed.len]     = '/';
+    location[sr->uri_processed.len + 1] = '\0';
+
+    /* FIXME: should we done something similar for SSL = 443 */
+    if (sr->host.data && sr->port > 0) {
+        if (sr->port != server->standard_port) {
+            port_redirect = sr->port;
+        }
+    }
+
+    if (MK_SCHED_CONN_PROP(cs->conn) & MK_CAP_SOCK_TLS) {
+        protocol = "https";
+    }
+
+    if (port_redirect > 0) {
+        mk_string_build(&real_location, &len, "%s://%s:%i%s\r\n",
+                        protocol, host, port_redirect, location);
+    }
+    else {
+        mk_string_build(&real_location, &len, "%s://%s%s\r\n",
+                        protocol, host, location);
+    }
+
+    MK_TRACE("Redirecting to '%s'", real_location);
+    mk_mem_free(host);
+
+    mk_header_set_http_status(sr, MK_REDIR_MOVED);
+    sr->headers.content_length = 0;
+
+    mk_ptr_reset(&sr->headers.content_type);
+    sr->headers.location = real_location;
+    sr->headers.cgi = SH_NOCGI;
+    sr->headers.pconnections_left =
+        (server->max_keep_alive_request - cs->counter_connections);
+
+    mk_header_prepare(cs, sr, server);
+
+    /* we do not free() real_location as it's freed by iov */
+    mk_mem_free(location);
+    sr->headers.location = NULL;
+    return -1;
+}
+
+/* Look for some  index.xxx in pathfile */
+static inline char *mk_http_index_lookup(mk_ptr_t *path_base,
+                                         char *buf, size_t buf_size,
+                                         size_t *out, size_t *bytes,
+                                         struct mk_server *server)
+{
+    off_t off = 0;
+    size_t len;
+    struct mk_string_line *entry;
+    struct mk_list *head;
+
+    if (!server->index_files) {
+        return NULL;
+    }
+
+    off = path_base->len;
+    memcpy(buf, path_base->data, off);
+
+    mk_list_foreach(head, server->index_files) {
+        entry = mk_list_entry(head, struct mk_string_line, _head);
+
+        len = off + entry->len + 1;
+        if (len >= buf_size) {
+            continue;
+        }
+
+        memcpy(buf + off, entry->val, entry->len);
+        buf[off + entry->len] = '\0';
+
+        if (access(buf, F_OK) == 0) {
+            MK_TRACE("Index lookup OK '%s'", buf);
+            *out = off + entry->len;
+            *bytes = path_base->len - 1;
+            return buf;
+        }
+    }
+
+    return NULL;
+}
+
+/* Turn CORK_OFF once headers are sent */
+#if defined (__linux__)
+static inline void mk_http_cb_file_on_consume(struct mk_stream_input *in,
+                                              long bytes)
+{
+    int ret;
+    (void) bytes;
+
+    /*
+     * This callback is invoked just once as we want to turn off
+     * the TCP Cork. We do this just overriding the callback for
+     * the file stream.
+     */
+    ret = mk_server_cork_flag(in->stream->channel->fd, TCP_CORK_OFF);
+    if (ret == -1) {
+        mk_warn("Could not set TCP_CORK/TCP_NOPUSH off");
+    }
+    MK_TRACE("[FD %i] Disable TCP_CORK/TCP_NOPUSH",
+             in->stream->channel->fd);
+    in->cb_consumed = NULL;
+}
+#endif
+
+int mk_http_init(struct mk_http_session *cs, struct mk_http_request *sr,
+                 struct mk_server *server)
+{
+    int ret;
+    int ret_file;
+    struct mk_mimetype *mime;
+    struct mk_list *head;
+    struct mk_list *handlers;
+    struct mk_plugin *plugin;
+    struct mk_vhost_handler *h_handler;
+    struct mk_http_thread *mth = NULL;
+    size_t index_length;
+    size_t index_bytes;
+    char *index_path = NULL;
+
+    MK_TRACE("[FD %i] HTTP Protocol Init, session %p", cs->socket, sr);
+
+    /* Request to root path of the virtualhost in question */
+    if (sr->uri_processed.len == 1 && sr->uri_processed.data[0] == '/') {
+        sr->real_path.data = sr->host_conf->documentroot.data;
+        sr->real_path.len = sr->host_conf->documentroot.len;
+    }
+
+    /* Compose real path */
+    if (sr->user_home == MK_FALSE) {
+        int len;
+
+        len = sr->host_conf->documentroot.len + sr->uri_processed.len;
+        if (len < MK_PATH_BASE) {
+            memcpy(sr->real_path_static,
+                   sr->host_conf->documentroot.data,
+                   sr->host_conf->documentroot.len);
+            memcpy(sr->real_path_static + sr->host_conf->documentroot.len,
+                   sr->uri_processed.data,
+                   sr->uri_processed.len);
+            sr->real_path_static[len] = '\0';
+            sr->real_path.data = sr->real_path_static;
+            sr->real_path.len = len;
+        }
+        else {
+            ret = mk_buffer_cat(&sr->real_path,
+                                sr->host_conf->documentroot.data,
+                                sr->host_conf->documentroot.len,
+                                sr->uri_processed.data,
+                                sr->uri_processed.len);
+
+            if (ret < 0) {
+                MK_TRACE("Error composing real path");
+                return MK_EXIT_ERROR;
+            }
+        }
+    }
+
+    /* Check if this is related to a protocol upgrade */
+#ifdef MK_HAVE_HTTP2
+    if (cs->parser.header_connection & MK_HTTP_PARSER_CONN_UPGRADE) {
+        /* HTTP/2.0 upgrade ? */
+        if (cs->parser.header_connection & MK_HTTP_PARSER_CONN_HTTP2_SE) {
+            MK_TRACE("Connection Upgrade request: HTTP/2.0");
+            /*
+             * This is a HTTP/2.0 upgrade, we need to validate that we
+             * have at least the 'Upgrade' and 'HTTP2-Settings' headers.
+             */
+            struct mk_http_header *p;
+            p = &cs->parser.headers[MK_HEADER_HTTP2_SETTINGS];
+            if (cs->parser.header_upgrade == MK_HTTP_PARSER_UPGRADE_H2C &&
+                p->key.data) {
+                /*
+                 * Switch protocols and invoke the callback upgrade to prepare
+                 * the new protocol internals.
+                 */
+                mk_sched_switch_protocol(cs->conn, MK_CAP_HTTP2);
+                return cs->conn->protocol->cb_upgrade(cs, sr, server);
+            }
+            else {
+                MK_TRACE("Invalid client upgrade request, skip it");
+            }
+        }
+    }
+#endif
+
+    /* Check backward directory request */
+    if (memmem(sr->uri_processed.data, sr->uri_processed.len,
+               MK_HTTP_DIRECTORY_BACKWARD,
+               sizeof(MK_HTTP_DIRECTORY_BACKWARD) - 1)) {
+        return mk_http_error(MK_CLIENT_FORBIDDEN, cs, sr, server);
+    }
+
+    if (sr->_content_length.data &&
+        (sr->method != MK_METHOD_POST &&
+         sr->method != MK_METHOD_PUT)) {
+        sr->_content_length.data = NULL;
+        sr->_content_length.len = 0;
+    }
+
+    ret_file = mk_file_get_info(sr->real_path.data, &sr->file_info, MK_FILE_READ);
+
+    /* Manually set the headers input streams */
+    sr->in_headers.type        = MK_STREAM_IOV;
+    sr->in_headers.dynamic     = MK_FALSE;
+    sr->in_headers.cb_consumed = NULL;
+    sr->in_headers.cb_finished = NULL;
+    sr->in_headers.stream      = &sr->stream;
+    mk_list_add(&sr->in_headers._head, &sr->stream.inputs);
+
+    /* Plugin Stage 30: look for handlers for this request */
+    if (sr->stage30_blocked == MK_FALSE) {
+        sr->uri_processed.data[sr->uri_processed.len] = '\0';
+        handlers = &sr->host_conf->handlers;
+        mk_list_foreach(head, handlers) {
+            h_handler = mk_list_entry(head, struct mk_vhost_handler, _head);
+
+            if (re_matchp(h_handler->match,
+                          sr->uri_processed.data, NULL) == -1) {
+                continue;
+            }
+
+            if (h_handler->cb) {
+                /* Create coroutine/thread context */
+                sr->headers.content_length = 0;
+                mth = mk_http_thread_create(MK_HTTP_THREAD_LIB,
+                                            h_handler,
+                                            cs, sr,
+                                            0, NULL);
+                if (!mth) {
+                    return -1;
+                }
+
+                mk_http_thread_start(mth);
+                return MK_EXIT_OK;
+            }
+            else {
+                if (!h_handler->handler) {
+                    return mk_http_error(MK_SERVER_INTERNAL_ERROR, cs, sr,
+                                         server);
+                }
+                plugin = h_handler->handler;
+                sr->stage30_handler = h_handler->handler;
+                ret = plugin->stage->stage30(plugin, cs, sr,
+                                             h_handler->n_params,
+                                             &h_handler->params);
+                mk_header_prepare(cs, sr, server);
+            }
+
+            MK_TRACE("[FD %i] STAGE_30 returned %i", cs->socket, ret);
+            switch (ret) {
+            case MK_PLUGIN_RET_CONTINUE:
+                /* FIXME: PLUGINS DISABLED
+                if ((plugin->flags & MK_PLUGIN_THREAD) &&
+                    plugin->stage->stage30_thread) {
+                    mth = mk_http_thread_new(MK_HTTP_THREAD_PLUGIN,
+                                             plugin, cs, sr,
+                                             h_handler->n_params,
+                                             &h_handler->params);
+                    printf("[http thread] %p\n", mth);
+                    mk_http_thread_resume(mth->parent);
+                }
+                */
+                return MK_PLUGIN_RET_CONTINUE;
+            case MK_PLUGIN_RET_CLOSE_CONX:
+                if (sr->headers.status > 0) {
+                    return mk_http_error(sr->headers.status, cs, sr, server);
+                }
+                else {
+                    return mk_http_error(MK_CLIENT_FORBIDDEN, cs, sr, server);
+                }
+            case MK_PLUGIN_RET_END:
+                return MK_EXIT_OK;
+            }
+        }
+    }
+
+    /* If there is no handler and the resource don't exists, raise a 404 */
+    if (ret_file == -1) {
+        return mk_http_error(MK_CLIENT_NOT_FOUND, cs, sr, server);
+    }
+
+    /* is it a valid directory ? */
+    if (sr->file_info.is_directory == MK_TRUE) {
+        /* Send redirect header if end slash is not found */
+        if (mk_http_directory_redirect_check(cs, sr, server) == -1) {
+            MK_TRACE("Directory Redirect");
+
+            /* Redirect has been sent */
+            return -1;
+        }
+
+        /* looking for an index file */
+        char tmppath[MK_MAX_PATH];
+        index_path = mk_http_index_lookup(&sr->real_path,
+                                          tmppath, MK_MAX_PATH,
+                                          &index_length, &index_bytes,
+                                          server);
+        if (index_path) {
+            if (sr->real_path.data != sr->real_path_static) {
+                mk_ptr_free(&sr->real_path);
+                sr->real_path.data = mk_string_dup(index_path);
+            }
+            /* If it's static and it still fits */
+            else if (index_length < MK_PATH_BASE) {
+                memcpy(sr->real_path_static, index_path, index_length);
+                sr->real_path_static[index_length] = '\0';
+            }
+            /* It was static, but didn't fit */
+            else {
+                sr->real_path.data = mk_string_dup(index_path);
+            }
+            sr->real_path.len  = index_length;
+
+            ret = mk_file_get_info(sr->real_path.data,
+                                   &sr->file_info, MK_FILE_READ);
+            if (ret != 0) {
+                return mk_http_error(MK_CLIENT_FORBIDDEN, cs, sr, server);
+            }
+
+        }
+    }
+
+#ifndef _WIN32
+    /* Check symbolic link file */
+    if (sr->file_info.is_link == MK_TRUE) {
+        if (server->symlink == MK_FALSE) {
+            return mk_http_error(MK_CLIENT_FORBIDDEN, cs, sr, server);
+        }
+        else {
+            int n;
+            char linked_file[MK_MAX_PATH];
+            n = readlink(sr->real_path.data, linked_file, MK_MAX_PATH);
+            if (n < 0) {
+                return mk_http_error(MK_CLIENT_FORBIDDEN, cs, sr, server);
+            }
+        }
+    }
+#endif
+
+    /* Plugin Stage 30: look for handlers for this request */
+    if (sr->stage30_blocked == MK_FALSE) {
+        char *uri;
+
+        if (!index_path) {
+            sr->uri_processed.data[sr->uri_processed.len] = '\0';
+            uri = sr->uri_processed.data;
+        }
+        else {
+            uri = sr->real_path.data + index_bytes;
+        }
+
+        handlers = &sr->host_conf->handlers;
+        mk_list_foreach(head, handlers) {
+            h_handler = mk_list_entry(head, struct mk_vhost_handler, _head);
+            if (re_matchp(h_handler->match, uri, NULL) == -1) {
+                continue;
+            }
+
+            plugin = h_handler->handler;
+            sr->stage30_handler = h_handler->handler;
+            ret = plugin->stage->stage30(plugin, cs, sr,
+                                         h_handler->n_params,
+                                         &h_handler->params);
+
+            MK_TRACE("[FD %i] STAGE_30 returned %i", cs->socket, ret);
+            switch (ret) {
+            case MK_PLUGIN_RET_CONTINUE:
+                return MK_PLUGIN_RET_CONTINUE;
+            case MK_PLUGIN_RET_CLOSE_CONX:
+                if (sr->headers.status > 0) {
+                    return mk_http_error(sr->headers.status, cs, sr, server);
+                }
+                else {
+                    return mk_http_error(MK_CLIENT_FORBIDDEN, cs, sr, server);
+                }
+            case MK_PLUGIN_RET_END:
+                return MK_EXIT_OK;
+            }
+        }
+    }
+
+    /*
+     * Monkey listens for PUT and DELETE methods in addition to GET, POST and
+     * HEAD, but it does not care about them, so if any plugin did not worked
+     * on it, Monkey will return error 501 (501 Not Implemented).
+     */
+    if (sr->method == MK_METHOD_PUT || sr->method == MK_METHOD_DELETE) {
+        return mk_http_error(MK_CLIENT_METHOD_NOT_ALLOWED, cs, sr, server);
+    }
+    else if (sr->method == MK_METHOD_UNKNOWN) {
+        return mk_http_error(MK_SERVER_NOT_IMPLEMENTED, cs, sr, server);
+    }
+
+    /* counter connections */
+    sr->headers.pconnections_left = (int)
+        (server->max_keep_alive_request - cs->counter_connections);
+
+    /* Set default value */
+    mk_header_set_http_status(sr, MK_HTTP_OK);
+    sr->headers.location = NULL;
+    sr->headers.content_length = 0;
+
+    /*
+     * For OPTIONS method, we let the plugin handle it and
+     * return without any content.
+     */
+    if (sr->method == MK_METHOD_OPTIONS) {
+        /* FIXME: OPTIONS NOT WORKING */
+        //sr->headers.allow_methods.data = MK_METHOD_AVAILABLE;
+        //sr->headers.allow_methods.len = strlen(MK_METHOD_AVAILABLE);
+
+        mk_ptr_reset(&sr->headers.content_type);
+        mk_header_prepare(cs, sr, server);
+        return MK_EXIT_OK;
+    }
+    else {
+        mk_ptr_reset(&sr->headers.allow_methods);
+    }
+
+    /* read permissions and check file */
+    if (sr->file_info.read_access == MK_FALSE) {
+        return mk_http_error(MK_CLIENT_FORBIDDEN, cs, sr, server);
+    }
+
+    /* Matching MimeType  */
+    mime = mk_mimetype_find(server, &sr->real_path);
+    if (!mime) {
+        mime = server->mimetype_default;
+    }
+
+    if (sr->file_info.is_directory == MK_TRUE) {
+        return mk_http_error(MK_CLIENT_FORBIDDEN, cs, sr, server);
+    }
+
+    /* get file size */
+    if (sr->file_info.size == 0) {
+        return mk_http_error(MK_CLIENT_NOT_FOUND, cs, sr, server);
+    }
+
+    /* Configure some headers */
+    sr->headers.last_modified = sr->file_info.last_modification;
+    sr->headers.etag_len = snprintf(sr->headers.etag_buf,
+                                    MK_HEADER_ETAG_SIZE,
+                                    "ETag: \"%x-%zx\"\r\n",
+                                    (unsigned int) sr->file_info.last_modification,
+                                    sr->file_info.size);
+
+    if (sr->if_modified_since.data && sr->method == MK_METHOD_GET) {
+        time_t date_client;       /* Date sent by client */
+        time_t date_file_server;  /* Date server file */
+
+        date_client = mk_utils_gmt2utime(sr->if_modified_since.data);
+        date_file_server = sr->file_info.last_modification;
+
+        if (date_file_server <= date_client &&
+            date_client > 0) {
+            mk_header_set_http_status(sr, MK_NOT_MODIFIED);
+            mk_header_prepare(cs, sr, server);
+            return MK_EXIT_OK;
+        }
+    }
+
+    /* Object size for log and response headers */
+    sr->headers.content_length = sr->file_info.size;
+    sr->headers.real_length = sr->file_info.size;
+
+    /* Open file */
+    if (mk_likely(sr->file_info.size > 0)) {
+        sr->file_fd = mk_vhost_open(sr, server);
+        if (sr->file_fd == -1) {
+            MK_TRACE("open() failed");
+            return mk_http_error(MK_CLIENT_FORBIDDEN, cs, sr, server);
+        }
+        sr->in_file.fd           = sr->file_fd;
+        sr->in_file.bytes_offset = 0;
+        sr->in_file.bytes_total  = sr->file_info.size;
+        sr->in_file.stream       = &sr->stream;
+    }
+
+    /* Process methods */
+    if (sr->method == MK_METHOD_GET || sr->method == MK_METHOD_HEAD) {
+        if (mime) {
+            sr->headers.content_type = mime->header_type;
+        }
+
+        /* HTTP Ranges */
+        if (sr->range.data != NULL && server->resume == MK_TRUE) {
+            if (mk_http_range_parse(sr) < 0) {
+                sr->headers.ranges[0] = -1;
+                sr->headers.ranges[1] = -1;
+                return mk_http_error(MK_CLIENT_BAD_REQUEST, cs, sr, server);
+            }
+            if (sr->headers.ranges[0] >= 0 || sr->headers.ranges[1] >= 0) {
+                mk_header_set_http_status(sr, MK_HTTP_PARTIAL);
+            }
+
+            /* Calc bytes to send & offset */
+            if (mk_http_range_set(sr, sr->file_info.size, server) != 0) {
+                sr->headers.content_length = -1;
+                sr->headers.ranges[0] = -1;
+                sr->headers.ranges[1] = -1;
+                return mk_http_error(MK_CLIENT_REQUESTED_RANGE_NOT_SATISF,
+                                     cs, sr, server);
+            }
+        }
+    }
+    else {
+        /* without content-type */
+        mk_ptr_reset(&sr->headers.content_type);
+    }
+
+    /* Send headers */
+    mk_header_prepare(cs, sr, server);
+    if (mk_unlikely(sr->headers.content_length == 0)) {
+        return 0;
+    }
+    /* Send file content */
+    if (sr->method == MK_METHOD_GET || sr->method == MK_METHOD_POST) {
+        /* Note: bytes and offsets are set after the Range check */
+        sr->in_file.type = MK_STREAM_FILE;
+        mk_stream_append(&sr->in_file, &sr->stream);
+    }
+
+    /*
+     * Enable TCP Cork for the remote socket. It will be disabled
+     * later by the file stream on the channel after send the first
+     * file bytes.
+     */
+#if defined(__linux__)
+    sr->in_file.cb_consumed = mk_http_cb_file_on_consume;
+#endif
+
+    /*
+     * Enable CORK/NO_PUSH
+     * -------------------
+     * If it was compiled for Linux, it will turn the Cork off after
+     * send the first round of bytes from the target static file.
+     *
+     * For OSX, it sets TCP_NOPUSH off after send all HTTP headers. Refer
+     * to mk_header.c for more details.
+     */
+    //mk_server_cork_flag(cs->socket, TCP_CORK_ON);
+
+    /* Start sending data to the channel */
+    return MK_EXIT_OK;
+}
+
+/*
+ * Check if a connection can stay open using
+ * the keepalive headers vars and Monkey configuration as criteria
+ */
+int mk_http_keepalive_check(struct mk_http_session *cs,
+                            struct mk_http_request *sr,
+                            struct mk_server *server)
+{
+    if (server->keep_alive == MK_FALSE) {
+        return -1;
+    }
+
+    /* Default Keepalive is off */
+    if (sr->protocol == MK_HTTP_PROTOCOL_10) {
+        cs->close_now = MK_TRUE;
+    }
+    else if (sr->protocol == MK_HTTP_PROTOCOL_11) {
+        cs->close_now = MK_FALSE;
+    }
+
+    if (sr->connection.data) {
+        if (cs->parser.header_connection == MK_HTTP_PARSER_CONN_KA &&
+            sr->protocol == MK_HTTP_PROTOCOL_11) {
+            cs->close_now  = MK_FALSE;
+        }
+        else if (cs->parser.header_connection == MK_HTTP_PARSER_CONN_CLOSE) {
+            cs->close_now  = MK_TRUE;
+        }
+    }
+
+    /* Client has reached keep-alive connections limit */
+    if (cs->counter_connections >= server->max_keep_alive_request) {
+        cs->close_now = MK_TRUE;
+        return -1;
+    }
+
+    return 0;
+}
+
+static inline void mk_http_request_ka_next(struct mk_http_session *cs)
+{
+    cs->body_length = 0;
+    cs->counter_connections++;
+
+    /* Update data for scheduler */
+    cs->init_time = cs->server->clock_context->log_current_utime;
+    cs->status = MK_REQUEST_STATUS_INCOMPLETE;
+
+    /* Initialize parser */
+    mk_http_parser_init(&cs->parser);
+}
+
+int mk_http_request_end(struct mk_http_session *cs, struct mk_server *server)
+{
+    int ret;
+    int status;
+    int len;
+    struct mk_http_request *sr = NULL;
+
+    if (server->max_keep_alive_request <= cs->counter_connections) {
+        cs->close_now = MK_TRUE;
+        goto shutdown;
+    }
+
+    /* Check if we have some enqueued pipeline requests */
+    ret = mk_http_parser_more(&cs->parser, cs->body_length);
+    if (ret == MK_TRUE) {
+        /* Our pipeline request limit is the same that our keepalive limit */
+        cs->counter_connections++;
+        len = (cs->body_length - cs->parser.i) -1;
+        memmove(cs->body,
+                cs->body + cs->parser.i + 1,
+                len);
+        cs->body_length = len;
+
+        /* Prepare for next one */
+        sr = mk_list_entry_first(&cs->request_list, struct mk_http_request, _head);
+        mk_http_request_free(sr, server);
+        mk_http_request_init(cs, sr, server);
+        mk_http_parser_init(&cs->parser);
+        status = mk_http_parser(sr, &cs->parser, cs->body, cs->body_length,
+                                server);
+        if (status == MK_HTTP_PARSER_OK) {
+            ret = mk_http_request_prepare(cs, sr, server);
+            if (ret == MK_EXIT_ABORT) {
+                return -1;
+            }
+
+            /*
+             * Return 1 means, we still have more data to send in a different
+             * scheduler round.
+             */
+            return 1;
+        }
+        else if (status == MK_HTTP_PARSER_PENDING) {
+            return 0;
+        }
+        else if (status == MK_HTTP_PARSER_ERROR) {
+            cs->close_now = MK_TRUE;
+        }
+    }
+
+ shutdown:
+    /*
+     * We need to ask to http_keepalive if this
+     * connection can continue working or we must
+     * close it.
+     */
+    if (cs->close_now == MK_TRUE) {
+        MK_TRACE("[FD %i] No KeepAlive mode, remove", cs->conn->event.fd);
+        mk_http_session_remove(cs, server);
+        return -1;
+    }
+    else {
+        mk_http_request_free_list(cs, server);
+        mk_http_request_ka_next(cs);
+        mk_sched_conn_timeout_add(cs->conn, mk_sched_get_thread_conf());
+        return 0;
+    }
+
+    return -1;
+}
+
+void cb_stream_page_finished(struct mk_stream_input *in)
+{
+    mk_ptr_t *page = in->buffer;
+
+    mk_ptr_free(page);
+    mk_mem_free(page);
+}
+
+/* Enqueue an error response. This function always returns MK_EXIT_OK */
+int mk_http_error(int http_status, struct mk_http_session *cs,
+                  struct mk_http_request *sr,
+                  struct mk_server *server)
+{
+    int ret, fd;
+    size_t count;
+    mk_ptr_t message;
+    mk_ptr_t page;
+    struct mk_vhost_error_page *entry;
+    struct mk_list *head;
+    struct file_info finfo;
+    struct mk_iov *iov;
+
+    /* This function requires monkey to be properly initialized which is not the case
+     * when it's just used to parse http requests in fluent-bit so we want it to ignore
+     * that case and let fluent-bit handle it.
+    */
+    if (server->workers == 0) {
+        return MK_EXIT_OK;
+    }
+
+    mk_header_set_http_status(sr, http_status);
+    mk_ptr_reset(&page);
+
+    /*
+     * We are nice sending error pages for clients who at least respect
+     * the especification
+     */
+    if (http_status != MK_CLIENT_LENGTH_REQUIRED &&
+        http_status != MK_CLIENT_BAD_REQUEST &&
+        http_status != MK_CLIENT_REQUEST_ENTITY_TOO_LARGE) {
+
+        /* Lookup a customized error page */
+        mk_list_foreach(head, &sr->host_conf->error_pages) {
+            entry = mk_list_entry(head, struct mk_vhost_error_page, _head);
+            if (entry->status != http_status) {
+                continue;
+            }
+
+            /* validate error file */
+            ret = mk_file_get_info(entry->real_path, &finfo, MK_FILE_READ);
+            if (ret == -1) {
+                break;
+            }
+
+            /* open file */
+            fd = open(entry->real_path, server->open_flags);
+            if (fd == -1) {
+                break;
+            }
+            /* This fd seems to be leaked, we need to verify this logic */
+
+            /* Outgoing headers */
+            sr->headers.content_length = finfo.size;
+            sr->headers.real_length    = finfo.size;
+            mk_header_prepare(cs, sr, server);
+
+            /* Stream setup */
+            mk_stream_in_file(&sr->stream, &sr->in_file, sr->file_fd,
+                              finfo.size, 0, NULL, NULL);
+            return MK_EXIT_OK;
+        }
+    }
+
+    mk_ptr_reset(&message);
+
+    switch (http_status) {
+    case MK_CLIENT_FORBIDDEN:
+        mk_http_error_page("Forbidden",
+                           &sr->uri,
+                           server->server_signature,
+                           &page.data, &page.len);
+        break;
+    case MK_CLIENT_NOT_FOUND:
+        mk_string_build(&message.data, &message.len,
+                        "The requested URL was not found on this server.");
+        mk_http_error_page("Not Found",
+                           &message,
+                           server->server_signature,
+                           &page.data, &page.len);
+        mk_ptr_free(&message);
+        break;
+    case MK_CLIENT_REQUEST_ENTITY_TOO_LARGE:
+        mk_string_build(&message.data, &message.len,
+                        "The request entity is too large.");
+        mk_http_error_page("Entity too large",
+                           &message,
+                           server->server_signature,
+                           &page.data, &page.len);
+        mk_ptr_free(&message);
+        break;
+    case MK_CLIENT_METHOD_NOT_ALLOWED:
+        mk_http_error_page("Method Not Allowed",
+                           &sr->uri,
+                           server->server_signature,
+                           &page.data, &page.len);
+        break;
+    case MK_SERVER_NOT_IMPLEMENTED:
+        mk_http_error_page("Method Not Implemented",
+                           &sr->uri,
+                           server->server_signature,
+                           &page.data, &page.len);
+        break;
+    case MK_SERVER_INTERNAL_ERROR:
+        mk_http_error_page("Internal Server Error",
+                           &sr->uri,
+                           server->server_signature,
+                           &page.data, &page.len);
+        break;
+    }
+
+    if (page.len > 0 && sr->method != MK_METHOD_HEAD && sr->method != MK_METHOD_UNKNOWN) {
+        sr->headers.content_length = page.len;
+    }
+    else {
+        sr->headers.content_length = 0;
+    }
+
+    sr->headers.location = NULL;
+    sr->headers.cgi = SH_NOCGI;
+    sr->headers.pconnections_left = 0;
+    sr->headers.last_modified = -1;
+
+    if (!page.data) {
+        mk_ptr_reset(&sr->headers.content_type);
+    }
+    else {
+        mk_ptr_set(&sr->headers.content_type, "Content-Type: text/html\r\n");
+    }
+
+    mk_header_prepare(cs, sr, server);
+    if (page.data) {
+        if (sr->method != MK_METHOD_HEAD) {
+            if (sr->headers._extra_rows) {
+                iov = sr->headers._extra_rows;
+                sr->in_headers_extra.bytes_total += page.len;
+            }
+            else {
+                iov = &sr->headers.headers_iov;
+                sr->in_headers.bytes_total += page.len;
+            }
+            mk_iov_add(iov, page.data, page.len, MK_TRUE);
+        }
+        else {
+            mk_mem_free(page.data);
+        }
+    }
+
+    mk_channel_write(cs->channel, &count);
+    mk_http_request_end(cs, server);
+
+    return MK_EXIT_OK;
+}
+
+/*
+ * From thread mk_sched_worker "list", remove the http_session
+ * struct information
+ */
+void mk_http_session_remove(struct mk_http_session *cs,
+                            struct mk_server *server)
+{
+    struct mk_list *tmp;
+    struct mk_list *head;
+    struct mk_plugin *handler;
+    struct mk_http_request *sr;
+
+    MK_TRACE("[FD %i] HTTP Session remove", cs->socket);
+    if (cs->_sched_init == MK_FALSE) {
+        return;
+    }
+
+    /* On session remove, make sure to cleanup any handler */
+    mk_list_foreach_safe(head, tmp, &cs->request_list) {
+        sr = mk_list_entry(head, struct mk_http_request, _head);
+        if (sr->stage30_handler) {
+            MK_TRACE("Hangup stage30 handler");
+            handler = sr->stage30_handler;
+            if (mk_unlikely(!handler->stage->stage30_hangup)) {
+                mk_warn("Plugin %s, do not implement stage30_hangup", handler->name);
+                continue;
+            }
+            handler->stage->stage30_hangup(handler, cs, sr);
+        }
+    }
+
+    if (cs->body != cs->body_fixed) {
+        mk_mem_free(cs->body);
+    }
+    mk_http_request_free_list(cs, server);
+    mk_list_del(&cs->request_list);
+
+    cs->_sched_init = MK_FALSE;
+}
+
+/* FIXME: nobody is using this */
+struct mk_http_session *mk_http_session_lookup(int socket)
+{
+    (void) socket;
+	return NULL;
+}
+
+
+/* Initialize a HTTP session (just created) */
+int mk_http_session_init(struct mk_http_session *cs, struct mk_sched_conn *conn,
+                         struct mk_server *server)
+{
+    /* Alloc memory for node */
+    cs->_sched_init = MK_TRUE;
+    cs->pipelined = MK_FALSE;
+    cs->counter_connections = 0;
+    cs->close_now = MK_FALSE;
+    cs->socket = conn->event.fd;
+    cs->status = MK_REQUEST_STATUS_INCOMPLETE;
+    cs->server = server;
+
+    /* Map the channel, just for protocol-handler internal stuff */
+    cs->channel = &conn->channel;
+
+    /* Map the connection instance, required to handle exceptions */
+    cs->conn = conn;
+
+    /* creation time in unix time */
+    cs->init_time = conn->arrive_time;
+
+    /* alloc space for body content */
+    if (conn->net->buffer_size > MK_REQUEST_CHUNK) {
+        cs->body = mk_mem_alloc(conn->net->buffer_size);
+        cs->body_size = conn->net->buffer_size;
+    }
+    else {
+        /* Buffer size based in Chunk bytes */
+        cs->body = cs->body_fixed;
+        cs->body_size = MK_REQUEST_CHUNK;
+    }
+
+    /* Current data length */
+    cs->body_length = 0;
+
+    /* Init session request list */
+    mk_list_init(&cs->request_list);
+
+    /* Initialize the parser */
+    mk_http_parser_init(&cs->parser);
+
+    return 0;
+}
+
+
+void mk_http_request_free(struct mk_http_request *sr, struct mk_server *server)
+{
+    /* Let the vhost interface to handle the session close */
+    mk_vhost_close(sr, server);
+
+    if (sr->headers.location) {
+        mk_mem_free(sr->headers.location);
+    }
+
+    if (sr->uri_processed.data != sr->uri.data) {
+        mk_ptr_free(&sr->uri_processed);
+    }
+
+    if (sr->real_path.data != sr->real_path_static) {
+        mk_ptr_free(&sr->real_path);
+    }
+
+    if (sr->stream.channel) {
+        mk_stream_release(&sr->stream);
+    }
+}
+
+void mk_http_request_free_list(struct mk_http_session *cs,
+                               struct mk_server *server)
+{
+    struct mk_list *head, *tmp;
+    struct mk_http_request *request;
+
+    /* sr = last node */
+    MK_TRACE("[FD %i] Free struct client_session", cs->socket);
+    mk_list_foreach_safe(head, tmp, &cs->request_list) {
+        request = mk_list_entry(head, struct mk_http_request, _head);
+        mk_list_del(&request->_head);
+
+        mk_http_request_free(request, server);
+        if (request != &cs->sr_fixed) {
+            mk_mem_free(request);
+        }
+    }
+}
+
+/*
+ * Lookup a known header or a non-known header. For unknown headers
+ * set the 'key' value wth a lowercase string
+ */
+struct mk_http_header *mk_http_header_get(int name, struct mk_http_request *req,
+                                          const char *key, unsigned int len)
+{
+    int i;
+    struct mk_http_parser *parser = &req->session->parser;
+    struct mk_http_header *header;
+
+    /* Known header */
+    if (name >= 0 && name < MK_HEADER_SIZEOF) {
+        return &parser->headers[name];
+    }
+
+    /* Check if want to retrieve a custom header */
+    if (name == MK_HEADER_OTHER) {
+        /* Iterate over the extra headers identified by the parser */
+        for (i = 0; i < parser->headers_extra_count; i++) {
+            header = &parser->headers_extra[i];
+            if (header->key.len != len) {
+                continue;
+            }
+
+            if (strncmp(header->key.data, key, len) == 0) {
+                return header;
+            }
+        }
+        return NULL;
+    }
+
+    return NULL;
+}
+
+/*
+ * Main callbacks for the Scheduler
+ */
+int mk_http_sched_read(struct mk_sched_conn *conn,
+                       struct mk_sched_worker *worker,
+                       struct mk_server *server)
+{
+    int ret;
+    int status;
+    size_t count;
+    (void) worker;
+    struct mk_http_session *cs;
+    struct mk_http_request *sr;
+
+#ifdef MK_HAVE_TRACE
+    int socket = conn->event.fd;
+#endif
+
+    cs = mk_http_session_get(conn);
+    if (cs->_sched_init == MK_FALSE) {
+        /* Create session for the client */
+        MK_TRACE("[FD %i] Create HTTP session", socket);
+        ret  = mk_http_session_init(cs, conn, server);
+        if (ret == -1) {
+            return -1;
+        }
+    }
+
+    /* Invoke the read handler, on this case we only support HTTP (for now :) */
+    ret = mk_http_handler_read(conn, cs, server);
+    if (ret > 0) {
+        if (mk_list_is_empty(&cs->request_list) == 0) {
+            /* Add the first entry */
+            sr = &cs->sr_fixed;
+            mk_list_add(&sr->_head, &cs->request_list);
+            mk_http_request_init(cs, sr, server);
+        }
+        else {
+            sr = mk_list_entry_first(&cs->request_list, struct mk_http_request, _head);
+        }
+        status = mk_http_parser(sr, &cs->parser, cs->body,
+                                cs->body_length, server);
+        if (status == MK_HTTP_PARSER_OK) {
+            MK_TRACE("[FD %i] HTTP_PARSER_OK", socket);
+            if (mk_http_status_completed(cs, conn) == -1) {
+                mk_http_session_remove(cs, server);
+                return -1;
+            }
+            mk_sched_conn_timeout_del(conn);
+            ret = mk_http_request_prepare(cs, sr, server);
+        }
+        else if (status == MK_HTTP_PARSER_ERROR) {
+            /* The HTTP parser may enqueued some response error */
+            if (mk_channel_is_empty(cs->channel) != 0) {
+                mk_channel_write(cs->channel, &count);
+            }
+            mk_http_session_remove(cs, server);
+            MK_TRACE("[FD %i] HTTP_PARSER_ERROR", socket);
+            return -1;
+        }
+        else {
+            MK_TRACE("[FD %i] HTTP_PARSER_PENDING", socket);
+        }
+    }
+
+    return ret;
+}
+
+/* The scheduler got a connection close event from the remote client */
+int mk_http_sched_close(struct mk_sched_conn *conn,
+                        struct mk_sched_worker *sched,
+                        int type, struct mk_server *server)
+{
+    struct mk_http_session *session;
+    (void) sched;
+
+#ifdef MK_HAVE_TRACE
+    MK_TRACE("[FD %i] HTTP sched close (type=%i)", conn->event.fd, type);
+#else
+    (void) type;
+#endif
+
+    /* Release resources of the requests and session */
+    session = mk_http_session_get(conn);
+    mk_http_session_remove(session, server);
+    return 0;
+}
+
+int mk_http_sched_done(struct mk_sched_conn *conn,
+                       struct mk_sched_worker *worker,
+                       struct mk_server *server)
+{
+    (void) worker;
+    struct mk_http_session *session;
+    struct mk_http_request *sr;
+
+    session = mk_http_session_get(conn);
+    sr = mk_list_entry_first(&session->request_list,
+                             struct mk_http_request, _head);
+    mk_plugin_stage_run_40(session, sr, server);
+
+    return mk_http_request_end(session, server);
+}
+
+struct mk_sched_handler mk_http_handler = {
+    .name             = "http",
+    .cb_read          = mk_http_sched_read,
+    .cb_close         = mk_http_sched_close,
+    .cb_done          = mk_http_sched_done,
+    .sched_extra_size = sizeof(struct mk_http_session),
+    .capabilities     = MK_CAP_HTTP
+};
diff --git a/fluent-bit/lib/monkey/mk_server/mk_http2.c b/fluent-bit/lib/monkey/mk_server/mk_http2.c
new file mode 100644
index 00000000..7a4f1e82
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_http2.c
@@ -0,0 +1,384 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#define _GNU_SOURCE
+
+#include <inttypes.h>
+
+#include <monkey/mk_http2.h>
+#include <monkey/mk_http2_settings.h>
+#include <monkey/mk_header.h>
+#include <monkey/mk_scheduler.h>
+
+/* HTTP/2 Connection Preface */
+#define MK_HTTP2_PREFACE "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
+static mk_ptr_t http2_preface = {
+    .data = MK_HTTP2_PREFACE,
+    .len  = sizeof(MK_HTTP2_PREFACE) - 1
+};
+
+static inline void buffer_consume(struct mk_http2_session *h2s, int bytes)
+{
+    memmove(h2s->buffer,
+            h2s->buffer + bytes,
+            h2s->buffer_length - bytes);
+
+    MK_TRACE("[h2] consume buffer length from %i to %i",
+             h2s->buffer_length, h2s->buffer_length - bytes);
+    h2s->buffer_length -= bytes;
+}
+
+static struct mk_http2_session *mk_http2_session_create()
+{
+    struct mk_http2_session *h2s;
+
+    h2s = mk_mem_alloc(sizeof(struct mk_http2_session));
+    if (!h2s) {
+        return NULL;
+    }
+    h2s->buffer = NULL;
+    h2s->buffer_length = 0;
+    h2s->buffer_size = sizeof(h2s->buffer_fixed);
+    h2s->buffer = h2s->buffer_fixed;
+    h2s->settings = MK_HTTP2_SETTINGS_DEFAULT;
+
+    return h2s;
+}
+
+/* FIXME
+static int mk_http2_session_destroy(struct mk_http2_session *h2s)
+{
+    if (h2s->buffer != h2s->buffer_fixed) {
+        mk_mem_free(h2s->buffer);
+    }
+    mk_mem_free(h2s);
+    return 0;
+}
+
+static int mk_http2_frame_header(char *buf, uint32_t length, uint8_t type,
+                                 uint32_t flags, void *data)
+{
+    struct mk_http2_frame *f = (struct mk_http2_frame *) buf;
+
+    f->len_type = (length << 8 | type);
+    f->flags    = flags;
+    f->payload  = data;
+
+    return sizeof(struct mk_http2_frame);
+}
+
+*/
+
+/* Handle an upgraded session */
+static int mk_http2_upgrade(void *cs, void *sr, struct mk_server *server)
+{
+    struct mk_http_session *s = cs;
+    struct mk_http_request *r = sr;
+    struct mk_http2_session *h2s;
+
+    mk_header_set_http_status(r, MK_INFO_SWITCH_PROTOCOL);
+    r->headers.connection = MK_HEADER_CONN_UPGRADED;
+    r->headers.upgrade = MK_HEADER_UPGRADED_H2C;
+    mk_header_prepare(s, r, server);
+
+    h2s = mk_http2_session_create();
+    if (!h2s) {
+        return -1;
+    }
+
+    h2s->status = MK_HTTP2_UPGRADED;
+    s->conn->data = h2s;
+
+    return MK_HTTP_OK;
+}
+
+/* FIXME Decode a frame header, no more... no less
+static inline void mk_http2_frame_decode_header(uint8_t *buf,
+                                                struct mk_http2_frame *frame)
+{
+    struct mk_http2_session *h2s;
+    (void) h2s;
+
+    frame->len_type  = mk_http2_bitdec_32u(buf);
+    frame->flags     = buf[4];
+    frame->stream_id = mk_http2_bitdec_stream_id(buf + 5);
+    frame->payload   = buf + 9;
+
+#ifdef MK_HAVE_TRACE
+    MK_TRACE("Frame Header");
+    printf(" length=%i, type=%i, stream_id=%i\n",
+           mk_http2_frame_len(frame),
+           mk_http2_frame_type(frame),
+           frame->stream_id);
+#endif
+}
+*/
+
+static inline int mk_http2_handle_settings(struct mk_sched_conn *conn,
+                                           struct mk_http2_frame *frame)
+{
+    int i;
+    int frame_len;
+    int settings;
+    int setting_size = 6; /* 16 bits identifier + 32 bits value = 6 bytes */
+    uint16_t setting_id;
+    uint32_t setting_value;
+    uint8_t *p;
+    struct mk_http2_session *h2s;
+
+    h2s = conn->data;
+    frame_len = mk_http2_frame_len(frame);
+    if (frame->flags == MK_HTTP2_SETTINGS_ACK) {
+        /*
+         * Nothing to do, the peer just received our SETTINGS and it's
+         * sending an acknowledge.
+         *
+         * note: validate that frame length is zero.
+         */
+        if (frame_len > 0) {
+            /*
+             * This must he handled as a connection error, we must reply
+             * with a FRAME_SIZE_ERROR. ref:
+             *
+             *  https://httpwg.github.io/specs/rfc7540.html#SETTINGS
+             */
+
+            /* FIXME: send a GOAWAY error frame */
+            MK_TRACE("FRAME SIZE ERR: %i\n", frame_len);
+            return -1;
+
+        }
+        return 0;
+    }
+
+    /*
+     * Iterate our SETTINGS payload, it may contain many entries in the
+     * following format:
+     *
+     * +-------------------------------+
+     * |       Identifier (16)         |
+     * +-------------------------------+-------------------------------+
+     * |                        Value (32)                             |
+     * +---------------------------------------------------------------+
+     *
+     * 48 bits = 6 bytes
+     */
+    settings = (frame_len / setting_size);
+    for (i = 0; i < settings; i++ ) {
+        /* Seek payload per SETTINGS entry */
+        p = frame->payload + (setting_size * i);
+
+        setting_id = p[0] << 8 | p[1];
+        setting_value = p[2] << 24 | p[3] << 16 | p[4] << 8  | p[5];
+        MK_H2_TRACE(conn, "[Setting] ID=%" PRIu16 " VAL=%" PRIu32,
+                    setting_id, setting_value);
+
+        switch (setting_id) {
+        case MK_HTTP2_SETTINGS_HEADER_TABLE_SIZE:
+            /* unhandled */
+            break;
+        case MK_HTTP2_SETTINGS_ENABLE_PUSH:
+            if (setting_value != 0 && setting_value != 1) {
+                /* FIXME: PROTOCOL_ERROR */
+                MK_H2_TRACE(conn, "Invalid SETTINGS_ENABLE_PUSH");
+                return -1;
+            }
+            h2s->settings.enable_push = setting_value;
+            break;
+        case MK_HTTP2_SETTINGS_MAX_CONCURRENT_STREAMS:
+            if (setting_value < 64) {
+                h2s->settings.max_concurrent_streams = setting_value;
+            }
+            else {
+                h2s->settings.max_concurrent_streams = 64;
+            }
+            MK_H2_TRACE(conn, "SETTINGS MAX_CONCURRENT_STREAMS=%i",
+                        setting_value);
+            break;
+        case MK_HTTP2_SETTINGS_INITIAL_WINDOW_SIZE:
+            if (setting_value < 65535 || setting_value > 2147483647) {
+                /* FIXME: send FLOW_CONTROL_ERROR */
+                MK_H2_TRACE(conn, "Invalid INITIAL_WINDOW_SIZE");
+                return -1;
+            }
+            h2s->settings.initial_window_size = setting_value;
+            break;
+        case MK_HTTP2_SETTINGS_MAX_FRAME_SIZE:
+            if (setting_value < 16384 || setting_value > 2147483647) {
+                /* FIXME: send PROTOCOL_ERROR */
+                return -1;
+            }
+            h2s->settings.max_frame_size = setting_value;
+            break;
+        case MK_HTTP2_SETTINGS_MAX_HEADER_LIST_SIZE:
+            /* Unhandled */
+            break;
+        default:
+            /*
+             * 5.5 Extending HTTP/2: ...Implementations MUST ignore unknown
+             * or unsupported values in all extensible protocol elements...
+             */
+            break;
+        }
+    }
+
+    /* FIXME // No errors, send the ACK
+    mk_http2_send_raw(conn, MK_HTTP2_SETTINGS_ACK_FRAME,
+                      sizeof(MK_HTTP2_SETTINGS_ACK_FRAME) - 1);
+    */
+    return 0;
+}
+
+
+static inline int mk_http2_frame_run(struct mk_sched_conn *conn,
+                                     struct mk_sched_worker *worker)
+{
+    int ret;
+    struct mk_http2_frame frame;
+    struct mk_http2_session *h2s;
+    (void) worker;
+
+    h2s = conn->data;
+
+    /* Decode the frame header */
+    //FIXME mk_http2_frame_decode_header(h2s->buffer, &frame);
+
+    /* Do some validations */
+    if (h2s->buffer_length < (MK_HTTP2_HEADER_SIZE + (frame.len_type >> 8))) {
+        /* FIXME: need more data */
+        return 0;
+    }
+
+    /* Do some work based on the frame type */
+    if (mk_http2_frame_type(&frame) == MK_HTTP2_SETTINGS) {
+        ret = mk_http2_handle_settings(conn, &frame);
+        /* FIXME: send our MK_HTTP2_SETTINGS_ACK_FRAME */
+        return ret;
+    }
+
+    return 0;
+}
+
+static int mk_http2_sched_read(struct mk_sched_conn *conn,
+                               struct mk_sched_worker *worker,
+                               struct mk_server *server)
+{
+    int bytes;
+    int new_size;
+    int available;
+    char *tmp;
+    struct mk_http2_session *h2s;
+    (void) worker;
+    (void) server;
+
+    h2s = conn->data;
+    available = h2s->buffer_size - h2s->buffer_length;
+    if (available == 0) {
+        new_size = h2s->buffer_size + MK_HTTP2_CHUNK;
+        if (h2s->buffer == h2s->buffer_fixed) {
+            h2s->buffer = mk_mem_alloc(new_size);
+            if (!h2s->buffer) {
+                /* FIXME: send internal server error ? */
+                return -1;
+            }
+            memcpy(h2s->buffer, h2s->buffer_fixed, h2s->buffer_length);
+            MK_TRACE("[FD %i] Buffer new size: %i, length: %i",
+                     conn->event.fd, new_size, h2s->buffer_length);
+        }
+        else {
+            MK_TRACE("[FD %i] Buffer realloc from %i to %i",
+                     conn->event.fd, h2s->buffer_size, new_size);
+            tmp = mk_mem_realloc(h2s->buffer, new_size);
+            if (tmp) {
+                h2s->buffer = tmp;
+                h2s->buffer_size = new_size;
+            }
+            else {
+                /* FIXME: send internal server error ? */
+                return -1;
+            }
+
+        }
+    }
+
+    /* Read the incoming data */
+    bytes = mk_sched_conn_read(conn,
+                               h2s->buffer,
+                               h2s->buffer_size - h2s->buffer_length);
+    if (bytes == 0) {
+        errno = 0;
+        return -1;
+    }
+    else if (bytes == -1) {
+        return -1;
+    }
+
+    h2s->buffer_length += bytes;
+
+    /* Upgraded connections from HTTP/1.x requires the preface */
+    if (h2s->status == MK_HTTP2_UPGRADED) {
+        if (h2s->buffer_length >= http2_preface.len) {
+            if (memcmp(h2s->buffer,
+                       http2_preface.data, http2_preface.len) != 0) {
+                MK_H2_TRACE(conn, "Invalid HTTP/2 preface");
+                return 0;
+            }
+
+            MK_H2_TRACE(conn, "HTTP/2 preface OK");
+
+            buffer_consume(h2s, http2_preface.len);
+            h2s->status = MK_HTTP2_OK;
+
+            /* Send out our default settings
+            mk_stream_set(&h2s->stream_settings,
+                          MK_STREAM_RAW,
+                          &conn->channel,
+                          MK_HTTP2_SETTINGS_DEFAULT_FRAME,
+                          sizeof(MK_HTTP2_SETTINGS_DEFAULT_FRAME) - 1,
+                          NULL,
+                          NULL, NULL, NULL);
+            */
+        }
+        else {
+            /* We need more data */
+            return 0;
+        }
+    }
+
+    /* Check that we have a minimum header size */
+    if (h2s->buffer_length < MK_HTTP2_HEADER_SIZE) {
+        MK_TRACE("HEADER FRAME incomplete %i/%i bytes",
+                 h2s->buffer_length, MK_HTTP2_HEADER_SIZE);
+        return 0;
+    }
+
+    /* We have at least one frame */
+    return mk_http2_frame_run(conn, worker);
+}
+
+
+struct mk_sched_handler mk_http2_handler = {
+    .name             = "http2",
+    .cb_read          = mk_http2_sched_read,
+    .cb_close         = NULL,
+    .cb_done          = NULL,
+    .cb_upgrade       = mk_http2_upgrade,
+    .sched_extra_size = sizeof(struct mk_http2_session),
+    .capabilities     = MK_CAP_HTTP2
+};
diff --git a/fluent-bit/lib/monkey/mk_server/mk_http_parser.c b/fluent-bit/lib/monkey/mk_server/mk_http_parser.c
new file mode 100644
index 00000000..4e7aa316
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_http_parser.c
@@ -0,0 +1,744 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <stdint.h>
+#include <limits.h>
+
+#include <monkey/mk_http.h>
+#include <monkey/mk_http_parser.h>
+#include <monkey/mk_http_status.h>
+
+#define mark_end()                              \
+    p->end = p->i;                              \
+    p->chars = -1;
+
+#define start_next()                            \
+    p->start = p->i + 1;                        \
+    continue
+
+#define field_len()   (p->end - p->start)
+#define header_scope_eq(p, x) p->header_min = p->header_max = x
+
+struct row_entry {
+    int len;
+    const char name[32];
+};
+
+struct row_entry mk_methods_table[] = {
+    { 3, "GET"     },
+    { 4, "POST"    },
+    { 4, "HEAD"    },
+    { 3, "PUT"     },
+    { 6, "DELETE"  },
+    { 7, "OPTIONS" }
+};
+
+struct row_entry mk_headers_table[] = {
+    {  6, "accept"              },
+    { 14, "accept-charset"      },
+    { 15, "accept-encoding"     },
+    { 15, "accept-language"     },
+    { 13, "authorization"       },
+    { 13, "cache-control"       },
+    {  6, "cookie"              },
+    { 10, "connection"          },
+    { 14, "content-length"      },
+    { 13, "content-range"       },
+    { 12, "content-type"        },
+    {  4, "host"                },
+    { 14, "http2-settings"      },
+    { 17, "if-modified-since"   },
+    { 13, "last-modified"       },
+    { 19, "last-modified-since" },
+    {  5, "range"               },
+    {  7, "referer"             },
+    {  7, "upgrade"             },
+    { 10, "user-agent"          }
+};
+
+static inline void reverse_char_lookup(char *buf, char c, int len, struct mk_http_parser *p)
+{
+    int x = 0;
+    int y = 0;
+
+    x = p->i;
+    do {
+        if (buf[x - y] == c) {
+            p->i = x - y;
+            return;
+        }
+        y++;
+    } while (y < len);
+}
+
+static inline void char_lookup(char *buf, char c, int len, struct mk_http_parser *p)
+{
+    int x = 0;
+
+    x = p->i;
+    do {
+        if (buf[x] == c) {
+            p->i = x;
+            return;
+        }
+        x++;
+    } while (x < len);
+}
+
+static inline int str_searchr(char *buf, char c, int len)
+{
+    int i;
+
+    for (i = len - 1; i >= 0; i--) {
+        if (buf[i] == c) {
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+static inline int method_lookup(struct mk_http_request *req,
+                                struct mk_http_parser *p, char *buffer)
+{
+    int i = 0;
+    int len;
+
+    /* Method lenght */
+    len = field_len();
+
+    /* Point the buffer */
+    req->method = MK_METHOD_UNKNOWN;
+    req->method_p.data = buffer + p->start;
+    req->method_p.len  = len;
+
+    if (p->method >= 0) {
+        if (strncmp(buffer + p->start + 1,
+                    mk_methods_table[p->method].name + 1,
+                    len - 1) == 0) {
+            req->method = p->method;
+            return req->method;
+        }
+    }
+
+    for (i = 0; i < MK_METHOD_SIZEOF; i++) {
+        if (len != mk_methods_table[i].len) {
+            continue;
+        }
+
+        if (strncmp(buffer + p->start, mk_methods_table[i].name, len) == 0) {
+            req->method = i;
+            return i;
+        }
+    }
+    return MK_METHOD_UNKNOWN;
+}
+
+static inline void request_set(mk_ptr_t *ptr, struct mk_http_parser *p, char *buffer)
+{
+    ptr->data = buffer + p->start;
+    ptr->len  = field_len();
+}
+
+/*
+ * expected: a known & expected value in lowercase
+ * value   : the expected string value in the header
+ * len     : the value string length.
+ *
+ * If it matches it return zero. Otherwise -1.
+ */
+static inline int header_cmp(const char *expected, char *value, int len)
+{
+    int i = 0;
+
+    if (len >= 8) {
+        if (expected[0] != tolower(value[0])) return -1;
+        if (expected[1] != tolower(value[1])) return -1;
+        if (expected[2] != tolower(value[2])) return -1;
+        if (expected[3] != tolower(value[3])) return -1;
+        if (expected[4] != tolower(value[4])) return -1;
+        if (expected[5] != tolower(value[5])) return -1;
+        if (expected[6] != tolower(value[6])) return -1;
+        if (expected[7] != tolower(value[7])) return -1;
+        i = 8;
+    }
+
+    for (; i < len; i++) {
+        if (expected[i] != tolower(value[i])) {
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+static inline int header_lookup(struct mk_http_parser *p, char *buffer)
+{
+    int i;
+    int len;
+    int pos;
+    long val;
+    char *endptr;
+    char *tmp;
+
+    struct mk_http_header *header;
+    struct mk_http_header *header_extra;
+    struct row_entry *h;
+
+    len = (p->header_sep - p->header_key);
+    for (i = p->header_min; i <= p->header_max && i >= 0; i++) {
+        h = &mk_headers_table[i];
+        /* Check string length first */
+        if (h->len != len) {
+            continue;
+        }
+
+        if (header_cmp(h->name + 1, buffer + p->header_key + 1, len - 1) == 0) {
+            /* We got a header match, register the header index */
+            header = &p->headers[i];
+            header->type = i;
+            header->key.data = buffer + p->header_key;
+            header->key.len  = len;
+            header->val.data = buffer + p->header_val;
+            header->val.len  = p->end - p->header_val;
+            p->header_count++;
+            mk_list_add(&header->_head, &p->header_list);
+
+            if (i == MK_HEADER_HOST) {
+                /* Handle a possible port number in the Host header */
+                int sep = str_searchr(header->val.data, ':', header->val.len);
+                if (sep > 0) {
+                    int plen;
+                    short int port_size = 6;
+                    char port[6]; /* Can't use port_size to declare a stack allocated array in vc++ */
+
+                    plen = header->val.len - sep - 1;
+                    if (plen <= 0 || plen >= port_size) {
+                        return -MK_CLIENT_BAD_REQUEST;
+                    }
+                    memcpy(&port, header->val.data + sep + 1, plen);
+                    port[plen] = '\0';
+
+                    errno = 0;
+                    val = strtol(port, &endptr, 10);
+                    if ((errno == ERANGE && (val == LONG_MAX || val == LONG_MIN))
+                        || (errno != 0 && val == 0)) {
+                        return -MK_CLIENT_BAD_REQUEST;
+                    }
+
+                    if (endptr == port || *endptr != '\0') {
+                        return -MK_CLIENT_BAD_REQUEST;
+                    }
+
+                    p->header_host_port = val;
+
+                    /* Re-set the Host header value without port */
+                    header->val.len = sep;
+                }
+            }
+            else if (i == MK_HEADER_CONTENT_LENGTH) {
+                errno = 0;
+                val = strtol(header->val.data, &endptr, 10);
+                if ((errno == ERANGE && (val == LONG_MAX || val == LONG_MIN))
+                    || (errno != 0 && val == 0)) {
+                    return -MK_CLIENT_REQUEST_ENTITY_TOO_LARGE;
+                }
+                if (endptr == header->val.data) {
+                    return -1;
+                }
+                if (val < 0) {
+                    return -1;
+                }
+
+                p->header_content_length = val;
+            }
+            else if (i == MK_HEADER_CONNECTION) {
+                /* Check Connection: Keep-Alive */
+                if (header->val.len == sizeof(MK_CONN_KEEP_ALIVE) - 1) {
+                    if (header_cmp(MK_CONN_KEEP_ALIVE,
+                                   header->val.data,
+                                   header->val.len ) == 0) {
+                        p->header_connection = MK_HTTP_PARSER_CONN_KA;
+                    }
+                }
+                /* Check Connection: Close */
+                else if (header->val.len == sizeof(MK_CONN_CLOSE) -1) {
+                    if (header_cmp(MK_CONN_CLOSE,
+                                   header->val.data, header->val.len) == 0) {
+                        p->header_connection = MK_HTTP_PARSER_CONN_CLOSE;
+                    }
+                }
+                else {
+                    p->header_connection = MK_HTTP_PARSER_CONN_UNKNOWN;
+
+                    /* Try to find some known values */
+
+                    /* Connection: upgrade */
+                    pos = mk_string_search_n(header->val.data,
+                                             "Upgrade",
+                                             MK_STR_INSENSITIVE,
+                                             header->val.len);
+                    if (pos >= 0) {
+                        p->header_connection = MK_HTTP_PARSER_CONN_UPGRADE;
+                    }
+
+                    /* Connection: HTTP2-Settings */
+                    pos = mk_string_search_n(header->val.data,
+                                             "HTTP2-Settings",
+                                             MK_STR_INSENSITIVE,
+                                             header->val.len);
+                    if (pos >= 0) {
+                        p->header_connection |= MK_HTTP_PARSER_CONN_HTTP2_SE;
+                    }
+                }
+            }
+            else if (i == MK_HEADER_UPGRADE) {
+                    if (header_cmp(MK_UPGRADE_H2C,
+                                   header->val.data, header->val.len) == 0) {
+                        p->header_upgrade = MK_HTTP_PARSER_UPGRADE_H2C;
+                    }
+            }
+
+            return 0;
+        }
+    }
+
+    /*
+     * The header_lookup did not match any known header, so we register this
+     * entry into the headers_extra array.
+     */
+    if (p->headers_extra_count < MK_HEADER_EXTRA_SIZE) {
+        header_extra = &p->headers_extra[p->headers_extra_count];
+        header_extra->key.data = tmp = (buffer + p->header_key);
+        header_extra->key.len  = len;
+
+        /* Transform the header key string to lowercase */
+        for (i = 0; i < len; i++) {
+            tmp[i] = tolower(tmp[i]);
+        }
+
+        header_extra->val.data = buffer + p->header_val;
+        header_extra->val.len  = p->end - p->header_val;
+        p->headers_extra_count++;
+        p->header_count++;
+        mk_list_add(&header_extra->_head, &p->header_list);
+        return 0;
+    }
+
+    /*
+     * Header is unknown and we cannot store it on our extra headers
+     * list as it's already full. Request is too large.
+     */
+    return -MK_CLIENT_REQUEST_ENTITY_TOO_LARGE;
+}
+
+/*
+ * This function is invoked everytime the parser evaluate the request is
+ * OK. Here we perform some extra validations mostly based on some logic
+ * and protocol requirements according to the data received.
+ */
+static inline int mk_http_parser_ok(struct mk_http_request *req,
+                                    struct mk_http_parser *p,
+                                    struct mk_server *server)
+{
+    /* Validate HTTP Version */
+    if (req->protocol == MK_HTTP_PROTOCOL_UNKNOWN) {
+        mk_http_error(MK_SERVER_HTTP_VERSION_UNSUP, req->session, req, server);
+        return MK_HTTP_PARSER_ERROR;
+    }
+
+    /* POST checks */
+    if (req->method == MK_METHOD_POST || req->method == MK_METHOD_PUT) {
+        /* validate Content-Length exists */
+        if (p->headers[MK_HEADER_CONTENT_LENGTH].type == 0) {
+            mk_http_error(MK_CLIENT_LENGTH_REQUIRED, req->session, req, server);
+            return MK_HTTP_PARSER_ERROR;
+        }
+    }
+
+    return MK_HTTP_PARSER_OK;
+}
+
+/*
+ * Parse the protocol and point relevant fields, don't take logic decisions
+ * based on this, just parse to locate things.
+ */
+int mk_http_parser(struct mk_http_request *req, struct mk_http_parser *p,
+                   char *buffer, int buf_len, struct mk_server *server)
+{
+    int s;
+    int tmp;
+    int ret;
+    int len;
+
+    /* lazy test
+    printf("p->i=%i buf_len=%i\n",
+           p->i, buf_len);
+
+    for (s = p->i; s < buf_len; s++) {
+        if (buffer[s] == '\r') {
+            printf("CR");
+        }
+        else if (buffer[s] == '\n') {
+            printf("LF");
+        }
+        else {
+            printf("%c", buffer[s]);
+        }
+    }
+    printf("\n");
+    */
+
+    len = buf_len;
+    for (; p->i < len; p->i++, p->chars++) {
+        /* FIRST LINE LEVEL: Method, URI & Protocol */
+        if (p->level == REQ_LEVEL_FIRST) {
+            switch (p->status) {
+            case MK_ST_REQ_METHOD:                      /* HTTP Method */
+                if (p->chars == -1) {
+                    switch (buffer[p->i]) {
+                    case 'G':
+                        p->method = MK_METHOD_GET;
+                        break;
+                    case 'P':
+                        p->method = MK_METHOD_POST;
+                        break;
+                    case 'H':
+                        p->method = MK_METHOD_HEAD;
+                        break;
+                    case 'D':
+                        p->method = MK_METHOD_DELETE;
+                        break;
+                    case 'O':
+                        p->method = MK_METHOD_OPTIONS;
+                        break;
+                    }
+                    continue;
+                }
+
+                if (buffer[p->i] == ' ') {
+                    mark_end();
+                    p->status = MK_ST_REQ_URI;
+                    if (p->end < 2) {
+                        return MK_HTTP_PARSER_ERROR;
+                    }
+                    method_lookup(req, p, buffer);
+                    start_next();
+                }
+                else {
+                    if ((p->i - p->start) > 10) {
+                        return MK_HTTP_PARSER_ERROR;
+                    }
+                }
+                break;
+            case MK_ST_REQ_URI:                         /* URI */
+                if (buffer[p->i] == ' ') {
+                    mark_end();
+                    p->status = MK_ST_REQ_PROT_VERSION;
+                    if (field_len() < 1) {
+                        return MK_HTTP_PARSER_ERROR;
+                    }
+                    request_set(&req->uri, p, buffer);
+                    start_next();
+                }
+                else if (buffer[p->i] == '?') {
+                    mark_end();
+                    request_set(&req->uri, p, buffer);
+                    p->status = MK_ST_REQ_QUERY_STRING;
+                    start_next();
+                }
+                else if (buffer[p->i] == '\r' || buffer[p->i] == '\n') {
+                    mk_http_error(MK_CLIENT_BAD_REQUEST, req->session,
+                                  req, server);
+                    return MK_HTTP_PARSER_ERROR;
+                }
+                break;
+            case MK_ST_REQ_QUERY_STRING:                /* Query string */
+                char_lookup(buffer, '\n', len, p);
+
+                if (buffer[p->i] == '\n') {
+                    reverse_char_lookup(buffer, ' ', p->i, p);
+                }
+
+                if (buffer[p->i] == ' ') {
+                    mark_end();
+                    request_set(&req->query_string, p, buffer);
+                    p->status = MK_ST_REQ_PROT_VERSION;
+                    start_next();
+                }
+                else if (buffer[p->i] == '\r' || buffer[p->i] == '\n') {
+                    mk_http_error(MK_CLIENT_BAD_REQUEST, req->session,
+                                  req, server);
+                    return MK_HTTP_PARSER_ERROR;
+                }
+                break;
+            case MK_ST_REQ_PROT_VERSION:                /* Protocol Version */
+                /*
+                 * Most of the time we already have the string version in our
+                 * buffer, for that case try to match the version and avoid
+                 * loop rounds.
+                 */
+                if (p->start + 6 >= p->i) {
+                    continue;
+                }
+
+                tmp = p->start;
+                if (buffer[tmp] == 'H' &&
+                    buffer[tmp + 1] == 'T' &&
+                    buffer[tmp + 2] == 'T' &&
+                    buffer[tmp + 3] == 'P' &&
+                    buffer[tmp + 4] == '/' &&
+                    buffer[tmp + 5] == '1' &&
+                    buffer[tmp + 6] == '.') {
+
+                    request_set(&req->protocol_p, p, buffer);
+                    req->protocol_p.len = 8;
+                    mk_http_set_minor_version(buffer[tmp + 7]);
+                }
+                else {
+                    mk_http_error(MK_SERVER_HTTP_VERSION_UNSUP,
+                                  req->session, req, server);
+                    return MK_HTTP_PARSER_ERROR;
+                }
+                p->status = MK_ST_FIRST_CONTINUE;
+                break;
+            case MK_ST_FIRST_CONTINUE:
+                if (buffer[p->i] == '\r') {
+                    p->status = MK_ST_FIRST_FINALIZING;
+                }
+                else {
+                    return MK_HTTP_PARSER_ERROR;
+                }
+                break;
+            case MK_ST_FIRST_FINALIZING:                  /* New Line */
+                if (buffer[p->i] == '\n') {
+                    p->level = REQ_LEVEL_CONTINUE;
+                    start_next();
+                }
+                else {
+                    return MK_HTTP_PARSER_ERROR;
+                }
+                break;
+            case MK_ST_BLOCK_END:
+                if (buffer[p->i] == '\n') {
+                    return mk_http_parser_ok(req, p, server);
+                }
+                else {
+                    return MK_HTTP_PARSER_ERROR;
+                }
+                break;
+            };
+        }
+        else if (p->level == REQ_LEVEL_CONTINUE) {
+            if (buffer[p->i] == '\r') {
+                p->level  = REQ_LEVEL_FIRST;
+                p->status = MK_ST_BLOCK_END;
+            }
+            else {
+                p->level  = REQ_LEVEL_HEADERS;
+                p->status = MK_ST_HEADER_KEY;
+                p->chars  = 0;
+            }
+        }
+        /* HEADERS: all headers stuff */
+        if (p->level == REQ_LEVEL_HEADERS) {
+            /* Expect a Header key */
+            if (p->status == MK_ST_HEADER_KEY) {
+                if (buffer[p->i] == '\r') {
+                    if (p->chars == 0) {
+                        p->level = REQ_LEVEL_END;
+                        start_next();
+                    }
+                    else {
+                        return MK_HTTP_PARSER_ERROR;
+                    }
+                }
+
+                if (p->chars == 0) {
+                    /*
+                     * We reach the start of a Header row, lets catch the most
+                     * probable header.
+                     *
+                     * The goal of this 'first row character lookup', is to define a
+                     * small range set of probable headers comparison once we catch
+                     * a header end.
+                     */
+                    s = tolower(buffer[p->i]);
+                    switch (s) {
+                    case 'a':
+                        p->header_min = MK_HEADER_ACCEPT;
+                        p->header_max = MK_HEADER_AUTHORIZATION;
+                        break;
+                    case 'c':
+                        p->header_min = MK_HEADER_CACHE_CONTROL;
+                        p->header_max = MK_HEADER_CONTENT_TYPE;
+                        break;
+                    case 'h':
+                        p->header_min = MK_HEADER_HOST;
+                        p->header_max = MK_HEADER_HTTP2_SETTINGS;
+                        break;
+                    case 'i':
+                        header_scope_eq(p, MK_HEADER_IF_MODIFIED_SINCE);
+                        break;
+                    case 'l':
+                        p->header_min = MK_HEADER_LAST_MODIFIED;
+                        p->header_max = MK_HEADER_LAST_MODIFIED_SINCE;
+                        break;
+                    case 'r':
+                        p->header_min = MK_HEADER_RANGE;
+                        p->header_max = MK_HEADER_REFERER;
+                        break;
+                    case 'u':
+                        p->header_min = MK_HEADER_UPGRADE;
+                        p->header_max = MK_HEADER_USER_AGENT;
+                        break;
+                    default:
+                        p->header_key = -1;
+                        p->header_sep = -1;
+                        p->header_min = -1;
+                        p->header_max = -1;
+                    };
+                    p->header_key = p->i;
+                    continue;
+                }
+
+                /* Found key/value separator */
+                char_lookup(buffer, ':', len, p);
+                if (buffer[p->i] == ':') {
+                    /* Set the key/value middle point */
+                    p->header_sep = p->i;
+
+                    /* validate length */
+                    mark_end();
+                    if (field_len() < 1) {
+                        return MK_HTTP_PARSER_ERROR;
+                    }
+
+                    /* Wait for a value */
+                    p->status = MK_ST_HEADER_VALUE;
+                    start_next();
+                }
+            }
+            /* Parsing the header value */
+            else if (p->status == MK_ST_HEADER_VALUE) {
+                /* Trim left, set starts only when found something != ' ' */
+                if (buffer[p->i] == '\r' || buffer[p->i] == '\n') {
+                    return MK_HTTP_PARSER_ERROR;
+                }
+                else if (buffer[p->i] != ' ') {
+                    p->status = MK_ST_HEADER_VAL_STARTS;
+                    p->start = p->header_val = p->i;
+                }
+                continue;
+            }
+            /* New header row starts */
+            else if (p->status == MK_ST_HEADER_VAL_STARTS) {
+                /* Maybe there is no more headers and we reach the end ? */
+                if (buffer[p->i] == '\r') {
+                    mark_end();
+                    if (field_len() <= 0) {
+                        return MK_HTTP_PARSER_ERROR;
+                    }
+
+                    /*
+                     * A header row has ended, lets lookup the header and populate
+                     * our headers table index.
+                     */
+                    ret = header_lookup(p, buffer);
+                    if (ret != 0) {
+                        if (ret < -1) {
+                            mk_http_error(-ret, req->session, req, server);
+                        }
+                        return MK_HTTP_PARSER_ERROR;
+                    }
+
+                    /* Try to catch next LF */
+                    if (p->i + 1 < len) {
+                        if (buffer[p->i + 1] == '\n') {
+                            p->i++;
+                            p->status = MK_ST_HEADER_KEY;
+                            p->chars = -1;
+                            start_next();
+                        }
+                    }
+
+                    p->status = MK_ST_HEADER_END;
+                    start_next();
+                }
+                else if (buffer[p->i] == '\n' && buffer[p->i - 1] != '\r') {
+                    return MK_HTTP_PARSER_ERROR;
+                }
+            }
+            else if (p->status == MK_ST_HEADER_END) {
+                if (buffer[p->i] == '\n') {
+                    p->status = MK_ST_HEADER_KEY;
+                    p->chars = -1;
+                    start_next();
+                }
+                else {
+                    return MK_HTTP_PARSER_ERROR;
+                }
+            }
+        }
+        else if (p->level == REQ_LEVEL_END) {
+            if (buffer[p->i] == '\n') {
+                if (p->header_content_length > 0) {
+                    p->level = REQ_LEVEL_BODY;
+                    p->chars = -1;
+                    start_next();
+                }
+                else {
+                    return mk_http_parser_ok(req, p, server);
+                }
+            }
+            else {
+                return MK_HTTP_PARSER_ERROR;
+            }
+        }
+        else if (p->level == REQ_LEVEL_BODY) {
+            /*
+             * Reaching this level can means two things:
+             *
+             * - A Pipeline Request
+             * - A Body content (POST/PUT methods)
+             */
+            if (p->header_content_length > 0) {
+
+                p->body_received = len - p->start;
+                if ((len - p->start) < p->header_content_length) {
+                    return MK_HTTP_PARSER_PENDING;
+                }
+
+                /* Cut off */
+                p->i += p->body_received;
+                req->data.len  = p->body_received;
+                req->data.data = (buffer + p->start);
+            }
+            return mk_http_parser_ok(req, p, server);
+        }
+    }
+
+    return MK_HTTP_PARSER_PENDING;
+}
diff --git a/fluent-bit/lib/monkey/mk_server/mk_http_thread.c b/fluent-bit/lib/monkey/mk_server/mk_http_thread.c
new file mode 100644
index 00000000..d3c606f3
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_http_thread.c
@@ -0,0 +1,290 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2016 Monkey Software LLC <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <monkey/mk_info.h>
+#include <monkey/mk_plugin.h>
+#include <monkey/mk_thread.h>
+#include <monkey/mk_net.h>
+#include <monkey/mk_vhost.h>
+#include <monkey/mk_http_thread.h>
+
+#include <stdlib.h>
+
+/*
+ * libco do not support parameters in the entrypoint function due to the
+ * complexity of implementation in terms of architecture and compiler, but
+ * it provide a workaround using a global structure as a middle entry-point
+ * that achieve the same stuff.
+ */
+struct mk_http_libco_params {
+    int type;
+    struct mk_vhost_handler *handler;
+    struct mk_http_session *session;
+    struct mk_http_request *request;
+    int n_params;
+    struct mk_list *params;
+    struct mk_thread *th;
+};
+
+pthread_once_t mk_http_thread_initialize_tls_once_flag = PTHREAD_ONCE_INIT;
+
+MK_TLS_DEFINE(struct mk_http_libco_params, mk_http_thread_libco_params);
+MK_TLS_DEFINE(struct mk_thread,            mk_thread);
+
+/* This function could return NULL if the process runs out of memory, in that
+ * case failure is imminent.
+ */
+static inline struct mk_http_libco_params *thread_get_libco_params()
+{
+    struct mk_http_libco_params *libco_params;
+
+    libco_params = MK_TLS_GET(mk_http_thread_libco_params);
+
+    if (libco_params == NULL) {
+        libco_params = mk_mem_alloc_z(sizeof(struct mk_http_libco_params));
+
+        if (libco_params == NULL) {
+            mk_err("libco thread params could not be allocated.");
+        }
+
+        MK_TLS_SET(mk_http_thread_libco_params, libco_params);
+    }
+
+    return libco_params;
+}
+
+static void mk_http_thread_initialize_tls_once()
+{
+    MK_TLS_INIT(mk_http_thread_libco_params);
+    MK_TLS_INIT(mk_thread);
+}
+
+void mk_http_thread_initialize_tls()
+{
+    pthread_once(&mk_http_thread_initialize_tls_once_flag,
+                 mk_http_thread_initialize_tls_once);
+}
+
+static inline void thread_cb_init_vars()
+{
+    struct mk_http_libco_params *libco_params;
+    struct mk_vhost_handler     *handler;
+    struct mk_http_session      *session;
+    struct mk_http_request      *request;
+    int                          close;
+    int                          type;
+    struct mk_http_thread       *mth;
+    struct mk_thread            *th;
+
+    libco_params = thread_get_libco_params();
+
+    type = libco_params->type;
+    handler = libco_params->handler;
+    session = libco_params->session;
+    request = libco_params->request;
+    th = libco_params->th;
+
+    /*
+     * Until this point the th->callee already set the variables, so we
+     * wait until the core wanted to resume so we really trigger the
+     * output callback.
+     */
+    co_switch(th->caller);
+
+    if (type == MK_HTTP_THREAD_LIB) {
+        /* Invoke the handler callback */
+        handler->cb(request, handler->data);
+
+        /*
+         * Once the callback finished, we need to sanitize the connection
+         * so other further requests can be processed.
+         */
+        int ret;
+        struct mk_sched_worker *sched;
+        struct mk_channel *channel;
+
+        channel = request->session->channel;
+        sched = mk_sched_get_thread_conf();
+
+        MK_EVENT_NEW(channel->event);
+        ret = mk_event_add(sched->loop,
+                           channel->fd,
+                           MK_EVENT_CONNECTION,
+                           MK_EVENT_READ, channel->event);
+        if (ret == -1) {
+            //return -1;
+        }
+
+        /* Save temporal session */
+        mth = request->thread;
+
+        /*
+         * Finalize request internally, if ret == -1 means we should
+         * ask to shutdown the connection.
+         */
+        ret = mk_http_request_end(session, session->server);
+        if (ret == -1) {
+            close = MK_TRUE;
+        }
+        else {
+            close = MK_FALSE;
+        }
+        mk_http_thread_purge(mth, close);
+
+        /* Return control to caller */
+        mk_thread_yield(th);
+    }
+    else if (type == MK_HTTP_THREAD_PLUGIN) {
+        /* FIXME: call plugin handler callback with params */
+    }
+}
+
+static inline void thread_params_set(struct mk_thread *th,
+                                     int type,
+                                     struct mk_vhost_handler *handler,
+                                     struct mk_http_session *session,
+                                     struct mk_http_request *request,
+                                     int n_params,
+                                     struct mk_list *params)
+{
+    struct mk_http_libco_params *libco_params;
+
+    libco_params = thread_get_libco_params();
+
+    /* Callback parameters in order */
+    libco_params->type     = type;
+    libco_params->handler  = handler;
+    libco_params->session  = session;
+    libco_params->request  = request;
+    libco_params->n_params = n_params;
+    libco_params->params   = params;
+    libco_params->th       = th;
+
+    co_switch(th->callee);
+}
+
+struct mk_http_thread *mk_http_thread_create(int type,
+                                             struct mk_vhost_handler *handler,
+                                             struct mk_http_session *session,
+                                             struct mk_http_request *request,
+                                             int n_params,
+                                             struct mk_list *params)
+{
+    size_t stack_size;
+    struct mk_thread *th = NULL;
+    struct mk_http_thread *mth;
+    struct mk_sched_worker *sched;
+
+    sched = mk_sched_get_thread_conf();
+    if (!sched) {
+        return NULL;
+    }
+
+    th = mk_thread_new(sizeof(struct mk_http_thread), NULL);
+    if (!th) {
+        return NULL;
+    }
+
+    mth = (struct mk_http_thread *) MK_THREAD_DATA(th);
+    if (!mth) {
+        return NULL;
+    }
+
+    mth->session = session;
+    mth->request = request;
+    mth->parent  = th;
+    mth->close   = MK_FALSE;
+    request->thread = mth;
+    mk_list_add(&mth->_head, &sched->threads);
+
+    th->caller = co_active();
+    th->callee = co_create(MK_THREAD_STACK_SIZE,
+                           thread_cb_init_vars, &stack_size);
+
+#ifdef MK_HAVE_VALGRIND
+    th->valgrind_stack_id = VALGRIND_STACK_REGISTER(th->callee,
+                                                    ((char *)th->callee) + stack_size);
+#endif
+
+    /* Workaround for makecontext() */
+    thread_params_set(th, type, handler, session, request, n_params, params);
+
+    return mth;
+}
+
+/*
+ * Move a http thread context from sched->thread to sched->threads_purge list.
+ * On this way the scheduler will release or reasign the resource later.
+ */
+int mk_http_thread_purge(struct mk_http_thread *mth, int close)
+{
+    struct mk_sched_worker *sched;
+
+    sched = mk_sched_get_thread_conf();
+    if (!sched) {
+        return -1;
+    }
+
+    mth->close = close;
+    mk_list_del(&mth->_head);
+    mk_list_add(&mth->_head, &sched->threads_purge);
+
+    return 0;
+}
+
+int mk_http_thread_destroy(struct mk_http_thread *mth)
+{
+    struct mk_thread *th;
+
+    /* Unlink from scheduler thread list */
+    mk_list_del(&mth->_head);
+
+    /* release original memory context */
+    th = mth->parent;
+    mth->session->channel->event->type = MK_EVENT_CONNECTION;
+    mk_thread_destroy(th);
+
+    return 0;
+}
+
+int mk_http_thread_event(struct mk_event *event)
+{
+    struct mk_sched_conn *conn = (struct mk_sched_conn *) event;
+
+    /*
+    struct mk_thread *th;
+    struct mk_http_thread *mth;
+
+    th = conn->channel.thread;
+    mth = (struct mk_http_thread *) MK_THREAD_DATA(th);
+    */
+
+    mk_thread_resume(conn->channel.thread);
+    return 0;
+}
+
+/*
+ * Start the co-routine: invoke coroutine callback and start processing
+ * data flush requests.
+ */
+int mk_http_thread_start(struct mk_http_thread *mth)
+{
+    mk_http_thread_resume(mth);
+    return 0;
+}
diff --git a/fluent-bit/lib/monkey/mk_server/mk_kernel.c b/fluent-bit/lib/monkey/mk_server/mk_kernel.c
new file mode 100644
index 00000000..cc69e96c
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_kernel.c
@@ -0,0 +1,165 @@
+/*-*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <monkey/monkey.h>
+#include <monkey/mk_core.h>
+#include <monkey/mk_kernel.h>
+#include <monkey/mk_utils.h>
+#include <monkey/mk_server.h>
+#include <monkey/mk_scheduler.h>
+
+#include <ctype.h>
+
+#ifndef _WIN32
+#include <sys/utsname.h>
+
+int mk_kernel_version()
+{
+    int a, b, c;
+    int len;
+    int pos;
+    char *p, *t;
+    char *tmp;
+    struct utsname uts;
+
+    if (uname(&uts) == -1) {
+        mk_libc_error("uname");
+    }
+    len = strlen(uts.release);
+
+    /* Fixme: this don't support Linux Kernel 10.x.x :P */
+    a = (*uts.release - '0');
+
+    /* Second number */
+    p = (uts.release) + 2;
+    pos = mk_string_char_search(p, '.', len - 2);
+    if (pos <= 0) {
+        /* Some Debian systems uses a different notation, e.g: 3.14-2-amd64 */
+        pos = mk_string_char_search(p, '-', len - 2);
+        if (pos <= 0) {
+            return -1;
+        }
+    }
+
+    tmp = mk_string_copy_substr(p, 0, pos);
+    if (!tmp) {
+        return -1;
+    }
+    b = atoi(tmp);
+    mk_mem_free(tmp);
+
+    /* Last number (it needs filtering) */
+    t = p = p + pos + 1;
+    do {
+        t++;
+    } while (isdigit(*t));
+
+    tmp = mk_string_copy_substr(p, 0, t - p);
+    if (!tmp) {
+        return -1;
+    }
+    c = atoi(tmp);
+    mk_mem_free(tmp);
+
+    MK_TRACE("Kernel detected: %i.%i.%i", a, b, c);
+    return MK_KERNEL_VERSION(a, b, c);
+}
+
+/* Detect specific Linux Kernel features that we may use */
+int mk_kernel_features(int version)
+{
+    int flags = 0;
+
+    /*
+     * TCP Auto Corking (disabled by #175)
+     * -----------------------------------
+     * I found that running some benchmarks on Linux 3.16 with
+     * tcp_autocorking enabled, it lead to lower performance, looks like
+     * a manual cork fits better for our needs.
+     *
+     * I think there is something wrong that we need to clarify, by now
+     * I've logged the following issue:
+     *
+     *   https://github.com/monkey/monkey/issues/175
+     *
+    if (mk_kernel_runver >= MK_KERNEL_VERSION(3, 14, 0) &&
+        mk_socket_tcp_autocorking() == MK_TRUE) {
+        flags |= MK_KERNEL_TCP_AUTOCORKING;
+    }
+    */
+
+    /* SO_REUSEPORT */
+    if (version >= MK_KERNEL_VERSION(3, 9, 0)) {
+        flags |= MK_KERNEL_SO_REUSEPORT;
+    }
+
+    /* TCP_FASTOPEN */
+    if (version >= MK_KERNEL_VERSION(3, 7, 0)) {
+        flags |= MK_KERNEL_TCP_FASTOPEN;
+    }
+
+    return flags;
+}
+
+int mk_kernel_features_print(char *buffer, size_t size,
+                             struct mk_server *server)
+{
+    int offset = 0;
+    int features = 0;
+
+    if (server->kernel_features & MK_KERNEL_TCP_FASTOPEN) {
+        offset += snprintf(buffer, size - offset, "%s", "TCP_FASTOPEN ");
+        features++;
+    }
+
+    if (server->kernel_features & MK_KERNEL_SO_REUSEPORT) {
+        if (server->scheduler_mode == MK_SCHEDULER_FAIR_BALANCING) {
+            offset += snprintf(buffer + offset, size - offset,
+                               "%s!%s", ANSI_BOLD ANSI_RED, ANSI_RESET);
+        }
+        offset += snprintf(buffer + offset, size - offset, "%s", "SO_REUSEPORT ");
+        features++;
+    }
+
+    if (server->kernel_features & MK_KERNEL_TCP_AUTOCORKING) {
+        snprintf(buffer + offset, size - offset, "%s", "TCP_AUTOCORKING ");
+        features++;
+    }
+
+    return features;
+}
+#else
+/* We still need to determine if this can be safely ignored or what do we need to do here */
+
+int mk_kernel_version()
+{
+    return 1;
+}
+
+int mk_kernel_features(int version)
+{
+    return 0;
+}
+
+int mk_kernel_features_print(char* buffer, size_t size,
+    struct mk_server* server)
+{
+    return 0;
+}
+#endif
diff --git a/fluent-bit/lib/monkey/mk_server/mk_lib.c b/fluent-bit/lib/monkey/mk_server/mk_lib.c
new file mode 100644
index 00000000..c2940086
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_lib.c
@@ -0,0 +1,796 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#define _GNU_SOURCE
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+
+#include <mk_core/mk_pthread.h>
+
+#include <monkey/mk_lib.h>
+#include <monkey/monkey.h>
+#include <monkey/mk_stream.h>
+#include <monkey/mk_thread.h>
+#include <monkey/mk_scheduler.h>
+#include <monkey/mk_fifo.h>
+#include <monkey/mk_utils.h>
+#include <monkey/mk_tls.h>
+
+#define config_eq(a, b) strcasecmp(a, b)
+
+static inline int bool_val(char *v)
+{
+    if (strcasecmp(v, "On") == 0 || strcasecmp(v, "Yes") == 0) {
+        return MK_TRUE;
+    }
+    else if (strcasecmp(v, "Off") == 0 || strcasecmp(v, "No") == 0) {
+        return MK_FALSE;
+    }
+
+    return -1;
+}
+
+mk_ctx_t *mk_create()
+{
+    mk_ctx_t *ctx;
+
+    ctx = mk_mem_alloc_z(sizeof(mk_ctx_t));
+    if (!ctx) {
+        return NULL;
+    }
+
+    /* Create Monkey server instance */
+    ctx->server = mk_server_create();
+
+    /*
+     * FIFO
+     * ====
+     * Before to prepare the background service, we create a MK_FIFO interface
+     * for further communication between the caller (user) and HTTP end-point
+     * callbacks.
+     */
+    ctx->fifo = mk_fifo_create(NULL, ctx->server);
+    ctx->fifo->key = &mk_server_fifo_key;
+
+    /*
+     * FIFO: Set workers callback associated to the Monkey scheduler to prepare them
+     * before to enter the event loop
+     */
+    mk_sched_worker_cb_add(ctx->server, mk_fifo_worker_setup, ctx->fifo);
+    return ctx;
+}
+
+int mk_destroy(mk_ctx_t *ctx)
+{
+    mk_fifo_destroy(ctx->fifo);
+    mk_mem_free(ctx);
+
+    return 0;
+}
+
+static inline int mk_lib_yield(mk_request_t *req)
+{
+    int ret;
+    struct mk_thread *th;
+    struct mk_channel *channel;
+    struct mk_sched_worker *sched;
+
+    sched = mk_sched_get_thread_conf();
+    if (!sched) {
+        return -1;
+    }
+
+    th = MK_TLS_GET(mk_thread);
+    channel = req->session->channel;
+
+    channel->thread = th;
+
+    ret = mk_event_add(sched->loop,
+                       channel->fd,
+                       MK_EVENT_THREAD,
+                       MK_EVENT_WRITE, channel->event);
+    if (ret == -1) {
+        return -1;
+    }
+
+    /* Just wait */
+    mk_thread_yield(th);
+
+    if (channel->event->status & MK_EVENT_REGISTERED) {
+        /* We got a notification, remove the event registered
+        ret = mk_event_add(sched->loop,
+                           channel->fd,
+                           MK_EVENT_CONNECTION,
+                           MK_EVENT_READ, channel->event);
+                           mk_thread_yield(th);
+        */
+
+        ret = mk_event_del(sched->loop, channel->event);
+    }
+
+    return 0;
+}
+
+static void mk_lib_worker(void *data)
+{
+    int fd;
+    int bytes;
+    uint64_t val;
+    struct mk_server *server;
+    struct mk_event *event;
+
+    mk_ctx_t *ctx = data;
+    server = ctx->server;
+
+    /* Start the service */
+    mk_server_setup(server);
+    mk_server_loop(server);
+
+    /*
+     * Give a second to the parent context to avoid consume an event
+     * we should not read at the moment (SIGNAL_START).
+     */
+    sleep(1);
+
+    /* Wait for events */
+    mk_event_wait(server->lib_evl);
+    mk_event_foreach(event, server->lib_evl) {
+        fd = event->fd;
+
+#ifdef _WIN32
+        bytes = recv(fd, &val, sizeof(uint64_t), MSG_WAITALL);
+#else
+        bytes = read(fd, &val, sizeof(uint64_t));
+#endif
+
+        if (bytes <= 0) {
+            return;
+        }
+
+        if (val == MK_SERVER_SIGNAL_STOP) {
+            break;
+        }
+    }
+
+    mk_event_loop_destroy(server->lib_evl);
+    mk_exit_all(server);
+    pthread_kill(pthread_self(), 0);
+
+    return;
+}
+
+int mk_start(mk_ctx_t *ctx)
+{
+    int fd;
+    int bytes;
+    int ret;
+    uint64_t val;
+    pthread_t tid;
+    struct mk_event *event;
+    struct mk_server *server;
+
+    server = ctx->server;
+
+    ret = mk_utils_worker_spawn(mk_lib_worker, ctx, &tid);
+    if (ret == -1) {
+        return -1;
+    }
+    ctx->worker_tid = tid;
+
+    /* Wait for the started signal so we can return to the caller */
+    mk_event_wait(server->lib_evl_start);
+    mk_event_foreach(event, server->lib_evl_start) {
+        fd = event->fd;
+
+        /* When using libevent _mk_event_channel_create creates a unix socket
+         * instead of a pipe and windows doesn't us calling read / write on a
+         * socket instead of recv / send
+         */
+#ifdef _WIN32        
+        bytes = recv(fd, &val, sizeof(uint64_t), MSG_WAITALL);
+#else
+        bytes = read(fd, &val, sizeof(uint64_t));
+#endif
+        
+        if (bytes <= 0) {
+            ret = -1;
+            break;
+        }
+
+        if (val == MK_SERVER_SIGNAL_START) {
+            ret = 0;
+            break;
+        }
+        else {
+            ret = -1;
+            break;
+        }
+    }
+
+    mk_event_loop_destroy(server->lib_evl_start);
+    if (ret == -1) {
+        mk_stop(ctx);
+    } 
+
+    return ret;
+}
+
+int mk_stop(mk_ctx_t *ctx)
+{
+    int n;
+    uint64_t val;
+    int8_t scheduler_mode ;
+    struct mk_server *server = ctx->server;
+
+    /* Keep track of the scheduler mode on stack, since the
+     * the worker may free the server before we need the info. 
+     */
+    scheduler_mode = server->scheduler_mode;
+
+    val = MK_SERVER_SIGNAL_STOP;
+
+    /* Send a stop signal to the main lib channel to abort.
+     *
+     * MK_SCHEDULER_FAIR_BALANCING: this signal will be
+     * consumed by mk_server_loop_balancer.
+     * 
+     * MK_SCHEDULER_REUSEPORT: this signal will be consumed
+     * by mk_lib_worker. 
+     */
+#ifdef _WIN32
+    n = send(server->lib_ch_manager[1], &val, sizeof(val), 0); 
+#else
+    n = write(server->lib_ch_manager[1], &val, sizeof(val));
+#endif
+    if (n <= 0) {
+        perror("write");
+        return -1;
+    }
+
+    /* In MK_SCHEDULER_FAIR_BALANCING mode, we need one more 
+     * stop signal to abort mk_lib_worker.
+     */
+    if (scheduler_mode == MK_SCHEDULER_FAIR_BALANCING) {
+        /* Give mk_server_loop_balancer time to clean up. */
+        sleep(1);
+
+        /* Send a signal for mk_lib_worker to abort */
+#ifdef _WIN32
+        n = send(server->lib_ch_manager[1], &val, sizeof(val), 0); 
+#else
+        n = write(server->lib_ch_manager[1], &val, sizeof(val));
+#endif
+        if (n <= 0) {
+            perror("write");
+            return -1;
+        }
+    }
+
+    /* Wait for the child thread to exit */
+    pthread_join(ctx->worker_tid, NULL);
+    return 0;
+}
+
+/*
+ * Instruct Monkey core to invoke a callback function inside each worker
+ * started by the scheduler.
+ */
+int mk_worker_callback(mk_ctx_t *ctx,
+                       void (*cb_func) (void *),
+                       void *data)
+{
+    return mk_sched_worker_cb_add(ctx->server, cb_func, data);
+}
+
+int mk_config_set_property(struct mk_server *server, char *k, char *v)
+{
+    int b;
+    int ret;
+    int num;
+    unsigned long len;
+
+    if (config_eq(k, "Listen") == 0) {
+        ret = mk_config_listen_parse(v, server);
+        if (ret != 0) {
+            return -1;
+        }
+    }
+    else if (config_eq(k, "Workers") == 0) {
+        num = atoi(v);
+        if (num <= 0) {
+            server->workers = mk_utils_get_system_core_count();
+        }
+        else {
+            server->workers = num;
+        }
+    }
+    else if (config_eq(k, "Timeout") == 0) {
+        num = atoi(v);
+        if (num <= 0) {
+            return -1;
+        }
+        server->timeout = num;
+    }
+    else if (config_eq(k, "KeepAlive") == 0) {
+        b = bool_val(v);
+        if (b == -1) {
+            return -1;
+        }
+        server->keep_alive = b;
+    }
+    else if (config_eq(k, "MaxKeepAliveRequest") == 0) {
+        num = atoi(v);
+        if (num <= 0) {
+            return -1;
+        }
+        server->max_keep_alive_request = num;
+    }
+    else if (config_eq(k, "KeepAliveTimeout") == 0) {
+        num = atoi(v);
+        if (num <= 0) {
+            return -1;
+        }
+        server->keep_alive_timeout = num;
+    }
+    else if (config_eq(k, "UserDir") == 0) {
+        server->conf_user_pub = mk_string_dup(v);
+    }
+    else if (config_eq(k, "IndexFile") == 0) {
+        server->index_files = mk_string_split_line(v);
+        if (!server->index_files) {
+            return -1;
+        }
+    }
+    else if (config_eq(k, "HideVersion") == 0) {
+        b = bool_val(v);
+        if (b == -1) {
+            return -1;
+        }
+        server->hideversion = b;
+    }
+    else if (config_eq(k, "Resume") == 0) {
+        b = bool_val(v);
+        if (b == -1) {
+            return -1;
+        }
+        server->resume = b;
+    }
+    else if (config_eq(k, "MaxRequestSize") == 0) {
+        num = atoi(v);
+        if (num <= 0) {
+            return -1;
+        }
+        server->max_request_size = num;
+    }
+    else if (config_eq(k, "SymLink") == 0) {
+        b = bool_val(v);
+        if (b == -1) {
+            return -1;
+        }
+        server->symlink = b;
+    }
+    else if (config_eq(k, "DefaultMimeType") == 0) {
+        mk_string_build(&server->mimetype_default_str, &len, "%s\r\n", v);
+    }
+    else if (config_eq(k, "FDT") == 0) {
+        b = bool_val(v);
+        if (b == -1) {
+            return -1;
+        }
+        server->fdt = b;
+    }
+
+    return 0;
+}
+
+int mk_config_set(mk_ctx_t *ctx, ...)
+{
+    int ret;
+    char *key;
+    char *value;
+    va_list va;
+
+    va_start(va, ctx);
+
+    while ((key = va_arg(va, char *))) {
+        value = va_arg(va, char *);
+        if (!value) {
+            /* Wrong parameter */
+            va_end(va);
+            return -1;
+        }
+
+        ret = mk_config_set_property(ctx->server, key, value);
+        if (ret != 0) {
+            va_end(va);
+            return -1;
+        }
+    }
+
+    va_end(va);
+    return 0;
+}
+
+/* Given a vhost id, return the vhost context */
+struct mk_vhost *mk_vhost_lookup(mk_ctx_t *ctx, int id)
+{
+    struct mk_vhost *host;
+    struct mk_list *head;
+
+    mk_list_foreach(head, &ctx->server->hosts) {
+        host = mk_list_entry(head, struct mk_vhost, _head);
+        if (host->id == id) {
+            return host;
+        }
+    }
+
+    return NULL;
+}
+
+int mk_vhost_create(mk_ctx_t *ctx, char *name)
+{
+    struct mk_vhost *h;
+    struct mk_vhost_alias *halias;
+
+    /* Virtual host */
+    h = mk_mem_alloc_z(sizeof(struct mk_vhost));
+    if (!h) {
+        return -1;
+    }
+
+    /* Assign a virtual host id, we just set based on list size */
+    h->id = mk_list_size(&ctx->server->hosts);
+    mk_list_init(&h->error_pages);
+    mk_list_init(&h->server_names);
+    mk_list_init(&h->handlers);
+
+    /* Host alias */
+    halias = mk_mem_alloc_z(sizeof(struct mk_vhost_alias));
+    if (!halias) {
+        mk_mem_free(h);
+        return -1;
+    }
+
+    /* Host name */
+    if (!name) {
+        halias->name = mk_string_dup("127.0.0.1");
+    }
+    else {
+        halias->name = mk_string_dup(name);
+    }
+    mk_list_add(&halias->_head, &h->server_names);
+    mk_list_add(&h->_head, &ctx->server->hosts);
+
+    /* Return the host id, that number is enough for further operations */
+    return h->id;
+}
+
+static int mk_vhost_set_property(struct mk_vhost *vh, char *k, char *v)
+{
+    struct mk_vhost_alias *ha;
+
+    if (config_eq(k, "Name") == 0) {
+        ha = mk_mem_alloc(sizeof(struct mk_vhost_alias));
+        if (!ha) {
+            return -1;
+        }
+        ha->name = mk_string_dup(v);
+        ha->len  = strlen(v);
+        mk_list_add(&ha->_head, &vh->server_names);
+    }
+    else if (config_eq(k, "DocumentRoot") == 0) {
+        vh->documentroot.data = mk_string_dup(v);
+        vh->documentroot.len  = strlen(v);
+    }
+
+    return 0;
+}
+
+int mk_vhost_set(mk_ctx_t *ctx, int vid, ...)
+{
+    int ret;
+    char *key;
+    char *value;
+    va_list va;
+    struct mk_vhost *vh;
+
+    /* Lookup the virtual host */
+    vh = mk_vhost_lookup(ctx, vid);
+    if (!vh) {
+        return -1;
+    }
+
+    va_start(va, vid);
+
+    while ((key = va_arg(va, char *))) {
+        value = va_arg(va, char *);
+        if (!value) {
+            /* Wrong parameter */
+            return -1;
+        }
+
+        ret = mk_vhost_set_property(vh, key, value);
+        if (ret != 0) {
+            va_end(va);
+            return -1;
+        }
+    }
+
+    va_end(va);
+    return 0;
+}
+
+int mk_vhost_handler(mk_ctx_t *ctx, int vid, char *regex,
+                     void (*cb)(mk_request_t *, void *), void *data)
+{
+    struct mk_vhost *vh;
+    struct mk_vhost_handler *handler;
+    void (*_cb) (struct mk_http_request *, void *);
+
+    /* Lookup the virtual host */
+    vh = mk_vhost_lookup(ctx, vid);
+    if (!vh) {
+        return -1;
+    }
+
+    _cb = cb;
+    handler = mk_vhost_handler_match(regex, _cb, data);
+    if (!handler) {
+        return -1;
+    }
+    mk_list_add(&handler->_head, &vh->handlers);
+
+    return 0;
+}
+
+/* Flush streams data associated to a request in question */
+int mk_http_flush(mk_request_t *req)
+{
+    int ret;
+    size_t out_bytes = 0;
+
+    ret = mk_channel_stream_write(&req->stream, &out_bytes);
+    return ret;
+}
+
+int mk_http_status(mk_request_t *req, int status)
+{
+    req->headers.status = status;
+    return 0;
+}
+
+/* Append a response header */
+int mk_http_header(mk_request_t *req,
+                   char *key, int key_len,
+                   char *val, int val_len)
+{
+    int pos;
+    int len;
+    char *buf;
+    struct response_headers *h;
+
+    h = &req->headers;
+    if (!h->_extra_rows) {
+        h->_extra_rows = mk_iov_create(MK_PLUGIN_HEADER_EXTRA_ROWS * 2, 0);
+        if (!h->_extra_rows) {
+            return -1;
+        }
+    }
+
+    len = key_len + val_len + 4;
+    buf = mk_mem_alloc(len);
+    if (!buf) {
+        /* we don't free extra_rows as it's released later */
+        return -1;
+    }
+
+    /* Compose the buffer */
+    memcpy(buf, key, key_len);
+    pos = key_len;
+    buf[pos++] = ':';
+    buf[pos++] = ' ';
+    memcpy(buf + pos, val, val_len);
+    pos += val_len;
+    buf[pos++] = '\r';
+    buf[pos++] = '\n';
+
+    /* Add the new buffer */
+    mk_iov_add(h->_extra_rows, buf, pos, MK_TRUE);
+
+    return 0;
+}
+
+static inline int chunk_header(long num, char *out)
+{
+    int i = 1;
+    int j, c;
+    int remainder;
+    int quotient;
+    char tmp[32];
+    char hex[] = "0123456789ABCDEF";
+
+    if (num == 0) {
+        out[0] = '0';
+        out[1] = '\r';
+        out[2] = '\n';
+        out[3] = '\r';
+        out[4] = '\n';
+        out[5] = '\0';
+        return 5;
+    }
+
+    quotient = num;
+    while (quotient != 0) {
+        remainder = quotient % 16;
+        tmp[i++] = hex[remainder];
+        quotient = quotient / 16;
+    }
+
+    c = 0;
+    for (j = i -1 ; j > 0; j--, c++) {
+        out[c] = tmp[j];
+    }
+
+    out[c++] = '\r';
+    out[c++] = '\n';
+    out[c] = '\0';
+
+    return c;
+}
+
+static void free_chunk_header(struct mk_stream_input *input)
+{
+    mk_mem_free(input->buffer);
+    input->buffer = NULL;
+}
+
+
+/* Check if response headers were processed, otherwise prepare them */
+static int headers_setup(mk_request_t *req)
+{
+    /*
+     * Let's keep it simple for now: if the headers have not been sent, do it
+     * now and then send the body content just queued.
+     */
+    if (req->headers.sent == MK_FALSE) {
+        /* Force chunked-transfer encoding */
+        if (req->protocol == MK_HTTP_PROTOCOL_11) {
+            req->headers.transfer_encoding = MK_HEADER_TE_TYPE_CHUNKED;
+        }
+        else {
+            req->headers.content_length = -1;
+        }
+        mk_header_prepare(req->session, req, req->session->server);
+    }
+    return 0;
+}
+
+/* Enqueue some data for the body response */
+int mk_http_send(mk_request_t *req, char *buf, size_t len,
+                 void (*cb_finish)(mk_request_t *))
+{
+    int chunk_len;
+    int ret;
+    char *tmp;
+    char chunk_pre[32];
+    (void) cb_finish;
+
+    if (req->session->channel->status != MK_CHANNEL_OK) {
+        return -1;
+    }
+
+    if (req->headers.status == -1) {
+        /* Cannot append data if the status have not been set */
+        mk_err("HTTP: set the response status first");
+        return -1;
+    }
+
+    /* Chunk encoding prefix */
+    if (req->protocol == MK_HTTP_PROTOCOL_11) {
+        chunk_len = chunk_header(len, chunk_pre);
+        tmp = mk_string_dup(chunk_pre);
+        if (!tmp) {
+            return -1;
+        }
+        ret = mk_stream_in_raw(&req->stream, NULL,
+                               tmp, chunk_len, NULL, free_chunk_header);
+        if (ret != 0) {
+            return -1;
+        }
+    }
+
+    /* Append raw data */
+    if (len > 0) {
+        ret = mk_stream_in_raw(&req->stream, NULL,
+                               buf, len, NULL, NULL);
+        if (ret == 0) {
+            /* Update count of bytes */
+            req->stream_size += len;
+        }
+    }
+
+    if (req->protocol == MK_HTTP_PROTOCOL_11 && len > 0) {
+        ret = mk_stream_in_raw(&req->stream, NULL,
+                               "\r\n", 2, NULL, NULL);
+    }
+
+    /* Validate if the response headers are ready */
+    headers_setup(req);
+
+    /* Flush channel data */
+    ret = mk_http_flush(req);
+
+    /*
+     * Flush have been done, before to return our original caller, we want to yield
+     * and give some execution time to the event loop to avoid possible blocking
+     * since the caller might be using this mk_http_send() in a loop.
+     */
+    mk_lib_yield(req);
+    return ret;
+}
+
+int mk_http_done(mk_request_t *req)
+{
+    if (req->session->channel->status != MK_CHANNEL_OK) {
+        return -1;
+    }
+
+    /* Validate if the response headers are ready */
+    headers_setup(req);
+
+    if (req->headers.transfer_encoding == MK_HEADER_TE_TYPE_CHUNKED) {
+        /* Append end-of-chunk bytes */
+        mk_http_send(req, NULL, 0, NULL);
+    }
+    else {
+        mk_http_send(req, NULL, 0, NULL);
+    }
+
+    if (req->session->close_now == MK_TRUE) {
+        mk_lib_yield(req);
+    }
+
+    return 0;
+}
+
+/* Create a messaging queue end-point */
+int mk_mq_create(mk_ctx_t *ctx, char *name, void (*cb), void *data)
+{
+    int id;
+
+    id = mk_fifo_queue_create(ctx->fifo, name, cb, data);
+    return id;
+}
+
+/* Write a message to a specific queue ID */
+int mk_mq_send(mk_ctx_t *ctx, int qid, void *data, size_t size)
+{
+    return mk_fifo_send(ctx->fifo, qid, data, size);
+}
+
+int mk_main()
+{
+    while (1) {
+        sleep(60);
+    }
+
+    return 0;
+}
diff --git a/fluent-bit/lib/monkey/mk_server/mk_mimetype.c b/fluent-bit/lib/monkey/mk_server/mk_mimetype.c
new file mode 100644
index 00000000..b86b4ef1
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_mimetype.c
@@ -0,0 +1,227 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <ctype.h>
+
+#include <mk_core/mk_unistd.h>
+
+#include <monkey/monkey.h>
+#include <monkey/mk_mimetype.h>
+#include <monkey/mk_utils.h>
+#include <monkey/mk_config.h>
+#include <monkey/mk_core.h>
+#include <monkey/mk_http.h>
+
+struct mk_mimetype *mimetype_default;
+
+static int rbtree_compare(const void *lhs, const void *rhs)
+{
+    return strcmp((const char *)lhs, (const char *)rhs);
+}
+
+/* Match mime type for requested resource */
+struct mk_mimetype *mk_mimetype_lookup(struct mk_server *server, char *name)
+{
+    int cmp;
+    struct rb_tree_node *node = server->mimetype_rb_head.root;
+
+    while (node) {
+        struct mk_mimetype *entry = container_of(node, struct mk_mimetype, _rb_head);
+        cmp = strcmp(name, entry->name);
+        if (cmp < 0)
+            node = node->left;
+        else if (cmp > 0)
+            node = node->right;
+        else {
+            return entry;
+        }
+    }
+    return NULL;
+}
+
+int mk_mimetype_add(struct mk_server *server, char *name, const char *type)
+{
+    int len = strlen(type) + 3;
+    char *p;
+    struct mk_mimetype *new_mime;
+
+    /* make sure we register the extension in lower case */
+    p = name;
+    for ( ; *p; ++p) *p = tolower(*p);
+
+    new_mime = mk_mem_alloc_z(sizeof(struct mk_mimetype));
+    if (!new_mime) {
+        return -1;
+    }
+    new_mime->name = mk_string_dup(name);
+    if (!new_mime->name) {
+        mk_mem_free(new_mime);
+        return -1;
+    }
+    new_mime->type.data = mk_mem_alloc(len);
+    if (!new_mime->type.data) {
+        mk_mem_free(new_mime->name);
+        mk_mem_free(new_mime);
+        return -1;
+    }
+    new_mime->type.len = len - 1;
+    new_mime->header_type.data = mk_mem_alloc(len + 32);
+    if (!new_mime->header_type.data) {
+        mk_mem_free(new_mime->name);
+        mk_mem_free(new_mime->type.data);
+        mk_mem_free(new_mime);
+        return -1;
+    }
+    new_mime->header_type.len = snprintf(new_mime->header_type.data,
+                                         len + 32,
+                                         "Content-Type: %s\r\n",
+                                         type);
+    strcpy(new_mime->type.data, type);
+    strcat(new_mime->type.data, MK_CRLF);
+    new_mime->type.data[len-1] = '\0';
+
+    /* Insert the node into the RBT */
+    rb_tree_insert(&server->mimetype_rb_head,
+                   new_mime->name, &new_mime->_rb_head);
+
+    /* Add to linked list head */
+    mk_list_add(&new_mime->_head, &server->mimetype_list);
+
+    return 0;
+}
+
+int mk_mimetype_init(struct mk_server *server)
+{
+    char *name;
+    int ret;
+
+    /* Initialize the heads */
+    mk_list_init(&server->mimetype_list);
+    rb_tree_new(&server->mimetype_rb_head, rbtree_compare);
+
+    name = mk_string_dup(MIMETYPE_DEFAULT_NAME);
+    if (server->mimetype_default_str) {
+        ret = mk_mimetype_add(server, name, server->mimetype_default_str);
+    }
+    else {
+        ret = mk_mimetype_add(server, name, MIMETYPE_DEFAULT_TYPE);
+    }
+    if (ret < 0) {
+        mk_mem_free(name);
+        return -1;
+    }
+    server->mimetype_default = mk_list_entry_first(&server->mimetype_list,
+                                                   struct mk_mimetype,
+                                                   _head);
+    mk_mem_free(name);
+    return 0;
+}
+
+/* Load the two mime arrays into memory */
+int mk_mimetype_read_config(struct mk_server *server)
+{
+    char path[MK_MAX_PATH];
+    struct mk_rconf *cnf;
+    struct mk_rconf_section *section;
+    struct mk_rconf_entry *entry;
+    struct mk_list *head;
+    struct file_info f_info;
+    int ret;
+
+    if (!server->conf_mimetype) {
+        return -1;
+    }
+
+    /* Read mime types configuration file */
+    snprintf(path, MK_MAX_PATH, "%s/%s",
+             server->path_conf_root,
+             server->conf_mimetype);
+
+    ret = mk_file_get_info(path, &f_info, MK_FILE_EXISTS);
+    if (ret == -1 || f_info.is_file == MK_FALSE) {
+        snprintf(path, MK_MAX_PATH, "%s", server->conf_mimetype);
+    }
+    cnf = mk_rconf_open(path);
+    if (!cnf) {
+        mk_warn("[mime] skipping mimetype configuration file");
+        return -1;
+    }
+
+    /* Get MimeTypes tag */
+    section = mk_rconf_section_get(cnf, "MIMETYPES");
+    if (!section) {
+        mk_err("[mime] Invalid mime type file");
+        return -1;
+    }
+
+    mk_list_foreach(head, &section->entries) {
+        entry = mk_list_entry(head, struct mk_rconf_entry, _head);
+        if (!entry->key || !entry->val) {
+            continue;
+        }
+
+        if (mk_mimetype_add(server, entry->key, entry->val) != 0) {
+            mk_err("[mime] Error loading Mime Types");
+            return -1;
+        }
+    }
+
+    mk_rconf_free(cnf);
+
+    return 0;
+}
+
+struct mk_mimetype *mk_mimetype_find(struct mk_server *server, mk_ptr_t *filename)
+{
+    int j, len;
+
+    j = len = filename->len;
+
+    /* looking for extension */
+    while (j >= 0 && filename->data[j] != '.') {
+        j--;
+    }
+
+    if (j <= 0) {
+        return NULL;
+    }
+
+    return mk_mimetype_lookup(server, filename->data + j + 1);
+}
+
+void mk_mimetype_free_all(struct mk_server *server)
+{
+    struct mk_list *head;
+    struct mk_list *tmp;
+    struct mk_mimetype *mime;
+
+    mk_list_foreach_safe(head, tmp, &server->mimetype_list) {
+        mime = mk_list_entry(head, struct mk_mimetype, _head);
+        mk_ptr_free(&mime->type);
+        mk_mem_free(mime->name);
+        mk_mem_free(mime->header_type.data);
+        mk_mem_free(mime);
+    }
+}
diff --git a/fluent-bit/lib/monkey/mk_server/mk_net.c b/fluent-bit/lib/monkey/mk_server/mk_net.c
new file mode 100644
index 00000000..de183de4
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_net.c
@@ -0,0 +1,284 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2016 Monkey Software LLC <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <monkey/mk_core.h>
+#include <monkey/mk_net.h>
+#include <monkey/mk_scheduler.h>
+#include <monkey/mk_plugin.h>
+#include <monkey/mk_thread.h>
+#include <monkey/mk_tls.h>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#include <afunix.h>
+#else
+#include <sys/socket.h>
+#include <netinet/tcp.h>
+#endif
+
+/* Initialize the network stack*/
+int mk_net_init()
+{
+#ifdef _WIN32
+    int result;
+    WSADATA wsa_data;
+    static int initialized = 0;
+
+    if(0 != initialized) {
+        return 0;
+    }
+
+    result = WSAStartup(MAKEWORD(2, 2), &wsa_data);
+
+    if(0 != result) {
+        if(WSAEINPROGRESS == result)
+        {
+            Sleep(100); /* Let the other thread finish initializing the stack */
+
+            return 0;
+        }
+
+        return -1;
+    }
+
+    initialized = 1;    
+#endif
+
+    return 0;
+}
+
+/* Connect to a TCP socket server */
+static int mk_net_fd_connect(int fd, char *host, unsigned long port)
+{
+    int ret;
+    struct addrinfo hints;
+    struct addrinfo *res;
+    char _port[6];
+
+    memset(&hints, 0, sizeof hints);
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+
+    snprintf(_port, sizeof(_port), "%lu", port);
+    ret = getaddrinfo(host, _port, &hints, &res);
+    if (ret != 0) {
+        return -1;
+    }
+
+    ret = connect(fd, res->ai_addr, res->ai_addrlen);
+    freeaddrinfo(res);
+
+    return ret;
+}
+
+struct mk_net_connection *mk_net_conn_create(char *addr, int port)
+{
+    int fd;
+    int ret;
+    int error = 0;
+    socklen_t len = sizeof(error);
+    struct mk_sched_worker *sched;
+    struct mk_net_connection *conn;
+
+    /* Allocate connection context */
+    conn = mk_mem_alloc(sizeof(struct mk_net_connection));
+    if (!conn) {
+        return NULL;
+    }
+
+    /* Create socket */
+    fd = mk_socket_create(AF_INET, SOCK_STREAM, 0);
+    if (fd == -1) {
+        mk_mem_free(conn);
+        return NULL;
+    }
+
+    /* Make socket async */
+    mk_socket_set_nonblocking(fd);
+    conn->fd = fd;
+
+    ret = mk_net_fd_connect(conn->fd, addr, port);
+    if (ret == -1) {
+        if (errno != EINPROGRESS) {
+            close(fd);
+            mk_mem_free(conn);
+            return NULL;
+        }
+
+        MK_EVENT_NEW(&conn->event);
+
+        sched = mk_sched_get_thread_conf();
+        // FIXME: not including the thread
+        //conn->thread = mk_thread_get();
+        ret = mk_event_add(sched->loop, conn->fd, MK_EVENT_THREAD,
+                           MK_EVENT_WRITE, &conn->event);
+        if (ret == -1) {
+            close(fd);
+            mk_mem_free(conn);
+            return NULL;
+        }
+
+        /*
+         * Return the control to the parent caller, we need to wait for
+         * the event loop to get back to us.
+         */
+        mk_thread_yield(conn->thread);
+
+        /* We got a notification, remove the event registered */
+        ret = mk_event_del(sched->loop, &conn->event);
+
+        /* Check the connection status */
+        if (conn->event.mask & MK_EVENT_WRITE) {
+            ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len);
+            if (ret == -1) {
+                close(fd);
+                mk_mem_free(conn);
+                return NULL;
+            }
+
+            if (error != 0) {
+                /* Connection is broken, not much to do here */
+                fprintf(stderr, "Async connection failed %s:%i\n",
+                        conn->host, conn->port);
+                close(fd);
+                mk_mem_free(conn);
+                return NULL;
+            }
+            MK_EVENT_NEW(&conn->event);
+            return conn;
+        }
+        else {
+            close(fd);
+            mk_mem_free(conn);
+            return NULL;
+        }
+    }
+
+    return NULL;
+}
+
+int mk_net_conn_write(struct mk_channel *channel,
+                      void *data, size_t len)
+{
+    int ret = 0;
+    int error;
+    ssize_t bytes;
+    size_t total = 0;
+    size_t send;
+    socklen_t slen = sizeof(error);
+    struct mk_thread *th = MK_TLS_GET(mk_thread);
+    struct mk_sched_worker *sched;
+
+    sched = mk_sched_get_thread_conf();
+    if (!sched) {
+        return -1;
+    }
+
+ retry:
+    error = 0;
+
+    if (len - total > 524288) {
+        send = 524288;
+    }
+    else {
+        send = (len - total);
+    }
+
+    send = len - total;
+    bytes = channel->io->write(channel->io->plugin, channel->fd, (uint8_t *)data + total, send);
+    if (bytes == -1) {
+        if (errno == EAGAIN) {
+            MK_EVENT_NEW(channel->event);
+            channel->thread = th;
+            ret = mk_event_add(sched->loop,
+                               channel->fd,
+                               MK_EVENT_THREAD,
+                               MK_EVENT_WRITE, channel->event);
+            if (ret == -1) {
+                /*
+                 * If we failed here there no much that we can do, just
+                 * let the caller we failed
+                 */
+                return -1;
+            }
+
+            /*
+             * Return the control to the parent caller, we need to wait for
+             * the event loop to get back to us.
+             */
+            mk_thread_yield(th);
+
+            /* We got a notification, remove the event registered */
+            ret = mk_event_del(sched->loop, channel->event);
+            if (ret == -1) {
+                return -1;
+            }
+
+            /* Check the connection status */
+            if (channel->event->mask & MK_EVENT_WRITE) {
+                ret = getsockopt(channel->fd, SOL_SOCKET, SO_ERROR, &error, &slen);
+                if (ret == -1) {
+                    fprintf(stderr, "[io] could not validate socket status");
+                    return -1;
+                }
+
+                if (error != 0) {
+                    return -1;
+                }
+
+                MK_EVENT_NEW(channel->event);
+                goto retry;
+            }
+            else {
+                return -1;
+            }
+
+        }
+        else {
+            return -1;
+        }
+    }
+
+    /* Update counters */
+    total += bytes;
+    if (total < len) {
+        channel->thread = th;
+        ret = mk_event_add(sched->loop,
+                           channel->fd,
+                           MK_EVENT_THREAD,
+                           MK_EVENT_WRITE, channel->event);
+        if (ret == -1) {
+            /*
+             * If we failed here there no much that we can do, just
+             * let the caller we failed
+             */
+            return -1;
+        }
+
+        mk_thread_yield(th);
+        goto retry;
+    }
+
+    if (channel->event->status & MK_EVENT_REGISTERED) {
+        /* We got a notification, remove the event registered */
+        ret = mk_event_del(sched->loop, channel->event);
+    }
+
+    return total;
+}
diff --git a/fluent-bit/lib/monkey/mk_server/mk_plugin.c b/fluent-bit/lib/monkey/mk_server/mk_plugin.c
new file mode 100644
index 00000000..50e2886b
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_plugin.c
@@ -0,0 +1,804 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <monkey/monkey.h>
+#include <monkey/mk_utils.h>
+#include <monkey/mk_http.h>
+#include <monkey/mk_clock.h>
+#include <monkey/mk_plugin.h>
+#include <monkey/mk_mimetype.h>
+#include <monkey/mk_vhost.h>
+#include <monkey/mk_static_plugins.h>
+#include <monkey/mk_plugin_stage.h>
+#include <monkey/mk_core.h>
+#include <monkey/mk_net.h>
+
+#ifndef _WIN32
+#include <dlfcn.h>
+#include <err.h>
+#endif
+
+enum {
+    bufsize = 256
+};
+
+static struct plugin_stagemap *plg_stagemap;
+struct plugin_network_io *plg_netiomap;
+
+struct mk_plugin *mk_plugin_lookup(char *shortname, struct mk_server *server)
+{
+    struct mk_list *head;
+    struct mk_plugin *p = NULL;
+
+    mk_list_foreach(head, &server->plugins) {
+        p = mk_list_entry(head, struct mk_plugin, _head);
+        if (strcmp(p->shortname, shortname) == 0){
+            return p;
+        }
+    }
+
+    return NULL;
+}
+
+void *mk_plugin_load_dynamic(const char *path)
+{
+    void *handle;
+
+#ifdef _WIN32
+    handle = (void *) LoadLibraryA(path);
+#else
+    handle = dlopen(path, RTLD_LAZY);
+
+    if (!handle) {
+        mk_warn("dlopen() %s", dlerror());
+    }
+#endif
+
+    return handle;
+}
+
+void *mk_plugin_load_symbol(void *handler, const char *symbol)
+{
+    void *s;
+
+#ifdef _WIN32
+    s = GetProcAddress((HMODULE)handler, symbol);
+#else
+    dlerror();
+    s = dlsym(handler, symbol);
+    if (dlerror() != NULL) {
+        return NULL;
+    }
+#endif
+
+    return s;
+}
+
+/* Initialize a plugin, trigger the init_plugin callback */
+static int mk_plugin_init(struct plugin_api *api,
+                          struct mk_plugin *plugin,
+                          struct mk_server *server)
+{
+    int ret;
+    unsigned long len;
+    char path[1024];
+    char *conf_dir = NULL;
+    struct file_info f_info;
+
+    MK_TRACE("Load Plugin: '%s'", plugin->shortname);
+
+    snprintf(path, 1024, "%s/%s",
+             server->path_conf_root, server->conf_plugins);
+    ret = mk_file_get_info(path, &f_info, MK_FILE_READ);
+    if (ret == -1 || f_info.is_directory == MK_FALSE) {
+        snprintf(path, 1024, "%s", server->conf_plugins);
+    }
+
+    /* Build plugin configuration path */
+    mk_string_build(&conf_dir,
+                    &len,
+                    "%s/%s/",
+                    path, plugin->shortname);
+
+    /* Init plugin */
+    plugin->api = api;
+    plugin->server_ctx = server;
+
+    if (plugin->network != NULL) {
+        plugin->network->plugin = plugin;
+    }
+
+    ret = plugin->init_plugin(plugin, conf_dir);
+    mk_mem_free(conf_dir);
+
+    return ret;
+}
+
+
+/*
+ * Load a plugin into Monkey core, 'type' defines if it's a MK_PLUGIN_STATIC or
+ * a MK_PLUGIN_DYNAMIC. 'shortname' is mandatory and 'path' is only used when
+ * MK_PLUGIN_DYNAMIC is set and represents the absolute path of the shared
+ * library.
+ */
+struct mk_plugin *mk_plugin_load(int type, const char *shortname,
+                                 void *data, struct mk_server *server)
+{
+    char *path;
+    char symbol[64];
+    void *handler;
+    struct mk_list *head;
+    struct mk_plugin *tmp;
+    struct mk_plugin *plugin = NULL;
+    struct mk_plugin_stage *stage;
+
+    /* Set main struct name to reference */
+    if (type == MK_PLUGIN_DYNAMIC) {
+        path = (char *) data;
+        handler = mk_plugin_load_dynamic(path);
+        if (!handler) {
+            return NULL;
+        }
+
+        snprintf(symbol, sizeof(symbol) - 1, "mk_plugin_%s", shortname);
+        plugin  = mk_plugin_load_symbol(handler, symbol);
+        if (!plugin) {
+            mk_warn("Plugin '%s' is not registering properly", path);
+#ifdef _WIN32
+            FreeLibrary((HMODULE)handler);
+#else
+            dlclose(handler);
+#endif
+            return NULL;
+        }
+
+        /* Make sure this is not loaded twice (ref #218) */
+        mk_list_foreach(head, &server->plugins) {
+            tmp = mk_list_entry(head, struct mk_plugin, _head);
+            if (tmp->load_type == MK_PLUGIN_STATIC &&
+                strcmp(tmp->name, plugin->name) == 0){
+                mk_warn("Plugin '%s' have been built-in.",
+                        tmp->shortname);
+#ifdef _WIN32
+                FreeLibrary((HMODULE)handler);
+#else
+                dlclose(handler);
+#endif
+                return NULL;
+            }
+        }
+
+        plugin->load_type = MK_PLUGIN_DYNAMIC;
+        plugin->handler   = handler;
+        plugin->path      = mk_string_dup(path);
+    }
+    else if (type == MK_PLUGIN_STATIC) {
+        plugin = (struct mk_plugin *) data;
+        plugin->load_type = MK_PLUGIN_STATIC;
+    }
+
+    if (!plugin) {
+        return NULL;
+    }
+
+    /* Validate all callbacks are set */
+    if (!plugin->shortname || !plugin->name || !plugin->version ||
+        !plugin->init_plugin || !plugin->exit_plugin) {
+        mk_warn("Plugin '%s' is not registering all fields properly",
+                shortname);
+        return NULL;
+    }
+
+    if (plugin->hooks & MK_PLUGIN_NETWORK_LAYER) {
+        mk_bug(!plugin->network);
+    }
+
+    mk_list_init(&plugin->stage_list);
+    if (plugin->hooks & MK_PLUGIN_STAGE) {
+        struct mk_plugin_stage *st;
+
+        stage = plugin->stage;
+        if (stage->stage10) {
+            st = mk_mem_alloc(sizeof(struct mk_plugin_stage));
+            st->stage10 = stage->stage10;
+            st->plugin  = plugin;
+            mk_list_add(&st->_head, &server->stage10_handler);
+            mk_list_add(&st->_parent_head, &plugin->stage_list);
+        }
+        if (stage->stage20) {
+            st = mk_mem_alloc(sizeof(struct mk_plugin_stage));
+            st->stage20 = stage->stage20;
+            st->plugin  = plugin;
+            mk_list_add(&st->_head, &server->stage20_handler);
+            mk_list_add(&st->_parent_head, &plugin->stage_list);
+        }
+        if (stage->stage30) {
+            st = mk_mem_alloc(sizeof(struct mk_plugin_stage));
+            st->stage30 = stage->stage30;
+            st->plugin  = plugin;
+            mk_list_add(&st->_head, &server->stage30_handler);
+            mk_list_add(&st->_parent_head, &plugin->stage_list);
+        }
+        if (stage->stage40) {
+            st = mk_mem_alloc(sizeof(struct mk_plugin_stage));
+            st->stage40 = stage->stage40;
+            st->plugin  = plugin;
+            mk_list_add(&st->_head, &server->stage40_handler);
+            mk_list_add(&st->_parent_head, &plugin->stage_list);
+        }
+        if (stage->stage50) {
+            st = mk_mem_alloc(sizeof(struct mk_plugin_stage));
+            st->stage50 = stage->stage50;
+            st->plugin  = plugin;
+            mk_list_add(&st->_head, &server->stage50_handler);
+            mk_list_add(&st->_parent_head, &plugin->stage_list);
+        }
+    }
+
+    if (type == MK_PLUGIN_DYNAMIC) {
+        /* Add Plugin to the end of the list */
+        mk_list_add(&plugin->_head, &server->plugins);
+    }
+
+    return plugin;
+}
+
+void mk_plugin_unregister(struct mk_plugin *p)
+{
+    mk_mem_free(p->path);
+    mk_list_del(&p->_head);
+    if (p->load_type == MK_PLUGIN_DYNAMIC) {
+#ifdef _WIN32
+        FreeLibrary((HMODULE)p->handler);
+#else
+        dlclose(p->handler);
+#endif
+    }
+
+}
+
+void mk_plugin_api_init(struct mk_server *server)
+{
+    struct plugin_api *api;
+
+    /* Create an instance of the API */
+    api = mk_mem_alloc_z(sizeof(struct plugin_api));
+
+#ifndef _WIN32
+    __builtin_prefetch(api);
+#endif
+
+    /* Setup and connections list */
+    /* FIXME: api->config = server; */
+
+    /* API plugins funcions */
+
+    /* Error helper */
+    api->_error = mk_print;
+
+    /* HTTP callbacks */
+    api->http_request_end = mk_plugin_http_request_end;
+    api->http_request_error = mk_plugin_http_error;
+
+    /* Memory callbacks */
+    api->pointer_set = mk_ptr_set;
+    api->pointer_print = mk_ptr_print;
+    api->pointer_to_buf = mk_ptr_to_buf;
+    api->plugin_load_symbol = mk_plugin_load_symbol;
+    api->mem_alloc = mk_mem_alloc;
+    api->mem_alloc_z = mk_mem_alloc_z;
+    api->mem_realloc = mk_mem_realloc;
+    api->mem_free = mk_mem_free;
+
+    /* String Callbacks */
+    api->str_build = mk_string_build;
+    api->str_dup = mk_string_dup;
+    api->str_search = mk_string_search;
+    api->str_search_n = mk_string_search_n;
+    api->str_char_search = mk_string_char_search;
+    api->str_copy_substr = mk_string_copy_substr;
+    api->str_itop = mk_string_itop;
+    api->str_split_line = mk_string_split_line;
+    api->str_split_free = mk_string_split_free;
+
+    /* File Callbacks */
+    api->file_to_buffer = mk_file_to_buffer;
+    api->file_get_info = mk_file_get_info;
+
+    /* HTTP Callbacks */
+    api->header_prepare = mk_plugin_header_prepare;
+    api->header_add = mk_plugin_header_add;
+    api->header_get = mk_http_header_get;
+    api->header_set_http_status = mk_header_set_http_status;
+
+    /* Channels / Streams */
+    api->channel_new   = mk_channel_new;
+    api->channel_flush = mk_channel_flush;
+    api->channel_write = mk_channel_write;
+    api->channel_append_stream = mk_channel_append_stream;
+
+    /* IOV callbacks */
+    api->iov_create  = mk_iov_create;
+    api->iov_realloc = mk_iov_realloc;
+    api->iov_free = mk_iov_free;
+    api->iov_free_marked = mk_iov_free_marked;
+    api->iov_add =  mk_iov_add;
+    api->iov_set_entry =  mk_iov_set_entry;
+    api->iov_send =  mk_iov_send;
+    api->iov_print =  mk_iov_print;
+
+    /* events mechanism */
+    api->ev_loop_create = mk_event_loop_create;
+    api->ev_add = mk_event_add;
+    api->ev_del = mk_event_del;
+    api->ev_timeout_create = mk_event_timeout_create;
+    api->ev_channel_create = mk_event_channel_create;
+    api->ev_wait = mk_event_wait;
+    api->ev_backend = mk_event_backend;
+
+    /* Mimetype */
+    api->mimetype_lookup = mk_mimetype_lookup;
+
+    /* Socket callbacks */
+    api->socket_cork_flag = mk_socket_set_cork_flag;
+    api->socket_connect = mk_socket_connect;
+    api->socket_open = mk_socket_open;
+    api->socket_reset = mk_socket_reset;
+    api->socket_set_tcp_fastopen = mk_socket_set_tcp_fastopen;
+    api->socket_set_tcp_reuseport = mk_socket_set_tcp_reuseport;
+    api->socket_set_tcp_nodelay = mk_socket_set_tcp_nodelay;
+    api->socket_set_nonblocking = mk_socket_set_nonblocking;
+    api->socket_create = mk_socket_create;
+    api->socket_ip_str = mk_socket_ip_str;
+
+    /* Async network */
+    api->net_conn_create = mk_net_conn_create;
+
+    /* Config Callbacks */
+    api->config_create = mk_rconf_create;
+    api->config_open = mk_rconf_open;
+    api->config_free = mk_rconf_free;
+    api->config_section_get = mk_rconf_section_get;
+    api->config_section_get_key = mk_rconf_section_get_key;
+
+    /* Scheduler and Event callbacks */
+    api->sched_loop           = mk_sched_loop;
+    api->sched_get_connection = mk_sched_get_connection;
+    api->sched_event_free     = mk_sched_event_free;
+    api->sched_remove_client  = mk_plugin_sched_remove_client;
+    api->sched_worker_info    = mk_plugin_sched_get_thread_conf;
+
+    /* Worker functions */
+    api->worker_spawn = mk_utils_worker_spawn;
+    api->worker_rename = mk_utils_worker_rename;
+
+    /* Time functions */
+    api->time_unix   = mk_plugin_time_now_unix;
+    api->time_to_gmt = mk_utils_utime2gmt;
+    api->time_human  = mk_plugin_time_now_human;
+
+    api->stacktrace = (void *) mk_utils_stacktrace;
+    api->kernel_version = mk_kernel_version;
+    api->kernel_features_print = mk_kernel_features_print;
+    api->plugins = &server->plugins;
+
+    /* handler */
+    api->handler_param_get = mk_handler_param_get;
+
+    server->api = api;
+}
+
+void mk_plugin_load_static(struct mk_server *server)
+{
+    /* Load static plugins */
+    mk_list_init(&server->plugins);
+    mk_static_plugins(&server->plugins);
+}
+
+void mk_plugin_load_all(struct mk_server *server)
+{
+    int ret;
+    char *tmp;
+    char *path;
+    char shortname[64];
+    struct mk_plugin *p;
+    struct mk_rconf *cnf;
+    struct mk_rconf_section *section;
+    struct mk_rconf_entry *entry;
+    struct mk_list *head;
+    struct mk_list *htmp;
+    struct file_info f_info;
+
+    mk_plugin_load_static(server);
+    mk_list_foreach_safe(head, htmp, &server->plugins) {
+        p = mk_list_entry(head, struct mk_plugin, _head);
+
+        /* Load the static plugin */
+        p = mk_plugin_load(MK_PLUGIN_STATIC,
+                           p->shortname,
+                           (void *) p,
+                           server);
+        if (!p) {
+            continue;
+        }
+        ret = mk_plugin_init(server->api, p, server);
+        if (ret == -1) {
+            /* Free plugin, do not register, error initializing */
+            mk_warn("Plugin initialization failed: %s", p->shortname);
+            mk_plugin_unregister(p);
+            continue;
+        }
+        else if (ret == -2) {
+            /* Do not register, just skip it */
+            mk_plugin_unregister(p);
+            continue;
+        }
+    }
+
+    /* In case there are not dynamic plugins */
+    if (!server->conf_plugin_load) {
+        return;
+    }
+
+    /* Read configuration file */
+    path = mk_mem_alloc_z(1024);
+    snprintf(path, 1024, "%s/%s", server->path_conf_root,
+             server->conf_plugin_load);
+    ret = mk_file_get_info(path, &f_info, MK_FILE_READ);
+    if (ret == -1 || f_info.is_file == MK_FALSE) {
+        snprintf(path, 1024, "%s", server->conf_plugin_load);
+    }
+
+    cnf = mk_rconf_open(path);
+    if (!cnf) {
+        mk_warn("No dynamic plugins loaded.");
+        mk_mem_free(path);
+        return;
+    }
+
+    /* Read section 'PLUGINS' */
+    section = mk_rconf_section_get(cnf, "PLUGINS");
+    if (!section) {
+        exit(EXIT_FAILURE);
+    }
+
+    /* Read key entries */
+    mk_list_foreach_safe(head, htmp, &section->entries) {
+        entry = mk_list_entry(head, struct mk_rconf_entry, _head);
+        if (strcasecmp(entry->key, "Load") == 0) {
+
+            /* Get plugin 'shortname' */
+            tmp = memrchr(entry->val, '-', strlen(entry->val));
+            ++tmp;
+            memset(shortname, '\0', sizeof(shortname) - 1);
+            strncpy(shortname, tmp, strlen(tmp) - 3);
+
+            /* Load the dynamic plugin */
+            p = mk_plugin_load(MK_PLUGIN_DYNAMIC,
+                               shortname,
+                               entry->val,
+                               server);
+            if (!p) {
+                mk_warn("Invalid plugin '%s'", entry->val);
+                continue;
+            }
+
+            ret = mk_plugin_init(server->api, p, server);
+            if (ret < 0) {
+                /* Free plugin, do not register */
+                MK_TRACE("Unregister plugin '%s'", p->shortname);
+                mk_plugin_unregister(p);
+                continue;
+            }
+        }
+    }
+
+    /* Look for plugins thread key data */
+    mk_plugin_preworker_calls(server);
+    mk_vhost_map_handlers(server);
+    mk_mem_free(path);
+    mk_rconf_free(cnf);
+}
+
+static void mk_plugin_exit_stages(struct mk_plugin *p)
+{
+    struct mk_list *tmp;
+    struct mk_list *head;
+    struct mk_plugin_stage *st;
+
+    mk_list_foreach_safe(head, tmp, &p->stage_list) {
+        st = mk_list_entry(head, struct mk_plugin_stage, _parent_head);
+
+        /* remove from direct config->stageN head list */
+        mk_list_del(&st->_head);
+
+        /* remove from plugin->stage_lists */
+        mk_list_del(&st->_parent_head);
+        mk_mem_free(st);
+    }
+}
+
+/* Invoke all plugins 'exit' hook and free resources by the plugin interface */
+void mk_plugin_exit_all(struct mk_server *server)
+{
+    struct mk_plugin *plugin;
+    struct mk_list *head, *tmp;
+
+    /* Plugins */
+    mk_list_foreach(head, &server->plugins) {
+        plugin = mk_list_entry(head, struct mk_plugin, _head);
+        plugin->exit_plugin(plugin);
+    }
+
+    /* Plugin interface it self */
+    mk_list_foreach_safe(head, tmp, &server->plugins) {
+        plugin = mk_list_entry(head, struct mk_plugin, _head);
+        mk_list_del(&plugin->_head);
+        mk_plugin_exit_stages(plugin);
+
+        if (plugin->load_type == MK_PLUGIN_DYNAMIC) {
+            mk_mem_free(plugin->path);
+#ifdef _WIN32
+            FreeLibrary((HMODULE)plugin->handler);
+#else
+            dlclose(plugin ->handler);
+#endif
+        }
+        else if (plugin->load_type == MK_PLUGIN_STATIC) {
+            if (plugin->network != NULL) {
+                mk_mem_free(plugin->network);
+            }
+
+            mk_mem_free(plugin);
+        }
+    }
+
+    mk_mem_free(server->api);
+    mk_mem_free(plg_stagemap);
+}
+
+/*
+ * When a worker is exiting, it invokes this function to release any plugin
+ * associated data.
+ */
+void mk_plugin_exit_worker()
+{
+}
+
+/* This function is called by every created worker
+ * for plugins which need to set some data under a thread
+ * context
+ */
+void mk_plugin_core_process(struct mk_server *server)
+{
+    struct mk_plugin *node;
+    struct mk_list *head;
+
+    mk_list_foreach(head, &server->plugins) {
+        node = mk_list_entry(head, struct mk_plugin, _head);
+
+        /* Init plugin */
+        if (node->master_init) {
+            node->master_init(server);
+        }
+    }
+}
+
+/* This function is called by every created worker
+ * for plugins which need to set some data under a thread
+ * context
+ */
+void mk_plugin_core_thread(struct mk_server *server)
+{
+
+    struct mk_plugin *node;
+    struct mk_list *head;
+
+    mk_list_foreach(head, &server->plugins) {
+        node = mk_list_entry(head, struct mk_plugin, _head);
+
+        /* Init plugin thread context */
+        if (node->worker_init) {
+            node->worker_init(server);
+        }
+    }
+}
+
+/* This function is called by Monkey *outside* of the
+ * thread context for plugins, so here's the right
+ * place to set pthread keys or similar
+ */
+void mk_plugin_preworker_calls(struct mk_server *server)
+{
+    int ret;
+    struct mk_plugin *node;
+    struct mk_list *head;
+
+    mk_list_foreach(head, &server->plugins) {
+        node = mk_list_entry(head, struct mk_plugin, _head);
+
+        /* Init pthread keys */
+        if (node->thread_key) {
+            MK_TRACE("[%s] Set thread key", node->shortname);
+
+            ret = pthread_key_create(node->thread_key, NULL);
+            if (ret != 0) {
+                mk_err("Plugin Error: could not create key for %s",
+                       node->shortname);
+            }
+        }
+    }
+}
+
+int mk_plugin_http_error(int http_status, struct mk_http_session *cs,
+                         struct mk_http_request *sr,
+                         struct mk_plugin *plugin)
+{
+    return mk_http_error(http_status, cs, sr, plugin->server_ctx);
+}
+
+
+int mk_plugin_http_request_end(struct mk_plugin *plugin,
+                               struct mk_http_session *cs, int close)
+{
+    int ret;
+    int con;
+    struct mk_http_request *sr;
+    struct mk_server *server = plugin->server_ctx;
+
+    MK_TRACE("[FD %i] PLUGIN HTTP REQUEST END", cs->socket);
+
+    cs->status = MK_REQUEST_STATUS_INCOMPLETE;
+    if (mk_list_is_empty(&cs->request_list) == 0) {
+        MK_TRACE("[FD %i] Tried to end non-existing request.", cs->socket);
+        return -1;
+    }
+
+    sr = mk_list_entry_last(&cs->request_list, struct mk_http_request, _head);
+    mk_plugin_stage_run_40(cs, sr, server);
+
+    if (close == MK_TRUE) {
+        cs->close_now = MK_TRUE;
+    }
+
+    /* Let's check if we should ask to finalize the connection or not */
+    ret = mk_http_request_end(cs, server);
+    MK_TRACE("[FD %i] HTTP session end = %i", cs->socket, ret);
+    if (ret < 0) {
+        con = mk_sched_event_close(cs->conn, mk_sched_get_thread_conf(),
+                                   MK_EP_SOCKET_DONE, server);
+        if (con != 0) {
+            return con;
+        }
+        else {
+            return -1;
+        }
+    }
+
+    return ret;
+}
+
+/* Plugin epoll event handlers
+ * ---------------------------
+ * this functions are called by connection.c functions as mk_conn_read(),
+ * mk_conn_write(),mk_conn_error(), mk_conn_close() and mk_conn_timeout().
+ *
+ * Return Values:
+ * -------------
+ *    MK_PLUGIN_RET_EVENT_NOT_ME: There's no plugin hook associated
+ */
+
+void mk_plugin_event_bad_return(const char *hook, int ret)
+{
+    mk_err("[%s] Not allowed return value %i", hook, ret);
+}
+
+int mk_plugin_time_now_unix(struct mk_server *server)
+{
+    return server->clock_context->log_current_utime;
+}
+
+mk_ptr_t *mk_plugin_time_now_human(struct mk_server *server)
+{
+    return &server->clock_context->log_current_time;
+}
+
+int mk_plugin_sched_remove_client(int socket, struct mk_server *server)
+{
+    struct mk_sched_conn *conn;
+    struct mk_sched_worker *sched;
+
+    MK_TRACE("[FD %i] remove client", socket);
+
+    sched = mk_sched_get_thread_conf();
+    conn  = mk_sched_get_connection(sched, socket);
+    if (!conn) {
+        return -1;
+    }
+
+    return mk_sched_remove_client(conn, sched, server);
+}
+
+int mk_plugin_header_prepare(struct mk_plugin *plugin,
+                             struct mk_http_session *cs,
+                             struct mk_http_request *sr)
+{
+    return mk_header_prepare(cs, sr, plugin->server_ctx);
+}
+
+
+int mk_plugin_header_add(struct mk_http_request *sr, char *row, int len)
+{
+    mk_bug(!sr);
+
+    if (!sr->headers._extra_rows) {
+        /*
+         * We allocate space for a fixed number of IOV entries:
+         *
+         *   MK_PLUGIN_HEADER_EXTRA_ROWS = X
+         *
+         *  we use (MK_PLUGIN_HEADER_EXTRA_ROWS * 2) thinking in an ending CRLF
+         */
+        sr->headers._extra_rows = mk_iov_create(MK_PLUGIN_HEADER_EXTRA_ROWS * 2, 0);
+        mk_bug(!sr->headers._extra_rows);
+    }
+
+    mk_iov_add(sr->headers._extra_rows, row, len,
+               MK_FALSE);
+    mk_iov_add(sr->headers._extra_rows,
+               mk_iov_crlf.data, mk_iov_crlf.len,
+               MK_FALSE);
+    return 0;
+}
+
+struct mk_sched_worker *mk_plugin_sched_get_thread_conf()
+{
+    return MK_TLS_GET(mk_tls_sched_worker_node);
+}
+
+struct mk_plugin *mk_plugin_cap(char cap, struct mk_server *server)
+{
+    struct mk_list *head;
+    struct mk_plugin *plugin;
+
+    mk_list_foreach(head, &server->plugins) {
+        plugin = mk_list_entry(head, struct mk_plugin, _head);
+        if (plugin->capabilities & cap) {
+            return plugin;
+        }
+    }
+
+    return NULL;
+}
+
+struct mk_vhost_handler_param *mk_handler_param_get(int id,
+                                                    struct mk_list *params)
+{
+    int i = 0;
+    struct mk_list *head;
+
+    mk_list_foreach(head, params) {
+        if (i == id) {
+            return mk_list_entry(head, struct mk_vhost_handler_param, _head);
+        }
+        i++;
+    }
+
+    return NULL;
+}
diff --git a/fluent-bit/lib/monkey/mk_server/mk_scheduler.c b/fluent-bit/lib/monkey/mk_server/mk_scheduler.c
new file mode 100644
index 00000000..a680d3cd
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_scheduler.c
@@ -0,0 +1,866 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <monkey/monkey.h>
+#include <monkey/mk_info.h>
+#include <monkey/mk_core.h>
+#include <monkey/mk_vhost.h>
+#include <monkey/mk_scheduler.h>
+#include <monkey/mk_scheduler_tls.h>
+#include <monkey/mk_server.h>
+#include <monkey/mk_thread.h>
+#include <monkey/mk_cache.h>
+#include <monkey/mk_config.h>
+#include <monkey/mk_clock.h>
+#include <monkey/mk_plugin.h>
+#include <monkey/mk_utils.h>
+#include <monkey/mk_linuxtrace.h>
+#include <monkey/mk_server.h>
+#include <monkey/mk_plugin_stage.h>
+#include <monkey/mk_http_thread.h>
+
+#include <signal.h>
+
+#ifndef _WIN32
+#include <sys/syscall.h>
+#endif
+
+extern struct mk_sched_handler mk_http_handler;
+extern struct mk_sched_handler mk_http2_handler;
+
+pthread_mutex_t mutex_worker_init = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t mutex_worker_exit = PTHREAD_MUTEX_INITIALIZER;
+
+/*
+ * Returns the worker id which should take a new incomming connection,
+ * it returns the worker id with less active connections. Just used
+ * if config->scheduler_mode is MK_SCHEDULER_FAIR_BALANCING.
+ */
+static inline int _next_target(struct mk_server *server)
+{
+    int i;
+    int target = 0;
+    unsigned long long tmp = 0, cur = 0;
+    struct mk_sched_ctx *ctx = server->sched_ctx;
+    struct mk_sched_worker *worker;
+
+    cur = (ctx->workers[0].accepted_connections -
+           ctx->workers[0].closed_connections);
+    if (cur == 0) {
+        return 0;
+    }
+
+    /* Finds the lowest load worker */
+    for (i = 1; i < server->workers; i++) {
+        worker = &ctx->workers[i];
+        tmp = worker->accepted_connections - worker->closed_connections;
+        if (tmp < cur) {
+            target = i;
+            cur = tmp;
+
+            if (cur == 0)
+                break;
+        }
+    }
+
+    /*
+     * If sched_ctx->workers[target] worker is full then the whole server too,
+     * because it has the lowest load.
+     */
+    if (mk_unlikely(server->server_capacity > 0 &&
+                    server->server_capacity <= cur)) {
+        MK_TRACE("Too many clients: %i", server->server_capacity);
+
+        /* Instruct to close the connection anyways, we lie, it will die */
+        return -1;
+    }
+
+    return target;
+}
+
+struct mk_sched_worker *mk_sched_next_target(struct mk_server *server)
+{
+    int t;
+    struct mk_sched_ctx *ctx = server->sched_ctx;
+
+    t = _next_target(server);
+    if (mk_likely(t != -1)) {
+        return &ctx->workers[t];
+    }
+
+    return NULL;
+}
+
+/*
+ * This function is invoked when the core triggers a MK_SCHED_SIGNAL_FREE_ALL
+ * event through the signal channels, it means the server will stop working
+ * so this is the last call to release all memory resources in use. Of course
+ * this takes place in a thread context.
+ */
+void mk_sched_worker_free(struct mk_server *server)
+{
+    int i;
+    pthread_t tid;
+    struct mk_sched_ctx *ctx = server->sched_ctx;
+    struct mk_sched_worker *worker = NULL;
+
+    pthread_mutex_lock(&mutex_worker_exit);
+
+    /*
+     * Fix Me: needs to implement API to make plugins release
+     * their resources first at WORKER LEVEL
+     */
+
+    /* External */
+    mk_plugin_exit_worker();
+    mk_vhost_fdt_worker_exit(server);
+    mk_cache_worker_exit();
+
+    /* Scheduler stuff */
+    tid = pthread_self();
+    for (i = 0; i < server->workers; i++) {
+        worker = &ctx->workers[i];
+        if (worker->tid == tid) {
+            break;
+        }
+        worker = NULL;
+    }
+
+    mk_bug(!worker);
+
+    /* FIXME!: there is nothing done here with the worker context */
+
+    /* Free master array (av queue & busy queue) */
+    mk_mem_free(MK_TLS_GET(mk_tls_sched_cs));
+    mk_mem_free(MK_TLS_GET(mk_tls_sched_cs_incomplete));
+    mk_mem_free(MK_TLS_GET(mk_tls_sched_worker_notif));
+    pthread_mutex_unlock(&mutex_worker_exit);
+}
+
+struct mk_sched_handler *mk_sched_handler_cap(char cap)
+{
+    if (cap == MK_CAP_HTTP) {
+        return &mk_http_handler;
+    }
+
+#ifdef MK_HAVE_HTTP2
+    else if (cap == MK_CAP_HTTP2) {
+        return &mk_http2_handler;
+    }
+#endif
+
+    return NULL;
+}
+
+/*
+ * Register a new client connection into the scheduler, this call takes place
+ * inside the worker/thread context.
+ */
+struct mk_sched_conn *mk_sched_add_connection(int remote_fd,
+                                              struct mk_server_listen *listener,
+                                              struct mk_sched_worker *sched,
+                                              struct mk_server *server)
+{
+    int ret;
+    int size;
+    struct mk_sched_handler *handler;
+    struct mk_sched_conn *conn;
+    struct mk_event *event;
+
+    /* Before to continue, we need to run plugin stage 10 */
+    ret = mk_plugin_stage_run_10(remote_fd, server);
+
+    /* Close connection, otherwise continue */
+    if (ret == MK_PLUGIN_RET_CLOSE_CONX) {
+        listener->network->network->close(listener->network, remote_fd);
+        MK_LT_SCHED(remote_fd, "PLUGIN_CLOSE");
+        return NULL;
+    }
+
+    handler = listener->protocol;
+    if (handler->sched_extra_size > 0) {
+        void *data;
+        size = (sizeof(struct mk_sched_conn) + handler->sched_extra_size);
+        data = mk_mem_alloc_z(size);
+        conn = (struct mk_sched_conn *) data;
+    }
+    else {
+        conn = mk_mem_alloc_z(sizeof(struct mk_sched_conn));
+    }
+
+    if (!conn) {
+        mk_err("[server] Could not register client");
+        return NULL;
+    }
+
+    event = &conn->event;
+    event->fd           = remote_fd;
+    event->type         = MK_EVENT_CONNECTION;
+    event->mask         = MK_EVENT_EMPTY;
+    event->status       = MK_EVENT_NONE;
+    conn->arrive_time   = server->clock_context->log_current_utime;
+    conn->protocol      = handler;
+    conn->net           = listener->network->network;
+    conn->is_timeout_on = MK_FALSE;
+    conn->server_listen = listener;
+
+    /* Stream channel */
+    conn->channel.type  = MK_CHANNEL_SOCKET;    /* channel type     */
+    conn->channel.fd    = remote_fd;            /* socket conn      */
+    conn->channel.io    = conn->net;            /* network layer    */
+    conn->channel.event = event;                /* parent event ref */
+    mk_list_init(&conn->channel.streams);
+
+    /*
+     * Register the connections into the timeout_queue:
+     *
+     * When a new connection arrives, we cannot assume it contains some data
+     * to read, meaning the event loop may not get notifications and the protocol
+     * handler will never be called. So in order to avoid DDoS we always register
+     * this session in the timeout_queue for further lookup.
+     *
+     * The protocol handler is in charge to remove the session from the
+     * timeout_queue.
+     */
+    mk_sched_conn_timeout_add(conn, sched);
+
+    /* Linux trace message */
+    MK_LT_SCHED(remote_fd, "REGISTERED");
+
+    return conn;
+}
+
+static void mk_sched_thread_lists_init()
+{
+    struct mk_list *sched_cs_incomplete;
+
+    /* mk_tls_sched_cs_incomplete */
+    sched_cs_incomplete = mk_mem_alloc(sizeof(struct mk_list));
+    mk_list_init(sched_cs_incomplete);
+    MK_TLS_SET(mk_tls_sched_cs_incomplete, sched_cs_incomplete);
+}
+
+/* Register thread information. The caller thread is the thread information's owner */
+static int mk_sched_register_thread(struct mk_server *server)
+{
+    struct mk_sched_ctx *ctx = server->sched_ctx;
+    struct mk_sched_worker *worker;
+
+    /*
+     * If this thread slept inside this section, some other thread may touch
+     * server->worker_id.
+     * So protect it with a mutex, only one thread may handle server->worker_id.
+     *
+     * Note : Let's use the platform agnostic atomics we implemented in cmetrics here
+     * instead of a lock.
+     */
+    worker = &ctx->workers[server->worker_id];
+    worker->idx = server->worker_id++;
+    worker->tid = pthread_self();
+
+#if defined(__linux__)
+    /*
+     * Under Linux does not exists the difference between process and
+     * threads, everything is a thread in the kernel task struct, and each
+     * one has it's own numerical identificator: PID .
+     *
+     * Here we want to know what's the PID associated to this running
+     * task (which is different from parent Monkey PID), it can be
+     * retrieved with gettid() but Glibc does not export to userspace
+     * the syscall, we need to call it directly through syscall(2).
+     */
+    worker->pid = syscall(__NR_gettid);
+#elif defined(__APPLE__)
+    uint64_t tid;
+    pthread_threadid_np(NULL, &tid);
+    worker->pid = tid;
+#else
+    worker->pid = 0xdeadbeef;
+#endif
+
+    /* Initialize lists */
+    mk_list_init(&worker->timeout_queue);
+    worker->request_handler = NULL;
+
+    return worker->idx;
+}
+
+static void mk_signal_thread_sigpipe_safe()
+{
+#ifndef _WIN32
+    sigset_t old;
+    sigset_t set;
+
+    sigemptyset(&set);
+    sigaddset(&set, SIGPIPE);
+    pthread_sigmask(SIG_BLOCK, &set, &old);
+#endif
+}
+
+/* created thread, all these calls are in the thread context */
+void *mk_sched_launch_worker_loop(void *data)
+{
+    int ret;
+    int wid;
+    unsigned long len;
+    char *thread_name = 0;
+    struct mk_list *head;
+    struct mk_sched_worker_cb *wcb;
+    struct mk_sched_worker *sched = NULL;
+    struct mk_sched_notif *notif = NULL;
+    struct mk_sched_thread_conf *thinfo = data;
+    struct mk_sched_ctx *ctx;
+    struct mk_server *server;
+
+    server = thinfo->server;
+    ctx = server->sched_ctx;
+
+    /* Avoid SIGPIPE signals on this thread */
+    mk_signal_thread_sigpipe_safe();
+
+    /* Init specific thread cache */
+    mk_sched_thread_lists_init();
+    mk_cache_worker_init();
+
+    /* Virtual hosts: initialize per thread-vhost data */
+    mk_vhost_fdt_worker_init(server);
+
+    /* Register working thread */
+    wid = mk_sched_register_thread(server);
+    sched = &ctx->workers[wid];
+    sched->loop = mk_event_loop_create(MK_EVENT_QUEUE_SIZE);
+    if (!sched->loop) {
+        mk_err("Error creating Scheduler loop");
+        exit(EXIT_FAILURE);
+    }
+
+
+    sched->mem_pagesize = mk_utils_get_system_page_size();
+
+    /*
+     * Create the notification instance and link it to the worker
+     * thread-scope list.
+     */
+    notif = mk_mem_alloc_z(sizeof(struct mk_sched_notif));
+    MK_TLS_SET(mk_tls_sched_worker_notif, notif);
+
+    /* Register the scheduler channel to signal active workers */
+    ret = mk_event_channel_create(sched->loop,
+                                  &sched->signal_channel_r,
+                                  &sched->signal_channel_w,
+                                  notif);
+    if (ret < 0) {
+        exit(EXIT_FAILURE);
+    }
+
+    mk_list_init(&sched->event_free_queue);
+    mk_list_init(&sched->threads);
+    mk_list_init(&sched->threads_purge);
+
+    /*
+     * ULONG_MAX BUG test only
+     * =======================
+     * to test the workaround we can use the following value:
+     *
+     *  thinfo->closed_connections = 1000;
+     */
+
+    //thinfo->ctx = thconf->ctx;
+
+    /* Rename worker */
+    mk_string_build(&thread_name, &len, "monkey: wrk/%i", sched->idx);
+    mk_utils_worker_rename(thread_name);
+    mk_mem_free(thread_name);
+
+    /* Export known scheduler node to context thread */
+    MK_TLS_SET(mk_tls_sched_worker_node, sched);
+    mk_plugin_core_thread(server);
+
+    if (server->scheduler_mode == MK_SCHEDULER_REUSEPORT) {
+        sched->listeners = mk_server_listen_init(server);
+        if (!sched->listeners) {
+            exit(EXIT_FAILURE);
+        }
+    }
+
+    /* Unlock the conditional initializator */
+    pthread_mutex_lock(&server->pth_mutex);
+    server->pth_init = MK_TRUE;
+    pthread_cond_signal(&server->pth_cond);
+    pthread_mutex_unlock(&server->pth_mutex);
+
+    /* Invoke custom worker-callbacks defined by the scheduler (lib) */
+    mk_list_foreach(head, &server->sched_worker_callbacks) {
+        wcb = mk_list_entry(head, struct mk_sched_worker_cb, _head);
+        wcb->cb_func(wcb->data);
+    }
+
+    mk_mem_free(thinfo);
+
+    /* init server thread loop */
+    mk_server_worker_loop(server);
+
+    return 0;
+}
+
+/* Create thread which will be listening for incomings requests */
+int mk_sched_launch_thread(struct mk_server *server, pthread_t *tout)
+{
+    pthread_t tid;
+    pthread_attr_t attr;
+    struct mk_sched_thread_conf *thconf;
+
+    server->pth_init = MK_FALSE;
+
+    /*
+     * This lock is used for the 'pth_cond' conditional. Once the worker
+     * thread is ready it will signal the condition.
+     */
+    pthread_mutex_lock(&server->pth_mutex);
+
+    /* Thread data */
+    thconf = mk_mem_alloc_z(sizeof(struct mk_sched_thread_conf));
+    thconf->server = server;
+
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+    if (pthread_create(&tid, &attr, mk_sched_launch_worker_loop,
+                       (void *) thconf) != 0) {
+        mk_libc_error("pthread_create");
+        pthread_mutex_unlock(&server->pth_mutex);
+        return -1;
+    }
+
+    *tout = tid;
+
+    /* Block until the child thread is ready */
+    while (!server->pth_init) {
+        pthread_cond_wait(&server->pth_cond, &server->pth_mutex);
+    }
+
+    pthread_mutex_unlock(&server->pth_mutex);
+
+    return 0;
+}
+
+/*
+ * The scheduler nodes are an array of struct mk_sched_worker type,
+ * each worker thread belongs to a scheduler node, on this function we
+ * allocate a scheduler node per number of workers defined.
+ */
+int mk_sched_init(struct mk_server *server)
+{
+    int size;
+    struct mk_sched_ctx *ctx;
+
+    ctx = mk_mem_alloc_z(sizeof(struct mk_sched_ctx));
+    if (!ctx) {
+        mk_libc_error("malloc");
+        return -1;
+    }
+
+    size = (sizeof(struct mk_sched_worker) * server->workers);
+    ctx->workers = mk_mem_alloc(size);
+    if (!ctx->workers) {
+        mk_libc_error("malloc");
+        mk_mem_free(ctx);
+        return -1;
+    }
+    memset(ctx->workers, '\0', size);
+
+    /* Initialize helpers */
+    pthread_mutex_init(&server->pth_mutex, NULL);
+    pthread_cond_init(&server->pth_cond, NULL);
+    server->pth_init = MK_FALSE;
+
+    /* Map context into server context */
+    server->sched_ctx = ctx;
+
+    /* The mk_thread_prepare call was replaced by mk_http_thread_initialize_tls
+     * which is called earlier.
+     */
+
+    return 0;
+}
+
+int mk_sched_exit(struct mk_server *server)
+{
+    struct mk_sched_ctx *ctx;
+
+    ctx = server->sched_ctx;
+    mk_sched_worker_cb_free(server);
+    mk_mem_free(ctx->workers);
+    mk_mem_free(ctx);
+
+    return 0;
+}
+
+void mk_sched_set_request_list(struct rb_root *list)
+{
+    MK_TLS_SET(mk_tls_sched_cs, list);
+}
+
+int mk_sched_remove_client(struct mk_sched_conn *conn,
+                           struct mk_sched_worker *sched,
+                           struct mk_server *server)
+{
+    struct mk_event *event;
+
+    /*
+     * Close socket and change status: we must invoke mk_epoll_del()
+     * because when the socket is closed is cleaned from the queue by
+     * the Kernel at its leisure, and we may get false events if we rely
+     * on that.
+     */
+    event = &conn->event;
+    MK_TRACE("[FD %i] Scheduler remove", event->fd);
+
+    mk_event_del(sched->loop, event);
+
+    /* Invoke plugins in stage 50 */
+    mk_plugin_stage_run_50(event->fd, server);
+
+    sched->closed_connections++;
+
+    /* Unlink from the red-black tree */
+    //rb_erase(&conn->_rb_head, &sched->rb_queue);
+    mk_sched_conn_timeout_del(conn);
+
+    /* Close at network layer level */
+    conn->net->close(conn->net->plugin, event->fd);
+
+    /* Release and return */
+    mk_channel_clean(&conn->channel);
+    mk_sched_event_free(&conn->event);
+    conn->status = MK_SCHED_CONN_CLOSED;
+
+    MK_LT_SCHED(remote_fd, "DELETE_CLIENT");
+    return 0;
+}
+
+/* FIXME: nobody is using this function, check back later */
+struct mk_sched_conn *mk_sched_get_connection(struct mk_sched_worker *sched,
+                                                 int remote_fd)
+{
+    (void) sched;
+    (void) remote_fd;
+    return NULL;
+}
+
+/*
+ * For a given connection number, remove all resources associated: it can be
+ * used on any context such as: timeout, I/O errors, request finished,
+ * exceptions, etc.
+ */
+int mk_sched_drop_connection(struct mk_sched_conn *conn,
+                             struct mk_sched_worker *sched,
+                             struct mk_server *server)
+{
+    mk_sched_threads_destroy_conn(sched, conn);
+    return mk_sched_remove_client(conn, sched, server);
+}
+
+int mk_sched_check_timeouts(struct mk_sched_worker *sched,
+                            struct mk_server *server)
+{
+    int client_timeout;
+    struct mk_sched_conn *conn;
+    struct mk_list *head;
+    struct mk_list *temp;
+
+    /* PENDING CONN TIMEOUT */
+    mk_list_foreach_safe(head, temp, &sched->timeout_queue) {
+        conn = mk_list_entry(head, struct mk_sched_conn, timeout_head);
+        if (conn->event.type & MK_EVENT_IDLE) {
+            continue;
+        }
+
+        client_timeout = conn->arrive_time + server->timeout;
+
+        /* Check timeout */
+        if (client_timeout <= server->clock_context->log_current_utime) {
+            MK_TRACE("Scheduler, closing fd %i due TIMEOUT",
+                     conn->event.fd);
+            MK_LT_SCHED(conn->event.fd, "TIMEOUT_CONN_PENDING");
+            conn->protocol->cb_close(conn, sched, MK_SCHED_CONN_TIMEOUT,
+                                     server);
+            mk_sched_drop_connection(conn, sched, server);
+        }
+    }
+
+    return 0;
+}
+
+static int sched_thread_cleanup(struct mk_sched_worker *sched,
+                                struct mk_list *list)
+{
+    int c = 0;
+    struct mk_list *tmp;
+    struct mk_list *head;
+    struct mk_http_thread *mth;
+    (void) sched;
+
+    mk_list_foreach_safe(head, tmp, list) {
+        mth = mk_list_entry(head, struct mk_http_thread, _head);
+        mk_http_thread_destroy(mth);
+        c++;
+    }
+
+    return c;
+
+}
+
+int mk_sched_threads_purge(struct mk_sched_worker *sched)
+{
+    int c = 0;
+
+    c = sched_thread_cleanup(sched, &sched->threads_purge);
+    return c;
+}
+
+int mk_sched_threads_destroy_all(struct mk_sched_worker *sched)
+{
+    int c = 0;
+
+    c = sched_thread_cleanup(sched, &sched->threads_purge);
+    c += sched_thread_cleanup(sched, &sched->threads);
+
+    return c;
+}
+
+/*
+ * Destroy the thread contexts associated to the particular
+ * connection.
+ *
+ * Return the number of contexts destroyed.
+ */
+int mk_sched_threads_destroy_conn(struct mk_sched_worker *sched,
+                                  struct mk_sched_conn *conn)
+{
+    int c = 0;
+    struct mk_list *tmp;
+    struct mk_list *head;
+    struct mk_http_thread *mth;
+    (void) sched;
+
+    mk_list_foreach_safe(head, tmp, &sched->threads) {
+        mth = mk_list_entry(head, struct mk_http_thread, _head);
+        if (mth->session->conn == conn) {
+            mk_http_thread_destroy(mth);
+            c++;
+        }
+    }
+    return c;
+}
+
+/*
+ * Scheduler events handler: lookup for event handler and invoke
+ * proper callbacks.
+ */
+int mk_sched_event_read(struct mk_sched_conn *conn,
+                        struct mk_sched_worker *sched,
+                        struct mk_server *server)
+{
+    int ret = 0;
+
+#ifdef MK_HAVE_TRACE
+    MK_TRACE("[FD %i] Connection Handler / read", conn->event.fd);
+#endif
+
+    /*
+     * When the event loop notify that there is some readable information
+     * from the socket, we need to invoke the protocol handler associated
+     * to this connection and also pass as a reference the 'read()' function
+     * that handle 'read I/O' operations, e.g:
+     *
+     *  - plain sockets through liana will use just read(2)
+     *  - ssl though mbedtls should use mk_mbedtls_read(..)
+     */
+    ret = conn->protocol->cb_read(conn, sched, server);
+    if (ret == -1) {
+        if (errno == EAGAIN) {
+            MK_TRACE("[FD %i] EAGAIN: need to read more data", conn->event.fd);
+            return 1;
+        }
+        return -1;
+    }
+
+    return ret;
+}
+
+int mk_sched_event_write(struct mk_sched_conn *conn,
+                         struct mk_sched_worker *sched,
+                         struct mk_server *server)
+{
+    int ret = -1;
+    size_t count;
+    struct mk_event *event;
+
+    MK_TRACE("[FD %i] Connection Handler / write", conn->event.fd);
+
+    ret = mk_channel_write(&conn->channel, &count);
+    if (ret == MK_CHANNEL_FLUSH || ret == MK_CHANNEL_BUSY) {
+        return 0;
+    }
+    else if (ret == MK_CHANNEL_DONE || ret == MK_CHANNEL_EMPTY) {
+        if (conn->protocol->cb_done) {
+            ret = conn->protocol->cb_done(conn, sched, server);
+        }
+        if (ret == -1) {
+            return -1;
+        }
+        else if (ret == 0) {
+            event = &conn->event;
+            mk_event_add(sched->loop, event->fd,
+                         MK_EVENT_CONNECTION,
+                         MK_EVENT_READ,
+                         conn);
+        }
+        return 0;
+    }
+    else if (ret & MK_CHANNEL_ERROR) {
+        return -1;
+    }
+
+    /* avoid to make gcc cry :_( */
+    return -1;
+}
+
+int mk_sched_event_close(struct mk_sched_conn *conn,
+                         struct mk_sched_worker *sched,
+                         int type, struct mk_server *server)
+{
+    MK_TRACE("[FD %i] Connection Handler, closed", conn->event.fd);
+    mk_event_del(sched->loop, &conn->event);
+
+    if (type != MK_EP_SOCKET_DONE) {
+        conn->protocol->cb_close(conn, sched, type, server);
+    }
+    /*
+     * Remove the socket from the scheduler and make sure
+     * to disable all notifications.
+     */
+    mk_sched_drop_connection(conn, sched, server);
+    return 0;
+}
+
+void mk_sched_event_free(struct mk_event *event)
+{
+    struct mk_sched_worker *sched = mk_sched_get_thread_conf();
+
+    if ((event->type & MK_EVENT_IDLE) != 0) {
+        return;
+    }
+
+    event->type |= MK_EVENT_IDLE;
+    mk_list_add(&event->_head, &sched->event_free_queue);
+}
+
+/* Register a new callback function to invoke when a worker is created */
+int mk_sched_worker_cb_add(struct mk_server *server,
+                           void (*cb_func) (void *),
+                           void *data)
+{
+    struct mk_sched_worker_cb *wcb;
+
+    wcb = mk_mem_alloc(sizeof(struct mk_sched_worker_cb));
+    if (!wcb) {
+        return -1;
+    }
+
+    wcb->cb_func = cb_func;
+    wcb->data    = data;
+    mk_list_add(&wcb->_head, &server->sched_worker_callbacks);
+    return 0;
+}
+
+void mk_sched_worker_cb_free(struct mk_server *server)
+{
+    struct mk_list *tmp;
+    struct mk_list *head;
+    struct mk_sched_worker_cb *wcb;
+
+    mk_list_foreach_safe(head, tmp, &server->sched_worker_callbacks) {
+        wcb = mk_list_entry(head, struct mk_sched_worker_cb, _head);
+        mk_list_del(&wcb->_head);
+        mk_mem_free(wcb);
+    }
+}
+
+int mk_sched_send_signal(struct mk_sched_worker *worker, uint64_t val)
+{
+    ssize_t n;
+
+    /* When using libevent _mk_event_channel_create creates a unix socket
+     * instead of a pipe and windows doesn't us calling read / write on a
+     * socket instead of recv / send
+     */
+
+#ifdef _WIN32
+    n = send(worker->signal_channel_w, &val, sizeof(uint64_t), 0);
+#else
+    n = write(worker->signal_channel_w, &val, sizeof(uint64_t));
+#endif
+
+    if (n < 0) {
+        mk_libc_error("write");
+
+        return 0;
+    }
+
+    return 1;
+}
+
+int mk_sched_broadcast_signal(struct mk_server *server, uint64_t val)
+{
+    int i;
+    int count = 0;
+    struct mk_sched_ctx *ctx;
+    struct mk_sched_worker *worker;
+
+    ctx = server->sched_ctx;
+    for (i = 0; i < server->workers; i++) {
+        worker = &ctx->workers[i];
+
+        count += mk_sched_send_signal(worker, val);
+    }
+
+    return count;
+}
+
+/*
+ * Wait for all workers to finish: this function assumes that previously a
+ * MK_SCHED_SIGNAL_FREE_ALL was sent to the worker channels.
+ */
+int mk_sched_workers_join(struct mk_server *server)
+{
+    int i;
+    int count = 0;
+    struct mk_sched_ctx *ctx;
+    struct mk_sched_worker *worker;
+
+    ctx = server->sched_ctx;
+    for (i = 0; i < server->workers; i++) {
+        worker = &ctx->workers[i];
+        pthread_join(worker->tid, NULL);
+        count++;
+    }
+
+    return count;
+}
diff --git a/fluent-bit/lib/monkey/mk_server/mk_server.c b/fluent-bit/lib/monkey/mk_server/mk_server.c
new file mode 100644
index 00000000..a84ef448
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_server.c
@@ -0,0 +1,679 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <monkey/mk_info.h>
+#include <monkey/monkey.h>
+#include <monkey/mk_config.h>
+#include <monkey/mk_scheduler.h>
+#include <monkey/mk_plugin.h>
+#include <monkey/mk_utils.h>
+#include <monkey/mk_server.h>
+#include <monkey/mk_server_tls.h>
+#include <monkey/mk_scheduler.h>
+#include <monkey/mk_core.h>
+#include <monkey/mk_fifo.h>
+#include <monkey/mk_http_thread.h>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#else
+#include <sys/socket.h>
+#include <netinet/in.h>
+#endif
+
+#ifndef _WIN32
+#include <sys/time.h>
+#include <sys/resource.h>
+#endif
+
+pthread_key_t mk_server_fifo_key;
+
+static int mk_server_lib_notify_event_loop_break(struct mk_sched_worker *sched);
+
+/* Return the number of clients that can be attended  */
+unsigned int mk_server_capacity(struct mk_server *server)
+{
+    int ret;
+    int cur;
+
+#ifndef _WIN32
+    struct rlimit lim;
+
+    /* Limit by system */
+    getrlimit(RLIMIT_NOFILE, &lim);
+    cur = lim.rlim_cur;
+
+    if (server->fd_limit > cur) {
+        lim.rlim_cur = server->fd_limit;
+        lim.rlim_max = server->fd_limit;
+
+        ret = setrlimit(RLIMIT_NOFILE, &lim);
+        if (ret == -1) {
+            mk_warn("Could not increase FDLimit to %i.", server->fd_limit);
+        }
+        else {
+            cur = server->fd_limit;
+        }
+    }
+    else if (server->fd_limit > 0) {
+        cur = server->fd_limit;
+    }
+
+#else
+    ret = 0;
+    cur = INT_MAX; 
+
+    /* This is not the right way to plug this, according to raymond chen the only limit
+     * to fd count is free memory in their winsock provider and there are no other limits
+     * that I know of but I should still look for a more elegant solution. (even if it
+     * was just ignoring the server_capacity limit in scheduler.c: _next_target)
+    */
+#endif
+
+    return cur;
+}
+
+static inline
+struct mk_sched_conn *mk_server_listen_handler(struct mk_sched_worker *sched,
+                                               void *data,
+                                               struct mk_server *server)
+{
+    int ret;
+    int client_fd = -1;
+    struct mk_sched_conn *conn;
+    struct mk_server_listen *listener = data;
+
+    client_fd = mk_socket_accept(listener->server_fd);
+    if (mk_unlikely(client_fd == -1)) {
+        MK_TRACE("[server] Accept connection failed: %s", strerror(errno));
+        goto error;
+    }
+
+    conn = mk_sched_add_connection(client_fd, listener, sched, server);
+    if (mk_unlikely(!conn)) {
+        goto error;
+    }
+
+    ret = mk_event_add(sched->loop, client_fd,
+                       MK_EVENT_CONNECTION, MK_EVENT_READ, conn);
+    if (mk_unlikely(ret != 0)) {
+        mk_err("[server] Error registering file descriptor: %s",
+               strerror(errno));
+        goto error;
+    }
+
+    sched->accepted_connections++;
+    MK_TRACE("[server] New connection arrived: FD %i", client_fd);
+    return conn;
+
+error:
+    if (client_fd != -1) {
+        listener->network->network->close(listener->network, client_fd);
+    }
+
+    return NULL;
+}
+
+void mk_server_listen_free()
+{
+    struct mk_list *list;
+    struct mk_list *tmp;
+    struct mk_list *head;
+    struct mk_server_listen *listener;
+
+    list = MK_TLS_GET(mk_tls_server_listen);
+    mk_list_foreach_safe(head, tmp, list) {
+        listener = mk_list_entry(head, struct mk_server_listen, _head);
+        mk_list_del(&listener->_head);
+        mk_mem_free(listener);
+    }
+}
+
+void mk_server_listen_exit(struct mk_list *list)
+{
+    struct mk_list *tmp;
+    struct mk_list *head;
+    struct mk_server_listen *listen;
+
+    if (!list) {
+        return;
+    }
+
+    mk_list_foreach_safe(head, tmp, list) {
+        listen = mk_list_entry(head, struct mk_server_listen, _head);
+        mk_event_closesocket(listen->server_fd);
+        mk_list_del(&listen->_head);
+        mk_mem_free(listen);
+    }
+
+    mk_mem_free(list);
+}
+
+struct mk_list *mk_server_listen_init(struct mk_server *server)
+{
+    int server_fd;
+    int reuse_port = MK_FALSE;
+    struct mk_list *head;
+    struct mk_list *listeners;
+    struct mk_event *event;
+    struct mk_server_listen *listener;
+    struct mk_sched_handler *protocol;
+    struct mk_plugin *plugin;
+    struct mk_config_listener *listen;
+
+    if (!server) {
+        goto error;
+    }
+
+    listeners = mk_mem_alloc(sizeof(struct mk_list));
+    mk_list_init(listeners);
+
+    if (server->scheduler_mode == MK_SCHEDULER_REUSEPORT) {
+        reuse_port = MK_TRUE;
+    }
+
+    mk_list_foreach(head, &server->listeners) {
+        listen = mk_list_entry(head, struct mk_config_listener, _head);
+
+        server_fd = mk_socket_server(listen->port,
+                                     listen->address,
+                                     reuse_port,
+                                     server);
+        if (server_fd >= 0) {
+            if (mk_socket_set_tcp_defer_accept(server_fd) != 0) {
+#if defined (__linux__)
+                mk_warn("[server] Could not set TCP_DEFER_ACCEPT");
+#endif
+            }
+
+            listener = mk_mem_alloc_z(sizeof(struct mk_server_listen));
+
+            /* configure the internal event_state */
+            event = &listener->event;
+            event->fd   = server_fd;
+            event->type = MK_EVENT_LISTENER;
+            event->mask = MK_EVENT_EMPTY;
+            event->status = MK_EVENT_NONE;
+
+            /* continue with listener setup and linking */
+            listener->server_fd = server_fd;
+            listener->listen    = listen;
+
+            if (listen->flags & MK_CAP_HTTP) {
+                protocol = mk_sched_handler_cap(MK_CAP_HTTP);
+                if (!protocol) {
+                    mk_err("HTTP protocol not supported");
+                    exit(EXIT_FAILURE);
+                }
+                listener->protocol = protocol;
+            }
+
+#ifdef MK_HAVE_HTTP2
+            if (listen->flags & MK_CAP_HTTP2) {
+                protocol = mk_sched_handler_cap(MK_CAP_HTTP2);
+                if (!protocol) {
+                    mk_err("HTTP2 protocol not supported");
+                    exit(EXIT_FAILURE);
+                }
+                listener->protocol = protocol;
+            }
+#endif
+            listener->network = mk_plugin_cap(MK_CAP_SOCK_PLAIN, server);
+
+            if (listen->flags & MK_CAP_SOCK_TLS) {
+                plugin = mk_plugin_cap(MK_CAP_SOCK_TLS, server);
+                if (!plugin) {
+                    mk_err("SSL/TLS not supported");
+                    exit(EXIT_FAILURE);
+                }
+                listener->network = plugin;
+            }
+
+            mk_list_add(&listener->_head, listeners);
+        }
+        else {
+            mk_err("[server] Failed to bind server socket to %s:%s.",
+                   listen->address,
+                   listen->port);
+            return NULL;
+        }
+    }
+
+    if (reuse_port == MK_TRUE) {
+        MK_TLS_SET(mk_tls_server_listen, listeners);
+    }
+
+    return listeners;
+
+error:
+    return NULL;
+}
+
+/* Here we launch the worker threads to attend clients */
+void mk_server_launch_workers(struct mk_server *server)
+{
+    int i;
+    pthread_t skip;
+
+    /* Launch workers */
+    for (i = 0; i < server->workers; i++) {
+        /* Spawn the thread */
+        mk_sched_launch_thread(server, &skip);
+    }
+}
+
+/*
+ * When using the FIFO interface, this function get's the FIFO worker
+ * context and register the pipe file descriptor into the main event
+ * loop.
+ *
+ * note: this function is invoked by each worker thread.
+ */
+static int mk_server_fifo_worker_setup(struct mk_event_loop *evl)
+{
+    int ret;
+    struct mk_fifo_worker *fw;
+
+    fw = pthread_getspecific(mk_server_fifo_key);
+    if (!fw) {
+        return -1;
+    }
+
+    ret = mk_event_add(evl, fw->channel[0],
+                       MK_EVENT_FIFO, MK_EVENT_READ,
+                       fw);
+    if (ret != 0) {
+        mk_err("[server] Error registering fifo worker channel: %s",
+               strerror(errno));
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * The loop_balancer() runs in the main process context and is considered
+ * the old-fashion way to handle connections. It have an event queue waiting
+ * for connections, once one arrives, it decides which worker (thread) may
+ * handle it registering the accept(2)ed file descriptor on the worker
+ * event monitored queue.
+ */
+void mk_server_loop_balancer(struct mk_server *server)
+{
+    size_t bytes;
+    uint64_t val;
+    int operation_flag;
+    struct mk_list *head;
+    struct mk_list *listeners;
+    struct mk_server_listen *listener;
+    struct mk_event *event;
+    struct mk_event_loop *evl;
+    struct mk_sched_worker *sched;
+    struct mk_event management_event;
+
+    /* Init the listeners */
+    listeners = mk_server_listen_init(server);
+    if (!listeners) {
+        mk_err("Failed to initialize listen sockets.");
+        return;
+    }
+
+    /* Create an event loop context */
+    evl = mk_event_loop_create(MK_EVENT_QUEUE_SIZE);
+    if (!evl) {
+        mk_err("Could not initialize event loop");
+        exit(EXIT_FAILURE);
+    }
+
+    /* Register the listeners */
+    mk_list_foreach(head, listeners) {
+        listener = mk_list_entry(head, struct mk_server_listen, _head);
+        mk_event_add(evl, listener->server_fd,
+                     MK_EVENT_LISTENER, MK_EVENT_READ,
+                     listener);
+    }
+
+    memset(&management_event, 0, sizeof(struct mk_event));
+
+    mk_event_add(evl,
+                 server->lib_ch_manager[0],
+                 MK_EVENT_NOTIFICATION,
+                 MK_EVENT_READ,
+                 &management_event);
+
+    operation_flag = MK_TRUE;
+    while (operation_flag) {
+        mk_event_wait(evl);
+        mk_event_foreach(event, evl) {
+            if (event->mask & MK_EVENT_READ) {
+                /* This signal is sent by mk_stop and both this and
+                 * mk_lib_worker are expecting it.
+                 */
+                if (server->lib_ch_manager[0] == event->fd) {
+#ifdef _WIN32
+        bytes = recv(event->fd, &val, sizeof(uint64_t), MSG_WAITALL);
+#else
+        bytes = read(event->fd, &val, sizeof(uint64_t));
+#endif
+
+                    if (bytes <= 0) {
+                        return;
+                    }
+
+                    if (val == MK_SERVER_SIGNAL_STOP) {
+                        operation_flag = MK_FALSE;
+
+                        break;
+                    }
+
+                    continue;
+                }
+
+                /*
+                 * Accept connection: determinate which thread may work on this
+                 * new connection.
+                 */
+                sched = mk_sched_next_target(server);
+                if (sched != NULL) {
+                    mk_server_listen_handler(sched, event, server);
+
+                    mk_server_lib_notify_event_loop_break(sched);
+
+#ifdef MK_HAVE_TRACE
+                    int i;
+                    struct mk_sched_ctx *ctx = server->sched_ctx;
+
+                    for (i = 0; i < server->workers; i++) {
+                        MK_TRACE("Worker Status");
+                        MK_TRACE(" WID %i / conx = %llu",
+                                 ctx->workers[i].idx,
+                                 ctx->workers[i].accepted_connections -
+                                 ctx->workers[i].closed_connections);
+                    }
+#endif
+                }
+                else {
+                    mk_warn("[server] Over capacity.");
+                }
+            }
+            else if (event->mask & MK_EVENT_CLOSE) {
+                mk_err("[server] Error on socket %d: %s",
+                       event->fd, strerror(errno));
+            }
+        }
+    }
+    mk_event_loop_destroy(evl);
+    mk_server_listen_exit(listeners);
+}
+
+/*
+ * This function is called when the scheduler is running in the REUSEPORT
+ * mode. That means that each worker is listening on shared TCP ports.
+ *
+ * When using shared TCP ports the Kernel decides to which worker the
+ * connection will be assigned.
+ */
+void mk_server_worker_loop(struct mk_server *server)
+{
+    int ret = -1;
+    int timeout_fd;
+    uint64_t val;
+    struct mk_event *event;
+    struct mk_event_loop *evl;
+    struct mk_list *list;
+    struct mk_list *head;
+    struct mk_sched_conn *conn;
+    struct mk_sched_worker *sched;
+    struct mk_server_listen *listener;
+    struct mk_server_timeout *server_timeout;
+
+    /* Get thread conf */
+    sched = mk_sched_get_thread_conf();
+    evl = sched->loop;
+
+    /*
+     * The worker will NOT process any connection until the master
+     * process through mk_server_loop() send us the green light
+     * signal MK_SERVER_SIGNAL_START.
+     */
+    mk_event_wait(evl);
+    mk_event_foreach(event, evl) {
+        if ((event->mask & MK_EVENT_READ) &&
+            event->type == MK_EVENT_NOTIFICATION) {
+            if (event->fd == sched->signal_channel_r) {
+        /* When using libevent _mk_event_channel_create creates a unix socket
+         * instead of a pipe and windows doesn't us calling read / write on a
+         * socket instead of recv / send
+         */
+#ifdef _WIN32
+                ret = recv(event->fd, &val, sizeof(val), MSG_WAITALL);
+#else
+                ret = read(event->fd, &val, sizeof(val));
+#endif
+                if (ret < 0) {
+                    mk_libc_error("read");
+                    continue;
+                }
+                if (val == MK_SERVER_SIGNAL_START) {
+                    MK_TRACE("Worker %i started (SIGNAL_START)", sched->idx);
+                    break;
+                }
+            }
+        }
+    }
+
+    if (server->scheduler_mode == MK_SCHEDULER_REUSEPORT) {
+        /* Register listeners */
+        list = MK_TLS_GET(mk_tls_server_listen);
+        mk_list_foreach(head, list) {
+            listener = mk_list_entry(head, struct mk_server_listen, _head);
+            mk_event_add(sched->loop, listener->server_fd,
+                         MK_EVENT_LISTENER, MK_EVENT_READ,
+                         listener);
+        }
+    }
+
+    /*
+     * If running in library mode, register the FIFO pipe file descriptors
+     * into the main event loop.
+     */
+    if (server->lib_mode == MK_TRUE) {
+        mk_server_fifo_worker_setup(evl);
+    }
+
+    /* create a new timeout file descriptor */
+    server_timeout = mk_mem_alloc_z(sizeof(struct mk_server_timeout));
+    MK_TLS_SET(mk_tls_server_timeout, server_timeout);
+    timeout_fd = mk_event_timeout_create(evl, server->timeout, 0, server_timeout);
+
+    while (1) {
+        mk_event_wait(evl);
+        mk_event_foreach(event, evl) {
+            ret = 0;
+            if (event->type & MK_EVENT_IDLE) {
+                continue;
+            }
+
+            if (event->type == MK_EVENT_CONNECTION) {
+                conn = (struct mk_sched_conn *) event;
+
+                if (event->mask & MK_EVENT_WRITE) {
+                    MK_TRACE("[FD %i] Event WRITE", event->fd);
+                    ret = mk_sched_event_write(conn, sched, server);
+                }
+
+                if (event->mask & MK_EVENT_READ) {
+                    MK_TRACE("[FD %i] Event READ", event->fd);
+                    ret = mk_sched_event_read(conn, sched, server);
+                }
+
+
+                if (event->mask & MK_EVENT_CLOSE && ret != -1) {
+                    MK_TRACE("[FD %i] Event CLOSE", event->fd);
+                    ret = -1;
+                }
+
+                if (ret < 0 && conn->status != MK_SCHED_CONN_CLOSED) {
+                    MK_TRACE("[FD %i] Event FORCE CLOSE | ret = %i",
+                             event->fd, ret);
+                    mk_sched_event_close(conn, sched, MK_EP_SOCKET_CLOSED,
+                                         server);
+                }
+            }
+            else if (event->type == MK_EVENT_LISTENER) {
+                /*
+                 * A new connection have been accepted..or failed, despite
+                 * the result, we let the loop continue processing the other
+                 * events triggered.
+                 */
+                conn = mk_server_listen_handler(sched, event, server);
+                if (conn) {
+                    //conn->event.mask = MK_EVENT_READ
+                    //goto speed;
+                }
+                continue;
+            }
+            else if (event->type == MK_EVENT_CUSTOM) {
+                /*
+                 * We got an event associated to a custom interface, that
+                 * means a plugin registered some file descriptor on this
+                 * event loop and an event was triggered. We pass the control
+                 * to the defined event handler.
+                 */
+                event->handler(event);
+            }
+            else if (event->type == MK_EVENT_NOTIFICATION) {
+#ifdef _WIN32
+                ret = recv(event->fd, &val, sizeof(val), MSG_WAITALL);
+#else
+                ret = read(event->fd, &val, sizeof(val));
+#endif
+                if (ret < 0) {
+                    mk_libc_error("read");
+                    continue;
+                }
+
+                if (event->fd == sched->signal_channel_r) {
+                    if (val == MK_SCHED_SIGNAL_DEADBEEF) {
+                        //FIXME:mk_sched_sync_counters();
+                        continue;
+                    }
+                    else if (val == MK_SCHED_SIGNAL_FREE_ALL) {
+                        if (timeout_fd > 0) {
+                            mk_event_timeout_destroy(evl, server_timeout);
+                        }
+                        mk_mem_free(MK_TLS_GET(mk_tls_server_timeout));
+                        mk_server_listen_exit(sched->listeners);
+                        mk_event_loop_destroy(evl);
+                        mk_sched_worker_free(server);
+                        return;
+                    }
+                    else if (val == MK_SCHED_SIGNAL_EVENT_LOOP_BREAK) {
+                        /* NOTE: This is just a notification that's sent to break out
+                         *       of the libevent loop in windows after accepting a new
+                         *       client
+                        */
+                        MK_TRACE("New client accepted, awesome!");
+                    }
+                }
+                else if (event->fd == timeout_fd) {
+                    mk_sched_check_timeouts(sched, server);
+                }
+                continue;
+            }
+            else if (event->type == MK_EVENT_THREAD) {
+                mk_http_thread_event(event);
+                continue;
+            }
+            else if (event->type == MK_EVENT_FIFO) {
+                mk_fifo_worker_read(event);
+                continue;
+            }
+        }
+        mk_sched_threads_purge(sched);
+        mk_sched_event_free_all(sched);
+    }
+}
+
+static int mk_server_lib_notify_event_loop_break(struct mk_sched_worker *sched)
+{
+    uint64_t val;
+
+    /* Check the channel is valid (enabled by library mode) */
+    if (sched->signal_channel_w <= 0) {
+        return -1;
+    }
+
+    val = MK_SCHED_SIGNAL_EVENT_LOOP_BREAK;
+
+#ifdef _WIN32
+    return send(sched->signal_channel_w, &val, sizeof(uint64_t), 0);
+#else
+    return write(sched->signal_channel_w, &val, sizeof(uint64_t));
+#endif
+}
+
+static int mk_server_lib_notify_started(struct mk_server *server)
+{
+    uint64_t val;
+
+    /* Check the channel is valid (enabled by library mode) */
+    if (server->lib_ch_start[1] <= 0) {
+        return -1;
+    }
+
+    val = MK_SERVER_SIGNAL_START;
+
+#ifdef _WIN32
+    return send(server->lib_ch_start[1], &val, sizeof(uint64_t), 0);
+#else
+    return write(server->lib_ch_start[1], &val, sizeof(uint64_t));
+#endif
+}
+
+void mk_server_loop(struct mk_server *server)
+{
+    uint64_t val;
+
+    /* Rename worker */
+    mk_utils_worker_rename("monkey: server");
+
+    if (server->lib_mode == MK_FALSE) {
+        mk_info("HTTP Server started");
+    }
+
+    /* Wake up workers */
+    val = MK_SERVER_SIGNAL_START;
+    mk_sched_broadcast_signal(server, val);
+
+    /* Signal lib caller (if any) */
+    mk_server_lib_notify_started(server);
+
+    /*
+     * When using REUSEPORT mode on the Scheduler, we need to signal
+     * them so they can start processing connections.
+     */
+    if (server->scheduler_mode == MK_SCHEDULER_REUSEPORT) {
+        /* do thing :) */
+    }
+    else {
+        /* FIXME!: this old mode needs some checks on library mode */
+        mk_server_loop_balancer(server);
+    }
+}
diff --git a/fluent-bit/lib/monkey/mk_server/mk_socket.c b/fluent-bit/lib/monkey/mk_server/mk_socket.c
new file mode 100644
index 00000000..0277ab1c
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_socket.c
@@ -0,0 +1,402 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#define _GNU_SOURCE
+
+#ifndef SOL_TCP
+#define SOL_TCP IPPROTO_TCP
+#endif
+
+#include <monkey/monkey.h>
+#include <monkey/mk_info.h>
+#include <monkey/mk_socket.h>
+#include <monkey/mk_kernel.h>
+#include <monkey/mk_net.h>
+#include <monkey/mk_core.h>
+#include <monkey/mk_utils.h>
+#include <monkey/mk_plugin.h>
+
+#include <time.h>
+
+/*
+ * Example from:
+ * http://www.baus.net/on-tcp_cork
+ */
+int mk_socket_set_cork_flag(int fd, int state)
+{
+    MK_TRACE("Socket, set Cork Flag FD %i to %s", fd, (state ? "ON" : "OFF"));
+
+#if defined (TCP_CORK)
+    return setsockopt(fd, SOL_TCP, TCP_CORK, &state, sizeof(state));
+#elif defined (TCP_NOPUSH)
+    return setsockopt(fd, SOL_SOCKET, TCP_NOPUSH, &state, sizeof(state));
+#endif
+
+    return 0;
+}
+
+int mk_socket_set_nonblocking(int sockfd)
+{
+
+    MK_TRACE("Socket, set FD %i to non-blocking", sockfd);
+
+#ifdef _WIN32
+    u_long flags;
+
+    flags = 0;
+    if (SOCKET_ERROR == ioctlsocket(sockfd, FIONBIO, &flags)) {
+        mk_err("Can't set to non-blocking mode socket %i", sockfd);
+        return -1;
+    }
+#else
+    if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFL, 0) | O_NONBLOCK) == -1) {
+        mk_err("Can't set to non-blocking mode socket %i", sockfd);
+        return -1;
+    }
+    fcntl(sockfd, F_SETFD, FD_CLOEXEC);
+#endif
+
+    return 0;
+}
+
+/*
+ * Enable the TCP_FASTOPEN feature for server side implemented in
+ * Linux Kernel >= 3.7, for more details read here:
+ *
+ *  TCP Fast Open: expediting web services: http://lwn.net/Articles/508865/
+ */
+int mk_socket_set_tcp_fastopen(int sockfd)
+{
+#if defined (__linux__)
+    int qlen = 5;
+    return setsockopt(sockfd, SOL_TCP, TCP_FASTOPEN, &qlen, sizeof(qlen));
+#endif
+
+    (void) sockfd;
+    return -1;
+}
+
+int mk_socket_set_tcp_nodelay(int sockfd)
+{
+    int on = 1;
+
+    return setsockopt(sockfd, SOL_TCP, TCP_NODELAY, &on, sizeof(on));
+}
+
+int mk_socket_set_tcp_defer_accept(int sockfd)
+{
+#if defined (__linux__)
+    int timeout = 0;
+
+    return setsockopt(sockfd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &timeout, sizeof(int));
+#else
+    (void) sockfd;
+    return -1;
+#endif
+}
+
+int mk_socket_set_tcp_reuseport(int sockfd)
+{
+    int on = 1;
+    return setsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));
+}
+
+int mk_socket_create(int domain, int type, int protocol)
+{
+    int fd;
+
+#ifdef SOCK_CLOEXEC
+    fd = socket(domain, type | SOCK_CLOEXEC, protocol);
+#else
+    fd = socket(domain, type, protocol);
+
+#ifndef _WIN32
+    fcntl(fd, F_SETFD, FD_CLOEXEC);
+#endif
+#endif
+
+    if (fd == -1) {
+        mk_libc_error("socket");
+        return -1;
+    }
+
+    return fd;
+}
+
+int mk_socket_open(char *path, int async)
+{
+    int ret;
+    int socket_fd;
+    struct sockaddr_un address;
+
+    socket_fd = mk_socket_create(PF_UNIX, SOCK_STREAM, 0);
+    if (socket_fd == -1) {
+        return -1;
+    }
+
+    memset(&address, '\0', sizeof(struct sockaddr_un));
+    address.sun_family = AF_UNIX;
+    snprintf(address.sun_path, sizeof(address.sun_path), "%s", path);
+
+    if (async == MK_TRUE) {
+        mk_socket_set_nonblocking(socket_fd);
+    }
+
+    ret = connect(socket_fd, (struct sockaddr *) &address,
+                  sizeof(struct sockaddr_un));
+    if (ret == -1) {
+        if (errno == EINPROGRESS) {
+            return socket_fd;
+        }
+        else {
+#ifdef MK_HAVE_TRACE
+            mk_libc_error("connect");
+#endif
+            close(socket_fd);
+            return -1;
+        }
+    }
+
+    return socket_fd;
+}
+
+
+int mk_socket_connect(char *host, int port, int async)
+{
+    int ret;
+    int socket_fd = -1;
+    char *port_str = 0;
+    unsigned long len;
+    struct addrinfo hints;
+    struct addrinfo *res, *rp;
+
+    memset(&hints, 0, sizeof hints);
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+
+    mk_string_build(&port_str, &len, "%d", port);
+
+    ret = getaddrinfo(host, port_str, &hints, &res);
+    mk_mem_free(port_str);
+    if(ret != 0) {
+        mk_err("Can't get addr info: %s", gai_strerror(ret));
+        return -1;
+    }
+    for (rp = res; rp != NULL; rp = rp->ai_next) {
+        socket_fd = mk_socket_create(rp->ai_family,
+                                     rp->ai_socktype, rp->ai_protocol);
+
+        if (socket_fd == -1) {
+            mk_warn("Error creating client socket, retrying");
+            continue;
+        }
+
+        if (async == MK_TRUE) {
+            mk_socket_set_nonblocking(socket_fd);
+        }
+
+        ret = connect(socket_fd,
+                      (struct sockaddr *) rp->ai_addr, rp->ai_addrlen);
+        if (ret == -1) {
+            if (errno == EINPROGRESS) {
+                break;
+            }
+            else {
+                printf("%s", strerror(errno));
+                perror("connect");
+                exit(1);
+                close(socket_fd);
+                continue;
+            }
+        }
+        break;
+    }
+    freeaddrinfo(res);
+
+    if (rp == NULL)
+        return -1;
+
+    return socket_fd;
+}
+
+int mk_socket_reset(int socket)
+{
+    int status = 1;
+
+    if (setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, &status, sizeof(int)) == -1) {
+        mk_libc_error("socket");
+        exit(EXIT_FAILURE);
+    }
+
+    return 0;
+}
+
+int mk_socket_bind(int socket_fd, const struct sockaddr *addr,
+                   socklen_t addrlen, int backlog, struct mk_server *server)
+{
+    int ret;
+
+    ret = bind(socket_fd, addr, addrlen);
+    if( ret == -1 ) {
+        mk_warn("Error binding socket");
+        return ret;
+    }
+
+    /*
+     * Enable TCP_FASTOPEN by default: if for some reason this call fail,
+     * it will not affect the behavior of the server, in order to succeed,
+     * Monkey must be running in a Linux system with Kernel >= 3.7 and the
+     * tcp_fastopen flag enabled here:
+     *
+     *     # cat /proc/sys/net/ipv4/tcp_fastopen
+     *
+     * To enable this feature just do:
+     *
+     *     # echo 1 > /proc/sys/net/ipv4/tcp_fastopen
+     */
+    if (server->kernel_features & MK_KERNEL_TCP_FASTOPEN) {
+        ret = mk_socket_set_tcp_fastopen(socket_fd);
+        if (ret == -1) {
+            mk_warn("Could not set TCP_FASTOPEN");
+        }
+    }
+
+    ret = listen(socket_fd, backlog);
+    if(ret == -1 ) {
+        return -1;
+    }
+
+    return ret;
+}
+
+/* Just IPv4 for now... */
+int mk_socket_server(char *port, char *listen_addr,
+                     int reuse_port, struct mk_server *server)
+{
+    int ret;
+    int socket_fd = -1;
+    struct addrinfo hints;
+    struct addrinfo *res, *rp;
+
+    memset(&hints, 0, sizeof hints);
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_flags = AI_PASSIVE;
+
+    mk_net_init();
+
+    ret = getaddrinfo(listen_addr, port, &hints, &res);
+    if(ret != 0) {
+        mk_err("Can't get addr info: %s", gai_strerror(ret));
+        return -1;
+    }
+
+    for (rp = res; rp != NULL; rp = rp->ai_next) {
+        socket_fd = mk_socket_create(rp->ai_family,
+                                     rp->ai_socktype, rp->ai_protocol);
+        if (socket_fd == -1) {
+            mk_warn("Error creating server socket, retrying");
+            continue;
+        }
+
+        ret = mk_socket_set_tcp_nodelay(socket_fd);
+        if (ret == -1) {
+            mk_warn("Could not set TCP_NODELAY");
+        }
+
+        mk_socket_reset(socket_fd);
+
+        /* Check if reuse port can be enabled on this socket */
+        if (reuse_port == MK_TRUE &&
+            (server->kernel_features & MK_KERNEL_SO_REUSEPORT)) {
+            ret = mk_socket_set_tcp_reuseport(socket_fd);
+            if (ret == -1) {
+                mk_warn("Could not use SO_REUSEPORT, using fair balancing mode");
+                server->scheduler_mode = MK_SCHEDULER_FAIR_BALANCING;
+            }
+        }
+
+        ret = mk_socket_bind(socket_fd, rp->ai_addr, rp->ai_addrlen,
+                             MK_SOMAXCONN, server);
+        if(ret == -1) {
+            mk_err("Cannot listen on %s:%s", listen_addr, port);
+            freeaddrinfo(res);
+            return -1;
+        }
+        break;
+    }
+    freeaddrinfo(res);
+
+    if (rp == NULL)
+        return -1;
+
+    return socket_fd;
+}
+
+int mk_socket_ip_str(int socket_fd, char **buf, int size, unsigned long *len)
+{
+    int ret;
+    struct sockaddr_storage addr;
+    socklen_t s_len = sizeof(addr);
+
+    ret = getpeername(socket_fd, (struct sockaddr *) &addr, &s_len);
+
+    if (mk_unlikely(ret == -1)) {
+        MK_TRACE("[FD %i] Can't get addr for this socket", socket_fd);
+        return -1;
+    }
+
+    errno = 0;
+
+    if(addr.ss_family == AF_INET) {
+        if((inet_ntop(AF_INET, &((struct sockaddr_in *)&addr)->sin_addr,
+                      *buf, size)) == NULL) {
+            mk_warn("mk_socket_ip_str: Can't get the IP text form (%i)", errno);
+            return -1;
+        }
+    }
+    else if(addr.ss_family == AF_INET6) {
+        if((inet_ntop(AF_INET6, &((struct sockaddr_in6 *)&addr)->sin6_addr,
+                      *buf, size)) == NULL) {
+            mk_warn("mk_socket_ip_str: Can't get the IP text form (%i)", errno);
+            return -1;
+        }
+    }
+
+    *len = strlen(*buf);
+    return 0;
+}
+
+int mk_socket_accept(int server_fd)
+{
+    int remote_fd;
+
+    struct sockaddr sock_addr;
+    socklen_t socket_size = sizeof(struct sockaddr);
+
+#ifdef MK_HAVE_ACCEPT4
+    remote_fd = accept4(server_fd, &sock_addr, &socket_size,
+                        SOCK_NONBLOCK | SOCK_CLOEXEC);
+#else
+    remote_fd = accept(server_fd, &sock_addr, &socket_size);
+    mk_socket_set_nonblocking(remote_fd);
+#endif
+
+    return remote_fd;
+}
diff --git a/fluent-bit/lib/monkey/mk_server/mk_stream.c b/fluent-bit/lib/monkey/mk_server/mk_stream.c
new file mode 100644
index 00000000..df0f1b0b
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_stream.c
@@ -0,0 +1,338 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <monkey/monkey.h>
+#include <monkey/mk_stream.h>
+#include <assert.h>
+
+/* Create a new channel */
+struct mk_channel *mk_channel_new(int type, int fd)
+{
+    struct mk_channel *channel;
+
+    channel = mk_mem_alloc(sizeof(struct mk_channel));
+    if (!channel) {
+        return NULL;
+    }
+    channel->type   = type;
+    channel->fd     = fd;
+    channel->status = MK_CHANNEL_OK;
+    mk_list_init(&channel->streams);
+
+    return channel;
+}
+
+int mk_channel_release(struct mk_channel *channel)
+{
+    mk_mem_free(channel);
+    return 0;
+}
+
+static inline size_t channel_write_in_file(struct mk_channel *channel,
+                                           struct mk_stream_input *in)
+{
+    ssize_t bytes = 0;
+
+    MK_TRACE("[CH %i] STREAM_FILE [fd=%i], bytes=%lu",
+             channel->fd, in->fd, in->bytes_total);
+
+    /* Direct write */
+    bytes = mk_sched_conn_sendfile(channel,
+                                   in->fd,
+                                   &in->bytes_offset,
+                                   in->bytes_total
+                                   );
+    MK_TRACE("[CH=%d] [FD=%i] WRITE STREAM FILE: %lu bytes",
+             channel->fd, in->fd, bytes);
+
+    return bytes;
+}
+
+size_t mk_stream_size(struct mk_stream *stream)
+{
+    return (stream->bytes_total - stream->bytes_offset);
+}
+
+/*
+ * It 'intent' to write a few streams over the channel and alter the
+ * channel notification side if required: READ -> WRITE.
+ */
+int mk_channel_flush(struct mk_channel *channel)
+{
+    int ret = 0;
+    size_t count = 0;
+    size_t total = 0;
+    uint32_t stop = (MK_CHANNEL_DONE | MK_CHANNEL_ERROR | MK_CHANNEL_EMPTY);
+
+    do {
+        ret = mk_channel_write(channel, &count);
+        total += count;
+
+#ifdef MK_HAVE_TRACE
+        MK_TRACE("Channel flush: %d bytes", count);
+        if (ret & MK_CHANNEL_DONE) {
+            MK_TRACE("Channel was empty");
+        }
+        if (ret & MK_CHANNEL_ERROR) {
+            MK_TRACE("Channel error");
+        }
+        if (ret & MK_CHANNEL_EMPTY) {
+            MK_TRACE("Channel empty");
+        }
+#endif
+    } while (total <= 4096 && ((ret & stop) == 0));
+
+    if (ret == MK_CHANNEL_DONE) {
+        MK_TRACE("Channel done");
+        return ret;
+    }
+    else if (ret & (MK_CHANNEL_FLUSH | MK_CHANNEL_BUSY)) {
+        MK_TRACE("Channel FLUSH | BUSY");
+        if ((channel->event->mask & MK_EVENT_WRITE) == 0) {
+            mk_event_add(mk_sched_loop(),
+                         channel->fd,
+                         MK_EVENT_CONNECTION,
+                         MK_EVENT_WRITE,
+                         channel->event);
+        }
+    }
+
+    return ret;
+}
+
+int mk_stream_in_release(struct mk_stream_input *in)
+{
+    if (in->cb_finished) {
+        in->cb_finished(in);
+    }
+
+    mk_stream_input_unlink(in);
+    if (in->dynamic == MK_TRUE) {
+        mk_mem_free(in);
+    }
+
+    return 0;
+}
+
+int mk_channel_stream_write(struct mk_stream *stream, size_t *count)
+{
+    ssize_t bytes = 0;
+    struct mk_iov *iov;
+    struct mk_list *tmp;
+    struct mk_list *head;
+    struct mk_channel *channel;
+    struct mk_stream_input *input;
+
+    channel = stream->channel;
+
+    /* Validate channel status */
+    if (channel->status != MK_CHANNEL_OK) {
+        return -MK_CHANNEL_ERROR;
+    }
+
+    /* Iterate inputs and process stream */
+    mk_list_foreach_safe(head, tmp, &stream->inputs) {
+        input = mk_list_entry(head, struct mk_stream_input, _head);
+        if (input->type == MK_STREAM_FILE) {
+            bytes = channel_write_in_file(channel, input);
+        }
+        else if (input->type == MK_STREAM_IOV) {
+            iov = input->buffer;
+            if (!iov) {
+                return MK_CHANNEL_EMPTY;
+            }
+
+            bytes = mk_sched_conn_writev(channel, iov);
+
+            MK_TRACE("[CH %i] STREAM_IOV, wrote %d bytes",
+                     channel->fd, bytes);
+            if (bytes > 0) {
+                /* Perform the adjustment on mk_iov */
+                mk_iov_consume(iov, bytes);
+            }
+        }
+        else if (input->type == MK_STREAM_RAW) {
+            bytes = mk_sched_conn_write(channel,
+                                        input->buffer, input->bytes_total);
+            MK_TRACE("[CH %i] STREAM_RAW, bytes=%lu/%lu\n",
+                     channel->fd, bytes, input->bytes_total);
+        }
+
+        if (bytes > 0) {
+            *count = bytes;
+            mk_stream_input_consume(input, bytes);
+
+            /* notification callback, optional */
+            if (stream->cb_bytes_consumed) {
+                stream->cb_bytes_consumed(stream, bytes);
+            }
+
+            if (input->cb_consumed) {
+                input->cb_consumed(input, bytes);
+            }
+
+            if (input->bytes_total == 0) {
+                MK_TRACE("Input done, unlinking (channel=%p)", channel);
+                mk_stream_in_release(input);
+            }
+            MK_TRACE("[CH %i] CHANNEL_FLUSH", channel->fd);
+        }
+        else if (bytes < 0) {
+            mk_stream_in_release(input);
+            return -MK_CHANNEL_ERROR;
+        }
+        else if (bytes == 0) {
+            mk_stream_in_release(input);
+            return -MK_CHANNEL_ERROR;
+        }
+    }
+
+    return bytes;
+}
+
+/* It perform a direct stream I/O write through the network layer */
+int mk_channel_write(struct mk_channel *channel, size_t *count)
+{
+    ssize_t bytes = -1;
+    struct mk_iov *iov;
+    struct mk_stream *stream = NULL;
+    struct mk_stream_input *input;
+
+    errno = 0;
+
+    if (mk_list_is_empty(&channel->streams) == 0) {
+        MK_TRACE("[CH %i] CHANNEL_EMPTY", channel->fd);
+        return MK_CHANNEL_EMPTY;
+    }
+
+    /* Get the input source */
+    stream = mk_list_entry_first(&channel->streams, struct mk_stream, _head);
+    if (mk_list_is_empty(&stream->inputs) == 0) {
+        return MK_CHANNEL_EMPTY;
+    }
+    input = mk_list_entry_first(&stream->inputs, struct mk_stream_input, _head);
+
+    /*
+     * Based on the Stream Input type we consume on that way, not all inputs
+     * requires to read from buffer, e.g: Static File, Pipes.
+     */
+    if (channel->type == MK_CHANNEL_SOCKET) {
+        if (input->type == MK_STREAM_FILE) {
+            bytes = channel_write_in_file(channel, input);
+        }
+        else if (input->type == MK_STREAM_IOV) {
+            iov   = input->buffer;
+            if (!iov) {
+                return MK_CHANNEL_EMPTY;
+            }
+
+            bytes = mk_sched_conn_writev(channel, iov);
+
+            MK_TRACE("[CH %i] STREAM_IOV, wrote %d bytes",
+                     channel->fd, bytes);
+            if (bytes > 0) {
+                /* Perform the adjustment on mk_iov */
+                mk_iov_consume(iov, bytes);
+            }
+        }
+        else if (input->type == MK_STREAM_RAW) {
+            bytes = mk_sched_conn_write(channel,
+                                        input->buffer, input->bytes_total);
+            MK_TRACE("[CH %i] STREAM_RAW, bytes=%lu/%lu",
+                     channel->fd, bytes, input->bytes_total);
+            if (bytes > 0) {
+                /* DEPRECATED: consume_raw(input, bytes); */
+            }
+        }
+
+        if (bytes > 0) {
+            *count = bytes;
+            mk_stream_input_consume(input, bytes);
+
+            /* notification callback, optional */
+            if (stream->cb_bytes_consumed) {
+                stream->cb_bytes_consumed(stream, bytes);
+            }
+
+            if (input->cb_consumed) {
+                input->cb_consumed(input, bytes);
+            }
+
+            if (input->bytes_total == 0) {
+                MK_TRACE("Input done, unlinking (channel=%p)", channel);
+                mk_stream_in_release(input);
+            }
+
+            if (mk_list_is_empty(&stream->inputs) == 0) {
+                /* Everytime the stream is empty, we notify the trigger the cb */
+                if (stream->cb_finished) {
+                    stream->cb_finished(stream);
+                }
+
+                if (mk_channel_is_empty(channel) == 0) {
+                    MK_TRACE("[CH %i] CHANNEL_DONE", channel->fd);
+                    return MK_CHANNEL_DONE;
+                }
+                else {
+                    MK_TRACE("[CH %i] CHANNEL_FLUSH", channel->fd);
+                    return MK_CHANNEL_FLUSH;
+                }
+            }
+
+            MK_TRACE("[CH %i] CHANNEL_FLUSH", channel->fd);
+            return MK_CHANNEL_FLUSH;
+        }
+        else if (bytes < 0) {
+            if (errno == EAGAIN) {
+                return MK_CHANNEL_BUSY;
+            }
+
+            mk_stream_in_release(input);
+            return MK_CHANNEL_ERROR;
+        }
+        else if (bytes == 0) {
+            mk_stream_in_release(input);
+            return MK_CHANNEL_ERROR;
+        }
+    }
+
+    return MK_CHANNEL_ERROR;
+}
+
+/* Remove any dynamic memory associated */
+int mk_channel_clean(struct mk_channel *channel)
+{
+    struct mk_list *tmp;
+    struct mk_list *tmp_in;
+    struct mk_list *head;
+    struct mk_list *head_in;
+    struct mk_stream *stream;
+    struct mk_stream_input *in;
+
+    mk_list_foreach_safe(head, tmp, &channel->streams) {
+        stream = mk_list_entry(head, struct mk_stream, _head);
+        mk_list_foreach_safe(head_in, tmp_in, &stream->inputs) {
+            in = mk_list_entry(head_in, struct mk_stream_input, _head);
+            mk_stream_in_release(in);
+        }
+        mk_stream_release(stream);
+    }
+
+    return 0;
+}
diff --git a/fluent-bit/lib/monkey/mk_server/mk_user.c b/fluent-bit/lib/monkey/mk_server/mk_user.c
new file mode 100644
index 00000000..7200ff08
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_user.c
@@ -0,0 +1,175 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <monkey/monkey.h>
+#include <monkey/mk_user.h>
+#include <monkey/mk_http.h>
+#include <monkey/mk_http_status.h>
+#include <monkey/mk_core.h>
+#include <monkey/mk_utils.h>
+#include <monkey/mk_config.h>
+
+#ifndef _WIN32
+#include <pwd.h>
+#include <sys/resource.h>
+#include <sys/types.h>
+#include <grp.h>
+
+int mk_user_init(struct mk_http_session *cs, struct mk_http_request *sr,
+                 struct mk_server *server)
+{
+    int limit;
+    const int offset = 2; /* The user is defined after the '/~' string, so offset = 2 */
+    const int user_len = 255;
+    char user[/*user_len*/ 255]; /* VC++ Doesn't allow for this to be a const int*/
+    char *user_uri;
+    struct passwd *s_user;
+
+    if (sr->uri_processed.len <= 2) {
+        return -1;
+    }
+
+    limit = mk_string_char_search(sr->uri_processed.data + offset, '/',
+                                  sr->uri_processed.len);
+
+    if (limit == -1) {
+        limit = (sr->uri_processed.len) - offset;
+    }
+
+    if (limit + offset >= (user_len)) {
+        return -1;
+    }
+
+    memcpy(user, sr->uri_processed.data + offset, limit);
+    user[limit] = '\0';
+
+    MK_TRACE("user: '%s'", user);
+
+    /* Check system user */
+    if ((s_user = getpwnam(user)) == NULL) {
+        mk_http_error(MK_CLIENT_NOT_FOUND, cs, sr, server);
+        return -1;
+    }
+
+    if (sr->uri_processed.len > (unsigned int) (offset+limit)) {
+        user_uri = mk_mem_alloc(sr->uri_processed.len);
+        if (!user_uri) {
+            return -1;
+        }
+
+        memcpy(user_uri,
+               sr->uri_processed.data + (offset + limit),
+               sr->uri_processed.len - offset - limit);
+        user_uri[sr->uri_processed.len - offset - limit] = '\0';
+
+        mk_string_build(&sr->real_path.data, &sr->real_path.len,
+                        "%s/%s%s",
+                        s_user->pw_dir, server->conf_user_pub, user_uri);
+        mk_mem_free(user_uri);
+    }
+    else {
+        mk_string_build(&sr->real_path.data, &sr->real_path.len,
+                        "%s/%s", s_user->pw_dir, server->conf_user_pub);
+    }
+
+    sr->user_home = MK_TRUE;
+    return 0;
+}
+
+/* Change process user */
+int mk_user_set_uidgid(struct mk_server *server)
+{
+    struct passwd *usr;
+
+    /* Launched by root ? */
+    if (geteuid() == 0 && server->user) {
+        struct rlimit rl;
+
+        if (getrlimit(RLIMIT_NOFILE, &rl)) {
+            mk_warn("cannot get resource limits");
+        }
+
+        /* Check if user exists  */
+        if ((usr = getpwnam(server->user)) == NULL) {
+            mk_err("Invalid user '%s'", server->user);
+            goto out;
+        }
+
+        if (initgroups(server->user, usr->pw_gid) != 0) {
+            mk_err("Initgroups() failed");
+        }
+
+        /* Change process UID and GID */
+        if (setegid(usr->pw_gid) == -1) {
+            mk_err("I cannot change the GID to %u", usr->pw_gid);
+        }
+
+        if (seteuid(usr->pw_uid) == -1) {
+            mk_err("I cannot change the UID to %u", usr->pw_uid);
+        }
+
+        server->is_seteuid = MK_TRUE;
+    }
+
+ out:
+    /* Variables set for run checks on file permission */
+    //FIXME
+    //EUID = geteuid();
+    //EGID = getegid();
+
+    return 0;
+}
+
+/* Return process to the original user */
+int mk_user_undo_uidgid(struct mk_server *server)
+{
+    if (server->is_seteuid == MK_TRUE) {
+        if (setegid(0) < 0) {
+            mk_err("Can't restore effective GID");
+        }
+        if (seteuid(0) < 0) {
+            mk_err("Can't restore effective UID");
+        }
+    }
+    return 0;
+}
+
+#else
+/*
+    None of these functionalities are going to be available in windows at the moment
+*/
+
+int mk_user_init(struct mk_http_session* cs, struct mk_http_request* sr,
+    struct mk_server* server)
+{
+    return -1;
+}
+
+int mk_user_set_uidgid(struct mk_server* server)
+{
+    mk_err("Cannot impersonate users in windows");
+
+    return 0;
+}
+
+int mk_user_undo_uidgid(struct mk_server* server)
+{
+    return 0;
+}
+#endif
diff --git a/fluent-bit/lib/monkey/mk_server/mk_utils.c b/fluent-bit/lib/monkey/mk_server/mk_utils.c
new file mode 100644
index 00000000..443c0ec3
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_utils.c
@@ -0,0 +1,589 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/* local headers */
+#include <monkey/monkey.h>
+#include <monkey/mk_core.h>
+#include <monkey/mk_utils.h>
+#include <monkey/mk_config.h>
+#include <monkey/mk_socket.h>
+#include <monkey/mk_clock.h>
+#include <monkey/mk_user.h>
+#include <monkey/mk_cache.h>
+#include <monkey/mk_tls.h>
+
+#include <assert.h>
+#include <ctype.h>
+#include <stdarg.h>
+#include <time.h>
+#include <inttypes.h>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#else
+#include <sys/socket.h>
+#endif
+
+/* stacktrace */
+#ifndef _WIN32
+#include <dlfcn.h>
+#endif
+
+#ifdef MK_HAVE_BACKTRACE
+#include <execinfo.h>
+#endif
+
+#define MK_UTILS_GMT_DATEFORMAT "%a, %d %b %Y %H:%M:%S GMT"
+
+#ifdef _WIN32
+static struct tm* localtime_r(const time_t* timep, struct tm* result)
+{
+    localtime_s(result, timep);
+
+    return result;
+}
+
+static struct tm* gmtime_r(const time_t* timep, struct tm* result)
+{
+    gmtime_s(result, timep);
+
+    return result;
+}
+
+static time_t timegm(struct tm* timeptr)
+{
+    return _mkgmtime(timeptr);
+}
+#endif
+
+#ifdef _WIN32
+int mk_utils_get_system_core_count()
+{
+    SYSTEM_LOGICAL_PROCESSOR_INFORMATION *proc_info_buffer;
+    unsigned int result_entry_count;
+    unsigned int entry_index;
+    DWORD result_length;
+    int result_code;
+    int core_count;
+
+    core_count = 1;
+    result_length = 0;
+    proc_info_buffer = NULL;
+
+    result_code = GetLogicalProcessorInformation(proc_info_buffer, &result_length);
+    /* We're passing a null buffer, result_code has to be false */
+
+    if (ERROR_INSUFFICIENT_BUFFER == GetLastError()) {
+        result_entry_count = result_length / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
+        proc_info_buffer = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION *) _alloca(result_length);
+
+        if(NULL != proc_info_buffer) {
+            result_code = GetLogicalProcessorInformation(proc_info_buffer, &result_length);
+
+            if (0 != result_code) {
+                core_count = 0;
+
+                for(entry_index = 0 ; entry_index < result_entry_count ; entry_index++) {
+                    if(RelationProcessorCore == proc_info_buffer[entry_index].Relationship) {
+                        core_count++;
+                    }
+                }
+            }
+        }
+
+        /* Athread stack allocation error is a pretty serious 
+         * error so in that case we let someone else handle it by returning a 
+         * sane default (1 core)
+         */
+    }
+
+    return core_count;
+}
+
+int mk_utils_get_system_page_size()
+{
+    SYSTEM_INFO si;
+
+    GetSystemInfo(&si);
+
+    return si.dwPageSize;
+}
+
+#else
+int mk_utils_get_system_core_count()
+{
+    return sysconf(_SC_NPROCESSORS_ONLN);
+}
+
+int mk_utils_get_system_page_size()
+{
+    return sysconf(_SC_PAGESIZE);
+}
+
+#endif
+
+
+/* Date helpers */
+static const char mk_date_wd[][6]  = {"Sun, ", "Mon, ", "Tue, ", "Wed, ", "Thu, ", "Fri, ", "Sat, "};
+static const char mk_date_ym[][5] = {"Jan ", "Feb ", "Mar ", "Apr ", "May ", "Jun ", "Jul ",
+                                     "Aug ", "Sep ", "Oct ", "Nov ", "Dec "};
+
+static int mk_utils_gmt_cache_get(char **data, time_t date)
+{
+    unsigned int i;
+    struct mk_gmt_cache *gcache = MK_TLS_GET(mk_tls_cache_gmtext);
+
+    if (mk_unlikely(!gcache)) {
+        return MK_FALSE;
+    }
+
+    for (i = 0; i < MK_GMT_CACHES; i++) {
+        if (date == gcache[i].time) {
+            memcpy(*data, gcache[i].text, 32);
+            gcache[i].hits++;
+            return MK_TRUE;
+        }
+    }
+
+    return MK_FALSE;
+}
+
+static void mk_utils_gmt_cache_add(char *data, time_t time)
+{
+    unsigned int i, min = 0;
+    struct mk_gmt_cache *gcache = MK_TLS_GET(mk_tls_cache_gmtext);
+
+    for (i = 1; i < MK_GMT_CACHES; i++) {
+        if (gcache[i].hits < gcache[min].hits)
+            min = i;
+    }
+
+    gcache[min].hits = 1;
+    gcache[min].time = time;
+    memcpy(gcache[min].text, data, 32);
+}
+
+/*
+ *This function given a unix time, set in a mk_ptr_t
+ * the date in the RFC1123 format like:
+ *
+ *    Wed, 23 Jun 2010 22:32:01 GMT
+ *
+ * it also adds a 'CRLF' at the end
+ */
+int mk_utils_utime2gmt(char **data, time_t date)
+{
+    const int size = 31;
+    unsigned short year, mday, hour, min, sec;
+    char *buf=0;
+    struct tm *gtm;
+
+    if (date == 0) {
+        if ((date = time(NULL)) == -1) {
+            return -1;
+        }
+    }
+    else {
+        /* Maybe it's converted already? */
+        if (mk_utils_gmt_cache_get(data, date) == MK_TRUE) {
+            return size;
+        }
+    }
+
+    /* Convert unix time to struct tm */
+    gtm = MK_TLS_GET(mk_tls_cache_gmtime);
+
+    /* If this function was invoked from a non-thread context it should exit */
+    mk_bug(!gtm);
+    gtm = gmtime_r(&date, gtm);
+    if (!gtm) {
+        return -1;
+    }
+
+    /* struct tm -> tm_year counts number of years after 1900 */
+    year = gtm->tm_year + 1900;
+
+    /* Signed division is slow, by using unsigned we gain 25% speed */
+    mday = gtm->tm_mday;
+    hour = gtm->tm_hour;
+    min = gtm->tm_min;
+    sec = gtm->tm_sec;
+
+    /* Compose template */
+    buf = *data;
+
+    /* Week day */
+    memcpy(buf, mk_date_wd[gtm->tm_wday], 5);
+    buf += 5;
+
+    /* Day of the month */
+    *buf++ = ('0' + (mday / 10));
+    *buf++ = ('0' + (mday % 10));
+    *buf++ = ' ';
+
+    /* Month */
+    memcpy(buf, mk_date_ym[gtm->tm_mon], 4);
+    buf += 4;
+
+    /* Year */
+    *buf++ = ('0' + (year / 1000) % 10);
+    *buf++ = ('0' + (year / 100) % 10);
+    *buf++ = ('0' + (year / 10) % 10);
+    *buf++ = ('0' + (year % 10));
+    *buf++ = ' ';
+
+    /* Hour */
+    *buf++ = ('0' + (hour / 10));
+    *buf++ = ('0' + (hour % 10));
+    *buf++ = ':';
+
+    /* Minutes */
+    *buf++ = ('0' + (min / 10));
+    *buf++ = ('0' + (min % 10));
+    *buf++ = ':';
+
+    /* Seconds */
+    *buf++ = ('0' + (sec / 10));
+    *buf++ = ('0' + (sec % 10));
+
+    /* GMT Time zone + CRLF */
+    memcpy(buf, " GMT\r\n\0", 7);
+
+    /* Add new entry to the cache */
+    mk_utils_gmt_cache_add(*data, date);
+
+    /* Set mk_ptr_t data len */
+    return size;
+}
+
+time_t mk_utils_gmt2utime(char *date)
+{
+    time_t new_unix_time;
+    struct tm t_data;
+    memset(&t_data, 0, sizeof(struct tm));
+
+
+#ifdef _WIN32
+#pragma message("Since there is no strptime in windows we'll parse the date in a really crude way just to get it out of the way")
+
+    if (0 != strcmp(MK_UTILS_GMT_DATEFORMAT, "%a, %d %b %Y %H:%M:%S GMT")) {
+        return -1;
+    }
+    
+    {
+        char *token;
+
+        token = strtok(date, " "); /* "%a, " */
+
+        if (NULL == token) {
+            return -1;
+        }
+
+        token = strtok(NULL, " "); /* "%d " */
+
+        if (NULL == token) {
+            return -1;
+        }
+
+        t_data.tm_mday = strtol(token, NULL, 10);
+
+        token = strtok(NULL, " "); /* "%b " */
+
+        if (NULL == token) {
+            return -1;
+        }
+
+        if(0 == _strnicmp(token, "jan", 3)){
+            t_data.tm_mon = 0;
+        }
+        else if(0 == _strnicmp(token, "feb", 3)){
+            t_data.tm_mon = 1;
+        }
+        else if(0 == _strnicmp(token, "mar", 3)){
+            t_data.tm_mon = 2;
+        }
+        else if(0 == _strnicmp(token, "apr", 3)){
+            t_data.tm_mon = 3;
+        }
+        else if(0 == _strnicmp(token, "may", 3)){
+            t_data.tm_mon = 4;
+        }
+        else if(0 == _strnicmp(token, "jun", 3)){
+            t_data.tm_mon = 5;
+        }
+        else if(0 == _strnicmp(token, "jul", 3)){
+            t_data.tm_mon = 6;
+        }
+        else if(0 == _strnicmp(token, "aug", 3)){
+            t_data.tm_mon = 7;
+        }
+        else if(0 == _strnicmp(token, "sep", 3)){
+            t_data.tm_mon = 8;
+        }
+        else if(0 == _strnicmp(token, "oct", 3)){
+            t_data.tm_mon = 9;
+        }
+        else if(0 == _strnicmp(token, "nov", 3)){
+            t_data.tm_mon = 10;
+        }
+        else if(0 == _strnicmp(token, "dec", 3)){
+            t_data.tm_mon = 11;
+        }
+        else {
+            return -1;
+        }
+
+        token = strtok(NULL, " "); /* "%Y " */
+
+        if (NULL == token) {
+            return -1;
+        }
+
+        t_data.tm_year = strtol(token, NULL, 10);
+
+        token = strtok(NULL, ":"); /* "%H:" */
+
+        if (NULL == token) {
+            return -1;
+        }
+
+        t_data.tm_hour = strtol(token, NULL, 10);
+
+        token = strtok(NULL, ":"); /* "%M:" */
+
+        if (NULL == token) {
+            return -1;
+        }
+
+        t_data.tm_min = strtol(token, NULL, 10);
+
+        token = strtok(NULL, " "); /* "%S " */
+
+        if (NULL == token) {
+            return -1;
+        }
+
+        t_data.tm_sec = strtol(token, NULL, 10);
+    }
+
+#else
+    if (!strptime(date, MK_UTILS_GMT_DATEFORMAT, (struct tm*)&t_data)) {
+        return -1;
+    }
+#endif
+
+    new_unix_time = timegm((struct tm *) &t_data);
+
+    return (new_unix_time);
+}
+
+int mk_buffer_cat(mk_ptr_t *p, char *buf1, int len1, char *buf2, int len2)
+{
+    /* Validate lengths */
+    if (mk_unlikely(len1 < 0 || len2 < 0)) {
+         return -1;
+    }
+
+    /* alloc space */
+    p->data = (char *) mk_mem_alloc(len1 + len2 + 1);
+
+    /* copy data */
+    memcpy(p->data, buf1, len1);
+    memcpy(p->data + len1, buf2, len2);
+    p->data[len1 + len2] = '\0';
+
+    /* assign len */
+    p->len = len1 + len2;
+
+    return 0;
+}
+
+/* Convert hexadecimal to int */
+int mk_utils_hex2int(char *hex, int len)
+{
+    int i = 0;
+    int res = 0;
+    char c;
+
+    while ((c = *hex++) && i < len) {
+        res *= 0x10;
+
+        if (c >= 'a' && c <= 'f') {
+            res += (c - 0x57);
+        }
+        else if (c >= 'A' && c <= 'F') {
+            res += (c - 0x37);
+        }
+        else if (c >= '0' && c <= '9') {
+            res += (c - 0x30);
+        }
+        else {
+            return -1;
+        }
+        i++;
+    }
+
+    if (res < 0) {
+        return -1;
+    }
+
+    return res;
+}
+
+/* If the URI contains hexa format characters it will return
+ * convert the Hexa values to ASCII character
+ */
+char *mk_utils_url_decode(mk_ptr_t uri)
+{
+    int tmp, hex_result;
+    unsigned int i;
+    int buf_idx = 0;
+    char *buf;
+    char hex[3];
+
+    if ((tmp = mk_string_char_search(uri.data, '%', uri.len)) < 0) {
+        return NULL;
+    }
+
+    i = tmp;
+
+    buf = mk_mem_alloc_z(uri.len + 1);
+    if (i > 0) {
+        memcpy(buf, uri.data, i);
+        buf_idx = i;
+    }
+
+    while (i < uri.len) {
+        if (uri.data[i] == '%' && i + 2 < uri.len) {
+            memcpy(hex, uri.data + i + 1, 2);
+            hex[2] = '\0';
+
+            hex_result = mk_utils_hex2int(hex, 2);
+
+            if (hex_result != -1) {
+                buf[buf_idx] = hex_result;
+            }
+            else {
+                mk_mem_free(buf);
+                return NULL;
+            }
+            i += 2;
+        }
+        else {
+            buf[buf_idx] = uri.data[i];
+        }
+        i++;
+        buf_idx++;
+    }
+    buf[buf_idx] = '\0';
+
+    return buf;
+}
+
+#ifndef MK_HAVE_BACKTRACE
+void mk_utils_stacktrace(void) {}
+#else
+void mk_utils_stacktrace(void)
+{
+    unsigned int i;
+    int ret;
+    size_t size;
+    void *arr[10];
+    Dl_info d;
+
+    printf("[stack trace]\n");
+    size = backtrace(arr, 10);
+
+    for (i = 1; i < size && i < 10; i++) {
+      ret = dladdr(arr[i], &d);
+      if (ret == 0 || !d.dli_sname) {
+          printf(" #%i  0x%016" PRIxPTR " in \?\?\?\?\?\?\?()\n",
+                 (i - 1), (uintptr_t) arr[i]);
+          continue;
+      }
+
+      printf(" #%i  0x%016" PRIxPTR " in %s() from %s\n",
+             (i - 1), (uintptr_t) arr[i], d.dli_sname, d.dli_fname);
+    }
+}
+#endif
+
+
+
+/*
+ * This hash generation function is taken originally from Redis source code:
+ *
+ *  https://github.com/antirez/redis/blob/unstable/src/dict.c#L109
+ *
+ * ----
+ * MurmurHash2, by Austin Appleby
+ * Note - This code makes a few assumptions about how your machine behaves -
+ * 1. We can read a 4-byte value from any address without crashing
+ * 2. sizeof(int) == 4
+ *
+ * And it has a few limitations -
+ *
+ * 1. It will not work incrementally.
+ * 2. It will not produce the same results on little-endian and big-endian
+ *    machines.
+ */
+unsigned int mk_utils_gen_hash(const void *key, int len)
+{
+    /* 'm' and 'r' are mixing constants generated offline.
+       They're not really 'magic', they just happen to work well.  */
+    uint32_t seed = 5381;
+    const uint32_t m = 0x5bd1e995;
+    const int r = 24;
+
+    /* Initialize the hash to a 'random' value */
+    uint32_t h = seed ^ len;
+
+    /* Mix 4 bytes at a time into the hash */
+    const unsigned char *data = (const unsigned char *)key;
+
+    while(len >= 4) {
+        uint32_t k = *(uint32_t*) data;
+
+        k *= m;
+        k ^= k >> r;
+        k *= m;
+
+        h *= m;
+        h ^= k;
+
+        data += 4;
+        len -= 4;
+    }
+
+    /* Handle the last few bytes of the input array  */
+    switch(len) {
+    case 3: h ^= data[2] << 16;   // fallthrough
+    case 2: h ^= data[1] << 8;    // fallthrough
+    case 1: h ^= data[0]; h *= m;
+    };
+
+    /* Do a few final mixes of the hash to ensure the last few
+     * bytes are well-incorporated. */
+    h ^= h >> 13;
+    h *= m;
+    h ^= h >> 15;
+
+    return (unsigned int) h;
+}
diff --git a/fluent-bit/lib/monkey/mk_server/mk_vhost.c b/fluent-bit/lib/monkey/mk_server/mk_vhost.c
new file mode 100644
index 00000000..2dc35fb1
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/mk_vhost.c
@@ -0,0 +1,821 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <monkey/mk_info.h>
+#include <monkey/monkey.h>
+#include <monkey/mk_core.h>
+#include <monkey/mk_vhost.h>
+#include <monkey/mk_vhost_tls.h>
+#include <monkey/mk_utils.h>
+#include <monkey/mk_http_status.h>
+#include <monkey/mk_info.h>
+
+#include <mk_core/mk_dirent.h>
+
+#include <re.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+static int str_to_regex(char *str, regex_t *reg)
+{
+    char *p = str;
+    regex_t *result;
+
+    while (*p) {
+        if (*p == ' ') *p = '|';
+        p++;
+    }
+
+    result = re_compile(str);
+
+    memcpy(reg, result, REGEXP_SIZE);
+
+    return 0;
+}
+
+/*
+ * This function is triggered upon thread creation (inside the thread
+ * context), here we configure per-thread data.
+ */
+int mk_vhost_fdt_worker_init(struct mk_server *server)
+{
+    int i;
+    int j;
+    struct mk_vhost *h;
+    struct mk_list *list;
+    struct mk_list *head;
+    struct vhost_fdt_host *fdt;
+    struct vhost_fdt_hash_table *ht;
+    struct vhost_fdt_hash_chain *hc;
+
+    if (server->fdt == MK_FALSE) {
+        return -1;
+    }
+
+    /*
+     * We are under a thread context and the main configuration is
+     * already in place. Now for every existent virtual host we are
+     * going to create the File Descriptor Table (FDT) which aims to
+     * hold references of 'open and shared' file descriptors under
+     * the Virtual Host context.
+     */
+
+    /*
+     * Under an initialization context we need to protect this critical
+     * section
+     */
+    pthread_mutex_lock(&server->vhost_fdt_mutex);
+
+    /*
+     * Initialize the thread FDT/Hosts list and create an entry per
+     * existent virtual host
+     */
+    list = mk_mem_alloc_z(sizeof(struct mk_list));
+    mk_list_init(list);
+
+    mk_list_foreach(head, &server->hosts) {
+        h = mk_list_entry(head, struct mk_vhost, _head);
+
+        fdt = mk_mem_alloc(sizeof(struct vhost_fdt_host));
+        fdt->host = h;
+
+        /* Initialize hash table */
+        for (i = 0; i < VHOST_FDT_HASHTABLE_SIZE; i++) {
+            ht = &fdt->hash_table[i];
+            ht->av_slots = VHOST_FDT_HASHTABLE_CHAINS;
+
+            /* for each chain under the hash table, set the fd */
+            for (j = 0; j < VHOST_FDT_HASHTABLE_CHAINS; j++) {
+                hc = &ht->chain[j];
+                hc->fd      = -1;
+                hc->hash    =  0;
+                hc->readers =  0;
+            }
+        }
+        mk_list_add(&fdt->_head, list);
+    }
+
+    MK_TLS_SET(mk_tls_vhost_fdt, list);
+    pthread_mutex_unlock(&server->vhost_fdt_mutex);
+
+    return 0;
+}
+
+int mk_vhost_fdt_worker_exit(struct mk_server *server)
+{
+    struct mk_list *list;
+    struct mk_list *head;
+    struct mk_list *tmp;
+    struct vhost_fdt_host *fdt;
+
+    if (server->fdt == MK_FALSE) {
+        return -1;
+    }
+
+    list = MK_TLS_GET(mk_tls_vhost_fdt);
+    mk_list_foreach_safe(head, tmp, list) {
+        fdt = mk_list_entry(head, struct vhost_fdt_host, _head);
+        mk_list_del(&fdt->_head);
+        mk_mem_free(fdt);
+    }
+
+    mk_mem_free(list);
+    return 0;
+}
+
+
+static inline
+struct vhost_fdt_hash_table *mk_vhost_fdt_table_lookup(int id, struct mk_vhost *host)
+{
+    struct mk_list *head;
+    struct mk_list *list;
+    struct vhost_fdt_host *fdt_host;
+    struct vhost_fdt_hash_table *ht = NULL;
+
+    list = MK_TLS_GET(mk_tls_vhost_fdt);
+    mk_list_foreach(head, list) {
+        fdt_host = mk_list_entry(head, struct vhost_fdt_host, _head);
+        if (fdt_host->host == host) {
+            ht = &fdt_host->hash_table[id];
+            return ht;
+        }
+    }
+
+    return ht;
+}
+
+static inline
+struct vhost_fdt_hash_chain
+*mk_vhost_fdt_chain_lookup(unsigned int hash, struct vhost_fdt_hash_table *ht)
+{
+    int i;
+    struct vhost_fdt_hash_chain *hc = NULL;
+
+    for (i = 0; i < VHOST_FDT_HASHTABLE_CHAINS; i++) {
+        hc = &ht->chain[i];
+        if (hc->hash == hash) {
+            return hc;
+        }
+    }
+
+    return NULL;
+}
+
+
+static inline int mk_vhost_fdt_open(int id, unsigned int hash,
+                                    struct mk_http_request *sr,
+                                    struct mk_server *server)
+{
+    int i;
+    int fd = -1;
+    struct vhost_fdt_hash_table *ht = NULL;
+    struct vhost_fdt_hash_chain *hc;
+
+    if (server->fdt == MK_FALSE) {
+        return open(sr->real_path.data, sr->file_info.flags_read_only);
+    }
+
+    ht = mk_vhost_fdt_table_lookup(id, sr->host_conf);
+    if (mk_unlikely(!ht)) {
+        return open(sr->real_path.data, sr->file_info.flags_read_only);
+    }
+
+    /* We got the hash table, now look around the chains array */
+    hc = mk_vhost_fdt_chain_lookup(hash, ht);
+    if (hc) {
+        /* Increment the readers and return the shared FD */
+        hc->readers++;
+        sr->vhost_fdt_id      = id;
+        sr->vhost_fdt_hash    = hash;
+        sr->vhost_fdt_enabled = MK_TRUE;
+        return hc->fd;
+    }
+
+    /*
+     * Get here means that no entry exists in the hash table for the
+     * requested file descriptor and hash, we must try to open the file
+     * and register the entry in the table.
+     */
+    fd = open(sr->real_path.data, sr->file_info.flags_read_only);
+    if (fd == -1) {
+        return -1;
+    }
+
+    /* If chains are full, just return the new FD, bad luck... */
+    if (ht->av_slots <= 0) {
+        return fd;
+    }
+
+    /* Register the new entry in an available slot */
+    for (i = 0; i < VHOST_FDT_HASHTABLE_CHAINS; i++) {
+        hc = &ht->chain[i];
+        if (hc->fd == -1) {
+            hc->fd   = fd;
+            hc->hash = hash;
+            hc->readers++;
+            ht->av_slots--;
+
+            sr->vhost_fdt_id      = id;
+            sr->vhost_fdt_hash    = hash;
+            sr->vhost_fdt_enabled = MK_TRUE;
+
+            return fd;
+        }
+    }
+
+    return fd;
+}
+
+static inline int mk_vhost_fdt_close(struct mk_http_request *sr,
+                                     struct mk_server *server)
+{
+    int id;
+    unsigned int hash;
+    struct vhost_fdt_hash_table *ht = NULL;
+    struct vhost_fdt_hash_chain *hc;
+
+    if (server->fdt == MK_FALSE || sr->vhost_fdt_enabled == MK_FALSE) {
+        if (sr->in_file.fd > 0) {
+            return close(sr->in_file.fd);
+        }
+        return -1;
+    }
+
+    id   = sr->vhost_fdt_id;
+    hash = sr->vhost_fdt_hash;
+
+    ht = mk_vhost_fdt_table_lookup(id, sr->host_conf);
+    if (mk_unlikely(!ht)) {
+        return close(sr->in_file.fd);
+    }
+
+    /* We got the hash table, now look around the chains array */
+    hc = mk_vhost_fdt_chain_lookup(hash, ht);
+    if (hc) {
+        /* Increment the readers and check if we should close */
+        hc->readers--;
+        sr->vhost_fdt_enabled = MK_FALSE;
+
+        if (hc->readers == 0) {
+            hc->fd   = -1;
+            hc->hash = 0;
+            ht->av_slots++;
+            return close(sr->in_file.fd);
+        }
+        else {
+            return 0;
+        }
+    }
+    return close(sr->in_file.fd);
+}
+
+
+int mk_vhost_open(struct mk_http_request *sr, struct mk_server *server)
+{
+    int id;
+    int off;
+    unsigned int hash;
+
+    off = sr->host_conf->documentroot.len;
+    hash = mk_utils_gen_hash(sr->real_path.data + off,
+                             sr->real_path.len - off);
+    id   = (hash % VHOST_FDT_HASHTABLE_SIZE);
+
+    return mk_vhost_fdt_open(id, hash, sr, server);
+}
+
+int mk_vhost_close(struct mk_http_request *sr, struct mk_server *server)
+{
+    return mk_vhost_fdt_close(sr, server);
+}
+
+struct mk_vhost_handler *mk_vhost_handler_match(char *match,
+                                                void (*cb)(struct mk_http_request *,
+                                                           void *),
+                                                void *data)
+{
+    int ret;
+    struct mk_vhost_handler *h;
+
+    h = mk_mem_alloc(sizeof(struct mk_vhost_handler));
+    if (!h) {
+        return NULL;
+    }
+    h->name  = NULL;
+    h->cb    = cb;
+    h->data  = data;
+    h->match = mk_mem_alloc(REGEXP_SIZE);
+    if (!h->match) {
+        mk_mem_free(h);
+        return NULL;
+    }
+    mk_list_init(&h->params);
+
+    ret = str_to_regex(match, h->match);
+    if (ret == -1) {
+        mk_mem_free(h);
+        return NULL;
+    }
+
+    return h;
+}
+
+/*
+ * Open a virtual host configuration file and return a structure with
+ * definitions.
+ */
+struct mk_vhost *mk_vhost_read(char *path)
+{
+    int ret;
+    char *tmp;
+    char *host_low;
+    struct stat checkdir;
+    struct mk_vhost *host;
+    struct mk_vhost_alias *new_alias;
+    struct mk_vhost_error_page *err_page;
+    struct mk_rconf *cnf;
+    struct mk_rconf_section *section_host;
+    struct mk_rconf_section *section_ep;
+    struct mk_rconf_section *section_handlers;
+    struct mk_rconf_entry *entry_ep;
+    struct mk_string_line *entry;
+    struct mk_list *head, *list, *line;
+    struct mk_vhost_handler *h_handler;
+    struct mk_vhost_handler_param *h_param;
+
+    /* Read configuration file */
+    cnf = mk_rconf_open(path);
+    if (!cnf) {
+        mk_err("Configuration error, aborting.");
+        exit(EXIT_FAILURE);
+    }
+
+    /* Read 'HOST' section */
+    section_host = mk_rconf_section_get(cnf, "HOST");
+    if (!section_host) {
+        mk_err("Invalid config file %s", path);
+        return NULL;
+    }
+
+    /* Alloc configuration node */
+    host = mk_mem_alloc_z(sizeof(struct mk_vhost));
+    host->config = cnf;
+    host->file = mk_string_dup(path);
+
+    /* Init list for host name aliases */
+    mk_list_init(&host->server_names);
+
+    /* Init list for custom error pages */
+    mk_list_init(&host->error_pages);
+
+    /* Init list for content handlers */
+    mk_list_init(&host->handlers);
+
+    /* Lookup Servername */
+    list = mk_rconf_section_get_key(section_host, "Servername", MK_RCONF_LIST);
+    if (!list) {
+        mk_err("Hostname does not contain a Servername");
+        exit(EXIT_FAILURE);
+    }
+
+    mk_list_foreach(head, list) {
+        entry = mk_list_entry(head, struct mk_string_line, _head);
+        if (entry->len > MK_HOSTNAME_LEN - 1) {
+            continue;
+        }
+
+        /* Hostname to lowercase */
+        host_low = mk_string_tolower(entry->val);
+
+        /* Alloc node */
+        new_alias = mk_mem_alloc_z(sizeof(struct mk_vhost_alias));
+        new_alias->name = mk_mem_alloc_z(entry->len + 1);
+        strncpy(new_alias->name, host_low, entry->len);
+        mk_mem_free(host_low);
+
+        new_alias->len = entry->len;
+
+        mk_list_add(&new_alias->_head, &host->server_names);
+    }
+    mk_string_split_free(list);
+
+    /* Lookup document root handled by a mk_ptr_t */
+    host->documentroot.data = mk_rconf_section_get_key(section_host,
+                                                       "DocumentRoot",
+                                                       MK_RCONF_STR);
+    if (!host->documentroot.data) {
+        mk_err("Missing DocumentRoot entry on %s file", path);
+        mk_rconf_free(cnf);
+        mk_mem_free(host->file);
+        mk_mem_free(host);
+        return NULL;
+    }
+
+    host->documentroot.len = strlen(host->documentroot.data);
+
+    /* Validate document root configured */
+    if (stat(host->documentroot.data, &checkdir) == -1) {
+        mk_err("Invalid path to DocumentRoot in %s", path);
+    }
+    else if (!(checkdir.st_mode & S_IFDIR)) {
+        mk_err("DocumentRoot variable in %s has an invalid directory path", path);
+    }
+
+    if (mk_list_is_empty(&host->server_names) == 0) {
+        mk_rconf_free(cnf);
+        mk_mem_free(host->file);
+        mk_mem_free(host);
+        return NULL;
+    }
+
+    /* Check Virtual Host redirection */
+    host->header_redirect.data = NULL;
+    host->header_redirect.len  = 0;
+
+    tmp = mk_rconf_section_get_key(section_host,
+                                   "Redirect",
+                                   MK_RCONF_STR);
+    if (tmp) {
+        host->header_redirect.data = mk_string_dup(tmp);
+        host->header_redirect.len  = strlen(tmp);
+        mk_mem_free(tmp);
+    }
+
+    /* Error Pages */
+    section_ep = mk_rconf_section_get(cnf, "ERROR_PAGES");
+    if (section_ep) {
+        mk_list_foreach(head, &section_ep->entries) {
+            entry_ep = mk_list_entry(head, struct mk_rconf_entry, _head);
+
+            int ep_status = -1;
+            char *ep_file = NULL;
+            unsigned long len;
+
+            ep_status = atoi(entry_ep->key);
+            ep_file   = entry_ep->val;
+
+            /* Validate input values */
+            if (ep_status < MK_CLIENT_BAD_REQUEST ||
+                ep_status > MK_SERVER_HTTP_VERSION_UNSUP ||
+                ep_file == NULL) {
+                continue;
+            }
+
+            /* Alloc error page node */
+            err_page = mk_mem_alloc_z(sizeof(struct mk_vhost_error_page));
+            err_page->status = ep_status;
+            err_page->file   = mk_string_dup(ep_file);
+            err_page->real_path = NULL;
+            mk_string_build(&err_page->real_path, &len, "%s/%s",
+                            host->documentroot.data, err_page->file);
+
+            MK_TRACE("Map error page: status %i -> %s", err_page->status, err_page->file);
+
+            /* Link page to the error page list */
+            mk_list_add(&err_page->_head, &host->error_pages);
+        }
+    }
+
+    /* Handlers */
+    int i;
+    int params;
+    struct mk_list *head_line;
+
+    section_handlers = mk_rconf_section_get(cnf, "HANDLERS");
+    if (!section_handlers) {
+        return host;
+    }
+    mk_list_foreach(head, &section_handlers->entries) {
+        entry_ep = mk_list_entry(head, struct mk_rconf_entry, _head);
+        if (strncasecmp(entry_ep->key, "Match", strlen(entry_ep->key)) == 0) {
+            line = mk_string_split_line(entry_ep->val);
+            if (!line) {
+                continue;
+            }
+            h_handler = mk_mem_alloc(sizeof(struct mk_vhost_handler));
+            if (!h_handler) {
+                exit(EXIT_FAILURE);
+            }
+            h_handler->match = mk_mem_alloc(REGEXP_SIZE);
+            if (!h_handler->match) {
+                mk_mem_free(h_handler);
+                exit(EXIT_FAILURE);
+            }
+            h_handler->cb = NULL;
+            mk_list_init(&h_handler->params);
+
+            i = 0;
+            params = 0;
+            mk_list_foreach(head_line, line) {
+                entry = mk_list_entry(head_line, struct mk_string_line, _head);
+                switch (i) {
+                case 0:
+                    ret = str_to_regex(entry->val, h_handler->match);
+                    if (ret == -1) {
+                        return NULL;
+                    }
+                    break;
+                case 1:
+                    h_handler->name = mk_string_dup(entry->val);
+                    break;
+                default:
+                    /* link parameters */
+                    h_param = mk_mem_alloc(sizeof(struct mk_vhost_handler_param));
+                    h_param->p.data = mk_string_dup(entry->val);
+                    h_param->p.len  = entry->len;
+                    mk_list_add(&h_param->_head, &h_handler->params);
+                    params++;
+                };
+                i++;
+            }
+            h_handler->n_params = params;
+            mk_string_split_free(line);
+
+            if (i < 2) {
+                mk_err("[Host Handlers] invalid Match value\n");
+                exit(EXIT_FAILURE);
+            }
+            mk_list_add(&h_handler->_head, &host->handlers);
+        }
+    }
+
+
+    return host;
+}
+
+int mk_vhost_map_handlers(struct mk_server *server)
+{
+    int n = 0;
+    struct mk_list *head;
+    struct mk_list *head_handler;
+    struct mk_vhost *host;
+    struct mk_vhost_handler *h_handler;
+    struct mk_plugin *p;
+
+    mk_list_foreach(head, &server->hosts) {
+        host = mk_list_entry(head, struct mk_vhost, _head);
+        mk_list_foreach(head_handler, &host->handlers) {
+            h_handler = mk_list_entry(head_handler,
+                                      struct mk_vhost_handler, _head);
+
+            /* Lookup plugin by name */
+            p = mk_plugin_lookup(h_handler->name, server);
+            if (!p) {
+                mk_err("Plugin '%s' was not loaded", h_handler->name);
+                continue;
+            }
+
+            if (p->hooks != MK_PLUGIN_STAGE) {
+                mk_err("Plugin '%s' is not a handler", h_handler->name);
+                continue;
+            }
+
+            h_handler->handler = p;
+            n++;
+        }
+    }
+
+    return n;
+}
+
+void mk_vhost_set_single(char *path, struct mk_server *server)
+{
+    struct mk_vhost *host;
+    struct mk_vhost_alias *halias;
+    struct stat checkdir;
+
+    /* Set the default host */
+    host = mk_mem_alloc_z(sizeof(struct mk_vhost));
+    mk_list_init(&host->error_pages);
+    mk_list_init(&host->server_names);
+
+    /* Prepare the unique alias */
+    halias = mk_mem_alloc_z(sizeof(struct mk_vhost_alias));
+    halias->name = mk_string_dup("127.0.0.1");
+    mk_list_add(&halias->_head, &host->server_names);
+
+    host->documentroot.data = mk_string_dup(path);
+    host->documentroot.len = strlen(path);
+    host->header_redirect.data = NULL;
+
+    /* Validate document root configured */
+    if (stat(host->documentroot.data, &checkdir) == -1) {
+        mk_err("Invalid path to DocumentRoot in %s", path);
+        exit(EXIT_FAILURE);
+    }
+    else if (!(checkdir.st_mode & S_IFDIR)) {
+        mk_err("DocumentRoot variable in %s has an invalid directory path", path);
+        exit(EXIT_FAILURE);
+    }
+    mk_list_add(&host->_head, &server->hosts);
+    mk_list_init(&host->handlers);
+}
+
+/* Given a configuration directory, start reading the virtual host entries */
+void mk_vhost_init(char *path, struct mk_server *server)
+{
+    DIR *dir;
+    unsigned long len;
+    char *buf = 0;
+    char *sites = 0;
+    char *file;
+    struct mk_vhost *p_host;     /* debug */
+    struct dirent *ent;
+    struct file_info f_info;
+    int ret;
+
+    if (!server->conf_sites) {
+        mk_warn("[vhost] skipping default site");
+        return;
+    }
+
+    /* Read default virtual host file */
+    mk_string_build(&sites, &len, "%s/%s/",
+                    path, server->conf_sites);
+    ret = mk_file_get_info(sites, &f_info, MK_FILE_EXISTS);
+    if (ret == -1 || f_info.is_directory == MK_FALSE) {
+        mk_mem_free(sites);
+        sites = server->conf_sites;
+    }
+
+    mk_string_build(&buf, &len, "%s/default", sites);
+
+    p_host = mk_vhost_read(buf);
+    if (!p_host) {
+        mk_err("Error parsing main configuration file 'default'");
+    }
+    mk_list_add(&p_host->_head, &server->hosts);
+    server->nhosts++;
+    mk_mem_free(buf);
+    buf = NULL;
+
+
+    /* Read all virtual hosts defined in sites/ */
+    if (!(dir = opendir(sites))) {
+        mk_mem_free(sites);
+        mk_err("Could not open %s", sites);
+        exit(EXIT_FAILURE);
+    }
+
+    /* Reading content */
+    while ((ent = readdir(dir)) != NULL) {
+        if (ent->d_name[0] == '.') {
+            continue;
+        }
+        if (strcmp((char *) ent->d_name, "..") == 0) {
+            continue;
+        }
+        if (ent->d_name[strlen(ent->d_name) - 1] ==  '~') {
+            continue;
+        }
+        if (strcasecmp((char *) ent->d_name, "default") == 0) {
+            continue;
+        }
+        file = NULL;
+        mk_string_build(&file, &len, "%s/%s", sites, ent->d_name);
+
+        p_host = mk_vhost_read(file);
+        mk_mem_free(file);
+        if (!p_host) {
+            continue;
+        }
+        else {
+            mk_list_add(&p_host->_head, &server->hosts);
+            server->nhosts++;
+        }
+    }
+    closedir(dir);
+    mk_mem_free(sites);
+}
+
+
+/* Lookup a registered virtual host based on the given 'host' input */
+int mk_vhost_get(mk_ptr_t host, struct mk_vhost **vhost,
+                 struct mk_vhost_alias **alias,
+                 struct mk_server *server)
+{
+    struct mk_vhost *entry_host;
+    struct mk_vhost_alias *entry_alias;
+    struct mk_list *head_vhost, *head_alias;
+
+    mk_list_foreach(head_vhost, &server->hosts) {
+        entry_host = mk_list_entry(head_vhost, struct mk_vhost, _head);
+        mk_list_foreach(head_alias, &entry_host->server_names) {
+            entry_alias = mk_list_entry(head_alias, struct mk_vhost_alias, _head);
+            if (entry_alias->len == host.len &&
+                strncmp(entry_alias->name, host.data, host.len) == 0) {
+                *vhost = entry_host;
+                *alias = entry_alias;
+                return 0;
+            }
+        }
+    }
+
+    return -1;
+}
+
+static void mk_vhost_handler_free(struct mk_vhost_handler *h)
+{
+    struct mk_list *tmp;
+    struct mk_list *head;
+    struct mk_vhost_handler_param *param;
+
+    /* Release Params */
+    mk_list_foreach_safe(head, tmp, &h->params) {
+        param = mk_list_entry(head, struct mk_vhost_handler_param, _head);
+        mk_list_del(&param->_head);
+        mk_mem_free(param->p.data);
+        mk_mem_free(param);
+    }
+
+    mk_mem_free(h->match);
+    mk_mem_free(h->name);
+    mk_mem_free(h);
+}
+
+int mk_vhost_destroy(struct mk_vhost *vh)
+{
+    struct mk_vhost_alias *halias = NULL;
+    struct mk_vhost_handler *hhandler;
+    struct mk_vhost_error_page *ep;
+    struct mk_list *head;
+    struct mk_list *tmp;
+
+    if (vh) {
+        /* Free aliases or servernames */
+        mk_list_foreach_safe(head, tmp, &vh->server_names) {
+            halias = mk_list_entry(head, struct mk_vhost_alias, _head);
+            if (halias) {
+                mk_list_del(&halias->_head);
+                if (halias->name) {
+                    mk_mem_free(halias->name);
+                }
+                mk_mem_free(halias);
+            }
+        }
+
+        /* Handlers */
+        mk_list_foreach_safe(head, tmp, &vh->handlers) {
+            hhandler = mk_list_entry(head, struct mk_vhost_handler, _head);
+            if (hhandler) {
+                mk_vhost_handler_free(hhandler);
+            }
+        }
+
+        /* Free error pages */
+        mk_list_foreach_safe(head, tmp, &vh->error_pages) {
+            ep = mk_list_entry(head, struct mk_vhost_error_page, _head);
+            if (ep) {
+                mk_list_del(&ep->_head);
+                if (ep->file) {
+                    mk_mem_free(ep->file);
+                }
+                if (ep->real_path) {
+                    mk_mem_free(ep->real_path);
+                }
+                mk_mem_free(ep);
+            }
+        }
+        mk_ptr_free(&vh->documentroot);
+
+        /* Free source configuration */
+        if (vh->config) {
+            mk_rconf_free(vh->config);
+        }
+        mk_list_del(&vh->_head);
+        if (vh->file) {
+            mk_mem_free(vh->file);
+        }
+
+        mk_mem_free(vh);
+    }
+    return 0;
+}
+
+void mk_vhost_free_all(struct mk_server *server)
+{
+    struct mk_vhost *host;
+    struct mk_list *head;
+    struct mk_list *tmp;
+
+    mk_list_foreach_safe(head, tmp, &server->hosts) {
+        host = mk_list_entry(head, struct mk_vhost, _head);
+        mk_vhost_destroy(host);
+    }
+}
diff --git a/fluent-bit/lib/monkey/mk_server/monkey.c b/fluent-bit/lib/monkey/mk_server/monkey.c
new file mode 100644
index 00000000..68513d21
--- /dev/null
+++ b/fluent-bit/lib/monkey/mk_server/monkey.c
@@ -0,0 +1,241 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Monkey HTTP Server
+ *  ==================
+ *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#define _GNU_SOURCE
+
+#include <mk_core/mk_pthread.h>
+#include <mk_core/mk_event.h>
+
+#include <monkey/mk_scheduler.h>
+#include <monkey/mk_plugin.h>
+#include <monkey/mk_clock.h>
+#include <monkey/mk_thread.h>
+#include <monkey/mk_mimetype.h>
+#include <monkey/mk_http_thread.h>
+
+pthread_once_t mk_server_tls_setup_once = PTHREAD_ONCE_INIT;
+
+static void mk_set_up_tls_keys()
+{
+    MK_INIT_INITIALIZE_TLS_UNIVERSAL();
+    MK_INIT_INITIALIZE_TLS();
+
+    mk_http_thread_initialize_tls();
+}
+
+void mk_server_info(struct mk_server *server)
+{
+    struct mk_list *head;
+    struct mk_plugin *p;
+    struct mk_config_listener *l;
+
+#ifdef _WIN32
+    printf(MK_BANNER_ENTRY "Process ID is %ld\n", (long)GetCurrentProcessId());
+#else
+    printf(MK_BANNER_ENTRY "Process ID is %ld\n", (long) getpid());
+#endif
+    mk_list_foreach(head, &server->listeners) {
+        l = mk_list_entry(head, struct mk_config_listener, _head);
+        printf(MK_BANNER_ENTRY "Server listening on %s:%s\n",
+               l->address, l->port);
+    }
+    printf(MK_BANNER_ENTRY
+           "%i threads, may handle up to %i client connections\n",
+           server->workers, server->server_capacity);
+
+    /* List loaded plugins */
+    printf(MK_BANNER_ENTRY "Loaded Plugins: ");
+    mk_list_foreach(head, &server->plugins) {
+        p = mk_list_entry(head, struct mk_plugin, _head);
+        printf("%s ", p->shortname);
+    }
+    printf("\n");
+
+#ifdef __linux__
+    char tmp[64];
+
+    if (mk_kernel_features_print(tmp, sizeof(tmp), server) > 0) {
+        printf(MK_BANNER_ENTRY "Linux Features: %s\n", tmp);
+    }
+#endif
+
+    fflush(stdout);
+}
+
+/* Initialize Monkey Server */
+struct mk_server *mk_server_create()
+{
+    int ret;
+    int kern_version;
+    int kern_features;
+    struct mk_server *server;
+
+    server = mk_mem_alloc_z(sizeof(struct mk_server));
+    if (!server) {
+        return NULL;
+    }
+
+    /* I'll try to leave both initializations here because 
+     * it should be possible to run in windows using the accept
+     * backend in which case it doesn't make sense to tie the net stack
+     * initialization to libevent.
+     */
+    mk_net_init();
+    mk_event_init();
+
+    /* Library mode: event loop */
+    server->lib_mode = MK_TRUE;
+    server->lib_evl = mk_event_loop_create(8);
+    if (!server->lib_evl) {
+        mk_mem_free(server);
+        return NULL;
+    }
+
+    /* Library mode: channel manager */
+
+    memset(&server->lib_ch_event, 0, sizeof(struct mk_event));
+
+    ret = mk_event_channel_create(server->lib_evl,
+                                  &server->lib_ch_manager[0],
+                                  &server->lib_ch_manager[1],
+                                  &server->lib_ch_event);
+
+    if (ret != 0) {
+        mk_event_loop_destroy(server->lib_evl);
+        mk_mem_free(server);
+        return NULL;
+    }
+
+    /* Library mode: start event loop */
+    server->lib_evl_start = mk_event_loop_create(1);
+    if (!server->lib_evl_start) {
+        mk_event_loop_destroy(server->lib_evl);
+        mk_mem_free(server);
+        return NULL;
+    }
+
+    memset(&server->lib_ch_start_event, 0, sizeof(struct mk_event));
+
+    ret = mk_event_channel_create(server->lib_evl_start,
+                                  &server->lib_ch_start[0],
+                                  &server->lib_ch_start[1],
+                                  &server->lib_ch_start_event);
+
+    if (ret != 0) {
+        mk_event_loop_destroy(server->lib_evl);
+        mk_event_loop_destroy(server->lib_evl_start);
+        mk_mem_free(server);
+        return NULL;
+    }
+
+    /* Initialize linked list heads */
+    mk_list_init(&server->plugins);
+    mk_list_init(&server->sched_worker_callbacks);
+    mk_list_init(&server->stage10_handler);
+    mk_list_init(&server->stage20_handler);
+    mk_list_init(&server->stage30_handler);
+    mk_list_init(&server->stage40_handler);
+    mk_list_init(&server->stage50_handler);
+    server->scheduler_mode = -1;
+
+    mk_core_init();
+
+    /* Init thread keys */
+    pthread_once(&mk_server_tls_setup_once, mk_set_up_tls_keys);
+
+    /* Init Kernel version data */
+    kern_version = mk_kernel_version();
+    kern_features = mk_kernel_features(kern_version);
+
+    server->kernel_version = kern_version;
+    server->kernel_features = kern_features;
+
+#ifdef MK_HAVE_TRACE
+    MK_TRACE("Monkey TRACE is enabled");
+    //pthread_mutex_init(&mutex_trace, (pthread_mutexattr_t *) NULL);
+#endif
+
+#ifdef LINUX_TRACE
+    mk_info("Linux Trace enabled");
+#endif
+
+    mk_config_set_init_values(server);
+
+    mk_mimetype_init(server);
+
+    pthread_mutex_init(&server->vhost_fdt_mutex, NULL);
+
+    return server;
+}
+
+int mk_server_setup(struct mk_server *server)
+{
+    int ret;
+    pthread_t tid;
+
+    /* Core and Scheduler setup */
+    mk_config_start_configure(server);
+    mk_config_signature(server);
+
+    mk_sched_init(server);
+
+
+    /* Clock init that must happen before starting threads */
+    mk_clock_sequential_init(server);
+
+    /* Load plugins */
+    mk_plugin_api_init(server);
+    mk_plugin_load_all(server);
+
+    /* Workers: logger and clock */
+    ret = mk_utils_worker_spawn((void *) mk_clock_worker_init, server, &tid);
+    if (ret != 0) {
+        return -1;
+    }
+
+    /* Configuration sanity check */
+    mk_config_sanity_check(server);
+
+    /* Invoke Plugin PRCTX hooks */
+    mk_plugin_core_process(server);
+
+    /* Launch monkey http workers */
+    mk_server_launch_workers(server);
+
+    return 0;
+}
+
+void mk_exit_all(struct mk_server *server)
+{
+    uint64_t val;
+
+    /* Distribute worker signals to stop working */
+    val = MK_SCHED_SIGNAL_FREE_ALL;
+    mk_sched_broadcast_signal(server, val);
+
+    /* Wait for all workers to finish */
+    mk_sched_workers_join(server);
+
+    /* Continue exiting */
+    mk_plugin_exit_all(server);
+    mk_clock_exit(server);
+
+    mk_sched_exit(server);
+    mk_config_free_all(server);
+}