Config.php

Go to the documentation of this file.

<?php

namespace Elgg;

use Elgg\Exceptions\ConfigurationException;
use Elgg\Project\Paths;
use Elgg\Traits\Loggable;

class Config {
    
    use Loggable;

    private $values;

    private $initial_values;

    private $cookies_configured = false;

    private $cookies = [];
    
    protected $locked_values = [
        'assetroot',
        'cacheroot',
        'dataroot',
        'elgg_settings_file',
        'installed',
        'path',
        'plugins_path',
        'pluginspath',
        'site_guid',
        'url',
        'wwwroot',
    ];

    protected $deprecated = [
        'elgg_settings_file' => '4.3',
        'path' => '4.3',
        'pluginspath' => '4.3',
        'site_guid' => '4.3',
        'sitedescription' => '4.3',
        'sitename' => '4.3',
        'url' => '4.3',
    ];
    
    protected $config_defaults = [
        'allow_phpinfo' => false,
        'authentication_failures_lifetime' => 600,
        'authentication_failures_limit' => 5,
        'auto_disable_plugins' => true,
        'batch_run_time_in_secs' => 4,
        'boot_cache_ttl' => 3600,
        'bootdata_plugin_settings_limit' => 40,
        'can_change_username' => false,
        'class_loader_verify_file_existence' => true,
        'comment_box_collapses' => true,
        'comments_group_only' => true,
        'comments_latest_first' => true,
        'comments_max_depth' => 0,
        'comments_per_page' => 25,
        'db_query_cache_limit' => 50,
        'default_limit' => 10,
        'elgg_maintenance_mode' => false,
        'email_html_part' => true,
        'email_html_part_images' => 'no',
        'email_subject_limit' => 998,
        'enable_delayed_email' => true,
        'friendly_time_number_of_days' => 30,
        'icon_sizes' => [
            'topbar' => ['w' => 16, 'h' => 16, 'square' => true, 'upscale' => true],
            'tiny' => ['w' => 25, 'h' => 25, 'square' => true, 'upscale' => true],
            'small' => ['w' => 40, 'h' => 40, 'square' => true, 'upscale' => true],
            'medium' => ['w' => 100, 'h' => 100, 'square' => true, 'upscale' => true],
            'large' => ['w' => 200, 'h' => 200, 'square' => true, 'upscale' => true],
            'master' => ['w' => 10240, 'h' => 10240, 'square' => false, 'upscale' => false, 'crop' => false],
        ],
        'language' => 'en',
        'language_detect_from_browser' => true,
        'lastcache' => 0,
        'message_delay' => 6,
        'min_password_length' => 6,
        'minusername' => 4,
        'notifications_max_runtime' => 45,
        'notifications_queue_delay' => 0,
        'pagination_behaviour' => 'ajax-replace',
        'security_email_require_confirmation' => true,
        'security_email_require_password' => true,
        'security_notify_admins' => true,
        'security_notify_user_password' => true,
        'security_protect_upgrade' => true,
        'session_bound_entity_icons' => false,
        'simplecache_enabled' => false,
        'site_guid' => 1, // deprecated
        'subresource_integrity_enabled' => false,
        'system_cache_enabled' => false,
        'testing_mode' => false,
        'webp_enabled' => true,
        'who_can_change_language' => 'everyone',
    ];
    
    protected $path_properties = [
        'dataroot',
        'cacheroot',
        'assetroot',
    ];
    
    const ENTITY_TYPES = ['group', 'object', 'site', 'user'];

    const SENSITIVE_PROPERTIES = [
        '__site_secret__',
        'db',
        'dbhost',
        'dbport',
        'dbuser',
        'dbpass',
        'dbname',
    ];
    
    public function __construct(array $values = []) {
        $this->saveInitialValues($values);
        
        $this->values = array_merge($this->config_defaults, $values);
        
        // set cookie values for session and remember me
        $this->getCookieConfig();
    }
    
    protected function saveInitialValues(array $values): void {
        // Don't keep copies of these in case config gets dumped
        foreach (self::SENSITIVE_PROPERTIES as $name) {
            unset($values[$name]);
        }
        
        $this->initial_values = $values;
    }

    public static function factory($settings_path = '', $try_env = true) {
        $reason1 = '';

        $settings_path = self::resolvePath($settings_path, $try_env);

        $config = self::fromFile($settings_path, $reason1);

        if (!$config) {
            throw new ConfigurationException(__METHOD__ . ": Reading configs failed: $reason1");
        }

        return $config;
    }

