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.3-2004-05-28-19:49:23 import; rename ngx_hunk_t to ngx_buf_t

Browse Source
This commit is contained in:
Igor Sysoev 2004-05-28 15:49:23 +00:00
parent 87a7d1c449
commit 369145cef1
41 changed files with 937 additions and 868 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
auto/cc
View File

@ -296,7 +296,7 @@ case $CC in
CFLAGS="$CFLAGS -zq" CFLAGS="$CFLAGS -zq"
# Open Watcom C 1.2 # Open Watcom C 1.2
have=HAVE_C99_VARIADIC_MACROS . auto/have #have=HAVE_C99_VARIADIC_MACROS . auto/have
# precompiled headers # precompiled headers
CORE_DEPS="$CORE_DEPS $OBJS\\ngx_config.pch" CORE_DEPS="$CORE_DEPS $OBJS\\ngx_config.pch"

4
auto/sources
View File

@ -11,7 +11,7 @@ CORE_DEPS="src/core/nginx.h \
src/core/ngx_alloc.h \ src/core/ngx_alloc.h \
src/core/ngx_array.h \ src/core/ngx_array.h \
src/core/ngx_table.h \ src/core/ngx_table.h \
src/core/ngx_hunk.h \ src/core/ngx_buf.h \
src/core/ngx_string.h \ src/core/ngx_string.h \
src/core/ngx_parse.h \ src/core/ngx_parse.h \
src/core/ngx_inet.h \ src/core/ngx_inet.h \
@ -29,7 +29,7 @@ CORE_SRCS="src/core/nginx.c \
src/core/ngx_log.c \ src/core/ngx_log.c \
src/core/ngx_alloc.c \ src/core/ngx_alloc.c \
src/core/ngx_array.c \ src/core/ngx_array.c \
src/core/ngx_hunk.c \ src/core/ngx_buf.c \
src/core/ngx_output_chain.c \ src/core/ngx_output_chain.c \
src/core/ngx_string.c \ src/core/ngx_string.c \
src/core/ngx_parse.c \ src/core/ngx_parse.c \

154
src/core/ngx_buf.c Normal file
View File

@ -0,0 +1,154 @@
#include <ngx_config.h>
#include <ngx_core.h>
ngx_buf_t *ngx_create_temp_buf(ngx_pool_t *pool, size_t size)
{
ngx_buf_t *b;
if (!(b = ngx_calloc_buf(pool))) {
return NULL;
}
if (!(b->start = ngx_palloc(pool, size))) {
return NULL;
}
b->pos = b->start;
b->last = b->start;
b->end = b->last + size;
b->temporary = 1;
/*
b->file_pos = 0;
b->file_last = 0;
b->file = NULL;
b->shadow = NULL;
b->tag = 0;
*/
return b;
}
ngx_chain_t *ngx_create_chain_of_bufs(ngx_pool_t *pool, ngx_bufs_t *bufs)
{
u_char *p;
ngx_int_t i;
ngx_buf_t *b;
ngx_chain_t *chain, *cl, **ll;
if (!(p = ngx_palloc(pool, bufs->num * bufs->size))) {
return NULL;
}
ll = &chain;
for (i = 0; i < bufs->num; i++) {
if (!(b = ngx_calloc_buf(pool))) {
return NULL;
}
b->pos = p;
b->last = p;
b->temporary = 1;
b->start = p;
p += bufs->size;
b->end = p;
/*
b->file_pos = 0;
b->file_last = 0;
b->file = NULL;
b->shadow = NULL;
b->tag = 0;
*/
if (!(cl = ngx_alloc_chain_link(pool))) {
return NULL;
}
cl->buf = b;
*ll = cl;
ll = &cl->next;
}
*ll = NULL;
return chain;
}
int ngx_chain_add_copy(ngx_pool_t *pool, ngx_chain_t **chain, ngx_chain_t *in)
{
ngx_chain_t *cl, **ll;
ll = chain;
for (cl = *chain; cl; cl = cl->next) {
ll = &cl->next;
}
while (in) {
ngx_test_null(cl, ngx_alloc_chain_link(pool), NGX_ERROR);
cl->buf = in->buf;
*ll = cl;
ll = &cl->next;
in = in->next;
}
*ll = NULL;
return NGX_OK;
}
void ngx_chain_update_chains(ngx_chain_t **free, ngx_chain_t **busy,
ngx_chain_t **out, ngx_buf_tag_t tag)
{
ngx_chain_t *tl;
if (*busy == NULL) {
*busy = *out;
} else {
for (tl = *busy; /* void */ ; tl = tl->next) {
if (tl->next == NULL) {
tl->next = *out;
break;
}
}
}
*out = NULL;
while (*busy) {
if (ngx_buf_size((*busy)->buf) != 0) {
break;
}
#if (HAVE_WRITE_ZEROCOPY)
if ((*busy)->buf->zerocopy_busy) {
break;
}
#endif
if ((*busy)->buf->tag != tag) {
*busy = (*busy)->next;
continue;
}
(*busy)->buf->pos = (*busy)->buf->last = (*busy)->buf->start;
tl = *busy;
*busy = (*busy)->next;
tl->next = *free;
*free = tl;
}
}

115
src/core/ngx_hunk.h → src/core/ngx_buf.h
View File

