Nginx 源码分析（9）——filter模块

最新推荐文章于 2022-09-26 17:33:28 发布
最新推荐文章于 2022-09-26 17:33:28 发布
阅读量118 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： 运维 数据结构与算法
原文链接：http://www.cnblogs.com/wenchuanchuangz/archive/2012/11/15/2772379.html
本文详细阐述了nginx中响应内容的输出流程，包括header和body的生成与发送，以及如何通过filter模块进行定制化处理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

        phase handler处理中介绍了content handler用于产生响应内容，随便找一个content phase的模块，比如：ngx_http_static_module.c，会发现在content handler中会调用ngx_http_send_header，然后最后调用ngx_http_output_filter。这两个函数就是发送响应头部和响应体的，在nginx中输出内容是通过filter完成的。

        filter模块用于过滤和输出响应内容，nginx将所有的filter组织成只有头结点的单链表（实际上就是栈），这个头结点分别是ngx_http_top_header_filter（过滤头部）和ngx_http_top_body_filter（过滤响应体）。在每次初始化一个filter模块时，都会将当前filter链表的头结点ngx_http_top_header_filter和ngx_http_top_body_filter分别保存为ngx_http_next_header_filter和ngx_http_next_body_filter，同时将本模块的filter函数保存为ngx_http_top_header_filter和ngx_http_top_body_filter，然后在本模块filter函数的最后部分调用ngx_http_next_header_filter和ngx_http_next_body_filter，这样就实现了所有filter模块的链式调用。由于filter模块的添加实际上就是不停的向链表的头push节点，所以后添加的模块比先添加的模块在filter链中靠前。

        先看一下ngx_http_send_header函数：

 

[cpp] view plaincopyprint?
  1. ngx_int_t 
  2. ngx_http_send_header(ngx_http_request_t *r) 
  3. { 
  4.     if (r->err_status) { 
  5.         r->headers_out.status = r->err_status; 
  6.         r->headers_out.status_line.len = 0; 
  7.     } 
  8.  
  9.     return ngx_http_top_header_filter(r); 
  10. }  
ngx_int_t
ngx_http_send_header(ngx_http_request_t *r)
{
    if (r->err_status) {
        r->headers_out.status = r->err_status;
        r->headers_out.status_line.len = 0;
    }

    return ngx_http_top_header_filter(r);
}
        实现很简单，就是调用ngx_http_top_header_filter函数，然后这个函数后调用接下来的filter直到filter链遍历完为止。ngx_http_output_filter与之类似，调用ngx_http_top_body_filter。

 

        filter的添加都是在http模块的postconfiguration回调函数中完成的，这部分调用是在ngx_http_block中：

 

[cpp] view plaincopyprint?
  1. for (m = 0; ngx_modules[m]; m++) { 
  2.     if (ngx_modules[m]->type != NGX_HTTP_MODULE) { 
  3.         continue; 
  4.     } 
  5.  
  6.     module = ngx_modules[m]->ctx; 
  7.  
  8.     if (module->postconfiguration) { 
  9.         if (module->postconfiguration(cf) != NGX_OK) { 
  10.             return NGX_CONF_ERROR; 
  11.         } 
  12.     } 
  13. }  
    for (m = 0; ngx_modules[m]; m++) {
        if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
            continue;
        }

        module = ngx_modules[m]->ctx;

        if (module->postconfiguration) {
            if (module->postconfiguration(cf) != NGX_OK) {
                return NGX_CONF_ERROR;
            }
        }
    }

        回调函数的调用顺序是遍历ngx_modules数组，然后逐一调用postconfiguration函数，那么filter模块在ngx_modules数组中的顺序就决定了其filter函数在filter链中位置。下面是ngx_modules数组的内容：

 

