nginx 配置解析 & 模块上下文

static ngx_command_t  ngx_http_mytest_commands[] =
        {

                {
                        ngx_string("test_flag"),
                        NGX_HTTP_LOC_CONF | NGX_CONF_FLAG,
                        ngx_conf_set_flag_slot,
                        NGX_HTTP_LOC_CONF_OFFSET,
                        offsetof(ngx_http_mytest_conf_t, my_flag),
                        NULL
                },

        }

typedef struct ngx_command_s     ngx_command_t;
struct ngx_command_s {
    ngx_str_t             name;       // 指令名称，如 "listen"、"server_name" 等
    ngx_uint_t            type;       // 指令的类型和上下文，如 NGX_HTTP_MAIN_CONF、NGX_HTTP_SRV_CONF , 简单来说就是可以出现在哪些配置体中。
    char               *(*set)(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);  // 指令的解析函数
    ngx_uint_t            conf;       // 指令的配置存储位置，如 NGX_HTTP_MAIN_CONF_OFFSET、NGX_HTTP_SRV_CONF_OFFSET， 简单来说就是这个配置存放于ngx_http_conf_ctx_t 的哪个块中， server local？
    ngx_uint_t            offset;     // 指令在配置结构体中的偏移量，用于定位存储位置
    void                 *post;      // 指令解析后的回调函数，通常为 NULL
};

char *
ngx_conf_set_flag_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
    char  *p = conf;

    ngx_str_t        *value;
    ngx_flag_t       *fp;
    ngx_conf_post_t  *post;

    fp = (ngx_flag_t *) (p + cmd->offset);

    if (*fp != NGX_CONF_UNSET) {
        return "is duplicate";
    }

    value = cf->args->elts;

    if (ngx_strcasecmp(value[1].data, (u_char *) "on") == 0) {
        *fp = 1;

    } else if (ngx_strcasecmp(value[1].data, (u_char *) "off") == 0) {
        *fp = 0;

    } else {
        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                     "invalid value \"%s\" in \"%s\" directive, "
                     "it must be \"on\" or \"off\"",
                     value[1].data, cmd->name.data);
        return NGX_CONF_ERROR;
    }

    if (cmd->post) {
        post = cmd->post;
        return post->post_handler(cf, post, fp);
    }

    return NGX_CONF_OK;
}

几点说明：
1. 参数conf就是http框架传给我们的，在ngx_http_mytest_create_loc_conf 回调方法中分配的结构体ngx_http_mytest_conf_t
2. cf->args是1个ngx_array_t队列，它的成员都是ngx_str_t结构。我们用value指向ngx_array_t的elts内容，其中value[1]就是第1个参数，同理value[2]是第2个参数
3.  ngx_command_t *cmd 则是触发命令 ~  

typedef struct {
    void ​**main_conf;  // 指向所有模块的全局配置数组
    void ​**srv_conf;   // 指向所有模块的 server 配置数组
    void ​**loc_conf;   // 指向所有模块的 location 配置数组
} ngx_http_conf_ctx_t;

// http{} 块配置（必须通过 create_main_conf 自定义）
typedef struct {
    ngx_array_t               servers;         // 所有server{}配置的集合
    ngx_http_phase_engine_t   phase_engine;    // HTTP处理阶段引擎
    ngx_uint_t               *server_names_hash_max_size;
    /* 其他30+个全局HTTP配置字段... */
} ngx_http_core_main_conf_t;

// server{} 块配置（默认结构体）
struct ngx_http_core_srv_conf_s { 
    ngx_str_t    server_name;      // 服务器名
    ngx_array_t  listen;           // 监听端口
    /* 其他40+个核心字段... */
};

// location{} 块配置（默认结构体） 
struct ngx_http_core_loc_conf_s {
    ngx_str_t    name;             // location匹配规则
    void       **handler;          // 内容处理器
    /* 其他30+个核心字段... */
};

// 在请求处理阶段获取配置
static ngx_int_t ngx_http_mymodule_handler(ngx_http_request_t *r) {
    ngx_http_mymodule_loc_conf_t *mlcf = ngx_http_get_module_loc_conf(r, ngx_http_mymodule_module);
    // 使用 mlcf->custom_setting 等字段
}


// 在配置解析阶段获取配置
static char *ngx_http_mymodule_directive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
    ngx_http_mymodule_loc_conf_t *mlcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_mymodule_module);
    // 设置 mlcf->custom_setting 等字段
}

/* 请求处理函数 */
static ngx_int_t ngx_http_mymodule_content_handler(ngx_http_request_t *r)
{
    // 使用 ngx_http_get_module_loc_conf 获取运行时配置
    ngx_http_mymodule_loc_conf_t *mlcf = ngx_http_get_module_loc_conf(r, ngx_http_mymodule_module);

    if (!mlcf->enable) {
        return NGX_DECLINED;
    }

    // 设置响应头
    r->headers_out.content_type.len = sizeof("text/plain") - 1;
    r->headers_out.content_type.data = (u_char *) "text/plain";
    r->headers_out.status = NGX_HTTP_OK;

    // 发送响应体
    ngx_buf_t *b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
    ngx_chain_t out;
    out.buf = b;
    out.next = NULL;

    b->pos = mlcf->response_text.data;
    b->last = mlcf->response_text.data + mlcf->response_text.len;
    b->memory = 1;
    b->last_buf = 1;

    r->headers_out.content_length_n = mlcf->response_text.len;
    ngx_http_send_header(r);
    return ngx_http_output_filter(r, &out);
}