@ -1,61 +1,87 @@
#ifndef _NGX_HUNK_H_INCLUDED_ #ifndef _NGX_BUF_H_INCLUDED_
#define _NGX_HUNK_H_INCLUDED_ #define _NGX_BUF_H_INCLUDED_
#include <ngx_config.h> #include <ngx_config.h>
#include <ngx_core.h> #include <ngx_core.h>
/* hunk type */ #if 0
/* the buf type */
/* the hunk is in memory */ /* the buf's content is in memory */
#define NGX_HUNK_IN_MEMORY 0x0001 #define NGX_HUNK_IN_MEMORY 0x0001
/* the hunk's content can be changed */ /* the buf's content can be changed */
#define NGX_HUNK_TEMP 0x0002 #define NGX_HUNK_TEMP 0x0002
/* the hunk's content is in cache and can not be changed */ /* the buf's content is in cache and can not be changed */
#define NGX_HUNK_MEMORY 0x0004 #define NGX_HUNK_MEMORY 0x0004
/* the hunk's content is mmap()ed and can not be changed */
#define NGX_HUNK_MMAP 0x0008 #define NGX_HUNK_MMAP 0x0008
/* the buf's content is recycled */
#define NGX_HUNK_RECYCLED 0x0010 #define NGX_HUNK_RECYCLED 0x0010
/* the hunk is in file */ /* the buf's content is in a file */
#define NGX_HUNK_FILE 0x0020 #define NGX_HUNK_FILE 0x0020
#define NGX_HUNK_STORAGE (NGX_HUNK_IN_MEMORY \ #define NGX_HUNK_STORAGE (NGX_HUNK_IN_MEMORY \
|NGX_HUNK_TEMP|NGX_HUNK_MEMORY|NGX_HUNK_MMAP \ |NGX_HUNK_TEMP|NGX_HUNK_MEMORY|NGX_HUNK_MMAP \
|NGX_HUNK_RECYCLED|NGX_HUNK_FILE) |NGX_HUNK_RECYCLED|NGX_HUNK_FILE)
/* hunk flags */ /* the buf flags */
/* in thread state flush means to write the hunk completely before return */ /* in thread state flush means to write the buf completely before return */
/* in event state flush means to start to write the hunk */ /* in event state flush means to start to write the buf */
#define NGX_HUNK_FLUSH 0x0100 #define NGX_HUNK_FLUSH 0x0100
/* last hunk */
/* the last buf */
#define NGX_HUNK_LAST 0x0200 #define NGX_HUNK_LAST 0x0200
#define NGX_HUNK_PREREAD 0x2000 #define NGX_HUNK_PREREAD 0x2000
#define NGX_HUNK_LAST_SHADOW 0x4000 #define NGX_HUNK_LAST_SHADOW 0x4000
#define NGX_HUNK_TEMP_FILE 0x8000 #define NGX_HUNK_TEMP_FILE 0x8000
#endif
typedef void * ngx_hunk_tag_t; typedef void * ngx_buf_tag_t;
typedef struct ngx_hunk_s ngx_hunk_t; typedef struct ngx_buf_s ngx_buf_t;
struct ngx_hunk_s { struct ngx_buf_s {
u_char *pos; u_char *pos;
u_char *last; u_char *last;
off_t file_pos; off_t file_pos;
off_t file_last; off_t file_last;
int type; int type;
u_char *start; /* start of hunk */ u_char *start; /* start of buffer */
u_char *end; /* end of hunk */ u_char *end; /* end of buffer */
ngx_hunk_tag_t tag; ngx_buf_tag_t tag;
ngx_file_t *file; ngx_file_t *file;
ngx_hunk_t *shadow; ngx_buf_t *shadow;
/* the buf's content can be changed */
unsigned temporary:1;
/*
* the buf's content is in a memory cache or in a read only memory
* and can not be changed
*/
unsigned memory:1;
/* the buf's content is mmap()ed and can not be changed */
unsigned mmap:1;
unsigned recycled:1;
unsigned in_file:1;
unsigned flush:1;
unsigned last_buf:1;
unsigned last_shadow:1;
unsigned temp_file:1;
unsigned zerocopy_busy:1;
/* STUB */ int num; /* STUB */ int num;
}; };
@ -63,8 +89,8 @@ struct ngx_hunk_s {
typedef struct ngx_chain_s ngx_chain_t; typedef struct ngx_chain_s ngx_chain_t;
struct ngx_chain_s { struct ngx_chain_s {
ngx_hunk_t *hunk; ngx_buf_t *buf;
ngx_chain_t *next; ngx_chain_t *next;
}; };
@ -77,7 +103,7 @@ typedef struct {
typedef int (*ngx_output_chain_filter_pt)(void *ctx, ngx_chain_t *out); typedef int (*ngx_output_chain_filter_pt)(void *ctx, ngx_chain_t *out);
typedef struct { typedef struct {
ngx_hunk_t *hunk; ngx_buf_t *buf;
ngx_chain_t *in; ngx_chain_t *in;
ngx_chain_t *free; ngx_chain_t *free;
ngx_chain_t *busy; ngx_chain_t *busy;
@ -87,9 +113,9 @@ typedef struct {
unsigned need_in_temp; unsigned need_in_temp;
ngx_pool_t *pool; ngx_pool_t *pool;
ngx_int_t hunks; ngx_int_t allocated;
ngx_bufs_t bufs; ngx_bufs_t bufs;
ngx_hunk_tag_t tag; ngx_buf_tag_t tag;
ngx_output_chain_filter_pt output_filter; ngx_output_chain_filter_pt output_filter;
void *filter_ctx; void *filter_ctx;
@ -107,6 +133,17 @@ typedef struct {
#define NGX_CHAIN_ERROR (ngx_chain_t *) NGX_ERROR #define NGX_CHAIN_ERROR (ngx_chain_t *) NGX_ERROR
#define ngx_buf_in_memory(b) (b->temporary || b->memory || b->mmap)
#define ngx_buf_in_memory_only(b) (ngx_buf_in_memory(b) && !b->in_file)
#define ngx_buf_special(b) \
((b->flush || b->last) && !ngx_buf_in_memory(b) && !b->in_file)
#define ngx_buf_size(b) \
(ngx_buf_in_memory(b) ? (size_t) (b->last - b->pos): \
(size_t) (b->file_last - b->file_pos))
#if 0
#define ngx_hunk_in_memory_only(h) \ #define ngx_hunk_in_memory_only(h) \
((h->type & (NGX_HUNK_IN_MEMORY|NGX_HUNK_FILE)) == NGX_HUNK_IN_MEMORY) ((h->type & (NGX_HUNK_IN_MEMORY|NGX_HUNK_FILE)) == NGX_HUNK_IN_MEMORY)
/* /*
@ -115,28 +152,34 @@ typedef struct {
*/ */
#define ngx_hunk_special(h) \
(h->type == (h->type & (NGX_HUNK_FLUSH|NGX_HUNK_LAST)))
#define ngx_hunk_size(h) \ #define ngx_hunk_special(b) \
((h->type & NGX_HUNK_IN_MEMORY) ? (size_t) (h->last - h->pos): \ (b->type == (b->type & (NGX_HUNK_FLUSH|NGX_HUNK_LAST)))
(size_t) (h->file_last - h->file_pos))
ngx_hunk_t *ngx_create_temp_hunk(ngx_pool_t *pool, size_t size); #define ngx_hunk_size(b) \
((b->type & NGX_HUNK_IN_MEMORY) ? (size_t) (b->last - b->pos): \
(size_t) (b->file_last - b->file_pos))
#define ngx_alloc_hunk(pool) ngx_palloc(pool, sizeof(ngx_hunk_t)) #endif
#define ngx_calloc_hunk(pool) ngx_pcalloc(pool, sizeof(ngx_hunk_t))
ngx_buf_t *ngx_create_temp_buf(ngx_pool_t *pool, size_t size);
ngx_chain_t *ngx_create_chain_of_bufs(ngx_pool_t *pool, ngx_bufs_t *bufs);
#define ngx_alloc_buf(pool) ngx_palloc(pool, sizeof(ngx_buf_t))
#define ngx_calloc_buf(pool) ngx_pcalloc(pool, sizeof(ngx_buf_t))
#define ngx_alloc_chain_link(pool) ngx_palloc(pool, sizeof(ngx_chain_t)) #define ngx_alloc_chain_link(pool) ngx_palloc(pool, sizeof(ngx_chain_t))
#define ngx_alloc_link_and_set_hunk(chain, h, pool, error) \ #define ngx_alloc_link_and_set_buf(chain, b, pool, error) \
do { \ do { \
ngx_test_null(chain, ngx_alloc_chain_link(pool), error); \ ngx_test_null(chain, ngx_alloc_chain_link(pool), error); \
chain->hunk = h; \ chain->buf = b; \
chain->next = NULL; \ chain->next = NULL; \
} while (0); } while (0);
@ -155,7 +198,7 @@ int ngx_chain_writer(void *data, ngx_chain_t *in);
int ngx_chain_add_copy(ngx_pool_t *pool, ngx_chain_t **chain, 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_buf_tag_t tag);
#endif /* _NGX_HUNK_H_INCLUDED_ */ #endif /* _NGX_BUF_H_INCLUDED_ */

72
src/core/ngx_conf_file.c
View File

@ -51,8 +51,8 @@ char *ngx_conf_parse(ngx_conf_t *cf, ngx_str_t *filename)
int m, rc, found, valid; int m, rc, found, valid;
char *rv; char *rv;
void *conf, **confp; void *conf, **confp;
ngx_str_t *name;
ngx_fd_t fd; ngx_fd_t fd;
ngx_str_t *name;
ngx_conf_file_t *prev; ngx_conf_file_t *prev;
ngx_command_t *cmd; ngx_command_t *cmd;
@ -73,18 +73,18 @@ char *ngx_conf_parse(ngx_conf_t *cf, ngx_str_t *filename)
} }
prev = cf->conf_file; prev = cf->conf_file;
ngx_test_null(cf->conf_file, if (!(cf->conf_file = ngx_palloc(cf->pool, sizeof(ngx_conf_file_t)))) {
ngx_palloc(cf->pool, sizeof(ngx_conf_file_t)), return NGX_CONF_ERROR;
NGX_CONF_ERROR); }
if (ngx_fd_info(fd, &cf->conf_file->file.info) == -1) { if (ngx_fd_info(fd, &cf->conf_file->file.info) == -1) {
ngx_log_error(NGX_LOG_EMERG, cf->log, ngx_errno, ngx_log_error(NGX_LOG_EMERG, cf->log, ngx_errno,
ngx_fd_info_n " %s failed", filename->data); ngx_fd_info_n " %s failed", filename->data);
} }
ngx_test_null(cf->conf_file->hunk, if (!(cf->conf_file->buffer = ngx_create_temp_buf(cf->pool, 1024))) {
ngx_create_temp_hunk(cf->pool, 1024), return NGX_CONF_ERROR;
NGX_CONF_ERROR); }
cf->conf_file->file.fd = fd; cf->conf_file->file.fd = fd;
cf->conf_file->file.name.len = filename->len; cf->conf_file->file.name.len = filename->len;
@ -97,8 +97,10 @@ char *ngx_conf_parse(ngx_conf_t *cf, ngx_str_t *filename)
for ( ;; ) { for ( ;; ) {
rc = ngx_conf_read_token(cf); rc = ngx_conf_read_token(cf);
/* ngx_conf_read_token() returns NGX_OK, NGX_ERROR, /*
NGX_CONF_FILE_DONE or NGX_CONF_BLOCK_DONE */ * ngx_conf_read_token() returns NGX_OK, NGX_ERROR,
* NGX_CONF_FILE_DONE or NGX_CONF_BLOCK_DONE
*/
#if 0 #if 0
ngx_log_debug(cf->log, "token %d" _ rc); ngx_log_debug(cf->log, "token %d" _ rc);
@ -315,7 +317,7 @@ static int ngx_conf_read_token(ngx_conf_t *cf)
int quoted, s_quoted, d_quoted; int quoted, s_quoted, d_quoted;
ssize_t n; ssize_t n;
ngx_str_t *word; ngx_str_t *word;
ngx_hunk_t *h; ngx_buf_t *b;
found = 0; found = 0;
need_space = 0; need_space = 0;
@ -324,8 +326,8 @@ static int ngx_conf_read_token(ngx_conf_t *cf)
quoted = s_quoted = d_quoted = 0; quoted = s_quoted = d_quoted = 0;
cf->args->nelts = 0; cf->args->nelts = 0;
h = cf->conf_file->hunk; b = cf->conf_file->buffer;
start = h->pos; start = b->pos;
#if 0 #if 0
ngx_log_debug(cf->log, "TOKEN START"); ngx_log_debug(cf->log, "TOKEN START");
@ -333,31 +335,31 @@ ngx_log_debug(cf->log, "TOKEN START");
for ( ;; ) { for ( ;; ) {
if (h->pos >= h->last) { if (b->pos >= b->last) {
if (cf->conf_file->file.offset if (cf->conf_file->file.offset
>= ngx_file_size(&cf->conf_file->file.info)) { >= ngx_file_size(&cf->conf_file->file.info)) {
return NGX_CONF_FILE_DONE; return NGX_CONF_FILE_DONE;
} }
if (h->pos - start) { if (b->pos - start) {
ngx_memcpy(h->start, start, (size_t) (h->pos - start)); ngx_memcpy(b->start, start, b->pos - start);
} }
n = ngx_read_file(&cf->conf_file->file, n = ngx_read_file(&cf->conf_file->file,
h->start + (h->pos - start), b->start + (b->pos - start),
(size_t) (h->end - (h->start + (h->pos - start))), b->end - (b->start + (b->pos - start)),
cf->conf_file->file.offset); cf->conf_file->file.offset);
if (n == NGX_ERROR) { if (n == NGX_ERROR) {
return NGX_ERROR; return NGX_ERROR;
} }
h->pos = h->start + (h->pos - start); b->pos = b->start + (b->pos - start);
start = h->start; start = b->start;
h->last = h->pos + n; b->last = b->pos + n;
} }
ch = *h->pos++; ch = *b->pos++;
#if 0 #if 0
ngx_log_debug(cf->log, "%d:%d:%d:%d:%d '%c'" _ ngx_log_debug(cf->log, "%d:%d:%d:%d:%d '%c'" _
@ -406,7 +408,7 @@ ngx_log_debug(cf->log, "%d:%d:%d:%d:%d '%c'" _
continue; continue;
} }
start = h->pos - 1; start = b->pos - 1;
switch (ch) { switch (ch) {
@ -485,14 +487,16 @@ ngx_log_debug(cf->log, "%d:%d:%d:%d:%d '%c'" _
} }
if (found) { if (found) {
ngx_test_null(word, ngx_push_array(cf->args), NGX_ERROR); if (!(word = ngx_push_array(cf->args))) {
ngx_test_null(word->data, return NGX_ERROR;
ngx_palloc(cf->pool, }
(size_t) (h->pos - start + 1)),
NGX_ERROR); if (!(word->data = ngx_palloc(cf->pool, b->pos - start + 1))) {
return NGX_ERROR;
}
for (dst = word->data, src = start, len = 0; for (dst = word->data, src = start, len = 0;
src < h->pos - 1; src < b->pos - 1;
len++) len++)
{ {
if (*src == '\\') { if (*src == '\\') {
@ -583,8 +587,12 @@ ngx_open_file_t *ngx_conf_open_file(ngx_cycle_t *cycle, ngx_str_t *name)
} }
} }
ngx_test_null(file, ngx_push_array(&cycle->open_files), NULL); if (!(file = ngx_push_array(&cycle->open_files))) {
return NULL;
}
file->fd = NGX_INVALID_FILE; file->fd = NGX_INVALID_FILE;
if (name) { if (name) {
file->name = *name; file->name = *name;
} }
@ -917,8 +925,8 @@ char *ngx_conf_unsupported(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
char *ngx_conf_check_num_bounds(ngx_conf_t *cf, void *post, void *data) char *ngx_conf_check_num_bounds(ngx_conf_t *cf, void *post, void *data)
{ {
ngx_conf_num_bounds_t *bounds = post; ngx_conf_num_bounds_t *bounds = post;
ngx_int_t *np = data; ngx_int_t *np = data;
if (bounds->high == -1) { if (bounds->high == -1) {
if (*np >= bounds->low) { if (*np >= bounds->low) {

2
src/core/ngx_conf_file.h
View File

@ -112,7 +112,7 @@ typedef struct {
typedef struct { typedef struct {
ngx_file_t file; ngx_file_t file;
ngx_hunk_t *hunk; ngx_buf_t *buffer;
int line; int line;
} ngx_conf_file_t; } ngx_conf_file_t;

2
src/core/ngx_connection.h
View File

@ -88,7 +88,7 @@ struct ngx_connection_s {
socklen_t local_socklen; socklen_t local_socklen;
#endif #endif
ngx_hunk_t *buffer; ngx_buf_t *buffer;
ngx_int_t number; ngx_int_t number;

2
src/core/ngx_core.h
View File

@ -26,7 +26,7 @@ typedef struct ngx_connection_s ngx_connection_t;
#include <ngx_parse.h> #include <ngx_parse.h>
#include <ngx_log.h> #include <ngx_log.h>
#include <ngx_alloc.h> #include <ngx_alloc.h>
#include <ngx_hunk.h> #include <ngx_buf.h>
#include <ngx_array.h> #include <ngx_array.h>
#include <ngx_table.h> #include <ngx_table.h>
#include <ngx_types.h> #include <ngx_types.h>

140
src/core/ngx_hunk.c
View File

@ -1,140 +0,0 @@
#include <ngx_config.h>
#include <ngx_core.h>
ngx_hunk_t *ngx_create_temp_hunk(ngx_pool_t *pool, size_t size)
{
ngx_hunk_t *h;
ngx_test_null(h, ngx_alloc_hunk(pool), NULL);
ngx_test_null(h->start, ngx_palloc(pool, size), NULL);
h->pos = h->start;
h->last = h->start;
h->file_pos = 0;
h->file_last = 0;
h->end = h->last + size;
h->type = NGX_HUNK_TEMP|NGX_HUNK_IN_MEMORY;
h->file = NULL;
h->shadow = NULL;
h->tag = 0;
return h;
}
ngx_chain_t *ngx_create_chain_of_hunks(ngx_pool_t *pool, ngx_bufs_t *bufs)
{
ngx_int_t i;
u_char *p;
ngx_hunk_t *h;
ngx_chain_t *chain, *cl, **ll;
ngx_test_null(p, ngx_palloc(pool, bufs->num * bufs->size), NULL);
ll = &chain;
for (i = 0; i < bufs->num; i++) {
ngx_test_null(h, ngx_alloc_hunk(pool), NULL);
h->pos = p;
h->last = p;
h->file_pos = 0;
h->file_last = 0;
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_TEMP;
h->start = p;
p += bufs->size;
h->end = p;
h->file = NULL;
h->shadow = NULL;
h->tag = 0;
ngx_test_null(cl, ngx_alloc_chain_link(pool), NULL);
cl->hunk = h;
*ll = cl;
ll = &cl->next;
}
*ll = NULL;
return chain;
}
int ngx_chain_add_copy(ngx_pool_t *pool, ngx_chain_t **chain, ngx_chain_t *in)
{
ngx_chain_t *cl, **ll;
ll = chain;
for (cl = *chain; cl; cl = cl->next) {
ll = &cl->next;
}
while (in) {
ngx_test_null(cl, ngx_alloc_chain_link(pool), NGX_ERROR);
cl->hunk = in->hunk;
*ll = cl;
ll = &cl->next;
in = in->next;
}
*ll = NULL;
return NGX_OK;
}
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 *tl;
if (*busy == NULL) {
*busy = *out;
} else {
for (tl = *busy; /* void */ ; tl = tl->next) {
if (tl->next == NULL) {
tl->next = *out;
break;
}
}
}
*out = NULL;
while (*busy) {
if (ngx_hunk_size((*busy)->hunk) != 0) {
break;
}
#if (HAVE_WRITE_ZEROCOPY)
if ((*busy)->hunk->type & NGX_HUNK_ZEROCOPY_BUSY) {
break;
}
#endif
if ((*busy)->hunk->tag != tag) {
*busy = (*busy)->next;
continue;
}
(*busy)->hunk->pos = (*busy)->hunk->last = (*busy)->hunk->start;
tl = *busy;
*busy = (*busy)->next;
tl->next = *free;
*free = tl;
}
}

108
src/core/ngx_output_chain.c
View File

@ -8,20 +8,20 @@
ngx_inline static int ngx_output_chain_need_to_copy(ngx_output_chain_ctx_t *ctx, ngx_inline static int ngx_output_chain_need_to_copy(ngx_output_chain_ctx_t *ctx,
ngx_hunk_t *hunk); ngx_buf_t *buf);
static int ngx_output_chain_copy_hunk(ngx_hunk_t *dst, ngx_hunk_t *src, static ngx_int_t ngx_output_chain_copy_buf(ngx_buf_t *dst, ngx_buf_t *src,
u_int sendfile); ngx_uint_t sendfile);
int ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in) int ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in)
{ {
int rc, last; int rc, last;
size_t size, hsize; size_t size, bsize;
ngx_chain_t *cl, *out, **last_out; ngx_chain_t *cl, *out, **last_out;
/* /*
* the short path for the case when the ctx->in chain is empty * the short path for the case when the ctx->in chain is empty
* and the incoming chain is empty too or it has the single hunk * and the incoming chain is empty too or it has the single buf
* that does not require the copy * that does not require the copy
*/ */
@ -32,7 +32,7 @@ int ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in)
} }
if (in->next == NULL if (in->next == NULL
&& (!ngx_output_chain_need_to_copy(ctx, in->hunk))) && (!ngx_output_chain_need_to_copy(ctx, in->buf)))
{ {
return ctx->output_filter(ctx->filter_ctx, in); return ctx->output_filter(ctx->filter_ctx, in);
} }
@ -55,11 +55,11 @@ int ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in)
while (ctx->in) { while (ctx->in) {
/* /*
* cycle while there are the ctx->in hunks * cycle while there are the ctx->in bufs
* or there are the free output hunks to copy in * or there are the free output bufs to copy in
*/ */
if (!ngx_output_chain_need_to_copy(ctx, ctx->in->hunk)) { if (!ngx_output_chain_need_to_copy(ctx, ctx->in->buf)) {
/* move the chain link to the output chain */ /* move the chain link to the output chain */
@ -73,15 +73,15 @@ int ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in)
continue; continue;
} }
if (ctx->hunk == NULL) { if (ctx->buf == NULL) {
/* get the free hunk */ /* get the free buf */
if (ctx->free) { if (ctx->free) {
ctx->hunk = ctx->free->hunk; ctx->buf = ctx->free->buf;
ctx->free = ctx->free->next; ctx->free = ctx->free->next;
} else if (out || ctx->hunks == ctx->bufs.num) { } else if (out || ctx->allocated == ctx->bufs.num) {
break; break;
@ -89,44 +89,45 @@ int ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in)
size = ctx->bufs.size; size = ctx->bufs.size;
if (ctx->in->hunk->type & NGX_HUNK_LAST) { if (ctx->in->buf->last_buf) {
hsize = ngx_hunk_size(ctx->in->hunk); bsize = ngx_buf_size(ctx->in->buf);
if (hsize < ctx->bufs.size) { if (bsize < ctx->bufs.size) {
/* /*
* allocate small temp hunk for the small last hunk * allocate small temp buf for the small last buf
* or its small last part * or its small last part
*/ */
size = hsize; size = bsize;
} else if (ctx->bufs.num == 1 } else if (ctx->bufs.num == 1
&& (hsize < ctx->bufs.size && (bsize < ctx->bufs.size
+ (ctx->bufs.size >> 2))) + (ctx->bufs.size >> 2)))
{ {
/* /*
* allocate a temp hunk that equals * allocate a temp buf that equals
* to the last hunk if the last hunk size is lesser * to the last buf if the last buf size is lesser
* than 1.25 of bufs.size and a temp hunk is single * than 1.25 of bufs.size and a temp buf is single
*/ */
size = hsize; size = bsize;
} }
} }
ngx_test_null(ctx->hunk, if (!(ctx->buf = ngx_create_temp_buf(ctx->pool, size))) {
ngx_create_temp_hunk(ctx->pool, size), return NGX_ERROR;
NGX_ERROR); }
ctx->hunk->tag = ctx->tag;
ctx->hunk->type |= NGX_HUNK_RECYCLED; ctx->buf->tag = ctx->tag;
ctx->hunks++; ctx->buf->recycled = 1;
ctx->allocated++;
} }
} }
rc = ngx_output_chain_copy_hunk(ctx->hunk, ctx->in->hunk, rc = ngx_output_chain_copy_buf(ctx->buf, ctx->in->buf,
ctx->sendfile); ctx->sendfile);
if (rc == NGX_ERROR) { if (rc == NGX_ERROR) {
return rc; return rc;
@ -139,16 +140,16 @@ int ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in)
return rc; return rc;
} }
/* delete the completed hunk from the ctx->in chain */ /* delete the completed buf from the ctx->in chain */
if (ngx_hunk_size(ctx->in->hunk) == 0) { if (ngx_buf_size(ctx->in->buf) == 0) {
ctx->in = ctx->in->next; ctx->in = ctx->in->next;
} }
ngx_alloc_link_and_set_hunk(cl, ctx->hunk, ctx->pool, NGX_ERROR); ngx_alloc_link_and_set_buf(cl, ctx->buf, ctx->pool, NGX_ERROR);
*last_out = cl; *last_out = cl;
last_out = &cl->next; last_out = &cl->next;
ctx->hunk = NULL; ctx->buf = NULL;
} }
if (out == NULL && last != NGX_NONE) { if (out == NULL && last != NGX_NONE) {
@ -168,26 +169,25 @@ int ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in)
ngx_inline static int ngx_output_chain_need_to_copy(ngx_output_chain_ctx_t *ctx, ngx_inline static int ngx_output_chain_need_to_copy(ngx_output_chain_ctx_t *ctx,
ngx_hunk_t *hunk) ngx_buf_t *buf)
{ {
if (ngx_hunk_special(hunk)) { if (ngx_buf_special(buf)) {
return 0; return 0;
} }
if (!ctx->sendfile) { if (!ctx->sendfile) {
if (!(hunk->type & NGX_HUNK_IN_MEMORY)) { if (!ngx_buf_in_memory(buf)) {
return 1; return 1;
} }
hunk->type &= ~NGX_HUNK_FILE; buf->in_file = 0;
} }
if (ctx->need_in_memory && (!(hunk->type & NGX_HUNK_IN_MEMORY))) { if (ctx->need_in_memory && !ngx_buf_in_memory(buf)) {
return 1; return 1;
} }
if (ctx->need_in_temp && (buf->memory || buf->mmap)) {
if (ctx->need_in_temp && (hunk->type & (NGX_HUNK_MEMORY|NGX_HUNK_MMAP))) {
return 1; return 1;
} }
@ -195,29 +195,29 @@ ngx_inline static int ngx_output_chain_need_to_copy(ngx_output_chain_ctx_t *ctx,
} }
static int ngx_output_chain_copy_hunk(ngx_hunk_t *dst, ngx_hunk_t *src, static ngx_int_t ngx_output_chain_copy_buf(ngx_buf_t *dst, ngx_buf_t *src,
u_int sendfile) ngx_uint_t sendfile)
{ {
size_t size; size_t size;
ssize_t n; ssize_t n;
size = ngx_hunk_size(src); size = ngx_buf_size(src);
if (size > (size_t) (dst->end - dst->pos)) { if (size > (size_t) (dst->end - dst->pos)) {
size = dst->end - dst->pos; size = dst->end - dst->pos;
} }
if (src->type & NGX_HUNK_IN_MEMORY) { if (ngx_buf_in_memory(src)) {
ngx_memcpy(dst->pos, src->pos, size); ngx_memcpy(dst->pos, src->pos, size);
src->pos += size; src->pos += size;
dst->last += size; dst->last += size;
if (src->type & NGX_HUNK_FILE) { if (src->in_file) {
src->file_pos += size; src->file_pos += size;
} }
if ((src->type & NGX_HUNK_LAST) && src->pos == src->last) { if (src->last_buf && src->pos == src->last) {
dst->type |= NGX_HUNK_LAST; dst->last_buf = 1;
} }
} else { } else {
@ -246,11 +246,11 @@ static int ngx_output_chain_copy_hunk(ngx_hunk_t *dst, ngx_hunk_t *src,
dst->last += n; dst->last += n;
if (!sendfile) { if (!sendfile) {
dst->type &= ~NGX_HUNK_FILE; dst->in_file = 0;
} }
if ((src->type & NGX_HUNK_LAST) && src->file_pos == src->file_last) { if (src->last_buf && src->file_pos == src->file_last) {
dst->type |= NGX_HUNK_LAST; dst->last_buf = 1;
} }
} }
@ -258,7 +258,7 @@ static int ngx_output_chain_copy_hunk(ngx_hunk_t *dst, ngx_hunk_t *src,
} }
int ngx_chain_writer(void *data, ngx_chain_t *in) ngx_int_t ngx_chain_writer(void *data, ngx_chain_t *in)
{ {
ngx_chain_writer_ctx_t *ctx = data; ngx_chain_writer_ctx_t *ctx = data;
@ -266,7 +266,7 @@ int ngx_chain_writer(void *data, ngx_chain_t *in)
for (/* void */; in; in = in->next) { for (/* void */; in; in = in->next) {
ngx_alloc_link_and_set_hunk(cl, in->hunk, ctx->pool, NGX_ERROR); ngx_alloc_link_and_set_buf(cl, in->buf, ctx->pool, NGX_ERROR);
*ctx->last = cl; *ctx->last = cl;
ctx->last = &cl->next; ctx->last = &cl->next;
} }

6
src/event/ngx_event_acceptex.c
View File

@ -129,9 +129,9 @@ int ngx_event_post_acceptex(ngx_listening_t *ls, int n)
NGX_ERROR); NGX_ERROR);
ngx_test_null(c->buffer, ngx_test_null(c->buffer,
ngx_create_temp_hunk(c->pool, ngx_create_temp_buf(c->pool,
ls->post_accept_buffer_size ls->post_accept_buffer_size
+ 2 * (c->listening->socklen + 16)), + 2 * (c->listening->socklen + 16)),
NGX_ERROR); NGX_ERROR);
ngx_test_null(c->local_sockaddr, ngx_palloc(c->pool, ls->socklen), ngx_test_null(c->local_sockaddr, ngx_palloc(c->pool, ls->socklen),

341
src/event/ngx_event_pipe.c
View File

@ -5,19 +5,19 @@
#include <ngx_event_pipe.h> #include <ngx_event_pipe.h>
static int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p); static ngx_int_t ngx_event_pipe_read_upstream(ngx_event_pipe_t *p);
static int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p); static ngx_int_t 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 ngx_int_t ngx_event_pipe_write_chain_to_temp_file(ngx_event_pipe_t *p);
ngx_inline static void ngx_event_pipe_remove_shadow_links(ngx_hunk_t *hunk); ngx_inline static void ngx_event_pipe_remove_shadow_links(ngx_buf_t *buf);
ngx_inline static void ngx_event_pipe_free_shadow_raw_hunk(ngx_chain_t **free, ngx_inline static void ngx_event_pipe_free_shadow_raw_buf(ngx_chain_t **free,
ngx_hunk_t *h); ngx_buf_t *buf);
ngx_inline static void ngx_event_pipe_add_free_hunk(ngx_chain_t **chain, ngx_inline static void ngx_event_pipe_add_free_buf(ngx_chain_t **chain,
ngx_chain_t *cl); ngx_chain_t *cl);
static int ngx_event_pipe_drain_chains(ngx_event_pipe_t *p); static ngx_int_t ngx_event_pipe_drain_chains(ngx_event_pipe_t *p);
int ngx_event_pipe(ngx_event_pipe_t *p, int do_write) ngx_int_t ngx_event_pipe(ngx_event_pipe_t *p, int do_write)
{ {
u_int flags; u_int flags;
ngx_event_t *rev, *wev; ngx_event_t *rev, *wev;
@ -73,10 +73,10 @@ int ngx_event_pipe(ngx_event_pipe_t *p, int do_write)
} }
int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p) ngx_int_t ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
{ {
int n, rc, size; int n, rc, size;
ngx_hunk_t *h; ngx_buf_t *b;
ngx_chain_t *chain, *cl, *tl; 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) {
@ -92,16 +92,16 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
break; break;
} }
if (p->preread_hunks == NULL && !p->upstream->read->ready) { if (p->preread_bufs == NULL && !p->upstream->read->ready) {
break; break;
} }
if (p->preread_hunks) { if (p->preread_bufs) {
/* use the pre-read hunks if they exist */ /* use the pre-read bufs if they exist */
chain = p->preread_hunks; chain = p->preread_bufs;
p->preread_hunks = NULL; p->preread_bufs = NULL;
n = p->preread_size; n = p->preread_size;
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0, ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0,
@ -115,7 +115,7 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
/* /*
* kqueue notifies about the end of file or a pending error. * kqueue notifies about the end of file or a pending error.
* This test allows not to allocate a hunk on these conditions * This test allows not to allocate a buf on these conditions
* and not to call ngx_recv_chain(). * and not to call ngx_recv_chain().
*/ */
@ -142,34 +142,36 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
break; break;
} }
if (p->free_raw_hunks) { if (p->free_raw_bufs) {
/* use the free hunks if they exist */ /* use the free bufs if they exist */
chain = p->free_raw_hunks; chain = p->free_raw_bufs;
if (p->single_buf) { if (p->single_buf) {
p->free_raw_hunks = p->free_raw_hunks->next; p->free_raw_bufs = p->free_raw_bufs->next;
chain->next = NULL; chain->next = NULL;
} else { } else {
p->free_raw_hunks = NULL; p->free_raw_bufs = NULL;
} }
} else if (p->hunks < p->bufs.num) { } else if (p->allocated < p->bufs.num) {
/* allocate a new hunk if it's still allowed */ /* allocate a new buf if it's still allowed */
ngx_test_null(h, ngx_create_temp_hunk(p->pool, p->bufs.size), if (!(b = ngx_create_temp_buf(p->pool, p->bufs.size))) {
NGX_ABORT); return NGX_ABORT;
p->hunks++; }
ngx_alloc_link_and_set_hunk(tl, h, p->pool, NGX_ABORT); p->allocated++;
ngx_alloc_link_and_set_buf(tl, b, p->pool, NGX_ABORT);
chain = tl; chain = tl;
} else if (!p->cachable && p->downstream->write->ready) { } else if (!p->cachable && p->downstream->write->ready) {
/* /*
* if the hunks are not needed to be saved in a cache and * if the bufs are not needed to be saved in a cache and
* a downstream is ready then write the hunks to a downstream * a downstream is ready then write the bufs to a downstream
*/ */
p->upstream_blocked = 1; p->upstream_blocked = 1;
@ -184,7 +186,7 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
{ {
/* /*
* if it's allowed then save some hunks from r->in * if it's allowed then save some bufs from r->in
* to a temporary file, and add them to a r->out chain * to a temporary file, and add them to a r->out chain
*/ */
@ -210,17 +212,17 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
return rc; return rc;
} }
chain = p->free_raw_hunks; chain = p->free_raw_bufs;
if (p->single_buf) { if (p->single_buf) {
p->free_raw_hunks = p->free_raw_hunks->next; p->free_raw_bufs = p->free_raw_bufs->next;
chain->next = NULL; chain->next = NULL;
} else { } else {
p->free_raw_hunks = NULL; p->free_raw_bufs = NULL;
} }
} else { } else {
/* if there're no hunks to read in then disable a level event */ /* if there're no bufs to read in then disable a level event */
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0, ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0,
"no pipe hunks to read in"); "no pipe hunks to read in");
@ -233,10 +235,10 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0, ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0,
"pipe recv chain: %d", n); "pipe recv chain: %d", n);
if (p->free_raw_hunks) { if (p->free_raw_bufs) {
chain->next = p->free_raw_hunks; chain->next = p->free_raw_bufs;
} }
p->free_raw_hunks = chain; p->free_raw_bufs = chain;
if (n == NGX_ERROR) { if (n == NGX_ERROR) {
p->upstream_error = 1; p->upstream_error = 1;
@ -245,7 +247,7 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
if (n == NGX_AGAIN) { if (n == NGX_AGAIN) {
if (p->single_buf) { if (p->single_buf) {
ngx_event_pipe_remove_shadow_links(chain->hunk); ngx_event_pipe_remove_shadow_links(chain->buf);
} }
break; break;
@ -264,16 +266,16 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
while (cl && n > 0) { while (cl && n > 0) {
ngx_event_pipe_remove_shadow_links(cl->hunk); ngx_event_pipe_remove_shadow_links(cl->buf);
size = cl->hunk->end - cl->hunk->last; size = cl->buf->end - cl->buf->last;
if (n >= size) { if (n >= size) {
cl->hunk->last = cl->hunk->end; cl->buf->last = cl->buf->end;
/* STUB */ cl->hunk->num = p->num++; /* STUB */ cl->buf->num = p->num++;
if (p->input_filter(p, cl->hunk) == NGX_ERROR) { if (p->input_filter(p, cl->buf) == NGX_ERROR) {
return NGX_ABORT; return NGX_ABORT;
} }
@ -281,56 +283,56 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
cl = cl->next; cl = cl->next;
} else { } else {
cl->hunk->last += n; cl->buf->last += n;
n = 0; n = 0;
} }
} }
p->free_raw_hunks = cl; p->free_raw_bufs = cl;
} }
#if (NGX_DEBUG0) #if (NGX_DEBUG)
if (p->in || p->busy || p->free_raw_hunks) { if (p->in || p->busy || p->free_raw_bufs) {
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0, "pipe buf"); ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0, "pipe buf");
} }
for (cl = p->in; cl; cl = cl->next) { for (cl = p->in; cl; cl = cl->next) {
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0, ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0,
"pipe buf in " PTR_FMT ", pos " PTR_FMT ", size: %d", "pipe buf in " PTR_FMT ", pos " PTR_FMT ", size: %d",
cl->hunk->start, cl->hunk->pos, cl->buf->start, cl->buf->pos,
cl->hunk->last - cl->hunk->pos); cl->buf->last - cl->buf->pos);
} }
for (cl = p->busy; cl; cl = cl->next) { for (cl = p->busy; cl; cl = cl->next) {
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0, ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0,
"pipe buf busy " PTR_FMT ", pos " PTR_FMT ", size: %d", "pipe buf busy " PTR_FMT ", pos " PTR_FMT ", size: %d",
cl->hunk->start, cl->hunk->pos, cl->buf->start, cl->buf->pos,
cl->hunk->last - cl->hunk->pos); cl->buf->last - cl->buf->pos);
} }
for (cl = p->free_raw_hunks; cl; cl = cl->next) { for (cl = p->free_raw_bufs; cl; cl = cl->next) {
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0, ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0,
"pipe buf free " PTR_FMT ", last " PTR_FMT ", size: %d", "pipe buf free " PTR_FMT ", last " PTR_FMT ", size: %d",
cl->hunk->start, cl->hunk->last, cl->buf->start, cl->buf->last,
cl->hunk->end - cl->hunk->last); cl->buf->end - cl->buf->last);
} }
#endif #endif
if ((p->upstream_eof || p->upstream_error) && p->free_raw_hunks) { if ((p->upstream_eof || p->upstream_error) && p->free_raw_bufs) {
/* STUB */ p->free_raw_hunks->hunk->num = p->num++; /* STUB */ p->free_raw_bufs->buf->num = p->num++;
if (p->input_filter(p, p->free_raw_hunks->hunk) == NGX_ERROR) { if (p->input_filter(p, p->free_raw_bufs->buf) == NGX_ERROR) {
return NGX_ABORT; return NGX_ABORT;
} }
p->free_raw_hunks = p->free_raw_hunks->next; p->free_raw_bufs = p->free_raw_bufs->next;
if (p->free_bufs) { if (p->free_bufs) {
for (cl = p->free_raw_hunks; cl; cl = cl->next) { for (cl = p->free_raw_bufs; cl; cl = cl->next) {
ngx_pfree(p->pool, cl->hunk->start); ngx_pfree(p->pool, cl->buf->start);
} }
} }
} }
@ -345,11 +347,11 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
} }
int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p) ngx_int_t ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p)
{ {
size_t bsize; size_t bsize;
ngx_uint_t flush; ngx_uint_t flush;
ngx_hunk_t *h; ngx_buf_t *b;
ngx_chain_t *out, **ll, *cl, *tl; ngx_chain_t *out, **ll, *cl, *tl;
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0, ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0,
@ -391,7 +393,7 @@ int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p)
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0, ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0,
"pipe write downstream done"); "pipe write downstream done");
/* TODO: free unused hunks */ /* TODO: free unused bufs */
p->downstream_done = 1; p->downstream_done = 1;
break; break;
@ -401,12 +403,12 @@ int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p)
break; break;
} }
/* bsize is the size of the busy hunks */ /* bsize is the size of the busy bufs */
bsize = 0; bsize = 0;
for (cl = p->busy; cl; cl = cl->next) { for (cl = p->busy; cl; cl = cl->next) {
bsize += cl->hunk->end - cl->hunk->start; bsize += cl->buf->end - cl->buf->start;
} }
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0, ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0,
@ -420,19 +422,19 @@ int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p)
if (p->out) { if (p->out) {
cl = p->out; cl = p->out;
if (bsize + ngx_hunk_size(cl->hunk) > p->busy_size) { if (bsize + ngx_buf_size(cl->buf) > p->busy_size) {
flush = 1; flush = 1;
break; break;
} }
p->out = p->out->next; p->out = p->out->next;
ngx_event_pipe_free_shadow_raw_hunk(&p->free_raw_hunks, ngx_event_pipe_free_shadow_raw_buf(&p->free_raw_bufs,
cl->hunk); cl->buf);
} else if (!p->cachable && p->in) { } else if (!p->cachable && p->in) {
cl = p->in; cl = p->in;
if (bsize + ngx_hunk_size(cl->hunk) > p->busy_size) { if (bsize + ngx_buf_size(cl->buf) > p->busy_size) {
flush = 1; flush = 1;
break; break;
} }
@ -443,7 +445,7 @@ int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p)
break; break;
} }
bsize += ngx_hunk_size(cl->hunk); bsize += ngx_buf_size(cl->buf);
cl->next = NULL; cl->next = NULL;
ngx_chain_add_link(out, ll, cl); ngx_chain_add_link(out, ll, cl);
} }
@ -464,43 +466,33 @@ int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p)
for (cl = p->free; cl; cl = cl->next) { for (cl = p->free; cl; cl = cl->next) {
if (cl->hunk->type & NGX_HUNK_TEMP_FILE) { if (cl->buf->temp_file) {
if (p->cachable || !p->cyclic_temp_file) { if (p->cachable || !p->cyclic_temp_file) {
continue; continue;
} }
/* reset p->temp_offset if all hunks had been sent */ /* reset p->temp_offset if all bufs had been sent */
if (cl->hunk->file_last == p->temp_file->offset) { if (cl->buf->file_last == p->temp_file->offset) {
p->temp_file->offset = 0; p->temp_file->offset = 0;
} }
} }
/* TODO: free hunk if p->free_bufs && upstream done */ /* TODO: free buf if p->free_bufs && upstream done */
/* add the free shadow raw hunk to p->free_raw_hunks */ /* add the free shadow raw buf to p->free_raw_bufs */
if (cl->hunk->type & NGX_HUNK_LAST_SHADOW) { if (cl->buf->last_shadow) {
h = cl->hunk->shadow; b = cl->buf->shadow;
h->pos = h->last = h->start; b->pos = b->last = b->start;
h->shadow = NULL; b->shadow = NULL;
ngx_alloc_link_and_set_hunk(tl, h, p->pool, NGX_ABORT); ngx_alloc_link_and_set_buf(tl, b, p->pool, NGX_ABORT);
ngx_event_pipe_add_free_hunk(&p->free_raw_hunks, tl); ngx_event_pipe_add_free_buf(&p->free_raw_bufs, tl);
cl->hunk->type &= ~NGX_HUNK_LAST_SHADOW; cl->buf->last_shadow = 0;
} }
cl->hunk->shadow = NULL;
#if 0 cl->buf->shadow = NULL;
if (p->cyclic_temp_file && (cl->hunk->type & NGX_HUNK_TEMP_FILE)) {
/* reset p->temp_offset if all hunks had been sent */
if (cl->hunk->file_last == p->temp_file->offset) {
p->temp_file->offset = 0;
}
}
#endif
} }
} }
@ -508,14 +500,14 @@ 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 ngx_int_t ngx_event_pipe_write_chain_to_temp_file(ngx_event_pipe_t *p)
{ {
int size, hsize; size_t size, bsize;
ngx_hunk_t *h; ngx_buf_t *b;
ngx_chain_t *cl, *tl, *next, *out, **ll, **last_free, fl; ngx_chain_t *cl, *tl, *next, *out, **ll, **last_free, fl;
if (p->hunk_to_file) { if (p->buf_to_file) {
fl.hunk = p->hunk_to_file; fl.buf = p->buf_to_file;
fl.next = p->in; fl.next = p->in;
out = &fl; out = &fl;
@ -533,19 +525,19 @@ static int ngx_event_pipe_write_chain_to_temp_file(ngx_event_pipe_t *p)
"pipe offset: %d", p->temp_file->offset); "pipe offset: %d", p->temp_file->offset);
do { do {
hsize = cl->hunk->last - cl->hunk->pos; bsize = cl->buf->last - cl->buf->pos;
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0, ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0,
"pipe buf " PTR_FMT ", pos " PTR_FMT ", size: %d", "pipe buf " PTR_FMT ", pos " PTR_FMT ", size: %d",
cl->hunk->start, cl->hunk->pos, hsize); cl->buf->start, cl->buf->pos, bsize);
if ((size + hsize > p->temp_file_write_size) if ((size + bsize > p->temp_file_write_size)
|| (p->temp_file->offset + size + hsize > p->max_temp_file_size)) || (p->temp_file->offset + size + bsize > p->max_temp_file_size))
{ {
break; break;
} }
size += hsize; size += bsize;
ll = &cl->next; ll = &cl->next;
cl = cl->next; cl = cl->next;
@ -571,16 +563,16 @@ static int ngx_event_pipe_write_chain_to_temp_file(ngx_event_pipe_t *p)
return NGX_ABORT; return NGX_ABORT;
} }
for (last_free = &p->free_raw_hunks; for (last_free = &p->free_raw_bufs;
*last_free != NULL; *last_free != NULL;
last_free = &(*last_free)->next) last_free = &(*last_free)->next)
{ {
/* void */ /* void */
} }
if (p->hunk_to_file) { if (p->buf_to_file) {
p->temp_file->offset = p->hunk_to_file->last - p->hunk_to_file->pos; p->temp_file->offset = p->buf_to_file->last - p->buf_to_file->pos;
p->hunk_to_file = NULL; p->buf_to_file = NULL;
out = out->next; out = out->next;
} }
@ -588,27 +580,20 @@ static int ngx_event_pipe_write_chain_to_temp_file(ngx_event_pipe_t *p)
next = cl->next; next = cl->next;
cl->next = NULL; cl->next = NULL;
h = cl->hunk; b = cl->buf;
h->file = &p->temp_file->file; b->file = &p->temp_file->file;
h->file_pos = p->temp_file->offset; b->file_pos = p->temp_file->offset;
p->temp_file->offset += h->last - h->pos; p->temp_file->offset += b->last - b->pos;
h->file_last = p->temp_file->offset; b->file_last = p->temp_file->offset;
h->type |= NGX_HUNK_FILE|NGX_HUNK_TEMP_FILE; b->in_file = 1;
b->temp_file = 1;
#if 0
if (p->cachable) {
h->type |= NGX_HUNK_FILE;
} else {
h->type |= NGX_HUNK_FILE|NGX_HUNK_TEMP_FILE;
}
#endif
ngx_chain_add_link(p->out, p->last_out, cl); ngx_chain_add_link(p->out, p->last_out, cl);
if (h->type & NGX_HUNK_LAST_SHADOW) { if (b->last_shadow) {
h->shadow->last = h->shadow->pos = h->shadow->start; b->shadow->last = b->shadow->pos = b->shadow->start;
ngx_alloc_link_and_set_hunk(tl, h->shadow, p->pool, NGX_ABORT); ngx_alloc_link_and_set_buf(tl, b->shadow, p->pool, NGX_ABORT);
*last_free = tl; *last_free = tl;
last_free = &tl->next; last_free = &tl->next;
} }
@ -620,32 +605,35 @@ static int ngx_event_pipe_write_chain_to_temp_file(ngx_event_pipe_t *p)
/* the copy input filter */ /* the copy input filter */
int ngx_event_pipe_copy_input_filter(ngx_event_pipe_t *p, ngx_hunk_t *hunk) ngx_int_t ngx_event_pipe_copy_input_filter(ngx_event_pipe_t *p, ngx_buf_t *buf)
{ {
ngx_hunk_t *h; ngx_buf_t *b;
ngx_chain_t *cl; ngx_chain_t *cl;
if (hunk->pos == hunk->last) { if (buf->pos == buf->last) {
return NGX_OK; return NGX_OK;
} }
if (p->free) { if (p->free) {
h = p->free->hunk; b = p->free->buf;
p->free = p->free->next; p->free = p->free->next;
} else { } else {
ngx_test_null(h, ngx_alloc_hunk(p->pool), NGX_ERROR); if (!(b = ngx_alloc_buf(p->pool))) {
return NGX_ERROR;
}
} }
ngx_memcpy(h, hunk, sizeof(ngx_hunk_t)); ngx_memcpy(b, buf, sizeof(ngx_buf_t));
h->shadow = hunk; b->shadow = buf;
h->tag = p->tag; b->tag = p->tag;
h->type |= NGX_HUNK_LAST_SHADOW|NGX_HUNK_RECYCLED; b->last_shadow = 1;
hunk->shadow = h; b->recycled = 1;
buf->shadow = b;
ngx_alloc_link_and_set_hunk(cl, h, p->pool, NGX_ERROR); ngx_alloc_link_and_set_buf(cl, b, p->pool, NGX_ERROR);
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0, "hunk #%d", h->num); ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0, "buf #%d", b->num);
ngx_chain_add_link(p->in, p->last_in, cl); ngx_chain_add_link(p->in, p->last_in, cl);
@ -653,56 +641,65 @@ int ngx_event_pipe_copy_input_filter(ngx_event_pipe_t *p, ngx_hunk_t *hunk)
} }
ngx_inline static void ngx_event_pipe_remove_shadow_links(ngx_hunk_t *hunk) ngx_inline static void ngx_event_pipe_remove_shadow_links(ngx_buf_t *buf)
{ {
ngx_hunk_t *h, *next; ngx_buf_t *b, *next;
if (hunk->shadow == NULL) { if (buf->shadow == NULL) {
return; return;
} }
h = hunk->shadow; b = buf->shadow;
while (!(h->type & NGX_HUNK_LAST_SHADOW)) { while (!b->last_shadow) {
next = h->shadow; next = b->shadow;
h->type &= ~(NGX_HUNK_TEMP|NGX_HUNK_IN_MEMORY|NGX_HUNK_RECYCLED); #if 0
h->shadow = NULL; b->type &= ~(NGX_HUNK_TEMP|NGX_HUNK_IN_MEMORY|NGX_HUNK_RECYCLED);
h = next; #endif
b->temporary = 0;
b->recycled = 0;
b->shadow = NULL;
b = next;
} }
h->type &= ~(NGX_HUNK_TEMP #if 0
b->type &= ~(NGX_HUNK_TEMP
|NGX_HUNK_IN_MEMORY |NGX_HUNK_IN_MEMORY
|NGX_HUNK_RECYCLED |NGX_HUNK_RECYCLED
|NGX_HUNK_LAST_SHADOW); |NGX_HUNK_LAST_SHADOW);
h->shadow = NULL; #endif
hunk->shadow = NULL; b->temporary = 0;
b->recycled = 0;
b->last_shadow = 0;
b->shadow = NULL;
buf->shadow = NULL;
} }
ngx_inline static void ngx_event_pipe_free_shadow_raw_hunk(ngx_chain_t **free, ngx_inline static void ngx_event_pipe_free_shadow_raw_buf(ngx_chain_t **free,
ngx_hunk_t *h) ngx_buf_t *buf)
{ {
ngx_hunk_t *s; ngx_buf_t *s;
ngx_chain_t *cl, **ll; ngx_chain_t *cl, **ll;
if (h->shadow == NULL) { if (buf->shadow == NULL) {
return; return;
} }
for (s = h->shadow; !(s->type & NGX_HUNK_LAST_SHADOW); s = s->shadow) { for (s = buf->shadow; !s->last_shadow; s = s->shadow) { /* void */ }
/* void */
}
ll = free; ll = free;
for (cl = *free ; cl; cl = cl->next) { for (cl = *free ; cl; cl = cl->next) {
if (cl->hunk == s) { if (cl->buf == s) {
*ll = cl->next; *ll = cl->next;
break; break;
} }
if (cl->hunk->shadow) { if (cl->buf->shadow) {
break; break;
} }
@ -711,15 +708,15 @@ ngx_inline static void ngx_event_pipe_free_shadow_raw_hunk(ngx_chain_t **free,
} }
ngx_inline static void ngx_event_pipe_add_free_hunk(ngx_chain_t **chain, ngx_inline static void ngx_event_pipe_add_free_buf(ngx_chain_t **chain,
ngx_chain_t *cl) ngx_chain_t *cl)
{ {
if (*chain == NULL) { if (*chain == NULL) {
*chain = cl; *chain = cl;
return; return;
} }
if ((*chain)->hunk->pos != (*chain)->hunk->last) { if ((*chain)->buf->pos != (*chain)->buf->last) {
cl->next = (*chain)->next; cl->next = (*chain)->next;
(*chain)->next = cl; (*chain)->next = cl;
@ -730,9 +727,9 @@ ngx_inline static void ngx_event_pipe_add_free_hunk(ngx_chain_t **chain,
} }
static int ngx_event_pipe_drain_chains(ngx_event_pipe_t *p) static ngx_int_t ngx_event_pipe_drain_chains(ngx_event_pipe_t *p)
{ {
ngx_hunk_t *h; ngx_buf_t *b;
ngx_chain_t *cl, *tl; ngx_chain_t *cl, *tl;
for ( ;; ) { for ( ;; ) {
@ -753,17 +750,17 @@ static int ngx_event_pipe_drain_chains(ngx_event_pipe_t *p)
} }
while (cl) { while (cl) {
if (cl->hunk->type & NGX_HUNK_LAST_SHADOW) { if (cl->buf->last_shadow) {
h = cl->hunk->shadow; b = cl->buf->shadow;
h->pos = h->last = h->start; b->pos = b->last = b->start;
h->shadow = NULL; b->shadow = NULL;
ngx_alloc_link_and_set_hunk(tl, h, p->pool, NGX_ABORT); ngx_alloc_link_and_set_buf(tl, b, p->pool, NGX_ABORT);
ngx_event_pipe_add_free_hunk(&p->free_raw_hunks, tl); ngx_event_pipe_add_free_buf(&p->free_raw_bufs, tl);
cl->hunk->type &= ~NGX_HUNK_LAST_SHADOW; cl->buf->last_shadow = 0;
} }
cl->hunk->shadow = NULL; cl->buf->shadow = NULL;
tl = cl->next; tl = cl->next;
cl->next = p->free; cl->next = p->free;
p->free = cl; p->free = cl;

31
src/event/ngx_event_pipe.h
View File

@ -9,16 +9,17 @@
typedef struct ngx_event_pipe_s ngx_event_pipe_t; typedef struct ngx_event_pipe_s ngx_event_pipe_t;
typedef int (*ngx_event_pipe_input_filter_pt)(ngx_event_pipe_t *p, typedef ngx_int_t (*ngx_event_pipe_input_filter_pt)(ngx_event_pipe_t *p,
ngx_hunk_t *hunk); ngx_buf_t *buf);
typedef int (*ngx_event_pipe_output_filter_pt)(void *data, ngx_chain_t *chain); typedef ngx_int_t (*ngx_event_pipe_output_filter_pt)(void *data,
ngx_chain_t *chain);
struct ngx_event_pipe_s { struct ngx_event_pipe_s {
ngx_connection_t *upstream; ngx_connection_t *upstream;
ngx_connection_t *downstream; ngx_connection_t *downstream;
ngx_chain_t *free_raw_hunks; ngx_chain_t *free_raw_bufs;
ngx_chain_t *in; ngx_chain_t *in;
ngx_chain_t **last_in; ngx_chain_t **last_in;
@ -30,14 +31,14 @@ struct ngx_event_pipe_s {
/* /*
* the input filter i.e. that moves HTTP/1.1 chunks * the input filter i.e. that moves HTTP/1.1 chunks
* from the raw hunks to an incoming chain * from the raw bufs to an incoming chain
*/ */
ngx_event_pipe_input_filter_pt input_filter; ngx_event_pipe_input_filter_pt input_filter;
void *input_ctx; void *input_ctx;
ngx_event_pipe_output_filter_pt output_filter; ngx_event_pipe_output_filter_pt output_filter;
void *output_ctx; void *output_ctx;
unsigned read:1; unsigned read:1;
unsigned cachable:1; unsigned cachable:1;
@ -51,16 +52,16 @@ struct ngx_event_pipe_s {
unsigned downstream_error:1; unsigned downstream_error:1;
unsigned cyclic_temp_file:1; unsigned cyclic_temp_file:1;
int hunks; ngx_int_t allocated;
ngx_bufs_t bufs; ngx_bufs_t bufs;
ngx_hunk_tag_t tag; ngx_buf_tag_t tag;
size_t busy_size; size_t busy_size;
off_t read_length; off_t read_length;
off_t max_temp_file_size; off_t max_temp_file_size;
int temp_file_write_size; size_t temp_file_write_size;
ngx_msec_t read_timeout; ngx_msec_t read_timeout;
ngx_msec_t send_timeout; ngx_msec_t send_timeout;
@ -69,9 +70,9 @@ struct ngx_event_pipe_s {
ngx_pool_t *pool; ngx_pool_t *pool;
ngx_log_t *log; ngx_log_t *log;
ngx_chain_t *preread_hunks; ngx_chain_t *preread_bufs;
int preread_size; size_t preread_size;
ngx_hunk_t *hunk_to_file; ngx_buf_t *buf_to_file;
ngx_temp_file_t *temp_file; ngx_temp_file_t *temp_file;
@ -79,8 +80,8 @@ struct ngx_event_pipe_s {
}; };
int ngx_event_pipe(ngx_event_pipe_t *p, int do_write); ngx_int_t ngx_event_pipe(ngx_event_pipe_t *p, int do_write);
int ngx_event_pipe_copy_input_filter(ngx_event_pipe_t *p, ngx_hunk_t *hunk); ngx_int_t ngx_event_pipe_copy_input_filter(ngx_event_pipe_t *p, ngx_buf_t *buf);
#endif /* _NGX_EVENT_PIPE_H_INCLUDED_ */ #endif /* _NGX_EVENT_PIPE_H_INCLUDED_ */

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

@ -40,7 +40,7 @@ typedef struct {
} ngx_http_charset_ctx_t; } ngx_http_charset_ctx_t;
static void ngx_charset_recode(ngx_hunk_t *h, char *table); static void ngx_charset_recode(ngx_buf_t *b, char *table);
static char *ngx_charset_map_block(ngx_conf_t *cf, ngx_command_t *cmd, static char *ngx_charset_map_block(ngx_conf_t *cf, ngx_command_t *cmd,
void *conf); void *conf);
@ -50,7 +50,7 @@ static char *ngx_http_set_charset_slot(ngx_conf_t *cf, ngx_command_t *cmd,
void *conf); void *conf);
static ngx_int_t ngx_http_add_charset(ngx_array_t *charsets, ngx_str_t *name); static ngx_int_t ngx_http_add_charset(ngx_array_t *charsets, ngx_str_t *name);
static int ngx_http_charset_filter_init(ngx_cycle_t *cycle); static ngx_int_t ngx_http_charset_filter_init(ngx_cycle_t *cycle);
static void *ngx_http_charset_create_main_conf(ngx_conf_t *cf); static void *ngx_http_charset_create_main_conf(ngx_conf_t *cf);
static char *ngx_http_charset_init_main_conf(ngx_conf_t *cf, void *conf); static char *ngx_http_charset_init_main_conf(ngx_conf_t *cf, void *conf);
@ -212,18 +212,18 @@ static int ngx_http_charset_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
table = charsets[lcf->source_charset].tables[lcf->default_charset]; table = charsets[lcf->source_charset].tables[lcf->default_charset];
for (cl = in; cl; cl = cl->next) { for (cl = in; cl; cl = cl->next) {
ngx_charset_recode(cl->hunk, table); ngx_charset_recode(cl->buf, table);
} }
return ngx_http_next_body_filter(r, in); return ngx_http_next_body_filter(r, in);
} }
static void ngx_charset_recode(ngx_hunk_t *h, char *table) static void ngx_charset_recode(ngx_buf_t *b, char *table)
{ {
u_char *p, c; u_char *p, c;
for (p = h->pos; p < h->last; p++) { for (p = b->pos; p < b->last; p++) {
c = *p; c = *p;
*p = table[c]; *p = table[c];
} }
@ -412,7 +412,7 @@ static ngx_int_t ngx_http_add_charset(ngx_array_t *charsets, ngx_str_t *name)
} }
static int ngx_http_charset_filter_init(ngx_cycle_t *cycle) static ngx_int_t ngx_http_charset_filter_init(ngx_cycle_t *cycle)
{ {
ngx_http_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;

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

@ -58,14 +58,14 @@ static int ngx_http_chunked_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
{ {
u_char *chunk; u_char *chunk;
size_t size, len; size_t size, len;
ngx_hunk_t *h; ngx_buf_t *b;
ngx_chain_t out, tail, *cl, *tl, **ll; ngx_chain_t out, tail, *cl, *tl, **ll;
if (in == NULL || !r->chunked) { if (in == NULL || !r->chunked) {
return ngx_http_next_body_filter(r, in); return ngx_http_next_body_filter(r, in);
} }
out.hunk = NULL; out.buf = NULL;
ll = &out.next; ll = &out.next;
size = 0; size = 0;
@ -73,12 +73,12 @@ static int ngx_http_chunked_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
for ( ;; ) { for ( ;; ) {
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"http chunk: %d", ngx_hunk_size(cl->hunk)); "http chunk: %d", ngx_buf_size(cl->buf));
size += ngx_hunk_size(cl->hunk); size += ngx_buf_size(cl->buf);
ngx_test_null(tl, ngx_alloc_chain_link(r->pool), NGX_ERROR); ngx_test_null(tl, ngx_alloc_chain_link(r->pool), NGX_ERROR);
tl->hunk = cl->hunk; tl->buf = cl->buf;
*ll = tl; *ll = tl;
ll = &tl->next; ll = &tl->next;
@ -93,25 +93,26 @@ static int ngx_http_chunked_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
ngx_test_null(chunk, ngx_palloc(r->pool, 11), NGX_ERROR); ngx_test_null(chunk, ngx_palloc(r->pool, 11), NGX_ERROR);
len = ngx_snprintf((char *) chunk, 11, SIZE_T_X_FMT CRLF, size); len = ngx_snprintf((char *) chunk, 11, SIZE_T_X_FMT CRLF, size);
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR); ngx_test_null(b, ngx_calloc_buf(r->pool), NGX_ERROR);
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_TEMP; b->temporary = 1;
h->pos = chunk; b->pos = chunk;
h->last = chunk + len; b->last = chunk + len;
out.hunk = h; out.buf = b;
} }
if (cl->hunk->type & NGX_HUNK_LAST) { if (cl->buf->last_buf) {
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR); ngx_test_null(b, ngx_calloc_buf(r->pool), NGX_ERROR);
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_MEMORY|NGX_HUNK_LAST; b->memory = 1;
h->pos = (u_char *) CRLF "0" CRLF CRLF; b->last_buf = 1;
h->last = h->pos + 7; b->pos = (u_char *) CRLF "0" CRLF CRLF;
b->last = b->pos + 7;
cl->hunk->type &= ~NGX_HUNK_LAST; cl->buf->last_buf = 0;
if (size == 0) { if (size == 0) {
h->pos += 2; b->pos += 2;
out.hunk = h; out.buf = b;
out.next = NULL; out.next = NULL;
return ngx_http_next_body_filter(r, &out); return ngx_http_next_body_filter(r, &out);
@ -123,13 +124,13 @@ static int ngx_http_chunked_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
return ngx_http_next_body_filter(r, out.next); return ngx_http_next_body_filter(r, out.next);
} }
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR); ngx_test_null(b, ngx_calloc_buf(r->pool), NGX_ERROR);
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_MEMORY; b->memory = 1;
h->pos = (u_char *) CRLF; b->pos = (u_char *) CRLF;
h->last = h->pos + 2; b->last = b->pos + 2;
} }
tail.hunk = h; tail.buf = b;
tail.next = NULL; tail.next = NULL;
*ll = &tail; *ll = &tail;

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

@ -39,9 +39,9 @@ typedef struct {
ngx_chain_t *busy; ngx_chain_t *busy;
ngx_chain_t *out; ngx_chain_t *out;
ngx_chain_t **last_out; ngx_chain_t **last_out;
ngx_hunk_t *in_hunk; ngx_buf_t *in_buf;
ngx_hunk_t *out_hunk; ngx_buf_t *out_buf;
ngx_int_t hunks; ngx_int_t bufs;
off_t length; off_t length;
@ -407,7 +407,7 @@ static int ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
{ {
int rc, wbits, memlevel, last; int rc, wbits, memlevel, last;
struct gztrailer *trailer; struct gztrailer *trailer;
ngx_hunk_t *h; ngx_buf_t *b;
ngx_chain_t *cl; 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;
@ -465,13 +465,13 @@ static int ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
return ngx_http_gzip_error(ctx); return ngx_http_gzip_error(ctx);
} }
ngx_test_null(h, ngx_calloc_hunk(r->pool), ngx_http_gzip_error(ctx)); ngx_test_null(b, ngx_calloc_buf(r->pool), ngx_http_gzip_error(ctx));
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_MEMORY; b->memory = 1;
h->pos = gzheader; b->pos = gzheader;
h->last = h->pos + 10; b->last = b->pos + 10;
ngx_alloc_link_and_set_hunk(cl, h, r->pool, ngx_http_gzip_error(ctx)); ngx_alloc_link_and_set_buf(cl, b, r->pool, ngx_http_gzip_error(ctx));
ctx->out = cl; ctx->out = cl;
ctx->last_out = &cl->next; ctx->last_out = &cl->next;
@ -504,29 +504,29 @@ static int ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
break; break;
} }
ctx->in_hunk = ctx->in->hunk; ctx->in_buf = ctx->in->buf;
ctx->in = ctx->in->next; ctx->in = ctx->in->next;
ctx->zstream.next_in = ctx->in_hunk->pos; ctx->zstream.next_in = ctx->in_buf->pos;
ctx->zstream.avail_in = ctx->in_hunk->last - ctx->in_hunk->pos; ctx->zstream.avail_in = ctx->in_buf->last - ctx->in_buf->pos;
ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"gzip in_hunk:" PTR_FMT " ni:" PTR_FMT " ai:%d", "gzip in_buf:" PTR_FMT " ni:" PTR_FMT " ai:%d",
ctx->in_hunk, ctx->in_buf,
ctx->zstream.next_in, ctx->zstream.avail_in); ctx->zstream.next_in, ctx->zstream.avail_in);
/* STUB */ /* STUB */
if (ctx->in_hunk->last < ctx->in_hunk->pos) { if (ctx->in_buf->last < ctx->in_buf->pos) {
ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0, ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
"zstream.avail_in is huge"); "zstream.avail_in is huge");
ctx->done = 1; ctx->done = 1;
return NGX_ERROR; return NGX_ERROR;
} }
if (ctx->in_hunk->type & NGX_HUNK_LAST) { if (ctx->in_buf->last_buf) {
ctx->flush = Z_FINISH; ctx->flush = Z_FINISH;
} else if (ctx->in_hunk->type & NGX_HUNK_FLUSH) { } else if (ctx->in_buf->flush) {
ctx->flush = Z_SYNC_FLUSH; ctx->flush = Z_SYNC_FLUSH;
} }
@ -545,17 +545,17 @@ static int ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
if (ctx->zstream.avail_out == 0) { if (ctx->zstream.avail_out == 0) {
if (ctx->free) { if (ctx->free) {
ctx->out_hunk = ctx->free->hunk; ctx->out_buf = ctx->free->buf;
ctx->free = ctx->free->next; ctx->free = ctx->free->next;
} else if (ctx->hunks < conf->bufs.num) { } else if (ctx->bufs < conf->bufs.num) {
ngx_test_null(ctx->out_hunk, ngx_test_null(ctx->out_buf,
ngx_create_temp_hunk(r->pool, conf->bufs.size), ngx_create_temp_buf(r->pool, conf->bufs.size),
ngx_http_gzip_error(ctx)); ngx_http_gzip_error(ctx));
ctx->out_hunk->tag = (ngx_hunk_tag_t) ctx->out_buf->tag = (ngx_buf_tag_t)
&ngx_http_gzip_filter_module; &ngx_http_gzip_filter_module;
ctx->out_hunk->type |= NGX_HUNK_RECYCLED; ctx->out_buf->recycled = 1;
ctx->hunks++; ctx->bufs++;
} else { } else {
ctx->blocked = 1; ctx->blocked = 1;
@ -563,7 +563,7 @@ static int ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
} }
ctx->blocked = 0; ctx->blocked = 0;
ctx->zstream.next_out = ctx->out_hunk->pos; ctx->zstream.next_out = ctx->out_buf->pos;
ctx->zstream.avail_out = conf->bufs.size; ctx->zstream.avail_out = conf->bufs.size;
} }
@ -587,23 +587,23 @@ static int ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
rc); rc);
ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"gzip in_hunk:" PTR_FMT " pos:" PTR_FMT, "gzip in_buf:" PTR_FMT " pos:" PTR_FMT,
ctx->in_hunk, ctx->in_hunk->pos); ctx->in_buf, ctx->in_buf->pos);
if (ctx->zstream.next_in) { if (ctx->zstream.next_in) {
ctx->in_hunk->pos = ctx->zstream.next_in; ctx->in_buf->pos = ctx->zstream.next_in;
if (ctx->zstream.avail_in == 0) { if (ctx->zstream.avail_in == 0) {
ctx->zstream.next_in = NULL; ctx->zstream.next_in = NULL;
} }
} }
ctx->out_hunk->last = ctx->zstream.next_out; ctx->out_buf->last = ctx->zstream.next_out;
if (ctx->zstream.avail_out == 0) { if (ctx->zstream.avail_out == 0) {
ngx_alloc_link_and_set_hunk(cl, ctx->out_hunk, r->pool, ngx_alloc_link_and_set_buf(cl, ctx->out_buf, r->pool,
ngx_http_gzip_error(ctx)); ngx_http_gzip_error(ctx));
*ctx->last_out = cl; *ctx->last_out = cl;
ctx->last_out = &cl->next; ctx->last_out = &cl->next;
ctx->redo = 1; ctx->redo = 1;
@ -614,11 +614,11 @@ static int ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
ctx->redo = 0; ctx->redo = 0;
if (ctx->flush == Z_SYNC_FLUSH) { if (ctx->flush == Z_SYNC_FLUSH) {
ctx->out_hunk->type |= NGX_HUNK_FLUSH; ctx->out_buf->flush = 0;
ctx->flush = Z_NO_FLUSH; ctx->flush = Z_NO_FLUSH;
ngx_alloc_link_and_set_hunk(cl, ctx->out_hunk, r->pool, ngx_alloc_link_and_set_buf(cl, ctx->out_buf, r->pool,
ngx_http_gzip_error(ctx)); ngx_http_gzip_error(ctx));
*ctx->last_out = cl; *ctx->last_out = cl;
ctx->last_out = &cl->next; ctx->last_out = &cl->next;
ctx->pass = 1; ctx->pass = 1;
@ -640,28 +640,28 @@ static int ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
ngx_pfree(r->pool, ctx->preallocated); ngx_pfree(r->pool, ctx->preallocated);
ngx_alloc_link_and_set_hunk(cl, ctx->out_hunk, r->pool, ngx_alloc_link_and_set_buf(cl, ctx->out_buf, r->pool,
ngx_http_gzip_error(ctx)); ngx_http_gzip_error(ctx));
*ctx->last_out = cl; *ctx->last_out = cl;
ctx->last_out = &cl->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_buf->last;
ctx->out_hunk->type |= NGX_HUNK_LAST; ctx->out_buf->last += 8;
ctx->out_hunk->last += 8; ctx->out_buf->last_buf = 1;
} else { } else {
ngx_test_null(h, ngx_create_temp_hunk(r->pool, 8), ngx_test_null(b, ngx_create_temp_buf(r->pool, 8),
ngx_http_gzip_error(ctx)); ngx_http_gzip_error(ctx));
h->type |= NGX_HUNK_LAST; b->last_buf = 1;
ngx_alloc_link_and_set_hunk(cl, h, r->pool, ngx_alloc_link_and_set_buf(cl, b, r->pool,
ngx_http_gzip_error(ctx)); ngx_http_gzip_error(ctx));
*ctx->last_out = cl; *ctx->last_out = cl;
ctx->last_out = &cl->next; ctx->last_out = &cl->next;
trailer = (struct gztrailer *) h->pos; trailer = (struct gztrailer *) b->pos;
h->last += 8; b->last += 8;
} }
#if (HAVE_LITTLE_ENDIAN) #if (HAVE_LITTLE_ENDIAN)
@ -681,8 +681,8 @@ static int ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
} }
if (conf->no_buffer && ctx->in == NULL) { if (conf->no_buffer && ctx->in == NULL) {
ngx_alloc_link_and_set_hunk(cl, ctx->out_hunk, r->pool, ngx_alloc_link_and_set_buf(cl, ctx->out_buf, r->pool,
ngx_http_gzip_error(ctx)); ngx_http_gzip_error(ctx));
*ctx->last_out = cl; *ctx->last_out = cl;
ctx->last_out = &cl->next; ctx->last_out = &cl->next;
ctx->pass = 1; ctx->pass = 1;
@ -719,7 +719,7 @@ static int ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
} }
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_gzip_filter_module); (ngx_buf_tag_t) &ngx_http_gzip_filter_module);
ctx->last_out = &ctx->out; ctx->last_out = &ctx->out;
if (ctx->done) { if (ctx->done) {

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

@ -406,7 +406,7 @@ static ngx_int_t ngx_http_range_body_filter(ngx_http_request_t *r,
ngx_chain_t *in) ngx_chain_t *in)
{ {
ngx_uint_t i; ngx_uint_t i;
ngx_hunk_t *h; ngx_buf_t *b;
ngx_chain_t *out, *hcl, *rcl, *dcl, **ll; 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;
@ -417,18 +417,15 @@ static ngx_int_t ngx_http_range_body_filter(ngx_http_request_t *r,
/* /*
* the optimized version for the static files only * the optimized version for the static files only
* that are passed in the single file hunk * that are passed in the single file buf
*/ */
if (in if (in && in->buf->in_file && in->buf->last_buf) {
&& in->hunk->type & NGX_HUNK_FILE
&& in->hunk->type & NGX_HUNK_LAST)
{
range = r->headers_out.ranges.elts; range = r->headers_out.ranges.elts;
if (r->headers_out.ranges.nelts == 1) { if (r->headers_out.ranges.nelts == 1) {
in->hunk->file_pos = range->start; in->buf->file_pos = range->start;
in->hunk->file_last = range->end; in->buf->file_last = range->end;
return ngx_http_next_body_filter(r, in); return ngx_http_next_body_filter(r, in);
} }
@ -446,33 +443,33 @@ static ngx_int_t ngx_http_range_body_filter(ngx_http_request_t *r,
* "Content-Range: bytes " * "Content-Range: bytes "
*/ */
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR); ngx_test_null(b, ngx_calloc_buf(r->pool), NGX_ERROR);
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_MEMORY; b->memory = 1;
h->pos = ctx->boundary_header.data; b->pos = ctx->boundary_header.data;
h->last = ctx->boundary_header.data + ctx->boundary_header.len; b->last = ctx->boundary_header.data + ctx->boundary_header.len;
ngx_test_null(hcl, ngx_alloc_chain_link(r->pool), NGX_ERROR); ngx_test_null(hcl, ngx_alloc_chain_link(r->pool), NGX_ERROR);
hcl->hunk = h; hcl->buf = b;
/* "SSSS-EEEE/TTTT" CRLF CRLF */ /* "SSSS-EEEE/TTTT" CRLF CRLF */
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR); ngx_test_null(b, ngx_calloc_buf(r->pool), NGX_ERROR);
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_TEMP; b->temporary = 1;
h->pos = range[i].content_range.data; b->pos = range[i].content_range.data;
h->last = range[i].content_range.data + range[i].content_range.len; b->last = range[i].content_range.data + range[i].content_range.len;
ngx_test_null(rcl, ngx_alloc_chain_link(r->pool), NGX_ERROR); ngx_test_null(rcl, ngx_alloc_chain_link(r->pool), NGX_ERROR);
rcl->hunk = h; rcl->buf = b;
/* the range data */ /* the range data */
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR); ngx_test_null(b, ngx_calloc_buf(r->pool), NGX_ERROR);
h->type = NGX_HUNK_FILE; b->in_file = 1;
h->file_pos = range[i].start; b->file_pos = range[i].start;
h->file_last = range[i].end; b->file_last = range[i].end;
h->file = in->hunk->file; b->file = in->buf->file;
ngx_alloc_link_and_set_hunk(dcl, h, r->pool, NGX_ERROR); ngx_alloc_link_and_set_buf(dcl, b, r->pool, NGX_ERROR);
*ll = hcl; *ll = hcl;
hcl->next = rcl; hcl->next = rcl;
@ -482,14 +479,15 @@ static ngx_int_t ngx_http_range_body_filter(ngx_http_request_t *r,
/* the last boundary CRLF "--0123456789--" CRLF */ /* the last boundary CRLF "--0123456789--" CRLF */
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR); ngx_test_null(b, ngx_calloc_buf(r->pool), NGX_ERROR);
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_TEMP|NGX_HUNK_LAST; b->temporary = 1;
ngx_test_null(h->pos, ngx_palloc(r->pool, 4 + 10 + 4), NGX_ERROR); b->last_buf = 1;
h->last = ngx_cpymem(h->pos, ctx->boundary_header.data, 4 + 10); ngx_test_null(b->pos, ngx_palloc(r->pool, 4 + 10 + 4), NGX_ERROR);
*h->last++ = '-'; *h->last++ = '-'; b->last = ngx_cpymem(b->pos, ctx->boundary_header.data, 4 + 10);
*h->last++ = CR; *h->last++ = LF; *b->last++ = '-'; *b->last++ = '-';
*b->last++ = CR; *b->last++ = LF;
ngx_alloc_link_and_set_hunk(hcl, h, r->pool, NGX_ERROR); ngx_alloc_link_and_set_buf(hcl, b, r->pool, NGX_ERROR);
*ll = hcl; *ll = hcl;
return ngx_http_next_body_filter(r, out); return ngx_http_next_body_filter(r, out);

22
src/http/modules/ngx_http_static_handler.c
View File

@ -67,7 +67,7 @@ static ngx_int_t ngx_http_static_handler(ngx_http_request_t *r)
ngx_str_t name, location; ngx_str_t name, location;
ngx_err_t err; ngx_err_t err;
ngx_log_t *log; ngx_log_t *log;
ngx_hunk_t *h; ngx_buf_t *b;
ngx_chain_t out; ngx_chain_t out;
ngx_file_info_t fi; ngx_file_info_t fi;
ngx_http_cleanup_t *file_cleanup, *redirect_cleanup; ngx_http_cleanup_t *file_cleanup, *redirect_cleanup;
@ -472,11 +472,11 @@ static ngx_int_t ngx_http_static_handler(ngx_http_request_t *r)
/* we need to allocate all before the header would be sent */ /* we need to allocate all before the header would be sent */
if (!(h = ngx_pcalloc(r->pool, sizeof(ngx_hunk_t)))) { if (!(b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t)))) {
return NGX_HTTP_INTERNAL_SERVER_ERROR; return NGX_HTTP_INTERNAL_SERVER_ERROR;
} }
if (!(h->file = ngx_pcalloc(r->pool, sizeof(ngx_file_t)))) { if (!(b->file = ngx_pcalloc(r->pool, sizeof(ngx_file_t)))) {
return NGX_HTTP_INTERNAL_SERVER_ERROR; return NGX_HTTP_INTERNAL_SERVER_ERROR;
} }
@ -487,15 +487,19 @@ static ngx_int_t ngx_http_static_handler(ngx_http_request_t *r)
return rc; return rc;
} }
h->type = r->main ? NGX_HUNK_FILE : NGX_HUNK_FILE|NGX_HUNK_LAST; b->in_file = 1;
h->file_pos = 0; if (!r->main) {
h->file_last = ngx_file_size(&fi); b->last_buf = 1;
}
h->file->fd = fd; b->file_pos = 0;
h->file->log = log; b->file_last = ngx_file_size(&fi);
out.hunk = h; b->file->fd = fd;
b->file->log = log;
out.buf = b;
out.next = NULL; out.next = NULL;
return ngx_http_output_filter(r, &out); return ngx_http_output_filter(r, &out);

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

