nginx-0.0.3-2004-05-28-19:49:23 import; rename ngx_hunk_t to ngx_buf_t

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

View File

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

View File

@ -11,7 +11,7 @@ CORE_DEPS="src/core/nginx.h \
src/core/ngx_alloc.h \
src/core/ngx_array.h \
src/core/ngx_table.h \
src/core/ngx_hunk.h \
src/core/ngx_buf.h \
src/core/ngx_string.h \
src/core/ngx_parse.h \
src/core/ngx_inet.h \
@ -29,7 +29,7 @@ CORE_SRCS="src/core/nginx.c \
src/core/ngx_log.c \
src/core/ngx_alloc.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_string.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;
}
}

View File

@ -1,61 +1,87 @@
#ifndef _NGX_HUNK_H_INCLUDED_
#define _NGX_HUNK_H_INCLUDED_
#ifndef _NGX_BUF_H_INCLUDED_
#define _NGX_BUF_H_INCLUDED_
#include <ngx_config.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
/* the hunk's content can be changed */
/* the buf's content can be changed */
#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
/* the hunk's content is mmap()ed and can not be changed */
#define NGX_HUNK_MMAP 0x0008
/* the buf's content is recycled */
#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_STORAGE (NGX_HUNK_IN_MEMORY \
|NGX_HUNK_TEMP|NGX_HUNK_MEMORY|NGX_HUNK_MMAP \
|NGX_HUNK_RECYCLED|NGX_HUNK_FILE)
/* hunk flags */
/* the buf flags */
/* in thread state flush means to write the hunk completely before return */
/* in event state flush means to start to write the hunk */
/* in thread state flush means to write the buf completely before return */
/* in event state flush means to start to write the buf */
#define NGX_HUNK_FLUSH 0x0100
/* last hunk */
/* the last buf */
#define NGX_HUNK_LAST 0x0200
#define NGX_HUNK_PREREAD 0x2000
#define NGX_HUNK_LAST_SHADOW 0x4000
#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 *last;
off_t file_pos;
off_t file_last;
int type;
u_char *start; /* start of hunk */
u_char *end; /* end of hunk */
ngx_hunk_tag_t tag;
u_char *start; /* start of buffer */
u_char *end; /* end of buffer */
ngx_buf_tag_t tag;
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;
};
@ -63,8 +89,8 @@ struct ngx_hunk_s {
typedef struct ngx_chain_s ngx_chain_t;
struct ngx_chain_s {
ngx_hunk_t *hunk;
ngx_chain_t *next;
ngx_buf_t *buf;
ngx_chain_t *next;
};
@ -77,7 +103,7 @@ typedef struct {
typedef int (*ngx_output_chain_filter_pt)(void *ctx, ngx_chain_t *out);
typedef struct {
ngx_hunk_t *hunk;
ngx_buf_t *buf;
ngx_chain_t *in;
ngx_chain_t *free;
ngx_chain_t *busy;
@ -87,9 +113,9 @@ typedef struct {
unsigned need_in_temp;
ngx_pool_t *pool;
ngx_int_t hunks;
ngx_int_t allocated;
ngx_bufs_t bufs;
ngx_hunk_tag_t tag;
ngx_buf_tag_t tag;
ngx_output_chain_filter_pt output_filter;
void *filter_ctx;
@ -107,6 +133,17 @@ typedef struct {
#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) \
((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) \
((h->type & NGX_HUNK_IN_MEMORY) ? (size_t) (h->last - h->pos): \
(size_t) (h->file_last - h->file_pos))
#define ngx_hunk_special(b) \
(b->type == (b->type & (NGX_HUNK_FLUSH|NGX_HUNK_LAST)))
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))
#define ngx_calloc_hunk(pool) ngx_pcalloc(pool, sizeof(ngx_hunk_t))
#endif
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_link_and_set_hunk(chain, h, pool, error) \
#define ngx_alloc_link_and_set_buf(chain, b, pool, error) \
do { \
ngx_test_null(chain, ngx_alloc_chain_link(pool), error); \
chain->hunk = h; \
chain->buf = b; \
chain->next = NULL; \
} 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);
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_ */

View File

@ -51,8 +51,8 @@ char *ngx_conf_parse(ngx_conf_t *cf, ngx_str_t *filename)
int m, rc, found, valid;
char *rv;
void *conf, **confp;
ngx_str_t *name;
ngx_fd_t fd;
ngx_str_t *name;
ngx_conf_file_t *prev;
ngx_command_t *cmd;
@ -73,18 +73,18 @@ char *ngx_conf_parse(ngx_conf_t *cf, ngx_str_t *filename)
}
prev = cf->conf_file;
ngx_test_null(cf->conf_file,
ngx_palloc(cf->pool, sizeof(ngx_conf_file_t)),
NGX_CONF_ERROR);
if (!(cf->conf_file = ngx_palloc(cf->pool, sizeof(ngx_conf_file_t)))) {
return NGX_CONF_ERROR;
}
if (ngx_fd_info(fd, &cf->conf_file->file.info) == -1) {
ngx_log_error(NGX_LOG_EMERG, cf->log, ngx_errno,
ngx_fd_info_n " %s failed", filename->data);
}
ngx_test_null(cf->conf_file->hunk,
ngx_create_temp_hunk(cf->pool, 1024),
NGX_CONF_ERROR);
if (!(cf->conf_file->buffer = ngx_create_temp_buf(cf->pool, 1024))) {
return NGX_CONF_ERROR;
}
cf->conf_file->file.fd = fd;
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 ( ;; ) {
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
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;
ssize_t n;
ngx_str_t *word;
ngx_hunk_t *h;
ngx_buf_t *b;
found = 0;
need_space = 0;
@ -324,8 +326,8 @@ static int ngx_conf_read_token(ngx_conf_t *cf)
quoted = s_quoted = d_quoted = 0;
cf->args->nelts = 0;
h = cf->conf_file->hunk;
start = h->pos;
b = cf->conf_file->buffer;
start = b->pos;
#if 0
ngx_log_debug(cf->log, "TOKEN START");
@ -333,31 +335,31 @@ ngx_log_debug(cf->log, "TOKEN START");
for ( ;; ) {
if (h->pos >= h->last) {
if (b->pos >= b->last) {
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;
}
if (h->pos - start) {
ngx_memcpy(h->start, start, (size_t) (h->pos - start));
if (b->pos - start) {
ngx_memcpy(b->start, start, b->pos - start);
}
n = ngx_read_file(&cf->conf_file->file,
h->start + (h->pos - start),
(size_t) (h->end - (h->start + (h->pos - start))),
b->start + (b->pos - start),
b->end - (b->start + (b->pos - start)),
cf->conf_file->file.offset);
if (n == NGX_ERROR) {
return NGX_ERROR;
}
h->pos = h->start + (h->pos - start);
start = h->start;
h->last = h->pos + n;
b->pos = b->start + (b->pos - start);
start = b->start;
b->last = b->pos + n;
}
ch = *h->pos++;
ch = *b->pos++;
#if 0
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;
}
start = h->pos - 1;
start = b->pos - 1;
switch (ch) {
@ -485,14 +487,16 @@ ngx_log_debug(cf->log, "%d:%d:%d:%d:%d '%c'" _
}
if (found) {
ngx_test_null(word, ngx_push_array(cf->args), NGX_ERROR);
ngx_test_null(word->data,
ngx_palloc(cf->pool,
(size_t) (h->pos - start + 1)),
NGX_ERROR);
if (!(word = ngx_push_array(cf->args))) {
return NGX_ERROR;
}
if (!(word->data = ngx_palloc(cf->pool, b->pos - start + 1))) {
return NGX_ERROR;
}
for (dst = word->data, src = start, len = 0;
src < h->pos - 1;
src < b->pos - 1;
len++)
{
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;
if (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)
{
ngx_conf_num_bounds_t *bounds = post;
ngx_int_t *np = data;
ngx_conf_num_bounds_t *bounds = post;
ngx_int_t *np = data;
if (bounds->high == -1) {
if (*np >= bounds->low) {

View File

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

View File

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

View File

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

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;
}
}

View File

@ -8,20 +8,20 @@
ngx_inline static int ngx_output_chain_need_to_copy(ngx_output_chain_ctx_t *ctx,
ngx_hunk_t *hunk);
static int ngx_output_chain_copy_hunk(ngx_hunk_t *dst, ngx_hunk_t *src,
u_int sendfile);
ngx_buf_t *buf);
static ngx_int_t ngx_output_chain_copy_buf(ngx_buf_t *dst, ngx_buf_t *src,
ngx_uint_t sendfile);
int ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in)
{
int rc, last;
size_t size, hsize;
size_t size, bsize;
ngx_chain_t *cl, *out, **last_out;
/*
* 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
*/
@ -32,7 +32,7 @@ int ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in)
}
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);
}
@ -55,11 +55,11 @@ int ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in)
while (ctx->in) {
/*
* cycle while there are the ctx->in hunks
* or there are the free output hunks to copy in
* cycle while there are the ctx->in bufs
* 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 */
@ -73,15 +73,15 @@ int ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in)
continue;
}
if (ctx->hunk == NULL) {
if (ctx->buf == NULL) {
/* get the free hunk */
/* get the free buf */
if (ctx->free) {
ctx->hunk = ctx->free->hunk;
ctx->buf = ctx->free->buf;
ctx->free = ctx->free->next;
} else if (out || ctx->hunks == ctx->bufs.num) {
} else if (out || ctx->allocated == ctx->bufs.num) {
break;
@ -89,44 +89,45 @@ int ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in)
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
*/
size = hsize;
size = bsize;
} else if (ctx->bufs.num == 1
&& (hsize < ctx->bufs.size
&& (bsize < ctx->bufs.size
+ (ctx->bufs.size >> 2)))
{
/*
* allocate a temp hunk that equals
* to the last hunk if the last hunk size is lesser
* than 1.25 of bufs.size and a temp hunk is single
* allocate a temp buf that equals
* to the last buf if the last buf size is lesser
* than 1.25 of bufs.size and a temp buf is single
*/
size = hsize;
size = bsize;
}
}
ngx_test_null(ctx->hunk,
ngx_create_temp_hunk(ctx->pool, size),
NGX_ERROR);
ctx->hunk->tag = ctx->tag;
ctx->hunk->type |= NGX_HUNK_RECYCLED;
ctx->hunks++;
if (!(ctx->buf = ngx_create_temp_buf(ctx->pool, size))) {
return NGX_ERROR;
}
ctx->buf->tag = ctx->tag;
ctx->buf->recycled = 1;
ctx->allocated++;
}
}
rc = ngx_output_chain_copy_hunk(ctx->hunk, ctx->in->hunk,
ctx->sendfile);
rc = ngx_output_chain_copy_buf(ctx->buf, ctx->in->buf,
ctx->sendfile);
if (rc == NGX_ERROR) {
return rc;
@ -139,16 +140,16 @@ int ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in)
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;
}
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->next;
ctx->hunk = NULL;
ctx->buf = NULL;
}
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_hunk_t *hunk)
ngx_buf_t *buf)
{
if (ngx_hunk_special(hunk)) {
if (ngx_buf_special(buf)) {
return 0;
}
if (!ctx->sendfile) {
if (!(hunk->type & NGX_HUNK_IN_MEMORY)) {
if (!ngx_buf_in_memory(buf)) {
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;
}
if (ctx->need_in_temp && (hunk->type & (NGX_HUNK_MEMORY|NGX_HUNK_MMAP))) {
if (ctx->need_in_temp && (buf->memory || buf->mmap)) {
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,
u_int sendfile)
static ngx_int_t ngx_output_chain_copy_buf(ngx_buf_t *dst, ngx_buf_t *src,
ngx_uint_t sendfile)
{
size_t size;
ssize_t n;
size = ngx_hunk_size(src);
size = ngx_buf_size(src);
if (size > (size_t) (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);
src->pos += size;
dst->last += size;
if (src->type & NGX_HUNK_FILE) {
if (src->in_file) {
src->file_pos += size;
}
if ((src->type & NGX_HUNK_LAST) && src->pos == src->last) {
dst->type |= NGX_HUNK_LAST;
if (src->last_buf && src->pos == src->last) {
dst->last_buf = 1;
}
} else {
@ -246,11 +246,11 @@ static int ngx_output_chain_copy_hunk(ngx_hunk_t *dst, ngx_hunk_t *src,
dst->last += n;
if (!sendfile) {
dst->type &= ~NGX_HUNK_FILE;
dst->in_file = 0;
}
if ((src->type & NGX_HUNK_LAST) && src->file_pos == src->file_last) {
dst->type |= NGX_HUNK_LAST;
if (src->last_buf && src->file_pos == src->file_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;
@ -266,7 +266,7 @@ int ngx_chain_writer(void *data, ngx_chain_t *in)
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->next;
}

View File

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

View File

@ -5,19 +5,19 @@
#include <ngx_event_pipe.h>
static int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p);
static int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p);
static ngx_int_t ngx_event_pipe_read_upstream(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);
ngx_inline static void ngx_event_pipe_remove_shadow_links(ngx_hunk_t *hunk);
ngx_inline static void ngx_event_pipe_free_shadow_raw_hunk(ngx_chain_t **free,
ngx_hunk_t *h);
ngx_inline static void ngx_event_pipe_add_free_hunk(ngx_chain_t **chain,
ngx_chain_t *cl);
static int ngx_event_pipe_drain_chains(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_buf_t *buf);
ngx_inline static void ngx_event_pipe_free_shadow_raw_buf(ngx_chain_t **free,
ngx_buf_t *buf);
ngx_inline static void ngx_event_pipe_add_free_buf(ngx_chain_t **chain,
ngx_chain_t *cl);
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;
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;
ngx_hunk_t *h;
ngx_buf_t *b;
ngx_chain_t *chain, *cl, *tl;
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;
}
if (p->preread_hunks == NULL && !p->upstream->read->ready) {
if (p->preread_bufs == NULL && !p->upstream->read->ready) {
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;
p->preread_hunks = NULL;
chain = p->preread_bufs;
p->preread_bufs = NULL;
n = p->preread_size;
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.
* 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().
*/
@ -142,34 +142,36 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
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) {
p->free_raw_hunks = p->free_raw_hunks->next;
p->free_raw_bufs = p->free_raw_bufs->next;
chain->next = NULL;
} 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),
NGX_ABORT);
p->hunks++;
if (!(b = ngx_create_temp_buf(p->pool, p->bufs.size))) {
return NGX_ABORT;
}
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;
} else if (!p->cachable && p->downstream->write->ready) {
/*
* if the hunks are not needed to be saved in a cache and
* a downstream is ready then write the hunks to a downstream
* if the bufs are not needed to be saved in a cache and
* a downstream is ready then write the bufs to a downstream
*/
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
*/
@ -210,17 +212,17 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
return rc;
}
chain = p->free_raw_hunks;
chain = p->free_raw_bufs;
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;
} else {
p->free_raw_hunks = NULL;
p->free_raw_bufs = NULL;
}
} 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,
"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,
"pipe recv chain: %d", n);
if (p->free_raw_hunks) {
chain->next = p->free_raw_hunks;
if (p->free_raw_bufs) {
chain->next = p->free_raw_bufs;
}
p->free_raw_hunks = chain;
p->free_raw_bufs = chain;
if (n == NGX_ERROR) {
p->upstream_error = 1;
@ -245,7 +247,7 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
if (n == NGX_AGAIN) {
if (p->single_buf) {
ngx_event_pipe_remove_shadow_links(chain->hunk);
ngx_event_pipe_remove_shadow_links(chain->buf);
}
break;
@ -264,16 +266,16 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
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) {
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;
}
@ -281,56 +283,56 @@ int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
cl = cl->next;
} else {
cl->hunk->last += n;
cl->buf->last += n;
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");
}
for (cl = p->in; cl; cl = cl->next) {
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0,
"pipe buf in " PTR_FMT ", pos " PTR_FMT ", size: %d",
cl->hunk->start, cl->hunk->pos,
cl->hunk->last - cl->hunk->pos);
cl->buf->start, cl->buf->pos,
cl->buf->last - cl->buf->pos);
}
for (cl = p->busy; cl; cl = cl->next) {
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0,
"pipe buf busy " PTR_FMT ", pos " PTR_FMT ", size: %d",
cl->hunk->start, cl->hunk->pos,
cl->hunk->last - cl->hunk->pos);
cl->buf->start, cl->buf->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,
"pipe buf free " PTR_FMT ", last " PTR_FMT ", size: %d",
cl->hunk->start, cl->hunk->last,
cl->hunk->end - cl->hunk->last);
cl->buf->start, cl->buf->last,
cl->buf->end - cl->buf->last);
}
#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;
}
p->free_raw_hunks = p->free_raw_hunks->next;
p->free_raw_bufs = p->free_raw_bufs->next;
if (p->free_bufs) {
for (cl = p->free_raw_hunks; cl; cl = cl->next) {
ngx_pfree(p->pool, cl->hunk->start);
for (cl = p->free_raw_bufs; cl; cl = cl->next) {
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;
ngx_uint_t flush;
ngx_hunk_t *h;
ngx_buf_t *b;
ngx_chain_t *out, **ll, *cl, *tl;
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,
"pipe write downstream done");
/* TODO: free unused hunks */
/* TODO: free unused bufs */
p->downstream_done = 1;
break;
@ -401,12 +403,12 @@ int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p)
break;
}
/* bsize is the size of the busy hunks */
/* bsize is the size of the busy bufs */
bsize = 0;
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,
@ -420,19 +422,19 @@ int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p)
if (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;
break;
}
p->out = p->out->next;
ngx_event_pipe_free_shadow_raw_hunk(&p->free_raw_hunks,
cl->hunk);
ngx_event_pipe_free_shadow_raw_buf(&p->free_raw_bufs,
cl->buf);
} else if (!p->cachable && 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;
break;
}
@ -443,7 +445,7 @@ int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p)
break;
}
bsize += ngx_hunk_size(cl->hunk);
bsize += ngx_buf_size(cl->buf);
cl->next = NULL;
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) {
if (cl->hunk->type & NGX_HUNK_TEMP_FILE) {
if (cl->buf->temp_file) {
if (p->cachable || !p->cyclic_temp_file) {
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;
}
}
/* 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) {
h = cl->hunk->shadow;
h->pos = h->last = h->start;
h->shadow = NULL;
ngx_alloc_link_and_set_hunk(tl, h, p->pool, NGX_ABORT);
ngx_event_pipe_add_free_hunk(&p->free_raw_hunks, tl);
if (cl->buf->last_shadow) {
b = cl->buf->shadow;
b->pos = b->last = b->start;
b->shadow = NULL;
ngx_alloc_link_and_set_buf(tl, b, p->pool, NGX_ABORT);
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
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
cl->buf->shadow = NULL;
}
}
@ -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;
ngx_hunk_t *h;
size_t size, bsize;
ngx_buf_t *b;
ngx_chain_t *cl, *tl, *next, *out, **ll, **last_free, fl;
if (p->hunk_to_file) {
fl.hunk = p->hunk_to_file;
if (p->buf_to_file) {
fl.buf = p->buf_to_file;
fl.next = p->in;
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);
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,
"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)
|| (p->temp_file->offset + size + hsize > p->max_temp_file_size))
if ((size + bsize > p->temp_file_write_size)
|| (p->temp_file->offset + size + bsize > p->max_temp_file_size))
{
break;
}
size += hsize;
size += bsize;
ll = &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;
}
for (last_free = &p->free_raw_hunks;
for (last_free = &p->free_raw_bufs;
*last_free != NULL;
last_free = &(*last_free)->next)
{
/* void */
}
if (p->hunk_to_file) {
p->temp_file->offset = p->hunk_to_file->last - p->hunk_to_file->pos;
p->hunk_to_file = NULL;
if (p->buf_to_file) {
p->temp_file->offset = p->buf_to_file->last - p->buf_to_file->pos;
p->buf_to_file = NULL;
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;
cl->next = NULL;
h = cl->hunk;
h->file = &p->temp_file->file;
h->file_pos = p->temp_file->offset;
p->temp_file->offset += h->last - h->pos;
h->file_last = p->temp_file->offset;
b = cl->buf;
b->file = &p->temp_file->file;
b->file_pos = p->temp_file->offset;
p->temp_file->offset += b->last - b->pos;
b->file_last = p->temp_file->offset;
h->type |= NGX_HUNK_FILE|NGX_HUNK_TEMP_FILE;
#if 0
if (p->cachable) {
h->type |= NGX_HUNK_FILE;
} else {
h->type |= NGX_HUNK_FILE|NGX_HUNK_TEMP_FILE;
}
#endif
b->in_file = 1;
b->temp_file = 1;
ngx_chain_add_link(p->out, p->last_out, cl);
if (h->type & NGX_HUNK_LAST_SHADOW) {
h->shadow->last = h->shadow->pos = h->shadow->start;
ngx_alloc_link_and_set_hunk(tl, h->shadow, p->pool, NGX_ABORT);
if (b->last_shadow) {
b->shadow->last = b->shadow->pos = b->shadow->start;
ngx_alloc_link_and_set_buf(tl, b->shadow, p->pool, NGX_ABORT);
*last_free = tl;
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 */
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;
if (hunk->pos == hunk->last) {
if (buf->pos == buf->last) {
return NGX_OK;
}
if (p->free) {
h = p->free->hunk;
b = p->free->buf;
p->free = p->free->next;
} 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));
h->shadow = hunk;
h->tag = p->tag;
h->type |= NGX_HUNK_LAST_SHADOW|NGX_HUNK_RECYCLED;
hunk->shadow = h;
ngx_memcpy(b, buf, sizeof(ngx_buf_t));
b->shadow = buf;
b->tag = p->tag;
b->last_shadow = 1;
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);
@ -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;
}
h = hunk->shadow;
b = buf->shadow;
while (!(h->type & NGX_HUNK_LAST_SHADOW)) {
next = h->shadow;
h->type &= ~(NGX_HUNK_TEMP|NGX_HUNK_IN_MEMORY|NGX_HUNK_RECYCLED);
h->shadow = NULL;
h = next;
while (!b->last_shadow) {
next = b->shadow;
#if 0
b->type &= ~(NGX_HUNK_TEMP|NGX_HUNK_IN_MEMORY|NGX_HUNK_RECYCLED);
#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_RECYCLED
|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_hunk_t *h)
ngx_inline static void ngx_event_pipe_free_shadow_raw_buf(ngx_chain_t **free,
ngx_buf_t *buf)
{
ngx_hunk_t *s;
ngx_buf_t *s;
ngx_chain_t *cl, **ll;
if (h->shadow == NULL) {
if (buf->shadow == NULL) {
return;
}
for (s = h->shadow; !(s->type & NGX_HUNK_LAST_SHADOW); s = s->shadow) {
/* void */
}
for (s = buf->shadow; !s->last_shadow; s = s->shadow) { /* void */ }
ll = free;
for (cl = *free ; cl; cl = cl->next) {
if (cl->hunk == s) {
if (cl->buf == s) {
*ll = cl->next;
break;
}
if (cl->hunk->shadow) {
if (cl->buf->shadow) {
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_chain_t *cl)
ngx_inline static void ngx_event_pipe_add_free_buf(ngx_chain_t **chain,
ngx_chain_t *cl)
{
if (*chain == NULL) {
*chain = cl;
return;
}
if ((*chain)->hunk->pos != (*chain)->hunk->last) {
if ((*chain)->buf->pos != (*chain)->buf->last) {
cl->next = (*chain)->next;
(*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;
for ( ;; ) {
@ -753,17 +750,17 @@ static int ngx_event_pipe_drain_chains(ngx_event_pipe_t *p)
}
while (cl) {
if (cl->hunk->type & NGX_HUNK_LAST_SHADOW) {
h = cl->hunk->shadow;
h->pos = h->last = h->start;
h->shadow = NULL;
ngx_alloc_link_and_set_hunk(tl, h, p->pool, NGX_ABORT);
ngx_event_pipe_add_free_hunk(&p->free_raw_hunks, tl);
if (cl->buf->last_shadow) {
b = cl->buf->shadow;
b->pos = b->last = b->start;
b->shadow = NULL;
ngx_alloc_link_and_set_buf(tl, b, p->pool, NGX_ABORT);
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;
cl->next = p->free;
p->free = cl;

View File

@ -9,16 +9,17 @@
typedef struct ngx_event_pipe_s ngx_event_pipe_t;
typedef int (*ngx_event_pipe_input_filter_pt)(ngx_event_pipe_t *p,
ngx_hunk_t *hunk);
typedef int (*ngx_event_pipe_output_filter_pt)(void *data, ngx_chain_t *chain);
typedef ngx_int_t (*ngx_event_pipe_input_filter_pt)(ngx_event_pipe_t *p,
ngx_buf_t *buf);
typedef ngx_int_t (*ngx_event_pipe_output_filter_pt)(void *data,
ngx_chain_t *chain);
struct ngx_event_pipe_s {
ngx_connection_t *upstream;
ngx_connection_t *downstream;
ngx_chain_t *free_raw_hunks;
ngx_chain_t *free_raw_bufs;
ngx_chain_t *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
* from the raw hunks to an incoming chain
* from the raw bufs to an incoming chain
*/
ngx_event_pipe_input_filter_pt input_filter;
void *input_ctx;
void *input_ctx;
ngx_event_pipe_output_filter_pt output_filter;
void *output_ctx;
void *output_ctx;
unsigned read:1;
unsigned cachable:1;
@ -51,16 +52,16 @@ struct ngx_event_pipe_s {
unsigned downstream_error:1;
unsigned cyclic_temp_file:1;
int hunks;
ngx_int_t allocated;
ngx_bufs_t bufs;
ngx_hunk_tag_t tag;
ngx_buf_tag_t tag;
size_t busy_size;
off_t read_length;
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 send_timeout;
@ -69,9 +70,9 @@ struct ngx_event_pipe_s {
ngx_pool_t *pool;
ngx_log_t *log;
ngx_chain_t *preread_hunks;
int preread_size;
ngx_hunk_t *hunk_to_file;
ngx_chain_t *preread_bufs;
size_t preread_size;
ngx_buf_t *buf_to_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);
int ngx_event_pipe_copy_input_filter(ngx_event_pipe_t *p, ngx_hunk_t *hunk);
ngx_int_t ngx_event_pipe(ngx_event_pipe_t *p, int do_write);
ngx_int_t ngx_event_pipe_copy_input_filter(ngx_event_pipe_t *p, ngx_buf_t *buf);
#endif /* _NGX_EVENT_PIPE_H_INCLUDED_ */

View File

@ -40,7 +40,7 @@ typedef struct {
} 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,
void *conf);
@ -50,7 +50,7 @@ static char *ngx_http_set_charset_slot(ngx_conf_t *cf, ngx_command_t *cmd,
void *conf);
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 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];
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);
}
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;
for (p = h->pos; p < h->last; p++) {
for (p = b->pos; p < b->last; p++) {
c = *p;
*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_top_header_filter = ngx_http_charset_header_filter;

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;
size_t size, len;
ngx_hunk_t *h;
ngx_buf_t *b;
ngx_chain_t out, tail, *cl, *tl, **ll;
if (in == NULL || !r->chunked) {
return ngx_http_next_body_filter(r, in);
}
out.hunk = NULL;
out.buf = NULL;
ll = &out.next;
size = 0;
@ -73,12 +73,12 @@ static int ngx_http_chunked_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
for ( ;; ) {
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);
tl->hunk = cl->hunk;
tl->buf = cl->buf;
*ll = tl;
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);
len = ngx_snprintf((char *) chunk, 11, SIZE_T_X_FMT CRLF, size);
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR);
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_TEMP;
h->pos = chunk;
h->last = chunk + len;
ngx_test_null(b, ngx_calloc_buf(r->pool), NGX_ERROR);
b->temporary = 1;
b->pos = chunk;
b->last = chunk + len;
out.hunk = h;
out.buf = b;
}
if (cl->hunk->type & NGX_HUNK_LAST) {
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR);
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_MEMORY|NGX_HUNK_LAST;
h->pos = (u_char *) CRLF "0" CRLF CRLF;
h->last = h->pos + 7;
if (cl->buf->last_buf) {
ngx_test_null(b, ngx_calloc_buf(r->pool), NGX_ERROR);
b->memory = 1;
b->last_buf = 1;
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) {
h->pos += 2;
out.hunk = h;
b->pos += 2;
out.buf = b;
out.next = NULL;
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);
}
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR);
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_MEMORY;
h->pos = (u_char *) CRLF;
h->last = h->pos + 2;
ngx_test_null(b, ngx_calloc_buf(r->pool), NGX_ERROR);
b->memory = 1;
b->pos = (u_char *) CRLF;
b->last = b->pos + 2;
}
tail.hunk = h;
tail.buf = b;
tail.next = NULL;
*ll = &tail;

View File

@ -39,9 +39,9 @@ typedef struct {
ngx_chain_t *busy;
ngx_chain_t *out;
ngx_chain_t **last_out;
ngx_hunk_t *in_hunk;
ngx_hunk_t *out_hunk;
ngx_int_t hunks;
ngx_buf_t *in_buf;
ngx_buf_t *out_buf;
ngx_int_t bufs;
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;
struct gztrailer *trailer;
ngx_hunk_t *h;
ngx_buf_t *b;
ngx_chain_t *cl;
ngx_http_gzip_ctx_t *ctx;
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);
}
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;
h->pos = gzheader;
h->last = h->pos + 10;
b->memory = 1;
b->pos = gzheader;
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->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;
}
ctx->in_hunk = ctx->in->hunk;
ctx->in_buf = ctx->in->buf;
ctx->in = ctx->in->next;
ctx->zstream.next_in = ctx->in_hunk->pos;
ctx->zstream.avail_in = ctx->in_hunk->last - ctx->in_hunk->pos;
ctx->zstream.next_in = ctx->in_buf->pos;
ctx->zstream.avail_in = ctx->in_buf->last - ctx->in_buf->pos;
ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"gzip in_hunk:" PTR_FMT " ni:" PTR_FMT " ai:%d",
ctx->in_hunk,
"gzip in_buf:" PTR_FMT " ni:" PTR_FMT " ai:%d",
ctx->in_buf,
ctx->zstream.next_in, ctx->zstream.avail_in);
/* 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,
"zstream.avail_in is huge");
ctx->done = 1;
return NGX_ERROR;
}
if (ctx->in_hunk->type & NGX_HUNK_LAST) {
if (ctx->in_buf->last_buf) {
ctx->flush = Z_FINISH;
} else if (ctx->in_hunk->type & NGX_HUNK_FLUSH) {
} else if (ctx->in_buf->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->free) {
ctx->out_hunk = ctx->free->hunk;
ctx->out_buf = ctx->free->buf;
ctx->free = ctx->free->next;
} else if (ctx->hunks < conf->bufs.num) {
ngx_test_null(ctx->out_hunk,
ngx_create_temp_hunk(r->pool, conf->bufs.size),
ngx_http_gzip_error(ctx));
ctx->out_hunk->tag = (ngx_hunk_tag_t)
} else if (ctx->bufs < conf->bufs.num) {
ngx_test_null(ctx->out_buf,
ngx_create_temp_buf(r->pool, conf->bufs.size),
ngx_http_gzip_error(ctx));
ctx->out_buf->tag = (ngx_buf_tag_t)
&ngx_http_gzip_filter_module;
ctx->out_hunk->type |= NGX_HUNK_RECYCLED;
ctx->hunks++;
ctx->out_buf->recycled = 1;
ctx->bufs++;
} else {
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->zstream.next_out = ctx->out_hunk->pos;
ctx->zstream.next_out = ctx->out_buf->pos;
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);
ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"gzip in_hunk:" PTR_FMT " pos:" PTR_FMT,
ctx->in_hunk, ctx->in_hunk->pos);
"gzip in_buf:" PTR_FMT " pos:" PTR_FMT,
ctx->in_buf, ctx->in_buf->pos);
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) {
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) {
ngx_alloc_link_and_set_hunk(cl, ctx->out_hunk, r->pool,
ngx_http_gzip_error(ctx));
ngx_alloc_link_and_set_buf(cl, ctx->out_buf, r->pool,
ngx_http_gzip_error(ctx));
*ctx->last_out = cl;
ctx->last_out = &cl->next;
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;
if (ctx->flush == Z_SYNC_FLUSH) {
ctx->out_hunk->type |= NGX_HUNK_FLUSH;
ctx->out_buf->flush = 0;
ctx->flush = Z_NO_FLUSH;
ngx_alloc_link_and_set_hunk(cl, ctx->out_hunk, r->pool,
ngx_http_gzip_error(ctx));
ngx_alloc_link_and_set_buf(cl, ctx->out_buf, r->pool,
ngx_http_gzip_error(ctx));
*ctx->last_out = cl;
ctx->last_out = &cl->next;
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_alloc_link_and_set_hunk(cl, ctx->out_hunk, r->pool,
ngx_http_gzip_error(ctx));
ngx_alloc_link_and_set_buf(cl, ctx->out_buf, r->pool,
ngx_http_gzip_error(ctx));
*ctx->last_out = cl;
ctx->last_out = &cl->next;
if (ctx->zstream.avail_out >= 8) {
trailer = (struct gztrailer *) ctx->out_hunk->last;
ctx->out_hunk->type |= NGX_HUNK_LAST;
ctx->out_hunk->last += 8;
trailer = (struct gztrailer *) ctx->out_buf->last;
ctx->out_buf->last += 8;
ctx->out_buf->last_buf = 1;
} 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));
h->type |= NGX_HUNK_LAST;
b->last_buf = 1;
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->last_out = cl;
ctx->last_out = &cl->next;
trailer = (struct gztrailer *) h->pos;
h->last += 8;
trailer = (struct gztrailer *) b->pos;
b->last += 8;
}
#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) {
ngx_alloc_link_and_set_hunk(cl, ctx->out_hunk, r->pool,
ngx_http_gzip_error(ctx));
ngx_alloc_link_and_set_buf(cl, ctx->out_buf, r->pool,
ngx_http_gzip_error(ctx));
*ctx->last_out = cl;
ctx->last_out = &cl->next;
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_hunk_tag_t) &ngx_http_gzip_filter_module);
(ngx_buf_tag_t) &ngx_http_gzip_filter_module);
ctx->last_out = &ctx->out;
if (ctx->done) {

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_uint_t i;
ngx_hunk_t *h;
ngx_buf_t *b;
ngx_chain_t *out, *hcl, *rcl, *dcl, **ll;
ngx_http_range_t *range;
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
* that are passed in the single file hunk
* that are passed in the single file buf
*/
if (in
&& in->hunk->type & NGX_HUNK_FILE
&& in->hunk->type & NGX_HUNK_LAST)
{
if (in && in->buf->in_file && in->buf->last_buf) {
range = r->headers_out.ranges.elts;
if (r->headers_out.ranges.nelts == 1) {
in->hunk->file_pos = range->start;
in->hunk->file_last = range->end;
in->buf->file_pos = range->start;
in->buf->file_last = range->end;
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 "
*/
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR);
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_MEMORY;
h->pos = ctx->boundary_header.data;
h->last = ctx->boundary_header.data + ctx->boundary_header.len;
ngx_test_null(b, ngx_calloc_buf(r->pool), NGX_ERROR);
b->memory = 1;
b->pos = ctx->boundary_header.data;
b->last = ctx->boundary_header.data + ctx->boundary_header.len;
ngx_test_null(hcl, ngx_alloc_chain_link(r->pool), NGX_ERROR);
hcl->hunk = h;
hcl->buf = b;
/* "SSSS-EEEE/TTTT" CRLF CRLF */
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR);
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_TEMP;
h->pos = range[i].content_range.data;
h->last = range[i].content_range.data + range[i].content_range.len;
ngx_test_null(b, ngx_calloc_buf(r->pool), NGX_ERROR);
b->temporary = 1;
b->pos = range[i].content_range.data;
b->last = range[i].content_range.data + range[i].content_range.len;
ngx_test_null(rcl, ngx_alloc_chain_link(r->pool), NGX_ERROR);
rcl->hunk = h;
rcl->buf = b;
/* the range data */
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR);
h->type = NGX_HUNK_FILE;
h->file_pos = range[i].start;
h->file_last = range[i].end;
h->file = in->hunk->file;
ngx_test_null(b, ngx_calloc_buf(r->pool), NGX_ERROR);
b->in_file = 1;
b->file_pos = range[i].start;
b->file_last = range[i].end;
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;
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 */
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR);
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_TEMP|NGX_HUNK_LAST;
ngx_test_null(h->pos, ngx_palloc(r->pool, 4 + 10 + 4), NGX_ERROR);
h->last = ngx_cpymem(h->pos, ctx->boundary_header.data, 4 + 10);
*h->last++ = '-'; *h->last++ = '-';
*h->last++ = CR; *h->last++ = LF;
ngx_test_null(b, ngx_calloc_buf(r->pool), NGX_ERROR);
b->temporary = 1;
b->last_buf = 1;
ngx_test_null(b->pos, ngx_palloc(r->pool, 4 + 10 + 4), NGX_ERROR);
b->last = ngx_cpymem(b->pos, ctx->boundary_header.data, 4 + 10);
*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;
return ngx_http_next_body_filter(r, out);

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_err_t err;
ngx_log_t *log;
ngx_hunk_t *h;
ngx_buf_t *b;
ngx_chain_t out;
ngx_file_info_t fi;
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 */
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;
}
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;
}
@ -487,15 +487,19 @@ static ngx_int_t ngx_http_static_handler(ngx_http_request_t *r)
return rc;
}
h->type = r->main ? NGX_HUNK_FILE : NGX_HUNK_FILE|NGX_HUNK_LAST;
b->in_file = 1;
h->file_pos = 0;
h->file_last = ngx_file_size(&fi);
if (!r->main) {
b->last_buf = 1;
}
h->file->fd = fd;
h->file->log = log;
b->file_pos = 0;
b->file_last = ngx_file_size(&fi);
out.hunk = h;
b->file->fd = fd;
b->file->log = log;
out.buf = b;
out.next = NULL;
return ngx_http_output_filter(r, &out);

View File

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

View File

@ -108,7 +108,7 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
{
size_t len;
ngx_uint_t i;
ngx_hunk_t *h;
ngx_buf_t *b;
ngx_chain_t *chain;
ngx_table_elt_t *header;
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;
}
/* STUB */ len++;
#if (NGX_DEBUG)
len++;
#endif
ngx_test_null(h, ngx_create_temp_hunk(r->pool, len), NULL);
ngx_alloc_link_and_set_hunk(chain, h, r->pool, NULL);
ngx_test_null(b, ngx_create_temp_buf(r->pool, len), NULL);
ngx_alloc_link_and_set_buf(chain, b, r->pool, NULL);
/* the request line */
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].len);
} 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.len - uc->location->len);
if (r->args.len > 0) {
*(h->last++) = '?';
h->last = ngx_cpymem(h->last, r->args.data, r->args.len);
*(b->last++) = '?';
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 */
h->last = ngx_cpymem(h->last, connection_close_header,
b->last = ngx_cpymem(b->last, connection_close_header,
sizeof(connection_close_header) - 1);
/* 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) {
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);
if (!uc->default_port) {
*(h->last++) = ':';
h->last = ngx_cpymem(h->last, uc->port_text.data,
*(b->last++) = ':';
b->last = ngx_cpymem(b->last, uc->port_text.data,
uc->port_text.len);
}
} 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);
}
*(h->last++) = CR; *(h->last++) = LF;
*(b->last++) = CR; *(b->last++) = LF;
/* the "X-Real-IP" header */
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);
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);
*(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 (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);
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.len);
*(h->last++) = ','; *(h->last++) = ' ';
*(b->last++) = ','; *(b->last++) = ' ';
} 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);
}
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);
*(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;
}
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);
*(h->last++) = CR; *(h->last++) = LF;
*(b->last++) = CR; *(b->last++) = LF;
ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"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 */
*(h->last++) = CR; *(h->last++) = LF;
*(b->last++) = CR; *(b->last++) = LF;
#if (NGX_DEBUG)
*(h->last) = '\0';
*(b->last) = '\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
return chain;
@ -389,7 +391,7 @@ static void ngx_http_proxy_init_upstream(void *data)
output->sendfile = r->sendfile;
output->pool = r->pool;
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;
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 */
for (cl = p->request->request_body->bufs; cl; cl = cl->next) {
cl->hunk->pos = cl->hunk->start;
cl->hunk->file_pos = 0;
cl->buf->pos = cl->buf->start;
cl->buf->file_pos = 0;
}
/* reinit the ngx_output_chain() context */
output = p->upstream->output_chain_ctx;
output->hunk = NULL;
output->buf = NULL;
output->in = NULL;
output->free = NULL;
output->busy = NULL;
@ -614,9 +616,9 @@ static void ngx_http_proxy_connect(ngx_http_proxy_ctx_t *p)
return;
}
output->free->hunk = r->request_body->buf;
output->free->next = NULL;
output->hunks = 1;
output->free->buf = r->request_body->buf;
output->free->buf = NULL;
output->allocated = 1;
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) {
p->header_in = ngx_create_temp_hunk(p->request->pool,
p->lcf->header_buffer_size);
p->header_in = ngx_create_temp_buf(p->request->pool,
p->lcf->header_buffer_size);
if (p->header_in == NULL) {
ngx_http_proxy_finalize_request(p, NGX_HTTP_INTERNAL_SERVER_ERROR);
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) {
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)
ngx_http_output_filter;
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->busy_size = p->lcf->busy_buffers_size;
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->temp_file_write_size = p->lcf->temp_file_write_size;
ep->preread_hunks = ngx_alloc_chain_link(r->pool);
if (ep->preread_hunks == NULL) {
if (!(ep->preread_bufs = ngx_alloc_chain_link(r->pool))) {
ngx_http_proxy_finalize_request(p, 0);
return;
}
ep->preread_hunks->hunk = p->header_in;
ep->preread_hunks->next = NULL;
ep->preread_bufs->buf = p->header_in;
ep->preread_bufs->next = NULL;
ep->preread_size = p->header_in->last - p->header_in->pos;
if (p->cachable) {
ep->hunk_to_file = ngx_calloc_hunk(r->pool);
if (ep->hunk_to_file == NULL) {
ep->buf_to_file = ngx_calloc_buf(r->pool);
if (ep->buf_to_file == NULL) {
ngx_http_proxy_finalize_request(p, 0);
return;
}
ep->hunk_to_file->pos = p->header_in->start;
ep->hunk_to_file->last = p->header_in->pos;
ep->hunk_to_file->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_TEMP;
ep->buf_to_file->pos = p->header_in->start;
ep->buf_to_file->last = p->header_in->pos;
ep->buf_to_file->temporary = 1;
}
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;
}
/* 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;
/*

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_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);
void ngx_http_handler(ngx_http_request_t *r);

View File

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

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->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->filter_ctx = r;

View File

@ -95,7 +95,7 @@ static int ngx_http_header_filter(ngx_http_request_t *r)
u_char *p;
size_t len;
ngx_uint_t status, i;
ngx_hunk_t *h;
ngx_buf_t *b;
ngx_chain_t *ln;
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;
}
if (!(h = ngx_create_temp_hunk(r->pool, len))) {
if (!(b = ngx_create_temp_buf(r->pool, len))) {
return NGX_ERROR;
}
/* "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 */
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);
} 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);
}
*(h->last++) = CR; *(h->last++) = LF;
*(b->last++) = CR; *(b->last++) = LF;
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)) {
h->last = ngx_cpymem(h->last, "Date: ", sizeof("Date: ") - 1);
h->last = ngx_cpymem(h->last, ngx_cached_http_time.data,
b->last = ngx_cpymem(b->last, "Date: ", sizeof("Date: ") - 1);
b->last = ngx_cpymem(b->last, ngx_cached_http_time.data,
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_n >= 0) {
h->last += ngx_snprintf((char *) h->last,
b->last += ngx_snprintf((char *) b->last,
sizeof("Content-Length: ") + NGX_OFF_T_LEN + 2,
"Content-Length: " OFF_T_FMT CRLF,
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) {
h->last = ngx_cpymem(h->last, "Content-Type: ",
b->last = ngx_cpymem(b->last, "Content-Type: ",
sizeof("Content-Type: ") - 1);
p = h->last;
h->last = ngx_cpymem(h->last, r->headers_out.content_type->value.data,
p = b->last;
b->last = ngx_cpymem(b->last, r->headers_out.content_type->value.data,
r->headers_out.content_type->value.len);
if (r->headers_out.charset.len) {
h->last = ngx_cpymem(h->last, "; charset=",
b->last = ngx_cpymem(b->last, "; charset=",
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.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;
}
*(h->last++) = CR; *(h->last++) = LF;
*(b->last++) = CR; *(b->last++) = LF;
}
if (r->headers_out.location
&& r->headers_out.location->value.len
&& r->headers_out.location->value.data[0] == '/')
{
p = h->last + sizeof("Location: ") - 1;
h->last = ngx_cpymem(h->last, "Location: http://",
p = b->last + sizeof("Location: ") - 1;
b->last = ngx_cpymem(b->last, "Location: http://",
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);
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);
}
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 = h->last - p;
r->headers_out.location->value.len = b->last - 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)
&& 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);
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) {
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);
}
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);
} else {
h->last = ngx_cpymem(h->last, "Connection: close" CRLF,
b->last = ngx_cpymem(b->last, "Connection: close" CRLF,
sizeof("Connection: close" CRLF) - 1);
}
@ -326,33 +326,33 @@ static int ngx_http_header_filter(ngx_http_request_t *r)
continue;
}
h->last = ngx_cpymem(h->last, header[i].key.data, header[i].key.len);
*(h->last++) = ':' ; *(h->last++) = ' ' ;
b->last = ngx_cpymem(b->last, header[i].key.data, header[i].key.len);
*(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);
*(h->last++) = CR; *(h->last++) = LF;
*(b->last++) = CR; *(b->last++) = LF;
}
#if (NGX_DEBUG)
*(h->last) = '\0';
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "%s\n", h->pos);
*(b->last) = '\0';
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "%s\n", b->pos);
#endif
/* 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) {
h->type |= NGX_HUNK_LAST;
b->last_buf = 1;
}
if (!(ln = ngx_alloc_chain_link(r->pool))) {
return NGX_ERROR;
}
ln->hunk = h;
ln->buf = b;
ln->next = NULL;
return ngx_http_write_filter(r, ln);

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;
enum {
@ -455,9 +455,9 @@ ngx_int_t ngx_http_parse_header_line(ngx_http_request_t *r, ngx_hunk_t *h)
} 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++;
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) {
r->state = sw_start;

View File

@ -236,8 +236,8 @@ static void ngx_http_init_request(ngx_event_t *rev)
}
if (c->buffer == NULL) {
c->buffer = ngx_create_temp_hunk(c->pool,
cscf->client_header_buffer_size);
c->buffer = ngx_create_temp_buf(c->pool,
cscf->client_header_buffer_size);
if (c->buffer == NULL) {
ngx_http_close_connection(c);
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)
{
int len;
ngx_hunk_t *h;
ngx_buf_t *b;
ngx_event_t *rev, *wev;
ngx_connection_t *c;
ngx_http_log_ctx_t *ctx;
@ -1257,12 +1257,12 @@ static void ngx_http_set_keepalive(ngx_http_request_t *r)
return;
}
h = c->buffer;
b = c->buffer;
wev = c->write;
wev->event_handler = ngx_http_empty_handler;
if (h->pos < h->last) {
if (b->pos < b->last) {
/*
* 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);
if (!cscf->large_client_header) {
len = h->last - h->pos;
ngx_memcpy(h->start, h->pos, len);
h->pos = h->start;
h->last = h->start + len;
len = b->last - b->pos;
ngx_memcpy(b->start, b->pos, len);
b->pos = b->start;
b->last = b->start + len;
}
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;
h->pos = h->last = h->start;
b->pos = b->last = b->start;
rev->event_handler = ngx_http_keepalive_handler;
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)
{
ngx_hunk_t *h;
ngx_buf_t *b;
ngx_chain_t out;
ngx_test_null(h, ngx_calloc_hunk(r->pool), NGX_ERROR);
h->type = NGX_HUNK_LAST;
out.hunk = h;
if (!(b = ngx_calloc_buf(r->pool))) {
return NGX_ERROR;
}
b->last_buf = 1;
out.buf = b;
out.next = NULL;
return ngx_http_output_filter(r, &out);

View File

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

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)
{
ssize_t size;
ngx_hunk_t *h;
ngx_buf_t *b;
ngx_chain_t *cl;
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 */
ngx_test_null(h, ngx_calloc_hunk(r->pool),
ngx_test_null(b, ngx_calloc_buf(r->pool),
NGX_HTTP_INTERNAL_SERVER_ERROR);
h->type = NGX_HUNK_IN_MEMORY|NGX_HUNK_TEMP;
h->start = h->pos = r->header_in->pos;
h->end = h->last = r->header_in->last;
b->temporary = 1;
b->start = b->pos = r->header_in->pos;
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);
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;
}
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_alloc_link_and_set_hunk(cl, r->request_body->buf, r->pool,
NGX_HTTP_INTERNAL_SERVER_ERROR);
ngx_alloc_link_and_set_buf(cl, r->request_body->buf, r->pool,
NGX_HTTP_INTERNAL_SERVER_ERROR);
if (r->request_body->bufs) {
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;
ssize_t n;
ngx_hunk_t *h;
ngx_buf_t *b;
ngx_connection_t *c;
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;
}
h = ngx_calloc_hunk(r->pool);
if (h == NULL) {
if (!(b = ngx_calloc_buf(r->pool))) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
h->type = NGX_HUNK_FILE;
h->file_pos = 0;
h->file_last = r->request_body->temp_file->file.offset;
h->file = &r->request_body->temp_file->file;
b->in_file = 1;
b->file_pos = 0;
b->file_last = r->request_body->temp_file->file.offset;
b->file = &r->request_body->temp_file->file;
if (r->request_body->bufs->next) {
r->request_body->bufs->next->hunk = h;
r->request_body->bufs->next->buf = b;
} else {
r->request_body->bufs->hunk = h;
r->request_body->bufs->buf = b;
}
}

