lib-http: Implemented limits on overall HTTP header size, size of individual header...

diff --git a/src/lib-http/http-client-connection.c b/src/lib-http/http-client-connection.c
index d59235d2f48d534af55fd379c6e83b590aaf1554..7a17b7ef7ec8ba81b76e1e407753be2c2e41dc98 100644 (file)
--- a/src/lib-http/http-client-connection.c
+++ b/src/lib-http/http-client-connection.c
@@ -721,7 +721,8 @@ http_client_connection_ready(struct http_client_connection *conn)
        }
 
        /* start protocol I/O */
-       conn->http_parser = http_response_parser_init(conn->conn.input);
+       conn->http_parser = http_response_parser_init
+               (conn->conn.input, &conn->client->set.response_hdr_limits);
        o_stream_set_flush_callback(conn->conn.output,
     http_client_connection_output, conn);
 }

diff --git a/src/lib-http/http-client.c b/src/lib-http/http-client.c
index 66ca2b3c41c7396df819aa47142f44166b42d67e..b598d5cd554a3131cb668b45c1e9e76277e0a94e 100644 (file)
--- a/src/lib-http/http-client.c
+++ b/src/lib-http/http-client.c
@@ -96,6 +96,7 @@ struct http_client *http_client_init(const struct http_client_settings *set)
                (set->max_pipelined_requests > 0 ? set->max_pipelined_requests : 1);
        client->set.max_attempts = set->max_attempts;
        client->set.max_redirects = set->max_redirects;
+       client->set.response_hdr_limits = set->response_hdr_limits;
        client->set.request_timeout_msecs = set->request_timeout_msecs;
        client->set.connect_timeout_msecs = set->connect_timeout_msecs;
        client->set.soft_connect_timeout_msecs = set->soft_connect_timeout_msecs;