    public static function fromFile($path, &$reason = '') {
        if (!is_file($path)) {
            $reason = "File $path not present.";
            return false;
        }

        if (!is_readable($path)) {
            $reason = "File $path not readable.";
            return false;
        }

        // legacy loading. If $CONFIG doesn't exist, remove it after the
        // settings file is read.
        if (isset($GLOBALS['CONFIG'])) {
            // don't overwrite it
            $global = $GLOBALS['CONFIG'];
            unset($GLOBALS['CONFIG']);
        } else {
            $global = null;
        }

        Includer::requireFile($path);

        if (empty($GLOBALS['CONFIG']->dataroot)) {
            $reason = 'The Elgg settings file is missing $CONFIG->dataroot.';
            return false;
        }

        if (empty($GLOBALS['CONFIG']->wwwroot)) {
            $reason = 'The Elgg settings file is missing $CONFIG->wwwroot.';
            return false;
        }

        $config = new self(get_object_vars($GLOBALS['CONFIG']));

        if ($global !== null) {
            // restore
            $GLOBALS['CONFIG'] = $global;
        } else {
            unset($GLOBALS['CONFIG']);
        }

        if ($config->{'X-Sendfile-Type'}) {
            $config->{'x_sendfile_type'} = $config->{'X-Sendfile-Type'};
            unset($config->{'X-Sendfile-Type'});
        }
        if ($config->{'X-Accel-Mapping'}) {
            $config->{'x_accel_mapping'} = $config->{'X-Accel-Mapping'};
            unset($config->{'X-Accel-Mapping'});
        }

        $config->elgg_settings_file = $path;

        return $config;
    }

    public static function resolvePath($settings_path = '', $try_env = true) {
        if (!$settings_path) {
            if ($try_env && !empty($_ENV['ELGG_SETTINGS_FILE'])) {
                $settings_path = $_ENV['ELGG_SETTINGS_FILE'];
            } else if (!$settings_path) {
                $settings_path = Paths::settingsFile(Paths::SETTINGS_PHP);
            }
        }

        return \Elgg\Project\Paths::sanitize($settings_path, false);
    }

    public function mergeValues(array $values) {
        foreach ($values as $name => $value) {
            $this->__set($name, $value);
        }
    }

    public function getValues() {
        return $this->values;
    }

    public function getCookieConfig() {
        if ($this->cookies_configured) {
            return $this->cookies;
        }

        $cookies = [];
        if ($this->hasInitialValue('cookies')) {
            $cookies = $this->getInitialValue('cookies');
        }

        // session cookie config
        if (!isset($cookies['session'])) {
            $cookies['session'] = [];
        }
        $session_defaults = session_get_cookie_params();
        $session_defaults['name'] = 'Elgg';
        $cookies['session'] = array_merge($session_defaults, $cookies['session']);
        
        // remember me cookie config
        if (!isset($cookies['remember_me'])) {
            $cookies['remember_me'] = [];
        }
        $session_defaults['name'] = 'elggperm';
        $session_defaults['expire'] = strtotime("+30 days");
        $cookies['remember_me'] = array_merge($session_defaults, $cookies['remember_me']);

        $this->cookies = $cookies;
        $this->cookies_configured = true;

        return $cookies;
    }

    public function __get($name) {

        if (array_key_exists($name, $this->deprecated)) {
            elgg_deprecated_notice("Using '{$name}' from config has been deprecated", $this->deprecated[$name]);
        }
        
        if (isset($this->values[$name])) {
            return $this->values[$name];
        }

        return null;
    }

    public function hasValue($name) {
        return isset($this->values[$name]);
    }

    public function getInitialValue($name) {
        return $this->initial_values[$name] ?? null;
    }

    public function hasInitialValue($name) {
        return isset($this->initial_values[$name]);
    }

    public function lock($name) {
        elgg_deprecated_notice(__METHOD__ . 'has been deprecated. It is no longer possible to lock config values.', '4.3');
    }

    public function isLocked($name) {
        $testing = $this->values['testing_mode'] ?? false;
        return !$testing && in_array($name, $this->locked_values) && $this->hasValue($name);
    }

    public function __set($name, $value) {
        if ($this->wasWarnedLocked($name)) {
            return;
        }
        
        if (in_array($name, $this->path_properties)) {
            $value = Paths::sanitize($value);
        }
        
        $this->values[$name] = $value;
    }

    public function __isset($name) {
        return $this->__get($name) !== null;
    }

    public function __unset($name) {
        if ($this->wasWarnedLocked($name)) {
            return;
        }

        unset($this->values[$name]);
    }

    public function save($name, $value) {
        if ($this->wasWarnedLocked($name)) {
            return false;
        }

        if (strlen($name) > 255) {
            $this->getLogger()->error("The name length for configuration variables cannot be greater than 255");
            return false;
        }

        if ($value === null) {
            // don't save null values
            return $this->remove($name);
        }
        
        $result = _elgg_services()->configTable->set($name, $value);

        $this->__set($name, $value);
    
        return $result;
    }

    public function remove($name) {
        if ($this->wasWarnedLocked($name)) {
            return false;
        }

        $result = _elgg_services()->configTable->remove($name);

        unset($this->values[$name]);
    
        return $result;
    }

    protected function wasWarnedLocked($name): bool {
        if (!$this->isLocked($name)) {
            return false;
        }
        
        $this->getLogger()->warning("The property {$name} is read-only.");

        return true;
    }
}