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-22-20:38:26 import

Browse Source
This commit is contained in:
Igor Sysoev 2003-10-22 16:38:26 +00:00
parent 5bf3d25d69
commit dc9dd434aa
31 changed files with 612 additions and 683 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
src/core/ngx_conf_file.c
View File

@ -6,10 +6,20 @@
#define MAX_CONF_ERRSTR 256 #define MAX_CONF_ERRSTR 256
/* Ten fixed arguments */
static int argument_number[] = { static int argument_number[] = {
NGX_CONF_NOARGS, NGX_CONF_NOARGS,
NGX_CONF_TAKE1, NGX_CONF_TAKE1,
NGX_CONF_TAKE2 NGX_CONF_TAKE2,
NGX_CONF_TAKE3,
NGX_CONF_TAKE4,
NGX_CONF_TAKE5,
NGX_CONF_TAKE6,
NGX_CONF_TAKE7,
NGX_CONF_TAKE8,
NGX_CONF_TAKE9,
NGX_CONF_TAKE10
}; };
static int ngx_conf_read_token(ngx_conf_t *cf); static int ngx_conf_read_token(ngx_conf_t *cf);
@ -146,17 +156,9 @@ ngx_log_debug(cf->log, "command '%s'" _ cmd->name.data);
/* is the directive's argument count right ? */ /* is the directive's argument count right ? */
if (cmd->type & argument_number[cf->args->nelts - 1]) { if (cmd->type & NGX_CONF_ANY) {
valid = 1; valid = 1;
} else if (cmd->type & NGX_CONF_1MORE) {
if (cf->args->nelts != 1) {
valid = 1;
} else {
valid = 0;
}
} else if (cmd->type & NGX_CONF_FLAG) { } else if (cmd->type & NGX_CONF_FLAG) {
if (cf->args->nelts == 2) { if (cf->args->nelts == 2) {
@ -165,7 +167,18 @@ ngx_log_debug(cf->log, "command '%s'" _ cmd->name.data);
valid = 0; valid = 0;
} }
} else if (cmd->type & NGX_CONF_ANY) { } else if (cmd->type & NGX_CONF_1MORE) {
if (cf->args->nelts != 1) {
valid = 1;
} else {
valid = 0;
}
} else if (cf->args->nelts <= 10
&& (cmd->type
& argument_number[cf->args->nelts - 1]))
{
valid = 1; valid = 1;
} else { } else {
@ -573,8 +586,7 @@ char *ngx_conf_set_str_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
value = (ngx_str_t *) cf->args->elts; value = (ngx_str_t *) cf->args->elts;
field->len = value[1].len; *field = value[1];
field->data = value[1].data;
return NGX_CONF_OK; return NGX_CONF_OK;
} }

12
src/core/ngx_conf_file.h
View File

@ -15,6 +15,18 @@
#define NGX_CONF_NOARGS 0x00000001 #define NGX_CONF_NOARGS 0x00000001
#define NGX_CONF_TAKE1 0x00000002 #define NGX_CONF_TAKE1 0x00000002
#define NGX_CONF_TAKE2 0x00000004 #define NGX_CONF_TAKE2 0x00000004
#define NGX_CONF_TAKE3 0x00000008
#define NGX_CONF_TAKE4 0x00000010
#define NGX_CONF_TAKE5 0x00000020
#define NGX_CONF_TAKE6 0x00000040
#define NGX_CONF_TAKE7 0x00000080
#define NGX_CONF_TAKE8 0x00000100
#define NGX_CONF_TAKE9 0x00000200
#define NGX_CONF_TAKE10 0x00000400
#define NGX_CONF_TAKE1234 (NGX_CONF_TAKE1|NGX_CONF_TAKE2|NGX_CONF_TAKE3 \
|NGX_CONF_TAKE4)
#define NGX_CONF_ARGS_NUMBER 0x0000ffff #define NGX_CONF_ARGS_NUMBER 0x0000ffff
#define NGX_CONF_ANY 0x00010000 #define NGX_CONF_ANY 0x00010000
#define NGX_CONF_1MORE 0x00020000 #define NGX_CONF_1MORE 0x00020000

41
src/core/ngx_file.c
View File

@ -164,3 +164,44 @@ int ngx_next_temp_number(int collision)
return ngx_temp_number++; return ngx_temp_number++;
} }
char *ngx_conf_set_path_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
char *p = conf;
int i, n;
ngx_str_t *value;
ngx_path_t *path, **pp;
pp = (ngx_path_t **) (p + cmd->offset);
if (*pp) {
return "is duplicate";
}
ngx_test_null(path, ngx_pcalloc(cf->pool, sizeof(ngx_path_t)), NULL);
*pp = path;
value = (ngx_str_t *) cf->args->elts;
path->name = value[1];
path->len = 0;
for (i = 0, n = 2; n < cf->args->nelts; i++, n++) {
path->level[i] = ngx_atoi(value[n].data, value[n].len);
if (path->level[i] == NGX_ERROR || path->level[i] == 0) {
return "invalid value";
}
path->len += path->level[i] + 1;
}
while (i < 3) {
path->level[i++] = 0;
}
return NULL;
}

19
src/core/ngx_file.h
View File

@ -34,5 +34,24 @@ int ngx_create_path(ngx_file_t *file, ngx_path_t *path);
void ngx_init_temp_number(); void ngx_init_temp_number();
int ngx_next_temp_number(int collision); int ngx_next_temp_number(int collision);
char *ngx_conf_set_path_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
#define ngx_conf_merge_path_value(conf, prev, path, l1, l2, l3, pool) \
if (conf == NULL) { \
if (prev == NULL) { \
ngx_test_null(conf, ngx_palloc(pool, sizeof(ngx_path_t)), NULL); \
conf->name.len = sizeof(path) - 1; \
conf->name.data = path; \
conf->level[0] = l1; \
conf->level[1] = l2; \
conf->level[2] = l3; \
conf->len = l1 + l2 + l3 + l1 ? 1:0 + l2 ? 1:0 + l3 ? 1:0; \
} else { \
conf = prev; \
} \
}
#endif /* _NGX_FILE_H_INCLUDED_ */ #endif /* _NGX_FILE_H_INCLUDED_ */

20
src/core/ngx_hunk.c
View File

@ -99,26 +99,26 @@ ngx_hunk_t *ngx_create_hunk_after(ngx_pool_t *pool, ngx_hunk_t *hunk, int size)
} }
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 **chain, ngx_chain_t *in)
{ {
ngx_chain_t *ce, **le; ngx_chain_t *cl, **ll;
le = ch; ll = chain;
for (ce = *ch; ce; ce = ce->next) { for (cl = *chain; cl; cl = cl->next) {
le = &ce->next; ll = &cl->next;
} }
while (in) { while (in) {
ngx_test_null(ce, ngx_alloc_chain_entry(pool), NGX_ERROR); ngx_test_null(cl, ngx_alloc_chain_link(pool), NGX_ERROR);
ce->hunk = in->hunk; cl->hunk = in->hunk;
*le = ce; *ll = cl;
le = &ce->next; ll = &cl->next;
in = in->next; in = in->next;
} }
*le = NULL; *ll = NULL;
return NGX_OK; return NGX_OK;
} }

21
src/core/ngx_hunk.h
View File

@ -99,31 +99,30 @@ ngx_hunk_t *ngx_create_temp_hunk(ngx_pool_t *pool, int size,
#define ngx_alloc_hunk(pool) ngx_palloc(pool, sizeof(ngx_hunk_t)) #define ngx_alloc_hunk(pool) ngx_palloc(pool, sizeof(ngx_hunk_t))
#define ngx_calloc_hunk(pool) ngx_pcalloc(pool, sizeof(ngx_hunk_t)) #define ngx_calloc_hunk(pool) ngx_pcalloc(pool, sizeof(ngx_hunk_t))
#define ngx_alloc_chain_entry(pool) ngx_palloc(pool, sizeof(ngx_chain_t))
#define ngx_add_hunk_to_chain(chain, h, pool, error) \ #define ngx_alloc_chain_link(pool) ngx_palloc(pool, sizeof(ngx_chain_t))
#define ngx_alloc_link_and_set_hunk(chain, h, pool, error) \
do { \ do { \
ngx_test_null(chain, ngx_alloc_chain_entry(pool), error); \ ngx_test_null(chain, ngx_alloc_chain_link(pool), error); \
chain->hunk = h; \ chain->hunk = h; \
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_link(chain, last, cl) \
#define ngx_chain_add_ce(chain, last, ce) \
if (chain) { \ if (chain) { \
*last = ce; \ *last = cl; \
} else { \ } else { \
chain = ce; \ chain = cl; \
} \ } \
last = &ce->next last = &cl->next
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 **chain, 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_hunk_tag_t tag); ngx_chain_t **out, ngx_hunk_tag_t tag);
#endif /* _NGX_HUNK_H_INCLUDED_ */ #endif /* _NGX_HUNK_H_INCLUDED_ */

44
src/core/ngx_listen.c
View File

@ -1,44 +0,0 @@
#include <ngx_config.h>
#include <ngx_types.h>
#include <ngx_errno.h>
#include <ngx_log.h>
#include <ngx_listen.h>
ngx_socket_t ngx_listen(struct sockaddr *addr, int backlog,
ngx_log_t *log, char *addr_text)
{
ngx_socket_t s;
int reuseaddr = 1;
#if (WIN32)
unsigned long nb = 1;
#endif
if ((s = socket(AF_INET, SOCK_STREAM, 0)) == -1)
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno, "socket failed");
if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
(const void *) &reuseaddr, sizeof(int)) == -1)
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
"ngx_listen: setsockopt (SO_REUSEADDR) failed");
#if (WIN32)
if (ioctlsocket(s, FIONBIO, &nb) == -1)
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
"ngx_listen: ioctlsocket (FIONBIO) failed");
#else
if (fcntl(s, F_SETFL, O_NONBLOCK) == -1)
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
"ngx_listen: fcntl (O_NONBLOCK) failed");
#endif
if (bind(s, (struct sockaddr *) addr, sizeof(struct sockaddr_in)) == -1)
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
"ngx_listen: bind to %s failed", addr_text);
if (listen(s, backlog) == -1)
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
"ngx_listen: listen to %s failed", addr_text);
return s;
}

54
src/core/ngx_listen.h
View File

@ -1,54 +0,0 @@
#ifndef _NGX_LISTEN_H_INCLUDED_
#define _NGX_LISTEN_H_INCLUDED_
#include <ngx_config.h>
#include <ngx_log.h>
#include <ngx_types.h>
#include <ngx_socket.h>
#include <ngx_connection.h>
typedef struct {
ngx_socket_t fd;
struct sockaddr *sockaddr;
socklen_t socklen; /* size of sockaddr */
int addr; /* offset to address in sockaddr */
int addr_text_max_len;
ngx_str_t addr_text;
int family;
int type;
int protocol;
int flags; /* Winsock2 flags */
void (*handler)(ngx_connection_t *c); /* handler of accepted
connection */
void *ctx; /* ngx_http_conf_ctx_t, for example */
void *servers; /* array of ngx_http_in_addr_t, for example */
ngx_log_t *log;
int pool_size;
int backlog;
time_t post_accept_timeout; /* should be here because
of the deferred accept */
unsigned bound:1; /* already bound */
unsigned inherited:1; /* inherited from previous process */
unsigned nonblocking_accept:1;
unsigned nonblocking:1;
#if 0
unsigned overlapped:1; /* Winsock2 overlapped */
#endif
unsigned shared:1; /* shared between threads or processes */
#if (HAVE_DEFERRED_ACCEPT)
unsigned deferred_accept:1;
#endif
} ngx_listen_t;
extern ngx_array_t ngx_listening_sockets;
#endif /* _NGX_LISTEN_H_INCLUDED_ */

50
src/core/ngx_write_chain.c
View File

@ -1,50 +0,0 @@
#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_types.h>
#include <ngx_alloc.h>
#include <ngx_array.h>
#include <ngx_hunk.h>
#include <ngx_connection.h>
ngx_chain_t *(*ngx_write_chain_proc)(ngx_connection_t *c, ngx_chain_t *in);
ngx_chain_t *ngx_write_chain(ngx_connection_t *c, ngx_chain_t *in, off_t flush)
{
#if (NGX_EVENT)
return (*ngx_write_chain_proc)(c, in);
#elif (NGX_EVENT_THREAD)
off_t sent;
ngx_chain_t *rc;
sent = flush - c->sent;
do {
rc = (*ngx_write_chain_proc)(c, in);
if (rc == NGX_CHAIN_ERROR && rc == NULL) {
return rc;
}
} while (c->thread && flush > c->sent - sent);
#else
ngx_chain_t *rc;
do {
rc = (*ngx_write_chain_proc)(c, in);
} while (rc != NGX_CHAIN_ERROR && rc != NULL);
return rc;
#endif
}

13
src/event/ngx_event_acceptex.h
View File

