nginx之chunked模块解析

#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_http.h>

/*在没有Content-Length头的情况下,chunk filter模块可以流式(stream)的加上长度.
注意这个前提条件,没有设置Content-Length头*/

typedef struct {
ngx_chain_t *free;
ngx_chain_t *busy;
} ngx_http_chunked_filter_ctx_t;

static ngx_int_t ngx_http_chunked_filter_init(ngx_conf_t *cf);

static ngx_http_module_t ngx_http_chunked_filter_module_ctx = {
NULL, /* preconfiguration */
ngx_http_chunked_filter_init, /* postconfiguration */

NULL, /* create main configuration */
NULL, /* init main configuration */

NULL, /* create server configuration */
NULL, /* merge server configuration */

NULL, /* create location configuration */
NULL /* merge location configuration */
};

ngx_module_t ngx_http_chunked_filter_module = {
NGX_MODULE_V1,
&ngx_http_chunked_filter_module_ctx, /* module context */
NULL, /* module directives */
NGX_HTTP_MODULE, /* module type */
NULL, /* init master */
NULL, /* init module */
NULL, /* init process */
NULL, /* init thread */
NULL, /* exit thread */
NULL, /* exit process */
NULL, /* exit master */
NGX_MODULE_V1_PADDING
};

static ngx_http_output_header_filter_pt ngx_http_next_header_filter;
static ngx_http_output_body_filter_pt ngx_http_next_body_filter;

static ngx_int_t
ngx_http_chunked_header_filter(ngx_http_request_t *r)
{
ngx_http_core_loc_conf_t *clcf;
ngx_http_chunked_filter_ctx_t *ctx;

if (r->headers_out.status == NGX_HTTP_NOT_MODIFIED //304
|| r->headers_out.status == NGX_HTTP_NO_CONTENT //204
|| r->headers_out.status < NGX_HTTP_OK //<200
|| r != r->main
|| (r->method & NGX_HTTP_HEAD))
{
return ngx_http_next_header_filter(r);
}

if (r->headers_out.content_length_n == -1) { //没有设置Content-Length
//对于响应头中没有content_length头的请求,强制短连接(<HTTP1.1)
if (r->http_version < NGX_HTTP_VERSION_11) {
r->keepalive = 0;
} else {
//分块传输编码(HTTP1.1)
clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

if (clcf->chunked_transfer_encoding) {
r->chunked = 1;
ctx = ngx_pcalloc(r->pool,
sizeof(ngx_http_chunked_filter_ctx_t));
if (ctx == NULL) {
return NGX_ERROR;
}

ngx_http_set_ctx(r, ctx, ngx_http_chunked_filter_module);

} else {
r->keepalive = 0;
}
}
}
return ngx_http_next_header_filter(r);
}

//fix the bug of giving chunk trailer when upstream aborts start
static ngx_int_t ngx_http_upstream_done(ngx_http_request_t *r)
{
if(r->headers_out.status == 301 || r->headers_out.status == 302 || r->headers_out.status == 304)
{
return NGX_OK;
}
ngx_http_upstream_t *u = r->upstream;

if (u == NULL){
return NGX_ERROR;
}

if (u->buffering && u->pipe->upstream_done
&& u->pipe->downstream_done) {
return NGX_OK;
}
if (!u->buffering && u->length == 0) {
return NGX_OK;
}

return NGX_ERROR;
}
//fix the bug of giving chunk trailer when upstream aborts end