[cpp] view plaincopyprint?
  1. ngx_module_t *ngx_modules[] = { 
  2.     &ngx_core_module, 
  3.     //……  
  4.     &ndk_http_module, 
  5.     &ngx_http_write_filter_module, 
  6.     &ngx_http_header_filter_module, 
  7.     &ngx_http_chunked_filter_module, 
  8.     &ngx_http_range_header_filter_module, 
  9.     &ngx_http_gzip_filter_module, 
  10.     &ngx_http_postpone_filter_module, 
  11.     &ngx_http_ssi_filter_module, 
  12.     &ngx_http_charset_filter_module, 
  13.     &ngx_http_userid_filter_module, 
  14.     &ngx_http_headers_filter_module, 
  15.     &ngx_http_set_misc_module, 
  16.     &ngx_http_echo_module, 
  17.     &ngx_http_copy_filter_module, 
  18.     &ngx_http_range_body_filter_module, 
  19.     &ngx_http_not_modified_filter_module, 
  20.     NULL 
  21. };  
ngx_module_t *ngx_modules[] = {
    &ngx_core_module,
    //……
    &ndk_http_module,
    &ngx_http_write_filter_module,
    &ngx_http_header_filter_module,
    &ngx_http_chunked_filter_module,
    &ngx_http_range_header_filter_module,
    &ngx_http_gzip_filter_module,
    &ngx_http_postpone_filter_module,
    &ngx_http_ssi_filter_module,
    &ngx_http_charset_filter_module,
    &ngx_http_userid_filter_module,
    &ngx_http_headers_filter_module,
    &ngx_http_set_misc_module,
    &ngx_http_echo_module,
    &ngx_http_copy_filter_module,
    &ngx_http_range_body_filter_module,
    &ngx_http_not_modified_filter_module,
    NULL
};
        可以看到ngx_http_write_filter_module和ngx_http_header_filter_module两个模块是最靠前的两个filter模块，所以它们处于filter链的最末尾，也就是最后执行。这两个模块就是用来输出header和body的，下面具体分析一下ngx_http_write_filter_module，ngx_http_header_filter_module与之类似。

 

        ngx_http_write_filter_module模块用于输出响应体，在调用时需要传入两个参数ngx_request_t和ngx_chain_t，第一个就是请求，第二个参数是输出内容的buffer链表，通过buffer的last字段标识最后一个buffer。这个模块的filter函数是ngx_http_write_filter，完成的功能很简单就是遍历buffer链表，然后输出响应内容。这里还需要注意一点，ngx_request_t有个out字段用来保存上一次没有发送的chain，当接收到新chain时，需要将新chain连接到旧chain。下面看一下代码。

 

[cpp] view plaincopyprint?
  1. c = r->connection; 
  2.  
  3. if (c->error) { 
  4.     return NGX_ERROR; 
  5. } 
  6.  
  7. size = 0;       /* 待输出的内容的大小 */ 
  8. flush = 0;      /* 是否需要flush */ 
  9. last = 0;       /* 是否是最后一个buffer */ 
  10. ll = &r->out;    /* 保存上次没有输出的ngx_buf_t */  
    c = r->connection;

    if (c->error) {
        return NGX_ERROR;
    }

    size = 0;		/* 待输出的内容的大小 */
    flush = 0;		/* 是否需要flush */
    last = 0;		/* 是否是最后一个buffer */
    ll = &r->out;	/* 保存上次没有输出的ngx_buf_t */
        这里对使用的变量初始化。
