[nginx源码分析]nginx handler 模块解析

nginx除去配置解析和初始化，就是根据请求根据状态机一步步执行流程，那么本节主要讲解首先是整个nginx对于一个客户端请求大致请求流程，其次是根据这个流程来写自己的handler模块。

nginx接受到一个client请求调用流程：

1 ngx_event_accept主要是accept连接生成并初始化connection

2 ngx_http_init_connection 函数主要设置rev和wev事件回调函数

3 ngx_http_init_request 初始化request

4 ngx_http_process_request_line 处理请求line

5 ngx_http_process_request_headers处理请求header

6 ngx_http_process_request处理请求

7 ngx_http_handler

8 ngx_http_core_run_phases

函数详细：

void
ngx_http_core_run_phases(ngx_http_request_t *r)
{   
ngx_int_t                   rc;
ngx_http_phase_handler_t   *ph;
ngx_http_core_main_conf_t  *cmcf;
cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
ph = cmcf->phase_engine.handlers;
while (ph[r->phase_handler].checker) {
  
rc = ph[r->phase_handler].checker(r, &ph[r->phase_handler]);
if (rc == NGX_OK) {
return;
}
}
}

然后遍历整个请求状态机的11个阶段

序号	阶段名称	阶段描述
0	NGX_HTTP_POST_READ_PHASE	请求头读取完成后的阶段
1	NGX_HTTP_SERVER_REWRITE_PHASE	Server内请求地址重写阶段
2	NGX_HTTP_FIND_CONFIG_PHASE	配置查找阶段
3	NGX_HTTP_REWRITE_PHASE	Location内请求地址重写阶段
4	NGX_HTTP_POST_REWRITE_PHASE	请求地址重写完成之后的阶段
5	NGX_HTTP_PREACCESS_PHASE	访问权限检查准备阶段
6	NGX_HTTP_ACCESS_PHASE	访问权限检查阶段
7	NGX_HTTP_POST_ACCESS_PHASE	访问权限检查完后之后的阶段
8	NGX_HTTP_TRY_FILES_PHASE	配置项try_files处理阶段
9	NGX_HTTP_CONTENT_PHASE	内容产生阶段
10	NGX_HTTP_LOG_PHASE	日志模块处理阶段

一般我们写handler模块都是在NGX_HTTP_CONTENT_PHASE阶段，也就是说我们直接把函数挂在在NGX_HTTP_CONTENT_PHASE就ok

我们自己写一个nginx handler模块

config文件

//config 文件
ngx_addon_name=ngx_http_read_module
HTTP_MODULES="$HTTP_MODULES ngx_http_read_module"
NGX_ADDON_SRCS="$NGX_ADDON_SRCS $ngx_addon_dir/ngx_http_read_module.c"

ngx_http_read_module.c文件

/*
 * =====================================================================================
 *
 *       Filename:  ngx_http_read_module.c
 *
 *    Description:  这个一个读取一个leek文件返回给用户
 *
 *        Version:  1.0
 *        Created:  2013年10月10日 11时06分53秒
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  [email protected]
 *   Organization:  
 *
 * =====================================================================================
 */
#include 
#include 
#include 

#define TEST_STRING     "This is a static module test string"
typedef struct 
{
        ngx_str_t name;
}ngx_http_test_loc_t;
ngx_str_t g_buf;

static void* ngx_http_leek_create_loc_conf(ngx_conf_t* cf);
static char* ngx_http_leek_merge_loc_conf(ngx_conf_t* cf, void* parent, void* child);
static ngx_int_t ngx_http_leekdump_handler(ngx_http_request_t *r);

/*
 * 这个函数调用创建一个ngx_http_test_loc_t结构,进行初始化成员,然后把这个结构挂在到http->ctx->loc_conf所对应的索引下面
 */
