C:/xampp/htdocs/moodle/lib/environmentlib.php

Go to the documentation of this file.

<?php

// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

defined('MOODLE_INTERNAL') || die();


    require_once($CFG->libdir.'/xmlize.php');


    define('NO_ERROR',                           0);
    define('NO_VERSION_DATA_FOUND',              1);
    define('NO_DATABASE_SECTION_FOUND',          2);
    define('NO_DATABASE_VENDORS_FOUND',          3);
    define('NO_DATABASE_VENDOR_MYSQL_FOUND',     4);
    define('NO_DATABASE_VENDOR_POSTGRES_FOUND',  5);
    define('NO_PHP_SECTION_FOUND',               6);
    define('NO_PHP_VERSION_FOUND',               7);
    define('NO_PHP_EXTENSIONS_SECTION_FOUND',    8);
    define('NO_PHP_EXTENSIONS_NAME_FOUND',       9);
    define('NO_DATABASE_VENDOR_VERSION_FOUND',  10);
    define('NO_UNICODE_SECTION_FOUND',          11);
    define('NO_CUSTOM_CHECK_FOUND',             12);
    define('CUSTOM_CHECK_FILE_MISSING',         13);
    define('CUSTOM_CHECK_FUNCTION_MISSING',     14);
    define('NO_PHP_SETTINGS_NAME_FOUND',        15);


    define('ENV_SELECT_NEWER',                   0);
    define('ENV_SELECT_DATAROOT',                1);
    define('ENV_SELECT_RELEASE',                 2);

function check_moodle_environment($version, $env_select = ENV_SELECT_NEWER) {

    $status = true;

    static $result = true;
    static $env_results;
    static $cache_exists = false;

    if ($cache_exists) {
        $environment_results = $env_results;
    } else {
        if (!$version = get_latest_version_available($version, $env_select)) {
            $status = false;
        }

        if (!($environment_results = environment_check($version, $env_select)) && $status) {
            $status = false;
        }

        if ($status) {
            foreach ($environment_results as $environment_result) {
                if (!$environment_result->getStatus() && $environment_result->getLevel() == 'required'
                  && !$environment_result->getBypassStr()) {
                    $result = false; // required item that is not bypased
                } else if ($environment_result->getStatus() && $environment_result->getLevel() == 'required'
                  && $environment_result->getRestrictStr()) {
                    $result = false; // required item that is restricted
                } else if ($environment_result->getErrorCode()) {
                    $result = false;
                }
            }
        }
        $env_results = $environment_results;
        $cache_exists = true;
    } 

    return array($result && $status, $environment_results);
}


function environment_get_errors($environment_results) {
    global $CFG;
    $errors = array();

    // Iterate over each environment_result
    foreach ($environment_results as $environment_result) {
        $type = $environment_result->getPart();
        $info = $environment_result->getInfo();
        $status = $environment_result->getStatus();
        $error_code = $environment_result->getErrorCode();

        $a = new stdClass();
        if ($error_code) {
            $a->error_code = $error_code;
            $errors[] = array($info, get_string('environmentxmlerror', 'admin', $a));
            return $errors;
        }

        if ($environment_result->getBypassStr() != '') {
            // not interesting
            continue;
        } else if ($environment_result->getRestrictStr() != '') {
            // error
        } else {
            if ($status) {
                // ok
                continue;
            } else {
                if ($environment_result->getLevel() == 'optional') {
                    // just a warning
                    continue;
                } else {
                    // error
                }
            }
        }

        // We are comparing versions
        $rec = new stdClass();
        if ($rec->needed = $environment_result->getNeededVersion()) {
            $rec->current = $environment_result->getCurrentVersion();
            if ($environment_result->getLevel() == 'required') {
                $stringtouse = 'environmentrequireversion';
            } else {
                $stringtouse = 'environmentrecommendversion';
            }
        // We are checking installed & enabled things
        } else if ($environment_result->getPart() == 'custom_check') {
            if ($environment_result->getLevel() == 'required') {
                $stringtouse = 'environmentrequirecustomcheck';
            } else {
                $stringtouse = 'environmentrecommendcustomcheck';
            }
        } else if ($environment_result->getPart() == 'php_setting') {
            if ($status) {
                $stringtouse = 'environmentsettingok';
            } else if ($environment_result->getLevel() == 'required') {
                $stringtouse = 'environmentmustfixsetting';
            } else {
                $stringtouse = 'environmentshouldfixsetting';
            }
        } else {
            if ($environment_result->getLevel() == 'required') {
                $stringtouse = 'environmentrequireinstall';
            } else {
                $stringtouse = 'environmentrecommendinstall';
            }
        }
        $report = get_string($stringtouse, 'admin', $rec);

        // Here we'll store all the feedback found
        $feedbacktext = '';
        // Append  the feedback if there is some
        $feedbacktext .= $environment_result->strToReport($environment_result->getFeedbackStr(), 'error');
        // Append the restrict if there is some
        $feedbacktext .= $environment_result->strToReport($environment_result->getRestrictStr(), 'error');

        $report .= html_to_text($feedbacktext);

        if ($environment_result->getPart() == 'custom_check'){
            $errors[] = array($info, $report);
        } else {
            $errors[] = array(($info !== '' ? "$type $info" : $type), $report);
        }
    }

    return $errors;
}