[cpp] view plaincopyprint?
  1. /* find the size, the flush point and the last link of the saved chain */ 
  2. for (cl = r->out; cl; cl = cl->next) { 
  3.     ll = &cl->next; 
  4.  
  5.     ngx_log_debug7(NGX_LOG_DEBUG_EVENT, c->log, 0, 
  6.                    "write old buf t:%d f:%d %p, pos %p, size: %z " 
  7.                    "file: %O, size: %z", 
  8.                    cl->buf->temporary, cl->buf->in_file, 
  9.                    cl->buf->start, cl->buf->pos, 
  10.                    cl->buf->last - cl->buf->pos, 
  11.                    cl->buf->file_pos, 
  12.                    cl->buf->file_last - cl->buf->file_pos); 
  13.  
  14. 1 
  15.     // ……  
  16. dif 
  17.  
  18.     size += ngx_buf_size(cl->buf); 
  19.  
  20.     if (cl->buf->flush || cl->buf->recycled) { 
  21.         flush = 1; 
  22.     } 
  23.  
  24.     if (cl->buf->last_buf) { 
  25.         last = 1; 
  26.     } 
  27. }  
    /* find the size, the flush point and the last link of the saved chain */
    for (cl = r->out; cl; cl = cl->next) {
        ll = &cl->next;

        ngx_log_debug7(NGX_LOG_DEBUG_EVENT, c->log, 0,
                       "write old buf t:%d f:%d %p, pos %p, size: %z "
                       "file: %O, size: %z",
                       cl->buf->temporary, cl->buf->in_file,
                       cl->buf->start, cl->buf->pos,
                       cl->buf->last - cl->buf->pos,
                       cl->buf->file_pos,
                       cl->buf->file_last - cl->buf->file_pos);

 #if 1
        // ……
 #endif

        size += ngx_buf_size(cl->buf);

        if (cl->buf->flush || cl->buf->recycled) {
            flush = 1;
        }

        if (cl->buf->last_buf) {
            last = 1;
        }
    }
        这段代码统计上次没有发送的chain的大小，以及是否需要flush还有是不是最后一个buffer。
[cpp] view plaincopyprint?
  1.     /* add the new chain to the existent one */ 
  2.  
  3.     for (ln = in; ln; ln = ln->next) { 
  4.         cl = ngx_alloc_chain_link(r->pool); 
  5.         if (cl == NULL) { 
  6.             return NGX_ERROR; 
  7.         } 
  8.  
  9.         cl->buf = ln->buf; 
  10.         /* ll原本保存的是old buf的最后一个节点的next的地址，这里会将new buf连接到old buf后 */ 
  11.         *ll = cl; 
  12.         ll = &cl->next; 
  13.  
  14.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, c->log, 0, 
  15.                        "write new buf t:%d f:%d %p, pos %p, size: %z " 
  16.                        "file: %O, size: %z", 
  17.                        cl->buf->temporary, cl->buf->in_file, 
  18.                        cl->buf->start, cl->buf->pos, 
  19.                        cl->buf->last - cl->buf->pos, 
  20.                        cl->buf->file_pos, 
  21.                        cl->buf->file_last - cl->buf->file_pos); 
  22.  
  23. #if 1  
  24.         // ……  
  25. #endif  
  26.  
  27.         size += ngx_buf_size(cl->buf); 
  28.  
  29.         if (cl->buf->flush || cl->buf->recycled) { 
  30.             flush = 1; 
  31.         } 
  32.  
  33.         /* 需要输出的最后一个buf */ 
  34.         if (cl->buf->last_buf) { 
  35.             last = 1; 
  36.         } 
  37.     }  
    /* add the new chain to the existent one */

    for (ln = in; ln; ln = ln->next) {
        cl = ngx_alloc_chain_link(r->pool);
        if (cl == NULL) {
            return NGX_ERROR;
        }

        cl->buf = ln->buf;
        /* ll原本保存的是old buf的最后一个节点的next的地址，这里会将new buf连接到old buf后 */
        *ll = cl;
        ll = &cl->next;

        ngx_log_debug7(NGX_LOG_DEBUG_EVENT, c->log, 0,
                       "write new buf t:%d f:%d %p, pos %p, size: %z "
                       "file: %O, size: %z",
                       cl->buf->temporary, cl->buf->in_file,
                       cl->buf->start, cl->buf->pos,
                       cl->buf->last - cl->buf->pos,
                       cl->buf->file_pos,
                       cl->buf->file_last - cl->buf->file_pos);

#if 1
        // ……
#endif

        size += ngx_buf_size(cl->buf);

        if (cl->buf->flush || cl->buf->recycled) {
            flush = 1;
        }

        /* 需要输出的最后一个buf */
        if (cl->buf->last_buf) {
            last = 1;
        }
    }
        将新chain添加的旧chain后，并统计size、flush和last。         接下来就是对chain进行处理，这会涉及一些标记，先来处理一下它们：

 

        1. clcf->postpone_output：由于处理postpone_output指令，用于设置延时输出的阈值。比如指令“postpone s”，当输出内容的size小于s，并且不是最后一个buffer，也不需要flush，那么就延时输出。

        2. c->write->delayed：表示当前连接是否因为某种原因需要延时输出，比如超过发送速率限制等，只有在其他地方取消delayed标记后才能继续输出。在delayed设置的情况下，需要设置c->buffered，并返回NGX_AGAIN。

        3. c->buffered：在buffer没有输出完的情况下，标记具体在哪个模块被buffer住了。buffered的取值：

 