static void* ngx_http_leek_create_loc_conf(ngx_conf_t* cf) {
        ngx_http_test_loc_t* conf;

        conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_test_loc_t));
        if (conf == NULL) {
                return NGX_CONF_ERROR;
        }
        conf->name.len = 0;
        conf->name.data = NULL;

        return conf;
}
/* 当读取配置文件并且解析到leek命令时候就会调用这个函数 */
char* setvalue(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
        ngx_http_test_loc_t* temp;
        struct stat buf;

        ngx_conf_set_str_slot(cf, cmd, conf);
        
        temp = (ngx_http_test_loc_t*)conf;
        if (access((char*)temp->name.data, F_OK) == -1)
        {
                return NGX_CONF_ERROR;
        }
        if (stat((char*)temp->name.data, &buf))
        {
                return NGX_CONF_ERROR;
        }

        g_buf.data = ngx_alloc(buf.st_size +1, cf->log);
        g_buf.data[buf.st_size] = 0;
        g_buf.len = buf.st_size+1;
        int fd = open((char*)temp->name.data, O_RDONLY);
        if (fd == -1)
        {
                return NGX_CONF_ERROR;
        }

        read(fd, g_buf.data, buf.st_size);
        return NGX_CONF_OK;
}
/*
 * ngx_string(leek) =>  定义一个leek命令
 * NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1 =>  命令只能存在loc作用域中并且带一个参数(NGX_CONF_TAKE1)
 * 回调函数为setvalue 
 * 保存在LOC数组中
 * 设置name在结构体ngx_http_test_loc_t偏移
 *
 */
static ngx_command_t ngx_http_read_commands [] = {
        {
                ngx_string("leek"),
                NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
                setvalue,
                NGX_HTTP_LOC_CONF_OFFSET,
                offsetof(ngx_http_test_loc_t, name),
                NULL
        },
ngx_null_command
};
/*
 * 挂在http回调函到阶段NGX_HTTP_CONTENT_PHASE
 */
static ngx_int_t ngx_http_read_init(ngx_conf_t *cf)
{
    ngx_http_handler_pt        *h;
    ngx_http_core_main_conf_t  *cmcf;

    cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

    h = ngx_array_push(&cmcf->phases[NGX_HTTP_CONTENT_PHASE].handlers);
    if (h == NULL) {
        return NGX_ERROR;
    }

    *h = ngx_http_leekdump_handler;

        return NGX_OK;
}
ngx_http_module_t  ngx_http_read_module_ctx = {
        NULL,                                  /* preconfiguration */
        ngx_http_read_init,                    /* postconfiguration */
        NULL,                                  /* create main configuration */
        NULL,                                  /* init main configuration */

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

        ngx_http_leek_create_loc_conf,                                      /* create location configuration */
        ngx_http_leek_merge_loc_conf                                   /* merge location configuration */
};

/*
 * 模块定义
 */
ngx_module_t ngx_http_read_module = 
{
        NGX_MODULE_V1,
        &ngx_http_read_module_ctx,             /* module context */
        ngx_http_read_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
};
/*
 * 合并对多个loc进行合并，用户对用户没有设置的loc使用parent loc值
 */
static char* ngx_http_leek_merge_loc_conf(ngx_conf_t* cf, void* parent, void* child) {
        ngx_http_test_loc_t* prev = parent;
        ngx_http_test_loc_t* conf = child;
        ngx_conf_merge_str_value(conf->name, prev->name, "Nginx");
        return NGX_CONF_OK;
}

/*
 * 回调函数，当用户访问leek页面的时候，就会把命令leek 设置的参数值文件，发给客户端
 * 关注两个函数
 * 1 ngx_http_send_header
 * 2 ngx_http_output_filter
 */
static ngx_int_t ngx_http_leekdump_handler(ngx_http_request_t *r)
{
        ngx_int_t rc;
        ngx_buf_t* b;
        ngx_chain_t out[3];

    if (ngx_rstrncasecmp((u_char *)"/leek", r->uri.data, 5) != 0) {
        return NGX_DECLINED;
    }

        r->headers_out.content_type.len = sizeof("text/html") - 1;
        r->headers_out.content_type.data = (u_char*)"text/html";

        b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));

        out[0].buf = b;
        out[0].next = NULL;

        b->pos = (u_char*)g_buf.data;
        b->last = b->pos + g_buf.len;
        b->memory = 1;
        b->last_buf = 1;

        r->headers_out.status = NGX_HTTP_OK;
        r->headers_out.content_length_n = g_buf.len;
        rc = ngx_http_send_header(r);
        if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
                return rc;
        }

        return ngx_http_output_filter(r, &out[0]);
}
(END) 

nginx.conf配置文件如下

worker_processes  1;

events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;


    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    #gzip  on;

    server {
        listen       80;
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            root   html;
            index  index.html index.htm;
        }

        location /leek {
            leek "/root/hunter/nginx/ngx_gdb/conf/mime.types.default";
        }
        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }

    }


}

此时content handler主要功能是当用户访问/"leek"页面的时候,把文件（

/root/hunter/nginx/ngx_gdb/conf/mime.types.default

）返回给用户浏览器客户端