static ngx_int_t
ngx_http_chunked_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
{
u_char *chunk;
off_t size;
ngx_int_t rc;
ngx_buf_t *b;
ngx_chain_t *out, *cl, *tl, **ll;
ngx_http_chunked_filter_ctx_t *ctx;

if (in == NULL || !r->chunked || r->header_only) {
return ngx_http_next_body_filter(r, in);
}

ctx = ngx_http_get_module_ctx(r, ngx_http_chunked_filter_module);

out = NULL;
ll = &out;

size = 0;
cl = in;

for ( ;; ) {
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"http chunk: %d", ngx_buf_size(cl->buf));

size += ngx_buf_size(cl->buf); //循环统计出总的size大小

if (cl->buf->flush
|| cl->buf->sync
|| ngx_buf_in_memory(cl->buf)
|| cl->buf->in_file)
{
tl = ngx_alloc_chain_link(r->pool);
if (tl == NULL) {
return NGX_ERROR;
}
//这样会形成一条新的链,链首为out
tl->buf = cl->buf;
*ll = tl;
ll = &tl->next;
}

if (cl->next == NULL) {
break;
}

cl = cl->next;
}
/*每个分块包含一个长度值和该分块的数据.长度值是十六进制形式并以CRLF与数据分隔开.
分块中数据的大小以字节计数,不包括长度值与数据之间的CRLF序列以及分块结尾的CRLF序列*/
if (size) {
tl = ngx_chain_get_free_buf(r->pool, &ctx->free);
if (tl == NULL) {
return NGX_ERROR;
}

b = tl->buf;
chunk = b->start;

/*多次调用output_body_filter,chunk可能在之前已分配?
但是,如果tl是新分配的chunk怎么可能不是NULL呢?*/
if (chunk == NULL) {
/* the "0000000000000000" is 64-bit hexadecimal string */
chunk = ngx_palloc(r->pool, sizeof("0000000000000000" CRLF) - 1);
if (chunk == NULL) {
return NGX_ERROR;
}

b->start = chunk;
//有必要分配这么大吗,size有这么大吗?
b->end = chunk + sizeof("0000000000000000" CRLF) - 1;
}

b->tag = (ngx_buf_tag_t) &ngx_http_chunked_filter_module;
b->memory = 0;
b->temporary = 1;
b->pos = chunk;
//在一些实现中块大小和CRLF之间填充有白空格(0x20)
b->last = ngx_sprintf(chunk, "%xO" CRLF, size);//十六进制小写

tl->next = out; //这个才是重点,out是内容
out = tl;
}

if (cl->buf->last_buf) {
//fix the bug of giving chunk trailer when upstream aborts start
if(r->upstream != NULL && ngx_http_upstream_done(r) != NGX_OK)
{
return NGX_ERROR;
}
//fix the bug of giving chunk trailer when upstream aborts end
tl = ngx_chain_get_free_buf(r->pool, &ctx->free);
if (tl == NULL) {
return NGX_ERROR;
}

b = tl->buf;

b->tag = (ngx_buf_tag_t) &ngx_http_chunked_filter_module;
b->temporary = 0;
b->memory = 1;
b->last_buf = 1;
//以"0<CR><LF>"为结尾分块
b->pos = (u_char *) CRLF "0" CRLF CRLF; //前面的CRLF是承接上一个分块的
b->last = b->pos + 7;

//数据会被以多个chain传递给过滤器,last_buf字段为1表明这是最后一个buf
cl->buf->last_buf = 0; //为什么为0?

*ll = tl;

if (size == 0) {
b->pos += 2; //CRLF
}

} else if (size > 0) {
tl = ngx_chain_get_free_buf(r->pool, &ctx->free);
if (tl == NULL) {
return NGX_ERROR;
}

//中间块
b = tl->buf;

b->tag = (ngx_buf_tag_t) &ngx_http_chunked_filter_module;
b->temporary = 0;
b->memory = 1;
b->pos = (u_char *) CRLF;
b->last = b->pos + 2;

*ll = tl;

} else {
*ll = NULL;
}

rc = ngx_http_next_body_filter(r, out);

ngx_chain_update_chains(r->pool, &ctx->free, &ctx->busy, &out,
(ngx_buf_tag_t) &ngx_http_chunked_filter_module);

return rc;
}

static ngx_int_t
ngx_http_chunked_filter_init(ngx_conf_t *cf)
{
ngx_http_next_header_filter = ngx_http_top_header_filter;
ngx_http_top_header_filter = ngx_http_chunked_header_filter;

ngx_http_next_body_filter = ngx_http_top_body_filter;
ngx_http_top_body_filter = ngx_http_chunked_body_filter;

return NGX_OK;
}
---------------------
作者：昌山小屋
来源：CSDN
原文：https://blog.csdn.net/ChuiGeDaQiQiu/article/details/78301778
版权声明：本文为博主原创文章，转载请附上博文链接！