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;
}
