Nginx的http模块代码分析

Nginx Nginx 评论

1、代码框架

http模块主要代码放在ngx_http.c这个文件中，接下来我们就来分析下相关代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
static char *ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
static ngx_int_t ngx_http_init_phases(ngx_conf_t *cf,
    ngx_http_core_main_conf_t *cmcf);
static ngx_int_t ngx_http_init_headers_in_hash(ngx_conf_t *cf,
    ngx_http_core_main_conf_t *cmcf);
static ngx_int_t ngx_http_init_phase_handlers(ngx_conf_t *cf,
    ngx_http_core_main_conf_t *cmcf);

static ngx_int_t ngx_http_add_addresses(ngx_conf_t *cf,
    ngx_http_core_srv_conf_t *cscf, ngx_http_conf_port_t *port,
    ngx_http_listen_opt_t *lsopt);
static ngx_int_t ngx_http_add_address(ngx_conf_t *cf,
    ngx_http_core_srv_conf_t *cscf, ngx_http_conf_port_t *port,
    ngx_http_listen_opt_t *lsopt);
static ngx_int_t ngx_http_add_server(ngx_conf_t *cf,
    ngx_http_core_srv_conf_t *cscf, ngx_http_conf_addr_t *addr);

static char *ngx_http_merge_servers(ngx_conf_t *cf,
    ngx_http_core_main_conf_t *cmcf, ngx_http_module_t *module,
    ngx_uint_t ctx_index);
static char *ngx_http_merge_locations(ngx_conf_t *cf,
    ngx_queue_t *locations, void **loc_conf, ngx_http_module_t *module,
    ngx_uint_t ctx_index);
static ngx_int_t ngx_http_init_locations(ngx_conf_t *cf,
    ngx_http_core_srv_conf_t *cscf, ngx_http_core_loc_conf_t *pclcf);
static ngx_int_t ngx_http_init_static_location_trees(ngx_conf_t *cf,
    ngx_http_core_loc_conf_t *pclcf);
static ngx_int_t ngx_http_cmp_locations(const ngx_queue_t *one,
    const ngx_queue_t *two);
static ngx_int_t ngx_http_join_exact_locations(ngx_conf_t *cf,
    ngx_queue_t *locations);
static void ngx_http_create_locations_list(ngx_queue_t *locations,
    ngx_queue_t *q);
static ngx_http_location_tree_node_t *
    ngx_http_create_locations_tree(ngx_conf_t *cf, ngx_queue_t *locations,
    size_t prefix);

static ngx_int_t ngx_http_optimize_servers(ngx_conf_t *cf,
    ngx_http_core_main_conf_t *cmcf, ngx_array_t *ports);
static ngx_int_t ngx_http_server_names(ngx_conf_t *cf,
    ngx_http_core_main_conf_t *cmcf, ngx_http_conf_addr_t *addr);
static ngx_int_t ngx_http_cmp_conf_addrs(const void *one, const void *two);
static int ngx_libc_cdecl ngx_http_cmp_dns_wildcards(const void *one,
    const void *two);

static ngx_int_t ngx_http_init_listening(ngx_conf_t *cf,
    ngx_http_conf_port_t *port);
static ngx_listening_t *ngx_http_add_listening(ngx_conf_t *cf,
    ngx_http_conf_addr_t *addr);
static ngx_int_t ngx_http_add_addrs(ngx_conf_t *cf, ngx_http_port_t *hport,
    ngx_http_conf_addr_t *addr);
#if (NGX_HAVE_INET6)
static ngx_int_t ngx_http_add_addrs6(ngx_conf_t *cf, ngx_http_port_t *hport,
    ngx_http_conf_addr_t *addr);
#endif

在ngx_http.c文件最前面这部分代码全部是函数声明，接下来看下http模块配置，指令设置、函数指针以及模块结构初始化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
ngx_uint_t   ngx_http_max_module;


