mirror/nginx
1
0
Fork 0
mirror of https://github.com/nginx/nginx.git synced 2025-06-07 17:52:38 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

nginx-0.0.1-2003-10-13-20:32:29 import

Browse Source
This commit is contained in:
Igor Sysoev 2003-10-13 16:32:29 +00:00
parent 0a280a3fc0
commit 913d0d4de7
4 changed files with 147 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/core/ngx_hunk.h
View File

@ -100,6 +100,19 @@ ngx_hunk_t *ngx_create_temp_hunk(ngx_pool_t *pool, int size,
chain->next = NULL; \ chain->next = NULL; \
} while (0); } while (0);
#define ngx_alloc_ce_and_set_hunk ngx_add_hunk_to_chain
#define ngx_chain_add_ce(ngx_chain_t *chain, ngx_chain_t **last, \
ngx_chain_t *ce) \
if (chain) { \
last->next = ce; \
} else { \
chain = ce; \
} \
last = ce;
int ngx_chain_add_copy(ngx_pool_t *pool, ngx_chain_t **ch, ngx_chain_t *in); int ngx_chain_add_copy(ngx_pool_t *pool, ngx_chain_t **ch, ngx_chain_t *in);
void ngx_chain_update_chains(ngx_chain_t **free, ngx_chain_t **busy, void ngx_chain_update_chains(ngx_chain_t **free, ngx_chain_t **busy,
ngx_chain_t **out); ngx_chain_t **out);

284
src/event/ngx_event_proxy.c
View File