function normalize_version($version) {

    $version = trim($version);
    $versionarr = explode(" ",$version);
    if (!empty($versionarr)) {
        $version = $versionarr[0];
    }
    $version = preg_replace('/[^\.\d]/', '.', $version);
    $version = preg_replace('/(\.{2,})/', '.', $version);
    $version = trim($version, '.');

    return $version;
}


function load_environment_xml($env_select=ENV_SELECT_NEWER) {

    global $CFG;

    static $data; //Only load and xmlize once by request

    if (!empty($data)) {
        return $data;
    }

    $file = $CFG->dataroot.'/environment/environment.xml';
    $internalfile = $CFG->dirroot.'/'.$CFG->admin.'/environment.xml';
    switch ($env_select) {
        case ENV_SELECT_NEWER:
            if (!is_file($file) || !is_readable($file) || filemtime($file) < filemtime($internalfile) ||
                !$contents = file_get_contents($file)) {
                if (!is_file($internalfile) || !is_readable($internalfile) || !$contents = file_get_contents($internalfile)) {
                    return false;
                }
            }
            break;
        case ENV_SELECT_DATAROOT:
            if (!is_file($file) || !is_readable($file) || !$contents = file_get_contents($file)) {
                return false;
            }
            break;
        case ENV_SELECT_RELEASE:
            if (!is_file($internalfile) || !is_readable($internalfile) || !$contents = file_get_contents($internalfile)) {
                return false;
            }
            break;
    }
    $data = xmlize($contents);

    return $data;
}


function get_list_of_environment_versions ($contents) {

    static $versions = array();

    if (!empty($versions)) {
        return $versions;
    }

    if (isset($contents['COMPATIBILITY_MATRIX']['#']['MOODLE'])) {
        foreach ($contents['COMPATIBILITY_MATRIX']['#']['MOODLE'] as $version) {
            $versions[] = $version['@']['version'];
        }
    }

    return $versions;
}


function get_latest_version_available ($version, $env_select) {

    $version = normalize_version($version);

    if (!$contents = load_environment_xml($env_select)) {
        return false;
    }

    if (!$versions = get_list_of_environment_versions($contents)) {
        return false;
    }
    if (in_array($version, $versions)) {
        return $version;
    } else {
        $found_version = false;
        foreach ($versions as $arrversion) {
            if (version_compare($arrversion, $version, '<')) {
                $found_version = $arrversion;
            }
        }
    }

    return $found_version;
}


function get_environment_for_version($version, $env_select) {

    $version = normalize_version($version);

    if (!$contents = load_environment_xml($env_select)) {
        return false;
    }

    if (!$versions = get_list_of_environment_versions($contents)) {
        return false;
    }

    if (!in_array($version, $versions)) {
        return false;
    }

    $fl_arr = array_flip($versions);

    return $contents['COMPATIBILITY_MATRIX']['#']['MOODLE'][$fl_arr[$version]];
}


