nginx/src/core/ngx_output_chain.c
Igor Sysoev 1b73583ba2 nginx-0.1.5-RELEASE import
*) Bugfix: on Solaris and Linux there may be too many "recvmsg()
       returned not enough data" alerts.

    *) Bugfix: there were the "writev() failed (22: Invalid argument)"
       errors on Solaris in proxy mode without sendfile. On other platforms
       that do not support sendfile at all the process got caught in an
       endless loop.

    *) Bugfix: segmentation fault on Solaris in proxy mode and using
       sendfile.

    *) Bugfix: segmentation fault on Solaris.

    *) Bugfix: on-line upgrade did not work on Linux.

    *) Bugfix: the ngx_http_autoindex_module module did not escape the
       spaces, the quotes, and the percent signs in the directory listing.

    *) Change: the decrease of the copy operations.

    *) Feature: the userid_p3p directive.
2004-11-11 14:07:14 +00:00

343 lines
8.1 KiB
C

/*
* Copyright (C) Igor Sysoev
*/
#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_event.h>
#define NGX_NONE 1
ngx_inline static ngx_int_t
ngx_output_chain_need_to_copy(ngx_output_chain_ctx_t *ctx, 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);
ngx_int_t ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in)
{
int rc, last;
size_t size, bsize;
ngx_chain_t *cl, *out, **last_out;
if (ctx->in == NULL && ctx->busy == NULL) {
/*
* the short path for the case when the ctx->in and ctx->busy chains
* are empty, the incoming chain is empty too or has the single buf
* that does not require the copy
*/
if (in == NULL) {
return ctx->output_filter(ctx->filter_ctx, in);
}
if (in->next == NULL
&& (!ngx_output_chain_need_to_copy(ctx, in->buf)))
{
return ctx->output_filter(ctx->filter_ctx, in);
}
}
/* add the incoming buf to the chain ctx->in */
if (in) {
if (ngx_chain_add_copy(ctx->pool, &ctx->in, in) == NGX_ERROR) {
return NGX_ERROR;
}
}
last = NGX_NONE;
out = NULL;
last_out = &out;
for ( ;; ) {
while (ctx->in) {
/*
* cycle while there are the ctx->in bufs
* or there are the free output bufs to copy in
*/
bsize = ngx_buf_size(ctx->in->buf);
if (bsize == 0 && !ngx_buf_special(ctx->in->buf)) {
ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, 0,
"zero size buf");
ctx->in = ctx->in->next;
continue;
}
if (!ngx_output_chain_need_to_copy(ctx, ctx->in->buf)) {
/* move the chain link to the output chain */
cl = ctx->in;
ctx->in = cl->next;
*last_out = cl;
last_out = &cl->next;
cl->next = NULL;
continue;
}
if (ctx->buf == NULL) {
/* get the free buf */
if (ctx->free) {
ctx->buf = ctx->free->buf;
ctx->free = ctx->free->next;
} else if (out || ctx->allocated == ctx->bufs.num) {
break;
} else {
size = ctx->bufs.size;
if (ctx->in->buf->last_buf) {
if (bsize < ctx->bufs.size) {
/*
* allocate small temp buf for the small last buf
* or its small last part
*/
size = bsize;
} else if (ctx->bufs.num == 1
&& (bsize < ctx->bufs.size
+ (ctx->bufs.size >> 2)))
{
/*
* 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 = bsize;
}
}
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_buf(ctx->buf, ctx->in->buf,
ctx->sendfile);
if (rc == NGX_ERROR) {
return rc;
}
if (rc == NGX_AGAIN) {
if (out) {
break;
}
return rc;
}
/* delete the completed buf from the ctx->in chain */
if (ngx_buf_size(ctx->in->buf) == 0) {
ctx->in = ctx->in->next;
}
if (!(cl = ngx_alloc_chain_link(ctx->pool))) {
return NGX_ERROR;
}
cl->buf = ctx->buf;
cl->next = NULL;
*last_out = cl;
last_out = &cl->next;
ctx->buf = NULL;
}
if (out == NULL && last != NGX_NONE) {
return last;
}
last = ctx->output_filter(ctx->filter_ctx, out);
ngx_chain_update_chains(&ctx->free, &ctx->busy, &out, ctx->tag);
last_out = &out;
if (last == NGX_ERROR) {
return last;
}
}
}
ngx_inline static ngx_int_t
ngx_output_chain_need_to_copy(ngx_output_chain_ctx_t *ctx, ngx_buf_t *buf)
{
if (ngx_buf_special(buf)) {
return 0;
}
if (!ctx->sendfile) {
if (!ngx_buf_in_memory(buf)) {
return 1;
}
buf->in_file = 0;
}
if (ctx->need_in_memory && !ngx_buf_in_memory(buf)) {
return 1;
}
if (ctx->need_in_temp && (buf->memory || buf->mmap)) {
return 1;
}
return 0;
}
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_buf_size(src);
if (size > (size_t) (dst->end - dst->pos)) {
size = dst->end - dst->pos;
}
if (ngx_buf_in_memory(src)) {
ngx_memcpy(dst->pos, src->pos, size);
src->pos += size;
dst->last += size;
if (src->in_file) {
if (sendfile) {
dst->in_file = 1;
dst->file = src->file;
dst->file_pos = src->file_pos;
dst->file_last = src->file_pos + size;
} else {
dst->in_file = 0;
}
src->file_pos += size;
} else {
dst->in_file = 0;
}
if (src->last_buf && src->pos == src->last) {
dst->last_buf = 1;
}
} else {
n = ngx_read_file(src->file, dst->pos, size, src->file_pos);
if (n == NGX_ERROR) {
return n;
}
#if (NGX_FILE_AIO_READ)
if (n == NGX_AGAIN) {
return n;
}
#endif
if ((size_t) n != size) {
ngx_log_error(NGX_LOG_ALERT, src->file->log, 0,
ngx_read_file_n " reads only %z of %uz from file",
n, size);
if (n == 0) {
return NGX_ERROR;
}
}
dst->last += n;
if (sendfile) {
dst->in_file = 1;
dst->file = src->file;
dst->file_pos = src->file_pos;
dst->file_last = src->file_pos + n;
} else {
dst->in_file = 0;
}
src->file_pos += n;
if (src->last_buf && src->file_pos == src->file_last) {
dst->last_buf = 1;
}
}
return NGX_OK;
}
ngx_int_t ngx_chain_writer(void *data, ngx_chain_t *in)
{
ngx_chain_writer_ctx_t *ctx = data;
ngx_chain_t *cl;
for (/* void */; in; in = in->next) {
ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->connection->log, 0,
"chain writer buf size: %uz", ngx_buf_size(in->buf));
if (!(cl = ngx_alloc_chain_link(ctx->pool))) {
return NGX_ERROR;
}
cl->buf = in->buf;
cl->next = NULL;
*ctx->last = cl;
ctx->last = &cl->next;
}
ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->connection->log, 0,
"chain writer in: %p", ctx->out);
ctx->out = ngx_send_chain(ctx->connection, ctx->out, ctx->limit);
ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->connection->log, 0,
"chain writer out: %p", ctx->out);
if (ctx->out == NGX_CHAIN_ERROR) {
return NGX_ERROR;
}
if (ctx->out == NULL) {
ctx->last = &ctx->out;
return NGX_OK;
}
return NGX_AGAIN;
}