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 array $values = [];
 
    private array $initial_values = [];
 
    private bool $cookies_configured = false;
 
    private array $cookies = [];
    
    protected array $locked_values = [
        'assetroot',
        'cacheroot',
        'dataroot',
        'installed',
        'plugins_path',
        'wwwroot',
    ];
 
    protected array $deprecated = [];
    
    protected array $config_defaults = [
        'admin_validation_notification' => false,
        '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,
        '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_enable_query_logging' => false,
        '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,
        'mentions_display_format' => 'display_name',
        'message_delay' => 6,
        'min_password_length' => 6,
        'minusername' => 4,
        'notifications_max_runtime' => 45,
        'notifications_queue_delay' => 0,
        'pagination_behaviour' => 'ajax-replace',
        'require_admin_validation' => false,
        '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,
        'subresource_integrity_enabled' => false,
        'system_cache_enabled' => false,
        'testing_mode' => false,
        'trash_enabled' => true,
        'trash_retention' => 30,
        'user_joined_river' => false,
        'webp_enabled' => true,
        'who_can_change_language' => 'everyone',
    ];
    
    protected array $path_properties = [
        'assetroot',
        'cacheroot',
        'dataroot',
        'plugins_path',
    ];
    
    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(string $settings_path = ''): static {
        $settings_path = self::resolvePath($settings_path);
 
        return self::fromFile($settings_path);
    }
 
    protected static function fromFile($path): static {
        if (!is_file($path)) {
            throw new ConfigurationException(__METHOD__ . ": Reading configs failed: File {$path} not present.");
        }
 
        if (!is_readable($path)) {
            throw new ConfigurationException(__METHOD__ . ": Reading configs failed: File {$path} not readable.");
        }
 
        // 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)) {
            throw new ConfigurationException(__METHOD__ . ': Reading configs failed: The Elgg settings file is missing $CONFIG->dataroot.');
        }
 
        if (empty($GLOBALS['CONFIG']->wwwroot)) {
            throw new ConfigurationException(__METHOD__ . ': Reading configs failed: The Elgg settings file is missing $CONFIG->wwwroot.');
        }
 
        $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'});
        }
 
        return $config;
    }
 
    public static function resolvePath(string $settings_path = ''): string {
        if (empty($settings_path)) {
            $settings_path = Paths::settingsFile(Paths::SETTINGS_PHP);
        }
 
        return Paths::sanitize($settings_path, false);
    }
 
    public function getValues(): array {
        return $this->values;
    }
 
    public function getCookieConfig(): array {
        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(string $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 null;
        }
        
        $value = $this->values[$name];
        if (in_array($name, $this->path_properties)) {
            $value = Paths::sanitize($value);
        }
 
        return $value;
    }
 
    public function hasValue(string $name): bool {
        return isset($this->values[$name]);
    }
 
    public function getInitialValue(string $name) {
        return $this->initial_values[$name] ?? null;
    }
 
    public function hasInitialValue(string $name): bool {
        return isset($this->initial_values[$name]);
    }
 
    public function isLocked(string $name): bool {
        $testing = $this->values['testing_mode'] ?? false;
        return !$testing && in_array($name, $this->locked_values) && $this->hasValue($name);
    }
 
    public function __set(string $name, $value): void {
        if ($this->wasWarnedLocked($name)) {
            return;
        }
        
        if (in_array($name, $this->path_properties)) {
            $value = Paths::sanitize($value);
        }
        
        $this->values[$name] = $value;
    }
 
    public function __isset(string $name): bool {
        return $this->__get($name) !== null;
    }
 
    public function __unset(string $name): void {
        if ($this->wasWarnedLocked($name)) {
            return;
        }
 
        unset($this->values[$name]);
    }
 
    public function save(string $name, $value): bool {
        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(string $name): bool {
        if ($this->wasWarnedLocked($name)) {
            return false;
        }
 
        $result = _elgg_services()->configTable->remove($name);
 
        unset($this->values[$name]);
    
        return $result;
    }
 
    protected function wasWarnedLocked(string $name): bool {
        if (!$this->isLocked($name)) {
            return false;
        }
        
        $this->getLogger()->warning("The property {$name} is read-only.");
 
        return true;
    }
}