ngx_http_output_header_filter_pt  ngx_http_top_header_filter;
ngx_http_output_body_filter_pt    ngx_http_top_body_filter;
ngx_http_request_body_filter_pt   ngx_http_top_request_body_filter;

ngx_str_t  ngx_http_html_default_types[] = {
    ngx_string("text/html"),
    ngx_null_string
};

// http指令定义
static ngx_command_t  ngx_http_commands[] = {

    { ngx_string("http"),
      NGX_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
      ngx_http_block,
      0,
      0,
      NULL },

      ngx_null_command
};

//核心模块上下文
static ngx_core_module_t  ngx_http_module_ctx = {
    ngx_string("http"),
    NULL,
    NULL
};

//http模块定义
ngx_module_t  ngx_http_module = {
    NGX_MODULE_V1,
    &ngx_http_module_ctx,                  /* module context */
    ngx_http_commands,                     /* module directives */
    NGX_CORE_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
};

接下来看下http块解析函数，ngx_http_block函数实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
static char *
ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
    char                        *rv;
    ngx_uint_t                   mi, m, s;
    ngx_conf_t                   pcf;
    ngx_http_module_t           *module;
    ngx_http_conf_ctx_t         *ctx;
    ngx_http_core_loc_conf_t    *clcf;
    ngx_http_core_srv_conf_t   **cscfp;
    ngx_http_core_main_conf_t   *cmcf;

    // 判断是否重复配置
    if (*(ngx_http_conf_ctx_t **) conf) {
        return "is duplicate";
    }

    /* the main http context */

    // 申请保存上下文的内存
    ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
    if (ctx == NULL) {
        return NGX_CONF_ERROR;
    }

    *(ngx_http_conf_ctx_t **) conf = ctx;


    /* count the number of the http modules and set up their indices */

    ngx_http_max_module = ngx_count_modules(cf->cycle, NGX_HTTP_MODULE);


    /* the http main_conf context, it is the same in the all http contexts */

    ctx->main_conf = ngx_pcalloc(cf->pool,
                                 sizeof(void *) * ngx_http_max_module);
    if (ctx->main_conf == NULL) {
        return NGX_CONF_ERROR;
    }


    /*
     * the http null srv_conf context, it is used to merge
     * the server{}s' srv_conf's
     */

    ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
    if (ctx->srv_conf == NULL) {
        return NGX_CONF_ERROR;
    }


    /*
     * the http null loc_conf context, it is used to merge
     * the server{}s' loc_conf's
     */

    ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
    if (ctx->loc_conf == NULL) {
        return NGX_CONF_ERROR;
    }


    /*
     * create the main_conf's, the null srv_conf's, and the null loc_conf's
     * of the all http modules
     */

    for (m = 0; cf->cycle->modules[m]; m++) {
        // 跳过非http模块
        if (cf->cycle->modules[m]->type != NGX_HTTP_MODULE) {
            continue;
        }

        module = cf->cycle->modules[m]->ctx;
        mi = cf->cycle->modules[m]->ctx_index;

        // 调用每个模块创建main级别conf的函数指针
        if (module->create_main_conf) {
            ctx->main_conf[mi] = module->create_main_conf(cf);
            if (ctx->main_conf[mi] == NULL) {
                return NGX_CONF_ERROR;
            }
        }

        // 调用每个模块创建server级别conf的函数指针
        if (module->create_srv_conf) {
            ctx->srv_conf[mi] = module->create_srv_conf(cf);
            if (ctx->srv_conf[mi] == NULL) {
                return NGX_CONF_ERROR;
            }
        }

        // 调用每个模块创建location级别conf的函数指针
        if (module->create_loc_conf) {
            ctx->loc_conf[mi] = module->create_loc_conf(cf);
            if (ctx->loc_conf[mi] == NULL) {
                return NGX_CONF_ERROR;
            }
        }
    }

    // 保存cf，在解析完配置后会还原
    pcf = *cf;
    // 保存http级别conf
    cf->ctx = ctx;

    for (m = 0; cf->cycle->modules[m]; m++) {
        // 跳过非http模块
        if (cf->cycle->modules[m]->type != NGX_HTTP_MODULE) {
            continue;
        }

        module = cf->cycle->modules[m]->ctx;
        //调用每个模块preconfiguration函数指针，在解析配置前需要做的
        if (module->preconfiguration) {
            if (module->preconfiguration(cf) != NGX_OK) {
                return NGX_CONF_ERROR;
            }
        }
    }

    /* parse inside the http{} block */

    cf->module_type = NGX_HTTP_MODULE;
    cf->cmd_type = NGX_HTTP_MAIN_CONF;
    // 开始解析http块里面的配置
    rv = ngx_conf_parse(cf, NULL);

    if (rv != NGX_CONF_OK) {
        goto failed;
    }

    /*
     * init http{} main_conf's, merge the server{}s' srv_conf's
     * and its location{}s' loc_conf's
     */

    // 取http main级别的conf
    cmcf = ctx->main_conf[ngx_http_core_module.ctx_index];
    cscfp = cmcf->servers.elts;

    // 调用每个http模块初始化main级别配置的函数
    for (m = 0; cf->cycle->modules[m]; m++) {
        // 跳过非http模块
        if (cf->cycle->modules[m]->type != NGX_HTTP_MODULE) {
            continue;
        }

        module = cf->cycle->modules[m]->ctx;
        mi = cf->cycle->modules[m]->ctx_index;

        /* init http{} main_conf's */
        // 调用每个模块init_main_conf函数指针
        if (module->init_main_conf) {
            rv = module->init_main_conf(cf, ctx->main_conf[mi]);
            if (rv != NGX_CONF_OK) {
                goto failed;
            }
        }

        // 合并server级别及location级别配置
        rv = ngx_http_merge_servers(cf, cmcf, module, mi);
        if (rv != NGX_CONF_OK) {
            goto failed;
        }
    }


    /* create location trees */
    // 构造http请求location匹配树
    for (s = 0; s < cmcf->servers.nelts; s++) {

        clcf = cscfp[s]->ctx->loc_conf[ngx_http_core_module.ctx_index];

        if (ngx_http_init_locations(cf, cscfp[s], clcf) != NGX_OK) {
            return NGX_CONF_ERROR;
        }

        // 构造静态location匹配树
        if (ngx_http_init_static_location_trees(cf, clcf) != NGX_OK) {
            return NGX_CONF_ERROR;
        }
    }


    // 初始化各个阶段的array
    if (ngx_http_init_phases(cf, cmcf) != NGX_OK) {
        return NGX_CONF_ERROR;
    }

    // 初始化http请求头headers
    if (ngx_http_init_headers_in_hash(cf, cmcf) != NGX_OK) {
        return NGX_CONF_ERROR;
    }

    // 处理每个http模块postconfiguration
    for (m = 0; cf->cycle->modules[m]; m++) {
        if (cf->cycle->modules[m]->type != NGX_HTTP_MODULE) {
            continue;
        }

        module = cf->cycle->modules[m]->ctx;
        //调用每个模块postconfiguration函数指针，用于处理配置解析完成后的操作
        if (module->postconfiguration) {
            if (module->postconfiguration(cf) != NGX_OK) {
                return NGX_CONF_ERROR;
            }
        }
    }

    // 初始化http变量
    if (ngx_http_variables_init_vars(cf) != NGX_OK) {
        return NGX_CONF_ERROR;
    }

    /*
     * http{}'s cf->ctx was needed while the configuration merging
     * and in postconfiguration process
     */
    // 恢复cf
    *cf = pcf;

    // 初始化http各个阶段handler
    if (ngx_http_init_phase_handlers(cf, cmcf) != NGX_OK) {
        return NGX_CONF_ERROR;
    }


    /* optimize the lists of ports, addresses and server names */
    // 处理相同端口以及server_name
    if (ngx_http_optimize_servers(cf, cmcf, cmcf->ports) != NGX_OK) {
        return NGX_CONF_ERROR;
    }

    return NGX_CONF_OK;