function environment_check($version, $env_select) {
    global $CFG;

    $version = normalize_version($version);

    $results = array(); //To store all the results

    if (!empty($CFG->version)) {
        $results[] = environment_check_moodle($version, $env_select);
    }
    $results[] = environment_check_unicode($version, $env_select);
    $results[] = environment_check_database($version, $env_select);
    $results[] = environment_check_php($version, $env_select);

    $phpext_results = environment_check_php_extensions($version, $env_select);
    $results = array_merge($results, $phpext_results);

    $phpsetting_results = environment_check_php_settings($version, $env_select);
    $results = array_merge($results, $phpsetting_results);

    $custom_results = environment_custom_checks($version, $env_select);
    $results = array_merge($results, $custom_results);

    return $results;
}


function environment_check_php_extensions($version, $env_select) {

    $results = array();

    if (!$data = get_environment_for_version($version, $env_select)) {
        $result = new environment_results('php_extension');
        $result->setStatus(false);
        $result->setErrorCode(NO_VERSION_DATA_FOUND);
        return array($result);
    }

    if (!isset($data['#']['PHP_EXTENSIONS']['0']['#']['PHP_EXTENSION'])) {
        $result = new environment_results('php_extension');
        $result->setStatus(false);
        $result->setErrorCode(NO_PHP_EXTENSIONS_SECTION_FOUND);
        return array($result);
    }
    foreach($data['#']['PHP_EXTENSIONS']['0']['#']['PHP_EXTENSION'] as $extension) {
        $result = new environment_results('php_extension');
        $level = get_level($extension);
        if (!isset($extension['@']['name'])) {
            $result->setStatus(false);
            $result->setErrorCode(NO_PHP_EXTENSIONS_NAME_FOUND);
        } else {
            $extension_name = $extension['@']['name'];
            if (!extension_loaded($extension_name)) {
                $result->setStatus(false);
            } else {
                $result->setStatus(true);
            }
            $result->setLevel($level);
            $result->setInfo($extension_name);
        }

        process_environment_result($extension, $result);

        $results[] = $result;
    }


    return $results;
}

function environment_check_php_settings($version, $env_select) {

    $results = array();

    if (!$data = get_environment_for_version($version, $env_select)) {
        $result = new environment_results('php_setting');
        $result->setStatus(false);
        $result->setErrorCode(NO_VERSION_DATA_FOUND);
        $results[] = $result;
        return $results;
    }

    if (!isset($data['#']['PHP_SETTINGS']['0']['#']['PHP_SETTING'])) {
        return $results;
    }
    foreach($data['#']['PHP_SETTINGS']['0']['#']['PHP_SETTING'] as $setting) {
        $result = new environment_results('php_setting');
        $level = get_level($setting);
        $result->setLevel($level);
        if (!isset($setting['@']['name'])) {
            $result->setStatus(false);
            $result->setErrorCode(NO_PHP_SETTINGS_NAME_FOUND);
        } else {
            $setting_name  = $setting['@']['name'];
            $setting_value = $setting['@']['value'];
            $result->setInfo($setting_name);

            if ($setting_name == 'memory_limit') {
                $current = ini_get('memory_limit');
                if ($current == -1) {
                    $result->setStatus(true);
                } else {
                    $current  = get_real_size($current);
                    $minlimit = get_real_size($setting_value);
                    if ($current < $minlimit) {
                        @ini_set('memory_limit', $setting_value);
                        $current = ini_get('memory_limit');
                        $current = get_real_size($current);
                    }
                    $result->setStatus($current >= $minlimit);
                }

            } else {
                $current = ini_get_bool($setting_name);
                if ($current == $setting_value) {
                    $result->setStatus(true);
                } else {
                    $result->setStatus(false);
                }
            }
        }

        process_environment_result($setting, $result);

        $results[] = $result;
    }


    return $results;
}

