Mercurial > hg > nginx-mail

comparison src/http/ngx_http.c @ 665:0b460e61bdcd default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge with nginx 1.0.0.
author Maxim Dounin <mdounin@mdounin.ru>
date Mon, 25 Apr 2011 04:22:17 +0400
parents 7ea1bba9a4f6
children
comparison
equal deleted inserted replaced
572:06419a2298a9 665:0b460e61bdcd
15 static ngx_int_t ngx_http_init_headers_in_hash(ngx_conf_t *cf, 15 static ngx_int_t ngx_http_init_headers_in_hash(ngx_conf_t *cf,
16 ngx_http_core_main_conf_t *cmcf); 16 ngx_http_core_main_conf_t *cmcf);
17 static ngx_int_t ngx_http_init_phase_handlers(ngx_conf_t *cf, 17 static ngx_int_t ngx_http_init_phase_handlers(ngx_conf_t *cf,
18 ngx_http_core_main_conf_t *cmcf); 18 ngx_http_core_main_conf_t *cmcf);
19 19
20 static ngx_int_t ngx_http_init_server_lists(ngx_conf_t *cf,
21 ngx_array_t *servers, ngx_array_t *ports);
22 static ngx_int_t ngx_http_add_ports(ngx_conf_t *cf,
23 ngx_http_core_srv_conf_t *cscf, ngx_array_t *ports,
24 ngx_http_listen_t *listen);
25 static ngx_int_t ngx_http_add_addresses(ngx_conf_t *cf, 20 static ngx_int_t ngx_http_add_addresses(ngx_conf_t *cf,
26 ngx_http_core_srv_conf_t *cscf, ngx_http_conf_port_t *port, 21 ngx_http_core_srv_conf_t *cscf, ngx_http_conf_port_t *port,
27 ngx_http_listen_t *listen); 22 ngx_http_listen_opt_t *lsopt);
28 static ngx_int_t ngx_http_add_address(ngx_conf_t *cf, 23 static ngx_int_t ngx_http_add_address(ngx_conf_t *cf,
29 ngx_http_core_srv_conf_t *cscf, ngx_http_conf_port_t *port, 24 ngx_http_core_srv_conf_t *cscf, ngx_http_conf_port_t *port,
30 ngx_http_listen_t *listen); 25 ngx_http_listen_opt_t *lsopt);
31 static ngx_int_t ngx_http_add_names(ngx_conf_t *cf, 26 static ngx_int_t ngx_http_add_server(ngx_conf_t *cf,
32 ngx_http_core_srv_conf_t *cscf, ngx_http_conf_addr_t *addr); 27 ngx_http_core_srv_conf_t *cscf, ngx_http_conf_addr_t *addr);
33 28
29 static char *ngx_http_merge_servers(ngx_conf_t *cf,
30 ngx_http_core_main_conf_t *cmcf, ngx_http_module_t *module,
31 ngx_uint_t ctx_index);
34 static char *ngx_http_merge_locations(ngx_conf_t *cf, 32 static char *ngx_http_merge_locations(ngx_conf_t *cf,
35 ngx_queue_t *locations, void **loc_conf, ngx_http_module_t *module, 33 ngx_queue_t *locations, void **loc_conf, ngx_http_module_t *module,
36 ngx_uint_t ctx_index); 34 ngx_uint_t ctx_index);
37 static ngx_int_t ngx_http_init_locations(ngx_conf_t *cf, 35 static ngx_int_t ngx_http_init_locations(ngx_conf_t *cf,
38 ngx_http_core_srv_conf_t *cscf, ngx_http_core_loc_conf_t *pclcf); 36 ngx_http_core_srv_conf_t *cscf, ngx_http_core_loc_conf_t *pclcf);
120 ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) 118 ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
121 { 119 {
122 char *rv; 120 char *rv;
123 ngx_uint_t mi, m, s; 121 ngx_uint_t mi, m, s;
124 ngx_conf_t pcf; 122 ngx_conf_t pcf;
125 ngx_array_t ports;
126 ngx_http_module_t *module; 123 ngx_http_module_t *module;
127 ngx_http_conf_ctx_t *ctx; 124 ngx_http_conf_ctx_t *ctx;
128 ngx_http_core_loc_conf_t *clcf; 125 ngx_http_core_loc_conf_t *clcf;
129 ngx_http_core_srv_conf_t **cscfp; 126 ngx_http_core_srv_conf_t **cscfp;
130 ngx_http_core_main_conf_t *cmcf; 127 ngx_http_core_main_conf_t *cmcf;
267 if (rv != NGX_CONF_OK) { 264 if (rv != NGX_CONF_OK) {
268 goto failed; 265 goto failed;
269 } 266 }
270 } 267 }
271 268
272 for (s = 0; s < cmcf->servers.nelts; s++) { 269 rv = ngx_http_merge_servers(cf, cmcf, module, mi);
273 270 if (rv != NGX_CONF_OK) {
274 /* merge the server{}s' srv_conf's */ 271 goto failed;
275
276 if (module->merge_srv_conf) {
277 rv = module->merge_srv_conf(cf, ctx->srv_conf[mi],
278 cscfp[s]->ctx->srv_conf[mi]);
279 if (rv != NGX_CONF_OK) {
280 goto failed;
281 }
282 }
283
284 if (module->merge_loc_conf) {
285
286 /* merge the server{}'s loc_conf */
287
288 rv = module->merge_loc_conf(cf, ctx->loc_conf[mi],
289 cscfp[s]->ctx->loc_conf[mi]);
290 if (rv != NGX_CONF_OK) {
291 goto failed;
292 }
293
294 /* merge the locations{}' loc_conf's */
295
296 clcf = cscfp[s]->ctx->loc_conf[ngx_http_core_module.ctx_index];
297
298 rv = ngx_http_merge_locations(cf, clcf->locations,
299 cscfp[s]->ctx->loc_conf,
300 module, mi);
301 if (rv != NGX_CONF_OK) {
302 goto failed;
303 }
304 }
305 } 272 }
306 } 273 }
307 274
308 275
309 /* create location trees */ 276 /* create location trees */
360 if (ngx_http_init_phase_handlers(cf, cmcf) != NGX_OK) { 327 if (ngx_http_init_phase_handlers(cf, cmcf) != NGX_OK) {
361 return NGX_CONF_ERROR; 328 return NGX_CONF_ERROR;
362 } 329 }
363 330
364 331
365 /*
366 * create the lists of ports, addresses and server names
367 * to find quickly the server core module configuration at run-time
368 */
369
370 if (ngx_http_init_server_lists(cf, &cmcf->servers, &ports) != NGX_OK) {
371 return NGX_CONF_ERROR;
372 }
373
374
375 /* optimize the lists of ports, addresses and server names */ 332 /* optimize the lists of ports, addresses and server names */
376 333
377 if (ngx_http_optimize_servers(cf, cmcf, &ports) != NGX_OK) { 334 if (ngx_http_optimize_servers(cf, cmcf, cmcf->ports) != NGX_OK) {
378 return NGX_CONF_ERROR; 335 return NGX_CONF_ERROR;
379 } 336 }
380 337
381 return NGX_CONF_OK; 338 return NGX_CONF_OK;
382 339
523 480
524 case NGX_HTTP_SERVER_REWRITE_PHASE: 481 case NGX_HTTP_SERVER_REWRITE_PHASE:
525 if (cmcf->phase_engine.server_rewrite_index == (ngx_uint_t) -1) { 482 if (cmcf->phase_engine.server_rewrite_index == (ngx_uint_t) -1) {
526 cmcf->phase_engine.server_rewrite_index = n; 483 cmcf->phase_engine.server_rewrite_index = n;
527 } 484 }
528 checker = ngx_http_core_generic_phase; 485 checker = ngx_http_core_rewrite_phase;
529 486
530 break; 487 break;
531 488
532 case NGX_HTTP_FIND_CONFIG_PHASE: 489 case NGX_HTTP_FIND_CONFIG_PHASE:
533 find_config_index = n; 490 find_config_index = n;
540 497
541 case NGX_HTTP_REWRITE_PHASE: 498 case NGX_HTTP_REWRITE_PHASE:
542 if (cmcf->phase_engine.location_rewrite_index == (ngx_uint_t) -1) { 499 if (cmcf->phase_engine.location_rewrite_index == (ngx_uint_t) -1) {
543 cmcf->phase_engine.location_rewrite_index = n; 500 cmcf->phase_engine.location_rewrite_index = n;
544 } 501 }
545 checker = ngx_http_core_generic_phase; 502 checker = ngx_http_core_rewrite_phase;
546 503
547 break; 504 break;
548 505
549 case NGX_HTTP_POST_REWRITE_PHASE: 506 case NGX_HTTP_POST_REWRITE_PHASE:
550 if (use_rewrite) { 507 if (use_rewrite) {
600 return NGX_OK; 557 return NGX_OK;
601 } 558 }
602 559
603 560
604 static char * 561 static char *
562 ngx_http_merge_servers(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf,
563 ngx_http_module_t *module, ngx_uint_t ctx_index)
564 {
565 char *rv;
566 ngx_uint_t s;
567 ngx_http_conf_ctx_t *ctx, saved;
568 ngx_http_core_loc_conf_t *clcf;
569 ngx_http_core_srv_conf_t **cscfp;
570
571 cscfp = cmcf->servers.elts;
572 ctx = (ngx_http_conf_ctx_t *) cf->ctx;
573 saved = *ctx;
574 rv = NGX_CONF_OK;
575
576 for (s = 0; s < cmcf->servers.nelts; s++) {
577
578 /* merge the server{}s' srv_conf's */
579
580 ctx->srv_conf = cscfp[s]->ctx->srv_conf;
581
582 if (module->merge_srv_conf) {
583 rv = module->merge_srv_conf(cf, saved.srv_conf[ctx_index],
584 cscfp[s]->ctx->srv_conf[ctx_index]);
585 if (rv != NGX_CONF_OK) {
586 goto failed;
587 }
588 }
589
590 if (module->merge_loc_conf) {
591
592 /* merge the server{}'s loc_conf */
593
594 ctx->loc_conf = cscfp[s]->ctx->loc_conf;
595
596 rv = module->merge_loc_conf(cf, saved.loc_conf[ctx_index],
597 cscfp[s]->ctx->loc_conf[ctx_index]);
598 if (rv != NGX_CONF_OK) {
599 goto failed;
600 }
601
602 /* merge the locations{}' loc_conf's */
603
604 clcf = cscfp[s]->ctx->loc_conf[ngx_http_core_module.ctx_index];
605
606 rv = ngx_http_merge_locations(cf, clcf->locations,
607 cscfp[s]->ctx->loc_conf,
608 module, ctx_index);
609 if (rv != NGX_CONF_OK) {
610 goto failed;
611 }
612 }
613 }
614
615 failed:
616
617 *ctx = saved;
618
619 return rv;
620 }
621
622
623 static char *
605 ngx_http_merge_locations(ngx_conf_t *cf, ngx_queue_t *locations, 624 ngx_http_merge_locations(ngx_conf_t *cf, ngx_queue_t *locations,
606 void **loc_conf, ngx_http_module_t *module, ngx_uint_t ctx_index) 625 void **loc_conf, ngx_http_module_t *module, ngx_uint_t ctx_index)
607 { 626 {
608 char *rv; 627 char *rv;
609 ngx_queue_t *q; 628 ngx_queue_t *q;
629 ngx_http_conf_ctx_t *ctx, saved;
610 ngx_http_core_loc_conf_t *clcf; 630 ngx_http_core_loc_conf_t *clcf;
611 ngx_http_location_queue_t *lq; 631 ngx_http_location_queue_t *lq;
612 632
613 if (locations == NULL) { 633 if (locations == NULL) {
614 return NGX_CONF_OK; 634 return NGX_CONF_OK;
615 } 635 }
636
637 ctx = (ngx_http_conf_ctx_t *) cf->ctx;
638 saved = *ctx;
616 639
617 for (q = ngx_queue_head(locations); 640 for (q = ngx_queue_head(locations);
618 q != ngx_queue_sentinel(locations); 641 q != ngx_queue_sentinel(locations);
619 q = ngx_queue_next(q)) 642 q = ngx_queue_next(q))
620 { 643 {
621 lq = (ngx_http_location_queue_t *) q; 644 lq = (ngx_http_location_queue_t *) q;
622 645
623 clcf = lq->exact ? lq->exact : lq->inclusive; 646 clcf = lq->exact ? lq->exact : lq->inclusive;
647 ctx->loc_conf = clcf->loc_conf;
624 648
625 rv = module->merge_loc_conf(cf, loc_conf[ctx_index], 649 rv = module->merge_loc_conf(cf, loc_conf[ctx_index],
626 clcf->loc_conf[ctx_index]); 650 clcf->loc_conf[ctx_index]);
627 if (rv != NGX_CONF_OK) { 651 if (rv != NGX_CONF_OK) {
628 return rv; 652 return rv;
632 module, ctx_index); 656 module, ctx_index);
633 if (rv != NGX_CONF_OK) { 657 if (rv != NGX_CONF_OK) {
634 return rv; 658 return rv;
635 } 659 }
636 } 660 }
661
662 *ctx = saved;
637 663
638 return NGX_CONF_OK; 664 return NGX_CONF_OK;
639 } 665 }
640 666
641 667
1107 1133
1108 return node; 1134 return node;
1109 } 1135 }
1110 1136
1111 1137
1112 static ngx_int_t 1138 ngx_int_t
1113 ngx_http_init_server_lists(ngx_conf_t *cf, ngx_array_t *servers, 1139 ngx_http_add_listen(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
1114 ngx_array_t *ports) 1140 ngx_http_listen_opt_t *lsopt)
1115 { 1141 {
1116 ngx_uint_t s, i; 1142 in_port_t p;
1117 ngx_http_listen_t *listen; 1143 ngx_uint_t i;
1118 ngx_http_core_srv_conf_t **cscfp; 1144 struct sockaddr *sa;
1119 1145 struct sockaddr_in *sin;
1120 if (ngx_array_init(ports, cf->temp_pool, 2, sizeof(ngx_http_conf_port_t)) 1146 ngx_http_conf_port_t *port;
1121 != NGX_OK) 1147 ngx_http_core_main_conf_t *cmcf;
1122 {
1123 return NGX_ERROR;
1124 }
1125
1126 /* "server" directives */
1127
1128 cscfp = servers->elts;
1129 for (s = 0; s < servers->nelts; s++) {
1130
1131 /* "listen" directives */
1132
1133 listen = cscfp[s]->listen.elts;
1134 for (i = 0; i < cscfp[s]->listen.nelts; i++) {
1135
1136 if (ngx_http_add_ports(cf, cscfp[s], ports, &listen[i]) != NGX_OK) {
1137 return NGX_ERROR;
1138 }
1139 }
1140 }
1141
1142 return NGX_OK;
1143 }
1144
1145
1146 static ngx_int_t
1147 ngx_http_add_ports(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
1148 ngx_array_t *ports, ngx_http_listen_t *listen)
1149 {
1150 in_port_t p;
1151 ngx_uint_t i;
1152 struct sockaddr *sa;
1153 struct sockaddr_in *sin;
1154 ngx_http_conf_port_t *port;
1155 #if (NGX_HAVE_INET6) 1148 #if (NGX_HAVE_INET6)
1156 struct sockaddr_in6 *sin6; 1149 struct sockaddr_in6 *sin6;
1157 #endif 1150 #endif
1158 1151
1159 sa = (struct sockaddr *) &listen->sockaddr; 1152 cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
1153
1154 if (cmcf->ports == NULL) {
1155 cmcf->ports = ngx_array_create(cf->temp_pool, 2,
1156 sizeof(ngx_http_conf_port_t));
1157 if (cmcf->ports == NULL) {
1158 return NGX_ERROR;
1159 }
1160 }
1161
1162 sa = &lsopt->u.sockaddr;
1160 1163
1161 switch (sa->sa_family) { 1164 switch (sa->sa_family) {
1162 1165
1163 #if (NGX_HAVE_INET6) 1166 #if (NGX_HAVE_INET6)
1164 case AF_INET6: 1167 case AF_INET6:
1165 sin6 = (struct sockaddr_in6 *) sa; 1168 sin6 = &lsopt->u.sockaddr_in6;
1166 p = sin6->sin6_port; 1169 p = sin6->sin6_port;
1167 break; 1170 break;
1168 #endif 1171 #endif
1169 1172
1173 #if (NGX_HAVE_UNIX_DOMAIN)
1174 case AF_UNIX:
1175 p = 0;
1176 break;
1177 #endif
1178
1170 default: /* AF_INET */ 1179 default: /* AF_INET */
1171 sin = (struct sockaddr_in *) sa; 1180 sin = &lsopt->u.sockaddr_in;
1172 p = sin->sin_port; 1181 p = sin->sin_port;
1173 break; 1182 break;
1174 } 1183 }
1175 1184
1176 port = ports->elts; 1185 port = cmcf->ports->elts;
1177 for (i = 0; i < ports->nelts; i++) { 1186 for (i = 0; i < cmcf->ports->nelts; i++) {
1178 1187
1179 if (p != port[i].port || sa->sa_family != port[i].family) { 1188 if (p != port[i].port || sa->sa_family != port[i].family) {
1180 continue; 1189 continue;
1181 } 1190 }
1182 1191
1183 /* a port is already in the port list */ 1192 /* a port is already in the port list */
1184 1193
1185 return ngx_http_add_addresses(cf, cscf, &port[i], listen); 1194 return ngx_http_add_addresses(cf, cscf, &port[i], lsopt);
1186 } 1195 }
1187 1196
1188 /* add a port to the port list */ 1197 /* add a port to the port list */
1189 1198
1190 port = ngx_array_push(ports); 1199 port = ngx_array_push(cmcf->ports);
1191 if (port == NULL) { 1200 if (port == NULL) {
1192 return NGX_ERROR; 1201 return NGX_ERROR;
1193 } 1202 }
1194 1203
1195 port->family = sa->sa_family; 1204 port->family = sa->sa_family;
1196 port->port = p; 1205 port->port = p;
1197 port->addrs.elts = NULL; 1206 port->addrs.elts = NULL;
1198 1207
1199 return ngx_http_add_address(cf, cscf, port, listen); 1208 return ngx_http_add_address(cf, cscf, port, lsopt);
1200 } 1209 }
1201 1210
1202 1211
1203 static ngx_int_t 1212 static ngx_int_t
1204 ngx_http_add_addresses(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf, 1213 ngx_http_add_addresses(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
1205 ngx_http_conf_port_t *port, ngx_http_listen_t *listen) 1214 ngx_http_conf_port_t *port, ngx_http_listen_opt_t *lsopt)
1206 { 1215 {
1207 u_char *p; 1216 u_char *p;
1208 size_t len, off; 1217 size_t len, off;
1209 ngx_uint_t i; 1218 ngx_uint_t i, default_server;
1210 struct sockaddr *sa; 1219 struct sockaddr *sa;
1211 ngx_http_conf_addr_t *addr; 1220 ngx_http_conf_addr_t *addr;
1221 #if (NGX_HAVE_UNIX_DOMAIN)
1222 struct sockaddr_un *saun;
1223 #endif
1224 #if (NGX_HTTP_SSL)
1225 ngx_uint_t ssl;
1226 #endif
1212 1227
1213 /* 1228 /*
1214 * we can not compare whole sockaddr struct's as kernel 1229 * we can not compare whole sockaddr struct's as kernel
1215 * may fill some fields in inherited sockaddr struct's 1230 * may fill some fields in inherited sockaddr struct's
1216 */ 1231 */
1217 1232
1218 sa = (struct sockaddr *) &listen->sockaddr; 1233 sa = &lsopt->u.sockaddr;
1219 1234
1220 switch (sa->sa_family) { 1235 switch (sa->sa_family) {
1221 1236
1222 #if (NGX_HAVE_INET6) 1237 #if (NGX_HAVE_INET6)
1223 case AF_INET6: 1238 case AF_INET6:
1224 off = offsetof(struct sockaddr_in6, sin6_addr); 1239 off = offsetof(struct sockaddr_in6, sin6_addr);
1225 len = 16; 1240 len = 16;
1226 break; 1241 break;
1227 #endif 1242 #endif
1228 1243
1244 #if (NGX_HAVE_UNIX_DOMAIN)
1245 case AF_UNIX:
1246 off = offsetof(struct sockaddr_un, sun_path);
1247 len = sizeof(saun->sun_path);
1248 break;
1249 #endif
1250
1229 default: /* AF_INET */ 1251 default: /* AF_INET */
1230 off = offsetof(struct sockaddr_in, sin_addr); 1252 off = offsetof(struct sockaddr_in, sin_addr);
1231 len = 4; 1253 len = 4;
1232 break; 1254 break;
1233 } 1255 }
1234 1256
1235 p = listen->sockaddr + off; 1257 p = lsopt->u.sockaddr_data + off;
1236 1258
1237 addr = port->addrs.elts; 1259 addr = port->addrs.elts;
1238 1260
1239 for (i = 0; i < port->addrs.nelts; i++) { 1261 for (i = 0; i < port->addrs.nelts; i++) {
1240 1262
1241 if (ngx_memcmp(p, (u_char *) addr[i].sockaddr + off, len) != 0) { 1263 if (ngx_memcmp(p, addr[i].opt.u.sockaddr_data + off, len) != 0) {
1242 continue; 1264 continue;
1243 } 1265 }
1244 1266
1245 /* the address is already in the address list */ 1267 /* the address is already in the address list */
1246 1268
1247 if (ngx_http_add_names(cf, cscf, &addr[i]) != NGX_OK) { 1269 if (ngx_http_add_server(cf, cscf, &addr[i]) != NGX_OK) {
1248 return NGX_ERROR; 1270 return NGX_ERROR;
1249 } 1271 }
1250 1272
1273 /* preserve default_server bit during listen options overwriting */
1274 default_server = addr[i].opt.default_server;
1275
1276 #if (NGX_HTTP_SSL)
1277 ssl = lsopt->ssl || addr[i].opt.ssl;
1278 #endif
1279
1280 if (lsopt->set) {
1281
1282 if (addr[i].opt.set) {
1283 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1284 "a duplicate listen options for %s", addr[i].opt.addr);
1285 return NGX_ERROR;
1286 }
1287
1288 addr[i].opt = *lsopt;
1289 }
1290
1251 /* check the duplicate "default" server for this address:port */ 1291 /* check the duplicate "default" server for this address:port */
1252 1292
1253 if (listen->conf.default_server) { 1293 if (lsopt->default_server) {
1254 1294
1255 if (addr[i].default_server) { 1295 if (default_server) {
1256 ngx_log_error(NGX_LOG_ERR, cf->log, 0, 1296 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1257 "the duplicate default server in %s:%ui", 1297 "a duplicate default server for %s", addr[i].opt.addr);
1258 listen->file_name, listen->line);
1259
1260 return NGX_ERROR; 1298 return NGX_ERROR;
1261 } 1299 }
1262 1300
1263 addr[i].core_srv_conf = cscf; 1301 default_server = 1;
1264 addr[i].default_server = 1; 1302 addr[i].default_server = cscf;
1303 }
1304
1305 addr[i].opt.default_server = default_server;
1265 #if (NGX_HTTP_SSL) 1306 #if (NGX_HTTP_SSL)
1266 addr[i].ssl = listen->conf.ssl; 1307 addr[i].opt.ssl = ssl;
1267 #endif 1308 #endif
1268 addr[i].listen_conf = &listen->conf;
1269 }
1270 1309
1271 return NGX_OK; 1310 return NGX_OK;
1272 } 1311 }
1273 1312
1274 /* add the address to the addresses list that bound to this port */ 1313 /* add the address to the addresses list that bound to this port */
1275 1314
1276 return ngx_http_add_address(cf, cscf, port, listen); 1315 return ngx_http_add_address(cf, cscf, port, lsopt);
1277 } 1316 }
1278 1317
1279 1318
1280 /* 1319 /*
1281 * add the server address, the server names and the server core module 1320 * add the server address, the server names and the server core module
1282 * configurations to the port list 1321 * configurations to the port list
1283 */ 1322 */
1284 1323
1285 static ngx_int_t 1324 static ngx_int_t
1286 ngx_http_add_address(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf, 1325 ngx_http_add_address(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
1287 ngx_http_conf_port_t *port, ngx_http_listen_t *listen) 1326 ngx_http_conf_port_t *port, ngx_http_listen_opt_t *lsopt)
1288 { 1327 {
1289 ngx_http_conf_addr_t *addr; 1328 ngx_http_conf_addr_t *addr;
1290 1329
1291 if (port->addrs.elts == NULL) { 1330 if (port->addrs.elts == NULL) {
1292 if (ngx_array_init(&port->addrs, cf->temp_pool, 4, 1331 if (ngx_array_init(&port->addrs, cf->temp_pool, 4,
1300 addr = ngx_array_push(&port->addrs); 1339 addr = ngx_array_push(&port->addrs);
1301 if (addr == NULL) { 1340 if (addr == NULL) {
1302 return NGX_ERROR; 1341 return NGX_ERROR;
1303 } 1342 }
1304 1343
1305 addr->sockaddr = (struct sockaddr *) &listen->sockaddr; 1344 addr->opt = *lsopt;
1306 addr->socklen = listen->socklen;
1307 addr->hash.buckets = NULL; 1345 addr->hash.buckets = NULL;
1308 addr->hash.size = 0; 1346 addr->hash.size = 0;
1309 addr->wc_head = NULL; 1347 addr->wc_head = NULL;
1310 addr->wc_tail = NULL; 1348 addr->wc_tail = NULL;
1311 addr->names.elts = NULL;
1312 #if (NGX_PCRE) 1349 #if (NGX_PCRE)
1313 addr->nregex = 0; 1350 addr->nregex = 0;
1314 addr->regex = NULL; 1351 addr->regex = NULL;
1315 #endif 1352 #endif
1316 addr->core_srv_conf = cscf; 1353 addr->default_server = cscf;
1317 addr->default_server = listen->conf.default_server; 1354 addr->servers.elts = NULL;
1318 addr->bind = listen->conf.bind; 1355
1319 addr->wildcard = listen->conf.wildcard; 1356 return ngx_http_add_server(cf, cscf, addr);
1320 #if (NGX_HTTP_SSL) 1357 }
1321 addr->ssl = listen->conf.ssl; 1358
1322 #endif 1359
1323 addr->listen_conf = &listen->conf; 1360 /* add the server core module configuration to the address:port */
1324
1325 return ngx_http_add_names(cf, cscf, addr);
1326 }
1327
1328
1329 /*
1330 * add the server names and the server core module
1331 * configurations to the address:port
1332 */
1333 1361
1334 static ngx_int_t 1362 static ngx_int_t
1335 ngx_http_add_names(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf, 1363 ngx_http_add_server(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
1336 ngx_http_conf_addr_t *addr) 1364 ngx_http_conf_addr_t *addr)
1337 { 1365 {
1338 ngx_uint_t i; 1366 ngx_uint_t i;
1339 ngx_http_server_name_t *server_names, *name; 1367 ngx_http_core_srv_conf_t **server;
1340 1368
1341 if (addr->names.elts == NULL) { 1369 if (addr->servers.elts == NULL) {
1342 if (ngx_array_init(&addr->names, cf->temp_pool, 4, 1370 if (ngx_array_init(&addr->servers, cf->temp_pool, 4,
1343 sizeof(ngx_http_server_name_t)) 1371 sizeof(ngx_http_core_srv_conf_t *))
1344 != NGX_OK) 1372 != NGX_OK)
1345 { 1373 {
1346 return NGX_ERROR; 1374 return NGX_ERROR;
1347 } 1375 }
1348 } 1376
1349 1377 } else {
1350 server_names = cscf->server_names.elts; 1378 server = addr->servers.elts;
1351 1379 for (i = 0; i < addr->servers.nelts; i++) {
1352 for (i = 0; i < cscf->server_names.nelts; i++) { 1380 if (server[i] == cscf) {
1353 1381 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1354 ngx_strlow(server_names[i].name.data, server_names[i].name.data, 1382 "a duplicate listen %s", addr->opt.addr);
1355 server_names[i].name.len); 1383 return NGX_ERROR;
1356 1384 }
1357 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, cf->log, 0, 1385 }
1358 "name: %V", &server_names[i].name); 1386 }
1359 1387
1360 name = ngx_array_push(&addr->names); 1388 server = ngx_array_push(&addr->servers);
1361 if (name == NULL) { 1389 if (server == NULL) {
1362 return NGX_ERROR; 1390 return NGX_ERROR;
1363 } 1391 }
1364 1392
1365 *name = server_names[i]; 1393 *server = cscf;
1366 }
1367 1394
1368 return NGX_OK; 1395 return NGX_OK;
1369 } 1396 }
1370 1397
1371 1398
1372 static ngx_int_t 1399 static ngx_int_t
1373 ngx_http_optimize_servers(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf, 1400 ngx_http_optimize_servers(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf,
1374 ngx_array_t *ports) 1401 ngx_array_t *ports)
1375 { 1402 {
1376 ngx_uint_t s, p, a; 1403 ngx_uint_t p, a;
1377 ngx_http_conf_port_t *port; 1404 ngx_http_conf_port_t *port;
1378 ngx_http_conf_addr_t *addr; 1405 ngx_http_conf_addr_t *addr;
1379 ngx_http_server_name_t *name; 1406
1407 if (ports == NULL) {
1408 return NGX_OK;
1409 }
1380 1410
1381 port = ports->elts; 1411 port = ports->elts;
1382 for (p = 0; p < ports->nelts; p++) { 1412 for (p = 0; p < ports->nelts; p++) {
1383 1413
1384 ngx_sort(port[p].addrs.elts, (size_t) port[p].addrs.nelts, 1414 ngx_sort(port[p].addrs.elts, (size_t) port[p].addrs.nelts,
1390 */ 1420 */
1391 1421
1392 addr = port[p].addrs.elts; 1422 addr = port[p].addrs.elts;
1393 for (a = 0; a < port[p].addrs.nelts; a++) { 1423 for (a = 0; a < port[p].addrs.nelts; a++) {
1394 1424
1395 name = addr[a].names.elts; 1425 if (addr[a].servers.nelts > 1
1396 for (s = 0; s < addr[a].names.nelts; s++) {
1397
1398 if (addr[a].core_srv_conf == name[s].core_srv_conf
1399 #if (NGX_PCRE) 1426 #if (NGX_PCRE)
1400 && name[s].captures == 0 1427 || addr[a].default_server->captures
1401 #endif 1428 #endif
1402 ) 1429 )
1403 { 1430 {
1404 continue;
1405 }
1406
1407 if (ngx_http_server_names(cf, cmcf, &addr[a]) != NGX_OK) { 1431 if (ngx_http_server_names(cf, cmcf, &addr[a]) != NGX_OK) {
1408 return NGX_ERROR; 1432 return NGX_ERROR;
1409 } 1433 }
1410
1411 break;
1412 } 1434 }
1413 } 1435 }
1414 1436
1415 if (ngx_http_init_listening(cf, &port[p]) != NGX_OK) { 1437 if (ngx_http_init_listening(cf, &port[p]) != NGX_OK) {
1416 return NGX_ERROR; 1438 return NGX_ERROR;
1423 1445
1424 static ngx_int_t 1446 static ngx_int_t
1425 ngx_http_server_names(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf, 1447 ngx_http_server_names(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf,
1426 ngx_http_conf_addr_t *addr) 1448 ngx_http_conf_addr_t *addr)
1427 { 1449 {
1428 ngx_int_t rc; 1450 ngx_int_t rc;
1429 ngx_uint_t s; 1451 ngx_uint_t n, s;
1430 ngx_hash_init_t hash; 1452 ngx_hash_init_t hash;
1431 ngx_hash_keys_arrays_t ha; 1453 ngx_hash_keys_arrays_t ha;
1432 ngx_http_server_name_t *name; 1454 ngx_http_server_name_t *name;
1455 ngx_http_core_srv_conf_t **cscfp;
1433 #if (NGX_PCRE) 1456 #if (NGX_PCRE)
1434 ngx_uint_t regex, i; 1457 ngx_uint_t regex, i;
1435 1458
1436 regex = 0; 1459 regex = 0;
1437 #endif 1460 #endif
1438 1461
1439 ngx_memzero(&ha, sizeof(ngx_hash_keys_arrays_t)); 1462 ngx_memzero(&ha, sizeof(ngx_hash_keys_arrays_t));
1447 1470
1448 if (ngx_hash_keys_array_init(&ha, NGX_HASH_LARGE) != NGX_OK) { 1471 if (ngx_hash_keys_array_init(&ha, NGX_HASH_LARGE) != NGX_OK) {
1449 goto failed; 1472 goto failed;
1450 } 1473 }
1451 1474
1452 name = addr->names.elts; 1475 cscfp = addr->servers.elts;
1453 1476
1454 for (s = 0; s < addr->names.nelts; s++) { 1477 for (s = 0; s < addr->servers.nelts; s++) {
1478
1479 name = cscfp[s]->server_names.elts;
1480
1481 for (n = 0; n < cscfp[s]->server_names.nelts; n++) {
1455 1482
1456 #if (NGX_PCRE) 1483 #if (NGX_PCRE)
1457 if (name[s].regex) { 1484 if (name[n].regex) {
1458 regex++; 1485 regex++;
1459 continue; 1486 continue;
1460 } 1487 }
1461 #endif 1488 #endif
1462 1489
1463 rc = ngx_hash_add_key(&ha, &name[s].name, name[s].core_srv_conf, 1490 rc = ngx_hash_add_key(&ha, &name[n].name, name[n].server,
1464 NGX_HASH_WILDCARD_KEY); 1491 NGX_HASH_WILDCARD_KEY);
1465 1492
1466 if (rc == NGX_ERROR) { 1493 if (rc == NGX_ERROR) {
1467 return NGX_ERROR; 1494 return NGX_ERROR;
1468 } 1495 }
1469 1496
1470 if (rc == NGX_DECLINED) { 1497 if (rc == NGX_DECLINED) {
1471 ngx_log_error(NGX_LOG_EMERG, cf->log, 0, 1498 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
1472 "invalid server name or wildcard \"%V\" on %s", 1499 "invalid server name or wildcard \"%V\" on %s",
1473 &name[s].name, addr->listen_conf->addr); 1500 &name[n].name, addr->opt.addr);
1474 return NGX_ERROR; 1501 return NGX_ERROR;
1475 } 1502 }
1476 1503
1477 if (rc == NGX_BUSY) { 1504 if (rc == NGX_BUSY) {
1478 ngx_log_error(NGX_LOG_WARN, cf->log, 0, 1505 ngx_log_error(NGX_LOG_WARN, cf->log, 0,
1479 "conflicting server name \"%V\" on %s, ignored", 1506 "conflicting server name \"%V\" on %s, ignored",
1480 &name[s].name, addr->listen_conf->addr); 1507 &name[n].name, addr->opt.addr);
1508 }
1481 } 1509 }
1482 } 1510 }
1483 1511
1484 hash.key = ngx_hash_key_lc; 1512 hash.key = ngx_hash_key_lc;
1485 hash.max_size = cmcf->server_names_hash_max_size; 1513 hash.max_size = cmcf->server_names_hash_max_size;
1544 addr->regex = ngx_palloc(cf->pool, regex * sizeof(ngx_http_server_name_t)); 1572 addr->regex = ngx_palloc(cf->pool, regex * sizeof(ngx_http_server_name_t));
1545 if (addr->regex == NULL) { 1573 if (addr->regex == NULL) {
1546 return NGX_ERROR; 1574 return NGX_ERROR;
1547 } 1575 }
1548 1576
1549 for (i = 0, s = 0; s < addr->names.nelts; s++) { 1577 i = 0;
1550 if (name[s].regex) { 1578
1551 addr->regex[i++] = name[s]; 1579 for (s = 0; s < addr->servers.nelts; s++) {
1580
1581 name = cscfp[s]->server_names.elts;
1582
1583 for (n = 0; n < cscfp[s]->server_names.nelts; n++) {
1584 if (name[n].regex) {
1585 addr->regex[i++] = name[n];
1586 }
1552 } 1587 }
1553 } 1588 }
1554 1589
1555 #endif 1590 #endif
1556 1591
1570 ngx_http_conf_addr_t *first, *second; 1605 ngx_http_conf_addr_t *first, *second;
1571 1606
1572 first = (ngx_http_conf_addr_t *) one; 1607 first = (ngx_http_conf_addr_t *) one;
1573 second = (ngx_http_conf_addr_t *) two; 1608 second = (ngx_http_conf_addr_t *) two;
1574 1609
1575 if (first->wildcard) { 1610 if (first->opt.wildcard) {
1576 /* a wildcard address must be the last resort, shift it to the end */ 1611 /* a wildcard address must be the last resort, shift it to the end */
1577 return 1; 1612 return 1;
1578 } 1613 }
1579 1614
1580 if (first->bind && !second->bind) { 1615 if (first->opt.bind && !second->opt.bind) {
1581 /* shift explicit bind()ed addresses to the start */ 1616 /* shift explicit bind()ed addresses to the start */
1582 return -1; 1617 return -1;
1583 } 1618 }
1584 1619
1585 if (!first->bind && second->bind) { 1620 if (!first->opt.bind && second->opt.bind) {
1586 /* shift explicit bind()ed addresses to the start */ 1621 /* shift explicit bind()ed addresses to the start */
1587 return 1; 1622 return 1;
1588 } 1623 }
1589 1624
1590 /* do not sort by default */ 1625 /* do not sort by default */
1621 * the "*:port" only and ignore other implicit bindings. The bindings 1656 * the "*:port" only and ignore other implicit bindings. The bindings
1622 * have been already sorted: explicit bindings are on the start, then 1657 * have been already sorted: explicit bindings are on the start, then
1623 * implicit bindings go, and wildcard binding is in the end. 1658 * implicit bindings go, and wildcard binding is in the end.
1624 */ 1659 */
1625 1660
1626 if (addr[last - 1].wildcard) { 1661 if (addr[last - 1].opt.wildcard) {
1627 addr[last - 1].bind = 1; 1662 addr[last - 1].opt.bind = 1;
1628 bind_wildcard = 1; 1663 bind_wildcard = 1;
1629 1664
1630 } else { 1665 } else {
1631 bind_wildcard = 0; 1666 bind_wildcard = 0;
1632 } 1667 }
1633 1668
1634 i = 0; 1669 i = 0;
1635 1670
1636 while (i < last) { 1671 while (i < last) {
1637 1672
1638 if (bind_wildcard && !addr[i].bind) { 1673 if (bind_wildcard && !addr[i].opt.bind) {
1639 i++; 1674 i++;
1640 continue; 1675 continue;
1641 } 1676 }
1642 1677
1643 ls = ngx_http_add_listening(cf, &addr[i]); 1678 ls = ngx_http_add_listening(cf, &addr[i]);
1689 { 1724 {
1690 ngx_listening_t *ls; 1725 ngx_listening_t *ls;
1691 ngx_http_core_loc_conf_t *clcf; 1726 ngx_http_core_loc_conf_t *clcf;
1692 ngx_http_core_srv_conf_t *cscf; 1727 ngx_http_core_srv_conf_t *cscf;
1693 1728
1694 ls = ngx_create_listening(cf, addr->sockaddr, addr->socklen); 1729 ls = ngx_create_listening(cf, &addr->opt.u.sockaddr, addr->opt.socklen);
1695 if (ls == NULL) { 1730 if (ls == NULL) {
1696 return NULL; 1731 return NULL;
1697 } 1732 }
1698 1733
1699 ls->addr_ntop = 1; 1734 ls->addr_ntop = 1;
1700 1735
1701 ls->handler = ngx_http_init_connection; 1736 ls->handler = ngx_http_init_connection;
1702 1737
1703 cscf = addr->core_srv_conf; 1738 cscf = addr->default_server;
1704 ls->pool_size = cscf->connection_pool_size; 1739 ls->pool_size = cscf->connection_pool_size;
1705 ls->post_accept_timeout = cscf->client_header_timeout; 1740 ls->post_accept_timeout = cscf->client_header_timeout;
1706 1741
1707 clcf = cscf->ctx->loc_conf[ngx_http_core_module.ctx_index]; 1742 clcf = cscf->ctx->loc_conf[ngx_http_core_module.ctx_index];
1708 1743
1719 ls->post_accept_buffer_size = cscf->client_header_buffer_size; 1754 ls->post_accept_buffer_size = cscf->client_header_buffer_size;
1720 } 1755 }
1721 } 1756 }
1722 #endif 1757 #endif
1723 1758
1724 ls->backlog = addr->listen_conf->backlog; 1759 ls->backlog = addr->opt.backlog;
1725 ls->rcvbuf = addr->listen_conf->rcvbuf; 1760 ls->rcvbuf = addr->opt.rcvbuf;
1726 ls->sndbuf = addr->listen_conf->sndbuf; 1761 ls->sndbuf = addr->opt.sndbuf;
1727 1762
1728 #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER) 1763 #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
1729 ls->accept_filter = addr->listen_conf->accept_filter; 1764 ls->accept_filter = addr->opt.accept_filter;
1730 #endif 1765 #endif
1731 1766
1732 #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT) 1767 #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
1733 ls->deferred_accept = addr->listen_conf->deferred_accept; 1768 ls->deferred_accept = addr->opt.deferred_accept;
1734 #endif 1769 #endif
1735 1770
1736 #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY) 1771 #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)
1737 ls->ipv6only = addr->listen_conf->ipv6only; 1772 ls->ipv6only = addr->opt.ipv6only;
1773 #endif
1774
1775 #if (NGX_HAVE_SETFIB)
1776 ls->setfib = addr->opt.setfib;
1738 #endif 1777 #endif
1739 1778
1740 return ls; 1779 return ls;
1741 } 1780 }
1742 1781
1758 1797
1759 addrs = hport->addrs; 1798 addrs = hport->addrs;
1760 1799
1761 for (i = 0; i < hport->naddrs; i++) { 1800 for (i = 0; i < hport->naddrs; i++) {
1762 1801
1763 sin = (struct sockaddr_in *) addr[i].sockaddr; 1802 sin = &addr[i].opt.u.sockaddr_in;
1764 addrs[i].addr = sin->sin_addr.s_addr; 1803 addrs[i].addr = sin->sin_addr.s_addr;
1765 addrs[i].conf.core_srv_conf = addr[i].core_srv_conf; 1804 addrs[i].conf.default_server = addr[i].default_server;
1766 #if (NGX_HTTP_SSL) 1805 #if (NGX_HTTP_SSL)
1767 addrs[i].conf.ssl = addr[i].ssl; 1806 addrs[i].conf.ssl = addr[i].opt.ssl;
1768 #endif 1807 #endif
1769 1808
1770 if (addr[i].hash.buckets == NULL 1809 if (addr[i].hash.buckets == NULL
1771 && (addr[i].wc_head == NULL 1810 && (addr[i].wc_head == NULL
1772 || addr[i].wc_head->hash.buckets == NULL) 1811 || addr[i].wc_head->hash.buckets == NULL)
1819 1858
1820 addrs6 = hport->addrs; 1859 addrs6 = hport->addrs;
1821 1860
1822 for (i = 0; i < hport->naddrs; i++) { 1861 for (i = 0; i < hport->naddrs; i++) {
1823 1862
1824 sin6 = (struct sockaddr_in6 *) addr[i].sockaddr; 1863 sin6 = &addr[i].opt.u.sockaddr_in6;
1825 addrs6[i].addr6 = sin6->sin6_addr; 1864 addrs6[i].addr6 = sin6->sin6_addr;
1826 addrs6[i].conf.core_srv_conf = addr[i].core_srv_conf; 1865 addrs6[i].conf.default_server = addr[i].default_server;
1827 #if (NGX_HTTP_SSL) 1866 #if (NGX_HTTP_SSL)
1828 addrs6[i].conf.ssl = addr[i].ssl; 1867 addrs6[i].conf.ssl = addr[i].opt.ssl;
1829 #endif 1868 #endif
1830 1869
1831 if (addr[i].hash.buckets == NULL 1870 if (addr[i].hash.buckets == NULL
1832 && (addr[i].wc_head == NULL 1871 && (addr[i].wc_head == NULL
1833 || addr[i].wc_head->hash.buckets == NULL) 1872 || addr[i].wc_head->hash.buckets == NULL)
1834 && (addr[i].wc_head == NULL 1873 && (addr[i].wc_tail == NULL
1835 || addr[i].wc_head->hash.buckets == NULL)) 1874 || addr[i].wc_tail->hash.buckets == NULL)
1875 #if (NGX_PCRE)
1876 && addr[i].nregex == 0
1877 #endif
1878 )
1836 { 1879 {
1837 continue; 1880 continue;
1838 } 1881 }
1839 1882
1840 vn = ngx_palloc(cf->pool, sizeof(ngx_http_virtual_names_t)); 1883 vn = ngx_palloc(cf->pool, sizeof(ngx_http_virtual_names_t));
1869 ngx_uint_t i, n, hash; 1912 ngx_uint_t i, n, hash;
1870 ngx_hash_key_t *type; 1913 ngx_hash_key_t *type;
1871 1914
1872 types = (ngx_array_t **) (p + cmd->offset); 1915 types = (ngx_array_t **) (p + cmd->offset);
1873 1916
1917 if (*types == (void *) -1) {
1918 return NGX_CONF_OK;
1919 }
1920
1874 default_type = cmd->post; 1921 default_type = cmd->post;
1875 1922
1876 if (*types == NULL) { 1923 if (*types == NULL) {
1877 *types = ngx_array_create(cf->temp_pool, 1, sizeof(ngx_hash_key_t)); 1924 *types = ngx_array_create(cf->temp_pool, 1, sizeof(ngx_hash_key_t));
1878 if (*types == NULL) { 1925 if (*types == NULL) {
1894 1941
1895 value = cf->args->elts; 1942 value = cf->args->elts;
1896 1943
1897 for (i = 1; i < cf->args->nelts; i++) { 1944 for (i = 1; i < cf->args->nelts; i++) {
1898 1945
1946 if (value[i].len == 1 && value[i].data[0] == '*') {
1947 *types = (void *) -1;
1948 return NGX_CONF_OK;
1949 }
1950
1899 hash = ngx_hash_strlow(value[i].data, value[i].data, value[i].len); 1951 hash = ngx_hash_strlow(value[i].data, value[i].data, value[i].len);
1900 value[i].data[value[i].len] = '\0'; 1952 value[i].data[value[i].len] = '\0';
1901 1953
1902 type = (*types)->elts; 1954 type = (*types)->elts;
1903 for (n = 0; n < (*types)->nelts; n++) { 1955 for (n = 0; n < (*types)->nelts; n++) {
1922 return NGX_CONF_OK; 1974 return NGX_CONF_OK;
1923 } 1975 }
1924 1976
1925 1977
1926 char * 1978 char *
1927 ngx_http_merge_types(ngx_conf_t *cf, ngx_array_t *keys, ngx_hash_t *types_hash, 1979 ngx_http_merge_types(ngx_conf_t *cf, ngx_array_t **keys, ngx_hash_t *types_hash,
1928 ngx_array_t *prev_keys, ngx_hash_t *prev_types_hash, 1980 ngx_array_t **prev_keys, ngx_hash_t *prev_types_hash,
1929 ngx_str_t *default_types) 1981 ngx_str_t *default_types)
1930 { 1982 {
1931 ngx_hash_init_t hash; 1983 ngx_hash_init_t hash;
1932 1984
1933 if (keys) { 1985 if (*keys) {
1986
1987 if (*keys == (void *) -1) {
1988 return NGX_CONF_OK;
1989 }
1934 1990
1935 hash.hash = types_hash; 1991 hash.hash = types_hash;
1936 hash.key = NULL; 1992 hash.key = NULL;
1937 hash.max_size = 2048; 1993 hash.max_size = 2048;
1938 hash.bucket_size = 64; 1994 hash.bucket_size = 64;
1939 hash.name = "test_types_hash"; 1995 hash.name = "test_types_hash";
1940 hash.pool = cf->pool; 1996 hash.pool = cf->pool;
1941 hash.temp_pool = NULL; 1997 hash.temp_pool = NULL;
1942 1998
1943 if (ngx_hash_init(&hash, keys->elts, keys->nelts) != NGX_OK) { 1999 if (ngx_hash_init(&hash, (*keys)->elts, (*keys)->nelts) != NGX_OK) {
1944 return NGX_CONF_ERROR; 2000 return NGX_CONF_ERROR;
1945 } 2001 }
1946 2002
1947 return NGX_CONF_OK; 2003 return NGX_CONF_OK;
1948 } 2004 }
1949 2005
1950 if (prev_types_hash->buckets == NULL) { 2006 if (prev_types_hash->buckets == NULL) {
1951 2007
1952 if (prev_keys == NULL) { 2008 if (*prev_keys == NULL) {
1953 2009
1954 if (ngx_http_set_default_types(cf, &prev_keys, default_types) 2010 if (ngx_http_set_default_types(cf, prev_keys, default_types)
1955 != NGX_OK) 2011 != NGX_OK)
1956 { 2012 {
1957 return NGX_CONF_ERROR; 2013 return NGX_CONF_ERROR;
1958 } 2014 }
2015
2016 } else if (*prev_keys == (void *) -1) {
2017 *keys = *prev_keys;
2018 return NGX_CONF_OK;
1959 } 2019 }
1960 2020
1961 hash.hash = prev_types_hash; 2021 hash.hash = prev_types_hash;
1962 hash.key = NULL; 2022 hash.key = NULL;
1963 hash.max_size = 2048; 2023 hash.max_size = 2048;
1964 hash.bucket_size = 64; 2024 hash.bucket_size = 64;
1965 hash.name = "test_types_hash"; 2025 hash.name = "test_types_hash";
1966 hash.pool = cf->pool; 2026 hash.pool = cf->pool;
1967 hash.temp_pool = NULL; 2027 hash.temp_pool = NULL;
1968 2028
1969 if (ngx_hash_init(&hash, prev_keys->elts, prev_keys->nelts) != NGX_OK) { 2029 if (ngx_hash_init(&hash, (*prev_keys)->elts, (*prev_keys)->nelts)
2030 != NGX_OK)
2031 {
1970 return NGX_CONF_ERROR; 2032 return NGX_CONF_ERROR;
1971 } 2033 }
1972 } 2034 }
1973 2035
1974 *types_hash = *prev_types_hash; 2036 *types_hash = *prev_types_hash;