@ -159,7 +159,7 @@ struct ngx_http_proxy_ctx_s {
ngx_http_proxy_upstream_t *upstream; ngx_http_proxy_upstream_t *upstream;
ngx_http_proxy_cache_t *cache; ngx_http_proxy_cache_t *cache;
ngx_hunk_t *header_in; ngx_buf_t *header_in;
ngx_http_busy_lock_ctx_t busy_lock; ngx_http_busy_lock_ctx_t busy_lock;

111
src/http/modules/proxy/ngx_http_proxy_upstream.c
View File

@ -108,7 +108,7 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
{ {
size_t len; size_t len;
ngx_uint_t i; ngx_uint_t i;
ngx_hunk_t *h; ngx_buf_t *b;
ngx_chain_t *chain; ngx_chain_t *chain;
ngx_table_elt_t *header; ngx_table_elt_t *header;
ngx_http_request_t *r; ngx_http_request_t *r;
@ -177,71 +177,73 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
len += header[i].key.len + 2 + header[i].value.len + 2; len += header[i].key.len + 2 + header[i].value.len + 2;
} }
/* STUB */ len++; #if (NGX_DEBUG)
len++;
#endif
ngx_test_null(h, ngx_create_temp_hunk(r->pool, len), NULL); ngx_test_null(b, ngx_create_temp_buf(r->pool, len), NULL);
ngx_alloc_link_and_set_hunk(chain, h, r->pool, NULL); ngx_alloc_link_and_set_buf(chain, b, r->pool, NULL);
/* the request line */ /* the request line */
if (p->upstream->method) { if (p->upstream->method) {
h->last = ngx_cpymem(h->last, b->last = ngx_cpymem(b->last,
http_methods[p->upstream->method - 1].data, http_methods[p->upstream->method - 1].data,
http_methods[p->upstream->method - 1].len); http_methods[p->upstream->method - 1].len);
} else { } else {
h->last = ngx_cpymem(h->last, r->method_name.data, r->method_name.len); b->last = ngx_cpymem(b->last, r->method_name.data, r->method_name.len);
} }
h->last = ngx_cpymem(h->last, uc->uri.data, uc->uri.len); b->last = ngx_cpymem(b->last, uc->uri.data, uc->uri.len);
h->last = ngx_cpymem(h->last, b->last = ngx_cpymem(b->last,
r->uri.data + uc->location->len, r->uri.data + uc->location->len,
r->uri.len - uc->location->len); r->uri.len - uc->location->len);
if (r->args.len > 0) { if (r->args.len > 0) {
*(h->last++) = '?'; *(b->last++) = '?';
h->last = ngx_cpymem(h->last, r->args.data, r->args.len); b->last = ngx_cpymem(b->last, r->args.data, r->args.len);
} }
h->last = ngx_cpymem(h->last, http_version, sizeof(http_version) - 1); b->last = ngx_cpymem(b->last, http_version, sizeof(http_version) - 1);
/* the "Connection: close" header */ /* the "Connection: close" header */
h->last = ngx_cpymem(h->last, connection_close_header, b->last = ngx_cpymem(b->last, connection_close_header,
sizeof(connection_close_header) - 1); sizeof(connection_close_header) - 1);
/* the "Host" header */ /* the "Host" header */
h->last = ngx_cpymem(h->last, host_header, sizeof(host_header) - 1); b->last = ngx_cpymem(b->last, host_header, sizeof(host_header) - 1);
if (p->lcf->preserve_host && r->headers_in.host) { if (p->lcf->preserve_host && r->headers_in.host) {
h->last = ngx_cpymem(h->last, r->headers_in.host->value.data, b->last = ngx_cpymem(b->last, r->headers_in.host->value.data,
r->headers_in.host_name_len); r->headers_in.host_name_len);
if (!uc->default_port) { if (!uc->default_port) {
*(h->last++) = ':'; *(b->last++) = ':';
h->last = ngx_cpymem(h->last, uc->port_text.data, b->last = ngx_cpymem(b->last, uc->port_text.data,
uc->port_text.len); uc->port_text.len);
} }
} else { } else {
h->last = ngx_cpymem(h->last, uc->host_header.data, b->last = ngx_cpymem(b->last, uc->host_header.data,
uc->host_header.len); uc->host_header.len);
} }
*(h->last++) = CR; *(h->last++) = LF; *(b->last++) = CR; *(b->last++) = LF;
/* the "X-Real-IP" header */ /* the "X-Real-IP" header */
if (p->lcf->set_x_real_ip) { if (p->lcf->set_x_real_ip) {
h->last = ngx_cpymem(h->last, x_real_ip_header, b->last = ngx_cpymem(b->last, x_real_ip_header,
sizeof(x_real_ip_header) - 1); sizeof(x_real_ip_header) - 1);
h->last = ngx_cpymem(h->last, r->connection->addr_text.data, b->last = ngx_cpymem(b->last, r->connection->addr_text.data,
r->connection->addr_text.len); r->connection->addr_text.len);
*(h->last++) = CR; *(h->last++) = LF; *(b->last++) = CR; *(b->last++) = LF;
} }
@ -249,23 +251,23 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
if (p->lcf->add_x_forwarded_for) { if (p->lcf->add_x_forwarded_for) {
if (r->headers_in.x_forwarded_for) { if (r->headers_in.x_forwarded_for) {
h->last = ngx_cpymem(h->last, x_forwarded_for_header, b->last = ngx_cpymem(b->last, x_forwarded_for_header,
sizeof(x_forwarded_for_header) - 1); sizeof(x_forwarded_for_header) - 1);
h->last = ngx_cpymem(h->last, b->last = ngx_cpymem(b->last,
r->headers_in.x_forwarded_for->value.data, r->headers_in.x_forwarded_for->value.data,
r->headers_in.x_forwarded_for->value.len); r->headers_in.x_forwarded_for->value.len);
*(h->last++) = ','; *(h->last++) = ' '; *(b->last++) = ','; *(b->last++) = ' ';
} else { } else {
h->last = ngx_cpymem(h->last, x_forwarded_for_header, b->last = ngx_cpymem(b->last, x_forwarded_for_header,
sizeof(x_forwarded_for_header) - 1); sizeof(x_forwarded_for_header) - 1);
} }
h->last = ngx_cpymem(h->last, r->connection->addr_text.data, b->last = ngx_cpymem(b->last, r->connection->addr_text.data,
r->connection->addr_text.len); r->connection->addr_text.len);
*(h->last++) = CR; *(h->last++) = LF; *(b->last++) = CR; *(b->last++) = LF;
} }
@ -289,14 +291,14 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
continue; continue;
} }
h->last = ngx_cpymem(h->last, header[i].key.data, header[i].key.len); b->last = ngx_cpymem(b->last, header[i].key.data, header[i].key.len);
*(h->last++) = ':'; *(h->last++) = ' '; *(b->last++) = ':'; *(b->last++) = ' ';
h->last = ngx_cpymem(h->last, header[i].value.data, b->last = ngx_cpymem(b->last, header[i].value.data,
header[i].value.len); header[i].value.len);
*(h->last++) = CR; *(h->last++) = LF; *(b->last++) = CR; *(b->last++) = LF;
ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"http proxy header: \"%s: %s\"", "http proxy header: \"%s: %s\"",
@ -304,12 +306,12 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
} }
/* add "\r\n" at the header end */ /* add "\r\n" at the header end */
*(h->last++) = CR; *(h->last++) = LF; *(b->last++) = CR; *(b->last++) = LF;
#if (NGX_DEBUG) #if (NGX_DEBUG)
*(h->last) = '\0'; *(b->last) = '\0';
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"http proxy header:\n\"%s\"", h->pos); "http proxy header:\n\"%s\"", b->pos);
#endif #endif
return chain; return chain;
@ -389,7 +391,7 @@ static void ngx_http_proxy_init_upstream(void *data)
output->sendfile = r->sendfile; output->sendfile = r->sendfile;
output->pool = r->pool; output->pool = r->pool;
output->bufs.num = 1; output->bufs.num = 1;
output->tag = (ngx_hunk_tag_t) &ngx_http_proxy_module; output->tag = (ngx_buf_tag_t) &ngx_http_proxy_module;
output->output_filter = (ngx_output_chain_filter_pt) ngx_chain_writer; output->output_filter = (ngx_output_chain_filter_pt) ngx_chain_writer;
if (!(writer = ngx_palloc(r->pool, sizeof(ngx_chain_writer_ctx_t)))) { if (!(writer = ngx_palloc(r->pool, sizeof(ngx_chain_writer_ctx_t)))) {
@ -420,15 +422,15 @@ static void ngx_http_proxy_reinit_upstream(ngx_http_proxy_ctx_t *p)
/* reinit the request chain */ /* reinit the request chain */
for (cl = p->request->request_body->bufs; cl; cl = cl->next) { for (cl = p->request->request_body->bufs; cl; cl = cl->next) {
cl->hunk->pos = cl->hunk->start; cl->buf->pos = cl->buf->start;
cl->hunk->file_pos = 0; cl->buf->file_pos = 0;
} }
/* reinit the ngx_output_chain() context */ /* reinit the ngx_output_chain() context */
output = p->upstream->output_chain_ctx; output = p->upstream->output_chain_ctx;
output->hunk = NULL; output->buf = NULL;
output->in = NULL; output->in = NULL;
output->free = NULL; output->free = NULL;
output->busy = NULL; output->busy = NULL;
@ -614,9 +616,9 @@ static void ngx_http_proxy_connect(ngx_http_proxy_ctx_t *p)
return; return;
} }
output->free->hunk = r->request_body->buf; output->free->buf = r->request_body->buf;
output->free->next = NULL; output->free->buf = NULL;
output->hunks = 1; output->allocated = 1;
r->request_body->buf->pos = r->request_body->buf->start; r->request_body->buf->pos = r->request_body->buf->start;
} }
@ -793,13 +795,13 @@ 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_buf(p->request->pool,
p->lcf->header_buffer_size); p->lcf->header_buffer_size);
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);
return; return;
} }
p->header_in->tag = (ngx_hunk_tag_t) &ngx_http_proxy_module; p->header_in->tag = (ngx_buf_tag_t) &ngx_http_proxy_module;
if (p->cache) { if (p->cache) {
p->header_in->pos += p->cache->ctx.header_size; p->header_in->pos += p->cache->ctx.header_size;
@ -1176,7 +1178,7 @@ static void ngx_http_proxy_send_response(ngx_http_proxy_ctx_t *p)
ep->output_filter = (ngx_event_pipe_output_filter_pt) ep->output_filter = (ngx_event_pipe_output_filter_pt)
ngx_http_output_filter; ngx_http_output_filter;
ep->output_ctx = r; ep->output_ctx = r;
ep->tag = (ngx_hunk_tag_t) &ngx_http_proxy_module; ep->tag = (ngx_buf_tag_t) &ngx_http_proxy_module;
ep->bufs = p->lcf->bufs; ep->bufs = p->lcf->bufs;
ep->busy_size = p->lcf->busy_buffers_size; ep->busy_size = p->lcf->busy_buffers_size;
ep->upstream = p->upstream->peer.connection; ep->upstream = p->upstream->peer.connection;
@ -1206,25 +1208,24 @@ static void ngx_http_proxy_send_response(ngx_http_proxy_ctx_t *p)
ep->max_temp_file_size = p->lcf->max_temp_file_size; ep->max_temp_file_size = p->lcf->max_temp_file_size;
ep->temp_file_write_size = p->lcf->temp_file_write_size; ep->temp_file_write_size = p->lcf->temp_file_write_size;
ep->preread_hunks = ngx_alloc_chain_link(r->pool); if (!(ep->preread_bufs = ngx_alloc_chain_link(r->pool))) {
if (ep->preread_hunks == NULL) {
ngx_http_proxy_finalize_request(p, 0); ngx_http_proxy_finalize_request(p, 0);
return; return;
} }
ep->preread_hunks->hunk = p->header_in; ep->preread_bufs->buf = p->header_in;
ep->preread_hunks->next = NULL; ep->preread_bufs->next = NULL;
ep->preread_size = p->header_in->last - p->header_in->pos; ep->preread_size = p->header_in->last - p->header_in->pos;
if (p->cachable) { if (p->cachable) {
ep->hunk_to_file = ngx_calloc_hunk(r->pool); ep->buf_to_file = ngx_calloc_buf(r->pool);
if (ep->hunk_to_file == NULL) { if (ep->buf_to_file == NULL) {
ngx_http_proxy_finalize_request(p, 0); ngx_http_proxy_finalize_request(p, 0);
return; return;
} }
ep->hunk_to_file->pos = p->header_in->start; ep->buf_to_file->pos = p->header_in->start;
ep->hunk_to_file->last = p->header_in->pos; ep->buf_to_file->last = p->header_in->pos;
ep->hunk_to_file->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_TEMP; ep->buf_to_file->temporary = 1;
} }
if (ngx_event_flags & NGX_USE_AIO_EVENT) { if (ngx_event_flags & NGX_USE_AIO_EVENT) {
@ -1232,7 +1233,7 @@ static void ngx_http_proxy_send_response(ngx_http_proxy_ctx_t *p)
ep->single_buf = 1; ep->single_buf = 1;
} }
/* TODO: ep->free_bufs = 0 if use ngx_create_chain_of_hunks() */ /* TODO: ep->free_bufs = 0 if use ngx_create_chain_of_bufs() */
ep->free_bufs = 1; ep->free_bufs = 1;
/* /*

2
src/http/ngx_http.h
View File

@ -62,7 +62,7 @@ void ngx_http_init_connection(ngx_connection_t *c);
int ngx_http_parse_request_line(ngx_http_request_t *r); int ngx_http_parse_request_line(ngx_http_request_t *r);
int ngx_http_parse_complex_uri(ngx_http_request_t *r); int ngx_http_parse_complex_uri(ngx_http_request_t *r);
int ngx_http_parse_header_line(ngx_http_request_t *r, ngx_hunk_t *h); int ngx_http_parse_header_line(ngx_http_request_t *r, ngx_buf_t *b);
int ngx_http_find_server_conf(ngx_http_request_t *r); int ngx_http_find_server_conf(ngx_http_request_t *r);
void ngx_http_handler(ngx_http_request_t *r); void ngx_http_handler(ngx_http_request_t *r);

2
src/http/ngx_http_cache.h
View File

@ -76,7 +76,7 @@ typedef struct {
uint32_t crc; uint32_t crc;
u_char md5[16]; u_char md5[16];
ngx_path_t *path; ngx_path_t *path;
ngx_hunk_t *buf; ngx_buf_t *buf;
time_t expires; time_t expires;
time_t last_modified; time_t last_modified;
time_t date; time_t date;

2
src/http/ngx_http_copy_filter.c
View File

@ -80,7 +80,7 @@ ngx_int_t ngx_http_copy_filter(ngx_http_request_t *r, ngx_chain_t *in)
ctx->pool = r->pool; ctx->pool = r->pool;
ctx->bufs = conf->bufs; ctx->bufs = conf->bufs;
ctx->tag = (ngx_hunk_tag_t) &ngx_http_copy_filter_module; ctx->tag = (ngx_buf_tag_t) &ngx_http_copy_filter_module;
ctx->output_filter = (ngx_output_chain_filter_pt) ngx_http_next_filter; ctx->output_filter = (ngx_output_chain_filter_pt) ngx_http_next_filter;
ctx->filter_ctx = r; ctx->filter_ctx = r;

82
src/http/ngx_http_header_filter.c
View File

@ -95,7 +95,7 @@ static int ngx_http_header_filter(ngx_http_request_t *r)
u_char *p; u_char *p;
size_t len; size_t len;
ngx_uint_t status, i; ngx_uint_t status, i;
ngx_hunk_t *h; ngx_buf_t *b;
ngx_chain_t *ln; ngx_chain_t *ln;
ngx_table_elt_t *header; ngx_table_elt_t *header;
@ -215,39 +215,39 @@ static int ngx_http_header_filter(ngx_http_request_t *r)
len += header[i].key.len + 2 + header[i].value.len + 2; len += header[i].key.len + 2 + header[i].value.len + 2;
} }
if (!(h = ngx_create_temp_hunk(r->pool, len))) { if (!(b = ngx_create_temp_buf(r->pool, len))) {
return NGX_ERROR; return NGX_ERROR;
} }
/* "HTTP/1.x " */ /* "HTTP/1.x " */
h->last = ngx_cpymem(h->last, "HTTP/1.1 ", sizeof("HTTP/1.x ") - 1); b->last = ngx_cpymem(b->last, "HTTP/1.1 ", sizeof("HTTP/1.x ") - 1);
/* status line */ /* status line */
if (r->headers_out.status_line.len) { if (r->headers_out.status_line.len) {
h->last = ngx_cpymem(h->last, r->headers_out.status_line.data, b->last = ngx_cpymem(b->last, r->headers_out.status_line.data,
r->headers_out.status_line.len); r->headers_out.status_line.len);
} else { } else {
h->last = ngx_cpymem(h->last, http_codes[status].data, b->last = ngx_cpymem(b->last, http_codes[status].data,
http_codes[status].len); http_codes[status].len);
} }
*(h->last++) = CR; *(h->last++) = LF; *(b->last++) = CR; *(b->last++) = LF;
if (!(r->headers_out.server && r->headers_out.server->key.len)) { if (!(r->headers_out.server && r->headers_out.server->key.len)) {
h->last = ngx_cpymem(h->last, server_string, sizeof(server_string) - 1); b->last = ngx_cpymem(b->last, server_string, sizeof(server_string) - 1);
} }
if (!(r->headers_out.date && r->headers_out.date->key.len)) { if (!(r->headers_out.date && r->headers_out.date->key.len)) {
h->last = ngx_cpymem(h->last, "Date: ", sizeof("Date: ") - 1); b->last = ngx_cpymem(b->last, "Date: ", sizeof("Date: ") - 1);
h->last = ngx_cpymem(h->last, ngx_cached_http_time.data, b->last = ngx_cpymem(b->last, ngx_cached_http_time.data,
ngx_cached_http_time.len); ngx_cached_http_time.len);
*(h->last++) = CR; *(h->last++) = LF; *(b->last++) = CR; *(b->last++) = LF;
} }
if (r->headers_out.content_length == NULL) { if (r->headers_out.content_length == NULL) {
if (r->headers_out.content_length_n >= 0) { if (r->headers_out.content_length_n >= 0) {
h->last += ngx_snprintf((char *) h->last, b->last += ngx_snprintf((char *) b->last,
sizeof("Content-Length: ") + NGX_OFF_T_LEN + 2, sizeof("Content-Length: ") + NGX_OFF_T_LEN + 2,
"Content-Length: " OFF_T_FMT CRLF, "Content-Length: " OFF_T_FMT CRLF,
r->headers_out.content_length_n); r->headers_out.content_length_n);
@ -255,69 +255,69 @@ static int ngx_http_header_filter(ngx_http_request_t *r)
} }
if (r->headers_out.content_type && r->headers_out.content_type->value.len) { if (r->headers_out.content_type && r->headers_out.content_type->value.len) {
h->last = ngx_cpymem(h->last, "Content-Type: ", b->last = ngx_cpymem(b->last, "Content-Type: ",
sizeof("Content-Type: ") - 1); sizeof("Content-Type: ") - 1);
p = h->last; p = b->last;
h->last = ngx_cpymem(h->last, r->headers_out.content_type->value.data, b->last = ngx_cpymem(b->last, r->headers_out.content_type->value.data,
r->headers_out.content_type->value.len); r->headers_out.content_type->value.len);
if (r->headers_out.charset.len) { if (r->headers_out.charset.len) {
h->last = ngx_cpymem(h->last, "; charset=", b->last = ngx_cpymem(b->last, "; charset=",
sizeof("; charset=") - 1); sizeof("; charset=") - 1);
h->last = ngx_cpymem(h->last, r->headers_out.charset.data, b->last = ngx_cpymem(b->last, r->headers_out.charset.data,
r->headers_out.charset.len); r->headers_out.charset.len);
r->headers_out.content_type->value.len = h->last - p; r->headers_out.content_type->value.len = b->last - p;
r->headers_out.content_type->value.data = p; r->headers_out.content_type->value.data = p;
} }
*(h->last++) = CR; *(h->last++) = LF; *(b->last++) = CR; *(b->last++) = LF;
} }
if (r->headers_out.location if (r->headers_out.location
&& r->headers_out.location->value.len && r->headers_out.location->value.len
&& r->headers_out.location->value.data[0] == '/') && r->headers_out.location->value.data[0] == '/')
{ {
p = h->last + sizeof("Location: ") - 1; p = b->last + sizeof("Location: ") - 1;
h->last = ngx_cpymem(h->last, "Location: http://", b->last = ngx_cpymem(b->last, "Location: http://",
sizeof("Location: http://") - 1); sizeof("Location: http://") - 1);
h->last = ngx_cpymem(h->last, r->server_name->data, b->last = ngx_cpymem(b->last, r->server_name->data,
r->server_name->len); r->server_name->len);
if (r->port != 80) { if (r->port != 80) {
h->last = ngx_cpymem(h->last, r->port_name->data, b->last = ngx_cpymem(b->last, r->port_name->data,
r->port_name->len); r->port_name->len);
} }
h->last = ngx_cpymem(h->last, r->headers_out.location->value.data, b->last = ngx_cpymem(b->last, r->headers_out.location->value.data,
r->headers_out.location->value.len); r->headers_out.location->value.len);
r->headers_out.location->value.len = h->last - p; r->headers_out.location->value.len = b->last - p;
r->headers_out.location->value.data = p; r->headers_out.location->value.data = p;
*(h->last++) = CR; *(h->last++) = LF; *(b->last++) = CR; *(b->last++) = LF;
} }
if (!(r->headers_out.last_modified && r->headers_out.last_modified->key.len) if (!(r->headers_out.last_modified && r->headers_out.last_modified->key.len)
&& r->headers_out.last_modified_time != -1) && r->headers_out.last_modified_time != -1)
{ {
h->last = ngx_cpymem(h->last, "Last-Modified: ", b->last = ngx_cpymem(b->last, "Last-Modified: ",
sizeof("Last-Modified: ") - 1); sizeof("Last-Modified: ") - 1);
h->last += ngx_http_time(h->last, r->headers_out.last_modified_time); b->last += ngx_http_time(b->last, r->headers_out.last_modified_time);
*(h->last++) = CR; *(h->last++) = LF; *(b->last++) = CR; *(b->last++) = LF;
} }
if (r->chunked) { if (r->chunked) {
h->last = ngx_cpymem(h->last, "Transfer-Encoding: chunked" CRLF, b->last = ngx_cpymem(b->last, "Transfer-Encoding: chunked" CRLF,
sizeof("Transfer-Encoding: chunked" CRLF) - 1); sizeof("Transfer-Encoding: chunked" CRLF) - 1);
} }
if (r->keepalive) { if (r->keepalive) {
h->last = ngx_cpymem(h->last, "Connection: keep-alive" CRLF, b->last = ngx_cpymem(b->last, "Connection: keep-alive" CRLF,
sizeof("Connection: keep-alive" CRLF) - 1); sizeof("Connection: keep-alive" CRLF) - 1);
} else { } else {
h->last = ngx_cpymem(h->last, "Connection: close" CRLF, b->last = ngx_cpymem(b->last, "Connection: close" CRLF,
sizeof("Connection: close" CRLF) - 1); sizeof("Connection: close" CRLF) - 1);
} }
@ -326,33 +326,33 @@ static int ngx_http_header_filter(ngx_http_request_t *r)
continue; continue;
} }
h->last = ngx_cpymem(h->last, header[i].key.data, header[i].key.len); b->last = ngx_cpymem(b->last, header[i].key.data, header[i].key.len);
*(h->last++) = ':' ; *(h->last++) = ' ' ; *(b->last++) = ':' ; *(b->last++) = ' ' ;
h->last = ngx_cpymem(h->last, header[i].value.data, b->last = ngx_cpymem(b->last, header[i].value.data,
header[i].value.len); header[i].value.len);
*(h->last++) = CR; *(h->last++) = LF; *(b->last++) = CR; *(b->last++) = LF;
} }
#if (NGX_DEBUG) #if (NGX_DEBUG)
*(h->last) = '\0'; *(b->last) = '\0';
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "%s\n", h->pos); ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "%s\n", b->pos);
#endif #endif
/* the end of HTTP header */ /* the end of HTTP header */
*(h->last++) = CR; *(h->last++) = LF; *(b->last++) = CR; *(b->last++) = LF;
r->header_size = h->last - h->pos; r->header_size = b->last - b->pos;
if (r->header_only) { if (r->header_only) {
h->type |= NGX_HUNK_LAST; b->last_buf = 1;
} }
if (!(ln = ngx_alloc_chain_link(r->pool))) { if (!(ln = ngx_alloc_chain_link(r->pool))) {
return NGX_ERROR; return NGX_ERROR;
} }
ln->hunk = h; ln->buf = b;
ln->next = NULL; ln->next = NULL;
return ngx_http_write_filter(r, ln); return ngx_http_write_filter(r, ln);

