diff options
| -rw-r--r-- | src/nxt_controller.c | 38 | ||||
| -rw-r--r-- | src/nxt_http_parse.c | 327 | ||||
| -rw-r--r-- | src/nxt_http_parse.h | 83 | ||||
| -rw-r--r-- | test/nxt_http_parse_unit_test.c | 199 |
4 files changed, 395 insertions, 252 deletions
diff --git a/src/nxt_controller.c b/src/nxt_controller.c index c8522573..e31e2e15 100644 --- a/src/nxt_controller.c +++ b/src/nxt_controller.c @@ -51,7 +51,7 @@ static void nxt_controller_conn_close(nxt_task_t *task, void *obj, void *data); static void nxt_controller_conn_free(nxt_task_t *task, void *obj, void *data); static nxt_int_t nxt_controller_request_content_length(void *ctx, - nxt_str_t *name, nxt_str_t *value, uintptr_t data); + nxt_http_field_t *field, uintptr_t data, nxt_log_t *log); static void nxt_controller_process_request(nxt_task_t *task, nxt_event_conn_t *c, nxt_controller_request_t *r); @@ -61,14 +61,14 @@ static nxt_buf_t *nxt_controller_response_body(nxt_controller_response_t *resp, nxt_mem_pool_t *pool); -static nxt_http_fields_t nxt_controller_request_fields[] = { +static nxt_http_fields_hash_entry_t nxt_controller_request_fields[] = { { nxt_string("Content-Length"), &nxt_controller_request_content_length, 0 }, { nxt_null_string, NULL, 0 } }; -static nxt_http_fields_hash_t *nxt_controller_request_fields_hash; +static nxt_http_fields_hash_t *nxt_controller_fields_hash; static nxt_controller_conf_t nxt_controller_conf; @@ -90,13 +90,13 @@ nxt_controller_start(nxt_task_t *task, nxt_runtime_t *rt) static const nxt_str_t json = nxt_string("{ \"sockets\": {}, \"applications\": {} }"); - hash = nxt_http_fields_hash(nxt_controller_request_fields, rt->mem_pool); - + hash = nxt_http_fields_hash_create(nxt_controller_request_fields, + rt->mem_pool); if (nxt_slow_path(hash == NULL)) { return NXT_ERROR; } - nxt_controller_request_fields_hash = hash; + nxt_controller_fields_hash = hash; if (nxt_listen_event(task, rt->controller_socket) == NULL) { return NXT_ERROR; @@ -215,8 +215,12 @@ nxt_controller_conn_init(nxt_task_t *task, void *obj, void *data) return; } - r->parser.hash = nxt_controller_request_fields_hash; - r->parser.ctx = r; + if (nxt_slow_path(nxt_http_parse_request_init(&r->parser, c->mem_pool) + != NXT_OK)) + { + nxt_controller_conn_free(task, c, NULL); + return; + } b = nxt_buf_mem_alloc(c->mem_pool, 1024, 0); if (nxt_slow_path(b == NULL)) { @@ -292,6 +296,14 @@ nxt_controller_conn_read(nxt_task_t *task, void *obj, void *data) return; } + rc = nxt_http_fields_process(r->parser.fields, nxt_controller_fields_hash, + r, task->log); + + if (nxt_slow_path(rc != NXT_OK)) { + nxt_controller_conn_close(task, c, r); + return; + } + preread = nxt_buf_mem_used_size(&b->mem); nxt_debug(task, "controller request header parsing complete, " @@ -508,24 +520,24 @@ nxt_controller_conn_free(nxt_task_t *task, void *obj, void *data) static nxt_int_t -nxt_controller_request_content_length(void *ctx, nxt_str_t *name, - nxt_str_t *value, uintptr_t data) +nxt_controller_request_content_length(void *ctx, nxt_http_field_t *field, + uintptr_t data, nxt_log_t *log) { off_t length; nxt_controller_request_t *r; r = ctx; - length = nxt_off_t_parse(value->start, value->length); + length = nxt_off_t_parse(field->value.start, field->value.length); if (nxt_fast_path(length > 0)) { - /* TODO length too big */ + nxt_log_error(NXT_LOG_ERR, log, "Content-Length is too big"); r->length = length; return NXT_OK; } - /* TODO logging (task?) */ + nxt_log_error(NXT_LOG_ERR, log, "Content-Length is invalid"); return NXT_ERROR; } diff --git a/src/nxt_http_parse.c b/src/nxt_http_parse.c index 9424dc8b..3e74461b 100644 --- a/src/nxt_http_parse.c +++ b/src/nxt_http_parse.c @@ -8,29 +8,29 @@ typedef struct { - nxt_http_field_handler_t handler; - uintptr_t data; + nxt_http_fields_hash_entry_t *entry; + union { - uint8_t str[8]; - uint64_t ui64; + uint8_t str[8]; + uint64_t ui64; } key[]; -} nxt_http_fields_hash_entry_t; - - -#define nxt_http_fields_hash_next_entry(entry, n) \ - ((nxt_http_fields_hash_entry_t *) ((u_char *) (entry) \ - + sizeof(nxt_http_fields_hash_entry_t) \ - + n * 8)) +} nxt_http_fields_hash_elt_t; struct nxt_http_fields_hash_s { size_t min_length; size_t max_length; void *long_fields; - nxt_http_fields_hash_entry_t *entries[]; + nxt_http_fields_hash_elt_t *elts[]; }; +#define nxt_http_fields_hash_next_elt(elt, n) \ + ((nxt_http_fields_hash_elt_t *) ((u_char *) (elt) \ + + sizeof(nxt_http_fields_hash_elt_t) \ + + n * 8)) + + static nxt_int_t nxt_http_parse_unusual_target(nxt_http_request_parse_t *rp, u_char **pos, u_char *end); static nxt_int_t nxt_http_parse_request_line(nxt_http_request_parse_t *rp, @@ -43,10 +43,9 @@ static u_char *nxt_http_lookup_field_end(u_char *p, u_char *end); static nxt_int_t nxt_http_parse_field_end(nxt_http_request_parse_t *rp, u_char **pos, u_char *end); -static nxt_http_fields_hash_entry_t *nxt_http_fields_hash_lookup( - nxt_http_fields_hash_t *hash, uint64_t *key, nxt_str_t *value); -static nxt_http_fields_hash_entry_t *nxt_http_header_fields_hash_lookup_long( - nxt_http_fields_hash_t *hash, nxt_str_t *value); + +static nxt_http_fields_hash_entry_t *nxt_http_fields_hash_lookup_long( + nxt_http_fields_hash_t *hash, nxt_http_field_t *field); typedef enum { @@ -427,7 +426,7 @@ nxt_http_parse_field_name(nxt_http_request_parse_t *rp, u_char **pos, p = *pos; size = end - p; - i = rp->offset; + i = rp->field.name.length; #define nxt_http_parse_field_name_step \ { \ @@ -438,7 +437,7 @@ nxt_http_parse_field_name(nxt_http_request_parse_t *rp, u_char **pos, goto name_end; \ } \ \ - rp->field_name_key.str[i % 32] = c; \ + rp->field.key.str[i % 32] = c; \ i++; \ } @@ -460,7 +459,7 @@ nxt_http_parse_field_name(nxt_http_request_parse_t *rp, u_char **pos, #undef nxt_http_parse_field_name_step - rp->offset = i; + rp->field.name.length = i; rp->handler = &nxt_http_parse_field_name; return NXT_AGAIN; @@ -474,10 +473,8 @@ name_end: *pos = &p[i] + 1; - rp->field_name.start = p; - rp->field_name.length = i; - - rp->offset = 0; + rp->field.name.length = i; + rp->field.name.start = p; return nxt_http_parse_field_value(rp, pos, end); } @@ -486,8 +483,6 @@ name_end: return NXT_ERROR; } - rp->field_name.length = 0; - return nxt_http_parse_field_end(rp, pos, end); } @@ -516,13 +511,13 @@ nxt_http_parse_field_value(nxt_http_request_parse_t *rp, u_char **pos, *pos = p; - p += rp->offset; + p += rp->field.value.length; for ( ;; ) { p = nxt_http_lookup_field_end(p, end); if (nxt_slow_path(p == end)) { - rp->offset = p - *pos; + rp->field.value.length = p - *pos; rp->handler = &nxt_http_parse_field_value; return NXT_AGAIN; } @@ -544,10 +539,8 @@ nxt_http_parse_field_value(nxt_http_request_parse_t *rp, u_char **pos, } } - rp->offset = 0; - - rp->field_value.start = *pos; - rp->field_value.length = p - *pos; + rp->field.value.length = p - *pos; + rp->field.value.start = *pos; *pos = p; @@ -624,9 +617,8 @@ static nxt_int_t nxt_http_parse_field_end(nxt_http_request_parse_t *rp, u_char **pos, u_char *end) { - u_char *p; - nxt_int_t rc; - nxt_http_fields_hash_entry_t *entry; + u_char *p; + nxt_http_field_t *field; p = *pos; @@ -642,21 +634,16 @@ nxt_http_parse_field_end(nxt_http_request_parse_t *rp, u_char **pos, if (nxt_fast_path(*p == '\n')) { *pos = p + 1; - if (rp->field_name.length != 0) { - entry = nxt_http_fields_hash_lookup(rp->hash, - rp->field_name_key.ui64, - &rp->field_name); + if (rp->field.name.length != 0) { + field = nxt_list_add(rp->fields); - if (entry != NULL) { - rc = entry->handler(rp->ctx, &rp->field_name, &rp->field_value, - entry->data); - - if (nxt_slow_path(rc != NXT_OK)) { - return NXT_ERROR; - } + if (nxt_slow_path(field == NULL)) { + return NXT_ERROR; } - nxt_memzero(rp->field_name_key.str, 32); + *field = rp->field; + + nxt_memzero(&rp->field, sizeof(nxt_http_field_t)); rp->handler = &nxt_http_parse_field_name; return NXT_OK; @@ -669,85 +656,175 @@ nxt_http_parse_field_end(nxt_http_request_parse_t *rp, u_char **pos, } -static nxt_http_fields_hash_entry_t * -nxt_http_fields_hash_lookup(nxt_http_fields_hash_t *hash, uint64_t *key, - nxt_str_t *value) +nxt_http_fields_hash_t * +nxt_http_fields_hash_create(nxt_http_fields_hash_entry_t *entries, + nxt_mem_pool_t *mp) { - nxt_http_fields_hash_entry_t *entry; + size_t min_length, max_length, length, size; + nxt_uint_t i, j, n; + nxt_http_fields_hash_t *hash; + nxt_http_fields_hash_elt_t *elt; - if (hash == NULL || value->length < hash->min_length) { + min_length = 32 + 1; + max_length = 0; + + for (i = 0; entries[i].handler != NULL; i++) { + length = entries[i].name.length; + + if (length > 32) { + /* TODO */ + return NULL; + } + + min_length = nxt_min(length, min_length); + max_length = nxt_max(length, max_length); + } + + size = sizeof(nxt_http_fields_hash_t); + + if (min_length <= 32) { + size += (max_length - min_length + 1) + * sizeof(nxt_http_fields_hash_elt_t *); + } + + hash = nxt_mem_zalloc(mp, size); + if (nxt_slow_path(hash == NULL)) { return NULL; } - if (value->length > hash->max_length) { - if (value->length > 32 && hash->long_fields != NULL) { - return nxt_http_header_fields_hash_lookup_long(hash, value); + hash->min_length = min_length; + hash->max_length = max_length; + + for (i = 0; entries[i].handler != NULL; i++) { + length = entries[i].name.length; + elt = hash->elts[length - min_length]; + + if (elt != NULL) { + continue; + } + + n = 1; + + for (j = i + 1; entries[j].handler != NULL; j++) { + if (length == entries[j].name.length) { + n++; + } + } + + size = sizeof(nxt_http_fields_hash_elt_t) + nxt_align_size(length, 8); + + elt = nxt_mem_zalloc(mp, n * size + + sizeof(nxt_http_fields_hash_elt_t)); + + if (nxt_slow_path(elt == NULL)) { + return NULL; } + hash->elts[length - min_length] = elt; + + for (j = i; entries[j].handler != NULL; j++) { + if (length != entries[j].name.length) { + continue; + } + + elt->entry = &entries[j]; + + nxt_memcpy_lowcase(elt->key->str, entries[j].name.start, length); + + n--; + + if (n == 0) { + break; + } + + elt = (nxt_http_fields_hash_elt_t *) ((u_char *) elt + size); + } + } + + return hash; +} + + +nxt_http_fields_hash_entry_t * +nxt_http_fields_hash_lookup(nxt_http_fields_hash_t *hash, + nxt_http_field_t *field) +{ + nxt_http_fields_hash_elt_t *elt; + + if (field->name.length < hash->min_length) { return NULL; } - entry = hash->entries[value->length - hash->min_length]; + if (field->name.length > hash->max_length) { + + if (field->name.length > 32 && hash->long_fields != NULL) { + return nxt_http_fields_hash_lookup_long(hash, field); + } - if (entry == NULL) { return NULL; } - switch ((value->length + 7) / 8) { + elt = hash->elts[field->name.length - hash->min_length]; + + if (elt == NULL) { + return NULL; + } + + switch ((field->name.length + 7) / 8) { case 1: do { - if (entry->key[0].ui64 == key[0]) { - return entry; + if (elt->key[0].ui64 == field->key.ui64[0]) { + return elt->entry; } - entry = nxt_http_fields_hash_next_entry(entry, 1); + elt = nxt_http_fields_hash_next_elt(elt, 1); - } while (entry->handler != NULL); + } while (elt->entry != NULL); break; case 2: do { - if (entry->key[0].ui64 == key[0] - && entry->key[1].ui64 == key[1]) + if (elt->key[0].ui64 == field->key.ui64[0] + && elt->key[1].ui64 == field->key.ui64[1]) { - return entry; + return elt->entry; } - entry = nxt_http_fields_hash_next_entry(entry, 2); + elt = nxt_http_fields_hash_next_elt(elt, 2); - } while (entry->handler != NULL); + } while (elt->entry != NULL); break; case 3: do { - if (entry->key[0].ui64 == key[0] - && entry->key[1].ui64 == key[1] - && entry->key[2].ui64 == key[2]) + if (elt->key[0].ui64 == field->key.ui64[0] + && elt->key[1].ui64 == field->key.ui64[1] + && elt->key[2].ui64 == field->key.ui64[2]) { - return entry; + return elt->entry; } - entry = nxt_http_fields_hash_next_entry(entry, 3); + elt = nxt_http_fields_hash_next_elt(elt, 3); - } while (entry->handler != NULL); + } while (elt->entry != NULL); break; case 4: do { - if (entry->key[0].ui64 == key[0] - && entry->key[1].ui64 == key[1] - && entry->key[2].ui64 == key[2] - && entry->key[3].ui64 == key[3]) + if (elt->key[0].ui64 == field->key.ui64[0] + && elt->key[1].ui64 == field->key.ui64[1] + && elt->key[2].ui64 == field->key.ui64[2] + && elt->key[3].ui64 == field->key.ui64[3]) { - return entry; + return elt->entry; } - entry = nxt_http_fields_hash_next_entry(entry, 4); + elt = nxt_http_fields_hash_next_elt(elt, 4); - } while (entry->handler != NULL); + } while (elt->entry != NULL); break; @@ -760,98 +837,34 @@ nxt_http_fields_hash_lookup(nxt_http_fields_hash_t *hash, uint64_t *key, static nxt_http_fields_hash_entry_t * -nxt_http_header_fields_hash_lookup_long(nxt_http_fields_hash_t *hash, - nxt_str_t *value) +nxt_http_fields_hash_lookup_long(nxt_http_fields_hash_t *hash, + nxt_http_field_t *field) { /* TODO */ return NULL; } -nxt_http_fields_hash_t * -nxt_http_fields_hash(nxt_http_fields_t *fields, nxt_mem_pool_t *mp) +nxt_int_t +nxt_http_fields_process(nxt_list_t *fields, nxt_http_fields_hash_t *hash, + void *ctx, nxt_log_t *log) { - size_t min_length, max_length, length, size; - nxt_uint_t i, j, n; - nxt_http_fields_hash_t *hash; + nxt_int_t rc; + nxt_http_field_t *field; nxt_http_fields_hash_entry_t *entry; - min_length = 32 + 1; - max_length = 0; - - for (i = 0; fields[i].handler != NULL; i++) { - length = fields[i].name.length; - - if (length > 32) { - /* TODO */ - return NULL; - } - - min_length = nxt_min(length, min_length); - max_length = nxt_max(length, max_length); - } - - size = sizeof(nxt_http_fields_hash_t); - - if (min_length <= 32) { - size += (max_length - min_length + 1) - * sizeof(nxt_http_fields_hash_entry_t *); - } - - hash = nxt_mem_zalloc(mp, size); - if (nxt_slow_path(hash == NULL)) { - return NULL; - } - - hash->min_length = min_length; - hash->max_length = max_length; - - for (i = 0; fields[i].handler != NULL; i++) { - length = fields[i].name.length; - entry = hash->entries[length - min_length]; + nxt_list_each(field, fields) { + entry = nxt_http_fields_hash_lookup(hash, field); if (entry != NULL) { - continue; - } - - n = 1; + rc = entry->handler(ctx, field, entry->data, log); - for (j = i + 1; fields[j].handler != NULL; j++) { - if (length == fields[j].name.length) { - n++; + if (rc != NXT_OK) { + return rc; } } - size = sizeof(nxt_http_fields_hash_entry_t) + nxt_align_size(length, 8); - - entry = nxt_mem_zalloc(mp, n * size - + sizeof(nxt_http_fields_hash_entry_t)); - - if (nxt_slow_path(entry == NULL)) { - return NULL; - } - - hash->entries[length - min_length] = entry; - - for (j = i; fields[j].handler != NULL; j++) { - if (length != fields[j].name.length) { - continue; - } - - entry->handler = fields[j].handler; - entry->data = fields[j].data; - - nxt_memcpy_lowcase(entry->key->str, fields[j].name.start, length); - - n--; + } nxt_list_loop; - if (n == 0) { - break; - } - - entry = (nxt_http_fields_hash_entry_t *) ((u_char *) entry + size); - } - } - - return hash; + return NXT_OK; } diff --git a/src/nxt_http_parse.h b/src/nxt_http_parse.h index 2376855e..4cf3dc3c 100644 --- a/src/nxt_http_parse.h +++ b/src/nxt_http_parse.h @@ -11,64 +11,87 @@ typedef struct nxt_http_request_parse_s nxt_http_request_parse_t; typedef struct nxt_http_fields_hash_s nxt_http_fields_hash_t; -typedef nxt_int_t (*nxt_http_field_handler_t)(void *ctx, nxt_str_t *name, - nxt_str_t *value, uintptr_t data); - typedef union { - u_char str[8]; - uint64_t ui64; + u_char str[8]; + uint64_t ui64; } nxt_http_ver_t; -struct nxt_http_request_parse_s { - nxt_int_t (*handler)(nxt_http_request_parse_t *rp, - u_char **pos, u_char *end); +typedef struct { + union { + uint8_t str[32]; + uint64_t ui64[4]; + } key; - size_t offset; + nxt_str_t name; + nxt_str_t value; +} nxt_http_field_t; - nxt_str_t method; - u_char *target_start; - u_char *target_end; - u_char *exten_start; - u_char *args_start; +struct nxt_http_request_parse_s { + nxt_int_t (*handler)(nxt_http_request_parse_t *rp, + u_char **pos, u_char *end); - nxt_http_ver_t version; + size_t offset; - union { - uint8_t str[32]; - uint64_t ui64[4]; - } field_name_key; + nxt_str_t method; + + u_char *target_start; + u_char *target_end; + u_char *exten_start; + u_char *args_start; - nxt_str_t field_name; - nxt_str_t field_value; + nxt_http_ver_t version; - nxt_http_fields_hash_t *hash; - void *ctx; + nxt_http_field_t field; + nxt_list_t *fields; /* target with "/." */ - unsigned complex_target:1; + unsigned complex_target:1; /* target with "%" */ - unsigned quoted_target:1; + unsigned quoted_target:1; /* target with " " */ - unsigned space_in_target:1; + unsigned space_in_target:1; /* target with "+" */ - unsigned plus_in_target:1; + unsigned plus_in_target:1; }; +typedef nxt_int_t (*nxt_http_field_handler_t)(void *ctx, + nxt_http_field_t *field, + uintptr_t data, nxt_log_t *log); + + typedef struct { nxt_str_t name; nxt_http_field_handler_t handler; uintptr_t data; -} nxt_http_fields_t; +} nxt_http_fields_hash_entry_t; + + +nxt_inline nxt_int_t +nxt_http_parse_request_init(nxt_http_request_parse_t *rp, nxt_mem_pool_t *mp) +{ + rp->fields = nxt_list_create(mp, 8, sizeof(nxt_http_field_t)); + if (nxt_slow_path(rp->fields == NULL)){ + return NXT_ERROR; + } + + return NXT_OK; +} nxt_int_t nxt_http_parse_request(nxt_http_request_parse_t *rp, nxt_buf_mem_t *b); -nxt_http_fields_hash_t *nxt_http_fields_hash(nxt_http_fields_t *fields, - nxt_mem_pool_t *mp); + +nxt_http_fields_hash_t *nxt_http_fields_hash_create( + nxt_http_fields_hash_entry_t *entries, nxt_mem_pool_t *mp); +nxt_http_fields_hash_entry_t *nxt_http_fields_hash_lookup( + nxt_http_fields_hash_t *hash, nxt_http_field_t *field); + +nxt_int_t nxt_http_fields_process(nxt_list_t *fields, + nxt_http_fields_hash_t *hash, void *ctx, nxt_log_t *log); #endif /* _NXT_HTTP_PARSER_H_INCLUDED_ */ diff --git a/test/nxt_http_parse_unit_test.c b/test/nxt_http_parse_unit_test.c index 2bc974db..f2b5ac96 100644 --- a/test/nxt_http_parse_unit_test.c +++ b/test/nxt_http_parse_unit_test.c @@ -25,8 +25,15 @@ typedef struct { } nxt_http_parse_unit_test_request_line_t; +typedef struct { + nxt_http_fields_hash_entry_t *entries; + nxt_int_t result; +} nxt_http_parse_unit_test_fields_t; + + typedef union { void *pointer; + nxt_http_parse_unit_test_fields_t fields; nxt_http_parse_unit_test_request_line_t request_line; } nxt_http_parse_unit_test_data_t; @@ -50,11 +57,26 @@ static nxt_int_t nxt_http_parse_unit_test_bench(nxt_thread_t *thr, static nxt_int_t nxt_http_parse_unit_test_request_line( nxt_http_request_parse_t *rp, nxt_http_parse_unit_test_data_t *data, nxt_str_t *request, nxt_log_t *log); +static nxt_int_t nxt_http_parse_unit_test_fields( + nxt_http_request_parse_t *rp, nxt_http_parse_unit_test_data_t *data, + nxt_str_t *request, nxt_log_t *log); + + +static nxt_int_t nxt_http_unit_test_header_return(void *ctx, nxt_http_field_t *field, + uintptr_t data, nxt_log_t *log); + + +static nxt_http_fields_hash_entry_t nxt_http_unit_test_fields[] = { + { nxt_string("X-Bad-Header"), + &nxt_http_unit_test_header_return, + (uintptr_t) NXT_ERROR }, -static nxt_int_t nxt_http_unit_test_header_return(void *ctx, nxt_str_t *name, - nxt_str_t *value, uintptr_t data); -static nxt_int_t nxt_http_unit_test_header_dump(void *ctx, nxt_str_t *name, - nxt_str_t *value, uintptr_t data); + { nxt_string("X-Good-Header"), + &nxt_http_unit_test_header_return, + (uintptr_t) NXT_OK }, + + { nxt_null_string, NULL, 0 } +}; static nxt_http_parse_unit_test_case_t nxt_http_unit_test_cases[] = { @@ -269,36 +291,57 @@ static nxt_http_parse_unit_test_case_t nxt_http_unit_test_cases[] = { }, { nxt_string("GET / HTTP/1.1\r\n" + "X-Unknown-Header: value\r\n" + "X-Good-Header: value\r\n\r\n"), + NXT_DONE, + &nxt_http_parse_unit_test_fields, + { .fields = { + nxt_http_unit_test_fields, + NXT_OK + }} + }, + { + nxt_string("GET / HTTP/1.1\r\n" + "X-Good-Header: value\r\n" + "X-Unknown-Header: value\r\n" "X-Bad-Header: value\r\n\r\n"), - NXT_ERROR, - NULL, { NULL } + NXT_DONE, + &nxt_http_parse_unit_test_fields, + { .fields = { + nxt_http_unit_test_fields, + NXT_ERROR + }} }, }; -static nxt_http_fields_t nxt_http_unit_test_headers[] = { - { nxt_string("X-Bad-Header"), - &nxt_http_unit_test_header_return, - (uintptr_t) NXT_ERROR }, - - { nxt_null_string, NULL, 0 } -}; - - -static nxt_http_fields_t nxt_http_unit_test_bench_headers[] = { - { nxt_string("Host"), &nxt_http_unit_test_header_dump, 0 }, - { nxt_string("User-Agent"), &nxt_http_unit_test_header_dump, 0 }, - { nxt_string("Accept-Encoding"), &nxt_http_unit_test_header_dump, 0 }, - { nxt_string("Accept-Language"), &nxt_http_unit_test_header_dump, 0 }, - { nxt_string("Connection"), &nxt_http_unit_test_header_dump, 0 }, - { nxt_string("Content-Length"), &nxt_http_unit_test_header_dump, 0 }, - { nxt_string("Content-Type"), &nxt_http_unit_test_header_dump, 0 }, - { nxt_string("If-Modified-Since"), &nxt_http_unit_test_header_dump, 0 }, - { nxt_string("If-Match"), &nxt_http_unit_test_header_dump, 0 }, - { nxt_string("Date"), &nxt_http_unit_test_header_dump, 0 }, - { nxt_string("Upgrade"), &nxt_http_unit_test_header_dump, 0 }, - { nxt_string("X-Forwarded-For"), &nxt_http_unit_test_header_dump, 0 }, - { nxt_string("X-Request-ID"), &nxt_http_unit_test_header_dump, 0 }, +static nxt_http_fields_hash_entry_t nxt_http_unit_test_bench_fields[] = { + { nxt_string("Host"), + &nxt_http_unit_test_header_return, NXT_OK }, + { nxt_string("User-Agent"), + &nxt_http_unit_test_header_return, NXT_OK }, + { nxt_string("Accept-Encoding"), + &nxt_http_unit_test_header_return, NXT_OK }, + { nxt_string("Accept-Language"), + &nxt_http_unit_test_header_return, NXT_OK }, + { nxt_string("Connection"), + &nxt_http_unit_test_header_return, NXT_OK }, + { nxt_string("Content-Length"), + &nxt_http_unit_test_header_return, NXT_OK }, + { nxt_string("Content-Type"), + &nxt_http_unit_test_header_return, NXT_OK }, + { nxt_string("If-Modified-Since"), + &nxt_http_unit_test_header_return, NXT_OK }, + { nxt_string("If-Match"), + &nxt_http_unit_test_header_return, NXT_OK }, + { nxt_string("Date"), + &nxt_http_unit_test_header_return, NXT_OK }, + { nxt_string("Upgrade"), + &nxt_http_unit_test_header_return, NXT_OK }, + { nxt_string("X-Forwarded-For"), + &nxt_http_unit_test_header_return, NXT_OK }, + { nxt_string("X-Request-ID"), + &nxt_http_unit_test_header_return, NXT_OK }, { nxt_null_string, NULL, 0 } }; @@ -387,30 +430,26 @@ nxt_http_parse_unit_test(nxt_thread_t *thr) { nxt_int_t rc; nxt_uint_t i; - nxt_mem_pool_t *pool; + nxt_mem_pool_t *mp; nxt_http_fields_hash_t *hash; nxt_http_request_parse_t rp; nxt_http_parse_unit_test_case_t *test; nxt_thread_time_update(thr); - pool = nxt_mem_pool_create(512); - if (pool == NULL) { - return NXT_ERROR; - } - - hash = nxt_http_fields_hash(nxt_http_unit_test_headers, pool); - - if (hash == NULL) { - return NXT_ERROR; - } - for (i = 0; i < nxt_nitems(nxt_http_unit_test_cases); i++) { test = &nxt_http_unit_test_cases[i]; nxt_memzero(&rp, sizeof(nxt_http_request_parse_t)); - rp.hash = hash; + mp = nxt_mem_pool_create(512); + if (mp == NULL) { + return NXT_ERROR; + } + + if (nxt_http_parse_request_init(&rp, mp) != NXT_OK) { + return NXT_ERROR; + } rc = nxt_http_parse_unit_test_run(&rp, &test->request); @@ -428,12 +467,18 @@ nxt_http_parse_unit_test(nxt_thread_t *thr) { return NXT_ERROR; } + + nxt_mem_pool_destroy(mp); } nxt_log_error(NXT_LOG_NOTICE, thr->log, "http parse unit test passed"); - hash = nxt_http_fields_hash(nxt_http_unit_test_bench_headers, pool); + mp = nxt_mem_pool_create(512); + if (mp == NULL) { + return NXT_ERROR; + } + hash = nxt_http_fields_hash_create(nxt_http_unit_test_bench_fields, mp); if (hash == NULL) { return NXT_ERROR; } @@ -452,7 +497,7 @@ nxt_http_parse_unit_test(nxt_thread_t *thr) return NXT_ERROR; } - nxt_mem_pool_destroy(pool); + nxt_mem_pool_destroy(mp); return NXT_OK; } @@ -486,6 +531,7 @@ nxt_http_parse_unit_test_bench(nxt_thread_t *thr, nxt_str_t *request, nxt_nsec_t start, end; nxt_uint_t i; nxt_buf_mem_t buf; + nxt_mem_pool_t *mp; nxt_http_request_parse_t rp; nxt_log_error(NXT_LOG_NOTICE, thr->log, @@ -502,14 +548,34 @@ nxt_http_parse_unit_test_bench(nxt_thread_t *thr, nxt_str_t *request, for (i = 0; nxt_fast_path(i < n); i++) { nxt_memzero(&rp, sizeof(nxt_http_request_parse_t)); + mp = nxt_mem_pool_create(512); + if (nxt_slow_path(mp == NULL)) { + return NXT_ERROR; + } + + if (nxt_slow_path(nxt_http_parse_request_init(&rp, mp) != NXT_OK)) { + return NXT_ERROR; + } + buf.pos = buf.start; buf.free = buf.end; if (nxt_slow_path(nxt_http_parse_request(&rp, &buf) != NXT_DONE)) { - nxt_log_alert(thr->log, "http parse unit %s request bench failed", - name); + nxt_log_alert(thr->log, "http parse unit %s request bench failed " + "while parsing", name); return NXT_ERROR; } + + if (nxt_slow_path(nxt_http_fields_process(rp.fields, hash, NULL, + thr->log) + != NXT_OK)) + { + nxt_log_alert(thr->log, "http parse unit %s request bench failed " + "while fields processing", name); + return NXT_ERROR; + } + + nxt_mem_pool_destroy(mp); } nxt_thread_time_update(thr); @@ -627,16 +693,45 @@ nxt_http_parse_unit_test_request_line(nxt_http_request_parse_t *rp, static nxt_int_t -nxt_http_unit_test_header_return(void *ctx, nxt_str_t *name, nxt_str_t *value, - uintptr_t data) +nxt_http_parse_unit_test_fields(nxt_http_request_parse_t *rp, + nxt_http_parse_unit_test_data_t *data, nxt_str_t *request, nxt_log_t *log) { - return (nxt_int_t) data; + nxt_int_t rc; + nxt_mem_pool_t *mp; + nxt_http_fields_hash_t *hash; + + nxt_http_parse_unit_test_fields_t *test = &data->fields; + + mp = nxt_mem_pool_create(256); + if (mp == NULL) { + return NXT_ERROR; + } + + hash = nxt_http_fields_hash_create(test->entries, mp); + if (hash == NULL) { + nxt_log_alert(log, "unable to create hash"); + return NXT_ERROR; + } + + rc = nxt_http_fields_process(rp->fields, hash, NULL, log); + + if (rc != test->result) { + nxt_log_alert(log, "http parse unit test hash failed:\n" + " - request:\n\"%V\"\n" + " - result: %i (expected: %i)", + request, rc, test->result); + return NXT_ERROR; + } + + nxt_mem_pool_destroy(mp); + + return NXT_OK; } static nxt_int_t -nxt_http_unit_test_header_dump(void *ctx, nxt_str_t *name, nxt_str_t *value, - uintptr_t data) +nxt_http_unit_test_header_return(void *ctx, nxt_http_field_t *field, + uintptr_t data, nxt_log_t *log) { - return NXT_OK; + return (nxt_int_t) data; } |