failed:
    // 恢复cf
    *cf = pcf;
    // 返回结果
    return rv;
}


接下来分析ngx_http_optimize_servers函数，此函数用于处理IP+Port相同，不同server_name的情况
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
static ngx_int_t
ngx_http_optimize_servers(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf,
    ngx_array_t *ports)
{
    ngx_uint_t             p, a;
    ngx_http_conf_port_t  *port;
    ngx_http_conf_addr_t  *addr;

    // 如果没有配置端口，则返回
    if (ports == NULL) {
        return NGX_OK;
    }

    // 遍历已经配置的port列表，
    port = ports->elts;
    for (p = 0; p < ports->nelts; p++) {

        // 将同一个port下挂的addr进行排序
        ngx_sort(port[p].addrs.elts, (size_t) port[p].addrs.nelts,
                 sizeof(ngx_http_conf_addr_t), ngx_http_cmp_conf_addrs);

        /*
         * check whether all name-based servers have the same
         * configuration as a default server for given address:port
         */

        // 如果一个addr下有多个server块，则处理server_name
        addr = port[p].addrs.elts;
        for (a = 0; a < port[p].addrs.nelts; a++) {

            if (addr[a].servers.nelts > 1
#if (NGX_PCRE)
                || addr[a].default_server->captures
#endif
               )
            {
                if (ngx_http_server_names(cf, cmcf, &addr[a]) != NGX_OK) {
                    return NGX_ERROR;
                }
            }
        }

        // 处理listen，从cycle->listening分配元素
        if (ngx_http_init_listening(cf, &port[p]) != NGX_OK) {
            return NGX_ERROR;
        }
    }

    return NGX_OK;
}

  1. 接下来分析ngx_http_server_names函数，这个函数的功能是server_name进行hash处理
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    static ngx_int_t
    ngx_http_server_names(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf,
        ngx_http_conf_addr_t *addr)
    {
        ngx_int_t                   rc;
        ngx_uint_t                  n, s;
        ngx_hash_init_t             hash;
        ngx_hash_keys_arrays_t      ha;
        ngx_http_server_name_t     *name;
        ngx_http_core_srv_conf_t  **cscfp;
    #if (NGX_PCRE)
        ngx_uint_t                  regex, i;

        regex = 0;
    #endif

        // 初始化hash key数组
        ngx_memzero(&ha, sizeof(ngx_hash_keys_arrays_t));

        // 创建初始化hash table所需的内存池
        ha.temp_pool = ngx_create_pool(NGX_DEFAULT_POOL_SIZE, cf->log);
        if (ha.temp_pool == NULL) {
            return NGX_ERROR;
        }

        ha.pool = cf->pool;

        // 初始化hash key
        if (ngx_hash_keys_array_init(&ha, NGX_HASH_LARGE) != NGX_OK) {
            goto failed;
        }

        cscfp = addr->servers.elts;

        // 遍历此地址下的所有server块
        for (s = 0; s < addr->servers.nelts; s++) {

            name = cscfp[s]->server_names.elts;

            for (n = 0; n < cscfp[s]->server_names.nelts; n++) {

    #if (NGX_PCRE)
                if (name[n].regex) {
                    regex++;
                    continue;
                }
    #endif

                // 将server_name添加到key中
                rc = ngx_hash_add_key(&ha, &name[n].name, name[n].server,
                                      NGX_HASH_WILDCARD_KEY);

                if (rc == NGX_ERROR) {
                    return NGX_ERROR;
                }

                if (rc == NGX_DECLINED) {
                    ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
                                  "invalid server name or wildcard \"%V\" on %V",
                                  &name[n].name, &addr->opt.addr_text);
                    return NGX_ERROR;
                }

                // server_name出现冲突
                if (rc == NGX_BUSY) {
                    ngx_log_error(NGX_LOG_WARN, cf->log, 0,
                                  "conflicting server name \"%V\" on %V, ignored",
                                  &name[n].name, &addr->opt.addr_text);
                }
            }
        }

        // 对hash表赋初值
        hash.key = ngx_hash_key_lc;
        hash.max_size = cmcf->server_names_hash_max_size;
        hash.bucket_size = cmcf->server_names_hash_bucket_size;
        hash.name = "server_names_hash";
        hash.pool = cf->pool;

        if (ha.keys.nelts) {
            hash.hash = &addr->hash;
            hash.temp_pool = NULL;

            if (ngx_hash_init(&hash, ha.keys.elts, ha.keys.nelts) != NGX_OK) {
                goto failed;
            }
        }

        // 前缀匹配
        if (ha.dns_wc_head.nelts) {

            ngx_qsort(ha.dns_wc_head.elts, (size_t) ha.dns_wc_head.nelts,
                      sizeof(ngx_hash_key_t), ngx_http_cmp_dns_wildcards);

            hash.hash = NULL;
            hash.temp_pool = ha.temp_pool;

            if (ngx_hash_wildcard_init(&hash, ha.dns_wc_head.elts,
                                       ha.dns_wc_head.nelts)
                != NGX_OK)
            {
                goto failed;
            }

            addr->wc_head = (ngx_hash_wildcard_t *) hash.hash;
        }

        // 后缀匹配
        if (ha.dns_wc_tail.nelts) {

            ngx_qsort(ha.dns_wc_tail.elts, (size_t) ha.dns_wc_tail.nelts,
                      sizeof(ngx_hash_key_t), ngx_http_cmp_dns_wildcards);

            hash.hash = NULL;
            hash.temp_pool = ha.temp_pool;

            if (ngx_hash_wildcard_init(&hash, ha.dns_wc_tail.elts,
                                       ha.dns_wc_tail.nelts)
                != NGX_OK)
            {
                goto failed;
            }

            addr->wc_tail = (ngx_hash_wildcard_t *) hash.hash;
        }

        ngx_destroy_pool(ha.temp_pool);

        // 处理正则
    #if (NGX_PCRE)

        if (regex == 0) {
            return NGX_OK;
        }

        addr->nregex = regex;
        addr->regex = ngx_palloc(cf->pool, regex * sizeof(ngx_http_server_name_t));
        if (addr->regex == NULL) {
            return NGX_ERROR;
        }

        i = 0;

        for (s = 0; s < addr->servers.nelts; s++) {

            name = cscfp[s]->server_names.elts;
            // 遍历server_name，对regex进行处理
            for (n = 0; n < cscfp[s]->server_names.nelts; n++) {
                if (name[n].regex) {
                    addr->regex[i++] = name[n];
                }
            }
        }

    #endif

        return NGX_OK;

    failed:
        // 释放temp_pool
        ngx_destroy_pool(ha.temp_pool);

        return NGX_ERROR;
    }

  1. 接下来分析ngx_http_init_listening函数
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    static ngx_int_t
    ngx_http_init_listening(ngx_conf_t *cf, ngx_http_conf_port_t *port)
    {
        ngx_uint_t                 i, last, bind_wildcard;
        ngx_listening_t           *ls;
        ngx_http_port_t           *hport;
        ngx_http_conf_addr_t      *addr;

        addr = port->addrs.elts;
        last = port->addrs.nelts;

        /*
         * If there is a binding to an "*:port" then we need to bind() to
         * the "*:port" only and ignore other implicit bindings.  The bindings
         * have been already sorted: explicit bindings are on the start, then
         * implicit bindings go, and wildcard binding is in the end.
         */

        if (addr[last - 1].opt.wildcard) {
            addr[last - 1].opt.bind = 1;
            bind_wildcard = 1;

        } else {
            bind_wildcard = 0;
        }

        i = 0;

        while (i < last) {

            if (bind_wildcard && !addr[i].opt.bind) {
                i++;
                continue;
            }

            // 从ngx_cycle->listening中push一个ls，跟socket相关的都保存在这里面
            ls = ngx_http_add_listening(cf, &addr[i]);
            if (ls == NULL) {
                return NGX_ERROR;
            }

            // 分配保存地址的内存，在ngx_init_connection中使用
            hport = ngx_pcalloc(cf->pool, sizeof(ngx_http_port_t));
            if (hport == NULL) {
                return NGX_ERROR;
            }

            ls->servers = hport;

            hport->naddrs = i + 1;

            switch (ls->sockaddr->sa_family) {

    #if (NGX_HAVE_INET6)
            case AF_INET6:
                if (ngx_http_add_addrs6(cf, hport, addr) != NGX_OK) {
                    return NGX_ERROR;
                }
                break;
    #endif
            default: /* AF_INET */
                // 将addr中的内容复制到hport中
                if (ngx_http_add_addrs(cf, hport, addr) != NGX_OK) {
                    return NGX_ERROR;
                }
                break;
            }

            addr++;
            last--;
        }

        return NGX_OK;
    }

  1. 接下来看看ngx_http_add_addrs函数的实现，ngx_http_add_addrs6类似
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    static ngx_int_t
    ngx_http_add_addrs(ngx_conf_t *cf, ngx_http_port_t *hport,
        ngx_http_conf_addr_t *addr)
    {
        ngx_uint_t                 i;
        ngx_http_in_addr_t        *addrs;
        struct sockaddr_in        *sin;
        ngx_http_virtual_names_t  *vn;

        // 申请必要内存，naddrs就是外面计算的这个端口下的ip个数
        hport->addrs = ngx_pcalloc(cf->pool,
                                   hport->naddrs * sizeof(ngx_http_in_addr_t));
        if (hport->addrs == NULL) {
            return NGX_ERROR;
        }

        addrs = hport->addrs;

        for (i = 0; i < hport->naddrs; i++) {

            sin = (struct sockaddr_in *) addr[i].opt.sockaddr;
            addrs[i].addr = sin->sin_addr.s_addr;
            addrs[i].conf.default_server = addr[i].default_server;
    #if (NGX_HTTP_SSL)
            addrs[i].conf.ssl = addr[i].opt.ssl;
    #endif
    #if (NGX_HTTP_V2)
            addrs[i].conf.http2 = addr[i].opt.http2;
    #endif
            addrs[i].conf.proxy_protocol = addr[i].opt.proxy_protocol;

            // 如果匹配server_name所需的hash桶为空，则不进行下一步操作
            if (addr[i].hash.buckets == NULL
                && (addr[i].wc_head == NULL
                    || addr[i].wc_head->hash.buckets == NULL)
                && (addr[i].wc_tail == NULL
                    || addr[i].wc_tail->hash.buckets == NULL)
    #if (NGX_PCRE)
                && addr[i].nregex == 0
    #endif
                )
            {
                continue;
            }

            // 申请保存server_name匹配所需内存
            vn = ngx_palloc(cf->pool, sizeof(ngx_http_virtual_names_t));
            if (vn == NULL) {
                return NGX_ERROR;
            }

            addrs[i].conf.virtual_names = vn;

            // 保存server_name匹配所需的hash值
            vn->names.hash = addr[i].hash;
            vn->names.wc_head = addr[i].wc_head;
            vn->names.wc_tail = addr[i].wc_tail;
    #if (NGX_PCRE)
            vn->nregex = addr[i].nregex;
            vn->regex = addr[i].regex;
    #endif
        }

        return NGX_OK;
    }

  2. 接下来看看函数的实现
    1

weeweetanBackend Developer

初级程序猿，之前主要涉及数据备份相关领域，现在研究CDN方向。业余时间也喜欢锻炼下，目前参过一次半程马拉松，四次全程马拉松，半马最好成绩99分钟，全马最好成绩3小时47分钟。