Fijxu
/
nginx-quic
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

nginx-0.0.1-2002-09-13-18:47:42 import

This commit is contained in:
Igor Sysoev 2002-09-13 14:47:42 +00:00
parent c9c73c364f
commit 3eabdc1c9c
5 changed files with 158 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
src/event/modules/ngx_kqueue_module.c
View File

@ -34,9 +34,10 @@ void ngx_kqueue_init(int max_connections, ngx_log_t *log)
nchanges = 0;
nevents = 512;
if ((kq = kqueue()) == -1) {
ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
"kqueue() failed");
kq = kqueue();
if (kq == -1) {
ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "kqueue() failed");
exit(1);
}
@ -52,7 +53,6 @@ void ngx_kqueue_init(int max_connections, ngx_log_t *log)
ngx_event_actions.timer = ngx_kqueue_add_timer;
ngx_event_actions.process = ngx_kqueue_process_events;
#endif
}
int ngx_kqueue_add_event(ngx_event_t *ev, int event, u_int flags)
@ -72,7 +72,7 @@ int ngx_kqueue_set_event(ngx_event_t *ev, int filter, u_int flags)
struct timespec ts = { 0, 0 };
ngx_connection_t *cn = (ngx_connection_t *) ev->data;
ngx_log_debug(ev->log, "ngx_kqueue_set_event: %d: ft:%d f:%08x" _
ngx_log_debug(ev->log, "kqueue set event: %d: ft:%d f:%08x" _
cn->fd _ filter _ flags);
if (nchanges >= nevents) {
@ -80,9 +80,8 @@ int ngx_kqueue_set_event(ngx_event_t *ev, int filter, u_int flags)
"ngx_kqueue_set_event: change list is filled up");
if (kevent(kq, change_list, nchanges, NULL, 0, &ts) == -1) {
ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
"ngx_kqueue_set_event: kevent failed");
return -1;
ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno, "kevent failed");
return NGX_ERROR;
}
nchanges = 0;
}
@ -95,7 +94,7 @@ int ngx_kqueue_set_event(ngx_event_t *ev, int filter, u_int flags)
change_list[nchanges].udata = ev;
nchanges++;
return 0;
return NGX_OK;
}
int ngx_kqueue_process_events(ngx_log_t *log)
@ -115,13 +114,12 @@ int ngx_kqueue_process_events(ngx_log_t *log)
delta = tv.tv_sec * 1000 + tv.tv_usec / 1000;
}
ngx_log_debug(log, "ngx_kqueue_process_events: timer: %d" _ timer);
ngx_log_debug(log, "kevent timer: %d" _ timer);
if ((events = kevent(kq, change_list, nchanges, event_list, nevents, tp))
== -1) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
"ngx_kqueue_process_events: kevent failed");
return -1;
events = kevent(kq, change_list, nchanges, event_list, nevents, tp);
if (events == -1) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno, "kevent failed");
return NGX_ERROR;
}
nchanges = 0;
@ -131,13 +129,11 @@ int ngx_kqueue_process_events(ngx_log_t *log)
delta = tv.tv_sec * 1000 + tv.tv_usec / 1000 - delta;
} else {
ngx_assert((events != 0), return -1, log,
"ngx_kqueue_process_events: "
ngx_assert((events != 0), return NGX_ERROR, log,
"kevent returns no events without timeout");
}
ngx_log_debug(log, "ngx_kqueue_process_events: "
"timer: %d, delta: %d" _ timer _ delta);
ngx_log_debug(log, "kevent timer: %d, delta: %d" _ timer _ delta);
if (timer) {
if (delta >= timer) {
@ -161,16 +157,14 @@ int ngx_kqueue_process_events(ngx_log_t *log)
for (i = 0; i < events; i++) {
ngx_log_debug(log, "ngx_kqueue_process_events: kevent: "
"%d: ft:%d f:%08x ff:%08x d:%d ud:%08x" _
ngx_log_debug(log, "kevent: %d: ft:%d f:%08x ff:%08x d:%d ud:%08x" _
event_list[i].ident _ event_list[i].filter _
event_list[i].flags _ event_list[i].fflags _
event_list[i].data _ event_list[i].udata);
if (event_list[i].flags & EV_ERROR) {
ngx_log_error(NGX_LOG_ALERT, log, event_list[i].data,
"ngx_kqueue_process_events: kevent error on %d",
event_list[i].ident);
"kevent error on %d", event_list[i].ident);
continue;
}
@ -198,12 +192,11 @@ int ngx_kqueue_process_events(ngx_log_t *log)
default:
ngx_assert(0, /* void */, log,
"ngx_kqueue_process_events: unknown filter %d" _
event_list[i].filter);
"unknown kevent filter %d" _ event_list[i].filter);
}
}
return 0;
return NGX_OK;
}
void ngx_kqueue_add_timer(ngx_event_t *ev, ngx_msec_t timer)

