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