[cpp] view plaincopyprint?
  1. #define NGX_HTTP_LOWLEVEL_BUFFERED         0xf0  
  2. #define NGX_HTTP_WRITE_BUFFERED            0x10  
  3. #define NGX_HTTP_GZIP_BUFFERED             0x20  
  4. #define NGX_HTTP_SSI_BUFFERED              0x01  
  5. #define NGX_HTTP_SUB_BUFFERED              0x02  
  6. #define NGX_HTTP_COPY_BUFFERED             0x04  
#define NGX_HTTP_LOWLEVEL_BUFFERED         0xf0
#define NGX_HTTP_WRITE_BUFFERED            0x10
#define NGX_HTTP_GZIP_BUFFERED             0x20
#define NGX_HTTP_SSI_BUFFERED              0x01
#define NGX_HTTP_SUB_BUFFERED              0x02
#define NGX_HTTP_COPY_BUFFERED             0x04
        4. r->limit_rate：对应limit_rate指令，表示request的发送速率限制值。一般地，通过这个值去设置c->write->delayed，当发送速率超过limit时就会设置c->write->delayed，这种情况下就会延迟发送，从而降低request的发送速率。

 

 

[cpp] view plaincopyprint?
  1. /*
  2. * avoid the output if there are no last buf, no flush point,
  3. * there are the incoming bufs and the size of all bufs
  4. * is smaller than "postpone_output" directive
  5. */ 
  6.  
  7. /* 在不是最后一个buf，并且不需要flush的情况下，postpone_output指令可以设置当响应内容小于某个值时，延时输出 */ 
  8. if (!last && !flush && in && size < (off_t) clcf->postpone_output) { 
  9.     return NGX_OK; 
  10. } 
  11.  
  12. /* 请求被delay，设置buffered标记，直接返回 */ 
  13. if (c->write->delayed) { 
  14.     c->buffered |= NGX_HTTP_WRITE_BUFFERED; 
  15.     return NGX_AGAIN; 
  16. } 
  17.  
  18. /* 输出内容大小为0，并且没有设置buffered标记，进入清理工作 */ 
  19. if (size == 0 && !(c->buffered & NGX_LOWLEVEL_BUFFERED)) { 
  20.  
  21.     /* 如果是最后一个标记，清空buffered标记 */ 
  22.     if (last) { 
  23.         r->out = NULL; 
  24.         c->buffered &= ~NGX_HTTP_WRITE_BUFFERED; 
  25.  
  26.         return NGX_OK; 
  27.     } 
  28.  
  29.     /* 如果需要flush */ 
  30.     if (flush) { 
  31.  
  32.         /* 这块不清楚干什么用的 */ 
  33.         do { 
  34.             r->out = r->out->next; 
  35.         } while (r->out); 
  36.  
  37.         /* 清空buffered标记 */ 
  38.         c->buffered &= ~NGX_HTTP_WRITE_BUFFERED; 
  39.  
  40.         return NGX_OK; 
  41.     } 
  42.  
  43.     ngx_log_error(NGX_LOG_ALERT, c->log, 0, 
  44.                   "the http output chain is empty"); 
  45.  
  46.     ngx_debug_point(); 
  47.  
  48.     return NGX_ERROR; 
  49. } 
  50.  
  51. /* 设置了limit rate */ 
  52. if (r->limit_rate) { 
  53.     limit = r->limit_rate * (ngx_time() - r->start_sec + 1) 
  54.             - (c->sent - clcf->limit_rate_after); 
  55.  
  56.     /* 超出发送速率限制 */ 
  57.     if (limit <= 0) { 
  58.         /* 设置delayed标记，延迟发送请求 */ 
  59.         c->write->delayed = 1; 
  60.         ngx_add_timer(c->write, 
  61.                       (ngx_msec_t) (- limit * 1000 / r->limit_rate + 1)); 
  62.  
  63.         /* 设置buffered标记 */ 
  64.         c->buffered |= NGX_HTTP_WRITE_BUFFERED; 
  65.  
  66.         return NGX_AGAIN; 
  67.     } 
  68.  
  69. } elseif (clcf->sendfile_max_chunk) { 
  70.     /* sendfile用的的limit */ 
  71.     limit = clcf->sendfile_max_chunk; 
  72.  
  73. } else { 
  74.     limit = 0; 
  75. }  
    /*
     * avoid the output if there are no last buf, no flush point,
     * there are the incoming bufs and the size of all bufs
     * is smaller than "postpone_output" directive
     */

    /* 在不是最后一个buf，并且不需要flush的情况下，postpone_output指令可以设置当响应内容小于某个值时，延时输出 */
    if (!last && !flush && in && size < (off_t) clcf->postpone_output) {
        return NGX_OK;
    }

    /* 请求被delay，设置buffered标记，直接返回 */
    if (c->write->delayed) {
        c->buffered |= NGX_HTTP_WRITE_BUFFERED;
        return NGX_AGAIN;
    }

    /* 输出内容大小为0，并且没有设置buffered标记，进入清理工作 */
    if (size == 0 && !(c->buffered & NGX_LOWLEVEL_BUFFERED)) {

    	/* 如果是最后一个标记，清空buffered标记 */
        if (last) {
            r->out = NULL;
            c->buffered &= ~NGX_HTTP_WRITE_BUFFERED;

            return NGX_OK;
        }

        /* 如果需要flush */
        if (flush) {

        	/* 这块不清楚干什么用的 */
            do {
                r->out = r->out->next;
            } while (r->out);

            /* 清空buffered标记 */
            c->buffered &= ~NGX_HTTP_WRITE_BUFFERED;

            return NGX_OK;
        }

        ngx_log_error(NGX_LOG_ALERT, c->log, 0,
                      "the http output chain is empty");

        ngx_debug_point();

        return NGX_ERROR;
    }

    /* 设置了limit rate */
    if (r->limit_rate) {
        limit = r->limit_rate * (ngx_time() - r->start_sec + 1)
                - (c->sent - clcf->limit_rate_after);

        /* 超出发送速率限制 */
        if (limit <= 0) {
        	/* 设置delayed标记，延迟发送请求 */
            c->write->delayed = 1;
            ngx_add_timer(c->write,
                          (ngx_msec_t) (- limit * 1000 / r->limit_rate + 1));

            /* 设置buffered标记 */
            c->buffered |= NGX_HTTP_WRITE_BUFFERED;

            return NGX_AGAIN;
        }

    } else if (clcf->sendfile_max_chunk) {
    	/* sendfile用的的limit */
        limit = clcf->sendfile_max_chunk;

    } else {
        limit = 0;
    }
        这段代码根据上述标记进行一些处理，具体看注释。接下来就是发送数据的过程以及后续处理。
