in_http: http realloc fus fix, http_server: same fix

plugins/in_http/http_conn.c

@@ -27,13 +27,72 @@
 static void http_conn_request_init(struct mk_http_session *session,
                                    struct mk_http_request *request);
 
+static void check_and_reassign_ptr(char **ptr, const char *old, char *new)
+{
+    if (ptr == NULL) {
+        return;
+    }
+
+    if (*ptr == NULL) {
+        return;
+    }
+
+    *ptr = new + (*ptr - old);
+}
+
+static int http_conn_realloc(struct flb_http *ctx,
+                               struct http_conn *conn,
+                               size_t size)
+{
+    char *tmp;
+    int idx;
+    struct mk_http_header *header;
+
+
+    tmp = flb_realloc(conn->buf_data, size);
+    if (!tmp) {
+        flb_errno();
+        return -1;
+    }
+    flb_plg_trace(ctx->ins, "buffer realloc %i -> %zu",
+                    conn->buf_size, size);
+
+    check_and_reassign_ptr(&conn->request.method_p.data, conn->buf_data, tmp);
+    check_and_reassign_ptr(&conn->request.uri.data, conn->buf_data, tmp);
+    check_and_reassign_ptr(&conn->request.uri_processed.data, conn->buf_data, tmp);
+    check_and_reassign_ptr(&conn->request.protocol_p.data, conn->buf_data, tmp);
+    check_and_reassign_ptr(&conn->request.body.data, conn->buf_data, tmp);
+    check_and_reassign_ptr(&conn->request._content_length.data, conn->buf_data, tmp);
+    check_and_reassign_ptr(&conn->request.content_type.data, conn->buf_data, tmp);
+    check_and_reassign_ptr(&conn->request.connection.data, conn->buf_data, tmp);
+    check_and_reassign_ptr(&conn->request.host.data, conn->buf_data, tmp);
+    check_and_reassign_ptr(&conn->request.host_port.data, conn->buf_data, tmp);
+    check_and_reassign_ptr(&conn->request.if_modified_since.data, conn->buf_data, tmp);
+    check_and_reassign_ptr(&conn->request.last_modified_since.data, conn->buf_data, tmp);
+    check_and_reassign_ptr(&conn->request.range.data, conn->buf_data, tmp);
+    check_and_reassign_ptr(&conn->request.data.data, conn->buf_data, tmp);
+    check_and_reassign_ptr(&conn->request.real_path.data, conn->buf_data, tmp);
+    check_and_reassign_ptr(&conn->request.query_string.data, conn->buf_data, tmp);
+
+    for (idx = conn->session.parser.header_min; idx <= conn->session.parser.header_max && idx >= 0; idx++) {
+        header = &conn->session.parser.headers[idx];
+
+        check_and_reassign_ptr(&header->key.data, conn->buf_data, tmp);
+        check_and_reassign_ptr(&header->val.data, conn->buf_data, tmp);
+    }
+
+    conn->buf_data = tmp;
+    conn->buf_size = size;
+
+    return 0;
+}
+
 static int http_conn_event(void *data)
 {
     int status;
     size_t size;
     ssize_t available;
     ssize_t bytes;
-    char *tmp;
     char *request_end;
     size_t request_len;
     struct flb_connection *connection;
@@ -61,16 +120,13 @@ static int http_conn_event(void *data)
             }
 
             size = conn->buf_size + ctx->buffer_chunk_size;
-            tmp = flb_realloc(conn->buf_data, size);
-            if (!tmp) {
+            if (http_conn_realloc(ctx, conn, size) == -1) {
                 flb_errno();
                 return -1;
             }
             flb_plg_trace(ctx->ins, "fd=%i buffer realloc %i -> %zu",
                           event->fd, conn->buf_size, size);
 
-            conn->buf_data = tmp;
-            conn->buf_size = size;
             available = (conn->buf_size - conn->buf_len) - 1;
         }
 

src/http_server/flb_http_server.c

@@ -668,6 +668,55 @@ void flb_http_server_session_destroy(struct flb_http_server_session *session)
     }
 }
 
+static void check_and_reassign_ptr(char **ptr, const char *old, char *new)
+{
+    if (ptr == NULL) {
+        return;
+    }
+
+    if (*ptr == NULL) {
+        return;
+    }
+
+    *ptr = new + (*ptr - old);
+}
+
+static int request_mk_recalculate(struct mk_http_request *req,
+                                  struct mk_http_parser *parser,
+                                  const char *oldbuf,
+                                  char *newbuf)
+{
+    int idx;
+    struct mk_http_header *header;
+
+
+    check_and_reassign_ptr(&req->method_p.data, oldbuf, newbuf);
+    check_and_reassign_ptr(&req->uri.data, oldbuf, newbuf);
+    check_and_reassign_ptr(&req->uri_processed.data, oldbuf, newbuf);
+    check_and_reassign_ptr(&req->protocol_p.data, oldbuf, newbuf);
+    check_and_reassign_ptr(&req->body.data, oldbuf, newbuf);
+    check_and_reassign_ptr(&req->_content_length.data, oldbuf, newbuf);
+    check_and_reassign_ptr(&req->content_type.data, oldbuf, newbuf);
+    check_and_reassign_ptr(&req->connection.data, oldbuf, newbuf);
+    check_and_reassign_ptr(&req->host.data, oldbuf, newbuf);
+    check_and_reassign_ptr(&req->host_port.data, oldbuf, newbuf);
+    check_and_reassign_ptr(&req->if_modified_since.data, oldbuf, newbuf);
+    check_and_reassign_ptr(&req->last_modified_since.data, oldbuf, newbuf);
+    check_and_reassign_ptr(&req->range.data, oldbuf, newbuf);
+    check_and_reassign_ptr(&req->data.data, oldbuf, newbuf);
+    check_and_reassign_ptr(&req->real_path.data, oldbuf, newbuf);
+    check_and_reassign_ptr(&req->query_string.data, oldbuf, newbuf);
+
+    for (idx = parser->header_min; idx <= parser->header_max && idx >= 0; idx++) {
+        header = &parser->headers[idx];
+
+        check_and_reassign_ptr(&header->key.data, oldbuf, newbuf);
+        check_and_reassign_ptr(&header->val.data, oldbuf, newbuf);
+    }
+
+    return 0;
+}
+
 int flb_http_server_session_ingest(struct flb_http_server_session *session, 
                             unsigned char *buffer, 
                             size_t length)
@@ -685,6 +734,13 @@ int flb_http_server_session_ingest(struct flb_http_server_session *session,
             return HTTP_SERVER_ALLOCATION_ERROR;
         }
 
+        if (session->version == HTTP_PROTOCOL_HTTP1) {
+            request_mk_recalculate(&session->http1.inner_request, 
+                            &session->http1.inner_parser,
+                            session->incoming_data,
+                            resized_buffer);
+        }
+
         session->incoming_data = resized_buffer;
     }