ElggPluginPackage.php

Go to the documentation of this file.

<?php

class ElggPluginPackage {

    const STATIC_CONFIG_FILENAME = 'elgg-plugin.php';

    private $requiredFiles = [
        'manifest.xml'
    ];

    private $textFiles = [
        'README.txt',
        'CHANGES.txt',
        'INSTALL.txt',
        'COPYRIGHT.txt',
        'LICENSE.txt',
        'README',
        'README.md',
        'README.markdown'
    ];

    private $providesSupportedTypes = [
        'plugin',
        'php_extension'
    ];

    private $depsSupportedTypes = [
        'elgg_release',
        'php_version',
        'php_extension',
        'php_ini',
        'plugin',
        'priority',
    ];

    private $errorMsg = '';

    protected $manifest;

    protected $path;

    protected $valid = null;

    protected $id;

    public function __construct($plugin, $validate = true) {
        $plugin_path = _elgg_config()->plugins_path;
        // @todo wanted to avoid another is_dir() call here.
        // should do some profiling to see how much it affects
        if (strpos($plugin, $plugin_path) === 0 || is_dir($plugin)) {
            // this is a path
            $path = \Elgg\Project\Paths::sanitize($plugin);

            // the id is the last element of the array
            $path_array = explode('/', trim($path, '/'));
            $id = array_pop($path_array);
        } else {
            // this is a plugin id
            // strict plugin names
            if (preg_match('/[^a-z0-9\.\-_]/i', $plugin)) {
                $msg = elgg_echo('PluginException:InvalidID', [$plugin]);
                throw PluginException::factory('InvalidID', null, $msg);
            }

            $path = "{$plugin_path}$plugin/";
            $id = $plugin;
        }

        if (!is_dir($path)) {
            $msg = elgg_echo('PluginException:InvalidPath', [$path]);
            throw PluginException::factory('InvalidPath', null, $msg);
        }

        $this->path = $path;
        $this->id = $id;

        if ($validate && !$this->isValid()) {
            if ($this->errorMsg) {
                $msg = elgg_echo('PluginException:InvalidPlugin:Details', [$plugin, $this->errorMsg]);
                throw PluginException::factory('InvalidPluginDetails', null, $msg);
            } else {
                $msg = elgg_echo('PluginException:InvalidPlugin', [$plugin]);
                throw PluginException::factory('InvalidPlugin', null, $msg);
            }
        }
    }

    /********************************
     * Validation and sanity checks *
     ********************************/

    public function isValid() {
        if (!isset($this->valid)) {
            $this->valid = $this->validate();
        }

        return $this->valid;
    }

    private function validate() {
        // check required files.
        foreach ($this->requiredFiles as $file) {
            if (!is_readable($this->path . $file)) {
                $this->errorMsg = elgg_echo('ElggPluginPackage:InvalidPlugin:MissingFile', [$file]);

                return false;
            }
        }

        // check for valid manifest.
        if (!$this->loadManifest()) {
            return false;
        }

        if (!$this->isNamedCorrectly()) {
            return false;
        }

        // can't require or conflict with yourself or something you provide.
        // make sure provides are all valid.
        if (!$this->hasSaneDependencies()) {
            return false;
        }

        if (!$this->hasReadableConfigFile()) {
            return false;
        }

        return true;
    }

    private function hasReadableConfigFile() {
        $file = "{$this->path}/" . self::STATIC_CONFIG_FILENAME;
        if (!is_file($file)) {
            return true;
        }

        if (is_readable($file)) {
            return true;
        }

        $this->errorMsg = elgg_echo('ElggPluginPackage:InvalidPlugin:UnreadableConfig');

        return false;
    }

    private function isNamedCorrectly() {
        $manifest = $this->getManifest();
        if ($manifest) {
            $required_id = $manifest->getID();
            if (!empty($required_id) && ($required_id !== $this->id)) {
                $this->errorMsg = elgg_echo('ElggPluginPackage:InvalidPlugin:InvalidId', [$required_id]);

                return false;
            }
        }

        return true;
    }

