Mercurial > hg > nginx-vendor-0-8
diff src/core/ngx_output_chain.c @ 0:f0b350454894 NGINX_0_1_0
nginx 0.1.0
*) The first public version.
author | Igor Sysoev <http://sysoev.ru> |
---|---|
date | Mon, 04 Oct 2004 00:00:00 +0400 |
parents | |
children | cc9f381affaa |
line wrap: on
line diff
new file mode 100644 --- /dev/null +++ b/src/core/ngx_output_chain.c @@ -0,0 +1,312 @@ + +/* + * 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; + + /* + * 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 buf + * that does not require the copy + */ + + if (ctx->in == NULL) { + + 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; + } + + ngx_alloc_link_and_set_buf(cl, ctx->buf, ctx->pool, NGX_ERROR); + *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) { + src->file_pos += size; + } + + 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 %d of %d from file", + n, size); + if (n == 0) { + return NGX_ERROR; + } + } + + src->file_pos += n; + dst->last += n; + + if (!sendfile) { + dst->in_file = 0; + } + + 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, + "WRITER buf: %d", ngx_buf_size(in->buf)); + + ngx_alloc_link_and_set_buf(cl, in->buf, ctx->pool, NGX_ERROR); + *ctx->last = cl; + ctx->last = &cl->next; + } + + ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->connection->log, 0, + "WRITER0: %X", ctx->out); + + ctx->out = ngx_send_chain(ctx->connection, ctx->out, ctx->limit); + + ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->connection->log, 0, + "WRITER1: %X", 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; +}