function environment_custom_checks($version, $env_select) {
    global $CFG;

    $results = array();

    $release = isset($CFG->release) ? $CFG->release : $version; 
    $current_version = normalize_version($release);

    if (!$data = get_environment_for_version($version, $env_select)) {
        return $results;
    }

    if (!isset($data['#']['CUSTOM_CHECKS']['0']['#']['CUSTOM_CHECK'])) {
        return $results;
    }

    foreach($data['#']['CUSTOM_CHECKS']['0']['#']['CUSTOM_CHECK'] as $check) {
        $result = new environment_results('custom_check');

        $level = get_level($check);

        if (isset($check['@']['file']) && isset($check['@']['function'])) {
            $file = $CFG->dirroot . '/' . $check['@']['file'];
            $function = $check['@']['function'];
            if (is_readable($file)) {
                include_once($file);
                if (function_exists($function)) {
                    $result->setLevel($level);
                    $result->setInfo($function);
                    $result = $function($result);
                } else {
                    if (version_compare($current_version, $version, '>=')) {
                        $result->setStatus(false);
                        $result->setInfo($function);
                        $result->setErrorCode(CUSTOM_CHECK_FUNCTION_MISSING);
                    } else {
                        $result = null;
                    }
                }
            } else {
                if (version_compare($current_version, $version, '>=')) {
                    $result->setStatus(false);
                    $result->setInfo($function);
                    $result->setErrorCode(CUSTOM_CHECK_FILE_MISSING);
                } else {
                    $result = null;
                }
            }
        } else {
            $result->setStatus(false);
            $result->setErrorCode(NO_CUSTOM_CHECK_FOUND);
        }

        if (!is_null($result)) {
            process_environment_result($check, $result);

            $results[] = $result;
        }
    }

    return $results;
}

function environment_check_moodle($version, $env_select) {

    $result = new environment_results('moodle');

    if (!$data = get_environment_for_version($version, $env_select)) {
        $result->setStatus(false);
        $result->setErrorCode(NO_VERSION_DATA_FOUND);
        return $result;
    }

    if (!isset($data['@']['requires'])) {
        $needed_version = '1.0'; 
    } else {
        $needed_version = $data['@']['requires'];
    }

    $current_version = normalize_version(get_config('', 'release'));

    if (version_compare($current_version, $needed_version, '>=')) {
        $result->setStatus(true);
    } else {
        $result->setStatus(false);
    }
    $result->setLevel('required');
    $result->setCurrentVersion($current_version);
    $result->setNeededVersion($needed_version);

    return $result;
}

function environment_check_php($version, $env_select) {

    $result = new environment_results('php');

    if (!$data = get_environment_for_version($version, $env_select)) {
        $result->setStatus(false);
        $result->setErrorCode(NO_VERSION_DATA_FOUND);
        return $result;
    }

    if (!isset($data['#']['PHP'])) {
        $result->setStatus(false);
        $result->setErrorCode(NO_PHP_SECTION_FOUND);
        return $result;
    } else {
        $level = get_level($data['#']['PHP']['0']);
        if (!isset($data['#']['PHP']['0']['@']['version'])) {
            $result->setStatus(false);
            $result->setErrorCode(NO_PHP_VERSION_FOUND);
            return $result;
        } else {
            $needed_version = $data['#']['PHP']['0']['@']['version'];
        }
    }

    $current_version = normalize_version(phpversion());

    if (version_compare($current_version, $needed_version, '>=')) {
        $result->setStatus(true);
    } else {
        $result->setStatus(false);
    }
    $result->setLevel($level);
    $result->setCurrentVersion($current_version);
    $result->setNeededVersion($needed_version);

    process_environment_result($data['#']['PHP'][0], $result);

    return $result;
}


function environment_check_unicode($version, $env_select) {
    global $DB;

    $result = new environment_results('unicode');

    if (!$data = get_environment_for_version($version, $env_select)) {
        $result->setStatus(false);
        $result->setErrorCode(NO_VERSION_DATA_FOUND);
        return $result;
    }


    if (!isset($data['#']['UNICODE'])) {
        $result->setStatus(false);
        $result->setErrorCode(NO_UNICODE_SECTION_FOUND);
        return $result;
    } else {
        $level = get_level($data['#']['UNICODE']['0']);
    }

    if (!$unicodedb = $DB->setup_is_unicodedb()) {
        $result->setStatus(false);
    } else {
        $result->setStatus(true);
    }

    $result->setLevel($level);

    process_environment_result($data['#']['UNICODE'][0], $result);

    return $result;
}