    private function hasSaneDependencies() {
        // protection against plugins with no manifest file
        if (!$this->getManifest()) {
            return false;
        }

        // Note: $conflicts and $requires are not unused. They're called dynamically
        $conflicts = $this->getManifest()->getConflicts();
        $requires = $this->getManifest()->getRequires();
        $provides = $this->getManifest()->getProvides();

        foreach ($provides as $provide) {
            // only valid provide types
            if (!in_array($provide['type'], $this->providesSupportedTypes)) {
                $this->errorMsg = elgg_echo('ElggPluginPackage:InvalidPlugin:InvalidProvides', [
                    $provide['type'],
                ]);

                return false;
            }

            // doesn't conflict or require any of its provides
            $name = $provide['name'];
            foreach (['conflicts', 'requires'] as $dep_type) {
                foreach (${$dep_type} as $dep) {
                    if (!in_array($dep['type'], $this->depsSupportedTypes)) {
                        $this->errorMsg = elgg_echo('ElggPluginPackage:InvalidPlugin:InvalidDependency', [
                            $dep['type'],
                        ]);

                        return false;
                    }

                    // make sure nothing is providing something it conflicts or requires.
                    if (isset($dep['name']) && $dep['name'] == $name) {
                        $version_compare = version_compare($provide['version'], $dep['version'], $dep['comparison']);

                        if ($version_compare) {
                            $this->errorMsg = elgg_echo('ElggPluginPackage:InvalidPlugin:CircularDep', [
                                $dep['type'],
                                $dep['name'],
                                $this->id,
                            ]);

                            return false;
                        }
                    }
                }
            }
        }

        return true;
    }


    /************
     * Manifest *
     ************/

    public function getManifest() {
        if (!$this->manifest) {
            if (!$this->loadManifest()) {
                return false;
            }
        }

        return $this->manifest;
    }

    private function loadManifest() {
        $file = $this->path . 'manifest.xml';

        try {
            $this->manifest = new \ElggPluginManifest($file, $this->id);
        } catch (Exception $e) {
            elgg_log($e, \Psr\Log\LogLevel::ERROR);

            $this->errorMsg = $e->getMessage();

            return false;
        }

        if ($this->manifest instanceof \ElggPluginManifest) {
            return true;
        }

        $this->errorMsg = elgg_echo('unknown_error');

        return false;
    }

    /****************
     * Readme Files *
     ***************/

    public function getTextFilenames() {
        return $this->textFiles;
    }

    /***********************
     * Dependencies system *
     ***********************/

    public function checkDependencies($full_report = false) {
        // Note: $conflicts and $requires are not unused. They're called dynamically
        $requires = $this->getManifest()->getRequires();
        $conflicts = $this->getManifest()->getConflicts();

        $enabled_plugins = elgg_get_plugins('active');
        $this_id = $this->getID();
        $report = [];

        // first, check if any active plugin conflicts with us.
        foreach ($enabled_plugins as $plugin) {
            $temp_conflicts = [];
            $temp_manifest = $plugin->getManifest();
            if ($temp_manifest instanceof \ElggPluginManifest) {
                $temp_conflicts = $plugin->getManifest()->getConflicts();
            }
            foreach ($temp_conflicts as $conflict) {
                if ($conflict['type'] == 'plugin' && $conflict['name'] == $this_id) {
                    $result = $this->checkDepPlugin($conflict, $enabled_plugins, false);

                    // rewrite the conflict to show the originating plugin
                    $conflict['name'] = $plugin->getDisplayName();

                    if (!$full_report && !$result['status']) {
                        $css_id = preg_replace('/[^a-z0-9-]/i', '-', $plugin->getManifest()->getID());
                        $link = elgg_view('output/url', [
                            'text' => $plugin->getDisplayName(),
                            'href' => "#$css_id",
                        ]);

                        $key = 'ElggPluginPackage:InvalidPlugin:ConflictsWithPlugin';
                        $this->errorMsg = elgg_echo($key, [$link]);

                        return $result['status'];
                    } else {
                        $report[] = [
                            'type' => 'conflicted',
                            'dep' => $conflict,
                            'status' => $result['status'],
                            'value' => $this->getManifest()->getVersion()
                        ];
                    }
                }
            }
        }

        $check_types = ['requires', 'conflicts'];

        if ($full_report) {
            // Note: $suggests is not unused. It's called dynamically
            $suggests = $this->getManifest()->getSuggests();
            $check_types[] = 'suggests';
        }

        foreach ($check_types as $dep_type) {
            $inverse = ($dep_type == 'conflicts') ? true : false;

            foreach (${$dep_type} as $dep) {
                switch ($dep['type']) {
                    case 'elgg_release':
                        $result = $this->checkDepElgg($dep, elgg_get_version(true), $inverse);
                        break;

                    case 'plugin':
                        $result = $this->checkDepPlugin($dep, $enabled_plugins, $inverse);
                        break;

                    case 'priority':
                        $result = $this->checkDepPriority($dep, $enabled_plugins, $inverse);
                        break;

                    case 'php_version':
                        $result = $this->checkDepPhpVersion($dep, $inverse);
                        break;

                    case 'php_extension':
                        $result = $this->checkDepPhpExtension($dep, $inverse);
                        break;

                    case 'php_ini':
                        $result = $this->checkDepPhpIni($dep, $inverse);
                        break;

                    default:
                        $result = null;//skip further check
                        break;
                }

                if ($result !== null) {
                    // unless we're doing a full report, break as soon as we fail.
                    if (!$full_report && !$result['status']) {
                        $type = $dep['type'];
                        
                        if ($type === 'priority') {
                            $text = "{$dep['priority']} {$dep['plugin']}";
                        } else {
                            $text = $dep['name'];
                        }
                        
                        $this->errorMsg = elgg_echo('admin:plugins:label:missing_dependency', ["{$type}: {$text}"]);

                        return $result['status'];
                    } else {
                        // build report element and comment
                        $report[] = [
                            'type' => $dep_type,
                            'dep' => $dep,
                            'status' => $result['status'],
                            'value' => $result['value']
                        ];
                    }
                }
            }
        }

        if ($full_report) {
            // add provides to full report
            $provides = $this->getManifest()->getProvides();

            foreach ($provides as $provide) {
                $report[] = [
                    'type' => 'provides',
                    'dep' => $provide,
                    'status' => true,
                    'value' => ''
                ];
            }

            return $report;
        }

        return true;
    }