/* 注册内容处理阶段 */
// 指令定义
static ngx_command_t ngx_http_hello_commands[] = {
        {
                ngx_string("hello_message"),          // 指令名
                NGX_HTTP_LOC_CONF | NGX_CONF_TAKE1,   // 使用位置和参数限制
                ngx_http_hello_set_message,           // 解析指令的函数
                NGX_HTTP_LOC_CONF_OFFSET,             // 配置存储在结构中的偏移量
                0,                                    // 用于指令的标志，通常为 0
                NULL                                  // 指令的回调，通常为 NULL
        },
        ngx_null_command
};
// 配置指令解析函数
static char *ngx_http_hello_set_message(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
    ngx_http_hello_loc_conf_t *hlcf = conf;

    ngx_str_t *value = cf->args->elts;
    hlcf->message = value[1];

    // 设置 handler
    ngx_http_core_loc_conf_t *clcf;
    clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
    clcf->handler = ngx_http_hello_handler; // 注册处理函数

    return NGX_CONF_OK;
}

// 打开抽屉，找到标着"核心模块"的格子
// 这个格子里的东西是 Nginx 官方定义的（如 alias、proxy_pass 等指令的配置）
ngx_http_core_loc_conf_t *clcf = 
    ngx_http_get_module_loc_conf(r, ngx_http_core_module);

// 同一个抽屉里，找到标着"我的模块"的格子
// 这个格子里的东西是您自己定义的（如 my_custom_header 等指令的配置）
ngx_http_mymodule_loc_conf_t *mlcf =
    ngx_http_get_module_loc_conf(r, ngx_http_mymodule_module);

ngx_http_core_loc_conf_t *clcf = 
    ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
// 可访问 clcf->alias, clcf->proxy_pass 等核心字段

ngx_http_mymodule_loc_conf_t *mlcf =
    ngx_http_conf_get_module_loc_conf(cf, ngx_http_mymodule_module);
// 可访问 mlcf->custom_setting 等自定义字段

static char *ngx_http_hello_set_message(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)

// 一个例子说清楚
static char *ngx_http_hello_set_message(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
    // 1. 获取模块配置结构体
    ngx_http_hello_loc_conf_t *hlcf = (ngx_http_hello_loc_conf_t *)conf;
    
    // 2. 从cf获取指令参数（如 hello_message "Hi"）
    ngx_str_t *args = cf->args->elts;
    hlcf->message = args[1];  // args[0]是指令名，args[1]是第一个参数
    
    // 3. 通过cmd检查指令类型
    if (!(cmd->type & NGX_HTTP_LOC_CONF)) {
        return "directive only allowed in location context";
    }
    
    return NGX_CONF_OK;
}

typedef struct {
    ngx_str_t my_config;  // 配置项
} ngx_http_mytest_srv_conf_t;

static void *
ngx_http_mytest_create_srv_conf(ngx_conf_t *cf)
{
    ngx_http_mytest_srv_conf_t *conf;

    conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_mytest_srv_conf_t));
    if (conf == NULL) {
        return NULL;
    }

    // 初始化配置
    conf->my_config.len = 0;
    conf->my_config.data = NULL;

    return conf;
}

static char *
ngx_http_mytest_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_http_mytest_srv_conf_t *prev = parent;  // 父配置（http{} 块）
    ngx_http_mytest_srv_conf_t *conf = child;   // 子配置（server{} 块）

    // 如果子配置未设置，则使用父配置
    if (conf->my_config.len == 0) {
        conf->my_config = prev->my_config;
    }

    return NGX_CONF_OK;
}

static ngx_command_t ngx_http_mytest_commands[] = {
    {
        ngx_string("my_config"),  // 指令名称
        NGX_HTTP_SRV_CONF | NGX_CONF_TAKE1,  // 支持 http{} 和 server{} 块
        ngx_conf_set_str_slot,
        NGX_HTTP_SRV_CONF_OFFSET,  // 配置数据存储到 server 配置块
        offsetof(ngx_http_mytest_srv_conf_t, my_config),  // 存储到 my_config 字段
        NULL
    },
    ngx_null_command
};

static ngx_http_module_t ngx_http_mytest_module_ctx = {
    NULL,                                  // preconfiguration
    NULL,                                  // postconfiguration
    NULL,                                  // create main configuration (移除)
    NULL,                                  // init main configuration
    ngx_http_mytest_create_srv_conf,       // create server configuration
    ngx_http_mytest_merge_srv_conf,        // merge server configuration
    NULL,                                  // create location configuration
    NULL                                   // merge location configuration
};

ngx_module_t ngx_http_mytest_module = {
    NGX_MODULE_V1,
    &ngx_http_mytest_module_ctx,           // module context
    ngx_http_mytest_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
};

typedef struct
{
    ngx_http_status_t           status;
    ngx_str_t					backendServer;
} ngx_http_mytest_ctx_t;

    //首先建立http上下文结构体ngx_http_mytest_ctx_t
    ngx_http_mytest_ctx_t* myctx = ngx_http_get_module_ctx(r, ngx_http_mytest_module);
    if (myctx == NULL)
    {
        myctx = ngx_palloc(r->pool, sizeof(ngx_http_mytest_ctx_t));
        if (myctx == NULL)
        {
            return NGX_ERROR;
        }
        //将新建的上下文与请求关联起来
        ngx_http_set_ctx(r, myctx, ngx_http_mytest_module);
    }

static void *
ngx_http_mytest_create_loc_conf(ngx_conf_t *cf) {
    ngx_http_mytest_conf_t *conf;
    conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_mytest_conf_t));
    conf->my_flag = NGX_CONF_UNSET;  // 设置默认值（unset）
    return conf;
}

static ngx_command_t ngx_http_mytest_commands[] = {
    {
        ngx_string("my_flag"),
        NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
        ngx_conf_set_flag_slot,
        NGX_HTTP_LOC_CONF_OFFSET,
        offsetof(ngx_http_mytest_conf_t, my_flag),
        NULL
    },
    ngx_null_command
};