@ -1,13 +0,0 @@
#ifndef _NGX_EVENT_ACCEPTEX_H_INCLUDED_
#define _NGX_EVENT_ACCEPTEX_H_INCLUDED_
#include <ngx_listen.h>
#include <ngx_event.h>
int ngx_event_acceptex(ngx_event_t *ev);
int ngx_event_post_acceptex(ngx_listen_t *ls, int n);
#endif /* _NGX_EVENT_ACCEPTEX_H_INCLUDED_ */

220
src/event/ngx_event_pipe.c
View File

@ -9,12 +9,12 @@ static int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p);
static int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p); static int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p);
static int ngx_event_pipe_write_chain_to_temp_file(ngx_event_pipe_t *p); static int ngx_event_pipe_write_chain_to_temp_file(ngx_event_pipe_t *p);
ngx_inline static void ngx_remove_shadow_links(ngx_hunk_t *hunk); ngx_inline static void ngx_event_pipe_remove_shadow_links(ngx_hunk_t *hunk);
ngx_inline static void ngx_remove_shadow_free_raw_hunk(ngx_chain_t **free, ngx_inline static void ngx_event_pipe_free_shadow_raw_hunk(ngx_chain_t **free,
ngx_hunk_t *h); ngx_hunk_t *h);
ngx_inline static void ngx_add_after_partially_filled_hunk(ngx_chain_t **chain, ngx_inline static void ngx_event_pipe_add_free_hunk(ngx_chain_t **chain,
ngx_chain_t *ce); ngx_chain_t *cl);
static int ngx_drain_chains(ngx_event_pipe_t *p); static int ngx_event_pipe_drain_chains(ngx_event_pipe_t *p);
int ngx_event_pipe(ngx_event_pipe_t *p, int do_write) int ngx_event_pipe(ngx_event_pipe_t *p, int do_write)
@ -57,7 +57,7 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
{ {
int n, rc, size; int n, rc, size;
ngx_hunk_t *h; ngx_hunk_t *h;
ngx_chain_t *chain, *ce, *te; ngx_chain_t *chain, *cl, *tl;
if (p->upstream_eof || p->upstream_error || p->upstream_done) { if (p->upstream_eof || p->upstream_error || p->upstream_done) {
return NGX_OK; return NGX_OK;
@ -131,8 +131,8 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
NGX_ABORT); NGX_ABORT);
p->hunks++; p->hunks++;
ngx_alloc_ce_and_set_hunk(te, h, p->pool, NGX_ABORT); ngx_alloc_link_and_set_hunk(tl, h, p->pool, NGX_ABORT);
chain = te; chain = tl;
} else if (!p->cachable && p->downstream->write->ready) { } else if (!p->cachable && p->downstream->write->ready) {
@ -212,33 +212,33 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
} }
} }
ce = chain; cl = chain;
while (ce && n > 0) { while (cl && n > 0) {
ngx_remove_shadow_links(ce->hunk); ngx_event_pipe_remove_shadow_links(cl->hunk);
size = ce->hunk->end - ce->hunk->last; size = cl->hunk->end - cl->hunk->last;
if (n >= size) { if (n >= size) {
ce->hunk->last = ce->hunk->end; cl->hunk->last = cl->hunk->end;
/* STUB */ ce->hunk->num = p->num++; /* STUB */ cl->hunk->num = p->num++;
if (p->input_filter(p, ce->hunk) == NGX_ERROR) { if (p->input_filter(p, cl->hunk) == NGX_ERROR) {
return NGX_ABORT; return NGX_ABORT;
} }
n -= size; n -= size;
ce = ce->next; cl = cl->next;
} else { } else {
ce->hunk->last += n; cl->hunk->last += n;
n = 0; n = 0;
} }
} }
p->free_raw_hunks = ce; p->free_raw_hunks = cl;
} }
if ((p->upstream_eof || p->upstream_error) && p->free_raw_hunks) { if ((p->upstream_eof || p->upstream_error) && p->free_raw_hunks) {
@ -263,15 +263,15 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p) int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p)
{ {
size_t busy_len; size_t bsize, to_write;
ngx_hunk_t *h; ngx_hunk_t *h;
ngx_chain_t *out, **le, *ce, *te; ngx_chain_t *out, **ll, *cl, *tl;
ngx_log_debug(p->log, "write downstream: %d" _ p->downstream->write->ready); ngx_log_debug(p->log, "write downstream: %d" _ p->downstream->write->ready);
for ( ;; ) { for ( ;; ) {
if (p->downstream_error) { if (p->downstream_error) {
return ngx_drain_chains(p); return ngx_event_pipe_drain_chains(p);
} }
if ((p->upstream_eof || p->upstream_error || p->upstream_done) if ((p->upstream_eof || p->upstream_error || p->upstream_done)
@ -285,95 +285,105 @@ int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p)
break; break;
} }
busy_len = 0; /*
* bsize is the busy hunks size
* to_write is the size of data that to be written
*/
bsize = 0;
to_write = 0;
if (!(p->upstream_eof || p->upstream_error || p->upstream_done)) { if (!(p->upstream_eof || p->upstream_error || p->upstream_done)) {
/* calculate p->busy_len */ for (cl = p->busy; cl; cl = cl->next) {
for (ce = p->busy; ce; ce = ce->next) { bsize += cl->hunk->end - cl->hunk->start;
busy_len += ngx_hunk_size(ce->hunk); to_write += ngx_hunk_size(cl->hunk);
} }
} }
out = NULL; out = NULL;
le = NULL; ll = NULL;
for ( ;; ) { for ( ;; ) {
if (p->out) { if (p->out) {
ce = p->out; cl = p->out;
if (!(p->upstream_eof || p->upstream_error || p->upstream_done) if (!(p->upstream_eof || p->upstream_error || p->upstream_done)
&& (busy_len + ngx_hunk_size(ce->hunk) > p->max_busy_len)) && (bsize + ngx_hunk_size(cl->hunk) > p->busy_size))
{ {
break; break;
} }
p->out = p->out->next; p->out = p->out->next;
ngx_remove_shadow_free_raw_hunk(&p->free_raw_hunks, ce->hunk); ngx_event_pipe_free_shadow_raw_hunk(&p->free_raw_hunks,
cl->hunk);
ngx_log_debug(p->log, "HUNK OUT: %d %x" _ ce->hunk->num _ ce->hunk->type); ngx_log_debug(p->log, "HUNK OUT: %d %x" _ cl->hunk->num _ cl->hunk->type);
} else if (!p->cachable && p->in) { } else if (!p->cachable && p->in) {
ce = p->in; cl = p->in;
if (!(p->upstream_eof || p->upstream_error || p->upstream_done) if (!(p->upstream_eof || p->upstream_error || p->upstream_done)
&& (busy_len + ngx_hunk_size(ce->hunk) > p->max_busy_len)) && (bsize + ngx_hunk_size(cl->hunk) > p->busy_size))
{ {
break; break;
} }
p->in = p->in->next; p->in = p->in->next;
ngx_log_debug(p->log, "HUNK IN: %d" _ ce->hunk->num); ngx_log_debug(p->log, "HUNK IN: %d" _ cl->hunk->num);
} else { } else {
break; break;
} }
busy_len += ngx_hunk_size(ce->hunk); bsize += ngx_hunk_size(cl->hunk);
ce->next = NULL; cl->next = NULL;
ngx_chain_add_ce(out, le, ce); ngx_chain_add_link(out, ll, cl);
} }
if (out == NULL) { if (out == NULL) {
ngx_log_debug(p->log, "no hunks to write BUSY: %d" _ busy_len); ngx_log_debug(p->log, "no hunks to write BUSY: %d" _ to_write);
if (!p->upstream_blocked || busy_len == 0) { if (!(p->upstream_blocked && to_write)) {
break; break;
} }
/* if the upstream is blocked then write the busy hunks */ /*
* if the upstream is blocked and there are the busy hunks
* to write then write these hunks
*/
} }
if (p->output_filter(p->output_ctx, out) == NGX_ERROR) { if (p->output_filter(p->output_ctx, out) == NGX_ERROR) {
p->downstream_error = 1; p->downstream_error = 1;
/* handle the downstream error at the begin of the cycle. */ /* handle the downstream error at the begin of a cycle */
continue; continue;
} }
ngx_chain_update_chains(&p->free, &p->busy, &out, p->tag); ngx_chain_update_chains(&p->free, &p->busy, &out, p->tag);
for (ce = p->free; ce; ce = ce->next) { for (cl = p->free; cl; cl = cl->next) {
/* add the free shadow raw hunk to p->free_raw_hunks */ /* add the free shadow raw hunk to p->free_raw_hunks */
if (ce->hunk->type & NGX_HUNK_LAST_SHADOW) { if (cl->hunk->type & NGX_HUNK_LAST_SHADOW) {
h = ce->hunk->shadow; h = cl->hunk->shadow;
h->pos = h->last = h->start; h->pos = h->last = h->start;
h->shadow = NULL; h->shadow = NULL;
ngx_alloc_ce_and_set_hunk(te, h, p->pool, NGX_ABORT); ngx_alloc_link_and_set_hunk(tl, h, p->pool, NGX_ABORT);
ngx_add_after_partially_filled_hunk(&p->free_raw_hunks, te); ngx_event_pipe_add_free_hunk(&p->free_raw_hunks, tl);
ce->hunk->type &= ~NGX_HUNK_LAST_SHADOW; cl->hunk->type &= ~NGX_HUNK_LAST_SHADOW;
} }
ce->hunk->shadow = NULL; cl->hunk->shadow = NULL;
if (p->cyclic_temp_file && (ce->hunk->type & NGX_HUNK_TEMP_FILE)) { if (p->cyclic_temp_file && (cl->hunk->type & NGX_HUNK_TEMP_FILE)) {
/* reset p->temp_offset if all hunks had been sent */ /* reset p->temp_offset if all hunks had been sent */
if (ce->hunk->file_last == p->temp_offset) { if (cl->hunk->file_last == p->temp_offset) {
p->temp_offset = 0; p->temp_offset = 0;
} }
} }
@ -388,7 +398,7 @@ static int ngx_event_pipe_write_chain_to_temp_file(ngx_event_pipe_t *p)
{ {
int rc, size, hsize; int rc, size, hsize;
ngx_hunk_t *h; ngx_hunk_t *h;
ngx_chain_t *ce, *te, *next, *out, **le, **last_free; ngx_chain_t *cl, *tl, *next, *out, **ll, **last_free;
ngx_log_debug(p->log, "write to file"); ngx_log_debug(p->log, "write to file");
@ -414,13 +424,13 @@ static int ngx_event_pipe_write_chain_to_temp_file(ngx_event_pipe_t *p)
if (!p->cachable) { if (!p->cachable) {
size = 0; size = 0;
ce = p->in; cl = p->in;
le = NULL; ll = NULL;
ngx_log_debug(p->log, "offset: %d" _ p->temp_offset); ngx_log_debug(p->log, "offset: %d" _ p->temp_offset);
do { do {
hsize = ce->hunk->last - ce->hunk->pos; hsize = cl->hunk->last - cl->hunk->pos;
ngx_log_debug(p->log, "hunk size: %d" _ hsize); ngx_log_debug(p->log, "hunk size: %d" _ hsize);
@ -431,16 +441,16 @@ ngx_log_debug(p->log, "hunk size: %d" _ hsize);
} }
size += hsize; size += hsize;
le = &ce->next; ll = &cl->next;
ce = ce->next; cl = cl->next;
} while (ce); } while (cl);
ngx_log_debug(p->log, "size: %d" _ size); ngx_log_debug(p->log, "size: %d" _ size);
if (ce) { if (cl) {
p->in = ce; p->in = cl;
*le = NULL; *ll = NULL;
} else { } else {
p->in = NULL; p->in = NULL;
@ -464,11 +474,11 @@ ngx_log_debug(p->log, "size: %d" _ size);
/* void */ /* void */
} }
for (ce = out; ce; ce = next) { for (cl = out; cl; cl = next) {
next = ce->next; next = cl->next;
ce->next = NULL; cl->next = NULL;
h = ce->hunk; h = cl->hunk;
h->file = p->temp_file; h->file = p->temp_file;
h->file_pos = p->temp_offset; h->file_pos = p->temp_offset;
p->temp_offset += h->last - h->pos; p->temp_offset += h->last - h->pos;
@ -480,13 +490,13 @@ ngx_log_debug(p->log, "size: %d" _ size);
h->type |= NGX_HUNK_FILE|NGX_HUNK_TEMP_FILE; h->type |= NGX_HUNK_FILE|NGX_HUNK_TEMP_FILE;
} }
ngx_chain_add_ce(p->out, p->last_out, ce); ngx_chain_add_link(p->out, p->last_out, cl);
if (h->type & NGX_HUNK_LAST_SHADOW) { if (h->type & NGX_HUNK_LAST_SHADOW) {
h->shadow->last = h->shadow->pos = h->shadow->start; h->shadow->last = h->shadow->pos = h->shadow->start;
ngx_alloc_ce_and_set_hunk(te, h->shadow, p->pool, NGX_ABORT); ngx_alloc_link_and_set_hunk(tl, h->shadow, p->pool, NGX_ABORT);
*last_free = te; *last_free = tl;
last_free = &te->next; last_free = &tl->next;
} }
} }
@ -499,7 +509,7 @@ ngx_log_debug(p->log, "size: %d" _ size);
int ngx_event_pipe_copy_input_filter(ngx_event_pipe_t *p, ngx_hunk_t *hunk) int ngx_event_pipe_copy_input_filter(ngx_event_pipe_t *p, ngx_hunk_t *hunk)
{ {
ngx_hunk_t *h; ngx_hunk_t *h;
ngx_chain_t *ce; ngx_chain_t *cl;
if (hunk->pos == hunk->last) { if (hunk->pos == hunk->last) {
return NGX_OK; return NGX_OK;
@ -519,15 +529,15 @@ int ngx_event_pipe_copy_input_filter(ngx_event_pipe_t *p, ngx_hunk_t *hunk)
h->type |= NGX_HUNK_LAST_SHADOW|NGX_HUNK_RECYCLED; h->type |= NGX_HUNK_LAST_SHADOW|NGX_HUNK_RECYCLED;
hunk->shadow = h; hunk->shadow = h;
ngx_alloc_ce_and_set_hunk(ce, h, p->pool, NGX_ERROR); ngx_alloc_link_and_set_hunk(cl, h, p->pool, NGX_ERROR);
ngx_log_debug(p->log, "HUNK %d" _ h->num); ngx_log_debug(p->log, "HUNK %d" _ h->num);
ngx_chain_add_ce(p->in, p->last_in, ce); ngx_chain_add_link(p->in, p->last_in, cl);
return NGX_OK; return NGX_OK;
} }
ngx_inline static void ngx_remove_shadow_links(ngx_hunk_t *hunk) ngx_inline static void ngx_event_pipe_remove_shadow_links(ngx_hunk_t *hunk)
{ {
ngx_hunk_t *h, *next; ngx_hunk_t *h, *next;
@ -554,11 +564,11 @@ ngx_inline static void ngx_remove_shadow_links(ngx_hunk_t *hunk)
} }
ngx_inline static void ngx_remove_shadow_free_raw_hunk(ngx_chain_t **free, ngx_inline static void ngx_event_pipe_free_shadow_raw_hunk(ngx_chain_t **free,
ngx_hunk_t *h) ngx_hunk_t *h)
{ {
ngx_hunk_t *s; ngx_hunk_t *s;
ngx_chain_t *ce, **le; ngx_chain_t *cl, **ll;
if (h->shadow == NULL) { if (h->shadow == NULL) {
return; return;
@ -568,77 +578,77 @@ ngx_inline static void ngx_remove_shadow_free_raw_hunk(ngx_chain_t **free,
/* void */ /* void */
} }
le = free; ll = free;
for (ce = *free ; ce; ce = ce->next) { for (cl = *free ; cl; cl = cl->next) {
if (ce->hunk == s) { if (cl->hunk == s) {
*le = ce->next; *ll = cl->next;
break; break;
} }
if (ce->hunk->shadow) { if (cl->hunk->shadow) {
break; break;
} }
le = &ce->next; ll = &cl->next;
} }
} }
ngx_inline static void ngx_add_after_partially_filled_hunk(ngx_chain_t **chain, ngx_inline static void ngx_event_pipe_add_free_hunk(ngx_chain_t **chain,
ngx_chain_t *ce) ngx_chain_t *cl)
{ {
if (*chain == NULL) { if (*chain == NULL) {
*chain = ce; *chain = cl;
return; return;
} }
if ((*chain)->hunk->pos != (*chain)->hunk->last) { if ((*chain)->hunk->pos != (*chain)->hunk->last) {
ce->next = (*chain)->next; cl->next = (*chain)->next;
(*chain)->next = ce; (*chain)->next = cl;
} else { } else {
ce->next = (*chain); cl->next = (*chain);
(*chain) = ce; (*chain) = cl;
} }
} }
static int ngx_drain_chains(ngx_event_pipe_t *p) static int ngx_event_pipe_drain_chains(ngx_event_pipe_t *p)
{ {
ngx_hunk_t *h; ngx_hunk_t *h;
ngx_chain_t *ce, *te; ngx_chain_t *cl, *tl;
for ( ;; ) { for ( ;; ) {
if (p->busy) { if (p->busy) {
ce = p->busy; cl = p->busy;
} else if (p->out) { } else if (p->out) {
ce = p->out; cl = p->out;
} else if (p->in) { } else if (p->in) {
ce = p->in; cl = p->in;
} else { } else {
return NGX_OK; return NGX_OK;
} }
while (ce) { while (cl) {
if (ce->hunk->type & NGX_HUNK_LAST_SHADOW) { if (cl->hunk->type & NGX_HUNK_LAST_SHADOW) {
h = ce->hunk->shadow; h = cl->hunk->shadow;
/* THINK NEEDED ??? */ h->pos = h->last = h->start; h->pos = h->last = h->start;
h->shadow = NULL; h->shadow = NULL;
ngx_alloc_ce_and_set_hunk(te, h, p->pool, NGX_ABORT); ngx_alloc_link_and_set_hunk(tl, h, p->pool, NGX_ABORT);
ngx_add_after_partially_filled_hunk(&p->free_raw_hunks, te); ngx_event_pipe_add_free_hunk(&p->free_raw_hunks, tl);
ce->hunk->type &= ~NGX_HUNK_LAST_SHADOW; cl->hunk->type &= ~NGX_HUNK_LAST_SHADOW;
} }
ce->hunk->shadow = NULL; cl->hunk->shadow = NULL;
te = ce->next; tl = cl->next;
ce->next = p->free; cl->next = p->free;
p->free = ce; p->free = cl;
ce = te; cl = tl;
} }
} }
} }

2
src/event/ngx_event_pipe.h
View File

@ -50,7 +50,7 @@ struct ngx_event_pipe_s {
ngx_bufs_t bufs; ngx_bufs_t bufs;
ngx_hunk_tag_t tag; ngx_hunk_tag_t tag;
size_t max_busy_len; size_t busy_size;
off_t temp_offset; off_t temp_offset;
off_t max_temp_file_size; off_t max_temp_file_size;

24
src/http/modules/ngx_http_charset_filter.c
View File

@ -50,9 +50,9 @@ ngx_module_t ngx_http_charset_filter_module = {
}; };
static int (*next_header_filter) (ngx_http_request_t *r); static ngx_http_output_header_filter_pt ngx_http_next_header_filter;
#if 0 #if 0
static int (*next_body_filter) (ngx_http_request_t *r, ngx_chain_t *ch); static ngx_http_output_body_filter_pt ngx_http_next_body_filter;
#endif #endif
@ -62,12 +62,12 @@ static int ngx_http_charset_header_filter(ngx_http_request_t *r)
if (r->headers_out.content_type == NULL if (r->headers_out.content_type == NULL
|| ngx_strncasecmp(r->headers_out.content_type->value.data, || ngx_strncasecmp(r->headers_out.content_type->value.data,
"text/", 5) != 0 "text/", 5) != 0
|| ngx_strstr(r->headers_out.content_type->value.data, "charset") || ngx_strstr(r->headers_out.content_type->value.data, "charset")
!= NULL != NULL
) )
{ {
return next_header_filter(r); return ngx_http_next_header_filter(r);
} }
lcf = ngx_http_get_module_loc_conf(r, ngx_http_charset_filter_module); lcf = ngx_http_get_module_loc_conf(r, ngx_http_charset_filter_module);
@ -75,15 +75,19 @@ static int ngx_http_charset_header_filter(ngx_http_request_t *r)
if (r->headers_out.status == NGX_HTTP_MOVED_PERMANENTLY if (r->headers_out.status == NGX_HTTP_MOVED_PERMANENTLY
&& r->headers_out.status == NGX_HTTP_MOVED_TEMPORARILY) && r->headers_out.status == NGX_HTTP_MOVED_TEMPORARILY)
{ {
/* do not set charset for the redirect because NN 4.x uses this
charset instead of the next page charset */ /*
* do not set charset for the redirect because NN 4.x uses this
* charset instead of the next page charset
*/
r->headers_out.charset.len = 0; r->headers_out.charset.len = 0;
} else if (r->headers_out.charset.len == 0) { } else if (r->headers_out.charset.len == 0) {
r->headers_out.charset = lcf->default_charset; r->headers_out.charset = lcf->default_charset;
} }
return next_header_filter(r); return ngx_http_next_header_filter(r);
} }
@ -91,18 +95,18 @@ static int ngx_http_charset_header_filter(ngx_http_request_t *r)
static int ngx_http_charset_body_filter(ngx_http_request_t *r, ngx_chain_t *in) static int ngx_http_charset_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
{ {
ngx_log_debug(r->connection->log, "CHARSET BODY"); ngx_log_debug(r->connection->log, "CHARSET BODY");
return next_body_filter(r, in); return ngx_http_next_body_filter(r, in);
} }
#endif #endif
static int ngx_http_charset_filter_init(ngx_cycle_t *cycle) static int ngx_http_charset_filter_init(ngx_cycle_t *cycle)
{ {
next_header_filter = ngx_http_top_header_filter; ngx_http_next_header_filter = ngx_http_top_header_filter;
ngx_http_top_header_filter = ngx_http_charset_header_filter; ngx_http_top_header_filter = ngx_http_charset_header_filter;
#if 0 #if 0
next_body_filter = ngx_http_top_body_filter; ngx_http_next_body_filter = ngx_http_top_body_filter;
ngx_http_top_body_filter = ngx_http_charset_body_filter; ngx_http_top_body_filter = ngx_http_charset_body_filter;
#endif #endif

53
src/http/modules/ngx_http_chunked_filter.c
View File

@ -29,14 +29,14 @@ ngx_module_t ngx_http_chunked_filter_module = {
}; };
static int (*next_header_filter) (ngx_http_request_t *r); static ngx_http_output_header_filter_pt ngx_http_next_header_filter;
static int (*next_body_filter) (ngx_http_request_t *r, ngx_chain_t *ch); static ngx_http_output_body_filter_pt ngx_http_next_body_filter;
static int ngx_http_chunked_header_filter(ngx_http_request_t *r) static int ngx_http_chunked_header_filter(ngx_http_request_t *r)
{ {
if (r->headers_out.status == NGX_HTTP_NOT_MODIFIED) { if (r->headers_out.status == NGX_HTTP_NOT_MODIFIED) {
return next_header_filter(r); return ngx_http_next_header_filter(r);
} }
if (r->headers_out.content_length_n == -1) { if (r->headers_out.content_length_n == -1) {
@ -48,7 +48,7 @@ static int ngx_http_chunked_header_filter(ngx_http_request_t *r)
} }
} }
return next_header_filter(r); return ngx_http_next_header_filter(r);
} }
@ -57,36 +57,31 @@ static int ngx_http_chunked_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
char *chunk; char *chunk;
size_t size, len; size_t size, len;
ngx_hunk_t *h; ngx_hunk_t *h;
ngx_chain_t *out, *ce, *te, **le; ngx_chain_t *out, *cl, *tl, **ll;
if (in == NULL || !r->chunked) { if (in == NULL || !r->chunked) {
return next_body_filter(r, in); return ngx_http_next_body_filter(r, in);
} }
ngx_test_null(out, ngx_alloc_chain_entry(r->pool), NGX_ERROR); ngx_test_null(out, ngx_alloc_chain_link(r->pool), NGX_ERROR);
le = &out->next; ll = &out->next;
size = 0; size = 0;
ce = in; cl = in;
for ( ;; ) { for ( ;; ) {
size += ngx_hunk_size(cl->hunk);
if (ce->hunk->type & NGX_HUNK_IN_MEMORY) { ngx_test_null(tl, ngx_alloc_chain_link(r->pool), NGX_ERROR);
size += ce->hunk->last - ce->hunk->pos; tl->hunk = cl->hunk;
} else { *ll = tl;
size += (size_t) (ce->hunk->file_last - ce->hunk->file_pos); ll = &tl->next;
}
ngx_test_null(te, ngx_alloc_chain_entry(r->pool), NGX_ERROR); if (cl->next == NULL) {
te->hunk = ce->hunk;
*le = te;
le = &te->next;
if (ce->next == NULL) {
break; break;
} }
ce = ce->next; cl = cl->next;
} }
ngx_test_null(chunk, ngx_palloc(r->pool, 11), NGX_ERROR); ngx_test_null(chunk, ngx_palloc(r->pool, 11), NGX_ERROR);
@ -101,8 +96,8 @@ static int ngx_http_chunked_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR); ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR);
if (ce->hunk->type & NGX_HUNK_LAST) { if (cl->hunk->type & NGX_HUNK_LAST) {
ce->hunk->type &= ~NGX_HUNK_LAST; cl->hunk->type &= ~NGX_HUNK_LAST;
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_MEMORY|NGX_HUNK_LAST; h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_MEMORY|NGX_HUNK_LAST;
h->pos = CRLF "0" CRLF CRLF; h->pos = CRLF "0" CRLF CRLF;
h->last = h->pos + 7; h->last = h->pos + 7;
@ -113,21 +108,19 @@ static int ngx_http_chunked_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
h->last = h->pos + 2; h->last = h->pos + 2;
} }
ngx_test_null(te, ngx_alloc_chain_entry(r->pool), NGX_ERROR); ngx_alloc_link_and_set_hunk(tl, h, r->pool, NGX_ERROR);
te->hunk = h; *ll = tl;
te->next = NULL;
*le = te;
return next_body_filter(r, out); return ngx_http_next_body_filter(r, out);
} }
static int ngx_http_chunked_filter_init(ngx_cycle_t *cycle) static int ngx_http_chunked_filter_init(ngx_cycle_t *cycle)
{ {
next_header_filter = ngx_http_top_header_filter; ngx_http_next_header_filter = ngx_http_top_header_filter;
ngx_http_top_header_filter = ngx_http_chunked_header_filter; ngx_http_top_header_filter = ngx_http_chunked_header_filter;
next_body_filter = ngx_http_top_body_filter; ngx_http_next_body_filter = ngx_http_top_body_filter;
ngx_http_top_body_filter = ngx_http_chunked_body_filter; ngx_http_top_body_filter = ngx_http_chunked_body_filter;
return NGX_OK; return NGX_OK;

78
src/http/modules/ngx_http_gzip_filter.c
View File

@ -7,9 +7,9 @@
typedef struct { typedef struct {
int enable; int enable;
ngx_bufs_t bufs; ngx_bufs_t bufs;
int no_buffer; int no_buffer;
} ngx_http_gzip_conf_t; } ngx_http_gzip_conf_t;
@ -111,9 +111,8 @@ struct gztrailer {
#endif #endif
static ngx_http_output_header_filter_pt ngx_http_next_header_filter;
static int (*next_header_filter) (ngx_http_request_t *r); static ngx_http_output_body_filter_pt ngx_http_next_body_filter;
static int (*next_body_filter) (ngx_http_request_t *r, ngx_chain_t *ch);
static int ngx_http_gzip_header_filter(ngx_http_request_t *r) static int ngx_http_gzip_header_filter(ngx_http_request_t *r)
@ -134,7 +133,7 @@ static int ngx_http_gzip_header_filter(ngx_http_request_t *r)
|| ngx_strstr(r->headers_in.accept_encoding->value.data, "gzip") == NULL || ngx_strstr(r->headers_in.accept_encoding->value.data, "gzip") == NULL
) )
{ {
return next_header_filter(r); return ngx_http_next_header_filter(r);
} }
/* TODO: "text/html" -> custom types */ /* TODO: "text/html" -> custom types */
@ -142,7 +141,7 @@ static int ngx_http_gzip_header_filter(ngx_http_request_t *r)
&& ngx_strncasecmp(r->headers_out.content_type->value.data, && ngx_strncasecmp(r->headers_out.content_type->value.data,
"text/html", 5) != 0) "text/html", 5) != 0)
{ {
return next_header_filter(r); return ngx_http_next_header_filter(r);
} }
ngx_http_create_ctx(r, ctx, ngx_http_gzip_filter_module, ngx_http_create_ctx(r, ctx, ngx_http_gzip_filter_module,
@ -162,7 +161,7 @@ static int ngx_http_gzip_header_filter(ngx_http_request_t *r)
r->headers_out.content_length = NULL; r->headers_out.content_length = NULL;
r->filter |= NGX_HTTP_FILTER_NEED_IN_MEMORY; r->filter |= NGX_HTTP_FILTER_NEED_IN_MEMORY;
return next_header_filter(r); return ngx_http_next_header_filter(r);
} }
@ -171,14 +170,14 @@ static int ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
int rc, wbits, mem_level, zin, zout, last; int rc, wbits, mem_level, zin, zout, last;
struct gztrailer *trailer; struct gztrailer *trailer;
ngx_hunk_t *h; ngx_hunk_t *h;
ngx_chain_t *ce; ngx_chain_t *cl;
ngx_http_gzip_ctx_t *ctx; ngx_http_gzip_ctx_t *ctx;
ngx_http_gzip_conf_t *conf; ngx_http_gzip_conf_t *conf;
ctx = ngx_http_get_module_ctx(r, ngx_http_gzip_filter_module); ctx = ngx_http_get_module_ctx(r, ngx_http_gzip_filter_module);
if (ctx == NULL) { if (ctx == NULL) {
return next_body_filter(r, in); return ngx_http_next_body_filter(r, in);
} }
conf = ngx_http_get_module_loc_conf(r, ngx_http_gzip_filter_module); conf = ngx_http_get_module_loc_conf(r, ngx_http_gzip_filter_module);
@ -218,12 +217,9 @@ static int ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
h->pos = gzheader; h->pos = gzheader;
h->last = h->pos + 10; h->last = h->pos + 10;
ngx_test_null(ce, ngx_alloc_chain_entry(r->pool), ngx_alloc_link_and_set_hunk(cl, h, r->pool, ngx_http_gzip_error(ctx));
ngx_http_gzip_error(ctx)); ctx->out = cl;
ce->hunk = h; ctx->last_out = &cl->next;
ce->next = NULL;
ctx->out = ce;
ctx->last_out = &ce->next;
ctx->crc32 = crc32(0L, Z_NULL, 0); ctx->crc32 = crc32(0L, Z_NULL, 0);
ctx->flush = Z_NO_FLUSH; ctx->flush = Z_NO_FLUSH;
@ -319,10 +315,10 @@ ngx_log_debug(r->connection->log, "DEFLATE(): %08x %08x %d %d %d" _
if (ctx->zstream.avail_out == 0) { if (ctx->zstream.avail_out == 0) {
ctx->out_hunk->last += conf->bufs.size; ctx->out_hunk->last += conf->bufs.size;
ngx_add_hunk_to_chain(ce, ctx->out_hunk, r->pool, ngx_alloc_link_and_set_hunk(cl, ctx->out_hunk, r->pool,
ngx_http_gzip_error(ctx)); ngx_http_gzip_error(ctx));
*ctx->last_out = ce; *ctx->last_out = cl;
ctx->last_out = &ce->next; ctx->last_out = &cl->next;
ctx->redo = 1; ctx->redo = 1;
} else { } else {
@ -333,10 +329,10 @@ ngx_log_debug(r->connection->log, "DEFLATE(): %08x %08x %d %d %d" _
ctx->out_hunk->type |= NGX_HUNK_FLUSH; ctx->out_hunk->type |= NGX_HUNK_FLUSH;
ctx->flush = Z_NO_FLUSH; ctx->flush = Z_NO_FLUSH;
ngx_add_hunk_to_chain(ce, ctx->out_hunk, r->pool, ngx_alloc_link_and_set_hunk(cl, ctx->out_hunk, r->pool,
ngx_http_gzip_error(ctx)); ngx_http_gzip_error(ctx));
*ctx->last_out = ce; *ctx->last_out = cl;
ctx->last_out = &ce->next; ctx->last_out = &cl->next;
break; break;
@ -355,10 +351,10 @@ ngx_log_debug(r->connection->log, "DEFLATE(): %08x %08x %d %d %d" _
ctx->flush = Z_NO_FLUSH; ctx->flush = Z_NO_FLUSH;
ngx_add_hunk_to_chain(ce, ctx->out_hunk, r->pool, ngx_alloc_link_and_set_hunk(cl, ctx->out_hunk, r->pool,
ngx_http_gzip_error(ctx)); ngx_http_gzip_error(ctx));
*ctx->last_out = ce; *ctx->last_out = cl;
ctx->last_out = &ce->next; ctx->last_out = &cl->next;
if (ctx->zstream.avail_out >= 8) { if (ctx->zstream.avail_out >= 8) {
trailer = (struct gztrailer *) ctx->out_hunk->last; trailer = (struct gztrailer *) ctx->out_hunk->last;
@ -372,12 +368,10 @@ ngx_log_debug(r->connection->log, "DEFLATE(): %08x %08x %d %d %d" _
h->type |= NGX_HUNK_LAST; h->type |= NGX_HUNK_LAST;
ngx_test_null(ce, ngx_alloc_chain_entry(r->pool), ngx_alloc_link_and_set_hunk(cl, h, r->pool,
ngx_http_gzip_error(ctx)); ngx_http_gzip_error(ctx));
ce->hunk = h; *ctx->last_out = cl;
ce->next = NULL; ctx->last_out = &cl->next;
*ctx->last_out = ce;
ctx->last_out = &ce->next;
trailer = (struct gztrailer *) h->pos; trailer = (struct gztrailer *) h->pos;
h->last += 8; h->last += 8;
} }
@ -399,10 +393,10 @@ ngx_log_debug(r->connection->log, "DEFLATE(): %08x %08x %d %d %d" _
break; break;
} else if (conf->no_buffer && ctx->in == NULL) { } else if (conf->no_buffer && ctx->in == NULL) {
ngx_add_hunk_to_chain(ce, ctx->out_hunk, r->pool, ngx_alloc_link_and_set_hunk(cl, ctx->out_hunk, r->pool,
ngx_http_gzip_error(ctx)); ngx_http_gzip_error(ctx));
*ctx->last_out = ce; *ctx->last_out = cl;
ctx->last_out = &ce->next; ctx->last_out = &cl->next;
break; break;
} }
@ -413,7 +407,7 @@ ngx_log_debug(r->connection->log, "DEFLATE(): %08x %08x %d %d %d" _
return last; return last;
} }
last = next_body_filter(r, ctx->out); last = ngx_http_next_body_filter(r, ctx->out);
if (last == NGX_ERROR) { if (last == NGX_ERROR) {
return ngx_http_gzip_error(ctx); return ngx_http_gzip_error(ctx);
@ -443,10 +437,10 @@ ngx_inline static int ngx_http_gzip_error(ngx_http_gzip_ctx_t *ctx)
static int ngx_http_gzip_filter_init(ngx_cycle_t *cycle) static int ngx_http_gzip_filter_init(ngx_cycle_t *cycle)
{ {
next_header_filter = ngx_http_top_header_filter; ngx_http_next_header_filter = ngx_http_top_header_filter;
ngx_http_top_header_filter = ngx_http_gzip_header_filter; ngx_http_top_header_filter = ngx_http_gzip_header_filter;
next_body_filter = ngx_http_top_body_filter; ngx_http_next_body_filter = ngx_http_top_body_filter;
ngx_http_top_body_filter = ngx_http_gzip_body_filter; ngx_http_top_body_filter = ngx_http_gzip_body_filter;
return NGX_OK; return NGX_OK;

12
src/http/modules/ngx_http_not_modified_filter.c
View File

@ -30,7 +30,7 @@ ngx_module_t ngx_http_not_modified_filter_module = {
}; };
static int (*next_header_filter) (ngx_http_request_t *r); static ngx_http_output_header_filter_pt ngx_http_next_header_filter;
static int ngx_http_not_modified_header_filter(ngx_http_request_t *r) static int ngx_http_not_modified_header_filter(ngx_http_request_t *r)
@ -41,7 +41,7 @@ static int ngx_http_not_modified_header_filter(ngx_http_request_t *r)
|| r->headers_in.if_modified_since == NULL || r->headers_in.if_modified_since == NULL
|| r->headers_out.last_modified_time == -1) || r->headers_out.last_modified_time == -1)
{ {
return next_header_filter(r); return ngx_http_next_header_filter(r);
} }
ims = ngx_http_parse_time(r->headers_in.if_modified_since->value.data, ims = ngx_http_parse_time(r->headers_in.if_modified_since->value.data,
@ -50,7 +50,9 @@ static int ngx_http_not_modified_header_filter(ngx_http_request_t *r)
ngx_log_debug(r->connection->log, "%d %d" _ ngx_log_debug(r->connection->log, "%d %d" _
ims _ r->headers_out.last_modified_time); ims _ r->headers_out.last_modified_time);
/* I think that the equality of the dates is correcter */ /*
* I think that the equality of the dates is correcter
*/
if (ims != NGX_ERROR && ims == r->headers_out.last_modified_time) { if (ims != NGX_ERROR && ims == r->headers_out.last_modified_time) {
r->headers_out.status = NGX_HTTP_NOT_MODIFIED; r->headers_out.status = NGX_HTTP_NOT_MODIFIED;
@ -61,13 +63,13 @@ static int ngx_http_not_modified_header_filter(ngx_http_request_t *r)
r->headers_out.accept_ranges->key.len = 0; r->headers_out.accept_ranges->key.len = 0;
} }
return next_header_filter(r); return ngx_http_next_header_filter(r);
} }
static int ngx_http_not_modified_filter_init(ngx_cycle_t *cycle) static int ngx_http_not_modified_filter_init(ngx_cycle_t *cycle)
{ {
next_header_filter = ngx_http_top_header_filter; ngx_http_next_header_filter = ngx_http_top_header_filter;
ngx_http_top_header_filter = ngx_http_not_modified_header_filter; ngx_http_top_header_filter = ngx_http_not_modified_header_filter;
return NGX_OK; return NGX_OK;

58
src/http/modules/ngx_http_range_filter.c
View File

@ -34,8 +34,8 @@ ngx_module_t ngx_http_range_filter_module = {
}; };
static int (*next_header_filter) (ngx_http_request_t *r); static ngx_http_output_header_filter_pt ngx_http_next_header_filter;
static int (*next_body_filter) (ngx_http_request_t *r, ngx_chain_t *ch); static ngx_http_output_body_filter_pt ngx_http_next_body_filter;
static int ngx_http_range_header_filter(ngx_http_request_t *r) static int ngx_http_range_header_filter(ngx_http_request_t *r)
@ -53,7 +53,7 @@ static int ngx_http_range_header_filter(ngx_http_request_t *r)
/* STUB: we currently support ranges for file hunks only */ /* STUB: we currently support ranges for file hunks only */
|| r->filter & NGX_HTTP_FILTER_NEED_IN_MEMORY) || r->filter & NGX_HTTP_FILTER_NEED_IN_MEMORY)
{ {
return next_header_filter(r); return ngx_http_next_header_filter(r);
} }
if (r->headers_in.range == NULL if (r->headers_in.range == NULL
@ -69,7 +69,7 @@ static int ngx_http_range_header_filter(ngx_http_request_t *r)
r->headers_out.accept_ranges->value.len = sizeof("bytes") - 1; r->headers_out.accept_ranges->value.len = sizeof("bytes") - 1;
r->headers_out.accept_ranges->value.data = "bytes"; r->headers_out.accept_ranges->value.data = "bytes";
return next_header_filter(r); return ngx_http_next_header_filter(r);
} }
ngx_init_array(r->headers_out.ranges, r->pool, 5, sizeof(ngx_http_range_t), ngx_init_array(r->headers_out.ranges, r->pool, 5, sizeof(ngx_http_range_t),
@ -279,7 +279,7 @@ static int ngx_http_range_header_filter(ngx_http_request_t *r)
} }
} }
return next_header_filter(r); return ngx_http_next_header_filter(r);
} }
@ -287,16 +287,18 @@ static int ngx_http_range_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
{ {
int i; int i;
ngx_hunk_t *h; ngx_hunk_t *h;
ngx_chain_t *out, *hce, *rce, *dce, **le; ngx_chain_t *out, *hcl, *rcl, *dcl, **ll;
ngx_http_range_t *range; ngx_http_range_t *range;
ngx_http_range_filter_ctx_t *ctx; ngx_http_range_filter_ctx_t *ctx;
if (r->headers_out.ranges.nelts == 0) { if (r->headers_out.ranges.nelts == 0) {
return next_body_filter(r, in); return ngx_http_next_body_filter(r, in);
} }
/* the optimized version for the static files only /*
that are passed in the single file hunk */ * the optimized version for the static files only
* that are passed in the single file hunk
*/
if (in if (in
&& in->hunk->type & NGX_HUNK_FILE && in->hunk->type & NGX_HUNK_FILE
@ -307,11 +309,11 @@ static int ngx_http_range_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
in->hunk->file_pos = range->start; in->hunk->file_pos = range->start;
in->hunk->file_last = range->end; in->hunk->file_last = range->end;
return next_body_filter(r, in); return ngx_http_next_body_filter(r, in);
} }
ctx = ngx_http_get_module_ctx(r, ngx_http_range_filter_module); ctx = ngx_http_get_module_ctx(r, ngx_http_range_filter_module);
le = &out; ll = &out;
range = r->headers_out.ranges.elts; range = r->headers_out.ranges.elts;
for (i = 0; i < r->headers_out.ranges.nelts; i++) { for (i = 0; i < r->headers_out.ranges.nelts; i++) {
@ -321,16 +323,16 @@ static int ngx_http_range_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
h->pos = ctx->boundary_header.data; h->pos = ctx->boundary_header.data;
h->last = ctx->boundary_header.data + ctx->boundary_header.len; h->last = ctx->boundary_header.data + ctx->boundary_header.len;
ngx_test_null(hce, ngx_alloc_chain_entry(r->pool), NGX_ERROR); ngx_test_null(hcl, ngx_alloc_chain_link(r->pool), NGX_ERROR);
hce->hunk = h; hcl->hunk = h;
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR); ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR);
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_TEMP; h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_TEMP;
h->pos = range[i].content_range.data; h->pos = range[i].content_range.data;
h->last = range[i].content_range.data + range[i].content_range.len; h->last = range[i].content_range.data + range[i].content_range.len;
ngx_test_null(rce, ngx_alloc_chain_entry(r->pool), NGX_ERROR); ngx_test_null(rcl, ngx_alloc_chain_link(r->pool), NGX_ERROR);
rce->hunk = h; rcl->hunk = h;
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR); ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR);
h->type = NGX_HUNK_FILE; h->type = NGX_HUNK_FILE;
@ -338,14 +340,12 @@ static int ngx_http_range_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
h->file_last = range[i].end; h->file_last = range[i].end;
h->file = in->hunk->file; h->file = in->hunk->file;
ngx_test_null(dce, ngx_alloc_chain_entry(r->pool), NGX_ERROR); ngx_alloc_link_and_set_hunk(dcl, h, r->pool, NGX_ERROR);
dce->hunk = h;
dce->next = NULL;
*le = hce; *ll = hcl;
hce->next = rce; hcl->next = rcl;
rce->next = dce; rcl->next = dcl;
le = &dce->next; ll = &dcl->next;
} }
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR); ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR);
@ -355,27 +355,25 @@ static int ngx_http_range_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
*h->last++ = '-'; *h->last++ = '-'; *h->last++ = '-'; *h->last++ = '-';
*h->last++ = CR; *h->last++ = LF; *h->last++ = CR; *h->last++ = LF;
ngx_test_null(hce, ngx_alloc_chain_entry(r->pool), NGX_ERROR); ngx_alloc_link_and_set_hunk(hcl, h, r->pool, NGX_ERROR);
hce->hunk = h; *ll = hcl;
hce->next = NULL;
*le = hce;
return next_body_filter(r, out); return ngx_http_next_body_filter(r, out);
} }
/* TODO: several incoming hunks of proxied responses /* TODO: several incoming hunks of proxied responses
and memory hunks on platforms that have no sendfile() */ and memory hunks on platforms that have no sendfile() */
return next_body_filter(r, in); return ngx_http_next_body_filter(r, in);
} }
static int ngx_http_range_filter_init(ngx_cycle_t *cycle) static int ngx_http_range_filter_init(ngx_cycle_t *cycle)
{ {
next_header_filter = ngx_http_top_header_filter; ngx_http_next_header_filter = ngx_http_top_header_filter;
ngx_http_top_header_filter = ngx_http_range_header_filter; ngx_http_top_header_filter = ngx_http_range_header_filter;
next_body_filter = ngx_http_top_body_filter; ngx_http_next_body_filter = ngx_http_top_body_filter;
ngx_http_top_body_filter = ngx_http_range_body_filter; ngx_http_top_body_filter = ngx_http_range_body_filter;
return NGX_OK; return NGX_OK;

192
src/http/modules/proxy/ngx_http_proxy_handler.c
View File

@ -26,6 +26,8 @@ static void ngx_http_proxy_close_connection(ngx_connection_t *c);
static int ngx_http_proxy_init(ngx_cycle_t *cycle); static int ngx_http_proxy_init(ngx_cycle_t *cycle);
static void *ngx_http_proxy_create_loc_conf(ngx_conf_t *cf); static void *ngx_http_proxy_create_loc_conf(ngx_conf_t *cf);
static char *ngx_http_proxy_merge_loc_conf(ngx_conf_t *cf,
void *parent, void *child);
static char *ngx_http_proxy_set_pass(ngx_conf_t *cf, ngx_command_t *cmd, static char *ngx_http_proxy_set_pass(ngx_conf_t *cf, ngx_command_t *cmd,
void *conf); void *conf);
@ -42,6 +44,62 @@ static ngx_command_t ngx_http_proxy_commands[] = {
0, 0,
NULL}, NULL},
{ngx_string("proxy_connect_timeout"),
NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
ngx_conf_set_msec_slot,
NGX_HTTP_LOC_CONF_OFFSET,
offsetof(ngx_http_proxy_loc_conf_t, connect_timeout),
NULL},
{ngx_string("proxy_send_timeout"),
NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
ngx_conf_set_msec_slot,
NGX_HTTP_LOC_CONF_OFFSET,
offsetof(ngx_http_proxy_loc_conf_t, send_timeout),
NULL},
{ngx_string("proxy_header_buffer_size"),
NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
ngx_conf_set_size_slot,
NGX_HTTP_LOC_CONF_OFFSET,
offsetof(ngx_http_proxy_loc_conf_t, header_buffer_size),
NULL},
{ngx_string("proxy_read_timeout"),
NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
ngx_conf_set_msec_slot,
NGX_HTTP_LOC_CONF_OFFSET,
offsetof(ngx_http_proxy_loc_conf_t, read_timeout),
NULL},
{ngx_string("proxy_buffers"),
NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
ngx_conf_set_bufs_slot,
NGX_HTTP_LOC_CONF_OFFSET,
offsetof(ngx_http_proxy_loc_conf_t, bufs),
NULL},
{ngx_string("proxy_busy_buffers_size"),
NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
ngx_conf_set_size_slot,
NGX_HTTP_LOC_CONF_OFFSET,
offsetof(ngx_http_proxy_loc_conf_t, busy_buffers_size),
NULL},
{ngx_string("proxy_temp_path"),
NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1234,
ngx_conf_set_path_slot,
NGX_HTTP_LOC_CONF_OFFSET,
offsetof(ngx_http_proxy_loc_conf_t, temp_path),
NULL},
{ngx_string("proxy_temp_file_write_size"),
NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
ngx_conf_set_size_slot,
NGX_HTTP_LOC_CONF_OFFSET,
offsetof(ngx_http_proxy_loc_conf_t, temp_file_write_size),
NULL},
ngx_null_command ngx_null_command
}; };
@ -54,11 +112,7 @@ ngx_http_module_t ngx_http_proxy_module_ctx = {
NULL, /* merge server configuration */ NULL, /* merge server configuration */
ngx_http_proxy_create_loc_conf, /* create location configration */ ngx_http_proxy_create_loc_conf, /* create location configration */
#if 0 ngx_http_proxy_merge_loc_conf /* merge location configration */
ngx_http_proxy_merge_conf /* merge location configration */
#endif
NULL
}; };
@ -108,7 +162,7 @@ static ngx_http_header_t headers_in[] = {
static char http_version[] = " HTTP/1.0" CRLF; static char http_version[] = " HTTP/1.0" CRLF;
static char host_header[] = "Host: "; static char host_header[] = "Host: ";
static char conn_close_header[] = "Connection: close" CRLF; static char connection_close_header[] = "Connection: close" CRLF;
@ -168,7 +222,7 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
+ sizeof(http_version) - 1 + sizeof(http_version) - 1
+ sizeof(host_header) - 1 + p->host_header.len + 2 + sizeof(host_header) - 1 + p->host_header.len + 2
/* 2 is for "\r\n" */ /* 2 is for "\r\n" */
+ sizeof(conn_close_header) - 1 + sizeof(connection_close_header) - 1
+ 2; /* 2 is for "\r\n" at the header end */ + 2; /* 2 is for "\r\n" at the header end */
header = (ngx_table_elt_t *) r->headers_in.headers->elts; header = (ngx_table_elt_t *) r->headers_in.headers->elts;
@ -189,7 +243,7 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
/* STUB */ len++; /* STUB */ len++;
ngx_test_null(h, ngx_create_temp_hunk(r->pool, len, 0, 0), NULL); ngx_test_null(h, ngx_create_temp_hunk(r->pool, len, 0, 0), NULL);
ngx_add_hunk_to_chain(chain, h, r->pool, NULL); ngx_alloc_link_and_set_hunk(chain, h, r->pool, NULL);
/* the request line */ /* the request line */
@ -220,8 +274,8 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
/* the "Connection: close" header */ /* the "Connection: close" header */
h->last = ngx_cpymem(h->last, conn_close_header, h->last = ngx_cpymem(h->last, connection_close_header,
sizeof(conn_close_header) - 1); sizeof(connection_close_header) - 1);
for (i = 0; i < r->headers_in.headers->nelts; i++) { for (i = 0; i < r->headers_in.headers->nelts; i++) {
@ -341,8 +395,7 @@ static void ngx_http_proxy_send_request(ngx_http_proxy_ctx_t *p)
#if (NGX_SUPPRESS_WARN) #if (NGX_SUPPRESS_WARN)
le = NULL; le = NULL;
#endif #endif
p->work_request_hunks = p->work_request_hunks = ngx_alloc_chain_link(p->request->pool);
ngx_alloc_chain_entry(p->request->pool);
if (p->work_request_hunks == NULL) { if (p->work_request_hunks == NULL) {
ngx_http_proxy_finalize_request(p, ngx_http_proxy_finalize_request(p,
NGX_HTTP_INTERNAL_SERVER_ERROR); NGX_HTTP_INTERNAL_SERVER_ERROR);
@ -357,7 +410,7 @@ static void ngx_http_proxy_send_request(ngx_http_proxy_ctx_t *p)
le = &te->next; le = &te->next;
ce->hunk->pos = ce->hunk->start; ce->hunk->pos = ce->hunk->start;
te = ngx_alloc_chain_entry(p->request->pool); te = ngx_alloc_chain_link(p->request->pool);
if (te == NULL) { if (te == NULL) {
ngx_http_proxy_finalize_request(p, ngx_http_proxy_finalize_request(p,
NGX_HTTP_INTERNAL_SERVER_ERROR); NGX_HTTP_INTERNAL_SERVER_ERROR);
@ -404,7 +457,7 @@ static void ngx_http_proxy_process_upstream_status_line(ngx_event_t *rev)
if (p->header_in == NULL) { if (p->header_in == NULL) {
p->header_in = ngx_create_temp_hunk(p->request->pool, p->header_in = ngx_create_temp_hunk(p->request->pool,
p->lcf->header_size, p->lcf->header_buffer_size,
0, 0); 0, 0);
if (p->header_in == NULL) { if (p->header_in == NULL) {
ngx_http_proxy_finalize_request(p, NGX_HTTP_INTERNAL_SERVER_ERROR); ngx_http_proxy_finalize_request(p, NGX_HTTP_INTERNAL_SERVER_ERROR);
@ -563,10 +616,6 @@ static void ngx_http_proxy_process_upstream_headers(ngx_event_t *rev)
/* there was error while a header line parsing */ /* there was error while a header line parsing */
#if 0
ngx_http_header_parse_error(r, rc);
ngx_http_proxy_next_upstream(p);
#endif
ngx_http_proxy_finalize_request(p, NGX_HTTP_BAD_GATEWAY); ngx_http_proxy_finalize_request(p, NGX_HTTP_BAD_GATEWAY);
return; return;
} }
@ -692,10 +741,8 @@ static void ngx_http_proxy_send_response(ngx_http_proxy_ctx_t *p)
/* */ /* */
#if 0
/* TODO: look "Content-Length" */ /* TODO: preallocate event_pipe hunks, look "Content-Length" */
p->block_size = p->lcf->block_size;
#endif
r->headers_out.status = p->status; r->headers_out.status = p->status;
@ -715,7 +762,7 @@ static void ngx_http_proxy_send_response(ngx_http_proxy_ctx_t *p)
ep->output_ctx = r; ep->output_ctx = r;
ep->tag = (ngx_hunk_tag_t) &ngx_http_proxy_module; ep->tag = (ngx_hunk_tag_t) &ngx_http_proxy_module;
ep->bufs = p->lcf->bufs; ep->bufs = p->lcf->bufs;
ep->max_busy_len = p->lcf->max_busy_len; ep->busy_size = p->lcf->busy_buffers_size;
ep->upstream = p->upstream.connection; ep->upstream = p->upstream.connection;
ep->downstream = r->connection; ep->downstream = r->connection;
ep->pool = r->pool; ep->pool = r->pool;
@ -736,7 +783,7 @@ static void ngx_http_proxy_send_response(ngx_http_proxy_ctx_t *p)
ep->temp_file_warn = "an upstream response is buffered " ep->temp_file_warn = "an upstream response is buffered "
"to a temporary file"; "to a temporary file";
ep->preread_hunks = ngx_alloc_chain_entry(r->pool); ep->preread_hunks = ngx_alloc_chain_link(r->pool);
if (ep->preread_hunks == NULL) { if (ep->preread_hunks == NULL) {
ngx_http_proxy_finalize_request(p, 0); ngx_http_proxy_finalize_request(p, 0);
return; return;
@ -758,8 +805,8 @@ static void ngx_http_proxy_send_response(ngx_http_proxy_ctx_t *p)
/* /*
* we need to disable the use of sendfile() if we use cyclic temp file * we need to disable the use of sendfile() if we use cyclic temp file
* because the writing a new data can interfere with sendfile * because the writing a new data can interfere with sendfile()
* that uses the same kernel file pages * that uses the same kernel file pages (at least on FreeBSD)
*/ */
ep->cyclic_temp_file = 1; ep->cyclic_temp_file = 1;
@ -1160,58 +1207,72 @@ static void *ngx_http_proxy_create_loc_conf(ngx_conf_t *cf)
ngx_pcalloc(cf->pool, sizeof(ngx_http_proxy_loc_conf_t)), ngx_pcalloc(cf->pool, sizeof(ngx_http_proxy_loc_conf_t)),
NGX_CONF_ERROR); NGX_CONF_ERROR);
/* STUB */ /* set by ngx_pcalloc():
ngx_test_null(conf->peers, ngx_pcalloc(cf->pool, sizeof(ngx_peers_t)),
NGX_CONF_ERROR);
conf->peers->number = 1; conf->bufs.num = 0;
conf->peers->peers[0].addr = inet_addr("127.0.0.1");
conf->peers->peers[0].host.data = "localhost";
conf->peers->peers[0].host.len = sizeof("localhost") - 1;
conf->peers->peers[0].port = htons(9000);
conf->peers->peers[0].addr_port_text.data = "127.0.0.1:9000";
conf->peers->peers[0].addr_port_text.len = sizeof("127.0.0.1:9000") - 1;
conf->connect_timeout = 30000; conf->path = NULL;
conf->send_timeout = 30000;
conf->header_size = 4096;
conf->read_timeout = 30000;
conf->bufs.num = 5; conf->upstreams = NULL;
conf->bufs.size = 4096; conf->peers = NULL;
conf->max_busy_len = 8192;
*/
/* CHECK in _init conf->max_temp_size >= conf->bufs.size !!! */ conf->connect_timeout = NGX_CONF_UNSET;
conf->max_temp_file_size = 4096 * 3; conf->send_timeout = NGX_CONF_UNSET;
conf->header_buffer_size = NGX_CONF_UNSET;
conf->read_timeout = NGX_CONF_UNSET;
conf->busy_buffers_size = NGX_CONF_UNSET;
/*
* "proxy_max_temp_file_size" is hardcoded to 1G for reverse proxy,
* it should be configurable in the generic proxy
*/
conf->max_temp_file_size = 1024 * 1024 * 1024;
conf->temp_file_write_size = 4096 * 2; conf->temp_file_write_size = NGX_CONF_UNSET;
conf->cyclic_temp_file= 1;
ngx_test_null(conf->temp_path, ngx_pcalloc(cf->pool, sizeof(ngx_path_t)), /* "proxy_cyclic_temp_file" is disabled */
NULL); conf->cyclic_temp_file = 0;
conf->temp_path->name.data = "temp";
conf->temp_path->name.len = 4;
conf->temp_path->level[0] = 1;
conf->temp_path->level[1] = 2;
conf->temp_path->level[2] = 3;
conf->temp_path->len = 0;
for (i = 0; i < 3; i++) {
if (conf->temp_path->level[i] == 0) {
break;
}
conf->temp_path->len += conf->temp_path->level[i] + 1;
}
/* */
return conf; return conf;
} }
static char *ngx_http_proxy_merge_loc_conf(ngx_conf_t *cf,
void *parent, void *child)
{
ngx_http_proxy_loc_conf_t *prev = parent;
ngx_http_proxy_loc_conf_t *conf = child;
ngx_conf_merge_msec_value(conf->connect_timeout,
prev->connect_timeout, 60000);
ngx_conf_merge_msec_value(conf->send_timeout, prev->send_timeout, 30000);
ngx_conf_merge_size_value(conf->header_buffer_size,
prev->header_buffer_size, 4096);
ngx_conf_merge_msec_value(conf->read_timeout, prev->read_timeout, 30000);
ngx_conf_merge_bufs_value(conf->bufs, prev->bufs, 8, 4096);
ngx_conf_merge_size_value(conf->busy_buffers_size,
prev->busy_buffers_size, 8192);
#if 0
if (conf->max_temp_file_size > conf->bufs.size) {
return "\"proxy_max_temp_file\" must be greater "
"than one of the \"proxy_buffers\"";
}
#endif
ngx_conf_merge_size_value(conf->temp_file_write_size,
prev->temp_file_write_size, 16384);
ngx_conf_merge_path_value(conf->temp_path, prev->temp_path,
"temp", 1, 2, 0, cf->pool);
return NULL;
}
static char *ngx_http_proxy_set_pass(ngx_conf_t *cf, ngx_command_t *cmd, static char *ngx_http_proxy_set_pass(ngx_conf_t *cf, ngx_command_t *cmd,
void *conf) void *conf)
{ {
@ -1337,6 +1398,7 @@ static char *ngx_http_proxy_set_pass(ngx_conf_t *cf, ngx_command_t *cmd,
return NULL; return NULL;
} }
static char *ngx_http_proxy_parse_upstream(ngx_str_t *url, static char *ngx_http_proxy_parse_upstream(ngx_str_t *url,
ngx_http_proxy_upstream_t *u) ngx_http_proxy_upstream_t *u)
{ {

10
src/http/modules/proxy/ngx_http_proxy_handler.h
View File

@ -21,17 +21,15 @@ typedef struct {
typedef struct { typedef struct {
ngx_msec_t connect_timeout; ngx_msec_t connect_timeout;
ngx_msec_t send_timeout; ngx_msec_t send_timeout;
ssize_t header_size; ssize_t header_buffer_size;
ngx_msec_t read_timeout; ngx_msec_t read_timeout;
ngx_bufs_t bufs; ngx_bufs_t bufs;
ssize_t busy_buffers_size;
/* STUB names */ ssize_t max_temp_file_size;
int max_busy_len; ssize_t temp_file_write_size;
int max_temp_file_size;
int temp_file_write_size;
int cyclic_temp_file; int cyclic_temp_file;
/* */
ngx_path_t *temp_path; ngx_path_t *temp_path;

13
src/http/ngx_http.h
View File

@ -17,12 +17,6 @@ typedef struct {
} ngx_http_log_ctx_t; } ngx_http_log_ctx_t;
typedef int (*ngx_http_output_header_filter_p)(ngx_http_request_t *r);
typedef int (*ngx_http_output_body_filter_p)
(ngx_http_request_t *r, ngx_chain_t *chain);
#define ngx_http_get_module_ctx(r, module) r->ctx[module.ctx_index] #define ngx_http_get_module_ctx(r, module) r->ctx[module.ctx_index]
#define ngx_http_create_ctx(r, cx, module, size, error) \ #define ngx_http_create_ctx(r, cx, module, size, error) \
@ -82,13 +76,6 @@ extern ngx_module_t ngx_http_module;
extern int ngx_max_module; extern int ngx_max_module;
extern ngx_array_t ngx_http_translate_handlers;
extern ngx_array_t ngx_http_index_handlers;
extern int (*ngx_http_top_header_filter) (ngx_http_request_t *r);
extern int (*ngx_http_top_body_filter) (ngx_http_request_t *r, ngx_chain_t *ch);
/* STUB */ /* STUB */
int ngx_http_log_handler(ngx_http_request_t *r); int ngx_http_log_handler(ngx_http_request_t *r);
/**/ /**/

1
src/http/ngx_http_core_module.c
View File

@ -226,6 +226,7 @@ void ngx_http_handler(ngx_http_request_t *r)
} }
#if 0 #if 0
/* TEST STUB */ r->http_version = NGX_HTTP_VERSION_10;
/* TEST STUB */ r->keepalive = 0; /* TEST STUB */ r->keepalive = 0;
#endif #endif

13
src/http/ngx_http_filter.h
View File

@ -7,12 +7,17 @@
#define NGX_HTTP_FILTER_NEED_TEMP 4 #define NGX_HTTP_FILTER_NEED_TEMP 4
int ngx_http_output_filter(ngx_http_request_t *r, ngx_chain_t *in); typedef int (*ngx_http_output_header_filter_pt)(ngx_http_request_t *r);
int ngx_http_write_filter(ngx_http_request_t *r, ngx_chain_t *in); typedef int (*ngx_http_output_body_filter_pt)
(ngx_http_request_t *r, ngx_chain_t *chain);
extern int (*ngx_http_top_header_filter) (ngx_http_request_t *r); int ngx_http_output_filter(ngx_http_request_t *r, ngx_chain_t *chain);
extern int (*ngx_http_top_body_filter) (ngx_http_request_t *r, ngx_chain_t *ch); int ngx_http_write_filter(ngx_http_request_t *r, ngx_chain_t *chain);
extern ngx_http_output_header_filter_pt ngx_http_top_header_filter;
extern ngx_http_output_body_filter_pt ngx_http_top_body_filter;
#endif /* _NGX_HTTP_FILTER_H_INCLUDED_ */ #endif /* _NGX_HTTP_FILTER_H_INCLUDED_ */

1
src/http/ngx_http_header_filter.c
View File

@ -371,5 +371,6 @@ static int ngx_http_header_filter(ngx_http_request_t *r)
static int ngx_http_header_filter_init(ngx_cycle_t *cycle) static int ngx_http_header_filter_init(ngx_cycle_t *cycle)
{ {
ngx_http_top_header_filter = ngx_http_header_filter; ngx_http_top_header_filter = ngx_http_header_filter;
return NGX_OK; return NGX_OK;
} }

73
src/http/ngx_http_output_filter.c
View File

@ -32,6 +32,8 @@ typedef struct {
} ngx_http_output_filter_ctx_t; } ngx_http_output_filter_ctx_t;
ngx_inline static int ngx_http_output_filter_need_to_copy(ngx_http_request_t *r,
ngx_hunk_t *hunk);
static int ngx_http_output_filter_copy_hunk(ngx_hunk_t *dst, ngx_hunk_t *src, static int ngx_http_output_filter_copy_hunk(ngx_hunk_t *dst, ngx_hunk_t *src,
int sendfile); int sendfile);
static void *ngx_http_output_filter_create_conf(ngx_conf_t *cf); static void *ngx_http_output_filter_create_conf(ngx_conf_t *cf);
@ -74,23 +76,12 @@ ngx_module_t ngx_http_output_filter_module = {
}; };
#define ngx_next_filter (*ngx_http_top_body_filter)
#define need_to_copy(r, hunk) \
(!ngx_hunk_special(hunk) \
&& (!r->sendfile \
|| ((r->filter & NGX_HTTP_FILTER_NEED_IN_MEMORY) \
&& (hunk->type & NGX_HUNK_IN_MEMORY) == 0) \
|| ((r->filter & NGX_HTTP_FILTER_NEED_TEMP) \
&& (hunk->type & (NGX_HUNK_MEMORY|NGX_HUNK_MMAP)))))
int ngx_http_output_filter(ngx_http_request_t *r, ngx_chain_t *in) int ngx_http_output_filter(ngx_http_request_t *r, ngx_chain_t *in)
{ {
int rc, last; int rc, last;
ssize_t size; ssize_t size;
ngx_chain_t *ce; ngx_chain_t *cl;
ngx_http_output_filter_ctx_t *ctx; ngx_http_output_filter_ctx_t *ctx;
ngx_http_output_filter_conf_t *conf; ngx_http_output_filter_conf_t *conf;
@ -112,11 +103,13 @@ int ngx_http_output_filter(ngx_http_request_t *r, ngx_chain_t *in)
if (ctx->in == NULL) { if (ctx->in == NULL) {
if (in == NULL) { if (in == NULL) {
return ngx_next_filter(r, in); return ngx_http_top_body_filter(r, in);
} }
if (in->next == NULL && (!need_to_copy(r, in->hunk))) { if (in->next == NULL
return ngx_next_filter(r, in); && (!ngx_http_output_filter_need_to_copy(r, in->hunk)))
{
return ngx_http_top_body_filter(r, in);
} }
} }
@ -137,16 +130,16 @@ int ngx_http_output_filter(ngx_http_request_t *r, ngx_chain_t *in)
while (ctx->in) { while (ctx->in) {
if (!need_to_copy(r, ctx->in->hunk)) { if (!ngx_http_output_filter_need_to_copy(r, ctx->in->hunk)) {
/* move the chain entry to the chain ctx->out */ /* move the chain link to the chain ctx->out */
ce = ctx->in; cl = ctx->in;
ctx->in = ce->next; ctx->in = cl->next;
*ctx->last_out = ce; *ctx->last_out = cl;
ctx->last_out = &ce->next; ctx->last_out = &cl->next;
ce->next = NULL; cl->next = NULL;
continue; continue;
} }
@ -204,9 +197,9 @@ int ngx_http_output_filter(ngx_http_request_t *r, ngx_chain_t *in)
ctx->in = ctx->in->next; ctx->in = ctx->in->next;
} }
ngx_add_hunk_to_chain(ce, ctx->hunk, r->pool, NGX_ERROR); ngx_alloc_link_and_set_hunk(cl, ctx->hunk, r->pool, NGX_ERROR);
*ctx->last_out = ce; *ctx->last_out = cl;
ctx->last_out = &ce->next; ctx->last_out = &cl->next;
ctx->hunk = NULL; ctx->hunk = NULL;
if (ctx->free == NULL) { if (ctx->free == NULL) {
@ -218,7 +211,7 @@ int ngx_http_output_filter(ngx_http_request_t *r, ngx_chain_t *in)
return last; return last;
} }
last = ngx_next_filter(r, ctx->out); last = ngx_http_top_body_filter(r, ctx->out);
ngx_chain_update_chains(&ctx->free, &ctx->busy, &ctx->out, ngx_chain_update_chains(&ctx->free, &ctx->busy, &ctx->out,
(ngx_hunk_tag_t) &ngx_http_output_filter_module); (ngx_hunk_tag_t) &ngx_http_output_filter_module);
@ -227,6 +220,34 @@ int ngx_http_output_filter(ngx_http_request_t *r, ngx_chain_t *in)
} }
ngx_inline static int ngx_http_output_filter_need_to_copy(ngx_http_request_t *r,
ngx_hunk_t *hunk)
{
if (ngx_hunk_special(hunk)) {
return 0;
}
if (!r->sendfile) {
return 1;
}
if ((r->filter & NGX_HTTP_FILTER_NEED_IN_MEMORY)
&& (!(hunk->type & NGX_HUNK_IN_MEMORY)))
{
return 1;
}
if ((r->filter & NGX_HTTP_FILTER_NEED_TEMP)
&& (hunk->type & (NGX_HUNK_MEMORY|NGX_HUNK_MMAP)))
{
return 1;
}
return 0;
}
static int ngx_http_output_filter_copy_hunk(ngx_hunk_t *dst, ngx_hunk_t *src, static int ngx_http_output_filter_copy_hunk(ngx_hunk_t *dst, ngx_hunk_t *src,
int sendfile) int sendfile)
{ {

4
src/http/ngx_http_request.c
View File

@ -49,17 +49,17 @@ static ngx_http_header_t headers_in[] = {
{ ngx_string("Connection"), offsetof(ngx_http_headers_in_t, connection) }, { ngx_string("Connection"), offsetof(ngx_http_headers_in_t, connection) },
{ ngx_string("If-Modified-Since"), { ngx_string("If-Modified-Since"),
offsetof(ngx_http_headers_in_t, if_modified_since) }, offsetof(ngx_http_headers_in_t, if_modified_since) },
{ ngx_string("User-Agent"), offsetof(ngx_http_headers_in_t, user_agent) },
{ ngx_string("Content-Length"), { ngx_string("Content-Length"),
offsetof(ngx_http_headers_in_t, content_length) }, offsetof(ngx_http_headers_in_t, content_length) },
{ ngx_string("Accept-Encoding"), { ngx_string("Accept-Encoding"),
offsetof(ngx_http_headers_in_t, accept_encoding) }, offsetof(ngx_http_headers_in_t, accept_encoding) },
{ ngx_string("Range"), offsetof(ngx_http_headers_in_t, range) }, { ngx_string("Range"), offsetof(ngx_http_headers_in_t, range) },
#if 0 #if 0
{ ngx_string("If-Range"), offsetof(ngx_http_headers_in_t, if_range) }, { ngx_string("If-Range"), offsetof(ngx_http_headers_in_t, if_range) },
#endif #endif
{ ngx_string("User-Agent"), offsetof(ngx_http_headers_in_t, user_agent) },
{ ngx_string("Keep-Alive"), offsetof(ngx_http_headers_in_t, keep_alive) }, { ngx_string("Keep-Alive"), offsetof(ngx_http_headers_in_t, keep_alive) },
{ ngx_null_string, 0 } { ngx_null_string, 0 }

6
src/http/ngx_http_request.h
View File

@ -66,12 +66,12 @@ typedef struct {
ngx_table_elt_t *host; ngx_table_elt_t *host;
ngx_table_elt_t *connection; ngx_table_elt_t *connection;
ngx_table_elt_t *if_modified_since; ngx_table_elt_t *if_modified_since;
ngx_table_elt_t *user_agent;
ngx_table_elt_t *content_length; ngx_table_elt_t *content_length;
ngx_table_elt_t *accept_encoding;
ngx_table_elt_t *range; ngx_table_elt_t *range;
ngx_table_elt_t *accept_encoding;
ngx_table_elt_t *user_agent;
ngx_table_elt_t *keep_alive; ngx_table_elt_t *keep_alive;
size_t host_name_len; size_t host_name_len;

16
src/http/ngx_http_special_response.c
View File

@ -154,7 +154,7 @@ int ngx_http_special_response_handler(ngx_http_request_t *r, int error)
{ {
int err, rc; int err, rc;
ngx_hunk_t *h; ngx_hunk_t *h;
ngx_chain_t *out, **le, *ce; ngx_chain_t *out, **ll, *cl;
r->headers_out.status = error; r->headers_out.status = error;
@ -219,15 +219,15 @@ int ngx_http_special_response_handler(ngx_http_request_t *r, int error)
} }
out = NULL; out = NULL;
le = NULL; ll = NULL;
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR); ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR);
h->type = NGX_HUNK_MEMORY|NGX_HUNK_IN_MEMORY; h->type = NGX_HUNK_MEMORY|NGX_HUNK_IN_MEMORY;
h->pos = error_pages[err].data; h->pos = error_pages[err].data;
h->last = error_pages[err].data + error_pages[err].len; h->last = error_pages[err].data + error_pages[err].len;
ngx_alloc_ce_and_set_hunk(ce, h, r->pool, NGX_ERROR); ngx_alloc_link_and_set_hunk(cl, h, r->pool, NGX_ERROR);
ngx_chain_add_ce(out, le, ce); ngx_chain_add_link(out, ll, cl);
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR); ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR);
@ -235,8 +235,8 @@ int ngx_http_special_response_handler(ngx_http_request_t *r, int error)
h->pos = error_tail; h->pos = error_tail;
h->last = error_tail + sizeof(error_tail) - 1; h->last = error_tail + sizeof(error_tail) - 1;
ngx_alloc_ce_and_set_hunk(ce, h, r->pool, NGX_ERROR); ngx_alloc_link_and_set_hunk(cl, h, r->pool, NGX_ERROR);
ngx_chain_add_ce(out, le, ce); ngx_chain_add_link(out, ll, cl);
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
@ -249,8 +249,8 @@ int ngx_http_special_response_handler(ngx_http_request_t *r, int error)
h->pos = msie_stub; h->pos = msie_stub;
h->last = msie_stub + sizeof(msie_stub) - 1; h->last = msie_stub + sizeof(msie_stub) - 1;
ngx_alloc_ce_and_set_hunk(ce, h, r->pool, NGX_ERROR); ngx_alloc_link_and_set_hunk(cl, h, r->pool, NGX_ERROR);
ngx_chain_add_ce(out, le, ce); ngx_chain_add_link(out, ll, cl);
} }
h->type |= NGX_HUNK_LAST; h->type |= NGX_HUNK_LAST;

33
src/http/ngx_http_write_filter.c
View File

@ -60,7 +60,7 @@ int ngx_http_write_filter(ngx_http_request_t *r, ngx_chain_t *in)
{ {
int last; int last;
off_t size, flush; off_t size, flush;
ngx_chain_t *ce, **le, *chain; ngx_chain_t *cl, **ll, *chain;
ngx_http_write_filter_ctx_t *ctx; ngx_http_write_filter_ctx_t *ctx;
ngx_http_write_filter_conf_t *conf; ngx_http_write_filter_conf_t *conf;
@ -74,20 +74,20 @@ int ngx_http_write_filter(ngx_http_request_t *r, ngx_chain_t *in)
size = flush = 0; size = flush = 0;
last = 0; last = 0;
le = &ctx->out; ll = &ctx->out;
/* find the size, the flush point and the last entry of the saved chain */ /* find the size, the flush point and the last link of the saved chain */
for (ce = ctx->out; ce; ce = ce->next) { for (cl = ctx->out; cl; cl = cl->next) {
le = &ce->next; ll = &cl->next;
size += ngx_hunk_size(ce->hunk); size += ngx_hunk_size(cl->hunk);
if (ce->hunk->type & (NGX_HUNK_FLUSH|NGX_HUNK_RECYCLED)) { if (cl->hunk->type & (NGX_HUNK_FLUSH|NGX_HUNK_RECYCLED)) {
flush = size; flush = size;
} }
if (ce->hunk->type & NGX_HUNK_LAST) { if (cl->hunk->type & NGX_HUNK_LAST) {
last = 1; last = 1;
} }
} }
@ -95,20 +95,17 @@ int ngx_http_write_filter(ngx_http_request_t *r, ngx_chain_t *in)
/* add the new chain to the existent one */ /* add the new chain to the existent one */
for (/* void */; in; in = in->next) { for (/* void */; in; in = in->next) {
ngx_test_null(ce, ngx_alloc_chain_entry(r->pool), NGX_ERROR); ngx_alloc_link_and_set_hunk(cl, in->hunk, r->pool, NGX_ERROR);
*ll = cl;
ll = &cl->next;
ce->hunk = in->hunk; size += ngx_hunk_size(cl->hunk);
ce->next = NULL;
*le = ce;
le = &ce->next;
size += ngx_hunk_size(ce->hunk); if (cl->hunk->type & (NGX_HUNK_FLUSH|NGX_HUNK_RECYCLED)) {
if (ce->hunk->type & (NGX_HUNK_FLUSH|NGX_HUNK_RECYCLED)) {
flush = size; flush = size;
} }
if (ce->hunk->type & NGX_HUNK_LAST) { if (cl->hunk->type & NGX_HUNK_LAST) {
last = 1; last = 1;
} }
} }
@ -124,7 +121,7 @@ int ngx_http_write_filter(ngx_http_request_t *r, ngx_chain_t *in)
/* /*
* avoid the output if there is no last hunk, no flush point and * avoid the output if there is no last hunk, no flush point and
* size of the hunks is smaller then "buffer_output" * the size of the hunks is smaller than "buffer_output" directive
*/ */
if (!last && flush == 0 && size < conf->buffer_output) { if (!last && flush == 0 && size < conf->buffer_output) {

66
src/os/unix/freebsd/ngx_sendfile.c
View File

@ -1,66 +0,0 @@
#include <ngx_config.h>
#if (HAVE_FREEBSD_SENDFILE)
#include <ngx_core.h>
#include <ngx_types.h>
#include <ngx_socket.h>
#include <ngx_errno.h>
#include <ngx_log.h>
#include <ngx_connection.h>
#include <ngx_sendv.h>
#include <ngx_sendfile.h>
/*
CHECK:
check sent if errno == EINTR then should return right sent.
EINTR should not occur according to man.
*/
int ngx_sendfile(ngx_connection_t *c,
ngx_iovec_t *headers, int hdr_cnt,
ngx_fd_t fd, off_t offset, size_t nbytes,
ngx_iovec_t *trailers, int trl_cnt,
off_t *sent, u_int flags)
{
int rc, i;
ngx_err_t err;
struct sf_hdtr hdtr;
hdtr.headers = headers;
hdtr.hdr_cnt = hdr_cnt;
hdtr.trailers = trailers;
hdtr.trl_cnt = trl_cnt;
#if (HAVE_FREEBSD_SENDFILE_NBYTES_BUG)
for (i = 0; i < hdr_cnt; i++) {
nbytes += headers[i].iov_len;
}
#endif
rc = sendfile(fd, c->fd, offset, nbytes, &hdtr, sent, flags);
if (rc == -1) {
err = ngx_errno;
if (err != NGX_EAGAIN && err != NGX_EINTR) {
ngx_log_error(NGX_LOG_ERR, c->log, err, "sendfile failed");
return NGX_ERROR;
} else {
ngx_log_error(NGX_LOG_INFO, c->log, err,
"sendfile sent only %qd bytes", *sent);
return NGX_AGAIN;
}
}
ngx_log_debug(c->log, "sendfile: %d, @%qd %qd:%d" _
rc _ offset _ *sent _ nbytes);
return NGX_OK;
}
#endif

96
src/os/unix/ngx_freebsd_sendfile_chain.c
View File

@ -32,14 +32,14 @@ ngx_chain_t *ngx_freebsd_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in)
ngx_err_t err; ngx_err_t err;
ngx_array_t header, trailer; ngx_array_t header, trailer;
ngx_hunk_t *file; ngx_hunk_t *file;
ngx_chain_t *ce, *tail; ngx_chain_t *cl, *tail;
if (!c->write->ready) { if (!c->write->ready) {
return in; return in;
} }
do { do {
ce = in; cl = in;
file = NULL; file = NULL;
fsize = 0; fsize = 0;
hsize = 0; hsize = 0;
@ -51,80 +51,80 @@ ngx_chain_t *ngx_freebsd_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in)
ngx_init_array(trailer, c->pool, 10, sizeof(struct iovec), ngx_init_array(trailer, c->pool, 10, sizeof(struct iovec),
NGX_CHAIN_ERROR); NGX_CHAIN_ERROR);
/* create the iovec and coalesce the neighbouring chain entries */ /* create the header iovec and coalesce the neighbouring hunks */
prev = NULL; prev = NULL;
iov = NULL; iov = NULL;
for (ce = in; ce; ce = ce->next) { for (cl = in; cl; cl = cl->next) {
if (ngx_hunk_special(ce->hunk)) { if (ngx_hunk_special(cl->hunk)) {
continue; continue;
} }
if (!ngx_hunk_in_memory_only(ce->hunk)) { if (!ngx_hunk_in_memory_only(cl->hunk)) {
break; break;
} }
if (prev == ce->hunk->pos) { if (prev == cl->hunk->pos) {
iov->iov_len += ce->hunk->last - ce->hunk->pos; iov->iov_len += cl->hunk->last - cl->hunk->pos;
prev = ce->hunk->last; prev = cl->hunk->last;
} else { } else {
ngx_test_null(iov, ngx_push_array(&header), NGX_CHAIN_ERROR); ngx_test_null(iov, ngx_push_array(&header), NGX_CHAIN_ERROR);
iov->iov_base = ce->hunk->pos; iov->iov_base = cl->hunk->pos;
iov->iov_len = ce->hunk->last - ce->hunk->pos; iov->iov_len = cl->hunk->last - cl->hunk->pos;
prev = ce->hunk->last; prev = cl->hunk->last;
} }
hsize += ce->hunk->last - ce->hunk->pos; hsize += cl->hunk->last - cl->hunk->pos;
} }
/* get the file hunk */ /* get the file hunk */
if (ce && (ce->hunk->type & NGX_HUNK_FILE)) { if (cl && (cl->hunk->type & NGX_HUNK_FILE)) {
file = ce->hunk; file = cl->hunk;
fsize = (size_t) (file->file_last - file->file_pos); fsize = (size_t) (file->file_last - file->file_pos);
fprev = file->file_last; fprev = file->file_last;
ce = ce->next; cl = cl->next;
/* coalesce the neighbouring file hunks */ /* coalesce the neighbouring file hunks */
while (ce && (ce->hunk->type & NGX_HUNK_FILE)) { while (cl && (cl->hunk->type & NGX_HUNK_FILE)) {
if (file->file->fd != ce->hunk->file->fd if (file->file->fd != cl->hunk->file->fd
|| fprev != ce->hunk->file_pos) || fprev != cl->hunk->file_pos)
{ {
break; break;
} }
fsize += (size_t) (ce->hunk->file_last - ce->hunk->file_pos); fsize += (size_t) (cl->hunk->file_last - cl->hunk->file_pos);
fprev = ce->hunk->file_last; fprev = cl->hunk->file_last;
ce = ce->next; cl = cl->next;
} }
} }
/* create the iovec and coalesce the neighbouring chain entries */ /* create the tailer iovec and coalesce the neighbouring hunks */
prev = NULL; prev = NULL;
iov = NULL; iov = NULL;
for ( /* void */; ce; ce = ce->next) { for ( /* void */; cl; cl = cl->next) {
if (ngx_hunk_special(ce->hunk)) { if (ngx_hunk_special(cl->hunk)) {
continue; continue;
} }
if (!ngx_hunk_in_memory_only(ce->hunk)) { if (!ngx_hunk_in_memory_only(cl->hunk)) {
break; break;
} }
if (prev == ce->hunk->pos) { if (prev == cl->hunk->pos) {
iov->iov_len += ce->hunk->last - ce->hunk->pos; iov->iov_len += cl->hunk->last - cl->hunk->pos;
prev = ce->hunk->last; prev = cl->hunk->last;
} else { } else {
ngx_test_null(iov, ngx_push_array(&trailer), NGX_CHAIN_ERROR); ngx_test_null(iov, ngx_push_array(&trailer), NGX_CHAIN_ERROR);
iov->iov_base = ce->hunk->pos; iov->iov_base = cl->hunk->pos;
iov->iov_len = ce->hunk->last - ce->hunk->pos; iov->iov_len = cl->hunk->last - cl->hunk->pos;
prev = ce->hunk->last; prev = cl->hunk->last;
} }
} }
@ -133,7 +133,7 @@ ngx_chain_t *ngx_freebsd_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in)
* a single sendfile() capability * a single sendfile() capability
*/ */
tail = ce; tail = cl;
if (file) { if (file) {
@ -155,7 +155,7 @@ ngx_log_debug(c->log, "NOPUSH");
hdtr.trl_cnt = trailer.nelts; hdtr.trl_cnt = trailer.nelts;
/* /*
* the old sendfile() "nbytes bug": * the "nbytes bug" of the old sendfile() syscall:
* http://www.freebsd.org/cgi/query-pr.cgi?pr=33771 * http://www.freebsd.org/cgi/query-pr.cgi?pr=33771
*/ */
@ -220,9 +220,9 @@ ngx_log_debug(c->log, "NOPUSH");
c->sent += sent; c->sent += sent;
for (ce = in; ce; ce = ce->next) { for (cl = in; cl; cl = cl->next) {
if (ngx_hunk_special(ce->hunk)) { if (ngx_hunk_special(cl->hunk)) {
continue; continue;
} }
@ -230,41 +230,43 @@ ngx_log_debug(c->log, "NOPUSH");
break; break;
} }
size = ngx_hunk_size(ce->hunk); size = ngx_hunk_size(cl->hunk);
if (sent >= size) { if (sent >= size) {
sent -= size; sent -= size;
if (ce->hunk->type & NGX_HUNK_IN_MEMORY) { if (cl->hunk->type & NGX_HUNK_IN_MEMORY) {
ce->hunk->pos = ce->hunk->last; cl->hunk->pos = cl->hunk->last;
} }
if (ce->hunk->type & NGX_HUNK_FILE) { if (cl->hunk->type & NGX_HUNK_FILE) {
ce->hunk->file_pos = ce->hunk->file_last; cl->hunk->file_pos = cl->hunk->file_last;
} }
continue; continue;
} }
if (ce->hunk->type & NGX_HUNK_IN_MEMORY) { if (cl->hunk->type & NGX_HUNK_IN_MEMORY) {
ce->hunk->pos += sent; cl->hunk->pos += sent;
} }
if (ce->hunk->type & NGX_HUNK_FILE) { if (cl->hunk->type & NGX_HUNK_FILE) {
ce->hunk->file_pos += sent; cl->hunk->file_pos += sent;
} }
break; break;
} }
in = ce; in = cl;
if (eagain) { if (eagain) {
/* /*
* sendfile() can return EAGAIN even if it has sent * sendfile() can return EAGAIN even if it has sent
* a whole file part and successive sendfile() would * a whole file part and successive sendfile() would
* return EAGAIN right away and would not send anything. * return EAGAIN right away and would not send anything
*/ */
c->write->ready = 0; c->write->ready = 0;
break; break;
} }

12
src/os/unix/ngx_readv_chain.c
View File

@ -4,7 +4,7 @@
#include <ngx_event.h> #include <ngx_event.h>
ssize_t ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *entry) ssize_t ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *chain)
{ {
ssize_t n; ssize_t n;
struct iovec *iov; struct iovec *iov;
@ -19,19 +19,17 @@ ssize_t ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *entry)
/* TODO: coalesce the neighbouring chain entries */ /* TODO: coalesce the neighbouring chain entries */
while (entry) { while (chain) {
ngx_test_null(iov, ngx_push_array(&io), NGX_ERROR); ngx_test_null(iov, ngx_push_array(&io), NGX_ERROR);
iov->iov_base = entry->hunk->last; iov->iov_base = chain->hunk->last;
iov->iov_len = entry->hunk->end - entry->hunk->last; iov->iov_len = chain->hunk->end - chain->hunk->last;
entry = entry->next; chain = chain->next;
} }
ngx_log_debug(c->log, "recv: %d:%d" _ io.nelts _ iov->iov_len); ngx_log_debug(c->log, "recv: %d:%d" _ io.nelts _ iov->iov_len);
n = readv(c->fd, (struct iovec *) io.elts, io.nelts); n = readv(c->fd, (struct iovec *) io.elts, io.nelts);
ngx_destroy_array(&io);
if (n == -1) { if (n == -1) {
c->read->ready = 0; c->read->ready = 0;