    private function checkDepPlugin(array $dep, array $plugins, $inverse = false) {
        $r = _elgg_services()->plugins->checkProvides('plugin', $dep['name'], $dep['version'], $dep['comparison']);

        if ($inverse) {
            $r['status'] = !$r['status'];
        }

        return $r;
    }

    private function checkDepPriority(array $dep, array $plugins, $inverse = false) {
        // grab the \ElggPlugin using this package.
        $plugin_package = elgg_get_plugin_from_id($this->getID());
        if (!$plugin_package) {
            return [
                'status' => true,
                'value' => 'uninstalled'
            ];
        }

        $test_plugin = elgg_get_plugin_from_id($dep['plugin']);

        // If this isn't a plugin or the plugin isn't installed or active
        // priority doesn't matter. Use requires to check if a plugin is active.
        if (!$test_plugin || !$test_plugin->isActive()) {
            return [
                'status' => true,
                'value' => 'uninstalled'
            ];
        }

        $plugin_priority = $plugin_package->getPriority();
        $test_plugin_priority = $test_plugin->getPriority();

        switch ($dep['priority']) {
            case 'before':
                $status = $plugin_priority < $test_plugin_priority;
                break;

            case 'after':
                $status = $plugin_priority > $test_plugin_priority;
                break;

            default;
                $status = false;
        }

        // get the current value
        if ($plugin_priority < $test_plugin_priority) {
            $value = 'before';
        } else {
            $value = 'after';
        }

        if ($inverse) {
            $status = !$status;
        }

        return [
            'status' => $status,
            'value' => $value
        ];
    }

    private function checkDepElgg(array $dep, $elgg_version, $inverse = false) {
        $status = version_compare($elgg_version, $dep['version'], $dep['comparison']);

        if ($inverse) {
            $status = !$status;
        }

        return [
            'status' => $status,
            'value' => $elgg_version
        ];
    }

    private function checkDepPhpVersion(array $dep, $inverse = false) {
        $php_version = phpversion();
        $status = version_compare($php_version, $dep['version'], $dep['comparison']);

        if ($inverse) {
            $status = !$status;
        }

        return [
            'status' => $status,
            'value' => $php_version
        ];
    }

    private function checkDepPhpExtension(array $dep, $inverse = false) {
        $name = $dep['name'];
        $version = $dep['version'];
        $comparison = $dep['comparison'];

        // not enabled.
        $status = extension_loaded($name);

        // enabled. check version.
        $ext_version = phpversion($name);

        if ($status) {
            // some extensions (like gd) don't provide versions. neat.
            // don't check version info and return a lie.
            if ($ext_version && $version) {
                $status = version_compare($ext_version, $version, $comparison);
            }

            if (!$ext_version) {
                $ext_version = '???';
            }
        }

        // some php extensions can be emulated, so check provides.
        if ($status == false) {
            $provides = _elgg_services()->plugins->checkProvides('php_extension', $name, $version, $comparison);
            $status = $provides['status'];
            $ext_version = $provides['value'];
        }

        if ($inverse) {
            $status = !$status;
        }

        return [
            'status' => $status,
            'value' => $ext_version
        ];
    }

    private function checkDepPhpIni($dep, $inverse = false) {
        $name = $dep['name'];
        $value = $dep['value'];
        $comparison = $dep['comparison'];

        // ini_get() normalizes truthy values to 1 but falsey values to 0 or ''.
        // version_compare() considers '' < 0, so normalize '' to 0.
        // \ElggPluginManifest normalizes all bool values and '' to 1 or 0.
        $setting = ini_get($name);

        if ($setting === '') {
            $setting = 0;
        }

        $status = version_compare($setting, $value, $comparison);

        if ($inverse) {
            $status = !$status;
        }

        return [
            'status' => $status,
            'value' => $setting
        ];
    }

    public function getID() {
        return $this->id;
    }

    public function getError() {
        return $this->errorMsg;
    }
}