int main(int argc, char **argv) { struct thread thread; master = thread_master_create(NULL); openzlog("grammar_sandbox", "NONE", 0, LOG_CONS | LOG_NDELAY | LOG_PID, LOG_DAEMON); zlog_set_level(ZLOG_DEST_SYSLOG, ZLOG_DISABLED); zlog_set_level(ZLOG_DEST_STDOUT, LOG_DEBUG); zlog_set_level(ZLOG_DEST_MONITOR, ZLOG_DISABLED); /* Library inits. */ cmd_init(1); host.name = strdup("test"); host.domainname = strdup("testdomainname"); vty_init(master, true); memory_init(); yang_init(); nb_init(master, NULL, 0); vty_stdio(vty_do_exit); /* Fetch next active thread. */ while (thread_fetch(master, &thread)) thread_call(&thread); /* Not reached. */ exit(0); }
static int fpm_socket_af_inet_listening_socket(struct fpm_worker_pool_s *wp) /* {{{ */ { char *dup_address = strdup(wp->config->listen_address); char *port_str = strrchr(dup_address, ':'); char *addr = NULL; int addr_len; int port = 0; int sock = -1; if (port_str) { /* this is host:port pair */ *port_str++ = '\0'; port = atoi(port_str); addr = dup_address; /* strip brackets from address for getaddrinfo */ addr_len = strlen(addr); if (addr[0] == '[' && addr[addr_len - 1] == ']') { addr[addr_len - 1] = '\0'; addr++; } } else if (strlen(dup_address) == strspn(dup_address, "0123456789")) { /* this is port */ port = atoi(dup_address); port_str = dup_address; } if (port == 0) { zlog(ZLOG_ERROR, "invalid port value '%s'", port_str); return -1; } if (addr) { /* Bind a specific address */ sock = fpm_socket_af_inet_socket_by_addr(wp, addr, port_str); } else { /* Bind ANYADDR * * Try "::" first as that covers IPv6 ANYADDR and mapped IPv4 ANYADDR * silencing warnings since failure is an option * * If that fails (because AF_INET6 is unsupported) retry with 0.0.0.0 */ int old_level = zlog_set_level(ZLOG_ALERT); sock = fpm_socket_af_inet_socket_by_addr(wp, "::", port_str); zlog_set_level(old_level); if (sock < 0) { zlog(ZLOG_NOTICE, "Failed implicitly binding to ::, retrying with 0.0.0.0"); sock = fpm_socket_af_inet_socket_by_addr(wp, "0.0.0.0", port_str); } } free(dup_address); return sock; }
int main (void) { master = thread_master_create (); signal_init (master, array_size(sigs), sigs); zlog_default = openzlog("testsig", ZLOG_NONE, LOG_CONS|LOG_NDELAY|LOG_PID, LOG_DAEMON); zlog_set_level (NULL, ZLOG_DEST_SYSLOG, ZLOG_DISABLED); zlog_set_level (NULL, ZLOG_DEST_STDOUT, LOG_DEBUG); zlog_set_level (NULL, ZLOG_DEST_MONITOR, ZLOG_DISABLED); while (thread_fetch (master, &t)) thread_call (&t); exit (0); }
static int fpm_conf_post_process(int force_daemon) /* {{{ */ { struct fpm_worker_pool_s *wp; if (fpm_global_config.pid_file) { fpm_evaluate_full_path(&fpm_global_config.pid_file, NULL, PHP_LOCALSTATEDIR, 0); } if (force_daemon >= 0) { /* forced from command line options */ fpm_global_config.daemonize = force_daemon; } fpm_globals.log_level = fpm_global_config.log_level; zlog_set_level(fpm_globals.log_level); if (fpm_global_config.process_max < 0) { zlog(ZLOG_ERROR, "process_max can't be negative"); return -1; } if (fpm_global_config.process_priority != 64 && (fpm_global_config.process_priority < -19 || fpm_global_config.process_priority > 20)) { zlog(ZLOG_ERROR, "process.priority must be included into [-19,20]"); return -1; } if (!fpm_global_config.error_log) { fpm_global_config.error_log = strdup("log/php-fpm.log"); } #ifdef HAVE_SYSTEMD if (0 > fpm_systemd_conf()) { return -1; } #endif #ifdef HAVE_SYSLOG_H if (!fpm_global_config.syslog_ident) { fpm_global_config.syslog_ident = strdup("php-fpm"); } if (fpm_global_config.syslog_facility < 0) { fpm_global_config.syslog_facility = LOG_DAEMON; } if (strcasecmp(fpm_global_config.error_log, "syslog") != 0) #endif { fpm_evaluate_full_path(&fpm_global_config.error_log, NULL, PHP_LOCALSTATEDIR, 0); } if (0 > fpm_stdio_open_error_log(0)) { return -1; } if (0 > fpm_event_pre_init(fpm_global_config.events_mechanism)) { return -1; } if (0 > fpm_conf_process_all_pools()) { return -1; } if (0 > fpm_log_open(0)) { return -1; } for (wp = fpm_worker_all_pools; wp; wp = wp->next) { if (!wp->config->access_log || !*wp->config->access_log) { continue; } if (0 > fpm_log_write(wp->config->access_format)) { zlog(ZLOG_ERROR, "[pool %s] wrong format for access.format '%s'", wp->config->name, wp->config->access_format); return -1; } } return 0; }
int zmaster_server_main(int argc, char **argv) { int op; char *test_listen = 0; parent_pid = getppid(); test_mode = 1; reloading = 0; softstopping = 0; ev_status = 0; ev_listen = 0; local_ev_close_do_once = 1; signal(SIGPIPE, SIG_IGN); if (!zvar_progname) { zvar_progname = argv[0]; } zvar_config_init(); zvar_evbase_init(); while ((op = getopt(argc, argv, "Ml:c:o:t:dv")) > 0) { switch (op) { case 'M': test_mode = 0; break; case 'l': test_listen = optarg; break; case 'c': zconfig_load(zvar_config, optarg); break; case 'o': { char *key, *value; key = zstrdup(optarg); value = strchr(key, '='); if (value) { *value++ = 0; } zconfig_add(zvar_config, key, value); zfree(key); } break; case 't': zvar_master_server_listen_type = optarg[0]; break; case 'd': zlog_set_level_from_console(ZLOG_DEBUG); break; case 'v': zlog_set_level_from_console(ZLOG_VERBOSE); break; default: zfatal("parameters error"); } } zlog_set_level(zlog_parse_level(zconfig_get_str(zvar_config, "zlog_level", "info"))); register_server(test_listen); { char *run_user = zconfig_get_str(zvar_config, "zrun_user", 0); if (!ZEMPTY(run_user)) { if (zchroot_user(0, run_user) < 0) { zfatal("change user %s(%m)", run_user); } } } if (zmaster_server_before_service) { zmaster_server_before_service(); } while (1) { zevbase_dispatch(zvar_evbase, 0); if (zmaster_server_loop) { zmaster_server_loop(); } if (reloading) { local_ev_close(); if (getppid() != parent_pid) { break; } } if (softstopping) { local_ev_close(); break; } } local_ev_close(); if (zmaster_server_before_exit) { zmaster_server_before_exit(); } zevtimer_fini(&reload_timer); zevbase_free(zvar_evbase); return 0; }
int fpm_unix_init_main() /* {{{ */ { struct fpm_worker_pool_s *wp; int is_root = !geteuid(); if (fpm_global_config.rlimit_files) { struct rlimit r; r.rlim_max = r.rlim_cur = (rlim_t) fpm_global_config.rlimit_files; if (0 > setrlimit(RLIMIT_NOFILE, &r)) { zlog(ZLOG_SYSERROR, "failed to set rlimit_core for this pool. Please check your system limits or decrease rlimit_files. setrlimit(RLIMIT_NOFILE, %d)", fpm_global_config.rlimit_files); return -1; } } if (fpm_global_config.rlimit_core) { struct rlimit r; r.rlim_max = r.rlim_cur = fpm_global_config.rlimit_core == -1 ? (rlim_t) RLIM_INFINITY : (rlim_t) fpm_global_config.rlimit_core; if (0 > setrlimit(RLIMIT_CORE, &r)) { zlog(ZLOG_SYSERROR, "failed to set rlimit_core for this pool. Please check your system limits or decrease rlimit_core. setrlimit(RLIMIT_CORE, %d)", fpm_global_config.rlimit_core); return -1; } } fpm_pagesize = getpagesize(); if (fpm_global_config.daemonize) { /* * If daemonize, the calling process will die soon * and the master process continues to initialize itself. * * The parent process has then to wait for the master * process to initialize to return a consistent exit * value. For this pupose, the master process will * send \"1\" into the pipe if everything went well * and \"0\" otherwise. */ struct timeval tv; fd_set rfds; int ret; if (pipe(fpm_globals.send_config_pipe) == -1) { zlog(ZLOG_SYSERROR, "failed to create pipe"); return -1; } /* then fork */ pid_t pid = fork(); switch (pid) { case -1 : /* error */ zlog(ZLOG_SYSERROR, "failed to daemonize"); return -1; case 0 : /* children */ close(fpm_globals.send_config_pipe[0]); /* close the read side of the pipe */ break; default : /* parent */ close(fpm_globals.send_config_pipe[1]); /* close the write side of the pipe */ /* * wait for 10s before exiting with error * the child is supposed to send 1 or 0 into the pipe to tell the parent * how it goes for it */ FD_ZERO(&rfds); FD_SET(fpm_globals.send_config_pipe[0], &rfds); tv.tv_sec = 10; tv.tv_usec = 0; zlog(ZLOG_DEBUG, "The calling process is waiting for the master process to ping via fd=%d", fpm_globals.send_config_pipe[0]); ret = select(fpm_globals.send_config_pipe[0] + 1, &rfds, NULL, NULL, &tv); if (ret == -1) { zlog(ZLOG_SYSERROR, "failed to select"); exit(FPM_EXIT_SOFTWARE); } if (ret) { /* data available */ int readval; ret = read(fpm_globals.send_config_pipe[0], &readval, sizeof(readval)); if (ret == -1) { zlog(ZLOG_SYSERROR, "failed to read from pipe"); exit(FPM_EXIT_SOFTWARE); } if (ret == 0) { zlog(ZLOG_ERROR, "no data have been read from pipe"); exit(FPM_EXIT_SOFTWARE); } else { if (readval == 1) { zlog(ZLOG_DEBUG, "I received a valid acknoledge from the master process, I can exit without error"); fpm_cleanups_run(FPM_CLEANUP_PARENT_EXIT); exit(FPM_EXIT_OK); } else { zlog(ZLOG_DEBUG, "The master process returned an error !"); exit(FPM_EXIT_SOFTWARE); } } } else { /* no date sent ! */ zlog(ZLOG_ERROR, "the master process didn't send back its status (via the pipe to the calling process)"); exit(FPM_EXIT_SOFTWARE); } exit(FPM_EXIT_SOFTWARE); } } /* continue as a child */ setsid(); if (0 > fpm_clock_init()) { return -1; } if (fpm_global_config.process_priority != 64) { if (is_root) { if (setpriority(PRIO_PROCESS, 0, fpm_global_config.process_priority) < 0) { zlog(ZLOG_SYSERROR, "Unable to set priority for the master process"); return -1; } } else { zlog(ZLOG_NOTICE, "'process.priority' directive is ignored when FPM is not running as root"); } } fpm_globals.parent_pid = getpid(); for (wp = fpm_worker_all_pools; wp; wp = wp->next) { if (0 > fpm_unix_conf_wp(wp)) { return -1; } } zlog_set_level(fpm_globals.log_level); return 0; }