[cpp] view plaincopyprint?
  1. sent = c->sent; 
  2.  
  3. ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, 
  4.                "http write filter limit %O", limit); 
  5.  
  6. /* send_chain返回的是没有发完的chain */ 
  7. chain = c->send_chain(c, r->out, limit); 
  8.  
  9. ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, 
  10.                "http write filter %p", chain); 
  11.  
  12. if (chain == NGX_CHAIN_ERROR) { 
  13.     c->error = 1; 
  14.     return NGX_ERROR; 
  15. } 
  16.  
  17. /* 对limit_rate处理，可能会设置delayed标记 */ 
  18. if (r->limit_rate) { 
  19.  
  20.     nsent = c->sent; 
  21.  
  22.     if (clcf->limit_rate_after) { 
  23.  
  24.         sent -= clcf->limit_rate_after; 
  25.         if (sent < 0) { 
  26.             sent = 0; 
  27.         } 
  28.  
  29.         nsent -= clcf->limit_rate_after; 
  30.         if (nsent < 0) { 
  31.             nsent = 0; 
  32.         } 
  33.     } 
  34.  
  35.     delay = (ngx_msec_t) ((nsent - sent) * 1000 / r->limit_rate + 1); 
  36.  
  37.     if (delay > 0) { 
  38.         c->write->delayed = 1; 
  39.         ngx_add_timer(c->write, delay); 
  40.     } 
  41.  
  42. } elseif (c->write->ready 
  43.            && clcf->sendfile_max_chunk 
  44.            && (size_t) (c->sent - sent) 
  45.                   >= clcf->sendfile_max_chunk - 2 * ngx_pagesize) 
  46. { 
  47.     c->write->delayed = 1; 
  48.     ngx_add_timer(c->write, 1); 
  49. } 
  50.  
  51. /* 释放已经发送的chain的内存 */ 
  52. for (cl = r->out; cl && cl != chain; /* void */) { 
  53.     ln = cl; 
  54.     cl = cl->next; 
  55.     ngx_free_chain(r->pool, ln); 
  56. } 
  57.  
  58. /* 重新赋值尚未发送的chain */ 
  59. r->out = chain; 
  60.  
  61. /* 如果chain不为空，那么buf没有发送完，需要设置buffered标记，并返回NGX_AGAIN */ 
  62. if (chain) { 
  63.     c->buffered |= NGX_HTTP_WRITE_BUFFERED; 
  64.     return NGX_AGAIN; 
  65. } 
  66.  
  67. /* 如果已经没有未发送的chain，就清空buffered标记 */ 
  68. c->buffered &= ~NGX_HTTP_WRITE_BUFFERED; 
  69.  
  70. /* 如果其他filter模块buffer了chain并且postponed为NULL，那么返回NGX_AGAIN，需要继续处理buf */ 
  71. if ((c->buffered & NGX_LOWLEVEL_BUFFERED) && r->postponed == NULL) { 
  72.     return NGX_AGAIN; 
  73. } 
  74.  
  75. return NGX_OK;  
    sent = c->sent;

    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
                   "http write filter limit %O", limit);

    /* send_chain返回的是没有发完的chain */
    chain = c->send_chain(c, r->out, limit);

    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
                   "http write filter %p", chain);

    if (chain == NGX_CHAIN_ERROR) {
        c->error = 1;
        return NGX_ERROR;
    }

    /* 对limit_rate处理，可能会设置delayed标记 */
    if (r->limit_rate) {

        nsent = c->sent;

        if (clcf->limit_rate_after) {

            sent -= clcf->limit_rate_after;
            if (sent < 0) {
                sent = 0;
            }

            nsent -= clcf->limit_rate_after;
            if (nsent < 0) {
                nsent = 0;
            }
        }

        delay = (ngx_msec_t) ((nsent - sent) * 1000 / r->limit_rate + 1);

        if (delay > 0) {
            c->write->delayed = 1;
            ngx_add_timer(c->write, delay);
        }

    } else if (c->write->ready
               && clcf->sendfile_max_chunk
               && (size_t) (c->sent - sent)
                      >= clcf->sendfile_max_chunk - 2 * ngx_pagesize)
    {
        c->write->delayed = 1;
        ngx_add_timer(c->write, 1);
    }

    /* 释放已经发送的chain的内存 */
    for (cl = r->out; cl && cl != chain; /* void */) {
        ln = cl;
        cl = cl->next;
        ngx_free_chain(r->pool, ln);
    }

    /* 重新赋值尚未发送的chain */
    r->out = chain;

    /* 如果chain不为空，那么buf没有发送完，需要设置buffered标记，并返回NGX_AGAIN */
    if (chain) {
        c->buffered |= NGX_HTTP_WRITE_BUFFERED;
        return NGX_AGAIN;
    }

    /* 如果已经没有未发送的chain，就清空buffered标记 */
    c->buffered &= ~NGX_HTTP_WRITE_BUFFERED;

    /* 如果其他filter模块buffer了chain并且postponed为NULL，那么返回NGX_AGAIN，需要继续处理buf */
    if ((c->buffered & NGX_LOWLEVEL_BUFFERED) && r->postponed == NULL) {
        return NGX_AGAIN;
    }

    return NGX_OK;
        上面就是ngx_http_write_filter的处理过程，ngx_http_header_filter与之类似，只是它处理的是响应头，然后在最后也是通过ngx_http_write_filter输出。