8
src/http/ngx_http_parse.c
View File

@ -438,7 +438,7 @@ ngx_int_t ngx_http_parse_request_line(ngx_http_request_t *r)
} }
ngx_int_t ngx_http_parse_header_line(ngx_http_request_t *r, ngx_hunk_t *h) ngx_int_t ngx_http_parse_header_line(ngx_http_request_t *r, ngx_buf_t *b)
{ {
u_char c, ch, *p; u_char c, ch, *p;
enum { enum {
@ -455,9 +455,9 @@ ngx_int_t ngx_http_parse_header_line(ngx_http_request_t *r, ngx_hunk_t *h)
} state; } state;
state = r->state; state = r->state;
p = h->pos; p = b->pos;
while (p < h->last && state < sw_done) { while (p < b->last && state < sw_done) {
ch = *p++; ch = *p++;
switch (state) { switch (state) {
@ -623,7 +623,7 @@ ngx_int_t ngx_http_parse_header_line(ngx_http_request_t *r, ngx_hunk_t *h)
} }
} }
h->pos = p; b->pos = p;
if (state == sw_done) { if (state == sw_done) {
r->state = sw_start; r->state = sw_start;

31
src/http/ngx_http_request.c
View File

@ -236,8 +236,8 @@ static void ngx_http_init_request(ngx_event_t *rev)
} }
if (c->buffer == NULL) { if (c->buffer == NULL) {
c->buffer = ngx_create_temp_hunk(c->pool, c->buffer = ngx_create_temp_buf(c->pool,
cscf->client_header_buffer_size); cscf->client_header_buffer_size);
if (c->buffer == NULL) { if (c->buffer == NULL) {
ngx_http_close_connection(c); ngx_http_close_connection(c);
return; return;
@ -1233,7 +1233,7 @@ static int ngx_http_read_discarded_body(ngx_http_request_t *r)
static void ngx_http_set_keepalive(ngx_http_request_t *r) static void ngx_http_set_keepalive(ngx_http_request_t *r)
{ {
int len; int len;
ngx_hunk_t *h; ngx_buf_t *b;
ngx_event_t *rev, *wev; ngx_event_t *rev, *wev;
ngx_connection_t *c; ngx_connection_t *c;
ngx_http_log_ctx_t *ctx; ngx_http_log_ctx_t *ctx;
@ -1257,12 +1257,12 @@ static void ngx_http_set_keepalive(ngx_http_request_t *r)
return; return;
} }
h = c->buffer; b = c->buffer;
wev = c->write; wev = c->write;
wev->event_handler = ngx_http_empty_handler; wev->event_handler = ngx_http_empty_handler;
if (h->pos < h->last) { if (b->pos < b->last) {
/* /*
* The pipelined request. * The pipelined request.
@ -1277,10 +1277,10 @@ static void ngx_http_set_keepalive(ngx_http_request_t *r)
cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module); cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
if (!cscf->large_client_header) { if (!cscf->large_client_header) {
len = h->last - h->pos; len = b->last - b->pos;
ngx_memcpy(h->start, h->pos, len); ngx_memcpy(b->start, b->pos, len);
h->pos = h->start; b->pos = b->start;
h->last = h->start + len; b->last = b->start + len;
} }
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "pipelined request"); ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "pipelined request");
@ -1293,7 +1293,7 @@ static void ngx_http_set_keepalive(ngx_http_request_t *r)
c->pipeline = 0; c->pipeline = 0;
h->pos = h->last = h->start; b->pos = b->last = b->start;
rev->event_handler = ngx_http_keepalive_handler; rev->event_handler = ngx_http_keepalive_handler;
if (wev->active) { if (wev->active) {
@ -1523,12 +1523,15 @@ void ngx_http_empty_handler(ngx_event_t *wev)
int ngx_http_send_last(ngx_http_request_t *r) int ngx_http_send_last(ngx_http_request_t *r)
{ {
ngx_hunk_t *h; ngx_buf_t *b;
ngx_chain_t out; ngx_chain_t out;
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR); if (!(b = ngx_calloc_buf(r->pool))) {
h->type = NGX_HUNK_LAST; return NGX_ERROR;
out.hunk = h; }
b->last_buf = 1;
out.buf = b;
out.next = NULL; out.next = NULL;
return ngx_http_output_filter(r, &out); return ngx_http_output_filter(r, &out);

4
src/http/ngx_http_request.h
View File

@ -176,7 +176,7 @@ typedef struct {
typedef struct { typedef struct {
ngx_temp_file_t *temp_file; ngx_temp_file_t *temp_file;
ngx_chain_t *bufs; ngx_chain_t *bufs;
ngx_hunk_t *buf; ngx_buf_t *buf;
size_t rest; size_t rest;
void (*handler) (void *data); void (*handler) (void *data);
void *data; void *data;
@ -216,7 +216,7 @@ struct ngx_http_request_s {
ngx_file_t file; ngx_file_t file;
ngx_pool_t *pool; ngx_pool_t *pool;
ngx_hunk_t *header_in; ngx_buf_t *header_in;
ngx_http_headers_in_t headers_in; ngx_http_headers_in_t headers_in;
ngx_http_headers_out_t headers_out; ngx_http_headers_out_t headers_out;

35
src/http/ngx_http_request_body.c
View File

@ -12,7 +12,7 @@ static ngx_int_t ngx_http_do_read_client_request_body(ngx_http_request_t *r);
ngx_int_t ngx_http_read_client_request_body(ngx_http_request_t *r) ngx_int_t ngx_http_read_client_request_body(ngx_http_request_t *r)
{ {
ssize_t size; ssize_t size;
ngx_hunk_t *h; ngx_buf_t *b;
ngx_chain_t *cl; ngx_chain_t *cl;
ngx_http_core_loc_conf_t *clcf; ngx_http_core_loc_conf_t *clcf;
@ -22,14 +22,14 @@ ngx_int_t ngx_http_read_client_request_body(ngx_http_request_t *r)
/* there is the pre-read part of the request body */ /* there is the pre-read part of the request body */
ngx_test_null(h, ngx_calloc_hunk(r->pool), ngx_test_null(b, ngx_calloc_buf(r->pool),
NGX_HTTP_INTERNAL_SERVER_ERROR); NGX_HTTP_INTERNAL_SERVER_ERROR);
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_TEMP; b->temporary = 1;
h->start = h->pos = r->header_in->pos; b->start = b->pos = r->header_in->pos;
h->end = h->last = r->header_in->last; b->end = b->last = r->header_in->last;
ngx_alloc_link_and_set_hunk(r->request_body->bufs, h, r->pool, ngx_alloc_link_and_set_buf(r->request_body->bufs, b, r->pool,
NGX_HTTP_INTERNAL_SERVER_ERROR); NGX_HTTP_INTERNAL_SERVER_ERROR);
if (size >= r->headers_in.content_length_n) { if (size >= r->headers_in.content_length_n) {
@ -61,11 +61,11 @@ ngx_int_t ngx_http_read_client_request_body(ngx_http_request_t *r)
size = clcf->client_body_buffer_size; size = clcf->client_body_buffer_size;
} }
ngx_test_null(r->request_body->buf, ngx_create_temp_hunk(r->pool, size), ngx_test_null(r->request_body->buf, ngx_create_temp_buf(r->pool, size),
NGX_HTTP_INTERNAL_SERVER_ERROR); NGX_HTTP_INTERNAL_SERVER_ERROR);
ngx_alloc_link_and_set_hunk(cl, r->request_body->buf, r->pool, ngx_alloc_link_and_set_buf(cl, r->request_body->buf, r->pool,
NGX_HTTP_INTERNAL_SERVER_ERROR); NGX_HTTP_INTERNAL_SERVER_ERROR);
if (r->request_body->bufs) { if (r->request_body->bufs) {
r->request_body->bufs->next = cl; r->request_body->bufs->next = cl;
@ -107,7 +107,7 @@ static ngx_int_t ngx_http_do_read_client_request_body(ngx_http_request_t *r)
{ {
size_t size; size_t size;
ssize_t n; ssize_t n;
ngx_hunk_t *h; ngx_buf_t *b;
ngx_connection_t *c; ngx_connection_t *c;
ngx_http_core_loc_conf_t *clcf; ngx_http_core_loc_conf_t *clcf;
@ -199,21 +199,20 @@ static ngx_int_t ngx_http_do_read_client_request_body(ngx_http_request_t *r)
return NGX_HTTP_INTERNAL_SERVER_ERROR; return NGX_HTTP_INTERNAL_SERVER_ERROR;
} }
h = ngx_calloc_hunk(r->pool); if (!(b = ngx_calloc_buf(r->pool))) {
if (h == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR; return NGX_HTTP_INTERNAL_SERVER_ERROR;
} }
h->type = NGX_HUNK_FILE; b->in_file = 1;
h->file_pos = 0; b->file_pos = 0;
h->file_last = r->request_body->temp_file->file.offset; b->file_last = r->request_body->temp_file->file.offset;
h->file = &r->request_body->temp_file->file; b->file = &r->request_body->temp_file->file;
if (r->request_body->bufs->next) { if (r->request_body->bufs->next) {
r->request_body->bufs->next->hunk = h; r->request_body->bufs->next->buf = b;
} else { } else {
r->request_body->bufs->hunk = h; r->request_body->bufs->buf = b;
} }
} }

34
src/http/ngx_http_special_response.c
View File

@ -181,7 +181,7 @@ int ngx_http_special_response_handler(ngx_http_request_t *r, int error)
{ {
ngx_int_t rc; ngx_int_t rc;
ngx_uint_t err, i; ngx_uint_t err, i;
ngx_hunk_t *h; ngx_buf_t *b;
ngx_chain_t *out, **ll, *cl; ngx_chain_t *out, **ll, *cl;
ngx_http_err_page_t *err_page; ngx_http_err_page_t *err_page;
ngx_http_core_loc_conf_t *clcf; ngx_http_core_loc_conf_t *clcf;
@ -293,25 +293,25 @@ int ngx_http_special_response_handler(ngx_http_request_t *r, int error)
out = NULL; out = NULL;
ll = NULL; ll = NULL;
if (!(h = ngx_calloc_hunk(r->pool))) { if (!(b = ngx_calloc_buf(r->pool))) {
return NGX_ERROR; return NGX_ERROR;
} }
h->type = NGX_HUNK_MEMORY|NGX_HUNK_IN_MEMORY; b->memory = 1;
h->pos = error_pages[err].data; b->pos = error_pages[err].data;
h->last = error_pages[err].data + error_pages[err].len; b->last = error_pages[err].data + error_pages[err].len;
ngx_alloc_link_and_set_hunk(cl, h, r->pool, NGX_ERROR); ngx_alloc_link_and_set_buf(cl, b, r->pool, NGX_ERROR);
ngx_chain_add_link(out, ll, cl); ngx_chain_add_link(out, ll, cl);
if (!(h = ngx_calloc_hunk(r->pool))) { if (!(b = ngx_calloc_buf(r->pool))) {
return NGX_ERROR; return NGX_ERROR;
} }
h->type = NGX_HUNK_MEMORY|NGX_HUNK_IN_MEMORY; b->memory = 1;
h->pos = error_tail; b->pos = error_tail;
h->last = error_tail + sizeof(error_tail) - 1; b->last = error_tail + sizeof(error_tail) - 1;
ngx_alloc_link_and_set_hunk(cl, h, r->pool, NGX_ERROR); ngx_alloc_link_and_set_buf(cl, b, r->pool, NGX_ERROR);
ngx_chain_add_link(out, ll, cl); ngx_chain_add_link(out, ll, cl);
if (clcf->msie_padding if (clcf->msie_padding
@ -319,18 +319,18 @@ int ngx_http_special_response_handler(ngx_http_request_t *r, int error)
&& error >= NGX_HTTP_BAD_REQUEST && error >= NGX_HTTP_BAD_REQUEST
&& error != NGX_HTTP_REQUEST_URI_TOO_LARGE) && error != NGX_HTTP_REQUEST_URI_TOO_LARGE)
{ {
if (!(h = ngx_calloc_hunk(r->pool))) { if (!(b = ngx_calloc_buf(r->pool))) {
return NGX_ERROR; return NGX_ERROR;
} }
h->type = NGX_HUNK_MEMORY|NGX_HUNK_IN_MEMORY; b->memory = 1;
h->pos = msie_stub; b->pos = msie_stub;
h->last = msie_stub + sizeof(msie_stub) - 1; b->last = msie_stub + sizeof(msie_stub) - 1;
ngx_alloc_link_and_set_hunk(cl, h, r->pool, NGX_ERROR); ngx_alloc_link_and_set_buf(cl, b, r->pool, NGX_ERROR);
ngx_chain_add_link(out, ll, cl); ngx_chain_add_link(out, ll, cl);
} }
h->type |= NGX_HUNK_LAST; b->last_buf = 1;
return ngx_http_output_filter(r, out); return ngx_http_output_filter(r, out);
} }

14
src/http/ngx_http_write_filter.c
View File

@ -92,13 +92,13 @@ int ngx_http_write_filter(ngx_http_request_t *r, ngx_chain_t *in)
for (cl = ctx->out; cl; cl = cl->next) { for (cl = ctx->out; cl; cl = cl->next) {
ll = &cl->next; ll = &cl->next;
size += ngx_hunk_size(cl->hunk); size += ngx_buf_size(cl->buf);
if (cl->hunk->type & (NGX_HUNK_FLUSH|NGX_HUNK_RECYCLED)) { if (cl->buf->flush || cl->buf->recycled) {
flush = size; flush = size;
} }
if (cl->hunk->type & NGX_HUNK_LAST) { if (cl->buf->last_buf) {
last = 1; last = 1;
} }
} }
@ -106,17 +106,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 (ln = in; ln; ln = ln->next) { for (ln = in; ln; ln = ln->next) {
ngx_alloc_link_and_set_hunk(cl, ln->hunk, r->pool, NGX_ERROR); ngx_alloc_link_and_set_buf(cl, ln->buf, r->pool, NGX_ERROR);
*ll = cl; *ll = cl;
ll = &cl->next; ll = &cl->next;
size += ngx_hunk_size(cl->hunk); size += ngx_buf_size(cl->buf);
if (cl->hunk->type & (NGX_HUNK_FLUSH|NGX_HUNK_RECYCLED)) { if (cl->buf->flush || cl->buf->recycled) {
flush = size; flush = size;
} }
if (cl->hunk->type & NGX_HUNK_LAST) { if (cl->buf->last_buf) {
last = 1; last = 1;
} }
} }

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

@ -28,15 +28,15 @@ ssize_t ngx_aio_read_chain(ngx_connection_t *c, ngx_chain_t *cl)
return total ? total : NGX_AGAIN; return total ? total : NGX_AGAIN;
} }
buf = cl->hunk->last; buf = cl->buf->last;
prev = cl->hunk->last; prev = cl->buf->last;
size = 0; size = 0;
/* coalesce the neighbouring hunks */ /* coalesce the neighbouring bufs */
while (cl && prev == cl->hunk->last) { while (cl && prev == cl->buf->last) {
size += cl->hunk->end - cl->hunk->last; size += cl->buf->end - cl->buf->last;
prev = cl->hunk->end; prev = cl->buf->end;
cl = cl->next; cl = cl->next;
} }

20
src/os/unix/ngx_aio_write_chain.c
View File

@ -19,7 +19,7 @@ ngx_chain_t *ngx_aio_write_chain(ngx_connection_t *c, ngx_chain_t *in)
while (cl) { while (cl) {
if (cl->hunk->last - cl->hunk->pos == 0) { if (cl->buf->last - cl->buf->pos == 0) {
cl = cl->next; cl = cl->next;
continue; continue;
} }
@ -30,15 +30,15 @@ ngx_chain_t *ngx_aio_write_chain(ngx_connection_t *c, ngx_chain_t *in)
return cl; return cl;
} }
buf = cl->hunk->pos; buf = cl->buf->pos;
prev = buf; prev = buf;
size = 0; size = 0;
/* coalesce the neighbouring hunks */ /* coalesce the neighbouring bufs */
while (cl && prev == cl->hunk->pos) { while (cl && prev == cl->buf->pos) {
size += cl->hunk->last - cl->hunk->pos; size += cl->buf->last - cl->buf->pos;
prev = cl->hunk->last; prev = cl->buf->last;
cl = cl->next; cl = cl->next;
} }
@ -60,14 +60,14 @@ ngx_chain_t *ngx_aio_write_chain(ngx_connection_t *c, ngx_chain_t *in)
for (cl = in; cl; cl = cl->next) { for (cl = in; cl; cl = cl->next) {
if (sent >= cl->hunk->last - cl->hunk->pos) { if (sent >= cl->buf->last - cl->buf->pos) {
sent -= cl->hunk->last - cl->hunk->pos; sent -= cl->buf->last - cl->buf->pos;
cl->hunk->pos = cl->hunk->last; cl->buf->pos = cl->buf->last;
continue; continue;
} }
cl->hunk->pos += sent; cl->buf->pos += sent;
break; break;
} }

18
src/os/unix/ngx_files.c
View File

@ -128,8 +128,8 @@ ssize_t ngx_write_chain_to_file(ngx_file_t *file, ngx_chain_t *cl,
/* use pwrite() if there's the only hunk in a chain */ /* use pwrite() if there's the only hunk in a chain */
if (cl->next == NULL) { if (cl->next == NULL) {
return ngx_write_file(file, cl->hunk->pos, return ngx_write_file(file, cl->buf->pos,
(size_t) (cl->hunk->last - cl->hunk->pos), (size_t) (cl->buf->last - cl->buf->pos),
offset); offset);
} }
@ -139,20 +139,20 @@ ssize_t ngx_write_chain_to_file(ngx_file_t *file, ngx_chain_t *cl,
ngx_init_array(io, pool, 10, sizeof(struct iovec), NGX_ERROR); ngx_init_array(io, pool, 10, sizeof(struct iovec), NGX_ERROR);
/* create the iovec and coalesce the neighbouring hunks */ /* create the iovec and coalesce the neighbouring bufs */
while (cl) { while (cl) {
if (prev == cl->hunk->pos) { if (prev == cl->buf->pos) {
iov->iov_len += cl->hunk->last - cl->hunk->pos; iov->iov_len += cl->buf->last - cl->buf->pos;
} else { } else {
ngx_test_null(iov, ngx_push_array(&io), NGX_ERROR); ngx_test_null(iov, ngx_push_array(&io), NGX_ERROR);
iov->iov_base = (void *) cl->hunk->pos; iov->iov_base = (void *) cl->buf->pos;
iov->iov_len = cl->hunk->last - cl->hunk->pos; iov->iov_len = cl->buf->last - cl->buf->pos;
} }
size += cl->hunk->last - cl->hunk->pos; size += cl->buf->last - cl->buf->pos;
prev = cl->hunk->last; prev = cl->buf->last;
cl = cl->next; cl = cl->next;
} }

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

@ -39,7 +39,7 @@ ngx_chain_t *ngx_freebsd_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in)
struct iovec *iov; struct iovec *iov;
struct sf_hdtr hdtr; struct sf_hdtr hdtr;
ngx_err_t err; ngx_err_t err;
ngx_hunk_t *file; ngx_buf_t *file;
ngx_array_t header, trailer; ngx_array_t header, trailer;
ngx_event_t *wev; ngx_event_t *wev;
ngx_chain_t *cl, *tail; ngx_chain_t *cl, *tail;
@ -74,87 +74,87 @@ 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 header iovec and coalesce the neighbouring hunks */ /* create the header iovec and coalesce the neighbouring bufs */
prev = NULL; prev = NULL;
iov = NULL; iov = NULL;
for (cl = in; cl && header.nelts < IOV_MAX; cl = cl->next) { for (cl = in; cl && header.nelts < IOV_MAX; cl = cl->next) {
if (ngx_hunk_special(cl->hunk)) { if (ngx_buf_special(cl->buf)) {
continue; continue;
} }
if (!ngx_hunk_in_memory_only(cl->hunk)) { if (!ngx_buf_in_memory_only(cl->buf)) {
break; break;
} }
if (prev == cl->hunk->pos) { if (prev == cl->buf->pos) {
iov->iov_len += cl->hunk->last - cl->hunk->pos; iov->iov_len += cl->buf->last - cl->buf->pos;
} 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 = (void *) cl->hunk->pos; iov->iov_base = (void *) cl->buf->pos;
iov->iov_len = cl->hunk->last - cl->hunk->pos; iov->iov_len = cl->buf->last - cl->buf->pos;
} }
prev = cl->hunk->last; prev = cl->buf->last;
hsize += cl->hunk->last - cl->hunk->pos; hsize += cl->buf->last - cl->buf->pos;
} }
/* get the file hunk */ /* get the file buf */
if (cl && (cl->hunk->type & NGX_HUNK_FILE)) { if (cl && cl->buf->in_file) {
file = cl->hunk; file = cl->buf;
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;
cl = cl->next; cl = cl->next;
/* coalesce the neighbouring file hunks */ /* coalesce the neighbouring file bufs */
while (cl && (cl->hunk->type & NGX_HUNK_FILE)) { while (cl && cl->buf->in_file) {
if (file->file->fd != cl->hunk->file->fd if (file->file->fd != cl->buf->file->fd
|| fprev != cl->hunk->file_pos) || fprev != cl->buf->file_pos)
{ {
break; break;
} }
fsize += (size_t) (cl->hunk->file_last - cl->hunk->file_pos); fsize += (size_t) (cl->buf->file_last - cl->buf->file_pos);
fprev = cl->hunk->file_last; fprev = cl->buf->file_last;
cl = cl->next; cl = cl->next;
} }
} }
if (file) { if (file) {
/* create the tailer iovec and coalesce the neighbouring hunks */ /* create the tailer iovec and coalesce the neighbouring bufs */
prev = NULL; prev = NULL;
iov = NULL; iov = NULL;
for ( /* void */; cl && trailer.nelts < IOV_MAX; cl = cl->next) { for ( /* void */; cl && trailer.nelts < IOV_MAX; cl = cl->next) {
if (ngx_hunk_special(cl->hunk)) { if (ngx_buf_special(cl->buf)) {
continue; continue;
} }
if (!ngx_hunk_in_memory_only(cl->hunk)) { if (!ngx_buf_in_memory_only(cl->buf)) {
break; break;
} }
if (prev == cl->hunk->pos) { if (prev == cl->buf->pos) {
iov->iov_len += cl->hunk->last - cl->hunk->pos; iov->iov_len += cl->buf->last - cl->buf->pos;
} else { } else {
ngx_test_null(iov, ngx_push_array(&trailer), ngx_test_null(iov, ngx_push_array(&trailer),
NGX_CHAIN_ERROR); NGX_CHAIN_ERROR);
iov->iov_base = (void *) cl->hunk->pos; iov->iov_base = (void *) cl->buf->pos;
iov->iov_len = cl->hunk->last - cl->hunk->pos; iov->iov_len = cl->buf->last - cl->buf->pos;
} }
prev = cl->hunk->last; prev = cl->buf->last;
} }
} }
/* /*
* the tail is the rest of the chain that exceeded * the tail is the rest of the chain that exceedes
* a single sendfile() capability * a single sendfile() capability
*/ */
@ -262,7 +262,7 @@ ngx_chain_t *ngx_freebsd_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in)
for (cl = in; cl; cl = cl->next) { for (cl = in; cl; cl = cl->next) {
if (ngx_hunk_special(cl->hunk)) { if (ngx_buf_special(cl->buf)) {
continue; continue;
} }
@ -270,28 +270,28 @@ ngx_chain_t *ngx_freebsd_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in)
break; break;
} }
size = ngx_hunk_size(cl->hunk); size = ngx_buf_size(cl->buf);
if (sent >= size) { if (sent >= size) {
sent -= size; sent -= size;
if (cl->hunk->type & NGX_HUNK_IN_MEMORY) { if (ngx_buf_in_memory(cl->buf)) {
cl->hunk->pos = cl->hunk->last; cl->buf->pos = cl->buf->last;
} }
if (cl->hunk->type & NGX_HUNK_FILE) { if (cl->buf->in_file) {
cl->hunk->file_pos = cl->hunk->file_last; cl->buf->file_pos = cl->buf->file_last;
} }
continue; continue;
} }
if (cl->hunk->type & NGX_HUNK_IN_MEMORY) { if (ngx_buf_in_memory(cl->buf)) {
cl->hunk->pos += sent; cl->buf->pos += sent;
} }
if (cl->hunk->type & NGX_HUNK_FILE) { if (cl->buf->in_file) {
cl->hunk->file_pos += sent; cl->buf->file_pos += sent;
} }
break; break;

6
src/os/unix/ngx_linux_sendfile_chain.c
View File

@ -28,7 +28,7 @@ ngx_chain_t *ngx_linux_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in)
ngx_int_t eintr; ngx_int_t eintr;
struct iovec *iov; struct iovec *iov;
ngx_err_t err; ngx_err_t err;
ngx_hunk_t *file; ngx_buf_t *file;
ngx_array_t header; ngx_array_t header;
ngx_event_t *wev; ngx_event_t *wev;
ngx_chain_t *cl, *tail; ngx_chain_t *cl, *tail;
@ -55,7 +55,7 @@ ngx_chain_t *ngx_linux_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in)
prev = NULL; prev = NULL;
iov = NULL; iov = NULL;
/* create the iovec and coalesce the neighbouring hunks */ /* create the iovec and coalesce the neighbouring bufs */
for (cl = in; cl && header.nelts < IOV_MAX; cl = cl->next) { for (cl = in; cl && header.nelts < IOV_MAX; cl = cl->next) {
if (ngx_hunk_special(cl->hunk)) { if (ngx_hunk_special(cl->hunk)) {
@ -131,7 +131,7 @@ ngx_chain_t *ngx_linux_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in)
} }
/* /*
* the tail is the rest of the chain that exceeded * the tail is the rest of the chain that exceedes
* a single sendfile() capability * a single sendfile() capability
*/ */

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

@ -10,10 +10,10 @@ ssize_t ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *chain)
{ {
u_char *prev; u_char *prev;
ssize_t n, size; ssize_t n, size;
struct iovec *iov;
ngx_err_t err; ngx_err_t err;
ngx_array_t io; ngx_array_t io;
ngx_event_t *rev; ngx_event_t *rev;
struct iovec *iov;
rev = c->read; rev = c->read;
@ -50,20 +50,20 @@ ssize_t ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *chain)
ngx_init_array(io, c->pool, 10, sizeof(struct iovec), NGX_ERROR); ngx_init_array(io, c->pool, 10, sizeof(struct iovec), NGX_ERROR);
/* coalesce the neighbouring hunks */ /* coalesce the neighbouring bufs */
while (chain) { while (chain) {
if (prev == chain->hunk->last) { if (prev == chain->buf->last) {
iov->iov_len += chain->hunk->end - chain->hunk->last; iov->iov_len += chain->buf->end - chain->buf->last;
} else { } else {
ngx_test_null(iov, ngx_push_array(&io), NGX_ERROR); ngx_test_null(iov, ngx_push_array(&io), NGX_ERROR);
iov->iov_base = (void *) chain->hunk->last; iov->iov_base = (void *) chain->buf->last;
iov->iov_len = chain->hunk->end - chain->hunk->last; iov->iov_len = chain->buf->end - chain->buf->last;
} }
size += chain->hunk->end - chain->hunk->last; size += chain->buf->end - chain->buf->last;
prev = chain->hunk->end; prev = chain->buf->end;
chain = chain->next; chain = chain->next;
} }
@ -137,10 +137,10 @@ ssize_t ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *chain)
{ {
u_char *prev; u_char *prev;
ssize_t n, size; ssize_t n, size;
struct iovec *iov;
ngx_err_t err; ngx_err_t err;
ngx_array_t io; ngx_array_t io;
ngx_event_t *rev; ngx_event_t *rev;
struct iovec *iov;
prev = NULL; prev = NULL;
iov = NULL; iov = NULL;
@ -148,20 +148,20 @@ ssize_t ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *chain)
ngx_init_array(io, c->pool, 10, sizeof(struct iovec), NGX_ERROR); ngx_init_array(io, c->pool, 10, sizeof(struct iovec), NGX_ERROR);
/* coalesce the neighbouring hunks */ /* coalesce the neighbouring bufs */
while (chain) { while (chain) {
if (prev == chain->hunk->last) { if (prev == chain->buf->last) {
iov->iov_len += chain->hunk->end - chain->hunk->last; iov->iov_len += chain->buf->end - chain->buf->last;
} else { } else {
ngx_test_null(iov, ngx_push_array(&io), NGX_ERROR); ngx_test_null(iov, ngx_push_array(&io), NGX_ERROR);
iov->iov_base = chain->hunk->last; iov->iov_base = chain->buf->last;
iov->iov_len = chain->hunk->end - chain->hunk->last; iov->iov_len = chain->buf->end - chain->buf->last;
} }
size += chain->hunk->end - chain->hunk->last; size += chain->buf->end - chain->buf->last;
prev = chain->hunk->end; prev = chain->buf->end;
chain = chain->next; chain = chain->next;
} }

6
src/os/unix/ngx_solaris_sendfilev_chain.c
View File

@ -40,7 +40,7 @@ ngx_chain_t *ngx_solaris_sendfilev_chain(ngx_connection_t *c, ngx_chain_t *in)
ngx_init_array(vec, c->pool, 10, sizeof(sendfilevec_t), ngx_init_array(vec, c->pool, 10, sizeof(sendfilevec_t),
NGX_CHAIN_ERROR); NGX_CHAIN_ERROR);
/* create the sendfilevec and coalesce the neighbouring hunks */ /* create the sendfilevec and coalesce the neighbouring bufs */
for (cl = in; cl && vec.nelts < IOV_MAX; cl = cl->next) { for (cl = in; cl && vec.nelts < IOV_MAX; cl = cl->next) {
if (ngx_hunk_special(cl->hunk)) { if (ngx_hunk_special(cl->hunk)) {
@ -83,8 +83,8 @@ ngx_chain_t *ngx_solaris_sendfilev_chain(ngx_connection_t *c, ngx_chain_t *in)
} }
/* /*
* the tail is the rest of the chain that exceeded a single * the tail is the rest of the chain that exceedes a single
* sendfilev() capability, IOV_MAX in Solaris is only 16 * sendfilev() capability, IOV_MAX in Solaris is limited by 16
*/ */
tail = cl; tail = cl;

24
src/os/unix/ngx_writev_chain.c
View File

@ -41,19 +41,19 @@ ngx_chain_t *ngx_writev_chain(ngx_connection_t *c, ngx_chain_t *in)
iov = NULL; iov = NULL;
eintr = 0; eintr = 0;
/* create the iovec and coalesce the neighbouring hunks */ /* create the iovec and coalesce the neighbouring bufs */
for (cl = in; cl; cl = cl->next) { for (cl = in; cl; cl = cl->next) {
if (prev == cl->hunk->pos) { if (prev == cl->buf->pos) {
iov->iov_len += cl->hunk->last - cl->hunk->pos; iov->iov_len += cl->buf->last - cl->buf->pos;
prev = cl->hunk->last; prev = cl->buf->last;
} else { } else {
ngx_test_null(iov, ngx_push_array(&io), NGX_CHAIN_ERROR); ngx_test_null(iov, ngx_push_array(&io), NGX_CHAIN_ERROR);
iov->iov_base = (void *) cl->hunk->pos; iov->iov_base = (void *) cl->buf->pos;
iov->iov_len = cl->hunk->last - cl->hunk->pos; iov->iov_len = cl->buf->last - cl->buf->pos;
prev = cl->hunk->last; prev = cl->buf->last;
} }
} }
@ -86,20 +86,20 @@ ngx_chain_t *ngx_writev_chain(ngx_connection_t *c, ngx_chain_t *in)
for (cl = in; cl && sent > 0; cl = cl->next) { for (cl = in; cl && sent > 0; cl = cl->next) {
size = cl->hunk->last - cl->hunk->pos; size = cl->buf->last - cl->buf->pos;
if (sent >= size) { if (sent >= size) {
sent -= size; sent -= size;
if (cl->hunk->type & NGX_HUNK_IN_MEMORY) { if (ngx_buf_in_memory(cl->buf)) {
cl->hunk->pos = cl->hunk->last; cl->buf->pos = cl->buf->last;
} }
continue; continue;
} }
if (cl->hunk->type & NGX_HUNK_IN_MEMORY) { if (ngx_buf_in_memory(cl->buf)) {
cl->hunk->pos += sent; cl->buf->pos += sent;
} }
break; break;

8
src/os/win32/ngx_files.c
View File

@ -139,15 +139,15 @@ ssize_t ngx_write_chain_to_file(ngx_file_t *file, ngx_chain_t *cl,
total = 0; total = 0;
while (cl) { while (cl) {
buf = cl->hunk->pos; buf = cl->buf->pos;
prev = buf; prev = buf;
size = 0; size = 0;
/* coalesce the neighbouring hunks */ /* coalesce the neighbouring hunks */
while (cl && prev == cl->hunk->pos) { while (cl && prev == cl->buf->pos) {
size += cl->hunk->last - cl->hunk->pos; size += cl->buf->last - cl->buf->pos;
prev = cl->hunk->last; prev = cl->buf->last;
cl = cl->next; cl = cl->next;
} }

14
src/os/win32/ngx_wsarecv_chain.c
View File

@ -23,20 +23,20 @@ ssize_t ngx_wsarecv_chain(ngx_connection_t *c, ngx_chain_t *chain)
ngx_init_array(io, c->pool, 10, sizeof(WSABUF), NGX_ERROR); ngx_init_array(io, c->pool, 10, sizeof(WSABUF), NGX_ERROR);
/* coalesce the neighbouring hunks */ /* coalesce the neighbouring bufs */
while (chain) { while (chain) {
if (prev == chain->hunk->last) { if (prev == chain->buf->last) {
wsabuf->len += chain->hunk->end - chain->hunk->last; wsabuf->len += chain->buf->end - chain->buf->last;
} else { } else {
ngx_test_null(wsabuf, ngx_push_array(&io), NGX_ERROR); ngx_test_null(wsabuf, ngx_push_array(&io), NGX_ERROR);
wsabuf->buf = (char *) chain->hunk->last; wsabuf->buf = (char *) chain->buf->last;
wsabuf->len = chain->hunk->end - chain->hunk->last; wsabuf->len = chain->buf->end - chain->buf->last;
} }
size += chain->hunk->end - chain->hunk->last; size += chain->buf->end - chain->buf->last;
prev = chain->hunk->end; prev = chain->buf->end;
chain = chain->next; chain = chain->next;
} }

44
src/os/win32/ngx_wsasend_chain.c
View File

@ -36,15 +36,15 @@ ngx_chain_t *ngx_wsasend_chain(ngx_connection_t *c, ngx_chain_t *in)
for (cl = in; cl; cl = cl->next) { for (cl = in; cl; cl = cl->next) {
if (prev == cl->hunk->pos) { if (prev == cl->buf->pos) {
wsabuf->len += cl->hunk->last - cl->hunk->pos; wsabuf->len += cl->buf->last - cl->buf->pos;
prev = cl->hunk->last; prev = cl->buf->last;
} else { } else {
ngx_test_null(wsabuf, ngx_push_array(&wsabufs), NGX_CHAIN_ERROR); ngx_test_null(wsabuf, ngx_push_array(&wsabufs), NGX_CHAIN_ERROR);
wsabuf->buf = (char *) cl->hunk->pos; wsabuf->buf = (char *) cl->buf->pos;
wsabuf->len = cl->hunk->last - cl->hunk->pos; wsabuf->len = cl->buf->last - cl->buf->pos;
prev = cl->hunk->last; prev = cl->buf->last;
} }
} }
@ -72,20 +72,20 @@ ngx_chain_t *ngx_wsasend_chain(ngx_connection_t *c, ngx_chain_t *in)
for (cl = in; cl && sent > 0; cl = cl->next) { for (cl = in; cl && sent > 0; cl = cl->next) {
size = cl->hunk->last - cl->hunk->pos; size = cl->buf->last - cl->buf->pos;
if (sent >= size) { if (sent >= size) {
sent -= size; sent -= size;
if (cl->hunk->type & NGX_HUNK_IN_MEMORY) { if (ngx_buf_in_memory(cl->buf)) {
cl->hunk->pos = cl->hunk->last; cl->buf->pos = cl->buf->last;
} }
continue; continue;
} }
if (cl->hunk->type & NGX_HUNK_IN_MEMORY) { if (ngx_buf_in_memory(cl->buf)) {
cl->hunk->pos += sent; cl->buf->pos += sent;
} }
break; break;
@ -136,16 +136,16 @@ ngx_chain_t *ngx_overlapped_wsasend_chain(ngx_connection_t *c, ngx_chain_t *in)
for (cl = in; cl; cl = cl->next) { for (cl = in; cl; cl = cl->next) {
if (prev == cl->hunk->pos) { if (prev == cl->buf->pos) {
wsabuf->len += cl->hunk->last - cl->hunk->pos; wsabuf->len += cl->buf->last - cl->buf->pos;
prev = cl->hunk->last; prev = cl->buf->last;
} else { } else {
ngx_test_null(wsabuf, ngx_push_array(&wsabufs), ngx_test_null(wsabuf, ngx_push_array(&wsabufs),
NGX_CHAIN_ERROR); NGX_CHAIN_ERROR);
wsabuf->buf = (char *) cl->hunk->pos; wsabuf->buf = (char *) cl->buf->pos;
wsabuf->len = cl->hunk->last - cl->hunk->pos; wsabuf->len = cl->buf->last - cl->buf->pos;
prev = cl->hunk->last; prev = cl->buf->last;
} }
} }
@ -213,20 +213,20 @@ ngx_chain_t *ngx_overlapped_wsasend_chain(ngx_connection_t *c, ngx_chain_t *in)
for (cl = in; cl && sent > 0; cl = cl->next) { for (cl = in; cl && sent > 0; cl = cl->next) {
size = cl->hunk->last - cl->hunk->pos; size = cl->buf->last - cl->buf->pos;
if (sent >= size) { if (sent >= size) {
sent -= size; sent -= size;
if (cl->hunk->type & NGX_HUNK_IN_MEMORY) { if (ngx_buf_in_memory(cl->buf)) {
cl->hunk->pos = cl->hunk->last; cl->buf->pos = cl->buf->last;
} }
continue; continue;
} }
if (cl->hunk->type & NGX_HUNK_IN_MEMORY) { if (ngx_buf_in_memory(cl->buf)) {
cl->hunk->pos += sent; cl->buf->pos += sent;
} }
break; break;