function environment_check_database($version, $env_select) {

    global $DB;

    $result = new environment_results('database');

    $vendors = array();  //Array of vendors in version

    if (!$data = get_environment_for_version($version, $env_select)) {
        $result->setStatus(false);
        $result->setErrorCode(NO_VERSION_DATA_FOUND);
        return $result;
    }

    if (!isset($data['#']['DATABASE'])) {
        $result->setStatus(false);
        $result->setErrorCode(NO_DATABASE_SECTION_FOUND);
        return $result;
    } else {
        $level = get_level($data['#']['DATABASE']['0']);
    }

    if (!isset($data['#']['DATABASE']['0']['#']['VENDOR'])) {
        $result->setStatus(false);
        $result->setErrorCode(NO_DATABASE_VENDORS_FOUND);
        return $result;
    } else {
        foreach ($data['#']['DATABASE']['0']['#']['VENDOR'] as $vendor) {
            if (isset($vendor['@']['name']) && isset($vendor['@']['version'])) {
                $vendors[$vendor['@']['name']] = $vendor['@']['version'];
                $vendorsxml[$vendor['@']['name']] = $vendor;
            }
        }
    }
    if (empty($vendors['mysql'])) {
        $result->setStatus(false);
        $result->setErrorCode(NO_DATABASE_VENDOR_MYSQL_FOUND);
        return $result;
    }
    if (empty($vendors['postgres'])) {
        $result->setStatus(false);
        $result->setErrorCode(NO_DATABASE_VENDOR_POSTGRES_FOUND);
        return $result;
    }

    $current_vendor = $DB->get_dbfamily();

    $dbinfo = $DB->get_server_info();
    $current_version = normalize_version($dbinfo['version']);
    $needed_version = $vendors[$current_vendor];

    if (!$needed_version) {
        $result->setStatus(false);
        $result->setErrorCode(NO_DATABASE_VENDOR_VERSION_FOUND);
        return $result;
    }

    if (version_compare($current_version, $needed_version, '>=')) {
        $result->setStatus(true);
    } else {
        $result->setStatus(false);
    }
    $result->setLevel($level);
    $result->setCurrentVersion($current_version);
    $result->setNeededVersion($needed_version);
    $result->setInfo($current_vendor);

    process_environment_result($vendorsxml[$current_vendor], $result);

    return $result;

}

function process_environment_bypass($xml, &$result) {

    if ($result->getStatus() || $result->getLevel() == 'optional') {
        return;
    }

    if (is_array($xml['#']) && isset($xml['#']['BYPASS'][0]['@']['function']) && isset($xml['#']['BYPASS'][0]['@']['message'])) {
        $function = $xml['#']['BYPASS'][0]['@']['function'];
        $message  = $xml['#']['BYPASS'][0]['@']['message'];
        if (function_exists($function)) {
            if ($function($result)) {
                if (empty($result->getBypassStr)) {
                    $result->setBypassStr($message);
                }
            }
        }
    }
}

function process_environment_restrict($xml, &$result) {

    if (!$result->getStatus() || $result->getLevel() == 'optional') {
        return;
    }
    if (is_array($xml['#']) && isset($xml['#']['RESTRICT'][0]['@']['function']) && isset($xml['#']['RESTRICT'][0]['@']['message'])) {
        $function = $xml['#']['RESTRICT'][0]['@']['function'];
        $message  = $xml['#']['RESTRICT'][0]['@']['message'];
        if (function_exists($function)) {
            if ($function($result)) {
                if (empty($result->getRestrictStr)) {
                    $result->setRestrictStr($message);
                }
            }
        }
    }
}

