?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
nginx 0.8.35
[nginx-catap.git] / src / core / nginx.c
bloba5fbccd407f7c031e2ec9d558eebbf7e80402b92
1
2 /*
3 * Copyright (C) Igor Sysoev
4 */
5
6
7 #include <ngx_config.h>
8 #include <ngx_core.h>
9 #include <nginx.h>
10
11
12 static ngx_int_t ngx_add_inherited_sockets(ngx_cycle_t *cycle);
13 static ngx_int_t ngx_get_options(int argc, char *const *argv);
14 static ngx_int_t ngx_process_options(ngx_cycle_t *cycle);
15 static ngx_int_t ngx_save_argv(ngx_cycle_t *cycle, int argc, char *const *argv);
16 static void *ngx_core_module_create_conf(ngx_cycle_t *cycle);
17 static char *ngx_core_module_init_conf(ngx_cycle_t *cycle, void *conf);
18 static char *ngx_set_user(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
19 static char *ngx_set_env(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
20 static char *ngx_set_priority(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
21 static char *ngx_set_cpu_affinity(ngx_conf_t *cf, ngx_command_t *cmd,
22 void *conf);
23
24
25 static ngx_conf_enum_t ngx_debug_points[] = {
26 { ngx_string("stop"), NGX_DEBUG_POINTS_STOP },
27 { ngx_string("abort"), NGX_DEBUG_POINTS_ABORT },
28 { ngx_null_string, 0 }
29 };
30
31
32 static ngx_command_t ngx_core_commands[] = {
33
34 { ngx_string("daemon"),
35 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_FLAG,
36 ngx_conf_set_flag_slot,
37 0,
38 offsetof(ngx_core_conf_t, daemon),
39 NULL },
40
41 { ngx_string("master_process"),
42 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_FLAG,
43 ngx_conf_set_flag_slot,
44 0,
45 offsetof(ngx_core_conf_t, master),
46 NULL },
47
48 { ngx_string("timer_resolution"),
49 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
50 ngx_conf_set_msec_slot,
51 0,
52 offsetof(ngx_core_conf_t, timer_resolution),
53 NULL },
54
55 { ngx_string("pid"),
56 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
57 ngx_conf_set_str_slot,
58 0,
59 offsetof(ngx_core_conf_t, pid),
60 NULL },
61
62 { ngx_string("lock_file"),
63 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
64 ngx_conf_set_str_slot,
65 0,
66 offsetof(ngx_core_conf_t, lock_file),
67 NULL },
68
69 { ngx_string("worker_processes"),
70 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
71 ngx_conf_set_num_slot,
72 0,
73 offsetof(ngx_core_conf_t, worker_processes),
74 NULL },
75
76 { ngx_string("debug_points"),
77 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
78 ngx_conf_set_enum_slot,
79 0,
80 offsetof(ngx_core_conf_t, debug_points),
81 &ngx_debug_points },
82
83 { ngx_string("user"),
84 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE12,
85 ngx_set_user,
86 0,
87 0,
88 NULL },
89
90 { ngx_string("worker_priority"),
91 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
92 ngx_set_priority,
93 0,
94 0,
95 NULL },
96
97 { ngx_string("worker_cpu_affinity"),
98 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_1MORE,
99 ngx_set_cpu_affinity,
100 0,
101 0,
102 NULL },
103
104 { ngx_string("worker_rlimit_nofile"),
105 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
106 ngx_conf_set_num_slot,
107 0,
108 offsetof(ngx_core_conf_t, rlimit_nofile),
109 NULL },
110
111 { ngx_string("worker_rlimit_core"),
112 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
113 ngx_conf_set_size_slot,
114 0,
115 offsetof(ngx_core_conf_t, rlimit_core),
116 NULL },
117
118 { ngx_string("worker_rlimit_sigpending"),
119 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
120 ngx_conf_set_num_slot,
121 0,
122 offsetof(ngx_core_conf_t, rlimit_sigpending),
123 NULL },
124
125 { ngx_string("working_directory"),
126 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
127 ngx_conf_set_str_slot,
128 0,
129 offsetof(ngx_core_conf_t, working_directory),
130 NULL },
131
132 { ngx_string("env"),
133 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
134 ngx_set_env,
135 0,
136 0,
137 NULL },
138
139 #if (NGX_THREADS)
140
141 { ngx_string("worker_threads"),
142 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
143 ngx_conf_set_num_slot,
144 0,
145 offsetof(ngx_core_conf_t, worker_threads),
146 NULL },
147
148 { ngx_string("thread_stack_size"),
149 NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
150 ngx_conf_set_size_slot,
151 0,
152 offsetof(ngx_core_conf_t, thread_stack_size),
153 NULL },
154
155 #endif
156
157 ngx_null_command
158 };
159
160
161 static ngx_core_module_t ngx_core_module_ctx = {
162 ngx_string("core"),
163 ngx_core_module_create_conf,
164 ngx_core_module_init_conf
165 };
166
167
168 ngx_module_t ngx_core_module = {
169 NGX_MODULE_V1,
170 &ngx_core_module_ctx, /* module context */
171 ngx_core_commands, /* module directives */
172 NGX_CORE_MODULE, /* module type */
173 NULL, /* init master */
174 NULL, /* init module */
175 NULL, /* init process */
176 NULL, /* init thread */
177 NULL, /* exit thread */
178 NULL, /* exit process */
179 NULL, /* exit master */
180 NGX_MODULE_V1_PADDING
181 };
182
183
184 ngx_uint_t ngx_max_module;
185
186 static ngx_uint_t ngx_show_help;
187 static ngx_uint_t ngx_show_version;
188 static ngx_uint_t ngx_show_configure;
189 static u_char *ngx_prefix;
190 static u_char *ngx_conf_file;
191 static u_char *ngx_conf_params;
192 static char *ngx_signal;
193
194
195 static char **ngx_os_environ;
196
197
198 int ngx_cdecl
199 main(int argc, char *const *argv)
200 {
201 ngx_int_t i;
202 ngx_log_t *log;
203 ngx_cycle_t *cycle, init_cycle;
204 ngx_core_conf_t *ccf;
205
206 if (ngx_get_options(argc, argv) != NGX_OK) {
207 return 1;
208 }
209
210 if (ngx_show_version) {
211 ngx_log_stderr(0, "nginx version: " NGINX_VER);
212
213 if (ngx_show_help) {
214 ngx_log_stderr(0,
215 "Usage: nginx [-?hvVt] [-s signal] [-c filename] "
216 "[-p prefix] [-g directives]" CRLF CRLF
217 "Options:" CRLF
218 " -?,-h : this help" CRLF
219 " -v : show version and exit" CRLF
220 " -V : show version and configure options then exit"
221 CRLF
222 " -t : test configuration and exit" CRLF
223 " -s signal : send signal to a master process: "
224 "stop, quit, reopen, reload" CRLF
225 #ifdef NGX_PREFIX
226 " -p prefix : set prefix path (default: "
227 NGX_PREFIX ")" CRLF
228 #else
229 " -p prefix : set prefix path (default: NONE)" CRLF
230 #endif
231 " -c filename : set configuration file (default: "
232 NGX_CONF_PATH ")" CRLF
233 " -g directives : set global directives out of configuration "
234 "file" CRLF
235 );
236 }
237
238 if (ngx_show_configure) {
239 #ifdef NGX_COMPILER
240 ngx_log_stderr(0, "built by " NGX_COMPILER);
241 #endif
242 #if (NGX_SSL)
243 #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
244 ngx_log_stderr(0, "TLS SNI support enabled");
245 #else
246 ngx_log_stderr(0, "TLS SNI support disabled");
247 #endif
248 #endif
249 ngx_log_stderr(0, "configure arguments:" NGX_CONFIGURE);
250 }
251
252 if (!ngx_test_config) {
253 return 0;
254 }
255 }
256
257 #if (NGX_FREEBSD)
258 ngx_debug_init();
259 #endif
260
261 /* TODO */ ngx_max_sockets = -1;
262
263 ngx_time_init();
264
265 #if (NGX_PCRE)
266 ngx_regex_init();
267 #endif
268
269 ngx_pid = ngx_getpid();
270
271 log = ngx_log_init(ngx_prefix);
272 if (log == NULL) {
273 return 1;
274 }
275
276 /* STUB */
277 #if (NGX_OPENSSL)
278 ngx_ssl_init(log);
279 #endif
280
281 /*
282 * init_cycle->log is required for signal handlers and
283 * ngx_process_options()
284 */
285
286 ngx_memzero(&init_cycle, sizeof(ngx_cycle_t));
287 init_cycle.log = log;
288 ngx_cycle = &init_cycle;
289
290 init_cycle.pool = ngx_create_pool(1024, log);
291 if (init_cycle.pool == NULL) {
292 return 1;
293 }
294
295 if (ngx_save_argv(&init_cycle, argc, argv) != NGX_OK) {
296 return 1;
297 }
298
299 if (ngx_process_options(&init_cycle) != NGX_OK) {
300 return 1;
301 }
302
303 if (ngx_os_init(log) != NGX_OK) {
304 return 1;
305 }
306
307 /*
308 * ngx_crc32_table_init() requires ngx_cacheline_size set in ngx_os_init()
309 */
310
311 if (ngx_crc32_table_init() != NGX_OK) {
312 return 1;
313 }
314
315 if (ngx_add_inherited_sockets(&init_cycle) != NGX_OK) {
316 return 1;
317 }
318
319 ngx_max_module = 0;
320 for (i = 0; ngx_modules[i]; i++) {
321 ngx_modules[i]->index = ngx_max_module++;
322 }
323
324 cycle = ngx_init_cycle(&init_cycle);
325 if (cycle == NULL) {
326 if (ngx_test_config) {
327 ngx_log_stderr(0, "configuration file %s test failed",
328 init_cycle.conf_file.data);
329 }
330
331 return 1;
332 }
333
334 if (ngx_test_config) {
335 ngx_log_stderr(0, "configuration file %s test is successful",
336 cycle->conf_file.data);
337 return 0;
338 }
339
340 if (ngx_signal) {
341 return ngx_signal_process(cycle, ngx_signal);
342 }
343
344 ngx_os_status(cycle->log);
345
346 ngx_cycle = cycle;
347
348 ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
349
350 if (ccf->master && ngx_process == NGX_PROCESS_SINGLE) {
351 ngx_process = NGX_PROCESS_MASTER;
352 }
353
354 #if !(NGX_WIN32)
355
356 if (ngx_init_signals(cycle->log) != NGX_OK) {
357 return 1;
358 }
359
360 if (!ngx_inherited && ccf->daemon) {
361 if (ngx_daemon(cycle->log) != NGX_OK) {
362 return 1;
363 }
364
365 ngx_daemonized = 1;
366 }
367
368 #endif
369
370 if (ngx_create_pidfile(&ccf->pid, cycle->log) != NGX_OK) {
371 return 1;
372 }
373
374 if (cycle->log->file->fd != ngx_stderr) {
375
376 if (ngx_set_stderr(cycle->log->file->fd) == NGX_FILE_ERROR) {
377 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
378 ngx_set_stderr_n " failed");
379 return 1;
380 }
381 }
382
383 if (log->file->fd != ngx_stderr) {
384 if (ngx_close_file(log->file->fd) == NGX_FILE_ERROR) {
385 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
386 ngx_close_file_n " built-in log failed");
387 }
388 }
389
390 ngx_use_stderr = 0;
391
392 if (ngx_process == NGX_PROCESS_SINGLE) {
393 ngx_single_process_cycle(cycle);
394
395 } else {
396 ngx_master_process_cycle(cycle);
397 }
398
399 return 0;
400 }
401
402
403 static ngx_int_t
404 ngx_add_inherited_sockets(ngx_cycle_t *cycle)
405 {
406 u_char *p, *v, *inherited;
407 ngx_int_t s;
408 ngx_listening_t *ls;
409
410 inherited = (u_char *) getenv(NGINX_VAR);
411
412 if (inherited == NULL) {
413 return NGX_OK;
414 }
415
416 ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0,
417 "using inherited sockets from \"%s\"", inherited);
418
419 if (ngx_array_init(&cycle->listening, cycle->pool, 10,
420 sizeof(ngx_listening_t))
421 != NGX_OK)
422 {
423 return NGX_ERROR;
424 }
425
426 for (p = inherited, v = p; *p; p++) {
427 if (*p == ':' || *p == ';') {
428 s = ngx_atoi(v, p - v);
429 if (s == NGX_ERROR) {
430 ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
431 "invalid socket number \"%s\" in " NGINX_VAR
432 " environment variable, ignoring the rest"
433 " of the variable", v);
434 break;
435 }
436
437 v = p + 1;
438
439 ls = ngx_array_push(&cycle->listening);
440 if (ls == NULL) {
441 return NGX_ERROR;
442 }
443
444 ngx_memzero(ls, sizeof(ngx_listening_t));
445
446 ls->fd = (ngx_socket_t) s;
447 }
448 }
449
450 ngx_inherited = 1;
451
452 return ngx_set_inherited_sockets(cycle);
453 }
454
455
456 char **
457 ngx_set_environment(ngx_cycle_t *cycle, ngx_uint_t *last)
458 {
459 char **p, **env;
460 ngx_str_t *var;
461 ngx_uint_t i, n;
462 ngx_core_conf_t *ccf;
463
464 ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
465
466 if (last == NULL && ccf->environment) {
467 return ccf->environment;
468 }
469
470 var = ccf->env.elts;
471
472 for (i = 0; i < ccf->env.nelts; i++) {
473 if (ngx_strcmp(var[i].data, "TZ") == 0
474 || ngx_strncmp(var[i].data, "TZ=", 3) == 0)
475 {
476 goto tz_found;
477 }
478 }
479
480 var = ngx_array_push(&ccf->env);
481 if (var == NULL) {
482 return NULL;
483 }
484
485 var->len = 2;
486 var->data = (u_char *) "TZ";
487
488 var = ccf->env.elts;
489
490 tz_found:
491
492 n = 0;
493
494 for (i = 0; i < ccf->env.nelts; i++) {
495
496 if (var[i].data[var[i].len] == '=') {
497 n++;
498 continue;
499 }
500
501 for (p = ngx_os_environ; *p; p++) {
502
503 if (ngx_strncmp(*p, var[i].data, var[i].len) == 0
504 && (*p)[var[i].len] == '=')
505 {
506 n++;
507 break;
508 }
509 }
510 }
511
512 if (last) {
513 env = ngx_alloc((*last + n + 1) * sizeof(char *), cycle->log);
514 *last = n;
515
516 } else {
517 env = ngx_palloc(cycle->pool, (n + 1) * sizeof(char *));
518 }
519
520 if (env == NULL) {
521 return NULL;
522 }
523
524 n = 0;
525
526 for (i = 0; i < ccf->env.nelts; i++) {
527
528 if (var[i].data[var[i].len] == '=') {
529 env[n++] = (char *) var[i].data;
530 continue;
531 }
532
533 for (p = ngx_os_environ; *p; p++) {
534
535 if (ngx_strncmp(*p, var[i].data, var[i].len) == 0
536 && (*p)[var[i].len] == '=')
537 {
538 env[n++] = *p;
539 break;
540 }
541 }
542 }
543
544 env[n] = NULL;
545
546 if (last == NULL) {
547 ccf->environment = env;
548 environ = env;
549 }
550
551 return env;
552 }
553
554
555 ngx_pid_t
556 ngx_exec_new_binary(ngx_cycle_t *cycle, char *const *argv)
557 {
558 char **env, *var;
559 u_char *p;
560 ngx_uint_t i, n;
561 ngx_pid_t pid;
562 ngx_exec_ctx_t ctx;
563 ngx_core_conf_t *ccf;
564 ngx_listening_t *ls;
565
566 ngx_memzero(&ctx, sizeof(ngx_exec_ctx_t));
567
568 ctx.path = argv[0];
569 ctx.name = "new binary process";
570 ctx.argv = argv;
571
572 n = 2;
573 env = ngx_set_environment(cycle, &n);
574 if (env == NULL) {
575 return NGX_INVALID_PID;
576 }
577
578 var = ngx_alloc(sizeof(NGINX_VAR)
579 + cycle->listening.nelts * (NGX_INT32_LEN + 1) + 2,
580 cycle->log);
581
582 p = ngx_cpymem(var, NGINX_VAR "=", sizeof(NGINX_VAR));
583
584 ls = cycle->listening.elts;
585 for (i = 0; i < cycle->listening.nelts; i++) {
586 p = ngx_sprintf(p, "%ud;", ls[i].fd);
587 }
588
589 *p = '\0';
590
591 env[n++] = var;
592
593 #if (NGX_SETPROCTITLE_USES_ENV)
594
595 /* allocate the spare 300 bytes for the new binary process title */
596
597 env[n++] = "SPARE=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
598 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
599 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
600 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
601 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
602
603 #endif
604
605 env[n] = NULL;
606
607 #if (NGX_DEBUG)
608 {
609 char **e;
610 for (e = env; *e; e++) {
611 ngx_log_debug1(NGX_LOG_DEBUG_CORE, cycle->log, 0, "env: %s", *e);
612 }
613 }
614 #endif
615
616 ctx.envp = (char *const *) env;
617
618 ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
619
620 if (ngx_rename_file(ccf->pid.data, ccf->oldpid.data) != NGX_OK) {
621 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
622 ngx_rename_file_n " %s to %s failed "
623 "before executing new binary process \"%s\"",
624 ccf->pid.data, ccf->oldpid.data, argv[0]);
625
626 ngx_free(env);
627 ngx_free(var);
628
629 return NGX_INVALID_PID;
630 }
631
632 pid = ngx_execute(cycle, &ctx);
633
634 if (pid == NGX_INVALID_PID) {
635 if (ngx_rename_file(ccf->oldpid.data, ccf->pid.data) != NGX_OK) {
636 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
637 ngx_rename_file_n " %s back to %s failed after "
638 "the try to execute the new binary process \"%s\"",
639 ccf->oldpid.data, ccf->pid.data, argv[0]);
640 }
641 }
642
643 ngx_free(env);
644 ngx_free(var);
645
646 return pid;
647 }
648
649
650 static ngx_int_t
651 ngx_get_options(int argc, char *const *argv)
652 {
653 u_char *p;
654 ngx_int_t i;
655
656 for (i = 1; i < argc; i++) {
657
658 p = (u_char *) argv[i];
659
660 if (*p++ != '-') {
661 ngx_log_stderr(0, "invalid option: \"%s\"", argv[i]);
662 return NGX_ERROR;
663 }
664
665 while (*p) {
666
667 switch (*p++) {
668
669 case '?':
670 case 'h':
671 ngx_show_version = 1;
672 ngx_show_help = 1;
673 break;
674
675 case 'v':
676 ngx_show_version = 1;
677 break;
678
679 case 'V':
680 ngx_show_version = 1;
681 ngx_show_configure = 1;
682 break;
683
684 case 't':
685 ngx_test_config = 1;
686 break;
687
688 case 'p':
689 if (*p) {
690 ngx_prefix = p;
691 goto next;
692 }
693
694 if (argv[++i]) {
695 ngx_prefix = (u_char *) argv[i];
696 goto next;
697 }
698
699 ngx_log_stderr(0, "option \"-p\" requires directory name");
700 return NGX_ERROR;
701
702 case 'c':
703 if (*p) {
704 ngx_conf_file = p;
705 goto next;
706 }
707
708 if (argv[++i]) {
709 ngx_conf_file = (u_char *) argv[i];
710 goto next;
711 }
712
713 ngx_log_stderr(0, "option \"-c\" requires file name");
714 return NGX_ERROR;
715
716 case 'g':
717 if (*p) {
718 ngx_conf_params = p;
719 goto next;
720 }
721
722 if (argv[++i]) {
723 ngx_conf_params = (u_char *) argv[i];
724 goto next;
725 }
726
727 ngx_log_stderr(0, "option \"-g\" requires parameter");
728 return NGX_ERROR;
729
730 case 's':
731 if (*p) {
732 ngx_signal = (char *) p;
733
734 } else if (argv[++i]) {
735 ngx_signal = argv[i];
736
737 } else {
738 ngx_log_stderr(0, "option \"-s\" requires parameter");
739 return NGX_ERROR;
740 }
741
742 if (ngx_strcmp(ngx_signal, "stop") == 0
743 || ngx_strcmp(ngx_signal, "quit") == 0
744 || ngx_strcmp(ngx_signal, "reopen") == 0
745 || ngx_strcmp(ngx_signal, "reload") == 0)
746 {
747 ngx_process = NGX_PROCESS_SIGNALLER;
748 goto next;
749 }
750
751 ngx_log_stderr(0, "invalid option: \"-s %s\"", ngx_signal);
752 return NGX_ERROR;
753
754 default:
755 ngx_log_stderr(0, "invalid option: \"%c\"", *(p - 1));
756 return NGX_ERROR;
757 }
758 }
759
760 next:
761
762 continue;
763 }
764
765 return NGX_OK;
766 }
767
768
769 static ngx_int_t
770 ngx_save_argv(ngx_cycle_t *cycle, int argc, char *const *argv)
771 {
772 #if (NGX_FREEBSD)
773
774 ngx_os_argv = (char **) argv;
775 ngx_argc = argc;
776 ngx_argv = (char **) argv;
777
778 #else
779 size_t len;
780 ngx_int_t i;
781
782 ngx_os_argv = (char **) argv;
783 ngx_argc = argc;
784
785 ngx_argv = ngx_alloc((argc + 1) * sizeof(char *), cycle->log);
786 if (ngx_argv == NULL) {
787 return NGX_ERROR;
788 }
789
790 for (i = 0; i < argc; i++) {
791 len = ngx_strlen(argv[i]) + 1;
792
793 ngx_argv[i] = ngx_alloc(len, cycle->log);
794 if (ngx_argv[i] == NULL) {
795 return NGX_ERROR;
796 }
797
798 (void) ngx_cpystrn((u_char *) ngx_argv[i], (u_char *) argv[i], len);
799 }
800
801 ngx_argv[i] = NULL;
802
803 #endif
804
805 ngx_os_environ = environ;
806
807 return NGX_OK;
808 }
809
810
811 static ngx_int_t
812 ngx_process_options(ngx_cycle_t *cycle)
813 {
814 u_char *p;
815 size_t len;
816
817 if (ngx_prefix) {
818 len = ngx_strlen(ngx_prefix);
819 p = ngx_prefix;
820
821 if (!ngx_path_separator(*p)) {
822 p = ngx_pnalloc(cycle->pool, len + 1);
823 if (p == NULL) {
824 return NGX_ERROR;
825 }
826
827 ngx_memcpy(p, ngx_prefix, len);
828 p[len++] = '/';
829 }
830
831 cycle->conf_prefix.len = len;
832 cycle->conf_prefix.data = p;
833 cycle->prefix.len = len;
834 cycle->prefix.data = p;
835
836 } else {
837
838 #ifndef NGX_PREFIX
839
840 p = ngx_pnalloc(cycle->pool, NGX_MAX_PATH);
841 if (p == NULL) {
842 return NGX_ERROR;
843 }
844
845 if (ngx_getcwd(p, NGX_MAX_PATH) == 0) {
846 ngx_log_stderr(ngx_errno, "[emerg]: " ngx_getcwd_n " failed");
847 return NGX_ERROR;
848 }
849
850 len = ngx_strlen(p);
851
852 p[len++] = '/';
853
854 cycle->conf_prefix.len = len;
855 cycle->conf_prefix.data = p;
856 cycle->prefix.len = len;
857 cycle->prefix.data = p;
858
859 #else
860
861 #ifdef NGX_CONF_PREFIX
862 cycle->conf_prefix.len = sizeof(NGX_CONF_PREFIX) - 1;
863 cycle->conf_prefix.data = (u_char *) NGX_CONF_PREFIX;
864 #else
865 cycle->conf_prefix.len = sizeof(NGX_PREFIX) - 1;
866 cycle->conf_prefix.data = (u_char *) NGX_PREFIX;
867 #endif
868 cycle->prefix.len = sizeof(NGX_PREFIX) - 1;
869 cycle->prefix.data = (u_char *) NGX_PREFIX;
870
871 #endif
872 }
873
874 if (ngx_conf_file) {
875 cycle->conf_file.len = ngx_strlen(ngx_conf_file);
876 cycle->conf_file.data = ngx_conf_file;
877
878 } else {
879 cycle->conf_file.len = sizeof(NGX_CONF_PATH) - 1;
880 cycle->conf_file.data = (u_char *) NGX_CONF_PATH;
881 }
882
883 if (ngx_conf_full_name(cycle, &cycle->conf_file, 0) != NGX_OK) {
884 return NGX_ERROR;
885 }
886
887 for (p = cycle->conf_file.data + cycle->conf_file.len - 1;
888 p > cycle->conf_file.data;
889 p--)
890 {
891 if (ngx_path_separator(*p)) {
892 cycle->conf_prefix.len = p - ngx_cycle->conf_file.data + 1;
893 cycle->conf_prefix.data = ngx_cycle->conf_file.data;
894 break;
895 }
896 }
897
898 if (ngx_conf_params) {
899 cycle->conf_param.len = ngx_strlen(ngx_conf_params);
900 cycle->conf_param.data = ngx_conf_params;
901 }
902
903 if (ngx_test_config) {
904 cycle->log->log_level = NGX_LOG_INFO;
905 }
906
907 return NGX_OK;
908 }
909
910
911 static void *
912 ngx_core_module_create_conf(ngx_cycle_t *cycle)
913 {
914 ngx_core_conf_t *ccf;
915
916 ccf = ngx_pcalloc(cycle->pool, sizeof(ngx_core_conf_t));
917 if (ccf == NULL) {
918 return NULL;
919 }
920
921 /*
922 * set by ngx_pcalloc()
923 *
924 * ccf->pid = NULL;
925 * ccf->oldpid = NULL;
926 * ccf->priority = 0;
927 * ccf->cpu_affinity_n = 0;
928 * ccf->cpu_affinity = NULL;
929 */
930
931 ccf->daemon = NGX_CONF_UNSET;
932 ccf->master = NGX_CONF_UNSET;
933 ccf->timer_resolution = NGX_CONF_UNSET_MSEC;
934
935 ccf->worker_processes = NGX_CONF_UNSET;
936 ccf->debug_points = NGX_CONF_UNSET;
937
938 ccf->rlimit_nofile = NGX_CONF_UNSET;
939 ccf->rlimit_core = NGX_CONF_UNSET_SIZE;
940 ccf->rlimit_sigpending = NGX_CONF_UNSET;
941
942 ccf->user = (ngx_uid_t) NGX_CONF_UNSET_UINT;
943 ccf->group = (ngx_gid_t) NGX_CONF_UNSET_UINT;
944
945 #if (NGX_THREADS)
946 ccf->worker_threads = NGX_CONF_UNSET;
947 ccf->thread_stack_size = NGX_CONF_UNSET_SIZE;
948 #endif
949
950 if (ngx_array_init(&ccf->env, cycle->pool, 1, sizeof(ngx_str_t))
951 != NGX_OK)
952 {
953 return NULL;
954 }
955
956 return ccf;
957 }
958
959
960 static char *
961 ngx_core_module_init_conf(ngx_cycle_t *cycle, void *conf)
962 {
963 ngx_core_conf_t *ccf = conf;
964
965 ngx_conf_init_value(ccf->daemon, 1);
966 ngx_conf_init_value(ccf->master, 1);
967 ngx_conf_init_msec_value(ccf->timer_resolution, 0);
968
969 ngx_conf_init_value(ccf->worker_processes, 1);
970 ngx_conf_init_value(ccf->debug_points, 0);
971
972 #if (NGX_HAVE_SCHED_SETAFFINITY)
973
974 if (ccf->cpu_affinity_n
975 && ccf->cpu_affinity_n != 1
976 && ccf->cpu_affinity_n != (ngx_uint_t) ccf->worker_processes)
977 {
978 ngx_log_error(NGX_LOG_WARN, cycle->log, 0,
979 "number of the \"worker_processes\" is not equal to "
980 "the number of the \"worker_cpu_affinity\" mask, "
981 "using last mask for remaining worker processes");
982 }
983
984 #endif
985
986 #if (NGX_THREADS)
987
988 ngx_conf_init_value(ccf->worker_threads, 0);
989 ngx_threads_n = ccf->worker_threads;
990 ngx_conf_init_size_value(ccf->thread_stack_size, 2 * 1024 * 1024);
991
992 #endif
993
994
995 if (ccf->pid.len == 0) {
996 ccf->pid.len = sizeof(NGX_PID_PATH) - 1;
997 ccf->pid.data = (u_char *) NGX_PID_PATH;
998 }
999
1000 if (ngx_conf_full_name(cycle, &ccf->pid, 0) != NGX_OK) {
1001 return NGX_CONF_ERROR;
1002 }
1003
1004 ccf->oldpid.len = ccf->pid.len + sizeof(NGX_OLDPID_EXT);
1005
1006 ccf->oldpid.data = ngx_pnalloc(cycle->pool, ccf->oldpid.len);
1007 if (ccf->oldpid.data == NULL) {
1008 return NGX_CONF_ERROR;
1009 }
1010
1011 ngx_memcpy(ngx_cpymem(ccf->oldpid.data, ccf->pid.data, ccf->pid.len),
1012 NGX_OLDPID_EXT, sizeof(NGX_OLDPID_EXT));
1013
1014
1015 #if !(NGX_WIN32)
1016
1017 if (ccf->user == (uid_t) NGX_CONF_UNSET_UINT && geteuid() == 0) {
1018 struct group *grp;
1019 struct passwd *pwd;
1020
1021 ngx_set_errno(0);
1022 pwd = getpwnam(NGX_USER);
1023 if (pwd == NULL) {
1024 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
1025 "getpwnam(\"" NGX_USER "\") failed");
1026 return NGX_CONF_ERROR;
1027 }
1028
1029 ccf->username = NGX_USER;
1030 ccf->user = pwd->pw_uid;
1031
1032 ngx_set_errno(0);
1033 grp = getgrnam(NGX_GROUP);
1034 if (grp == NULL) {
1035 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
1036 "getgrnam(\"" NGX_GROUP "\") failed");
1037 return NGX_CONF_ERROR;
1038 }
1039
1040 ccf->group = grp->gr_gid;
1041 }
1042
1043
1044 if (ccf->lock_file.len == 0) {
1045 ccf->lock_file.len = sizeof(NGX_LOCK_PATH) - 1;
1046 ccf->lock_file.data = (u_char *) NGX_LOCK_PATH;
1047 }
1048
1049 if (ngx_conf_full_name(cycle, &ccf->lock_file, 0) != NGX_OK) {
1050 return NGX_CONF_ERROR;
1051 }
1052
1053 {
1054 ngx_str_t lock_file;
1055
1056 lock_file = cycle->old_cycle->lock_file;
1057
1058 if (lock_file.len) {
1059 lock_file.len--;
1060
1061 if (ccf->lock_file.len != lock_file.len
1062 || ngx_strncmp(ccf->lock_file.data, lock_file.data, lock_file.len)
1063 != 0)
1064 {
1065 ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
1066 "\"lock_file\" could not be changed, ignored");
1067 }
1068
1069 cycle->lock_file.len = lock_file.len + 1;
1070 lock_file.len += sizeof(".accept");
1071
1072 cycle->lock_file.data = ngx_pstrdup(cycle->pool, &lock_file);
1073 if (cycle->lock_file.data == NULL) {
1074 return NGX_CONF_ERROR;
1075 }
1076
1077 } else {
1078 cycle->lock_file.len = ccf->lock_file.len + 1;
1079 cycle->lock_file.data = ngx_pnalloc(cycle->pool,
1080 ccf->lock_file.len + sizeof(".accept"));
1081 if (cycle->lock_file.data == NULL) {
1082 return NGX_CONF_ERROR;
1083 }
1084
1085 ngx_memcpy(ngx_cpymem(cycle->lock_file.data, ccf->lock_file.data,
1086 ccf->lock_file.len),
1087 ".accept", sizeof(".accept"));
1088 }
1089 }
1090
1091 #endif
1092
1093 return NGX_CONF_OK;
1094 }
1095
1096
1097 static char *
1098 ngx_set_user(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1099 {
1100 #if (NGX_WIN32)
1101
1102 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1103 "\"user\" is not supported, ignored");
1104
1105 return NGX_CONF_OK;
1106
1107 #else
1108
1109 ngx_core_conf_t *ccf = conf;
1110
1111 char *group;
1112 struct passwd *pwd;
1113 struct group *grp;
1114 ngx_str_t *value;
1115
1116 if (ccf->user != (uid_t) NGX_CONF_UNSET_UINT) {
1117 return "is duplicate";
1118 }
1119
1120 if (geteuid() != 0) {
1121 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1122 "the \"user\" directive makes sense only "
1123 "if the master process runs "
1124 "with super-user privileges, ignored");
1125 return NGX_CONF_OK;
1126 }
1127
1128 value = (ngx_str_t *) cf->args->elts;
1129
1130 ccf->username = (char *) value[1].data;
1131
1132 ngx_set_errno(0);
1133 pwd = getpwnam((const char *) value[1].data);
1134 if (pwd == NULL) {
1135 ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
1136 "getpwnam(\"%s\") failed", value[1].data);
1137 return NGX_CONF_ERROR;
1138 }
1139
1140 ccf->user = pwd->pw_uid;
1141
1142 group = (char *) ((cf->args->nelts == 2) ? value[1].data : value[2].data);
1143
1144 ngx_set_errno(0);
1145 grp = getgrnam(group);
1146 if (grp == NULL) {
1147 ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
1148 "getgrnam(\"%s\") failed", group);
1149 return NGX_CONF_ERROR;
1150 }
1151
1152 ccf->group = grp->gr_gid;
1153
1154 return NGX_CONF_OK;
1155
1156 #endif
1157 }
1158
1159
1160 static char *
1161 ngx_set_env(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1162 {
1163 ngx_core_conf_t *ccf = conf;
1164
1165 ngx_str_t *value, *var;
1166 ngx_uint_t i;
1167
1168 var = ngx_array_push(&ccf->env);
1169 if (var == NULL) {
1170 return NGX_CONF_ERROR;
1171 }
1172
1173 value = cf->args->elts;
1174 *var = value[1];
1175
1176 for (i = 0; i < value[1].len; i++) {
1177
1178 if (value[1].data[i] == '=') {
1179
1180 var->len = i;
1181
1182 return NGX_CONF_OK;
1183 }
1184 }
1185
1186 return NGX_CONF_OK;
1187 }
1188
1189
1190 static char *
1191 ngx_set_priority(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1192 {
1193 ngx_core_conf_t *ccf = conf;
1194
1195 ngx_str_t *value;
1196 ngx_uint_t n, minus;
1197
1198 if (ccf->priority != 0) {
1199 return "is duplicate";
1200 }
1201
1202 value = cf->args->elts;
1203
1204 if (value[1].data[0] == '-') {
1205 n = 1;
1206 minus = 1;
1207
1208 } else if (value[1].data[0] == '+') {
1209 n = 1;
1210 minus = 0;
1211
1212 } else {
1213 n = 0;
1214 minus = 0;
1215 }
1216
1217 ccf->priority = ngx_atoi(&value[1].data[n], value[1].len - n);
1218 if (ccf->priority == NGX_ERROR) {
1219 return "invalid number";
1220 }
1221
1222 if (minus) {
1223 ccf->priority = -ccf->priority;
1224 }
1225
1226 return NGX_CONF_OK;
1227 }
1228
1229
1230 static char *
1231 ngx_set_cpu_affinity(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1232 {
1233 #if (NGX_HAVE_SCHED_SETAFFINITY)
1234 ngx_core_conf_t *ccf = conf;
1235
1236 u_char ch;
1237 u_long *mask;
1238 ngx_str_t *value;
1239 ngx_uint_t i, n;
1240
1241 if (ccf->cpu_affinity) {
1242 return "is duplicate";
1243 }
1244
1245 mask = ngx_palloc(cf->pool, (cf->args->nelts - 1) * sizeof(long));
1246 if (mask == NULL) {
1247 return NGX_CONF_ERROR;
1248 }
1249
1250 ccf->cpu_affinity_n = cf->args->nelts - 1;
1251 ccf->cpu_affinity = mask;
1252
1253 value = cf->args->elts;
1254
1255 for (n = 1; n < cf->args->nelts; n++) {
1256
1257 if (value[n].len > 32) {
1258 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1259 "\"worker_cpu_affinity\" supports up to 32 CPU only");
1260 return NGX_CONF_ERROR;
1261 }
1262
1263 mask[n - 1] = 0;
1264
1265 for (i = 0; i < value[n].len; i++) {
1266
1267 ch = value[n].data[i];
1268
1269 if (ch == ' ') {
1270 continue;
1271 }
1272
1273 mask[n - 1] <<= 1;
1274
1275 if (ch == '0') {
1276 continue;
1277 }
1278
1279 if (ch == '1') {
1280 mask[n - 1] |= 1;
1281 continue;
1282 }
1283
1284 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1285 "invalid character \"%c\" in \"worker_cpu_affinity\"",
1286 ch);
1287 return NGX_CONF_ERROR;
1288 }
1289 }
1290
1291 #else
1292
1293 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1294 "\"worker_cpu_affinity\" is not supported "
1295 "on this platform, ignored");
1296 #endif
1297
1298 return NGX_CONF_OK;
1299 }
1300
1301
1302 u_long
1303 ngx_get_cpu_affinity(ngx_uint_t n)
1304 {
1305 ngx_core_conf_t *ccf;
1306
1307 ccf = (ngx_core_conf_t *) ngx_get_conf(ngx_cycle->conf_ctx,
1308 ngx_core_module);
1309
1310 if (ccf->cpu_affinity == NULL) {
1311 return 0;
1312 }
1313
1314 if (ccf->cpu_affinity_n > n) {
1315 return ccf->cpu_affinity[n];
1316 }
1317
1318 return ccf->cpu_affinity[ccf->cpu_affinity_n - 1];
1319 }
catap's nginx repository