Nginx 过滤模块

// 在模块初始化函数中
ngx_http_next_header_filter = ngx_http_top_header_filter;
ngx_http_top_header_filter = my_header_filter;  // 插入Header过滤链

ngx_http_next_body_filter = ngx_http_top_body_filter;
ngx_http_top_body_filter = my_body_filter;      // 插入Body过滤链

// Header过滤函数
static ngx_int_t my_header_filter(ngx_http_request_t *r);

// Body过滤函数
static ngx_int_t my_body_filter(ngx_http_request_t *r, ngx_chain_t *in);

static ngx_int_t my_body_filter(ngx_http_request_t *r, ngx_chain_t *in) {
    // 处理逻辑...
    return ngx_http_next_body_filter(r, in);  // 关键！
}

// 过滤模块必有：
// Nginx的全局header过滤链入口指针，所有header过滤模块通过此链串联。
ngx_http_top_header_filter = my_header_filter;

static ngx_int_t my_postconfiguration(ngx_conf_t *cf) {
    ngx_http_handler_pt *h = ngx_array_push(&cmcf->phases[NGX_HTTP_CONTENT_PHASE].handlers);
    *h = my_content_handler;  // 模块的处理函数
    return NGX_OK;
}

static ngx_int_t my_header_filter(ngx_http_request_t *r) {
    // 修改响应头
    return ngx_http_next_header_filter(r);
}

static ngx_int_t my_body_filter(ngx_http_request_t *r, ngx_chain_t *in) {
    // 修改响应体
    return ngx_http_next_body_filter(r, in);
}

ngx_module_t ngx_http_xxx_module = {  // 模块变量名带 `http_` 前缀
    NGX_MODULE_V1,
    &ngx_http_xxx_module_ctx,          // 上下文
    ngx_http_xxx_commands,             // 指令集
    NGX_HTTP_MODULE,                   // 关键标记：必须是这个类型
    ...
};

~/nginx-1.0.14/objs/ngx_modules.c

ngx_module_t *ngx_modules[] = {
    &ngx_core_module,
    &ngx_errlog_module,
    &ngx_conf_module,
    &ngx_events_module,
    &ngx_event_core_module,
    &ngx_epoll_module,
    &ngx_http_module,
    &ngx_http_core_module,
    &ngx_http_log_module,
    &ngx_http_upstream_module,
    &ngx_http_static_module,
    &ngx_http_autoindex_module,
    &ngx_http_index_module,
    &ngx_http_auth_basic_module,
    &ngx_http_access_module,
    &ngx_http_limit_zone_module,
    &ngx_http_limit_req_module,
    &ngx_http_geo_module,
    &ngx_http_map_module,
    &ngx_http_split_clients_module,
    &ngx_http_referer_module,
    &ngx_http_rewrite_module,
    &ngx_http_proxy_module,
    &ngx_http_fastcgi_module,
    &ngx_http_uwsgi_module,
    &ngx_http_scgi_module,
    &ngx_http_memcached_module,
    &ngx_http_empty_gif_module,
    &ngx_http_browser_module,
    &ngx_http_upstream_ip_hash_module,
    &ngx_http_mytest_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_copy_filter_module,
    &ngx_http_range_body_filter_module,
    &ngx_http_not_modified_filter_module,
    NULL
};

// 示例数组结构（实际由configure生成）
ngx_module_t *ngx_modules[] = {
    &ngx_core_module,            // 核心模块1（最先加载）
    &ngx_http_core_module,       // HTTP核心模块
    &ngx_http_rewrite_module,    // 标准HTTP模块
    &my_custom_module,           // 第三方模块
    NULL                         // 数组结束
};

// nginx.c 中的初始化逻辑
for (i = 0; ngx_modules[i]; i++) {
    if (ngx_modules[i]->init_module) {
        ngx_modules[i]->init_module(cycle); // 绝对按数组顺序执行
    }
}

// ngx_http_block() 中的HTTP模块初始化
for (i = 0; ngx_modules[i]; i++) {
    if (ngx_modules[i]->type != NGX_HTTP_MODULE) continue;
    
    hmod = ngx_modules[i]->ctx;
    if (hmod->preconfiguration) hmod->preconfiguration(cf);  // 阶段1
    if (hmod->postconfiguration) hmod->postconfiguration(cf); // 阶段2
}

static ngx_http_module_t  ngx_http_mytest_module_ctx =
        {
                NULL,                              /* preconfiguration */
                NULL,                  	          /* 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 */
        };