@ -18,10 +18,10 @@ int ngx_event_proxy_read_upstream(ngx_event_proxy_t *p)
{ {
int n, rc, size; int n, rc, size;
ngx_hunk_t *h, *nh; ngx_hunk_t *h, *nh;
ngx_chain_t *chain, *temp, *entry, *next; ngx_chain_t *chain, *rest, *ce, *next;
#if (NGX_SUPPRESS_WARN) #if (NGX_SUPPRESS_WARN)
entry = NULL; rest = NULL;
#endif #endif
#if (NGX_EVENT_COPY_FILTER) #if (NGX_EVENT_COPY_FILTER)
@ -38,22 +38,30 @@ ngx_log_debug(p->log, "read upstream");
for ( ;; ) { for ( ;; ) {
/* use the pre-read hunks if they exist */
if (p->preread_hunks) { if (p->preread_hunks) {
/* use the pre-read hunks if they exist */
chain = p->preread_hunks; chain = p->preread_hunks;
p->preread_hunks = NULL; p->preread_hunks = NULL;
n = p->preread_size; n = p->preread_size;
ngx_log_debug(p->log, "preread: %d" _ n);
} else { } else {
#if (HAVE_KQUEUE) /* kqueue notifies about the end of file or a pending error */ #if (HAVE_KQUEUE)
/*
* kqueue notifies about the end of file or a pending error.
* This test allows not to allocate a hunk on these conditions
* and not to call ngx_recv_chain().
*/
if (ngx_event_flags == NGX_HAVE_KQUEUE_EVENT) { if (ngx_event_flags == NGX_HAVE_KQUEUE_EVENT) {
if (p->upstream->read->error) { if (p->upstream->read->error) {
ngx_log_error(NGX_LOG_ERR, p->log, ngx_log_error(NGX_LOG_ERR, p->log, p->upstream->read->error,
p->upstream->read->error,
"readv() failed"); "readv() failed");
p->upstream_error = 1; p->upstream_error = 1;
@ -62,66 +70,66 @@ ngx_log_debug(p->log, "read upstream");
} else if (p->upstream->read->eof } else if (p->upstream->read->eof
&& p->upstream->read->available == 0) { && p->upstream->read->available == 0) {
p->upstream_eof = 1; p->upstream_eof = 1;
p->block_upstream = 0;
break; break;
} }
} }
#endif #endif
/* use the free hunks if they exist */
if (p->free_hunks) { if (p->free_hunks) {
/* use the free hunks if they exist */
chain = p->free_hunks; chain = p->free_hunks;
p->free_hunks = NULL; p->free_hunks = NULL;
ngx_log_debug(p->log, "free hunk: %08X:%d" _ chain->hunk _ ngx_log_debug(p->log, "free hunk: %08X:%d" _ chain->hunk _
chain->hunk->end - chain->hunk->last); chain->hunk->end - chain->hunk->last);
/* allocate a new hunk if it's still allowed */ } else if (p->hunks < p->bufs.num) {
} else if (p->allocated < p->max_block_size) { /* allocate a new hunk if it's still allowed */
h = ngx_create_temp_hunk(p->pool, p->block_size, 20, 20);
if (h == NULL) {
return NGX_ABORT;
}
p->allocated += p->block_size; ngx_test_null(h, ngx_create_temp_hunk(p->pool,
p->bufs.size, 20, 20);
NGX_ABORT);
p->hunks++;
temp = ngx_alloc_chain_entry(p->pool); ngx_alloc_ce_and_set_hunk(te, h, p->pool, NGX_ABORT);
if (temp == NULL) { chain = te;
return NGX_ABORT;
}
temp->hunk = h;
temp->next = NULL;
chain = temp;
ngx_log_debug(p->log, "new hunk: %08X" _ chain->hunk); ngx_log_debug(p->log, "new hunk: %08X" _ chain->hunk);
/* use the file hunks if they exist */
} else if (p->file_hunks) { } else if (p->file_hunks) {
/* use the file hunks if they exist */
chain = p->file_hunks; chain = p->file_hunks;
p->file_hunks = NULL; p->file_hunks = NULL;
ngx_log_debug(p->log, "file hunk: %08X" _ chain->hunk _ ngx_log_debug(p->log, "file hunk: %08X" _ chain->hunk _
chain->hunk->end - chain->hunk->last); chain->hunk->end - chain->hunk->last);
/* if the hunks are not needed to be saved in a cache and
a downstream is ready then write the hunks to a downstream */
} else if (p->cachable == 0 && p->downstream->write->ready) { } else if (p->cachable == 0 && p->downstream->write->ready) {
/*
* if the hunks are not needed to be saved in a cache and
* a downstream is ready then write the hunks to a downstream
*/
ngx_log_debug(p->log, "downstream ready"); ngx_log_debug(p->log, "downstream ready");
break; break;
/* if it's allowed then save the incoming hunks to a temporary
file, move the saved read hunks to a file chain,
convert the incoming hunks into the file hunks
and add them to an outgoing chain */
} else if (p->temp_offset < p->max_temp_file_size) { } else if (p->temp_offset < p->max_temp_file_size) {
/*
* if it's allowed then save the incoming hunks to a temporary
* file, move the saved read hunks to a file chain,
* convert the incoming hunks into the file hunks
* and add them to an outgoing chain
*/
rc = ngx_event_proxy_write_chain_to_temp_file(p); rc = ngx_event_proxy_write_chain_to_temp_file(p);
ngx_log_debug(p->log, "temp offset: %d" _ p->temp_offset); ngx_log_debug(p->log, "temp offset: %d" _ p->temp_offset);
@ -136,10 +144,9 @@ ngx_log_debug(p->log, "temp offset: %d" _ p->temp_offset);
ngx_log_debug(p->log, "new file hunk: %08X:%d" _ chain->hunk _ ngx_log_debug(p->log, "new file hunk: %08X:%d" _ chain->hunk _
chain->hunk->end - chain->hunk->last); chain->hunk->end - chain->hunk->last);
/* if there're no hunks to read in then disable a level event */
} else { } else {
p->block_upstream = 1;
/* if there're no hunks to read in then disable a level event */
ngx_log_debug(p->log, "no hunks to read in"); ngx_log_debug(p->log, "no hunks to read in");
@ -148,48 +155,43 @@ ngx_log_debug(p->log, "no hunks to read in");
n = ngx_recv_chain(p->upstream, chain); n = ngx_recv_chain(p->upstream, chain);
}
ngx_log_debug(p->log, "recv_chain: %d" _ n); ngx_log_debug(p->log, "recv_chain: %d" _ n);
if (n == NGX_ERROR) { if (n == NGX_ERROR) {
p->upstream_error = 1; p->upstream_error = 1;
return NGX_ERROR; return NGX_ERROR;
} }
if (n == NGX_AGAIN) { if (n == NGX_AGAIN) {
if (p->upstream->read->blocked) { if (ngx_handle_read_event(p->upstream->read) == NGX_ERROR) {
if (ngx_add_event(p->upstream->read, NGX_READ_EVENT,
NGX_LEVEL_EVENT) == NGX_ERROR) {
return NGX_ABORT; return NGX_ABORT;
} }
p->block_upstream = 0;
p->upstream->read->blocked = 0; break;
} }
break; if (n == 0) {
} if (chain->hunk->shadow == NULL) {
p->free_hunks = chain;
}
p->upstream_eof = 1;
if (n == 0) { break;
if (chain->hunk->shadow == NULL) {
p->free_hunks = chain;
} }
p->upstream_eof = 1;
p->block_upstream = 0;
break;
} }
/* move the full hunks to a read chain /*
and the partial filled hunk to a free chain * move the full hunks to a read chain, the partial filled hunk
and remove the shadow links for these hunks */ * to a free chain, and remove the shadow links for these hunks
*/
for (entry = chain; entry && n > 0; entry = next) { for (ce = chain; ce && n > 0; ce = next) {
next = entry->next; next = ce->next;
entry->next = NULL; ce->next = NULL;
if (entry->hunk->shadow) { if (ce->hunk->shadow) {
for (h = entry->hunk->shadow; for (h = ce->hunk->shadow;
(h->type & NGX_HUNK_LAST_SHADOW) == 0; (h->type & NGX_HUNK_LAST_SHADOW) == 0;
h = nh) h = nh)
{ {
@ -205,22 +207,22 @@ ngx_log_debug(p->log, "recv_chain: %d" _ n);
|NGX_HUNK_IN_MEMORY |NGX_HUNK_IN_MEMORY
|NGX_HUNK_RECYCLED |NGX_HUNK_RECYCLED
|NGX_HUNK_LAST_SHADOW); |NGX_HUNK_LAST_SHADOW);
entry->hunk->shadow = NULL; ce->hunk->shadow = NULL;
} }
size = entry->hunk->end - entry->hunk->last; size = ce->hunk->end - ce->hunk->last;
if (n >= size) { if (n >= size) {
entry->hunk->last = entry->hunk->end; ce->hunk->last = ce->hunk->end;
if (p->read_hunks) { if (p->read_hunks) {
p->last_read_hunk->next = entry; p->last_read_hunk->next = ce;
} else { } else {
p->read_hunks = entry; p->read_hunks = ce;
} }
p->last_read_hunk = entry; p->last_read_hunk = ce;
n -= size; n -= size;
@ -232,37 +234,21 @@ ngx_log_debug(p->log, "recv_chain: %d" _ n);
/* the inline copy input filter */ /* the inline copy input filter */
h = ngx_alloc_hunk(p->pool); ngx_test_null(h, ngx_alloc_hunk(p->pool), NGX_ABORT);
if (h == NULL) {
return NGX_ABORT;
}
ngx_memcpy(h, entry->hunk, sizeof(ngx_hunk_t)); ngx_memcpy(h, ce->hunk, sizeof(ngx_hunk_t));
h->shadow = entry->hunk; h->shadow = ce->hunk;
h->type |= NGX_HUNK_LAST_SHADOW|NGX_HUNK_RECYCLED; h->type |= NGX_HUNK_LAST_SHADOW|NGX_HUNK_RECYCLED;
entry->hunk->shadow = h; ce->hunk->shadow = h;
temp = ngx_alloc_chain_entry(p->pool); ngx_alloc_ce_and_set_hunk(te, h, p->pool, NGX_ABORT);
if (temp == NULL) {
return NGX_ABORT;
}
temp->hunk = h; ngx_chain_add_ce(p->in_hunks, p->last_in_hunk, te);
temp->next = NULL;
if (p->in_hunks) {
p->last_in_hunk->next = temp;
} else {
p->in_hunks = temp;
}
p->last_in_hunk = temp;
#endif #endif
} else { } else {
entry->hunk->last += n; ce->hunk->last += n;
p->free_hunks = entry; p->free_hunks = ce;
n = 0; n = 0;
} }
@ -272,8 +258,10 @@ ngx_log_debug(p->log, "recv_chain: %d" _ n);
chain = NULL; chain = NULL;
} }
/* the input filter i.e. that moves HTTP/1.1 chunks /*
from a read chain to an incoming chain */ * the input filter i.e. that moves HTTP/1.1 chunks
* from a read chain to an incoming chain
*/
if (p->input_filter) { if (p->input_filter) {
if (p->input_filter(p, chain) == NGX_ERROR) { if (p->input_filter(p, chain) == NGX_ERROR) {
@ -281,38 +269,38 @@ ngx_log_debug(p->log, "recv_chain: %d" _ n);
} }
} }
ngx_log_debug(p->log, "rest chain: %08X" _ entry); ngx_log_debug(p->log, "rest chain: %08X" _ ce);
/* if the rest hunks are file hunks then move them to a file chain /*
otherwise add them to a free chain */ * if the rest hunks are file hunks then move them to a file chain
* otherwise add them to a free chain
*/
if (entry) { if (rest) {
if (entry->hunk->shadow) { if (rest->hunk->shadow) {
p->file_hunks = entry; p->file_hunks = rest;
} else { } else {
if (p->free_hunks) { if (p->free_hunks) {
p->free_hunks->next = entry; p->free_hunks->next = rest;
} else { } else {
p->free_hunks = entry; p->free_hunks = rest;
} }
} }
p->block_upstream = 0;
break; break;
} }
} }
ngx_log_debug(p->log, "eof: %d block: %d" _ ngx_log_debug(p->log, "eof: %d" _ p->upstream_eof);
p->upstream_eof _ p->block_upstream);
/* if there's the end of upstream response then move /*
the partially filled hunk from a free chain to an incoming chain */ * if there's the end of upstream response then move
* the partially filled hunk from a free chain to an incoming chain
*/
if (p->upstream_eof) { if (p->upstream_eof) {
p->upstream->read->ready = 0;
if (p->free_hunks if (p->free_hunks
&& p->free_hunks->hunk->pos < p->free_hunks->hunk->last) && p->free_hunks->hunk->pos < p->free_hunks->hunk->last)
{ {
@ -323,34 +311,36 @@ ngx_log_debug(p->log, "eof: %d block: %d" _
return NGX_ABORT; return NGX_ABORT;
} }
#else #else
if (p->input_filter) { if (p->input_filter) {
if (p->input_filter(p, NULL) == NGX_ERROR) { if (p->input_filter(p, NULL) == NGX_ERROR) {
return NGX_ABORT; return NGX_ABORT;
} }
} else { } else {
entry = p->free_hunks; ce = p->free_hunks;
if (p->in_hunks) { if (p->in_hunks) {
p->last_in_hunk->next = entry; p->last_in_hunk->next = ce;
} else { } else {
p->in_hunks = entry; p->in_hunks = ce;
} }
p->last_in_hunk = entry; p->last_in_hunk = ce;
} }
p->free_hunks = entry->next; p->free_hunks = ce->next;
entry->next = NULL; ce->next = NULL;
#endif
#endif /* NGX_EVENT_COPY_FILTER */
} }
#if 0 #if 0
/* free the unneeded hunks */ /* free the unneeded hunks */
for (entry = p->free_hunks; entry; entry = ce->next) { for (ce = p->free_hunks; ce; ce = ce->next) {
ngx_free_hunk(p->pool, entry->hunk); ngx_free_hunk(p->pool, ce->hunk);
} }
#endif #endif
@ -387,17 +377,10 @@ ngx_log_debug(p->log, "eof: %d block: %d" _
ngx_log_debug(p->log, "upstream level: %d" _ p->upstream_level); ngx_log_debug(p->log, "upstream level: %d" _ p->upstream_level);
if (p->upstream_level == 0 if (p->upstream_level == 0) {
&& p->block_upstream if (ngx_handler_read_event(p->upstream->read) == NGX_ERROR) {
&& ngx_event_flags & NGX_USE_LEVEL_EVENT)
{
if (ngx_del_event(p->upstream->read, NGX_READ_EVENT, 0) == NGX_ERROR) {
return NGX_ABORT; return NGX_ABORT;
} }
p->upstream->read->blocked = 1;
return NGX_AGAIN;
} }
if (p->upstream_eof) { if (p->upstream_eof) {
@ -415,6 +398,8 @@ int ngx_event_proxy_write_to_downstream(ngx_event_proxy_t *p)
ngx_hunk_t *h; ngx_hunk_t *h;
ngx_chain_t *entry; ngx_chain_t *entry;
#if 0
if (p->upstream_level == 0 if (p->upstream_level == 0
&& p->downstream_level == 0 && p->downstream_level == 0
&& p->busy_hunk == NULL && p->busy_hunk == NULL
@ -431,6 +416,8 @@ int ngx_event_proxy_write_to_downstream(ngx_event_proxy_t *p)
return NGX_AGAIN; return NGX_AGAIN;
} }
#endif
p->downstream_level++; p->downstream_level++;
ngx_log_debug(p->log, "write to downstream"); ngx_log_debug(p->log, "write to downstream");
@ -695,45 +682,32 @@ static int ngx_event_proxy_copy_input_filter(ngx_event_proxy_t *p,
ngx_chain_t *chain) ngx_chain_t *chain)
{ {
ngx_hunk_t *h; ngx_hunk_t *h;
ngx_chain_t *entry, *temp; ngx_chain_t *ce, *temp;
if (p->upstream_eof) { if (p->upstream_eof) {
entry = p->free_hunks;
if (p->in_hunks) { /* THINK comment */
p->last_in_hunk->next = entry;
} else { ce = p->free_hunks;
p->in_hunks = entry;
}
p->last_in_hunk = entry; ngx_chain_add_ce(p->in_hunk, p->last_in_hunk, ce);
p->free_hunks = entry->next; p->free_hunks = ce->next;
entry->next = NULL; ce->next = NULL;
return NGX_OK; return NGX_OK;
} }
for (entry = chain; entry; entry = entry->next) { for (ce = chain; ce; ce = ce->next) {
ngx_test_null(h, ngx_alloc_hunk(p->pool), NGX_ERROR); ngx_test_null(h, ngx_alloc_hunk(p->pool), NGX_ERROR);
ngx_memcpy(h, entry->hunk, sizeof(ngx_hunk_t)); ngx_memcpy(h, ce->hunk, sizeof(ngx_hunk_t));
h->shadow = entry->hunk; h->shadow = ce->hunk;
h->type |= NGX_HUNK_LAST_SHADOW|NGX_HUNK_RECYCLED; h->type |= NGX_HUNK_LAST_SHADOW|NGX_HUNK_RECYCLED;
entry->hunk->shadow = h; ce->hunk->shadow = h;
ngx_test_null(temp, ngx_alloc_chain_entry(p->pool), NGX_ERROR); ngx_alloc_ce_and_set_hunk(te, h, p->pool, NGX_ERROR);
temp->hunk = h;
temp->next = NULL;
if (p->in_hunks) { ngx_chain_add_ce(p->in_hunk, p->last_in_hunk, te);
p->last_in_hunk->next = temp;
} else {
p->in_hunks = temp;
}
p->last_in_hunk = temp;
} }
return NGX_OK; return NGX_OK;

5
src/event/ngx_event_proxy.h
View File

@ -49,9 +49,8 @@ struct ngx_event_proxy_s {
int upstream_level; int upstream_level;
int downstream_level; int downstream_level;
int allocated; int hunks;
int block_size; ngx_bufs_t bufs;
int max_block_size;
off_t temp_offset; off_t temp_offset;
off_t max_temp_file_size; off_t max_temp_file_size;

4
src/http/ngx_http_special_response.c
View File

@ -234,7 +234,9 @@ int ngx_http_special_response_handler(ngx_http_request_t *r, int error)
if (/* STUB: "msie_padding on/off" */ 1 if (/* STUB: "msie_padding on/off" */ 1
&& r->http_version >= NGX_HTTP_VERSION_10 && r->http_version >= NGX_HTTP_VERSION_10
&& error >= NGX_HTTP_BAD_REQUEST) && error >= NGX_HTTP_BAD_REQUEST
&& error != NGX_HTTP_REQUEST_URI_TOO_LARGE
)
{ {
if (ngx_http_output_filter(r, h) == NGX_ERROR) { if (ngx_http_output_filter(r, h) == NGX_ERROR) {