diff --git a/src/lib-http/http-client.h b/src/lib-http/http-client.h
index 627d141e73a4c45f9516d645a6e78aa971833cf2..63327b6a8faa58683aa2628220daecd6fa63d7db 100644 (file)
--- a/src/lib-http/http-client.h
+++ b/src/lib-http/http-client.h
@@ -59,6 +59,9 @@ struct http_client_settings {
        /* maximum number of attempts for a request */
        unsigned int max_attempts;
 
+       /* response header limits */
+       struct http_header_limits response_hdr_limits;
+
        /* max time to wait for HTTP request to finish before retrying
           (default = unlimited) */
        unsigned int request_timeout_msecs;

diff --git a/src/lib-http/http-header-parser.c b/src/lib-http/http-header-parser.c
index d78f6ed69cab05ce3a103ad52db7175bd6f239a5..92046748cf3a883c2bfea0ed6fe7c5890b5df72a 100644 (file)
--- a/src/lib-http/http-header-parser.c
+++ b/src/lib-http/http-header-parser.c
@@ -6,6 +6,7 @@
 #include "str.h"
 #include "str-sanitize.h"
 #include "http-parser.h"
+#include "http-header.h"
 
 #include "http-header-parser.h"
 
@@ -25,6 +26,10 @@ enum http_header_parse_state {
 struct http_header_parser {
        struct istream *input;
 
+       struct http_header_limits limits;
+       uoff_t size, field_size;
+       unsigned int field_count;
+
        const unsigned char *begin, *cur, *end;
        const char *error;
 
@@ -34,9 +39,9 @@ struct http_header_parser {
        enum http_header_parse_state state;
 };
 
-// FIXME(Stephan): Add support for limiting maximum header size.
-
-struct http_header_parser *http_header_parser_init(struct istream *input)
+struct http_header_parser *
+http_header_parser_init(struct istream *input,
+       const struct http_header_limits *limits)
 {
        struct http_header_parser *parser;
 
@@ -45,6 +50,16 @@ struct http_header_parser *http_header_parser_init(struct istream *input)
        parser->name = str_new(default_pool, 128);
        parser->value_buf = buffer_create_dynamic(default_pool, 4096);
 
+       if (limits != NULL)
+               parser->limits = *limits;
+
+       if (parser->limits.max_size == 0)
+               parser->limits.max_size = (uoff_t)-1;
+       if (parser->limits.max_field_size == 0)
+               parser->limits.max_field_size = (uoff_t)-1;
+       if (parser->limits.max_fields == 0)
+               parser->limits.max_fields = (unsigned int)-1;
+
        return parser;
 }
 
@@ -62,6 +77,9 @@ void http_header_parser_deinit(struct http_header_parser **_parser)
 void http_header_parser_reset(struct http_header_parser *parser)
 {
        parser->state = HTTP_HEADER_PARSE_STATE_INIT;
+       parser->size = 0;
+       parser->field_size = 0;
+       parser->field_count = 0;
 }
 
 static int http_header_parse_name(struct http_header_parser *parser)
@@ -144,7 +162,7 @@ static int http_header_parse(struct http_header_parser *parser)
                        if (http_char_is_token(*parser->cur)) {
                                if ((ret=http_header_parse_name(parser)) <= 0)
                                        return ret;
-                       } else if (str_len(parser->name) == 0) {
+                       } else if (*parser->cur != ':' && str_len(parser->name) == 0) {
                                parser->state = HTTP_HEADER_PARSE_STATE_LAST_LINE;
                                break;
                        }
@@ -163,6 +181,10 @@ static int http_header_parse(struct http_header_parser *parser)
                                parser->error = "Empty header field name";
                                return -1;
                        }
+                       if (++parser->field_count > parser->limits.max_fields) {
+                               parser->error = "Excessive number of header fields";
+                               return -1;
+                       }
                        parser->state = HTTP_HEADER_PARSE_STATE_OWS;
                        /* fall through */
                case HTTP_HEADER_PARSE_STATE_OWS:
@@ -203,7 +225,7 @@ static int http_header_parse(struct http_header_parser *parser)
                                parser->state = HTTP_HEADER_PARSE_STATE_OWS;
                                break;
                        }
-                       parser->state = HTTP_HEADER_PARSE_STATE_NAME;
+                       parser->state = HTTP_HEADER_PARSE_STATE_INIT;
                        return 1;
                case HTTP_HEADER_PARSE_STATE_LAST_LINE:
                        if (*parser->cur == '\r') {
@@ -247,12 +269,35 @@ int http_header_parse_next_field(struct http_header_parser *parser,
        const char **name_r, const unsigned char **data_r, size_t *size_r,
        const char **error_r)
 {
+       const uoff_t max_size = parser->limits.max_size;
+       const uoff_t max_field_size = parser->limits.max_field_size;
        const unsigned char *data;
-       size_t size;
+       uoff_t size;
        int ret;
 
+       *error_r = NULL;
+
        while ((ret=i_stream_read_data
                (parser->input, &parser->begin, &size, 0)) > 0) {
+
+               /* check header size limits */
+               if (parser->size >= max_size) {
+                       *error_r = "Excessive header size";
+                       return -1;
+               }
+               if (parser->field_size > max_field_size) {
+                       *error_r = "Excessive header field size";
+                       return -1;
+               }
+
+               /* don't parse beyond header size limits */
+               if (size > (max_size - parser->size))
+                       size = max_size - parser->size;
+               if (size > (max_field_size - parser->field_size)) {
+                       size = max_field_size - parser->field_size;
+                       size = (size == 0 ? 1 : size); /* need to parse one more byte */
+               }
+
                parser->cur = parser->begin;
                parser->end = parser->cur + size;
 
@@ -262,8 +307,12 @@ int http_header_parse_next_field(struct http_header_parser *parser,
                }
 
                i_stream_skip(parser->input, parser->cur - parser->begin);
+               parser->size += parser->cur - parser->begin;
+               parser->field_size += parser->cur - parser->begin;
 
                if (ret == 1) {
+                       parser->field_size = 0;
+
                        if (parser->state != HTTP_HEADER_PARSE_STATE_EOH) {
                                data = buffer_get_data(parser->value_buf, &size);
                        

diff --git a/src/lib-http/http-header-parser.h b/src/lib-http/http-header-parser.h
index 75c6fb90a50a14f192e7d4fa08ff3e4265ac1fa4..7138caff2a2751499fdb5e7c775ab97ad81c4504 100644 (file)
--- a/src/lib-http/http-header-parser.h
+++ b/src/lib-http/http-header-parser.h
@@ -1,9 +1,12 @@
 #ifndef HTTP_HEADER_PARSER_H
 #define HTTP_HEADER_PARSER_H
 
+struct http_header_limits;
 struct http_header_parser;
 
-struct http_header_parser *http_header_parser_init(struct istream *input);
+struct http_header_parser *
+http_header_parser_init(struct istream *input,
+       const struct http_header_limits *limits);
 void http_header_parser_deinit(struct http_header_parser **_parser);
 
 void http_header_parser_reset(struct http_header_parser *parser);

diff --git a/src/lib-http/http-header.h b/src/lib-http/http-header.h
index 91b8ebe06a427321fe282bd4e4a1be64392a2e99..f0620afd7ee66d315a094da6fac43ca688c97dc2 100644 (file)
--- a/src/lib-http/http-header.h
+++ b/src/lib-http/http-header.h
@@ -3,6 +3,12 @@
 
 struct http_header;
 
+struct http_header_limits {
+       uoff_t max_size;
+       uoff_t max_field_size;
+       unsigned int max_fields;
+};
+
 struct http_header_field {
        const char *key; /* FIXME: rename to 'name' for v2.3 */
        const char *value;

diff --git a/src/lib-http/http-message-parser.c b/src/lib-http/http-message-parser.c
index 270e841c62a6a14845c365b474e59ab0cc226528..1c1ea54b8a205304ea5d6bbe6557958961973f6b 100644 (file)
--- a/src/lib-http/http-message-parser.c
+++ b/src/lib-http/http-message-parser.c
@@ -13,10 +13,12 @@
 #include <ctype.h>
 
 void http_message_parser_init(struct http_message_parser *parser,
-                             struct istream *input)
+       struct istream *input, const struct http_header_limits *hdr_limits)
 {
        memset(parser, 0, sizeof(*parser));
        parser->input = input;
+       if (hdr_limits != NULL)
+               parser->header_limits = *hdr_limits;
 }
 
 void http_message_parser_deinit(struct http_message_parser *parser)
@@ -34,10 +36,12 @@ void http_message_parser_restart(struct http_message_parser *parser,
 {
        i_assert(parser->payload == NULL);
 
-       if (parser->header_parser == NULL)
-               parser->header_parser = http_header_parser_init(parser->input);
-       else
+       if (parser->header_parser == NULL) {
+               parser->header_parser =
+                       http_header_parser_init(parser->input, &parser->header_limits);
+       } else {
                http_header_parser_reset(parser->header_parser);
+       }
 
        if (parser->msg.pool != NULL)
                pool_unref(&parser->msg.pool);

diff --git a/src/lib-http/http-message-parser.h b/src/lib-http/http-message-parser.h
index 79e90a2a2c228e632e45c7311e3efbaa02eb47b3..c439b8cc4604dbf49cfb4259fd86e5db5e7571ea 100644 (file)
--- a/src/lib-http/http-message-parser.h
+++ b/src/lib-http/http-message-parser.h
@@ -4,7 +4,7 @@
 #include "http-response.h"
 #include "http-transfer.h"
 
-struct http_header;
+#include "http-header.h"
 
 struct http_message {
        pool_t pool;
@@ -26,6 +26,7 @@ struct http_message {
 
 struct http_message_parser {
        struct istream *input;
+       struct http_header_limits header_limits;
 
        const unsigned char *cur, *end;
 
@@ -37,7 +38,8 @@ struct http_message_parser {
 };
 
 void http_message_parser_init(struct http_message_parser *parser,
-                             struct istream *input);
+       struct istream *input, const struct http_header_limits *hdr_limits)
+       ATTR_NULL(3);
 void http_message_parser_deinit(struct http_message_parser *parser);
 void http_message_parser_restart(struct http_message_parser *parser,
        pool_t pool);

diff --git a/src/lib-http/http-request-parser.c b/src/lib-http/http-request-parser.c
index c9f5c39daec85b8c364fb37c7890b068e415d705..a1a6b6fadf39fb87944c3cd01088f719768ebf18 100644 (file)
--- a/src/lib-http/http-request-parser.c
+++ b/src/lib-http/http-request-parser.c
@@ -29,12 +29,14 @@ struct http_request_parser {
        unsigned int skipping_line:1;
 };
 
-struct http_request_parser *http_request_parser_init(struct istream *input)
+struct http_request_parser *
+http_request_parser_init(struct istream *input,
+       const struct http_header_limits *hdr_limits)
 {
        struct http_request_parser *parser;
 
        parser = i_new(struct http_request_parser, 1);
-       http_message_parser_init(&parser->parser, input);
+       http_message_parser_init(&parser->parser, input, hdr_limits);
        return parser;
 }
 

diff --git a/src/lib-http/http-request-parser.h b/src/lib-http/http-request-parser.h
index 450aafaf61fe7ff993af1783e72867aff58c2287..1f526560fbddd6e3fb4450cda1b6432906196a5e 100644 (file)
--- a/src/lib-http/http-request-parser.h
+++ b/src/lib-http/http-request-parser.h
@@ -4,7 +4,8 @@
 #include "http-request.h"
 
 struct http_request_parser *
-http_request_parser_init(struct istream *input);
+http_request_parser_init(struct istream *input,
+       const struct http_header_limits *hdr_limits) ATTR_NULL(2);
 void http_request_parser_deinit(struct http_request_parser **_parser);
 
 int http_request_parse_next(struct http_request_parser *parser,

diff --git a/src/lib-http/http-response-parser.c b/src/lib-http/http-response-parser.c
index a088980ae2c24d35b7a063d97fc95fe02e8b73ff..db0a37883999ea102cf7a9b3b5e3bd91c1936348 100644 (file)
--- a/src/lib-http/http-response-parser.c
+++ b/src/lib-http/http-response-parser.c
@@ -28,12 +28,15 @@ struct http_response_parser {
        const char *response_reason;
 };
 
-struct http_response_parser *http_response_parser_init(struct istream *input)
+struct http_response_parser *
+http_response_parser_init(struct istream *input,
+       const struct http_header_limits *hdr_limits)
 {
        struct http_response_parser *parser;
 
+       /* FIXME: implement status line limit */
        parser = i_new(struct http_response_parser, 1);
-       http_message_parser_init(&parser->parser, input);
+       http_message_parser_init(&parser->parser, input, hdr_limits);
        return parser;
 }
 

diff --git a/src/lib-http/http-response-parser.h b/src/lib-http/http-response-parser.h
index 479bb9dfc6b40b21c19d0ab0a122fcd8344c1854..dea41f31e300526bfcb10f6e5573c2e46f609343 100644 (file)
--- a/src/lib-http/http-response-parser.h
+++ b/src/lib-http/http-response-parser.h
@@ -3,10 +3,12 @@
 
 #include "http-response.h"
 
+struct http_header_limits;
 struct http_response_parser;
 
 struct http_response_parser *
-http_response_parser_init(struct istream *input);
+http_response_parser_init(struct istream *input,
+       const struct http_header_limits *hdr_limits) ATTR_NULL(2);
 void http_response_parser_deinit(struct http_response_parser **_parser);
 
 int http_response_parse_next(struct http_response_parser *parser,

diff --git a/src/lib-http/http-transfer-chunked.c b/src/lib-http/http-transfer-chunked.c
index b774cf8adc03d9b49c4711ae985339ac344cb05f..5d1d01226f9a49b3ba6499bb5e025e4ac15196f7 100644 (file)
--- a/src/lib-http/http-transfer-chunked.c
+++ b/src/lib-http/http-transfer-chunked.c
@@ -425,7 +425,9 @@ static int http_transfer_chunked_parse_trailer(
        int ret;
 
        if (tcstream->header_parser == NULL) {
-               tcstream->header_parser = http_header_parser_init(tcstream->istream.parent);
+               /* FIXME: limit trailer size */
+               tcstream->header_parser =
+                       http_header_parser_init(tcstream->istream.parent, 0);
        }
 
        while ((ret=http_header_parse_next_field(tcstream->header_parser,

diff --git a/src/lib-http/test-http-header-parser.c b/src/lib-http/test-http-header-parser.c
index 9187b0432e16ab0a96a695226a4ee822105fcf62..d9e64cf16e5640c71b3c61d4b99ccefbe64507ce 100644 (file)
--- a/src/lib-http/test-http-header-parser.c
+++ b/src/lib-http/test-http-header-parser.c
@@ -3,6 +3,7 @@
 #include "test-lib.h"
 #include "istream.h"
 #include "test-common.h"
+#include "http-response.h"
 #include "http-header-parser.h"
 
 #include <time.h>
@@ -14,6 +15,7 @@ struct http_header_parse_result {
 
 struct http_header_parse_test {
        const char *header;
+       struct http_header_limits limits;
        const struct http_header_parse_result *fields;
 };
 
@@ -138,7 +140,12 @@ static const struct http_header_parse_test valid_header_parse_tests[] = {
                        "Content-Type: text/html; charset=utf-8\r\n"
                        "Content-Encoding: gzip\r\n"
                        "\r\n",
-               .fields = valid_header_parse_result4
+               .fields = valid_header_parse_result4,
+               .limits = {
+                       .max_size = 340,
+                       .max_field_size = 46,
+                       .max_fields = 12
+               }
        },{
                .header =
                        "\r\n",
@@ -155,7 +162,8 @@ static void test_http_header_parse_valid(void)
        for (i = 0; i < valid_header_parse_test_count; i++) T_BEGIN {
                struct istream *input;
                struct http_header_parser *parser;
-               const char *header, *field_name, *error;
+               const struct http_header_limits *limits;
+               const char *header, *field_name, *error = NULL;
                const unsigned char *field_data;
                size_t field_size;
                int ret;
@@ -163,8 +171,9 @@ static void test_http_header_parse_valid(void)
 
                header = valid_header_parse_tests[i].header;
                header_len = strlen(header);
+               limits = &valid_header_parse_tests[i].limits;
                input = test_istream_create_data(header, header_len);
-               parser = http_header_parser_init(input);
+               parser = http_header_parser_init(input, limits);
 
                test_begin(t_strdup_printf("http header valid [%d]", i));
 
@@ -199,35 +208,96 @@ static void test_http_header_parse_valid(void)
                        j++;
                }
 
-               test_out("parse success", ret > 0);
+               test_out_reason("parse success", ret > 0, error);
                test_end();
                http_header_parser_deinit(&parser);
        } T_END;
 }
 
-static const char *invalid_header_parse_tests[] = {
-       "Date: Sat, 06 Oct 2012 16:01:44 GMT\r\n"
-       "Server : Apache/2.2.16 (Debian)\r\n"
-       "Last-Modified: Mon, 30 Jul 2012 11:09:28 GMT\r\n"
-       "\r\n",
-       "Date: Sat, 06 Oct 2012 17:18:22 GMT\r\n"
-       "Server: Apache/2.2.3 (CentOS)\r\n"
-       "X Powered By: PHP/5.3.6\r\n"
-       "\r\n",
-       "Host: www.example.com\n\r"
-       "Accept: image/png,image/*;q=0.8,*/*;q=0.5\n\r"
-       "Accept-Language: en-us,en;q=0.5\n\r"
-       "Accept-Encoding: gzip, deflate\n\r"
-       "\n\r",
-       "Host: p5-lrqzb4yavu4l7nagydw-428649-i2-v6exp3-ds.metric.example.com\n"
-       "User-Agent:Mozilla/5.0 (Windows NT 6.1; WOW64; rv:15.0)\n"
-       "Accept:\t\timage/png,image/*;q=0.8,*/\177;q=0.5\n"
-       "\n",
-       "Date: Sat, 06 Oct 2012 17:12:37 GMT\r\n"
-       "Server: Apache/2.2.16 (Debian) PHP/5.3.3-7+squeeze14 with\r\n"
-       "Suhosin-Patch proxy_html/3.0.1 mod_python/3.3.1 Python/2.6.6\r\n"
-       "mod_ssl/2.2.16 OpenSSL/0.9.8o mod_perl/2.0.4 Perl/v5.10.1\r\n"
-       "\r\n",
+static const struct http_header_parse_test invalid_header_parse_tests[] = {
+       {
+               .header = 
+                       "Date: Sat, 06 Oct 2012 16:01:44 GMT\r\n"
+                       "Server : Apache/2.2.16 (Debian)\r\n"
+                       "Last-Modified: Mon, 30 Jul 2012 11:09:28 GMT\r\n"
+                       "\r\n"
+       },{
+               .header = 
+                       "Date: Sat, 06 Oct 2012 17:18:22 GMT\r\n"
+                       "Server: Apache/2.2.3 (CentOS)\r\n"
+                       "X Powered By: PHP/5.3.6\r\n"
+                       "\r\n"
+       },{
+               .header = 
+                       "Host: www.example.com\n\r"
+                       "Accept: image/png,image/*;q=0.8,*/*;q=0.5\n\r"
+                       "Accept-Language: en-us,en;q=0.5\n\r"
+                       "Accept-Encoding: gzip, deflate\n\r"
+                       "\n\r"
+       },{
+               .header = 
+                       "Host: p5-lrqzb4yavu4l7nagydw-428649-i2-v6exp3-ds.metric.example.com\n"
+                       "User-Agent:Mozilla/5.0 (Windows NT 6.1; WOW64; rv:15.0)\n"
+                       "Accept:\t\timage/png,image/*;q=0.8,*/\177;q=0.5\n"
+                       "\n"
+       },{
+               .header = 
+                       "Date: Sat, 06 Oct 2012 17:12:37 GMT\r\n"
+                       "Server: Apache/2.2.16 (Debian) PHP/5.3.3-7+squeeze14 with\r\n"
+                       "Suhosin-Patch proxy_html/3.0.1 mod_python/3.3.1 Python/2.6.6\r\n"
+                       "mod_ssl/2.2.16 OpenSSL/0.9.8o mod_perl/2.0.4 Perl/v5.10.1\r\n"
+                       "\r\n"
+       },{
+               .header = 
+                       "Age: 58        \r\n"
+                       "Date: Sun, 04 Aug 2013 09:33:09 GMT\r\n"
+                       "Expires: Sun, 04 Aug 2013 09:34:08 GMT\r\n"
+                       "Cache-Control: max-age=60        \r\n"
+                       "Content-Length: 17336     \r\n"
+                       "Connection: Keep-Alive\r\n"
+                       "Via: NS-CACHE-9.3\r\n"
+                       "Server: Apache\r\n"
+                       "Vary: Host\r\n"
+                       "Last-Modified: Sun, 04 Aug 2013 09:33:07 GMT\r\n"
+                       "Content-Type: text/html; charset=utf-8\r\n"
+                       "Content-Encoding: gzip\r\n"
+                       "\r\n",
+               .limits = { .max_size = 339 }
+       },{
+               .header = 
+                       "Age: 58        \r\n"
+                       "Date: Sun, 04 Aug 2013 09:33:09 GMT\r\n"
+                       "Expires: Sun, 04 Aug 2013 09:34:08 GMT\r\n"
+                       "Cache-Control: max-age=60        \r\n"
+                       "Content-Length: 17336     \r\n"
+                       "Connection: Keep-Alive\r\n"
+                       "Via: NS-CACHE-9.3\r\n"
+                       "Server: Apache\r\n"
+                       "Vary: Host\r\n"
+                       "Last-Modified: Sun, 04 Aug 2013 09:33:07 GMT\r\n"
+                       "Content-Type: text/html; charset=utf-8\r\n"
+                       "Content-Encoding: gzip\r\n"
+                       "\r\n",
+               .fields = valid_header_parse_result4,
+               .limits = { .max_field_size = 45 }
+       },{
+               .header = 
+                       "Age: 58        \r\n"
+                       "Date: Sun, 04 Aug 2013 09:33:09 GMT\r\n"
+                       "Expires: Sun, 04 Aug 2013 09:34:08 GMT\r\n"
+                       "Cache-Control: max-age=60        \r\n"
+                       "Content-Length: 17336     \r\n"
+                       "Connection: Keep-Alive\r\n"
+                       "Via: NS-CACHE-9.3\r\n"
+                       "Server: Apache\r\n"
+                       "Vary: Host\r\n"
+                       "Last-Modified: Sun, 04 Aug 2013 09:33:07 GMT\r\n"
+                       "Content-Type: text/html; charset=utf-8\r\n"
+                       "Content-Encoding: gzip\r\n"
+                       "\r\n",
+               .fields = valid_header_parse_result4,
+               .limits = { .max_fields = 11 }
+       }
 };
 
 unsigned int invalid_header_parse_test_count = N_ELEMENTS(invalid_header_parse_tests);
@@ -239,14 +309,16 @@ static void test_http_header_parse_invalid(void)
        for (i = 0; i < invalid_header_parse_test_count; i++) T_BEGIN {
                struct istream *input;
                struct http_header_parser *parser;
-               const char *header, *field_name, *error;
+               const struct http_header_limits *limits;
+               const char *header, *field_name, *error = NULL;
                const unsigned char *field_data;
                size_t field_size;
                int ret;
 
-               header = invalid_header_parse_tests[i];
+               header = invalid_header_parse_tests[i].header;
+               limits = &invalid_header_parse_tests[i].limits;
                input = i_stream_create_from_data(header, strlen(header));
-               parser = http_header_parser_init(input);
+               parser = http_header_parser_init(input, limits);
 
                test_begin(t_strdup_printf("http header invalid [%d]", i));
 
@@ -255,7 +327,7 @@ static void test_http_header_parse_invalid(void)
                        if (field_name == NULL) break;
                }
 
-               test_out("parse failure", ret < 0);
+               test_out_reason("parse failure", ret < 0, error);
                test_end();
                http_header_parser_deinit(&parser);
        } T_END;

diff --git a/src/lib-http/test-http-response-parser.c b/src/lib-http/test-http-response-parser.c
index faab6fe76bde9a4f88eb990a6839a59f36274a63..f83d352a4573839b2900a7d419dc501b24c6d4ec 100644 (file)
--- a/src/lib-http/test-http-response-parser.c
+++ b/src/lib-http/test-http-response-parser.c
@@ -108,7 +108,7 @@ static void test_http_response_parse_valid(void)
                response_text = test->response;
                response_text_len = strlen(response_text);
                input = test_istream_create_data(response_text, response_text_len);
-               parser = http_response_parser_init(input);
+               parser = http_response_parser_init(input, NULL);
 
                test_begin(t_strdup_printf("http response valid [%d]", i));
 
@@ -196,7 +196,7 @@ static void test_http_response_parse_invalid(void)
                test = invalid_response_parse_tests[i];
                response_text = test;
                input = i_stream_create_from_data(response_text, strlen(response_text));
-               parser = http_response_parser_init(input);
+               parser = http_response_parser_init(input, NULL);
 
                test_begin(t_strdup_printf("http response invalid [%d]", i));
 
@@ -212,7 +212,7 @@ static void test_http_response_parse_invalid(void)
        test_begin("http response with NULs");
        input = i_stream_create_from_data(invalid_response_with_nuls,
                                          sizeof(invalid_response_with_nuls)-1);
-       parser = http_response_parser_init(input);
+       parser = http_response_parser_init(input, 0);
        while ((ret=http_response_parse_next(parser, FALSE, &response, &error)) > 0);
        test_assert(ret < 0);
        test_end();

diff --git a/src/lib-http/test-http-server.c b/src/lib-http/test-http-server.c
index d0f30231ee784be02a7772dff9d779d513650624..29f9b027936fcf4a4c6ce589086d2435169ada97 100644 (file)
--- a/src/lib-http/test-http-server.c
+++ b/src/lib-http/test-http-server.c
@@ -84,7 +84,7 @@ static void client_init(int fd)
        client = i_new(struct client, 1);
        connection_init_server(clients, &client->conn,
                               "(http client)", fd, fd);
-       client->parser = http_request_parser_init(client->conn.input);
+       client->parser = http_request_parser_init(client->conn.input, 0);
 }
 
 static void client_accept(void *context ATTR_UNUSED)