Variant IniSetting::FromString(const String& ini, const String& filename,
bool process_sections /* = false */,
int scanner_mode /* = NormalScanner */) {
Lock lock(s_mutex); // ini parser is not thread-safe
// We are parsing something new, so reset this flag
s_config_is_a_constant = false;
auto ini_cpp = ini.toCppString();
auto filename_cpp = filename.toCppString();
if (process_sections) {
CallbackData data;
SectionParserCallback cb;
data.arr = Array::Create();
if (zend_parse_ini_string(ini_cpp, filename_cpp, scanner_mode, cb, &data)) {
return data.arr;
}
} else {
ParserCallback cb;
Variant ret = Array::Create();
if (zend_parse_ini_string(ini_cpp, filename_cpp, scanner_mode, cb, &ret)) {
return ret;
}
}
return false;
}
IniSetting::Map IniSetting::FromStringAsMap(const std::string& ini,
const std::string& filename) {
Lock lock(s_mutex); // ini parser is not thread-safe
SystemParserCallback cb;
Map ret = IniSetting::Map::object;
zend_parse_ini_string(ini, filename, NormalScanner, cb, &ret);
return ret;
}
IniSettingMap IniSetting::FromStringAsMap(const std::string& ini,
const std::string& filename) {
Lock lock(s_mutex); // ini parser is not thread-safe
// We are parsing something new, so reset this flag
s_config_is_a_constant = false;
SystemParserCallback cb;
Variant parsed;
zend_parse_ini_string(ini, filename, NormalScanner, cb, &parsed);
return std::move(parsed);
}
Variant IniSetting::FromString(CStrRef ini, CStrRef filename,
bool process_sections, int scanner_mode) {
Lock lock(s_mutex); // ini parser is not thread-safe
if (process_sections) {
CallbackData data;
data.arr = Array::Create();
if (zend_parse_ini_string
(ini, filename, scanner_mode, php_ini_parser_cb_with_sections, &data)) {
return data.arr;
}
} else {
Variant ret = Array::Create();
if (zend_parse_ini_string
(ini, filename, scanner_mode, php_simple_ini_parser_cb, &ret)) {
return ret;
}
}
return false;
}
Variant IniSetting::FromString(const String& ini, const String& filename,
bool process_sections, int scanner_mode) {
Lock lock(s_mutex); // ini parser is not thread-safe
auto ini_cpp = ini.toCppString();
auto filename_cpp = filename.toCppString();
if (process_sections) {
SectionParserCallback::CallbackData data;
SectionParserCallback cb;
data.arr = Array::Create();
if (zend_parse_ini_string(ini_cpp, filename_cpp, scanner_mode, cb, &data)) {
return data.arr;
}
} else {
ParserCallback cb;
Variant ret = Array::Create();
if (zend_parse_ini_string(ini_cpp, filename_cpp, scanner_mode, cb, &ret)) {
return ret;
}
}
return false;
}
IniSettingMap IniSetting::FromStringAsMap(const std::string& ini,
const std::string& filename) {
Lock lock(s_mutex); // ini parser is not thread-safe
// We are parsing something new, so reset this flag
s_config_is_a_constant = false;
SystemParserCallback cb;
Variant parsed;
zend_parse_ini_string(ini, filename, NormalScanner, cb, &parsed);
if (parsed.isNull()) {
return uninit_null();
}
// We have the final values for our ini settings.
// Unbox everything so that we have no more references in the map since we do
// things that might require us not to have references
// (e.g. calling Variant::SetEvalScalar(), which will assert if an
// arraydata's elements are KindOfRef)
std::set<ArrayData*> seen;
bool use_defaults = false;
Variant ret = Unbox(parsed, seen, use_defaults, empty_string());
if (use_defaults) {
return uninit_null();
}
return ret;
}
int fpm_conf_load_ini_file(char *filename) /* {{{ */
{
int error = 0;
char *buf = NULL, *newbuf = NULL;
int bufsize = 0;
int fd, n;
int nb_read = 1;
char c = '*';
int ret = 1;
if (!filename || !filename[0]) {
zlog(ZLOG_ERROR, "configuration filename is empty");
return -1;
}
fd = open(filename, O_RDONLY, 0);
if (fd < 0) {
zlog(ZLOG_SYSERROR, "failed to open configuration file '%s'", filename);
return -1;
}
if (ini_recursion++ > 4) {
zlog(ZLOG_ERROR, "failed to include more than 5 files recusively");
close(fd);
return -1;
}
ini_lineno = 0;
while (nb_read > 0) {
int tmp;
ini_lineno++;
ini_filename = filename;
for (n = 0; (nb_read = read(fd, &c, sizeof(char))) == sizeof(char) && c != '\n'; n++) {
if (n == bufsize) {
bufsize += 1024;
newbuf = (char*) realloc(buf, sizeof(char) * (bufsize + 2));
if (newbuf == NULL) {
ini_recursion--;
close(fd);
free(buf);
return -1;
}
buf = newbuf;
}
buf[n] = c;
}
if (n == 0) {
continue;
}
/* always append newline and null terminate */
buf[n++] = '\n';
buf[n] = '\0';
tmp = zend_parse_ini_string(buf, 1, ZEND_INI_SCANNER_NORMAL, (zend_ini_parser_cb_t)fpm_conf_ini_parser, &error);
ini_filename = filename;
if (error || tmp == FAILURE) {
if (ini_include) free(ini_include);
ini_recursion--;
close(fd);
free(buf);
return -1;
}
if (ini_include) {
char *tmp = ini_include;
ini_include = NULL;
fpm_evaluate_full_path(&tmp, NULL, NULL, 0);
fpm_conf_ini_parser_include(tmp, &error);
if (error) {
free(tmp);
ini_recursion--;
close(fd);
free(buf);
return -1;
}
free(tmp);
}
}
free(buf);
ini_recursion--;
close(fd);
return ret;
}
/* {{{ php_init_config
*/
int php_init_config(void)
{
char *php_ini_file_name = NULL;
char *php_ini_search_path = NULL;
int php_ini_scanned_path_len;
char *open_basedir;
int free_ini_search_path = 0;
zend_file_handle fh;
zend_hash_init(&configuration_hash, 8, NULL, config_zval_dtor, 1);
if (sapi_module.ini_defaults) {
sapi_module.ini_defaults(&configuration_hash);
}
zend_llist_init(&extension_lists.engine, sizeof(char *), (llist_dtor_func_t) free_estring, 1);
zend_llist_init(&extension_lists.functions, sizeof(char *), (llist_dtor_func_t) free_estring, 1);
open_basedir = PG(open_basedir);
if (sapi_module.php_ini_path_override) {
php_ini_file_name = sapi_module.php_ini_path_override;
php_ini_search_path = sapi_module.php_ini_path_override;
free_ini_search_path = 0;
} else if (!sapi_module.php_ini_ignore) {
int search_path_size;
char *default_location;
char *env_location;
static const char paths_separator[] = { ZEND_PATHS_SEPARATOR, 0 };
#ifdef PHP_WIN32
char *reg_location;
char phprc_path[MAXPATHLEN];
#endif
env_location = getenv("PHPRC");
#ifdef PHP_WIN32
if (!env_location) {
char dummybuf;
int size;
SetLastError(0);
/*If the given bugger is not large enough to hold the data, the return value is
the buffer size, in characters, required to hold the string and its terminating
null character. We use this return value to alloc the final buffer. */
size = GetEnvironmentVariableA("PHPRC", &dummybuf, 0);
if (GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
/* The environment variable doesn't exist. */
env_location = "";
} else {
if (size == 0) {
env_location = "";
} else {
size = GetEnvironmentVariableA("PHPRC", phprc_path, size);
if (size == 0) {
env_location = "";
} else {
env_location = phprc_path;
}
}
}
}
#else
if (!env_location) {
env_location = "";
}
#endif
/*
* Prepare search path
*/
search_path_size = MAXPATHLEN * 4 + (int)strlen(env_location) + 3 + 1;
php_ini_search_path = (char *) emalloc(search_path_size);
free_ini_search_path = 1;
php_ini_search_path[0] = 0;
/* Add environment location */
if (env_location[0]) {
if (*php_ini_search_path) {
strlcat(php_ini_search_path, paths_separator, search_path_size);
}
strlcat(php_ini_search_path, env_location, search_path_size);
php_ini_file_name = env_location;
}
#ifdef PHP_WIN32
/* Add registry location */
reg_location = GetIniPathFromRegistry();
if (reg_location != NULL) {
if (*php_ini_search_path) {
strlcat(php_ini_search_path, paths_separator, search_path_size);
}
strlcat(php_ini_search_path, reg_location, search_path_size);
efree(reg_location);
}
#endif
/* Add cwd (not with CLI) */
if (!sapi_module.php_ini_ignore_cwd) {
if (*php_ini_search_path) {
strlcat(php_ini_search_path, paths_separator, search_path_size);
}
strlcat(php_ini_search_path, ".", search_path_size);
}
if (PG(php_binary)) {
char *separator_location, *binary_location;
binary_location = estrdup(PG(php_binary));
separator_location = strrchr(binary_location, DEFAULT_SLASH);
if (separator_location && separator_location != binary_location) {
*(separator_location) = 0;
}
if (*php_ini_search_path) {
strlcat(php_ini_search_path, paths_separator, search_path_size);
}
strlcat(php_ini_search_path, binary_location, search_path_size);
efree(binary_location);
}
/* Add default location */
#ifdef PHP_WIN32
default_location = (char *) emalloc(MAXPATHLEN + 1);
if (0 < GetWindowsDirectory(default_location, MAXPATHLEN)) {
if (*php_ini_search_path) {
strlcat(php_ini_search_path, paths_separator, search_path_size);
}
strlcat(php_ini_search_path, default_location, search_path_size);
}
/* For people running under terminal services, GetWindowsDirectory will
* return their personal Windows directory, so lets add the system
* windows directory too */
if (0 < GetSystemWindowsDirectory(default_location, MAXPATHLEN)) {
if (*php_ini_search_path) {
strlcat(php_ini_search_path, paths_separator, search_path_size);
}
strlcat(php_ini_search_path, default_location, search_path_size);
}
efree(default_location);
#else
default_location = PHP_CONFIG_FILE_PATH;
if (*php_ini_search_path) {
strlcat(php_ini_search_path, paths_separator, search_path_size);
}
strlcat(php_ini_search_path, default_location, search_path_size);
#endif
}
PG(open_basedir) = NULL;
/*
* Find and open actual ini file
*/
memset(&fh, 0, sizeof(fh));
/* If SAPI does not want to ignore all ini files OR an overriding file/path is given.
* This allows disabling scanning for ini files in the PHP_CONFIG_FILE_SCAN_DIR but still
* load an optional ini file. */
if (!sapi_module.php_ini_ignore || sapi_module.php_ini_path_override) {
/* Check if php_ini_file_name is a file and can be opened */
if (php_ini_file_name && php_ini_file_name[0]) {
zend_stat_t statbuf;
if (!VCWD_STAT(php_ini_file_name, &statbuf)) {
if (!((statbuf.st_mode & S_IFMT) == S_IFDIR)) {
fh.handle.fp = VCWD_FOPEN(php_ini_file_name, "r");
if (fh.handle.fp) {
fh.filename = php_ini_opened_path = expand_filepath(php_ini_file_name, NULL);
}
}
}
}
/* Otherwise search for php-%sapi-module-name%.ini file in search path */
if (!fh.handle.fp) {
const char *fmt = "php-%s.ini";
char *ini_fname;
spprintf(&ini_fname, 0, fmt, sapi_module.name);
fh.handle.fp = php_fopen_with_path(ini_fname, "r", php_ini_search_path, &php_ini_opened_path);
efree(ini_fname);
if (fh.handle.fp) {
fh.filename = php_ini_opened_path;
}
}
/* If still no ini file found, search for php.ini file in search path */
if (!fh.handle.fp) {
fh.handle.fp = php_fopen_with_path("php.ini", "r", php_ini_search_path, &php_ini_opened_path);
if (fh.handle.fp) {
fh.filename = php_ini_opened_path;
}
}
}
if (free_ini_search_path) {
efree(php_ini_search_path);
}
PG(open_basedir) = open_basedir;
if (fh.handle.fp) {
fh.type = ZEND_HANDLE_FP;
RESET_ACTIVE_INI_HASH();
zend_parse_ini_file(&fh, 1, ZEND_INI_SCANNER_NORMAL, (zend_ini_parser_cb_t) php_ini_parser_cb, &configuration_hash);
{
zval tmp;
ZVAL_NEW_STR(&tmp, zend_string_init(fh.filename, strlen(fh.filename), 1));
zend_hash_str_update(&configuration_hash, "cfg_file_path", sizeof("cfg_file_path")-1, &tmp);
if (php_ini_opened_path) {
efree(php_ini_opened_path);
}
php_ini_opened_path = zend_strndup(Z_STRVAL(tmp), Z_STRLEN(tmp));
}
}
/* Check for PHP_INI_SCAN_DIR environment variable to override/set config file scan directory */
php_ini_scanned_path = getenv("PHP_INI_SCAN_DIR");
if (!php_ini_scanned_path) {
/* Or fall back using possible --with-config-file-scan-dir setting (defaults to empty string!) */
php_ini_scanned_path = PHP_CONFIG_FILE_SCAN_DIR;
}
php_ini_scanned_path_len = (int)strlen(php_ini_scanned_path);
/* Scan and parse any .ini files found in scan path if path not empty. */
if (!sapi_module.php_ini_ignore && php_ini_scanned_path_len) {
struct dirent **namelist;
int ndir, i;
zend_stat_t sb;
char ini_file[MAXPATHLEN];
char *p;
zend_file_handle fh2;
zend_llist scanned_ini_list;
zend_llist_element *element;
int l, total_l = 0;
char *bufpath, *debpath, *endpath;
int lenpath;
zend_llist_init(&scanned_ini_list, sizeof(char *), (llist_dtor_func_t) free_estring, 1);
memset(&fh2, 0, sizeof(fh2));
bufpath = estrdup(php_ini_scanned_path);
for (debpath = bufpath ; debpath ; debpath=endpath) {
endpath = strchr(debpath, DEFAULT_DIR_SEPARATOR);
if (endpath) {
*(endpath++) = 0;
}
if (!debpath[0]) {
/* empty string means default builtin value
to allow "/foo/phd.d:" or ":/foo/php.d" */
debpath = PHP_CONFIG_FILE_SCAN_DIR;
}
lenpath = (int)strlen(debpath);
if (lenpath > 0 && (ndir = php_scandir(debpath, &namelist, 0, php_alphasort)) > 0) {
for (i = 0; i < ndir; i++) {
/* check for any file with .ini extension */
if (!(p = strrchr(namelist[i]->d_name, '.')) || (p && strcmp(p, ".ini"))) {
free(namelist[i]);
continue;
}
/* Reset active ini section */
RESET_ACTIVE_INI_HASH();
if (IS_SLASH(debpath[lenpath - 1])) {
snprintf(ini_file, MAXPATHLEN, "%s%s", debpath, namelist[i]->d_name);
} else {
snprintf(ini_file, MAXPATHLEN, "%s%c%s", debpath, DEFAULT_SLASH, namelist[i]->d_name);
}
if (VCWD_STAT(ini_file, &sb) == 0) {
if (S_ISREG(sb.st_mode)) {
if ((fh2.handle.fp = VCWD_FOPEN(ini_file, "r"))) {
fh2.filename = ini_file;
fh2.type = ZEND_HANDLE_FP;
if (zend_parse_ini_file(&fh2, 1, ZEND_INI_SCANNER_NORMAL, (zend_ini_parser_cb_t) php_ini_parser_cb, &configuration_hash) == SUCCESS) {
/* Here, add it to the list of ini files read */
l = (int)strlen(ini_file);
total_l += l + 2;
p = estrndup(ini_file, l);
zend_llist_add_element(&scanned_ini_list, &p);
}
}
}
}
free(namelist[i]);
}
free(namelist);
}
}
efree(bufpath);
if (total_l) {
int php_ini_scanned_files_len = (php_ini_scanned_files) ? (int)strlen(php_ini_scanned_files) + 1 : 0;
php_ini_scanned_files = (char *) realloc(php_ini_scanned_files, php_ini_scanned_files_len + total_l + 1);
if (!php_ini_scanned_files_len) {
*php_ini_scanned_files = '\0';
}
total_l += php_ini_scanned_files_len;
for (element = scanned_ini_list.head; element; element = element->next) {
if (php_ini_scanned_files_len) {
strlcat(php_ini_scanned_files, ",\n", total_l);
}
strlcat(php_ini_scanned_files, *(char **)element->data, total_l);
strlcat(php_ini_scanned_files, element->next ? ",\n" : "\n", total_l);
}
}
zend_llist_destroy(&scanned_ini_list);
} else {
/* Make sure an empty php_ini_scanned_path ends up as NULL */
php_ini_scanned_path = NULL;
}
if (sapi_module.ini_entries) {
/* Reset active ini section */
RESET_ACTIVE_INI_HASH();
zend_parse_ini_string(sapi_module.ini_entries, 1, ZEND_INI_SCANNER_NORMAL, (zend_ini_parser_cb_t) php_ini_parser_cb, &configuration_hash);
}
return SUCCESS;
}
