#else
# include <stdint.h>
#endif
+#ifdef HAVE_GLOB
+# ifndef PHP_WIN32
+# include <glob.h>
+# else
+# include "win32/glob.h"
+# endif
+#endif
#include <stdio.h>
#include <unistd.h>
+#include "php.h"
+#include "zend_ini_scanner.h"
+#include "zend_globals.h"
+#include "zend_stream.h"
+
#include "fpm.h"
#include "fpm_conf.h"
#include "fpm_stdio.h"
#include "fpm_sockets.h"
#include "fpm_shm.h"
#include "fpm_status.h"
-#include "xml_config.h"
#include "zlog.h"
-struct fpm_global_config_s fpm_global_config;
+static int fpm_conf_load_ini_file(char *filename);
+static char *fpm_conf_set_integer(zval *value, void **config, intptr_t offset);
+static char *fpm_conf_set_time(zval *value, void **config, intptr_t offset);
+static char *fpm_conf_set_boolean(zval *value, void **config, intptr_t offset);
+static char *fpm_conf_set_string(zval *value, void **config, intptr_t offset);
+static char *fpm_conf_set_log_level(zval *value, void **config, intptr_t offset);
+static char *fpm_conf_set_rlimit_core(zval *value, void **config, intptr_t offset);
+static char *fpm_conf_set_pm(zval *value, void **config, intptr_t offset);
+
+struct fpm_global_config_s fpm_global_config = { 0, 0, 0, 1, NULL, NULL};
+static struct fpm_worker_pool_s *current_wp = NULL;
+static int ini_recursion = 0;
+static char *ini_filename = NULL;
+static int ini_lineno = 0;
+static char *ini_include = NULL;
+
+static struct ini_value_parser_s ini_fpm_global_options[] = {
+ { "emergency_restart_threshold", &fpm_conf_set_integer, offsetof(struct fpm_global_config_s, emergency_restart_threshold) },
+ { "emergency_restart_interval", &fpm_conf_set_time, offsetof(struct fpm_global_config_s, emergency_restart_interval) },
+ { "process_control_timeout", &fpm_conf_set_time, offsetof(struct fpm_global_config_s, process_control_timeout) },
+ { "daemonize", &fpm_conf_set_boolean, offsetof(struct fpm_global_config_s, daemonize) },
+ { "pid", &fpm_conf_set_string, offsetof(struct fpm_global_config_s, pid_file) },
+ { "error_log", &fpm_conf_set_string, offsetof(struct fpm_global_config_s, error_log) },
+ { "log_level", &fpm_conf_set_log_level, 0 },
+ { 0, 0, 0 }
+};
-static void *fpm_global_config_ptr() /* {{{ */
+static struct ini_value_parser_s ini_fpm_pool_options[] = {
+ { "user", &fpm_conf_set_string, offsetof(struct fpm_worker_pool_config_s, user) },
+ { "group", &fpm_conf_set_string, offsetof(struct fpm_worker_pool_config_s, group) },
+ { "chroot", &fpm_conf_set_string, offsetof(struct fpm_worker_pool_config_s, chroot) },
+ { "chdir", &fpm_conf_set_string, offsetof(struct fpm_worker_pool_config_s, chdir) },
+ { "request_terminate_timeout", &fpm_conf_set_time, offsetof(struct fpm_worker_pool_config_s, request_terminate_timeout) },
+ { "request_slowlog_timeout", &fpm_conf_set_time, offsetof(struct fpm_worker_pool_config_s, request_slowlog_timeout) },
+ { "slowlog", &fpm_conf_set_string, offsetof(struct fpm_worker_pool_config_s, slowlog) },
+ { "rlimit_files", &fpm_conf_set_integer, offsetof(struct fpm_worker_pool_config_s, rlimit_files) },
+ { "rlimit_core", &fpm_conf_set_rlimit_core, offsetof(struct fpm_worker_pool_config_s, rlimit_core) },
+ { "catch_workers_output", &fpm_conf_set_boolean, offsetof(struct fpm_worker_pool_config_s, catch_workers_output) },
+ { "listen", &fpm_conf_set_string, offsetof(struct fpm_worker_pool_config_s, listen_address) },
+ { "listen.owner", &fpm_conf_set_string, offsetof(struct fpm_worker_pool_config_s, listen_owner) },
+ { "listen.group", &fpm_conf_set_string, offsetof(struct fpm_worker_pool_config_s, listen_group) },
+ { "listen.mode", &fpm_conf_set_string, offsetof(struct fpm_worker_pool_config_s, listen_mode) },
+ { "listen.backlog", &fpm_conf_set_integer, offsetof(struct fpm_worker_pool_config_s, listen_backlog) },
+ { "listen.allowed_clients", &fpm_conf_set_string, offsetof(struct fpm_worker_pool_config_s, listen_allowed_clients) },
+ { "pm", &fpm_conf_set_pm, offsetof(struct fpm_worker_pool_config_s, pm) },
+ { "pm.max_requests", &fpm_conf_set_integer, offsetof(struct fpm_worker_pool_config_s, pm_max_requests) },
+ { "pm.max_children", &fpm_conf_set_integer, offsetof(struct fpm_worker_pool_config_s, pm_max_children) },
+ { "pm.start_servers", &fpm_conf_set_integer, offsetof(struct fpm_worker_pool_config_s, pm_start_servers) },
+ { "pm.min_spare_servers", &fpm_conf_set_integer, offsetof(struct fpm_worker_pool_config_s, pm_min_spare_servers) },
+ { "pm.max_spare_servers", &fpm_conf_set_integer, offsetof(struct fpm_worker_pool_config_s, pm_max_spare_servers) },
+ { "pm.status_path", &fpm_conf_set_string, offsetof(struct fpm_worker_pool_config_s, pm_status_path) },
+ { "ping.path", &fpm_conf_set_string, offsetof(struct fpm_worker_pool_config_s, ping_path) },
+ { "ping.response", &fpm_conf_set_string, offsetof(struct fpm_worker_pool_config_s, ping_response) },
+ { 0, 0, 0 }
+};
+
+static char *fpm_conf_set_boolean(zval *value, void **config, intptr_t offset) /* {{{ */
{
- return &fpm_global_config;
+ char *val = Z_STRVAL_P(value);
+ long value_y = !strcasecmp(val, "yes") || !strcmp(val, "1") || !strcasecmp(val, "on") || !strcasecmp(val, "true");
+ long value_n = !strcasecmp(val, "no") || !strcmp(val, "0") || !strcasecmp(val, "off") || !strcasecmp(val, "false");
+
+ if (!value_y && !value_n) {
+ return "invalid boolean value";
+ }
+
+ * (int *) ((char *) *config + offset) = value_y ? 1 : 0;
+ return NULL;
}
/* }}} */
-static char *fpm_conf_set_log_level(void **conf, char *name, void *vv, intptr_t offset) /* {{{ */
+static char *fpm_conf_set_string(zval *value, void **config, intptr_t offset) /* {{{ */
{
- char *value = vv;
+ char *new;
+ char **old = (char **) ((char *) *config + offset);
+ if (*old) {
+ return "it's already been defined. Can't do that twice.";
+ }
- if (!strcmp(value, "debug")) {
- fpm_globals.log_level = ZLOG_DEBUG;
- } else if (!strcmp(value, "notice")) {
- fpm_globals.log_level = ZLOG_NOTICE;
- } else if (!strcmp(value, "warn")) {
- fpm_globals.log_level = ZLOG_WARNING;
- } else if (!strcmp(value, "error")) {
- fpm_globals.log_level = ZLOG_ERROR;
- } else if (!strcmp(value, "alert")) {
- fpm_globals.log_level = ZLOG_ALERT;
- } else {
- return "invalid value for 'log_level'";
+ new = strdup(Z_STRVAL_P(value));
+ if (!new) {
+ return "fpm_conf_set_string(): strdup() failed";
}
+ *old = new;
return NULL;
}
/* }}} */
-static struct xml_conf_section xml_section_fpm_global_options = {
- .conf = &fpm_global_config_ptr,
- .path = "/configuration/global_options",
- .parsers = (struct xml_value_parser []) {
- { XML_CONF_SCALAR, "emergency_restart_threshold", &xml_conf_set_slot_integer, offsetof(struct fpm_global_config_s, emergency_restart_threshold) },
- { XML_CONF_SCALAR, "emergency_restart_interval", &xml_conf_set_slot_time, offsetof(struct fpm_global_config_s, emergency_restart_interval) },
- { XML_CONF_SCALAR, "process_control_timeout", &xml_conf_set_slot_time, offsetof(struct fpm_global_config_s, process_control_timeout) },
- { XML_CONF_SCALAR, "daemonize", &xml_conf_set_slot_boolean, offsetof(struct fpm_global_config_s, daemonize) },
- { XML_CONF_SCALAR, "pid_file", &xml_conf_set_slot_string, offsetof(struct fpm_global_config_s, pid_file) },
- { XML_CONF_SCALAR, "error_log", &xml_conf_set_slot_string, offsetof(struct fpm_global_config_s, error_log) },
- { XML_CONF_SCALAR, "log_level", &fpm_conf_set_log_level, 0 },
- { 0, 0, 0, 0 }
+static char *fpm_conf_set_integer(zval *value, void **config, intptr_t offset) /* {{{ */
+{
+ int i;
+ char *val = Z_STRVAL_P(value);
+
+ for (i=0; i<strlen(val); i++) {
+ if ( i == 0 && val[i] == '-' ) continue;
+ if (val[i] < '0' || val[i] > '9') {
+ return("is not a valid number (greater or equal than zero");
+ }
}
-};
+ * (int *) ((char *) *config + offset) = atoi(val);
+ return(NULL);
+}
+/* }}} */
-static char *fpm_conf_set_pm_style(void **conf, char *name, void *vv, intptr_t offset) /* {{{ */
+static char *fpm_conf_set_time(zval *value, void **config, intptr_t offset) /* {{{ */
{
- char *value = vv;
- struct fpm_pm_s *c = *conf;
+ char *val = Z_STRVAL_P(value);
+ int len = strlen(val);
+ char suffix;
+ int seconds;
+ if (!len) {
+ return "invalid time value";
+ }
+
+ suffix = val[len-1];
+ switch (suffix) {
+ case 'm' :
+ val[len-1] = '\0';
+ seconds = 60 * atoi(val);
+ break;
+ case 'h' :
+ val[len-1] = '\0';
+ seconds = 60 * 60 * atoi(val);
+ break;
+ case 'd' :
+ val[len-1] = '\0';
+ seconds = 24 * 60 * 60 * atoi(val);
+ break;
+ case 's' : /* s is the default suffix */
+ val[len-1] = '\0';
+ suffix = '0';
+ default :
+ if (suffix < '0' || suffix > '9') {
+ return "unknown suffix used in time value";
+ }
+ seconds = atoi(val);
+ break;
+ }
- if (!strcmp(value, "static")) {
- c->style = PM_STYLE_STATIC;
- } else if (!strcmp(value, "dynamic")) {
- c->style = PM_STYLE_DYNAMIC;
+ * (int *) ((char *) *config + offset) = seconds;
+ return NULL;
+}
+/* }}} */
+
+static char *fpm_conf_set_log_level(zval *value, void **config, intptr_t offset) /* {{{ */
+{
+ char *val = Z_STRVAL_P(value);
+
+ if (!strcmp(val, "debug")) {
+ fpm_globals.log_level = ZLOG_DEBUG;
+ } else if (!strcasecmp(val, "notice")) {
+ fpm_globals.log_level = ZLOG_NOTICE;
+ } else if (!strcasecmp(val, "warn")) {
+ fpm_globals.log_level = ZLOG_WARNING;
+ } else if (!strcasecmp(val, "error")) {
+ fpm_globals.log_level = ZLOG_ERROR;
+ } else if (!strcasecmp(val, "alert")) {
+ fpm_globals.log_level = ZLOG_ALERT;
} else {
- return "invalid value for 'style'";
+ return "invalid value for 'log_level'";
}
return NULL;
}
/* }}} */
-static char *fpm_conf_set_rlimit_core(void **conf, char *name, void *vv, intptr_t offset) /* {{{ */
+static char *fpm_conf_set_rlimit_core(zval *value, void **config, intptr_t offset) /* {{{ */
{
- char *value = vv;
- struct fpm_worker_pool_config_s *c = *conf;
+ char *val = Z_STRVAL_P(value);
+ struct fpm_worker_pool_config_s *c = *config;
- if (!strcmp(value, "unlimited")) {
+ if (!strcmp(val, "unlimited")) {
c->rlimit_core = -1;
} else {
int int_value;
void *subconf = &int_value;
char *error;
- error = xml_conf_set_slot_integer(&subconf, name, vv, 0);
+ error = fpm_conf_set_integer(value, &subconf, 0);
if (error) {
return error;
}
if (int_value < 0) {
- return "invalid value for 'rlimit_core'";
+ return "must be greater than zero or 'unlimited'";
}
c->rlimit_core = int_value;
}
/* }}} */
-static char *fpm_conf_set_catch_workers_output(void **conf, char *name, void *vv, intptr_t offset) /* {{{ */
+static char *fpm_conf_set_pm(zval *value, void **config, intptr_t offset) /* {{{ */
{
- struct fpm_worker_pool_config_s *c = *conf;
- int int_value;
- void *subconf = &int_value;
- char *error;
-
- error = xml_conf_set_slot_boolean(&subconf, name, vv, 0);
-
- if (error) {
- return error;
+ char *val = Z_STRVAL_P(value);
+ struct fpm_worker_pool_config_s *c = *config;
+ if (!strcmp(val, "static")) {
+ c->pm = PM_STYLE_STATIC;
+ } else if (!strcmp(val, "dynamic")) {
+ c->pm = PM_STYLE_DYNAMIC;
+ } else {
+ return "invalid process manager (static or dynamic)";
}
-
- c->catch_workers_output = int_value;
return NULL;
}
/* }}} */
-static struct xml_conf_section fpm_conf_set_dynamic_subsection_conf = {
- .path = "dynamic somewhere", /* fixme */
- .parsers = (struct xml_value_parser []) {
- { XML_CONF_SCALAR, "start_servers", &xml_conf_set_slot_integer, offsetof(struct fpm_pm_s, dynamic.start_servers) },
- { XML_CONF_SCALAR, "min_spare_servers", &xml_conf_set_slot_integer, offsetof(struct fpm_pm_s, dynamic.min_spare_servers) },
- { XML_CONF_SCALAR, "max_spare_servers", &xml_conf_set_slot_integer, offsetof(struct fpm_pm_s, dynamic.max_spare_servers) },
- { 0, 0, 0, 0 }
- }
-};
-
-static char *fpm_conf_set_dynamic_subsection(void **conf, char *name, void *xml_node, intptr_t offset) /* {{{ */
+static char *fpm_conf_set_array(zval *key, zval *value, void **config, int convert_to_bool) /* {{{ */
{
- return xml_conf_parse_section(conf, &fpm_conf_set_dynamic_subsection_conf, xml_node);
-}
-/* }}} */
-
-static struct xml_conf_section fpm_conf_set_listen_options_subsection_conf = {
- .path = "listen options somewhere", /* fixme */
- .parsers = (struct xml_value_parser []) {
- { XML_CONF_SCALAR, "backlog", &xml_conf_set_slot_integer, offsetof(struct fpm_listen_options_s, backlog) },
- { XML_CONF_SCALAR, "owner", &xml_conf_set_slot_string, offsetof(struct fpm_listen_options_s, owner) },
- { XML_CONF_SCALAR, "group", &xml_conf_set_slot_string, offsetof(struct fpm_listen_options_s, group) },
- { XML_CONF_SCALAR, "mode", &xml_conf_set_slot_string, offsetof(struct fpm_listen_options_s, mode) },
- { 0, 0, 0, 0 }
- }
-};
-
-static char *fpm_conf_set_listen_options_subsection(void **conf, char *name, void *xml_node, intptr_t offset) /* {{{ */
-{
- void *subconf = (char *) *conf + offset;
- struct fpm_listen_options_s *lo;
-
- lo = malloc(sizeof(*lo));
-
- if (!lo) {
- return "malloc() failed";
- }
-
- memset(lo, 0, sizeof(*lo));
- lo->backlog = -1;
- * (struct fpm_listen_options_s **) subconf = lo;
- subconf = lo;
-
- return xml_conf_parse_section(&subconf, &fpm_conf_set_listen_options_subsection_conf, xml_node);
-}
-/* }}} */
-
-static struct xml_conf_section fpm_conf_set_pm_subsection_conf = {
- .path = "pm settings somewhere", /* fixme */
- .parsers = (struct xml_value_parser []) {
- { XML_CONF_SCALAR, "style", &fpm_conf_set_pm_style, 0 },
- { XML_CONF_SCALAR, "max_children", &xml_conf_set_slot_integer, offsetof(struct fpm_pm_s, max_children) },
- { XML_CONF_SCALAR, "status", &xml_conf_set_slot_string, offsetof(struct fpm_pm_s, status) },
- { XML_CONF_SCALAR, "ping", &xml_conf_set_slot_string, offsetof(struct fpm_pm_s, ping) },
- { XML_CONF_SCALAR, "pong", &xml_conf_set_slot_string, offsetof(struct fpm_pm_s, pong) },
- { XML_CONF_SUBSECTION, "dynamic", &fpm_conf_set_dynamic_subsection, offsetof(struct fpm_pm_s, dynamic) },
- { 0, 0, 0, 0 }
- }
-};
-
-static char *fpm_conf_set_pm_subsection(void **conf, char *name, void *xml_node, intptr_t offset) /* {{{ */
-{
- void *subconf = (char *) *conf + offset;
- struct fpm_pm_s *pm;
-
- pm = malloc(sizeof(*pm));
-
- if (!pm) {
- return "fpm_conf_set_pm_subsection(): malloc failed";
- }
-
- memset(pm, 0, sizeof(*pm));
- *(struct fpm_pm_s **) subconf = pm;
- subconf = pm;
- return xml_conf_parse_section(&subconf, &fpm_conf_set_pm_subsection_conf, xml_node);
-}
-/* }}} */
-
-static char *xml_conf_set_slot_key_value_pair(void **conf, char *name, void *vv, intptr_t offset) /* {{{ */
-{
- char *value = vv;
struct key_value_s *kv;
- struct key_value_s ***parent = (struct key_value_s ***) conf;
+ struct key_value_s ***parent = (struct key_value_s ***) config;
+ int b;
+ void *subconf = &b;
kv = malloc(sizeof(*kv));
}
memset(kv, 0, sizeof(*kv));
- kv->key = strdup(name);
- kv->value = strdup(value);
-
- if (!kv->key || !kv->value) {
- return "xml_conf_set_slot_key_value_pair(): strdup() failed";
- }
-
- kv->next = **parent;
- **parent = kv;
- return NULL;
-}
-/* }}} */
-
-static char *xml_conf_set_slot_key_value_pair_bool(void **conf, char *name, void *vv, intptr_t offset) /* {{{ */
-{
- int value;
- void *subconf = &value;
- char *error;
+ kv->key = strdup(Z_STRVAL_P(key));
- error = xml_conf_set_slot_boolean(&subconf, name, vv, 0);
- if (error) {
- return error;
+ if (!kv->key) {
+ return "fpm_conf_set_array: strdup(key) failed";
}
- return(xml_conf_set_slot_key_value_pair(conf, name, value ? "On" : "Off", offset));
-}
-/* }}} */
-
-static struct xml_conf_section fpm_conf_set_key_value_pairs_subsection_conf = {
- .path = "key_value_pairs somewhere", /* fixme */
- .parsers = (struct xml_value_parser []) {
- { XML_CONF_SCALAR, 0, &xml_conf_set_slot_key_value_pair, 0 },
- { 0, 0, 0, 0 }
+ if (convert_to_bool) {
+ char *err = fpm_conf_set_boolean(value, &subconf, 0);
+ if (err) return(err);
+ kv->value = strdup(b ? "On" : "Off");
+ } else {
+ kv->value = strdup(Z_STRVAL_P(value));
}
-};
-static struct xml_conf_section fpm_conf_set_key_value_pairs_subsection_conf_bool = {
- .path = "key_value_pairs somewhere", /* fixme */
- .parsers = (struct xml_value_parser []) {
- { XML_CONF_SCALAR, 0, &xml_conf_set_slot_key_value_pair_bool, 0 },
- { 0, 0, 0, 0 }
+ if (!kv->value) {
+ free(kv->key);
+ return "fpm_conf_set_array: strdup(value) failed";
}
-};
-
-static char *fpm_conf_set_key_value_pairs_subsection(void **conf, char *name, void *xml_node, intptr_t offset) /* {{{ */
-{
- void *next_kv = (char *) *conf + offset;
- return xml_conf_parse_section(&next_kv, &fpm_conf_set_key_value_pairs_subsection_conf, xml_node);
-}
-/* }}} */
-static char *fpm_conf_set_key_value_pairs_subsection_bool(void **conf, char *name, void *xml_node, intptr_t offset) /* {{{ */
-{
- void *next_kv = (char *) *conf + offset;
- return xml_conf_parse_section(&next_kv, &fpm_conf_set_key_value_pairs_subsection_conf_bool, xml_node);
+ kv->next = **parent;
+ **parent = kv;
+ return NULL;
}
/* }}} */
static void *fpm_worker_pool_config_alloc() /* {{{ */
{
- static struct fpm_worker_pool_s *current_wp = 0;
struct fpm_worker_pool_s *wp;
wp = fpm_worker_pool_alloc();
}
memset(wp->config, 0, sizeof(struct fpm_worker_pool_config_s));
+ wp->config->listen_backlog = -1;
- if (current_wp) {
- current_wp->next = wp;
+ if (!fpm_worker_all_pools) {
+ fpm_worker_all_pools = wp;
+ } else {
+ struct fpm_worker_pool_s *tmp = fpm_worker_all_pools;
+ while (tmp) {
+ if (!tmp->next) {
+ tmp->next = wp;
+ break;
+ }
+ tmp = tmp->next;
+ }
}
current_wp = wp;
struct key_value_s *kv, *kv_next;
free(wpc->name);
+ free(wpc->pm_status_path);
+ free(wpc->ping_path);
+ free(wpc->ping_response);
free(wpc->listen_address);
- free(wpc->pm->status);
- free(wpc->pm->ping);
- free(wpc->pm->pong);
- if (wpc->listen_options) {
- free(wpc->listen_options->owner);
- free(wpc->listen_options->group);
- free(wpc->listen_options->mode);
- free(wpc->listen_options);
- }
+ free(wpc->listen_owner);
+ free(wpc->listen_group);
+ free(wpc->listen_mode);
for (kv = wpc->php_values; kv; kv = kv_next) {
kv_next = kv->next;
free(kv->key);
free(kv->value);
free(kv);
}
- for (kv = wpc->environment; kv; kv = kv_next) {
+ for (kv = wpc->env; kv; kv = kv_next) {
kv_next = kv->next;
free(kv->key);
free(kv->value);
free(kv);
}
- free(wpc->pm);
+ free(wpc->listen_allowed_clients);
free(wpc->user);
free(wpc->group);
free(wpc->chroot);
free(wpc->chdir);
- free(wpc->allowed_clients);
free(wpc->slowlog);
return 0;
}
/* }}} */
-static struct xml_conf_section xml_section_fpm_worker_pool_config = {
- .conf = &fpm_worker_pool_config_alloc,
- .path = "/configuration/workers/pool",
- .parsers = (struct xml_value_parser []) {
- { XML_CONF_SCALAR, "name", &xml_conf_set_slot_string, offsetof(struct fpm_worker_pool_config_s, name) },
- { XML_CONF_SCALAR, "listen_address", &xml_conf_set_slot_string, offsetof(struct fpm_worker_pool_config_s, listen_address) },
- { XML_CONF_SUBSECTION, "listen_options", &fpm_conf_set_listen_options_subsection, offsetof(struct fpm_worker_pool_config_s, listen_options) },
- { XML_CONF_SUBSECTION, "php_value", &fpm_conf_set_key_value_pairs_subsection, offsetof(struct fpm_worker_pool_config_s, php_values) },
- { XML_CONF_SUBSECTION, "php_flag", &fpm_conf_set_key_value_pairs_subsection_bool, offsetof(struct fpm_worker_pool_config_s, php_values) },
- { XML_CONF_SUBSECTION, "php_admin_value", &fpm_conf_set_key_value_pairs_subsection, offsetof(struct fpm_worker_pool_config_s, php_admin_values) },
- { XML_CONF_SUBSECTION, "php_admin_flag", &fpm_conf_set_key_value_pairs_subsection_bool, offsetof(struct fpm_worker_pool_config_s, php_admin_values) },
- { XML_CONF_SCALAR, "user", &xml_conf_set_slot_string, offsetof(struct fpm_worker_pool_config_s, user) },
- { XML_CONF_SCALAR, "group", &xml_conf_set_slot_string, offsetof(struct fpm_worker_pool_config_s, group) },
- { XML_CONF_SCALAR, "chroot", &xml_conf_set_slot_string, offsetof(struct fpm_worker_pool_config_s, chroot) },
- { XML_CONF_SCALAR, "chdir", &xml_conf_set_slot_string, offsetof(struct fpm_worker_pool_config_s, chdir) },
- { XML_CONF_SCALAR, "allowed_clients", &xml_conf_set_slot_string, offsetof(struct fpm_worker_pool_config_s, allowed_clients) },
- { XML_CONF_SUBSECTION, "environment", &fpm_conf_set_key_value_pairs_subsection, offsetof(struct fpm_worker_pool_config_s, environment) },
- { XML_CONF_SCALAR, "request_terminate_timeout", &xml_conf_set_slot_time, offsetof(struct fpm_worker_pool_config_s, request_terminate_timeout) },
- { XML_CONF_SCALAR, "request_slowlog_timeout", &xml_conf_set_slot_time, offsetof(struct fpm_worker_pool_config_s, request_slowlog_timeout) },
- { XML_CONF_SCALAR, "slowlog", &xml_conf_set_slot_string, offsetof(struct fpm_worker_pool_config_s, slowlog) },
- { XML_CONF_SCALAR, "rlimit_files", &xml_conf_set_slot_integer, offsetof(struct fpm_worker_pool_config_s, rlimit_files) },
- { XML_CONF_SCALAR, "rlimit_core", &fpm_conf_set_rlimit_core, 0 },
- { XML_CONF_SCALAR, "max_requests", &xml_conf_set_slot_integer, offsetof(struct fpm_worker_pool_config_s, max_requests) },
- { XML_CONF_SCALAR, "catch_workers_output", &fpm_conf_set_catch_workers_output, 0 },
- { XML_CONF_SUBSECTION, "pm", &fpm_conf_set_pm_subsection, offsetof(struct fpm_worker_pool_config_s, pm) },
- { 0, 0, 0, 0 }
- }
-};
-
-static struct xml_conf_section *fpm_conf_all_sections[] = {
- &xml_section_fpm_global_options,
- &xml_section_fpm_worker_pool_config,
- 0
-};
-
static int fpm_evaluate_full_path(char **path) /* {{{ */
{
if (**path != '/') {
fpm_evaluate_full_path(&wp->config->listen_address);
}
} else {
- wp->is_template = 1;
+ zlog(ZLOG_STUFF, ZLOG_ALERT, "[pool %s] no listen address have been defined!", wp->config->name);
+ return -1;
+ }
+
+ if (!wp->config->user) {
+ zlog(ZLOG_STUFF, ZLOG_ALERT, "[pool %s] user has not been defined", wp->config->name);
+ return -1;
}
if (wp->config->pm == NULL) {
return -1;
}
- if (wp->config->pm->style == PM_STYLE_DYNAMIC) {
- struct fpm_pm_s *pm = wp->config->pm;
+ if (wp->config->pm_max_children < 1) {
+ zlog(ZLOG_STUFF, ZLOG_ALERT, "[pool %s] pm_max_children must be a positiive value", wp->config->name);
+ return -1;
+ }
+
+ if (wp->config->pm == PM_STYLE_DYNAMIC) {
+ struct fpm_worker_pool_config_s *config = wp->config;
- if (pm->dynamic.min_spare_servers <= 0) {
- zlog(ZLOG_STUFF, ZLOG_ALERT, "[pool %s] min_spare_servers(%d) must be a positive value", wp->config->name, pm->dynamic.min_spare_servers);
+ if (config->pm_min_spare_servers <= 0) {
+ zlog(ZLOG_STUFF, ZLOG_ALERT, "[pool %s] min_spare_servers(%d) must be a positive value", wp->config->name, config->pm_min_spare_servers);
return -1;
}
- if (pm->dynamic.max_spare_servers <= 0) {
- zlog(ZLOG_STUFF, ZLOG_ALERT, "[pool %s] max_spare_servers(%d) must be a positive value", wp->config->name, pm->dynamic.max_spare_servers);
+ if (config->pm_max_spare_servers <= 0) {
+ zlog(ZLOG_STUFF, ZLOG_ALERT, "[pool %s] max_spare_servers(%d) must be a positive value", wp->config->name, config->pm_max_spare_servers);
return -1;
}
- if (pm->dynamic.min_spare_servers > pm->max_children ||
- pm->dynamic.max_spare_servers > pm->max_children) {
+ if (config->pm_max_spare_servers > config->pm_max_children ||
+ config->pm_max_spare_servers > config->pm_max_children) {
zlog(ZLOG_STUFF, ZLOG_ALERT, "[pool %s] min_spare_servers(%d) and max_spare_servers(%d) cannot be greater than max_children(%d)",
- wp->config->name, pm->dynamic.min_spare_servers, pm->dynamic.max_spare_servers, pm->max_children);
+ wp->config->name, config->pm_max_spare_servers, config->pm_max_spare_servers, config->pm_max_children);
return -1;
}
- if (pm->dynamic.max_spare_servers < pm->dynamic.min_spare_servers) {
- zlog(ZLOG_STUFF, ZLOG_ALERT, "[pool %s] max_spare_servers(%d) must not be less than min_spare_servers(%d)", wp->config->name, pm->dynamic.max_spare_servers, pm->dynamic.min_spare_servers);
+ if (config->pm_max_spare_servers < config->pm_max_spare_servers) {
+ zlog(ZLOG_STUFF, ZLOG_ALERT, "[pool %s] max_spare_servers(%d) must not be less than min_spare_servers(%d)", wp->config->name, config->pm_max_spare_servers, config->pm_max_spare_servers);
return -1;
}
- if (pm->dynamic.start_servers <= 0) {
- pm->dynamic.start_servers = pm->dynamic.min_spare_servers + ((pm->dynamic.max_spare_servers - pm->dynamic.min_spare_servers) / 2);
- zlog(ZLOG_STUFF, ZLOG_NOTICE, "[pool %s] start_servers has been set to %d", wp->config->name, pm->dynamic.start_servers);
- } else if (pm->dynamic.start_servers < pm->dynamic.min_spare_servers || pm->dynamic.start_servers > pm->dynamic.max_spare_servers) {
- zlog(ZLOG_STUFF, ZLOG_ALERT, "[pool %s] start_servers(%d) must not be less than min_spare_servers(%d) and not greater than max_spare_servers(%d)", wp->config->name, pm->dynamic.start_servers, pm->dynamic.min_spare_servers, pm->dynamic.max_spare_servers);
+ if (config->pm_start_servers <= 0) {
+ config->pm_start_servers = config->pm_min_spare_servers + ((config->pm_max_spare_servers - config->pm_min_spare_servers) / 2);
+ zlog(ZLOG_STUFF, ZLOG_WARNING, "[pool %s] start_servers is not set. It's been set to %d.", wp->config->name, config->pm_start_servers);
+ } else if (config->pm_start_servers < config->pm_max_spare_servers || config->pm_start_servers > config->pm_max_spare_servers) {
+ zlog(ZLOG_STUFF, ZLOG_ALERT, "[pool %s] start_servers(%d) must not be less than min_spare_servers(%d) and not greater than max_spare_servers(%d)", wp->config->name, config->pm_start_servers, config->pm_max_spare_servers, config->pm_max_spare_servers);
return -1;
}
}
if (wp->config->request_slowlog_timeout) {
#if HAVE_FPM_TRACE
if (! (wp->config->slowlog && *wp->config->slowlog)) {
- zlog(ZLOG_STUFF, ZLOG_ERROR, "[pool %s] 'slowlog' must be specified for use with 'request_slowlog_timeout'",
- wp->config->name);
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[pool %s] 'slowlog' must be specified for use with 'request_slowlog_timeout'", wp->config->name);
return -1;
}
#else
static int warned = 0;
if (!warned) {
- zlog(ZLOG_STUFF, ZLOG_WARNING, "[pool %s] 'request_slowlog_timeout' is not supported on your system",
- wp->config->name);
+ zlog(ZLOG_STUFF, ZLOG_WARNING, "[pool %s] 'request_slowlog_timeout' is not supported on your system", wp->config->name);
warned = 1;
}
}
}
- if (wp->config->pm->ping && *wp->config->pm->ping) {
- char *ping = wp->config->pm->ping;
+ if (wp->config->ping_path && *wp->config->ping_path) {
+ char *ping = wp->config->ping_path;
int i;
if (*ping != '/') {
- zlog(ZLOG_STUFF, ZLOG_ERROR, "[pool %s] the ping page '%s' must start with a '/'", wp->config->name, ping);
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[pool %s] the ping path '%s' must start with a '/'", wp->config->name, ping);
return -1;
}
if (strlen(ping) < 2) {
- zlog(ZLOG_STUFF, ZLOG_ERROR, "[pool %s] the ping page '%s' is not long enough", wp->config->name, ping);
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[pool %s] the ping path '%s' is not long enough", wp->config->name, ping);
return -1;
}
for (i=0; i<strlen(ping); i++) {
if (!isalnum(ping[i]) && ping[i] != '/' && ping[i] != '-' && ping[i] != '_' && ping[i] != '.') {
- zlog(ZLOG_STUFF, ZLOG_ERROR, "[pool %s] the ping page '%s' must containt only the following characters '[alphanum]/_-.'", wp->config->name, ping);
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[pool %s] the ping path '%s' must containt only the following characters '[alphanum]/_-.'", wp->config->name, ping);
return -1;
}
}
- if (!wp->config->pm->pong) {
- wp->config->pm->pong = strdup("pong");
+ if (!wp->config->ping_response) {
+ wp->config->ping_response = strdup("pong");
} else {
- if (strlen(wp->config->pm->pong) < 1) {
- zlog(ZLOG_STUFF, ZLOG_ERROR, "[pool %s] the ping response page '%s' is not long enough", wp->config->name, wp->config->pm->pong);
+ if (strlen(wp->config->ping_response) < 1) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[pool %s] the ping response page '%s' is not long enough", wp->config->name, wp->config->ping_response);
return -1;
}
}
} else {
- if (wp->config->pm->pong) {
- free(wp->config->pm->pong);
- wp->config->pm->pong = NULL;
+ if (wp->config->ping_response) {
+ free(wp->config->ping_response);
+ wp->config->ping_response = NULL;
}
}
- if (wp->config->pm->status && *wp->config->pm->status) {
+ if (wp->config->pm_status_path && *wp->config->pm_status_path) {
int i;
- char *status = wp->config->pm->status;
+ char *status = wp->config->pm_status_path;
/* struct fpm_status_s fpm_status; */
if (*status != '/') {
- zlog(ZLOG_STUFF, ZLOG_ERROR, "[pool %s] the status page '%s' must start with a '/'", wp->config->name, status);
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[pool %s] the status path '%s' must start with a '/'", wp->config->name, status);
return -1;
}
if (strlen(status) < 2) {
- zlog(ZLOG_STUFF, ZLOG_ERROR, "[pool %s] the status page '%s' is not long enough", wp->config->name, status);
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[pool %s] the status path '%s' is not long enough", wp->config->name, status);
return -1;
}
for (i=0; i<strlen(status); i++) {
if (!isalnum(status[i]) && status[i] != '/' && status[i] != '-' && status[i] != '_' && status[i] != '.') {
- zlog(ZLOG_STUFF, ZLOG_ERROR, "[pool %s] the status page '%s' must containt only the following characters '[alphanum]/_-.'", wp->config->name, status);
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[pool %s] the status path '%s' must containt only the following characters '[alphanum]/_-.'", wp->config->name, status);
return -1;
}
}
}
fpm_status_update_accepted_conn(wp->shm_status, 0);
fpm_status_update_activity(wp->shm_status, -1, -1, -1, 1);
- fpm_status_set_pm(wp->shm_status, wp->config->pm->style);
+ fpm_status_set_pm(wp->shm_status, wp->config->pm);
/* memset(&fpm_status.last_update, 0, sizeof(fpm_status.last_update)); */
}
}
}
/* }}} */
-int fpm_conf_init_main() /* {{{ */
+static void fpm_conf_ini_parser_include(char *inc, void *arg TSRMLS_DC) /* {{{ */
{
- char *filename = fpm_globals.config;
- char *err;
+ char *filename;
+ int *error = (int *)arg;;
+ glob_t g;
+ int i;
+
+ if (!inc || !arg) return;
+ if (*error) return; /* We got already an error. Switch to the end. */
+ spprintf(&filename, 0, "%s", ini_filename);
+
+#ifdef HAVE_GLOB
+ {
+ g.gl_offs = 0;
+ if ((i = glob(inc, GLOB_ERR | GLOB_MARK | GLOB_NOSORT, NULL, &g)) != 0) {
+#ifdef GLOB_NOMATCH
+ if (i == GLOB_NOMATCH) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "Nothing match the include pattern '%s' from %s at line %d.", inc, filename, ini_lineno);
+ *error = 1;
+ return;
+ }
+#endif /* GLOB_NOMATCH */
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "Unable to globalize '%s' (ret=%d) from %s at line %d.", inc, i, filename, ini_lineno);
+ *error = 1;
+ return;
+ }
+
+ for(i=0; i<g.gl_pathc; i++) {
+ int len = strlen(g.gl_pathv[i]);
+ if (len < 1) continue;
+ if (g.gl_pathv[i][len - 1] == '/') continue; /* don't parse directories */
+ if (0 > fpm_conf_load_ini_file(g.gl_pathv[i])) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "Unable to include %s from %s at line %d", g.gl_pathv[i], filename, ini_lineno);
+ *error = 1;
+ return;
+ }
+ }
+ globfree(&g);
+ }
+#else /* HAVE_GLOB */
+ if (0 > fpm_conf_load_ini_file(inc)) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "Unable to include %s from %s at line %d", inc, filename, ini_lineno);
+ *error = 1;
+ return;
+ }
+#endif /* HAVE_GLOB */
+}
+/* }}} */
+
+static void fpm_conf_ini_parser_section(zval *section, void *arg TSRMLS_DC) /* {{{ */
+{
+ struct fpm_worker_pool_s *wp;
+ struct fpm_worker_pool_config_s *config;
+ int *error = (int *)arg;
+
+ /* switch to global conf */
+ if (!strcasecmp(Z_STRVAL_P(section), "global")) {
+ current_wp = NULL;
+ return;
+ }
+
+ for (wp = fpm_worker_all_pools; wp; wp = wp->next) {
+ if (!wp->config) continue;
+ if (!wp->config->name) continue;
+ if (!strcasecmp(wp->config->name, Z_STRVAL_P(section))) {
+ /* Found a wp with the same name. Bring it back */
+ current_wp = wp;
+ return;
+ }
+ }
+
+ /* it's a new pool */
+ config = (struct fpm_worker_pool_config_s *)fpm_worker_pool_config_alloc();
+ if (!current_wp || !config) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[%s:%d] Unable to alloc a new WorkerPool for worker '%s'", ini_filename, ini_lineno, Z_STRVAL_P(section));
+ *error = 1;
+ return;
+ }
+ config->name = strdup(Z_STRVAL_P(section));
+ if (!config->name) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[%s:%d] Unable to alloc memory for configuration name for worker '%s'", ini_filename, ini_lineno, Z_STRVAL_P(section));
+ *error = 1;
+ return;
+ }
+}
+/* }}} */
+
+static void fpm_conf_ini_parser_entry(zval *name, zval *value, void *arg TSRMLS_DC) /* {{{ */
+{
+ struct ini_value_parser_s *parser;
+ void *config = NULL;
+
+ int *error = (int *)arg;
+ if (!value) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[%s:%d] value is NULL for a ZEND_INI_PARSER_ENTRY", ini_filename, ini_lineno);
+ *error = 1;
+ return;
+ }
+
+ if (!strcmp(Z_STRVAL_P(name), "include")) {
+ // fpm_conf_ini_parser_include(value, error);
+ if (ini_include) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[%s:%d] two includes at the same time !", ini_filename, ini_lineno);
+ *error = 1;
+ return;
+ }
+ ini_include = strdup(Z_STRVAL_P(value));
+ return;
+ }
+
+ if (!current_wp) { /* we are in the global section */
+ parser = ini_fpm_global_options;
+ config = &fpm_global_config;
+ } else {
+ parser = ini_fpm_pool_options;
+ config = current_wp->config;
+ }
+
+ for (;parser->name; parser++) {
+ if (!strcasecmp(parser->name, Z_STRVAL_P(name))) {
+ char *ret;
+ if (!parser->parser) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[%s:%d] the parser for entry '%s' is not defined", ini_filename, ini_lineno, parser->name);
+ *error = 1;
+ return;
+ }
+
+ ret = parser->parser(value, &config, parser->offset);
+ if (ret) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[%s:%d] unable to parse value for entry '%s': %s", ini_filename, ini_lineno, parser->name, ret);
+ *error = 1;
+ return;
+ }
+
+ /* all is good ! */
+ return;
+ }
+ }
+
+ /* nothing has been found if we got here */
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[%s:%d] unknown entry '%s'", ini_filename, ini_lineno, Z_STRVAL_P(name));
+ *error = 1;
+}
+/* }}} */
+
+static void fpm_conf_ini_parser_array(zval *name, zval *key, zval *value, void *arg TSRMLS_DC) /* {{{ */
+{
+ int *error = (int *)arg;
+ char *err = NULL;
+ void *config;
- if (0 > xml_conf_sections_register(fpm_conf_all_sections)) {
+ if (!Z_STRVAL_P(key) || !Z_STRVAL_P(value) || !*Z_STRVAL_P(key) || !*Z_STRVAL_P(value)) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[%s:%d] Mispell array ?", ini_filename, ini_lineno);
+ *error = 1;
+ return;
+ }
+ if (!current_wp || !current_wp->config) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[%s:%d] Array are not allowed in the global section", ini_filename, ini_lineno);
+ *error = 1;
+ return;
+ }
+
+ if (!strcmp("env", Z_STRVAL_P(name))) {
+ config = (char *)current_wp->config + offsetof(struct fpm_worker_pool_config_s, env);
+ err = fpm_conf_set_array(key, value, &config, 0);
+
+ } else if (!strcmp("php_value", Z_STRVAL_P(name))) {
+ config = (char *)current_wp->config + offsetof(struct fpm_worker_pool_config_s, php_values);
+ err = fpm_conf_set_array(key, value, &config, 0);
+
+ } else if (!strcmp("php_admin_value", Z_STRVAL_P(name))) {
+ config = (char *)current_wp->config + offsetof(struct fpm_worker_pool_config_s, php_admin_values);
+ err = fpm_conf_set_array(key, value, &config, 0);
+
+ } else if (!strcmp("php_flag", Z_STRVAL_P(name))) {
+ config = (char *)current_wp->config + offsetof(struct fpm_worker_pool_config_s, php_values);
+ err = fpm_conf_set_array(key, value, &config, 1);
+
+ } else if (!strcmp("php_admin_flag", Z_STRVAL_P(name))) {
+ config = (char *)current_wp->config + offsetof(struct fpm_worker_pool_config_s, php_admin_values);
+ err = fpm_conf_set_array(key, value, &config, 1);
+
+ } else {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[%s:%d] unknown directive '%s'", ini_filename, ini_lineno, Z_STRVAL_P(name));
+ *error = 1;
+ return;
+ }
+
+ if (err) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[%s:%d] error while parsing '%s[%s]' : %s", ini_filename, ini_lineno, Z_STRVAL_P(name), Z_STRVAL_P(key), err);
+ *error = 1;
+ return;
+ }
+}
+/* }}} */
+
+static void fpm_conf_ini_parser(zval *arg1, zval *arg2, zval *arg3, int callback_type, void *arg TSRMLS_DC) /* {{{ */
+{
+ int *error;
+
+ if (!arg1 || !arg) return;
+ error = (int *)arg;
+ if (*error) return; /* We got already an error. Switch to the end. */
+
+ switch(callback_type) {
+ case ZEND_INI_PARSER_ENTRY:
+ fpm_conf_ini_parser_entry(arg1, arg2, error);
+ break;;
+ case ZEND_INI_PARSER_SECTION:
+ fpm_conf_ini_parser_section(arg1, error);
+ break;;
+ case ZEND_INI_PARSER_POP_ENTRY:
+ fpm_conf_ini_parser_array(arg1, arg3, arg2, error);
+ break;;
+ default:
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "[%s:%d] Unknown INI syntax", ini_filename, ini_lineno);
+ *error = 1;
+ break;;
+ }
+}
+/* }}} */
+
+int fpm_conf_load_ini_file(char *filename) /* {{{ */
+{
+ int error = 0;
+ char buf[1024+1];
+ int fd, n;
+ int nb_read = 1;
+ char c = '*';
+
+ int ret = 1;
+
+ if (!filename || !filename[0]) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "Configuration file is empty");
+ return -1;
+ }
+
+ fd = open(filename, O_RDONLY, 0);
+ if (fd < 0) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "Unable to open file '%s', errno=%d", filename, errno);
+ return -1;
+ }
+
+ if (ini_recursion++ > 4) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "You can include more than 5 files recusively");
return -1;
}
+ ini_lineno = 0;
+ while (nb_read > 0) {
+ int tmp;
+ memset(buf, 0, sizeof(char) * (1024 + 1));
+ for (n=0; n<1024 && (nb_read = read(fd, &c, sizeof(char))) == sizeof(char) && c != '\n'; n++) {
+ buf[n] = c;
+ }
+ if (c == '\n') {
+ buf[n++] = c;
+ }
+ ini_lineno++;
+ ini_filename = filename;
+ tmp = zend_parse_ini_string(buf, 1, ZEND_INI_SCANNER_RAW, (zend_ini_parser_cb_t)fpm_conf_ini_parser, &error TSRMLS_CC);
+ ini_filename = filename;
+ if (error || tmp == FAILURE) {
+ if (ini_include) free(ini_include);
+ ini_recursion--;
+ close(fd);
+ return -1;
+ }
+ if (ini_include) {
+ char *tmp = ini_include;
+ ini_include = NULL;
+ fpm_conf_ini_parser_include(tmp, &error TSRMLS_CC);
+ if (error) {
+ free(tmp);
+ ini_recursion--;
+ close(fd);
+ ret = -1;
+ }
+ free(tmp);
+ }
+ }
+
+ ini_recursion--;
+ close(fd);
+ return ret;
+
+}
+/* }}} */
+
+int fpm_conf_init_main() /* {{{ */
+{
+ char *filename = fpm_globals.config;
+ int free = 0;
+ int ret;
+
if (filename == NULL) {
spprintf(&filename, 0, "%s/php-fpm.conf", PHP_SYSCONFDIR);
- err = xml_conf_load_file(filename);
- efree(filename);
- } else {
- err = xml_conf_load_file(filename);
+ free = 1;
}
- if (err) {
- zlog(ZLOG_STUFF, ZLOG_ERROR, "failed to load configuration file: %s", err);
+ ret = fpm_conf_load_ini_file(filename);
+
+ if (0 > ret) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "failed to load configuration file '%s'", filename);
+ if (free) efree(filename);
return -1;
}
+ if (free) efree(filename);
+
if (0 > fpm_conf_post_process()) {
+ zlog(ZLOG_STUFF, ZLOG_ERROR, "failed to post process the configuration");
return -1;
}
- xml_conf_clean();
-
if (0 > fpm_cleanup_add(FPM_CLEANUP_ALL, fpm_conf_cleanup, 0)) {
return -1;
}
-<?xml version="1.0" ?>
-<configuration>
-
- All relative paths in this config are relative to php's install prefix
-
- <section name="global_options">
-
- Pid file
- <value name="pid_file">@EXPANDED_LOCALSTATEDIR@/run/php-fpm.pid</value>
-
- Error log file
- <value name="error_log">@EXPANDED_LOCALSTATEDIR@/log/php-fpm.log</value>
-
- Log level
- <value name="log_level">notice</value>
-
- When this amount of php processes exited with SIGSEGV or SIGBUS ...
- <value name="emergency_restart_threshold">10</value>
-
- ... in a less than this interval of time, a graceful restart will be initiated.
- Useful to work around accidental curruptions in accelerator's shared memory.
- <value name="emergency_restart_interval">1m</value>
-
- Time limit on waiting child's reaction on signals from master
- <value name="process_control_timeout">5s</value>
-
- Set to 'no' to debug fpm
- <value name="daemonize">yes</value>
-
- </section>
-
- <workers>
-
- <section name="pool">
-
- Name of pool. Used in logs and stats.
- <value name="name">default</value>
-
- Address to accept fastcgi requests on.
- Valid syntax is 'ip.ad.re.ss:port' or just 'port' or '/path/to/unix/socket'
- <value name="listen_address">127.0.0.1:9000</value>
-
- <value name="listen_options">
-
- Set listen(2) backlog
- <value name="backlog">-1</value>
-
- Set permissions for unix socket, if one used.
- In Linux read/write permissions must be set in order to allow connections from web server.
- Many BSD-derrived systems allow connections regardless of permissions.
- <value name="owner">@php_fpm_user@</value>
- <value name="group">@php_fpm_group@</value>
- <value name="mode">0666</value>
- </value>
-
- Additional php.ini defines, specific to this pool of workers.
- These settings overwrite the values previously defined in the php.ini.
- Like apache, you can use php_value, php_flag, php_admin_value or php_admin_flag.
- Defining 'extension' will search for the corresponding shared extension in extension_dir.
- Defining 'disable_functions' or 'disable_classes' won't overwrite previously defined
- php.ini value, but the new value will be append.
- <value name="php_value">
- <!-- <value name="error_log">/var/log/php-error.log</value> -->
- </value>
- <value name="php_flag">
- <!-- <value name="log_errors">true</value> -->
- </value>
- <value name="php_admin_value">
- <!-- <value name="sendmail_path">/usr/sbin/sendmail -t -i</value> -->
- </value>
- <value name="php_admin_flag">
- <!-- <value name="display_errors">0</value> -->
- </value>
-
- Unix user of processes
- <value name="user">@php_fpm_user@</value>
-
- Unix group of processes
- <value name="group">@php_fpm_group@</value>
-
- Process manager settings
- <value name="pm">
-
- Sets style of controling worker process count.
- Valid values are 'static' and 'dynamic'
- <value name="style">static</value>
-
- Sets the limit on the number of simultaneous requests that will be served.
- Equivalent to Apache MaxClients directive.
- Equivalent to PHP_FCGI_CHILDREN environment in original php.fcgi
- Used with any pm_style.
- <value name="max_children">50</value>
-
- Sets the status URI to call to obtain php-fpm status page.
- If not set, no URI will be recognized as a status page.
- By default, it returns text/plain looking like:
- accepted conn: 12073
- pool: default
- process manager: static
- idle processes: 35
- active processes: 65
- total processes: 100
- "accepted conn" : the number of request accepted by the pool
- "pool" : the name of the pool
- "process manager": static or dynamic
- "idle processes": the number of idle processes
- "active processes": the number of active processes
- "total processes": idle + active
- The last three number are uptaded every second.
- The "accepted conn" is updated in real time
- *** Output ***
- By default it returns text/plain
- But passing as a query string html or json, it will returns
- the corresponding output syntax:
- http://www.foo.bar/status
- http://www.foo.bar/status?json
- http://www.foo.bar/status?html
- *** WARNING ***
- It has to start with a /. It could be named has you want.
- It's maybe not a good idea to use .php extension to be certain
- not to conflict with a real PHP file
- <value name="status">/status</value>
-
- Set the ping URI to call the monitoring page of php-fpm
- If not set, no URI will be recognized as a ping page.
- This could be used to test from outside that php-fpm
- is alive and responding:
- - have a graph of php-fpm availability (rrd or such)
- - remove a server from a pool if it's not responding (load balancing systems)
- - trigger alerts for the operating team (24/7)
- *** WARNING ***
- It has to start with a /. It could be named has you want.
- It's maybe not a good idea to use .php extension to be certain
- not to conflict with a real PHP file
- <value name="ping">/ping</value>
- Set the response to custom the response of a ping request
- If 'pong' is not set, the default is "pong".
- The response is text/plain with a 200 response code
- <value name="pong">pong</value>
-
- Settings group for 'dynamic' pm style
- <value name="dynamic">
-
- Sets the number of server processes created on startup.
- Used only when 'dynamic' pm_style is selected
- <value name="start_servers">20</value>
-
- Sets the desired minimum number of idle server processes.
- Used only when 'dynamic' pm_style is selected
- <value name="min_spare_servers">5</value>
-
- Sets the desired maximum number of idle server processes.
- Used only when 'dynamic' pm_style is selected
- <value name="max_spare_servers">35</value>
-
- </value>
-
- </value>
-
- The timeout (in seconds) for serving a single request after which the worker process will be terminated
- Should be used when 'max_execution_time' ini option does not stop script execution for some reason
- '0s' means 'off'
- <value name="request_terminate_timeout">0s</value>
-
- The timeout (in seconds) for serving of single request after which a php backtrace will be dumped to slow.log file
- '0s' means 'off'
- <value name="request_slowlog_timeout">0s</value>
-
- The log file for slow requests
- <value name="slowlog">@EXPANDED_LOCALSTATEDIR@/log/php-fpm.log.slow</value>
-
- Set open file desc rlimit
- <value name="rlimit_files">1024</value>
-
- Set max core size rlimit
- <value name="rlimit_core">0</value>
-
- Chroot to this directory at the start, absolute path
- <value name="chroot"></value>
-
- Chdir to this directory at the start, absolute path
- <value name="chdir"></value>
-
- Redirect workers' stdout and stderr into main error log.
- If not set, they will be redirected to /dev/null, according to FastCGI specs
- <value name="catch_workers_output">yes</value>
-
- How much requests each process should execute before respawn.
- Useful to work around memory leaks in 3rd party libraries.
- For endless request processing please specify 0
- Equivalent to PHP_FCGI_MAX_REQUESTS
- <value name="max_requests">500</value>
-
- Comma separated list of ipv4 addresses of FastCGI clients that allowed to connect.
- Equivalent to FCGI_WEB_SERVER_ADDRS environment in original php.fcgi (5.2.2+)
- Makes sense only with AF_INET listening socket.
- <value name="allowed_clients">127.0.0.1</value>
-
- Pass environment variables like LD_LIBRARY_PATH
- All $VARIABLEs are taken from current environment
- <value name="environment">
- <value name="HOSTNAME">$HOSTNAME</value>
- <value name="PATH">/usr/local/bin:/usr/bin:/bin</value>
- <value name="TMP">/tmp</value>
- <value name="TMPDIR">/tmp</value>
- <value name="TEMP">/tmp</value>
- <value name="OSTYPE">$OSTYPE</value>
- <value name="MACHTYPE">$MACHTYPE</value>
- <value name="MALLOC_CHECK_">2</value>
- </value>
-
- </section>
-
- </workers>
-
-</configuration>
+;
+; All relative paths in this config are relative to php's install prefix
+;
+;
+; Include one or more files.
+; If glob(3) exists, it's used to include a bunch of files from a glob(3) pattern
+; This directive can be used everywhere in the file.
+;
+;include=@EXPANDED_SYSCONFDIR@/fpm.d/*.conf
+;
+;
+
+[global]
+; Pid file
+; default: none
+;
+;pid = @EXPANDED_LOCALSTATEDIR@/run/php-fpm.pid
+
+; Error log file
+; default: @EXPANDED_LOCALSTATEDIR@/log/php-fpm.log
+;
+;error_log = @EXPANDED_LOCALSTATEDIR@/log/php-fpm.log
+
+; Log level
+; alert, error, warning, notice, debug
+; default: notice
+;
+;log_level = notice
+
+; When this amount of php processes exited with SIGSEGV or SIGBUS ...
+; 0 means 'Off'
+; default: 0
+;
+;emergency_restart_threshold = 0
+
+; ... in a less than this interval of time, a graceful restart will be initiated.
+; Useful to work around accidental curruptions in accelerator's shared memory.
+; available units are s(econd), m(inute), h(hour), or d(day)
+; default : 0s
+;
+;emergency_restart_interval = 0s
+
+; Time limit on waiting child's reaction on signals from master
+; available units are s(econd), m(inute), h(hour), or d(day)
+; default : 0s
+;
+;process_control_timeout = 0s
+
+; send fpm to backgound (default)
+; set to 'no' to keep FPM in foreground for debugging
+; default : yes
+;
+;daemonize = yes
+
+; Start a new pool named 'www'
+; The name is used in logs and stats
+; There is no limitation of the number of pool FPM can handle. Your system will tell you anyway :)
+[www]
+
+; Address to accept fastcgi requests on.
+; Valid syntaxes are:
+; - 'ip.ad.re.ss:port' to listen on a TCP scoket to the specific address on the specific port
+; - 'port' to listen on a TCP socket to all addreses on the specific port
+; - '/path/to/unix/socket' to listen on a unix socket
+; it's mandatory
+;
+listen = 127.0.0.1:9000
+
+; Set listen(2) backlog
+; -1 means unlimited
+; default : -1
+;
+;listen.backlog = -1
+
+; Set permissions for unix socket, if one used.
+; In Linux read/write permissions must be set in order to allow connections from web server.
+; Many BSD-derrived systems allow connections regardless of permissions.
+; default: user and group are set as the running user. Mode is set to 0666
+;
+;listen.owner = @php_fpm_user@
+;listen.group = @php_fpm_group@
+;listen.mode = 0666
+
+; Unix user/group of processes
+; The user is mandatory. If the group is not set, the default user's group
+; will be used
+user = @php_fpm_user@
+group = @php_fpm_group@
+
+; Choose the process manager which control how processes are managed
+; Two choices:
+; - static : a fixed number (pm.max_children) of child processes
+; - dynamic : The number of child processes are set up dynamically depending on the following directives
+; - pm.max_children : the maximum number of children that can be alive at the same time
+; - pm.start_servers : the number of children created on startup
+; - pm.min_spare_servers : the minimum number of children in 'idle' state (waiting to precess).
+; If the number of 'idle' processes is less than this number,
+; some children will be created.
+; - pm.max_spare_servers : the maximum number of children in 'idle' state (waiting to precess).
+; If the number of 'idle' processes is greater than this number,
+; some children will be killed;
+; It's mandatory
+pm = dynamic
+
+; Sets the limit on the number of simultaneous requests (children processes will be forked) that will be served.
+; Equivalent to Apache MaxClients directive (with mpm_prefork).
+; Equivalent to PHP_FCGI_CHILDREN environment in original php.fcgi
+; Used with any pm.style.
+; It's mandatory
+;
+pm.max_children = 50
+
+; Sets the number of server processes created on startup.
+; Used only with 'dynamic' pm.style
+; default : min_spare + (max_spare - min_spare) / 2
+;
+;pm.start_servers = 20
+
+; Sets the desired minimum number of idle server processes.
+; Used only with 'dynamic' pm.style
+; It's mandatory when pm is set to dynamic
+;
+;pm.min_spare_servers = 5
+
+; Sets the desired maximum number of idle server processes.
+; Used only with 'dynamic' pm.style
+; It's mandatory when pm is set to dynamic
+;
+;pm.max_spare_servers = 35
+
+; How much requests each process should execute before respawn.
+; Useful to work around memory leaks in 3rd party libraries.
+; For endless request processing please specify 0
+; Equivalent to PHP_FCGI_MAX_REQUESTS
+; default : 0
+;
+;max_requests = 500
+
+; Sets the status URI to call to obtain php-fpm status page.
+; If not set, no URI will be recognized as a status page.
+; By default, it returns text/plain looking like:
+; accepted conn: 12073
+; pool: default
+; process manager: static
+; idle processes: 35
+; active processes: 65
+; total processes: 100
+; "accepted conn" : the number of request accepted by the pool
+; "pool" : the name of the pool
+; "process manager": static or dynamic
+; "idle processes": the number of idle processes
+; "active processes": the number of active processes
+; "total processes": idle + active
+; The last three number are uptaded every second.
+; The "accepted conn" is updated in real time
+; *** Output ***
+; By default it returns text/plain
+; But passing as a query string html or json, it will returns
+; the corresponding output syntax:
+; http://www.foo.bar/status
+; http://www.foo.bar/status?json
+; http://www.foo.bar/status?html
+; *** WARNING ***
+; It has to start with a /. It could be named has you want.
+; It's maybe not a good idea to use .php extension to be certain
+; not to conflict with a real PHP file
+;
+; default: not set
+;
+;pm.status_path = /status
+
+; Set the ping URI to call the monitoring page of php-fpm
+; If not set, no URI will be recognized as a ping page.
+; This could be used to test from outside that php-fpm
+; is alive and responding:
+; - have a graph of php-fpm availability (rrd or such)
+; - remove a server from a pool if it's not responding (load balancing systems)
+; - trigger alerts for the operating team (24/7)
+; *** WARNING ***
+; It has to start with a /. It could be named has you want.
+; It's maybe not a good idea to use .php extension to be certain
+; not to conflict with a real PHP file
+;
+; default: not set
+;
+;ping.path = /ping
+
+; Set the response to custom the response of a ping request
+; If 'pong' is not set, the default is "pong".
+; The response is text/plain with a 200 response code
+;
+; default: pong
+;
+;pong.response = pong
+
+; The timeout (in seconds) for serving a single request after which the worker process will be terminated
+; Should be used when 'max_execution_time' ini option does not stop script execution for some reason
+; '0' means 'off'
+; available units are s(econd), m(inute), h(hour), or d(day)
+; default: 0
+;
+;request_terminate_timeout = 0s
+
+; The timeout (in seconds) for serving of single request after which a php backtrace will be dumped to slow.log file
+; '0s' means 'off'
+; available units are s(econd), m(inute), h(hour), or d(day)
+;
+;request_slowlog_timeout = 0s
+
+; The log file for slow requests
+; default: @EXPANDED_LOCALSTATEDIR@/log/php-fpm.log.slow
+;
+;slowlog = @EXPANDED_LOCALSTATEDIR@/log/php-fpm.log.slow
+
+; Set open file desc rlimit
+; default: system defined value
+;
+;rlimit_files = 1024
+
+; Set max core size rlimit
+; It could be
+; - unlimited
+; - an integer greater or equal to 0
+; default: system defined value
+;
+;rlimit_core = 0
+
+; Chroot to this directory at the start, absolute path
+; *** WARNING ***
+; chrooting is a great security features and should be used whenever it's possible.
+; However, all php path will be related to the chroot (error_log, sessions.save_path, ...)
+; When not set, chroot is not used
+; default: not set
+;
+;chroot =
+
+; Chdir to this directory at the start, absolute path
+; default: current directory or / when chroot
+;
+;chdir = /var/www
+
+; Redirect workers' stdout and stderr into main error log.
+; If not set, they will be redirected to /dev/null, according to FastCGI specs
+; default: no
+;
+;catch_workers_output = yes
+
+; List of ipv4 addresses of FastCGI clients that allowed to connect.
+; Equivalent to FCGI_WEB_SERVER_ADDRS environment in original php.fcgi (5.2.2+)
+; Makes sense only with a tcp listening socket.
+; Each addresses must be separated by a comma
+; default: any
+;
+;listen.allowed_client = 127.0.0.1
+
+; Pass environment variables like LD_LIBRARY_PATH
+; All $VARIABLEs are taken from current environment
+; default: clean env
+;
+;env[HOSTNAME] = $HOSTNAME
+;env[PATH] = /usr/local/bin:/usr/bin:/bin
+;env[TMP] = /tmp
+;env[TMPDIR] = /tmp
+;env[TEMP] = /tmp
+
+; Additional php.ini defines, specific to this pool of workers.
+; These settings overwrite the values previously defined in the php.ini.
+; The directives are the same as the php sapi:
+; - php_value/php_flag: you can set classic ini defines which can be overwriten from PHP call 'ini_set'.
+; - php_admin_value/php_admin_flag: those directives won't be overwriten by PHP call 'ini_set'
+; For php_*flag, valid values are on, off, 1, 0, true, false, yes or no
+;
+; Defining 'extension' will load the corresponding shared extension from extension_dir.
+; Defining 'disable_functions' or 'disable_classes' won't overwrite previously defined
+; php.ini value, but the new value will be append.
+;
+; default: nothing is defined but the ones in php.ini and at startup with the -d arguement
+;
+;php_admin_value[sendmail_path] = /usr/sbin/sendmail -t -i -fpool1@my.domain.com
+;php_flag[display_errors] = off
+;php_admin_value[error_log] = /var/log/fpm-php.www.log
+;php_admin_value[log_errors] = on
+;php_admin_value[memory_limit] = 32M
projects / php / commitdiff