View File

@ -181,7 +181,7 @@ int ngx_http_special_response_handler(ngx_http_request_t *r, int error)
{
ngx_int_t rc;
ngx_uint_t err, i;
ngx_hunk_t *h;
ngx_buf_t *b;
ngx_chain_t *out, **ll, *cl;
ngx_http_err_page_t *err_page;
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;
ll = NULL;
if (!(h = ngx_calloc_hunk(r->pool))) {
if (!(b = ngx_calloc_buf(r->pool))) {
return NGX_ERROR;
}
h->type = NGX_HUNK_MEMORY|NGX_HUNK_IN_MEMORY;
h->pos = error_pages[err].data;
h->last = error_pages[err].data + error_pages[err].len;
b->memory = 1;
b->pos = error_pages[err].data;
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);
if (!(h = ngx_calloc_hunk(r->pool))) {
if (!(b = ngx_calloc_buf(r->pool))) {
return NGX_ERROR;
}
h->type = NGX_HUNK_MEMORY|NGX_HUNK_IN_MEMORY;
h->pos = error_tail;
h->last = error_tail + sizeof(error_tail) - 1;
b->memory = 1;
b->pos = error_tail;
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);
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_REQUEST_URI_TOO_LARGE)
{
if (!(h = ngx_calloc_hunk(r->pool))) {
if (!(b = ngx_calloc_buf(r->pool))) {
return NGX_ERROR;
}
h->type = NGX_HUNK_MEMORY|NGX_HUNK_IN_MEMORY;
h->pos = msie_stub;
h->last = msie_stub + sizeof(msie_stub) - 1;
b->memory = 1;
b->pos = msie_stub;
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);
}
h->type |= NGX_HUNK_LAST;
b->last_buf = 1;
return ngx_http_output_filter(r, out);
}

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) {
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;
}
if (cl->hunk->type & NGX_HUNK_LAST) {
if (cl->buf->last_buf) {
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 */
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->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;
}
if (cl->hunk->type & NGX_HUNK_LAST) {
if (cl->buf->last_buf) {
last = 1;
}
}

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;
}
buf = cl->hunk->last;
prev = cl->hunk->last;
buf = cl->buf->last;
prev = cl->buf->last;
size = 0;
/* coalesce the neighbouring hunks */
/* coalesce the neighbouring bufs */
while (cl && prev == cl->hunk->last) {
size += cl->hunk->end - cl->hunk->last;
prev = cl->hunk->end;
while (cl && prev == cl->buf->last) {
size += cl->buf->end - cl->buf->last;
prev = cl->buf->end;
cl = cl->next;
}

View File

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

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 */
if (cl->next == NULL) {
return ngx_write_file(file, cl->hunk->pos,
(size_t) (cl->hunk->last - cl->hunk->pos),
return ngx_write_file(file, cl->buf->pos,
(size_t) (cl->buf->last - cl->buf->pos),
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);
/* create the iovec and coalesce the neighbouring hunks */
/* create the iovec and coalesce the neighbouring bufs */
while (cl) {
if (prev == cl->hunk->pos) {
iov->iov_len += cl->hunk->last - cl->hunk->pos;
if (prev == cl->buf->pos) {
iov->iov_len += cl->buf->last - cl->buf->pos;
} else {
ngx_test_null(iov, ngx_push_array(&io), NGX_ERROR);
iov->iov_base = (void *) cl->hunk->pos;
iov->iov_len = cl->hunk->last - cl->hunk->pos;
iov->iov_base = (void *) cl->buf->pos;
iov->iov_len = cl->buf->last - cl->buf->pos;
}
size += cl->hunk->last - cl->hunk->pos;
prev = cl->hunk->last;
size += cl->buf->last - cl->buf->pos;
prev = cl->buf->last;
cl = cl->next;
}

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

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;
struct iovec *iov;
ngx_err_t err;
ngx_hunk_t *file;
ngx_buf_t *file;
ngx_array_t header;
ngx_event_t *wev;
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;
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) {
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
*/

View File

@ -10,10 +10,10 @@ ssize_t ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *chain)
{
u_char *prev;
ssize_t n, size;
struct iovec *iov;
ngx_err_t err;
ngx_array_t io;
ngx_event_t *rev;
struct iovec *iov;
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);
/* coalesce the neighbouring hunks */
/* coalesce the neighbouring bufs */
while (chain) {
if (prev == chain->hunk->last) {
iov->iov_len += chain->hunk->end - chain->hunk->last;
if (prev == chain->buf->last) {
iov->iov_len += chain->buf->end - chain->buf->last;
} else {
ngx_test_null(iov, ngx_push_array(&io), NGX_ERROR);
iov->iov_base = (void *) chain->hunk->last;
iov->iov_len = chain->hunk->end - chain->hunk->last;
iov->iov_base = (void *) chain->buf->last;
iov->iov_len = chain->buf->end - chain->buf->last;
}
size += chain->hunk->end - chain->hunk->last;
prev = chain->hunk->end;
size += chain->buf->end - chain->buf->last;
prev = chain->buf->end;
chain = chain->next;
}
@ -137,10 +137,10 @@ ssize_t ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *chain)
{
u_char *prev;
ssize_t n, size;
struct iovec *iov;
ngx_err_t err;
ngx_array_t io;
ngx_event_t *rev;
struct iovec *iov;
prev = 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);
/* coalesce the neighbouring hunks */
/* coalesce the neighbouring bufs */
while (chain) {
if (prev == chain->hunk->last) {
iov->iov_len += chain->hunk->end - chain->hunk->last;
if (prev == chain->buf->last) {
iov->iov_len += chain->buf->end - chain->buf->last;
} else {
ngx_test_null(iov, ngx_push_array(&io), NGX_ERROR);
iov->iov_base = chain->hunk->last;
iov->iov_len = chain->hunk->end - chain->hunk->last;
iov->iov_base = chain->buf->last;
iov->iov_len = chain->buf->end - chain->buf->last;
}
size += chain->hunk->end - chain->hunk->last;
prev = chain->hunk->end;
size += chain->buf->end - chain->buf->last;
prev = chain->buf->end;
chain = chain->next;
}

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_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) {
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
* sendfilev() capability, IOV_MAX in Solaris is only 16
* the tail is the rest of the chain that exceedes a single
* sendfilev() capability, IOV_MAX in Solaris is limited by 16
*/
tail = cl;

View File

@ -41,19 +41,19 @@ ngx_chain_t *ngx_writev_chain(ngx_connection_t *c, ngx_chain_t *in)
iov = NULL;
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) {
if (prev == cl->hunk->pos) {
iov->iov_len += cl->hunk->last - cl->hunk->pos;
prev = cl->hunk->last;
if (prev == cl->buf->pos) {
iov->iov_len += cl->buf->last - cl->buf->pos;
prev = cl->buf->last;
} else {
ngx_test_null(iov, ngx_push_array(&io), NGX_CHAIN_ERROR);
iov->iov_base = (void *) cl->hunk->pos;
iov->iov_len = cl->hunk->last - cl->hunk->pos;
prev = cl->hunk->last;
iov->iov_base = (void *) cl->buf->pos;
iov->iov_len = cl->buf->last - cl->buf->pos;
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) {
size = cl->hunk->last - cl->hunk->pos;
size = cl->buf->last - cl->buf->pos;
if (sent >= size) {
sent -= size;
if (cl->hunk->type & NGX_HUNK_IN_MEMORY) {
cl->hunk->pos = cl->hunk->last;
if (ngx_buf_in_memory(cl->buf)) {
cl->buf->pos = cl->buf->last;
}
continue;
}
if (cl->hunk->type & NGX_HUNK_IN_MEMORY) {
cl->hunk->pos += sent;
if (ngx_buf_in_memory(cl->buf)) {
cl->buf->pos += sent;
}
break;

View File

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

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);
/* coalesce the neighbouring hunks */
/* coalesce the neighbouring bufs */
while (chain) {
if (prev == chain->hunk->last) {
wsabuf->len += chain->hunk->end - chain->hunk->last;
if (prev == chain->buf->last) {
wsabuf->len += chain->buf->end - chain->buf->last;
} else {
ngx_test_null(wsabuf, ngx_push_array(&io), NGX_ERROR);
wsabuf->buf = (char *) chain->hunk->last;
wsabuf->len = chain->hunk->end - chain->hunk->last;
wsabuf->buf = (char *) chain->buf->last;
wsabuf->len = chain->buf->end - chain->buf->last;
}
size += chain->hunk->end - chain->hunk->last;
prev = chain->hunk->end;
size += chain->buf->end - chain->buf->last;
prev = chain->buf->end;
chain = chain->next;
}

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) {
if (prev == cl->hunk->pos) {
wsabuf->len += cl->hunk->last - cl->hunk->pos;
prev = cl->hunk->last;
if (prev == cl->buf->pos) {
wsabuf->len += cl->buf->last - cl->buf->pos;
prev = cl->buf->last;
} else {
ngx_test_null(wsabuf, ngx_push_array(&wsabufs), NGX_CHAIN_ERROR);
wsabuf->buf = (char *) cl->hunk->pos;
wsabuf->len = cl->hunk->last - cl->hunk->pos;
prev = cl->hunk->last;
wsabuf->buf = (char *) cl->buf->pos;
wsabuf->len = cl->buf->last - cl->buf->pos;
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) {
size = cl->hunk->last - cl->hunk->pos;
size = cl->buf->last - cl->buf->pos;
if (sent >= size) {
sent -= size;
if (cl->hunk->type & NGX_HUNK_IN_MEMORY) {
cl->hunk->pos = cl->hunk->last;
if (ngx_buf_in_memory(cl->buf)) {
cl->buf->pos = cl->buf->last;
}
continue;
}
if (cl->hunk->type & NGX_HUNK_IN_MEMORY) {
cl->hunk->pos += sent;
if (ngx_buf_in_memory(cl->buf)) {
cl->buf->pos += sent;
}
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) {
if (prev == cl->hunk->pos) {
wsabuf->len += cl->hunk->last - cl->hunk->pos;
prev = cl->hunk->last;
if (prev == cl->buf->pos) {
wsabuf->len += cl->buf->last - cl->buf->pos;
prev = cl->buf->last;
} else {
ngx_test_null(wsabuf, ngx_push_array(&wsabufs),
NGX_CHAIN_ERROR);
wsabuf->buf = (char *) cl->hunk->pos;
wsabuf->len = cl->hunk->last - cl->hunk->pos;
prev = cl->hunk->last;
wsabuf->buf = (char *) cl->buf->pos;
wsabuf->len = cl->buf->last - cl->buf->pos;
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) {
size = cl->hunk->last - cl->hunk->pos;
size = cl->buf->last - cl->buf->pos;
if (sent >= size) {
sent -= size;
if (cl->hunk->type & NGX_HUNK_IN_MEMORY) {
cl->hunk->pos = cl->hunk->last;
if (ngx_buf_in_memory(cl->buf)) {
cl->buf->pos = cl->buf->last;
}
continue;
}
if (cl->hunk->type & NGX_HUNK_IN_MEMORY) {
cl->hunk->pos += sent;
if (ngx_buf_in_memory(cl->buf)) {
cl->buf->pos += sent;
}
break;