16
src/http/ngx_http.h
View File

@ -18,11 +18,12 @@
#define NGX_HTTP_CONN_KEEP_ALIVE 1
#define NGX_HTTP_HEADER_DONE 1
#define NGX_HTTP_INVALID_METHOD 10
#define NGX_HTTP_INVALID_REQUEST 11
#define NGX_HTTP_INVALID_HEAD 12
#define NGX_HTTP_INVALID_HEADER 13
#define NGX_HTTP_PARSE_HEADER_DONE 1
#define NGX_HTTP_PARSE_INVALID_METHOD 10
#define NGX_HTTP_PARSE_INVALID_REQUEST 11
#define NGX_HTTP_PARSE_TOO_LONG_URI 12
#define NGX_HTTP_PARSE_INVALID_HEAD 13
#define NGX_HTTP_PARSE_INVALID_HEADER 14
#define NGX_HTTP_OK 200
@ -30,6 +31,7 @@
#define NGX_HTTP_MOVED_PERMANENTLY 302
#define NGX_HTTP_BAD_REQUEST 400
#define NGX_HTTP_NOT_FOUND 404
#define NGX_HTTP_REQUEST_URI_TOO_LARGE 414
#define NGX_HTTP_INTERNAL_SERVER_ERROR 503
@ -116,8 +118,10 @@ struct ngx_http_request_s {
unsigned keepalive:1;
unsigned lingering_close:1;
unsigned header_timeout:1;
unsigned process_header:1;
unsigned header_timeout:1;
unsigned logging:1;
unsigned header_only:1;
unsigned unusual_uri:1;

185
src/http/ngx_http_event.c
View File

@ -1,3 +1,7 @@
/*
TODO Win32 inet_ntoa
ngx_inet_ntop
*/
#include <ngx_config.h>
#include <ngx_core.h>
@ -36,7 +40,7 @@ static int ngx_http_handler(ngx_http_request_t *r);
static int ngx_http_set_default_handler(ngx_http_request_t *r);
static int ngx_http_writer(ngx_event_t *ev);
static int ngx_http_keepalive_handler(ngx_event_t *ev);
static int ngx_http_lingering_close(ngx_event_t *ev);
static int ngx_http_special_response(ngx_http_request_t *r, int error);
@ -47,13 +51,11 @@ static int ngx_http_close_request(ngx_http_request_t *r);
static size_t ngx_http_log_error(void *data, char *buf, size_t len);
/* STUB */
static int ngx_http_writer(ngx_event_t *ev);
static char *header_errors[] = {
"client %s sent invalid method",
"client %s sent invalid request",
"client %s sent too long URI",
"client %s sent HEAD method in HTTP/0.9 request"
};
@ -68,8 +70,9 @@ int ngx_http_init_connection(ngx_connection_t *c)
ev = c->read;
ev->event_handler = ngx_http_init_request;
/* TODO: connection's pool size */
ngx_test_null(c->pool, ngx_create_pool(1024, ev->log), NGX_ERROR);
ngx_test_null(c->pool,
ngx_create_pool(srv->connection_pool_size, ev->log),
NGX_ERROR);
ngx_test_null(addr, ngx_palloc(c->pool, c->socklen), NGX_ERROR);
ngx_memcpy(addr, c->sockaddr, c->socklen);
@ -78,10 +81,7 @@ int ngx_http_init_connection(ngx_connection_t *c)
ngx_test_null(c->addr_text, ngx_palloc(c->pool, c->addr_textlen),
NGX_ERROR);
#if (WIN32)
/*
c->addr_text = inet_ntoa((struct in_addr) ((char *)c->sockaddr + c->addr));
*/
c->addr_text = NULL;
#else
inet_ntop(c->family, (char *)c->sockaddr + c->addr,
c->addr_text, c->addr_textlen);
@ -121,7 +121,7 @@ int ngx_http_init_connection(ngx_connection_t *c)
}
int ngx_http_init_request(ngx_event_t *ev)
static int ngx_http_init_request(ngx_event_t *ev)
{
ngx_connection_t *c;
ngx_http_server_t *srv;
@ -130,12 +130,22 @@ int ngx_http_init_request(ngx_event_t *ev)
c = (ngx_connection_t *) ev->data;
srv = (ngx_http_server_t *) c->server;
if (c->buffer == NULL) {
ngx_test_null(c->buffer,
ngx_create_temp_hunk(c->pool, srv->header_buffer_size,
0, 0),
NGX_ERROR);
} else {
c->buffer->pos.mem = c->buffer->last.mem = c->buffer->start;
}
ngx_test_null(r, ngx_pcalloc(c->pool, sizeof(ngx_http_request_t)),
NGX_ERROR);
c->data = r;
r->connection = c;
r->server = srv;
r->header_in = c->buffer;
r->srv_conf = ngx_srv_conf;
r->loc_conf = ngx_loc_conf;
@ -146,13 +156,10 @@ int ngx_http_init_request(ngx_event_t *ev)
ngx_test_null(r->ctx, ngx_pcalloc(r->pool, sizeof(void *) * ngx_max_module),
ngx_http_close_request(r));
ngx_test_null(r->header_in,
ngx_create_temp_hunk(r->pool, srv->header_buffer_size, 0, 0),
ngx_http_close_request(r));
ev->event_handler = ngx_http_process_request;
r->state_handler = ngx_http_process_request_line;
r->process_header = 1;
r->header_timeout = 1;
return ngx_http_process_request(ev);
}
@ -163,6 +170,7 @@ static int ngx_http_process_request(ngx_event_t *ev)
int n, rc;
ngx_connection_t *c ;
ngx_http_request_t *r;
ngx_http_log_ctx_t *ctx;
c = (ngx_connection_t *) ev->data;
r = (ngx_http_request_t *) c->data;
@ -173,8 +181,8 @@ static int ngx_http_process_request(ngx_event_t *ev)
r->header_in->end - r->header_in->last.mem);
if (n == NGX_AGAIN) {
if (!r->header_timeout) {
r->header_timeout = 1;
if (r->header_timeout) {
r->header_timeout = 0;
ngx_del_timer(ev);
ngx_add_timer(ev, r->server->header_timeout);
}
@ -210,8 +218,8 @@ static int ngx_http_process_request(ngx_event_t *ev)
} while (r->process_header
&& r->header_in->pos.mem < r->header_in->last.mem);
if (!r->header_timeout) {
r->header_timeout = 1;
if (r->header_timeout) {
r->header_timeout = 0;
ngx_del_timer(ev);
ngx_add_timer(ev, r->server->header_timeout);
}
@ -219,6 +227,7 @@ static int ngx_http_process_request(ngx_event_t *ev)
return rc;
}
static int ngx_http_process_request_line(ngx_http_request_t *r)
{
int rc;
@ -238,6 +247,8 @@ static int ngx_http_process_request_line(ngx_http_request_t *r)
if (r->http_version == 9)
return ngx_http_handler(r);
/* TODO: check too long URI - no space for header, compact buffer */
r->state_handler = ngx_http_process_request_header;
ctx = r->connection->log->data;
ctx->action = "reading client request headers";
@ -245,15 +256,26 @@ static int ngx_http_process_request_line(ngx_http_request_t *r)
return NGX_OK;
}
if (r->header_in->last.mem >= r->header_in->end) {
rc == NGX_HTTP_PARSE_TOO_LONG_URI;
} else if (rc == NGX_AGAIN) {
return NGX_AGAIN;
}
ctx = r->connection->log->data;
r->connection->log->handler = NULL;
ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
header_errors[rc - NGX_HTTP_INVALID_METHOD], ctx->client);
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
header_errors[rc - NGX_HTTP_PARSE_INVALID_METHOD],
ctx->client);
r->connection->log->handler = ngx_http_log_error;
return ngx_http_error(r, NGX_HTTP_BAD_REQUEST);
return ngx_http_error(r, (rc == NGX_HTTP_PARSE_TOO_LONG_URI) ?
NGX_HTTP_REQUEST_URI_TOO_LARGE:
NGX_HTTP_BAD_REQUEST);
}
static int ngx_http_process_request_header(ngx_http_request_t *r)
{
int rc;
@ -262,21 +284,23 @@ static int ngx_http_process_request_header(ngx_http_request_t *r)
for ( ;; ) {
rc = ngx_read_http_header_line(r);
/* TODO: check too long header, compact buffer */
if (rc == NGX_OK) {
if (ngx_http_process_request_header_line(r) == NGX_ERROR)
return ngx_http_error(r, NGX_HTTP_BAD_REQUEST);
} else if (rc == NGX_HTTP_HEADER_DONE) {
} else if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
ngx_log_debug(r->connection->log, "HTTP header done");
return ngx_http_handler(r);
} else if (rc == NGX_AGAIN) {
return NGX_AGAIN;
} else if (rc == NGX_HTTP_INVALID_HEADER) {
} else if (rc == NGX_HTTP_PARSE_INVALID_HEADER) {
ctx = r->connection->log->data;
r->connection->log->handler = NULL;
ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"client %s sent invalid header", ctx->client);
r->connection->log->handler = ngx_http_log_error;
@ -285,6 +309,7 @@ static int ngx_http_process_request_header(ngx_http_request_t *r)
}
}
static int ngx_http_process_request_header_line(ngx_http_request_t *r)
{
/* STUB */
@ -296,13 +321,8 @@ static int ngx_http_process_request_header_line(ngx_http_request_t *r)
return NGX_OK;
}
static int ngx_http_block_read(ngx_event_t *ev)
{
ngx_log_debug(ev->log, "http read blocked");
ngx_del_event(ev, NGX_READ_EVENT);
ev->blocked = 1;
}
/* ******************** */
void ngx_http_discard_body(ngx_http_request_t *r)
{
@ -375,13 +395,15 @@ static int ngx_http_discarded_read(ngx_event_t *ev)
return n;
}
/* ******************** */
static int ngx_http_handler(ngx_http_request_t *r)
{
int rc;
ngx_msec_t timeout;
ngx_del_timer(r->connection->read);
r->header_timeout = 1;
r->header_timeout = 0;
r->process_header = 0;
r->state_handler = NULL;
@ -408,7 +430,6 @@ static int ngx_http_handler(ngx_http_request_t *r)
if (ngx_add_event(r->connection->write, NGX_WRITE_EVENT,
NGX_ONESHOT_EVENT) == NGX_ERROR) {
#endif
/* log http request */
return ngx_http_close_request(r);
}
@ -460,49 +481,6 @@ static int ngx_http_handler(ngx_http_request_t *r)
}
}
static int ngx_http_lingering_close(ngx_event_t *ev)
{
ssize_t n;
ngx_msec_t timer;
ngx_connection_t *c;
ngx_http_request_t *r;
c = (ngx_connection_t *) ev->data;
r = (ngx_http_request_t *) c->data;
ngx_log_debug(ev->log, "http lingering close");
if (ev->timedout)
return NGX_DONE;
/* STUB */
timer = r->lingering_time - ngx_time();
if (timer <= 0)
return NGX_DONE;
if (r->discarded_buffer == NULL)
ngx_test_null(r->discarded_buffer,
ngx_palloc(r->pool, r->server->discarded_buffer_size),
NGX_ERROR);
n = ngx_event_recv(c, r->discarded_buffer,
r->server->discarded_buffer_size);
if (n == NGX_ERROR)
return NGX_ERROR;
if (n == 0)
return NGX_DONE;
if (timer > LINGERING_TIMEOUT)
timer = LINGERING_TIMEOUT;
ngx_del_timer(ev);
ngx_add_timer(ev, timer * 1000);
return NGX_OK;
}
int ngx_http_internal_redirect(ngx_http_request_t *r, char *uri)
{
ngx_log_debug(r->connection->log, "internal redirect: '%s'" _ uri);
@ -566,6 +544,15 @@ static int ngx_http_set_default_handler(ngx_http_request_t *r)
}
static int ngx_http_block_read(ngx_event_t *ev)
{
ngx_log_debug(ev->log, "http read blocked");
ngx_del_event(ev, NGX_READ_EVENT);
ev->blocked = 1;
}
static int ngx_http_writer(ngx_event_t *ev)
{
int rc;
@ -644,6 +631,11 @@ static int ngx_http_keepalive_handler(ngx_event_t *ev)
ngx_connection_t *c;
ngx_http_log_ctx_t *ctx;
ngx_log_debug(ev->log, "http keepalive");
if (ev->timedout)
return NGX_DONE;
if (closed)
/* NGX_LOG_INFO or even silent */
return NGX_ERROR;
@ -659,6 +651,49 @@ static int ngx_http_keepalive_handler(ngx_event_t *ev)
#endif
static int ngx_http_lingering_close(ngx_event_t *ev)
{
ssize_t n;
ngx_msec_t timer;
ngx_connection_t *c;
ngx_http_request_t *r;
c = (ngx_connection_t *) ev->data;
r = (ngx_http_request_t *) c->data;
ngx_log_debug(ev->log, "http lingering close");
if (ev->timedout)
return NGX_DONE;
/* STUB */
timer = r->lingering_time - ngx_time();
if (timer <= 0)
return NGX_DONE;
if (r->discarded_buffer == NULL)
ngx_test_null(r->discarded_buffer,
ngx_palloc(r->pool, r->server->discarded_buffer_size),
NGX_ERROR);
n = ngx_event_recv(c, r->discarded_buffer,
r->server->discarded_buffer_size);
if (n == NGX_ERROR)
return NGX_ERROR;
if (n == 0)
return NGX_DONE;
if (timer > LINGERING_TIMEOUT)
timer = LINGERING_TIMEOUT;
ngx_del_timer(ev);
ngx_add_timer(ev, timer * 1000);
return NGX_OK;
}
static int ngx_http_special_response(ngx_http_request_t *r, int error)
{

3
src/http/ngx_http_output_filter.c
View File

@ -65,9 +65,6 @@ int ngx_http_output_filter(ngx_http_request_t *r, ngx_hunk_t *hunk)
ctx->next_filter = ngx_http_output_next_filter;
}
ngx_log_debug(r->connection->log, "HUNK: x%x CTX-IN: x%x CTX->HUNK: x%x" _
hunk _ ctx->in _ ctx->hunk);
if (hunk && (hunk->type & NGX_HUNK_LAST))
ctx->last = 1;

38
src/http/ngx_http_parse.c
View File

@ -32,7 +32,7 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
state, p, r->header_in->last, ch, p);
*/
/* GCC 2.95.2 and VC 6.0 compiles switch as jump table */
/* GCC 2.95.2 and VC 6.0 compiles this switch as jump table */
switch (state) {
@ -44,7 +44,7 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
return NGX_AGAIN;
if (*p != 'E' || *(p + 1) != 'T')
return NGX_HTTP_INVALID_METHOD;
return NGX_HTTP_PARSE_INVALID_METHOD;
r->method = NGX_HTTP_GET;
p += 2;
@ -55,7 +55,7 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
return NGX_AGAIN;
if (*p != 'E' || *(p + 1) != 'A' || *(p + 2) != 'D')
return NGX_HTTP_INVALID_METHOD;
return NGX_HTTP_PARSE_INVALID_METHOD;
r->method = NGX_HTTP_HEAD;
p += 3;
@ -66,14 +66,14 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
return NGX_AGAIN;
if (*p != 'O' || *(p + 1) != 'S' || *(p + 2) != 'T')
return NGX_HTTP_INVALID_METHOD;
return NGX_HTTP_PARSE_INVALID_METHOD;
r->method = NGX_HTTP_POST;
p += 3;
break;
default:
return NGX_HTTP_INVALID_METHOD;
return NGX_HTTP_PARSE_INVALID_METHOD;
}
state = sw_space_after_method;
@ -86,7 +86,7 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
state = sw_spaces_before_uri;
break;
default:
return NGX_HTTP_INVALID_METHOD;
return NGX_HTTP_PARSE_INVALID_METHOD;
}
break;
@ -210,7 +210,7 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
state = sw_http_version;
break;
default:
return NGX_HTTP_INVALID_REQUEST;
return NGX_HTTP_PARSE_INVALID_REQUEST;
}
break;
@ -223,7 +223,7 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
}
if (ch != 'T' || *p != 'T' || *(p + 1) != 'P' || *(p + 2) != '/')
return NGX_HTTP_INVALID_REQUEST;
return NGX_HTTP_PARSE_INVALID_REQUEST;
p += 3;
state = sw_first_major_digit;
@ -232,7 +232,7 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
/* first digit of major HTTP version */
case sw_first_major_digit:
if (ch < '1' || ch > '9')
return NGX_HTTP_INVALID_REQUEST;
return NGX_HTTP_PARSE_INVALID_REQUEST;
r->http_major = ch - '0';
state = sw_major_digit;
@ -246,7 +246,7 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
}
if (ch < '0' || ch > '9')
return NGX_HTTP_INVALID_REQUEST;
return NGX_HTTP_PARSE_INVALID_REQUEST;
r->http_major = r->http_major * 10 + ch - '0';
break;
@ -254,7 +254,7 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
/* first digit of minor HTTP version */
case sw_first_minor_digit:
if (ch < '0' || ch > '9')
return NGX_HTTP_INVALID_REQUEST;
return NGX_HTTP_PARSE_INVALID_REQUEST;
r->http_minor = ch - '0';
@ -274,7 +274,7 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
}
if (ch < '0' || ch > '9')
return NGX_HTTP_INVALID_REQUEST;
return NGX_HTTP_PARSE_INVALID_REQUEST;
r->http_minor = r->http_minor * 10 + ch - '0';
break;
@ -286,7 +286,7 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
state = sw_done;
break;
default:
return NGX_HTTP_INVALID_REQUEST;
return NGX_HTTP_PARSE_INVALID_REQUEST;
}
break;
}
@ -298,7 +298,7 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
r->http_version = r->http_major * 1000 + r->http_minor;
r->state = sw_start;
if (r->http_version == 9 && r->method == NGX_HTTP_HEAD)
return NGX_HTTP_INVALID_HEAD;
return NGX_HTTP_PARSE_INVALID_HEAD;
else
return NGX_OK;
} else {
@ -358,7 +358,7 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
if (ch >= '0' && ch <= '9')
break;
return NGX_HTTP_INVALID_HEADER;
return NGX_HTTP_PARSE_INVALID_HEADER;
}
break;
@ -381,7 +381,7 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
if (ch >= '0' && ch <= '9')
break;
return NGX_HTTP_INVALID_HEADER;
return NGX_HTTP_PARSE_INVALID_HEADER;
/* space* before header value */
case sw_space_before_value:
@ -445,7 +445,7 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
state = sw_done;
break;
default:
return NGX_HTTP_INVALID_HEADER;
return NGX_HTTP_PARSE_INVALID_HEADER;
}
break;
@ -456,7 +456,7 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
state = sw_header_done;
break;
default:
return NGX_HTTP_INVALID_HEADER;
return NGX_HTTP_PARSE_INVALID_HEADER;
}
break;
}
@ -469,7 +469,7 @@ printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
return NGX_OK;
} else if (state == sw_header_done) {
r->state = sw_start;
return NGX_HTTP_HEADER_DONE;
return NGX_HTTP_PARSE_HEADER_DONE;
} else {
r->state = state;
return NGX_AGAIN;