// 当解析到http{}块时执行的伪代码（ngx_http_block函数简化版）
void ngx_http_block(ngx_conf_t *cf) {
    // 阶段1：调用所有HTTP模块的preconfiguration
    for (i = 0; ngx_modules[i]; i++) {
        if (ngx_modules[i]->type != NGX_HTTP_MODULE) continue;
        hmod = ngx_modules[i]->ctx;
        if (hmod->preconfiguration) {
            hmod->preconfiguration(cf);  // 此时尚未创建任何配置结构
        }
    }

    // 阶段2：创建配置结构（MAIN/SRV/LOC）
    for (i = 0; ngx_modules[i]; i++) {
        if (ngx_modules[i]->type != NGX_HTTP_MODULE) continue;
        hmod = ngx_modules[i]->ctx;
        
        if (hmod->create_main_conf) {
            ctx->main_conf[mi] = hmod->create_main_conf(cf);
        }
        if (hmod->create_srv_conf) {
            ctx->srv_conf[mi] = hmod->create_srv_conf(cf);
        }
        if (hmod->create_loc_conf) {
            ctx->loc_conf[mi] = hmod->create_loc_conf(cf);
        }
    }

    // 阶段3：解析server{}和location{}配置
    parse_servers_and_locations(cf);

    // 阶段4：调用所有HTTP模块的postconfiguration
    for (i = 0; ngx_modules[i]; i++) {
        if (ngx_modules[i]->type != NGX_HTTP_MODULE) continue;
        hmod = ngx_modules[i]->ctx;
        if (hmod->postconfiguration) {
            hmod->postconfiguration(cf);  // 此时所有配置已就绪
        }
    }
}

// config
HTTP_FILTER_MODULES="$HTTP_FILTER_MODULES ngx_http_myfilter_module"

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


typedef struct
{
    ngx_flag_t		enable;
} ngx_http_myfilter_conf_t;

typedef struct
{
    ngx_int_t   	add_prefix;
} ngx_http_myfilter_ctx_t;


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_str_t filter_prefix = ngx_string("[my filter prefix]");



static void* ngx_http_myfilter_create_conf(ngx_conf_t *cf);
static char *
ngx_http_myfilter_merge_conf(ngx_conf_t *cf, void *parent, void *child);

static ngx_int_t ngx_http_myfilter_init(ngx_conf_t *cf);
static ngx_int_t
ngx_http_myfilter_header_filter(ngx_http_request_t *r);
static ngx_int_t
ngx_http_myfilter_body_filter(ngx_http_request_t *r, ngx_chain_t *in);




static ngx_command_t  ngx_http_myfilter_commands[] =
        {
                {
                        ngx_string("add_prefix"),
                        NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_HTTP_LMT_CONF | NGX_CONF_FLAG,
                        ngx_conf_set_flag_slot,
                        NGX_HTTP_LOC_CONF_OFFSET,
                        offsetof(ngx_http_myfilter_conf_t, enable),
                        NULL
                },

                ngx_null_command
        };


static ngx_http_module_t  ngx_http_myfilter_module_ctx =
        {
                NULL,                                  /* preconfiguration方法  */
                ngx_http_myfilter_init,            /* postconfiguration方法 */

                NULL,                                  /*create_main_conf 方法 */
                NULL,                                  /* init_main_conf方法 */

                NULL,                                  /* create_srv_conf方法 */
                NULL,                                  /* merge_srv_conf方法 */

                ngx_http_myfilter_create_conf,    /* create_loc_conf方法 */
                ngx_http_myfilter_merge_conf      /*merge_loc_conf方法*/
        };