转载于:https://www.cnblogs.com/wenchuanchuangz/archive/2012/11/15/2772379.html

nginx http处理（write_filter响应数据发送过滤器）
huzilinitachi的专栏
04-18 2734
        作为处理相应数据过滤器，ngx_http_write_filter_module起到了收集响应数据（包含buffer缓冲数据及本地文件 本地文件包含实际的静态文件及缓存文件）、使用定时器设置响应限速延时的功能。        ngx_http_write_filter_module也是使用top_body_filter来挂载在body_filter链来处理的，不过write_fil...
nginx源码分析（7）——请求处理
架构师专栏
10-09 9356
在建立连接过程中，对于nginx监听到的每个客户端连接，都会将它的读事件的handler设置为ngx_http_init_request函数，这个函数就是请求处理的入口。在处理请求时，主要就是要解析http请求，比如：uri，请求行等，然后再根据请求生成响应。下面看一下nginx处理的具体过程。 1. ngx_http_init_request         在ngx_http_in
nginx源码分析（9）——filter模块
架构师专栏
10-11 7775
phase handler处理中介绍了content handler用于产生响应内容，随便找一个content phase的模块，比如：ngx_http_static_module.c，会发现在content handler中会调用ngx_http_send_header，然后最后调用ngx_http_output_filter。这两个函数就是发送响应头部和响应体的，在nginx中输出内容是通过f
ngx_http_output_filter
Edidaughter的博客
06-12 610
nginx
[nginx源码分析]nginx filter模块解析
Ubuntu黑客
05-07 1082
nginx源码分析
Nginx开发从入门到精通（三）：过滤模块
阿利的技术积累
03-06 846
过滤模块简介 (90%) 执行时间和内容 (90%) 过滤（filter）模块是过滤响应头和内容的模块，可以对回复的头和内容进行处理。它的处理时间在获取回复内容之后，向用户发送响应之前。它的处理过程分为两个阶段，过滤HTTP回复的头部和主体，在这两个阶段可以分别对头部和主体进行修改。 在代码中有类似的函数： ngx_http_top_header_filter(r); ng
nginx源码分析（5）——监听socket初始化
架构师专栏
07-18 1万+
在nginx源码分析（4）中，看到了nginx的事件模型，但其中没有介绍监听socket的初始化。而对于web server来说，需要通过监听socket来监听客户端的连接等。本篇将会具体介绍这方面的内容。还记得在前文介绍ngx_cycle_t结构时，它具有一个listening属性，是一个数组，存储所有监听socket，下面就来看看这些信息是什么时候添加的、以及如何初始化的。 1. 重要的数据
nginx源码分析（1）——启动过程
架构师专栏
07-09 8084
1. 重要的数据结构         1. ngx_module_t         nginx中所有模块的类型都是ngx_module_t类型的，定义了模块的一些属性。nginx是完全模块化的，所有的组件都是模块，从而实现了nginx的高度松耦合。同时，我们在进行nginx模块开发时，也离不开这个数据结构。 struct ngx_module_s { /** * 在具体类
nginx源码分析（8）——phase handler处理
架构师专栏
10-10 9365
nginx将请求的处理过程划分为11个phase（阶段），相当于是对请求处理的一种抽象，便于定制处理过程。这个11个phase，分别是（定义在http/ngx_http_core_module.h）： typedef enum { NGX_HTTP_POST_READ_PHASE = 0, /* 读取请求 */ NGX_HTTP_SERVER_REWRITE_PHAS
nginx源码分析—模块及其初始化
热门推荐
学习，思考，记录，分享。
06-28 4万+
本博客（http://blog.youkuaiyun.com/livelylittlefish）贴出作者（阿波）相关研究、学习内容所做的笔记，欢迎广大朋友指正！Content0. 序1. nginx有哪些模块？2. nginx如何描述这些模块？2.1 模块数据结构2.1.1 ngx_module_t结构2.1.2 ngx_command_t结构2.2 模块类图3. nginx如何组织这些模块？3.1 全局数组
【Nginx】开发一个HTTP过滤模块
aodiyi6351的博客
07-24 119
与HTTP处理模块不同。HTTP过滤模块的工作是对发送给用户的HTTP响应做一些加工。server返回的一个响应能够被随意多个HTTP过滤模块以流水线的方式依次处理。HTTP响应分为头部和包体，ngx_http_send_header和ngx_http_output_filter函数分别负责发送头部和包体。它们会依次调用各个过滤模块对待发送的响应进行处理。 HTTP过滤...
Nginx深入详解之过滤模块
zhangge3663的博客
09-30 4742
一、模块简介     过滤(filter)模块是过滤响应头和内容的模块，可以对回复的头和内容进行处理。它的处理时间在获取回复内容之后，向用户发送响应之前。它的处理过程分为两个阶段，过滤HTTP回复和头部和主体，在这两个阶段可以分别对头部和主体进行修改。下面函数就是分别对头部和主体进行过滤的函数，所有模块的响应内容要返回给客户端，都必须调用这两个接口:     ngx_http_top_head...
Nginx之HTTP过滤模块
weixin_30919919的博客
06-30 94
1. HTTP 过滤模块 ngx_http_not_modified_module 仅对 HTTP 头部做处理。在返回 200 成功时，根据请求中 If-Modified-Since 或者 If-Unmodified-Since 头部取得浏览器缓存文件的时间，再分析返回用户文件的最后修改时间，以此决定是否直接发送 304 Not Modified 响应给用户。 ngx_http_range_bod...
NGINX源码之：filter机制
qq_22351805的博客
09-26 988
NGINX源码解读，ngx_http_send_header、ngx_http_output_filter、ngx_linux_sendfile_chain、
Nginx开发一个简单的HTTP过滤模块
zhangge3663的博客
04-29 542
本文将学些开发一个简单的HTTP过滤模块，它能够对Content-Type为text/plain的包体前加上前缀字符串prefix.&lt;一&gt; 过滤模块的调用顺序过滤模块可以叠加，也就是说一个请求会被所有的HTTP过滤模块依次处理。过滤模块的调用时有顺序的，它的顺序在编译的时候就决定了。控制编译的脚本位于auto/modules中，当你编译完Nginx以后，可以再objs目录下面看到一个n...
nginx http处理（postpone延迟处理过滤器）
huzilinitachi的专栏
04-17 2384
        ngx_http_postpone_filter_module 用于处理延时的http请求（主要是子请求配置的）。postpone过滤器发生的时间点在处理响应包体时，这也是这个模块名称的由来。延时处理过滤功能和子请求之间的联系在点击打开链接子请求的说明里。        postpone的处理流程也比较简单：先配置top_body_filter处理函数指针，然后再通过配置的函数处理...
nginx 学习五 filter模块简介和实现一个简单的filter模块
yanziguilai的专栏
09-26 3814
1 nginx过滤模块简介 过滤（filter）模块是过滤响应头和内容的模块，可以对回复的头和内容进行处理。它的处理时间在获取回复内容之后， 向用户发送响应之前。它的处理过程分为两个阶段，过滤HTTP回复的头部和主体，在这两个阶段可以分别对头部和主体 进行修改。 2 过滤模块执行顺序 2.1 ngx_http_output_(head, body)_filter_pt 先看一下ng
NGINX输出问题解决过程
Besko的博客
08-15 2159
发现在编译了新写的ngx_http_nc_module时，以前的nginx_hello_module失效了，甚至连nginx的欢迎页面也进不去，打开浏览器的调试工具发现一直处于pending状态，真是让人费解。 经过导师的帮助，通过gdb调试时发现，在nginx的ngx_http_core_module中的ngx_http_core_run_phases函数，调用了如下方法， ...
Nginx源码架构与核心模块分析
Nginx源码分析 Nginx源码分析是对Nginx源代码的深入分析，涵盖了Nginx代码的目录和结构、基本数据结构、Nginx的core module结构和运行机制、Nginx的http module结构和运行机制等方面。 **Nginx代码的目录和结构** ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值