function process_environment_messages($xml, &$result) {

    if (is_array($xml['#']) && isset($xml['#']['FEEDBACK'][0]['#'])) {
        $feedbackxml = $xml['#']['FEEDBACK'][0]['#'];

        if (!$result->status and $result->getLevel() == 'required') {
            if (isset($feedbackxml['ON_ERROR'][0]['@']['message'])) {
                $result->setFeedbackStr($feedbackxml['ON_ERROR'][0]['@']['message']);
            }
        } else if (!$result->status and $result->getLevel() == 'optional') {
            if (isset($feedbackxml['ON_CHECK'][0]['@']['message'])) {
                $result->setFeedbackStr($feedbackxml['ON_CHECK'][0]['@']['message']);
            }
        } else {
            if (isset($feedbackxml['ON_OK'][0]['@']['message'])) {
                $result->setFeedbackStr($feedbackxml['ON_OK'][0]['@']['message']);
            }
        }
    }
}


//--- Helper Class to return results to caller ---//


class environment_results {
    var $part;
    var $status;
    var $error_code;
    var $level;
    var $current_version;
    var $needed_version;
    var $info;
    var $feedback_str;
    var $bypass_str;
    var $restrict_str;

    function environment_results($part) {
        $this->part=$part;
        $this->status=false;
        $this->error_code=NO_ERROR;
        $this->level='required';
        $this->current_version='';
        $this->needed_version='';
        $this->info='';
        $this->feedback_str='';
        $this->bypass_str='';
        $this->restrict_str='';
    }

    function setStatus($status) {
        $this->status=$status;
        if ($status) {
            $this->setErrorCode(NO_ERROR);
        }
    }

    function setErrorCode($error_code) {
        $this->error_code=$error_code;
    }

    function setLevel($level) {
        $this->level=$level;
    }

    function setCurrentVersion($current_version) {
        $this->current_version=$current_version;
    }

    function setNeededVersion($needed_version) {
        $this->needed_version=$needed_version;
    }

    function setInfo($info) {
        $this->info=$info;
    }

    function setFeedbackStr($str) {
        $this->feedback_str=$str;
    }


    function setBypassStr($str) {
        $this->bypass_str=$str;
    }

    function setRestrictStr($str) {
        $this->restrict_str=$str;
    }

    function getStatus() {
        return $this->status;
    }

    function getErrorCode() {
        return $this->error_code;
    }

    function getLevel() {
        return $this->level;
    }

    function getCurrentVersion() {
        return $this->current_version;
    }

    function getNeededVersion() {
        return $this->needed_version;
    }

    function getInfo() {
        return $this->info;
    }

    function getPart() {
        return $this->part;
    }

    function getFeedbackStr() {
        return $this->feedback_str;
    }

    function getBypassStr() {
        return $this->bypass_str;
    }

    function getRestrictStr() {
        return $this->restrict_str;
    }

    function strToReport($string, $class){
        if (!empty($string)){
            if (is_array($string)){
                $str = call_user_func_array('get_string', $string);
            } else {
                $str = get_string($string, 'admin');
            }
            return '<p class="'.$class.'">'.$str.'</p>';
        } else {
            return '';
        }
    }
}


function bypass_mysql416_reqs ($result) {
    if (version_compare($result->getCurrentVersion(), '4.1.12', '>=')) {
        return true;
    }

    return false;
}


function restrict_php50_version($result) {
    if (version_compare($result->getCurrentVersion(), '5.0.0', '>=')
      and version_compare($result->getCurrentVersion(), '5.0.99', '<')) {
        return true;
    }
    return false;
}

function get_level($element) {
    $level = 'required';
    if (isset($element['@']['level'])) {
        $level = $element['@']['level'];
        if (!in_array($level, array('required', 'optional'))) {
            debugging('The level of a check in the environment.xml file must be "required" or "optional".', DEBUG_DEVELOPER);
            $level = 'required';
        }
    } else {
        debugging('Checks in the environment.xml file must have a level="required" or level="optional" attribute.', DEBUG_DEVELOPER);
    }
    return $level;
}

function process_environment_result($element, &$result) {
    process_environment_messages($element, $result);
    process_environment_bypass($element, $result);
    process_environment_restrict($element, $result);
}