ngx_module_t  ngx_http_myfilter_module =
        {
                NGX_MODULE_V1,
                &ngx_http_myfilter_module_ctx,     /* module context */
                ngx_http_myfilter_commands,        /* 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_int_t ngx_http_myfilter_init(ngx_conf_t *cf)
{
    //插入到头部处理方法链表的首部
    ngx_http_next_header_filter = ngx_http_top_header_filter;
    ngx_http_top_header_filter = ngx_http_myfilter_header_filter;

    //插入到包体处理方法链表的首部
    ngx_http_next_body_filter = ngx_http_top_body_filter;
    ngx_http_top_body_filter = ngx_http_myfilter_body_filter;

    return NGX_OK;
}

static ngx_int_t
ngx_http_myfilter_header_filter(ngx_http_request_t *r)
{
    ngx_http_myfilter_ctx_t   *ctx;
    ngx_http_myfilter_conf_t  *conf;

    //如果不是返回成功，这时是不需要理会是否加前缀的，直接交由下一个过滤模块
    //处理响应码非200的情形
    if (r->headers_out.status != NGX_HTTP_OK)
    {
        return ngx_http_next_header_filter(r);
    }

    //获取http上下文
    ctx = ngx_http_get_module_ctx(r, ngx_http_myfilter_module);
    if (ctx)
    {
        //该请求的上下文已经存在，这说明
        // ngx_http_myfilter_header_filter已经被调用过1次，
        //直接交由下一个过滤模块处理
        return ngx_http_next_header_filter(r);
    }

    //获取存储配置项的ngx_http_myfilter_conf_t结构体
    conf = ngx_http_get_module_loc_conf(r, ngx_http_myfilter_module);

    //如果enable成员为0，也就是配置文件中没有配置add_prefix配置项，
    //或者add_prefix配置项的参数值是off，这时直接交由下一个过滤模块处理
    if (conf->enable == 0)
    {
        return ngx_http_next_header_filter(r);
    }

    //构造http上下文结构体ngx_http_myfilter_ctx_t
    ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_myfilter_ctx_t));
    if (ctx == NULL)
    {
        return NGX_ERROR;
    }

    //add_prefix为0表示不加前缀
    ctx->add_prefix = 0;

    //将构造的上下文设置到当前请求中
    ngx_http_set_ctx(r, ctx, ngx_http_myfilter_module);

    //myfilter过滤模块只处理Content-Type是"text/plain"类型的http响应
    if (r->headers_out.content_type.len >= sizeof("text/plain") - 1
        && ngx_strncasecmp(r->headers_out.content_type.data, (u_char *) "text/plain", sizeof("text/plain") - 1) == 0)
    {
        //1表示需要在http包体前加入前缀
        ctx->add_prefix = 1;

        //如果处理模块已经在Content-Length写入了http包体的长度，由于
        //我们加入了前缀字符串，所以需要把这个字符串的长度也加入到
        //Content-Length中
        if (r->headers_out.content_length_n > 0)
            r->headers_out.content_length_n += filter_prefix.len;
    }

    //交由下一个过滤模块继续处理
    return ngx_http_next_header_filter(r);
}


static ngx_int_t
ngx_http_myfilter_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
{
    ngx_http_myfilter_ctx_t   *ctx;
    ctx = ngx_http_get_module_ctx(r, ngx_http_myfilter_module);
    //如果获取不到上下文，或者上下文结构体中的add_prefix为0或者2时，
    //都不会添加前缀，这时直接交给下一个http过滤模块处理
    if (ctx == NULL || ctx->add_prefix != 1)
    {
        return ngx_http_next_body_filter(r, in);
    }

    //将add_prefix设置为2，这样即使ngx_http_myfilter_body_filter
    //再次回调时，也不会重复添加前缀
    ctx->add_prefix = 2;

    //从请求的内存池中分配内存，用于存储字符串前缀
    ngx_buf_t* b = ngx_create_temp_buf(r->pool, filter_prefix.len);
    //将ngx_buf_t中的指针正确地指向filter_prefix字符串
    b->start = b->pos = filter_prefix.data;
    b->last = b->pos + filter_prefix.len;

    //从请求的内存池中生成ngx_chain_t链表，将刚分配的ngx_buf_t设置到
    //其buf成员中，并将它添加到原先待发送的http包体前面
    ngx_chain_t *cl = ngx_alloc_chain_link(r->pool);
    cl->buf = b;
    cl->next = in;

    //调用下一个模块的http包体处理方法，注意这时传入的是新生成的cl链表
    return ngx_http_next_body_filter(r, cl);
}


static void* ngx_http_myfilter_create_conf(ngx_conf_t *cf)
{
    ngx_http_myfilter_conf_t  *mycf;

    //创建存储配置项的结构体
    mycf = (ngx_http_myfilter_conf_t  *)ngx_pcalloc(cf->pool, sizeof(ngx_http_myfilter_conf_t));
    if (mycf == NULL)
    {
        return NULL;
    }

    //ngx_flat_t类型的变量，如果使用预设函数ngx_conf_set_flag_slot
    //解析配置项参数，必须初始化为NGX_CONF_UNSET
    mycf->enable = NGX_CONF_UNSET;

    return mycf;
}

static char *
ngx_http_myfilter_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_http_myfilter_conf_t *prev = (ngx_http_myfilter_conf_t *)parent;
    ngx_http_myfilter_conf_t *conf = (ngx_http_myfilter_conf_t *)child;

//合并ngx_flat_t类型的配置项enable
    ngx_conf_merge_value(conf->enable, prev->enable, 0);

    return NGX_CONF_OK;
}