lib/environmentlib.php

   1 <?php  //$Id$
   2
   3 ///////////////////////////////////////////////////////////////////////////
   4 //                                                                       //
   5 // NOTICE OF COPYRIGHT                                                   //
   6 //                                                                       //
   7 // Moodle - Modular Object-Oriented Dynamic Learning Environment         //
   8 //          http://moodle.com                                            //
   9 //                                                                       //
  10 // Copyright (C) 2001-3001 Martin Dougiamas        http://dougiamas.com  //
  11 //           (C) 2001-3001 Eloy Lafuente (stronk7) http://contiento.com  //
  12 //                                                                       //
  13 // This program is free software; you can redistribute it and/or modify  //
  14 // it under the terms of the GNU General Public License as published by  //
  15 // the Free Software Foundation; either version 2 of the License, or     //
  16 // (at your option) any later version.                                   //
  17 //                                                                       //
  18 // This program is distributed in the hope that it will be useful,       //
  19 // but WITHOUT ANY WARRANTY; without even the implied warranty of        //
  20 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         //
  21 // GNU General Public License for more details:                          //
  22 //                                                                       //
  23 //          http://www.gnu.org/copyleft/gpl.html                         //
  24 //                                                                       //
  25 ///////////////////////////////////////////////////////////////////////////
  26
  27 // This library includes all the necessary stuff to execute some standard
  28 // tests of required versions and libraries to run Moodle. It can be
  29 // used from the admin interface, and both at install and upgrade.
  30 //
  31 // All the info is stored in the admin/environment.xml file,
  32 // supporting to have an updated version in dataroot/environment
  33
  34 /// Add required files
  35     require_once($CFG->libdir.'/xmlize.php');
  36
  37 /// Define a buch of XML processing errors
  38     define('NO_ERROR',                           0);
  39     define('NO_VERSION_DATA_FOUND',              1);
  40     define('NO_DATABASE_SECTION_FOUND',          2);
  41     define('NO_DATABASE_VENDORS_FOUND',          3);
  42     define('NO_DATABASE_VENDOR_MYSQL_FOUND',     4);
  43     define('NO_DATABASE_VENDOR_POSTGRES_FOUND',  5);
  44     define('NO_PHP_SECTION_FOUND',               6);
  45     define('NO_PHP_VERSION_FOUND',               7);
  46     define('NO_PHP_EXTENSIONS_SECTION_FOUND',    8);
  47     define('NO_PHP_EXTENSIONS_NAME_FOUND',       9);
  48     define('NO_DATABASE_VENDOR_VERSION_FOUND',  10);
  49     define('NO_UNICODE_SECTION_FOUND',          11);
  50     define('NO_CUSTOM_CHECK_FOUND',             12);
  51     define('CUSTOM_CHECK_FILE_MISSING',         13);
  52     define('CUSTOM_CHECK_FUNCTION_MISSING',     14);
  53
  54 /**
  55  * This function will perform the whole check, returning
  56  * true or false as final result. Also, he full array of
  57  * environment_result will be returned in the parameter list.
  58  * The function looks for the best version to compare and
  59  * everything. This is the only function that should be called
  60  * ever from the rest of Moodle.
  61  * @param string version version to check.
  62  * @param array results array of results checked.
  63  * @param boolean true/false, whether to print the table or just return results array
  64  * @return boolean true/false, depending of results
  65  */
  66 function check_moodle_environment($version, &$environment_results, $print_table=true) {
  67
  68     $status = true;
  69
  70 /// This are cached per request
  71     static $result = true;
  72     static $env_results;
  73     static $cache_exists = false;
  74
  75 /// if we have results cached, use them
  76     if ($cache_exists) {
  77         $environment_results = $env_results;
  78 /// No cache exists, calculate everything
  79     } else {
  80     /// Get the more recent version before the requested
  81         if (!$version = get_latest_version_available($version)) {
  82             $status = false;
  83         }
  84
  85     /// Perform all the checks
  86         if (!($environment_results = environment_check($version)) && $status) {
  87             $status = false;
  88         }
  89
  90     /// Iterate over all the results looking for some error in required items
  91     /// or some error_code
  92         if ($status) {
  93             foreach ($environment_results as $environment_result) {
  94                 if (!$environment_result->getStatus() && $environment_result->getLevel() == 'required'
  95                   && !$environment_result->getBypassStr()) {
  96                     $result = false; // required item that is not bypased
  97                 } else if ($environment_result->getStatus() && $environment_result->getLevel() == 'required'
  98                   && $environment_result->getRestrictStr()) {
  99                     $result = false; // required item that is restricted
 100                 } else if ($environment_result->getErrorCode()) {
 101                     $result = false;
 102                 }
 103             }
 104         }
 105     /// Going to end, we store environment_results to cache
 106         $env_results = $environment_results;
 107         $cache_exists = true;
 108     } ///End of cache block
 109
 110 /// If we have decided to print all the information, just do it
 111     if ($print_table) {
 112         print_moodle_environment($result && $status, $environment_results);
 113     }
 114
 115     return ($result && $status);
 116 }
 117
 118 /**
 119  * This function will print one beautiful table with all the environmental
 120  * configuration and how it suits Moodle needs.
 121  * @param boolean final result of the check (true/false)
 122  * @param array environment_results array of results gathered
 123  */
 124 function print_moodle_environment($result, $environment_results) {
 125 /// Get some strings
 126     $strname = get_string('name');
 127     $strinfo = get_string('info');
 128     $strreport = get_string('report');
 129     $strstatus = get_string('status');
 130     $strok = get_string('ok');
 131     $strerror = get_string('error');
 132     $strcheck = get_string('check');
 133     $strbypassed = get_string('bypassed');
 134     $strrestricted = get_string('restricted');
 135     $strenvironmenterrortodo = get_string('environmenterrortodo', 'admin');
 136 /// Table headers
 137     $servertable = new stdClass;//table for server checks
 138     $servertable->head  = array ($strname, $strinfo, $strreport, $strstatus);
 139     $servertable->align = array ('center', 'center', 'left', 'center');
 140     $servertable->wrap  = array ('nowrap', '', '', 'nowrap');
 141     $servertable->size  = array ('10', 10, '100%', '10');
 142     $servertable->width = '90%';
 143     $servertable->class = 'environmenttable generaltable';
 144
 145     $serverdata = array('ok'=>array(), 'warn'=>array(), 'error'=>array());
 146
 147     $othertable = new stdClass;//table for custom checks
 148     $othertable->head  = array ($strinfo, $strreport, $strstatus);
 149     $othertable->align = array ('center', 'left', 'center');
 150     $othertable->wrap  = array ('', '', 'nowrap');
 151     $othertable->size  = array (10, '100%', '10');
 152     $othertable->width = '90%';
 153     $othertable->class = 'environmenttable generaltable';
 154
 155     $otherdata = array('ok'=>array(), 'warn'=>array(), 'error'=>array());
 156
 157 /// Iterate over each environment_result
 158     $continue = true;
 159     foreach ($environment_results as $environment_result) {
 160         $errorline   = false;
 161         $warningline = false;
 162         if ($continue) {
 163             $type = $environment_result->getPart();
 164             $info = $environment_result->getInfo();
 165             $status = $environment_result->getStatus();
 166             $error_code = $environment_result->getErrorCode();
 167         /// Process Report field
 168             $rec = new stdClass();
 169         /// Something has gone wrong at parsing time
 170             if ($error_code) {
 171                 $stringtouse = 'environmentxmlerror';
 172                 $rec->error_code = $error_code;
 173                 $status = $strerror;
 174                 $errorline = true;
 175                 $continue = false;
 176             }
 177
 178             if ($continue) {
 179             /// We are comparing versions
 180                 if ($rec->needed = $environment_result->getNeededVersion()) {
 181                     $rec->current = $environment_result->getCurrentVersion();
 182                     if ($environment_result->getLevel() == 'required') {
 183                         $stringtouse = 'environmentrequireversion';
 184                     } else {
 185                         $stringtouse = 'environmentrecommendversion';
 186                     }
 187             /// We are checking installed & enabled things
 188                 } else if ($environment_result->getPart() == 'custom_check') {
 189                     if ($environment_result->getLevel() == 'required') {
 190                         $stringtouse = 'environmentrequirecustomcheck';
 191                     } else {
 192                         $stringtouse = 'environmentrecommendcustomcheck';
 193                     }
 194                 } else {
 195                     if ($environment_result->getLevel() == 'required') {
 196                         $stringtouse = 'environmentrequireinstall';
 197                     } else {
 198                         $stringtouse = 'environmentrecommendinstall';
 199                     }
 200                 }
 201             /// Calculate the status value
 202                 if ($environment_result->getBypassStr() != '') {            //Handle bypassed result (warning)
 203                     $status = $strbypassed;
 204                     $warningline = true;
 205                 } else if ($environment_result->getRestrictStr() != '') {   //Handle restricted result (error)
 206                     $status = $strrestricted;
 207                     $errorline = true;
 208                 } else {
 209                     if ($status) {                                          //Handle ok result (ok)
 210                         $status = $strok;
 211                     } else {
 212                         if ($environment_result->getLevel() == 'optional') {//Handle check result (warning)
 213                             $status = $strcheck;
 214                             $warningline = true;
 215                         } else {                                            //Handle error result (error)
 216                             $status = $strcheck;
 217                             $errorline = true;
 218                         }
 219                     }
 220                 }
 221             }
 222
 223         /// Build the text
 224             $linkparts = array();
 225             $linkparts[] = 'admin/environment';
 226             $linkparts[] = $type;
 227             if (!empty($info)){
 228                $linkparts[] = $info;
 229             }
 230             $report = doc_link(join($linkparts, '/'), get_string($stringtouse, 'admin', $rec));
 231
 232
 233         /// Format error or warning line
 234             if ($errorline || $warningline) {
 235                 $messagetype = $errorline? 'error':'warn';
 236             } else {
 237                 $messagetype = 'ok';
 238             }
 239             $status = '<span class="'.$messagetype.'">'.$status.'</span>';
 240         /// Here we'll store all the feedback found
 241             $feedbacktext = '';
 242             ///Append  the feedback if there is some
 243             $feedbacktext .= $environment_result->strToReport($environment_result->getFeedbackStr(), $messagetype);
 244         ///Append the bypass if there is some
 245             $feedbacktext .= $environment_result->strToReport($environment_result->getBypassStr(), 'warn');
 246         ///Append the restrict if there is some
 247             $feedbacktext .= $environment_result->strToReport($environment_result->getRestrictStr(), 'error');
 248
 249             $report .= $feedbacktext;
 250         /// Add the row to the table
 251
 252             if ($environment_result->getPart() == 'custom_check'){
 253                 $otherdata[$messagetype][] = array ($info, $report, $status);
 254             } else {
 255                 $serverdata[$messagetype][] = array ($type, $info, $report, $status);
 256             }
 257         }
 258     }
 259     //put errors first in
 260     $servertable->data = array_merge($serverdata['error'], $serverdata['warn'], $serverdata['ok']);
 261     $othertable->data = array_merge($otherdata['error'], $otherdata['warn'], $otherdata['ok']);
 262
 263 /// Print table
 264     print_heading(get_string('serverchecks', 'admin'));
 265     print_table($servertable);
 266     if (count($othertable->data)){
 267         print_heading(get_string('customcheck', 'admin'));
 268         print_table($othertable);
 269     }
 270
 271 /// Finally, if any error has happened, print the summary box
 272     if (!$result) {
 273         print_simple_box($strenvironmenterrortodo, 'center', '', '', '', 'environmentbox errorbox');
 274     }
 275 }
 276
 277
 278 /**
 279  * This function will normalize any version to just a serie of numbers
 280  * separated by dots. Everything else will be removed.
 281  * @param string $version the original version
 282  * @return string the normalized version
 283  */
 284 function normalize_version($version) {
 285 /// Replace everything but numbers and dots by dots
 286     $version = preg_replace('/[^\.\d]/', '.', $version);
 287 /// Combine multiple dots in one
 288     $version = preg_replace('/(\.{2,})/', '.', $version);
 289 /// Trim possible leading and trailing dots
 290     $version = trim($version, '.');
 291
 292     return $version;
 293 }
 294
 295
 296 /**
 297  * This function will load the environment.xml file and xmlize it
 298  * @return mixed the xmlized structure or false on error
 299  */
 300 function load_environment_xml() {
 301
 302     global $CFG;
 303
 304     static $data; //Only load and xmlize once by request
 305
 306     if (!empty($data)) {
 307         return $data;
 308     }
 309
 310 /// First of all, take a look inside $CFG->dataroot/environment/environment.xml
 311     $file = $CFG->dataroot.'/environment/environment.xml';
 312     $internalfile = $CFG->dirroot.'/'.$CFG->admin.'/environment.xml';
 313     if (!is_file($file) || !is_readable($file) || filemtime($file) < filemtime($internalfile) ||
 314         !$contents = file_get_contents($file)) {
 315     /// Fallback to fixed $CFG->admin/environment.xml
 316         if (!is_file($internalfile) || !is_readable($internalfile) || !$contents = file_get_contents($internalfile)) {
 317             return false;
 318         }
 319     }
 320 /// XML the whole file
 321     $data = xmlize($contents);
 322
 323     return $data;
 324 }
 325
 326
 327 /**
 328  * This function will return the list of Moodle versions available
 329  * @return mixed array of versions. False on error.
 330  */
 331 function get_list_of_environment_versions ($contents) {
 332
 333     static $versions = array();
 334
 335     if (!empty($versions)) {
 336         return $versions;
 337     }
 338
 339     if (isset($contents['COMPATIBILITY_MATRIX']['#']['MOODLE'])) {
 340         foreach ($contents['COMPATIBILITY_MATRIX']['#']['MOODLE'] as $version) {
 341             $versions[] = $version['@']['version'];
 342         }
 343     }
 344
 345     return $versions;
 346 }
 347
 348
 349 /**
 350  * This function will return the most recent version in the environment.xml
 351  * file previous or equal to the version requested
 352  * @param string version top version from which we start to look backwards
 353  * @return string more recent version or false if not found
 354  */
 355 function get_latest_version_available ($version) {
 356
 357 /// Normalize the version requested
 358     $version = normalize_version($version);
 359
 360 /// Load xml file
 361     if (!$contents = load_environment_xml()) {
 362         return false;
 363     }
 364
 365 /// Detect available versions
 366     if (!$versions = get_list_of_environment_versions($contents)) {
 367         return false;
 368     }
 369 /// First we look for exact version
 370     if (in_array($version, $versions)) {
 371         return $version;
 372     } else {
 373         $found_version = false;
 374     /// Not exact match, so we are going to iterate over the list searching
 375     /// for the latest version before the requested one
 376         foreach ($versions as $arrversion) {
 377             if (version_compare($arrversion, $version, '<')) {
 378                 $found_version = $arrversion;
 379             }
 380         }
 381     }
 382
 383     return $found_version;
 384 }
 385
 386
 387 /**
 388  * This function will return the xmlized data belonging to one Moodle version
 389  * @return mixed the xmlized structure or false on error
 390  */
 391 function get_environment_for_version($version) {
 392
 393 /// Normalize the version requested
 394     $version = normalize_version($version);
 395
 396 /// Load xml file
 397     if (!$contents = load_environment_xml()) {
 398         return false;
 399     }
 400
 401 /// Detect available versions
 402     if (!$versions = get_list_of_environment_versions($contents)) {
 403         return false;
 404     }
 405
 406 /// If the version requested is available
 407     if (!in_array($version, $versions)) {
 408         return false;
 409     }
 410
 411 /// We now we have it. Extract from full contents.
 412     $fl_arr = array_flip($versions);
 413
 414     return $contents['COMPATIBILITY_MATRIX']['#']['MOODLE'][$fl_arr[$version]];
 415 }
 416
 417
 418 /**
 419  * This function will check for everything (DB, PHP and PHP extensions for now)
 420  * returning an array of environment_result objects.
 421  * @param string $version xml version we are going to use to test this server
 422  * @return array array of results encapsulated in one environment_result object
 423  */
 424 function environment_check($version) {
 425
 426     global $CFG;
 427
 428 /// Normalize the version requested
 429     $version = normalize_version($version);
 430
 431     $results = array(); //To store all the results
 432
 433 /// Only run the moodle versions checker on upgrade, not on install
 434     if (empty($CFG->running_installer)) {
 435         $results[] = environment_check_moodle($version);
 436     }
 437     $results[] = environment_check_unicode($version);
 438     $results[] = environment_check_database($version);
 439     $results[] = environment_check_php($version);
 440
 441     $phpext_results = environment_check_php_extensions($version);
 442     $results = array_merge($results, $phpext_results);
 443
 444     $custom_results = environment_custom_checks($version);
 445     $results = array_merge($results, $custom_results);
 446
 447     return $results;
 448 }
 449
 450
 451 /**
 452  * This function will check if php extensions requirements are satisfied
 453  * @param string $version xml version we are going to use to test this server
 454  * @return array array of results encapsulated in one environment_result object
 455  */
 456 function environment_check_php_extensions($version) {
 457
 458     $results = array();
 459
 460 /// Get the enviroment version we need
 461     if (!$data = get_environment_for_version($version)) {
 462     /// Error. No version data found
 463         $result = new environment_results('php_extension');
 464         $result->setStatus(false);
 465         $result->setErrorCode(NO_VERSION_DATA_FOUND);
 466         return $result;
 467     }
 468
 469 /// Extract the php_extension part
 470     if (!isset($data['#']['PHP_EXTENSIONS']['0']['#']['PHP_EXTENSION'])) {
 471     /// Error. No PHP section found
 472         $result = new environment_results('php_extension');
 473         $result->setStatus(false);
 474         $result->setErrorCode(NO_PHP_EXTENSIONS_SECTION_FOUND);
 475         return $result;
 476     }
 477 /// Iterate over extensions checking them and creating the needed environment_results
 478     foreach($data['#']['PHP_EXTENSIONS']['0']['#']['PHP_EXTENSION'] as $extension) {
 479         $result = new environment_results('php_extension');
 480     /// Check for level
 481         $level = get_level($extension);
 482     /// Check for extension name
 483         if (!isset($extension['@']['name'])) {
 484             $result->setStatus(false);
 485             $result->setErrorCode(NO_PHP_EXTENSIONS_NAME_FOUND);
 486         } else {
 487             $extension_name = $extension['@']['name'];
 488         /// The name exists. Just check if it's an installed extension
 489             if (!extension_loaded($extension_name)) {
 490                 $result->setStatus(false);
 491             } else {
 492                 $result->setStatus(true);
 493             }
 494             $result->setLevel($level);
 495             $result->setInfo($extension_name);
 496         }
 497
 498     /// Do any actions defined in the XML file.
 499         process_environment_result($extension, $result);
 500
 501     /// Add the result to the array of results
 502         $results[] = $result;
 503     }
 504
 505
 506     return $results;
 507 }
 508
 509 /**
 510  * This function will do the custom checks.
 511  * @param string $version xml version we are going to use to test this server.
 512  * @return array array of results encapsulated in environment_result objects.
 513  */
 514 function environment_custom_checks($version) {
 515     global $CFG;
 516
 517     $results = array();
 518
 519 /// Get the enviroment version we need
 520     if (!$data = get_environment_for_version($version)) {
 521     /// Error. No version data found - but this will already have been reported.
 522         return $results;
 523     }
 524
 525 /// Extract the CUSTOM_CHECKS part
 526     if (!isset($data['#']['CUSTOM_CHECKS']['0']['#']['CUSTOM_CHECK'])) {
 527     /// No custom checks found - not a problem
 528         return $results;
 529     }
 530
 531 /// Iterate over extensions checking them and creating the needed environment_results
 532     foreach($data['#']['CUSTOM_CHECKS']['0']['#']['CUSTOM_CHECK'] as $check) {
 533         $result = new environment_results('custom_check');
 534
 535     /// Check for level
 536         $level = get_level($check);
 537
 538     /// Check for extension name
 539         if (isset($check['@']['file']) && isset($check['@']['function'])) {
 540             $file = $CFG->dirroot . '/' . $check['@']['file'];
 541             $function = $check['@']['function'];
 542             if (is_readable($file)) {
 543                 include_once($file);
 544                 if (function_exists($function)) {
 545                     $result->setLevel($level);
 546                     $result->setInfo($function);
 547                     $result = $function($result);
 548                 } else {
 549                     $result->setStatus(false);
 550                     $result->setErrorCode(CUSTOM_CHECK_FUNCTION_MISSING);
 551                 }
 552             } else {
 553                 $result->setStatus(false);
 554                 $result->setErrorCode(CUSTOM_CHECK_FILE_MISSING);
 555             }
 556         } else {
 557             $result->setStatus(false);
 558             $result->setErrorCode(NO_CUSTOM_CHECK_FOUND);
 559         }
 560
 561         if (!is_null($result)) {
 562         /// Do any actions defined in the XML file.
 563             process_environment_result($check, $result);
 564
 565         /// Add the result to the array of results
 566             $results[] = $result;
 567         }
 568     }
 569
 570     return $results;
 571 }
 572
 573 /**
 574  * This function will check if Moodle requirements are satisfied
 575  * @param string $version xml version we are going to use to test this server
 576  * @return object results encapsulated in one environment_result object
 577  */
 578 function environment_check_moodle($version) {
 579
 580     $result = new environment_results('moodle');
 581
 582 /// Get the enviroment version we need
 583     if (!$data = get_environment_for_version($version)) {
 584     /// Error. No version data found
 585         $result->setStatus(false);
 586         $result->setErrorCode(NO_VERSION_DATA_FOUND);
 587         return $result;
 588     }
 589
 590 /// Extract the moodle part
 591     if (!isset($data['@']['requires'])) {
 592         $needed_version = '1.0'; /// Default to 1.0 if no moodle requires is found
 593     } else {
 594     /// Extract required moodle version
 595         $needed_version = $data['@']['requires'];
 596     }
 597
 598 /// Now search the version we are using
 599     $current_version = normalize_version(get_config('', 'release'));
 600
 601 /// And finally compare them, saving results
 602     if (version_compare($current_version, $needed_version, '>=')) {
 603         $result->setStatus(true);
 604     } else {
 605         $result->setStatus(false);
 606     }
 607     $result->setLevel('required');
 608     $result->setCurrentVersion($current_version);
 609     $result->setNeededVersion($needed_version);
 610
 611     return $result;
 612 }
 613
 614 /**
 615  * This function will check if php requirements are satisfied
 616  * @param string $version xml version we are going to use to test this server
 617  * @return object results encapsulated in one environment_result object
 618  */
 619 function environment_check_php($version) {
 620
 621     $result = new environment_results('php');
 622
 623 /// Get the enviroment version we need
 624     if (!$data = get_environment_for_version($version)) {
 625     /// Error. No version data found
 626         $result->setStatus(false);
 627         $result->setErrorCode(NO_VERSION_DATA_FOUND);
 628         return $result;
 629     }
 630
 631 /// Extract the php part
 632     if (!isset($data['#']['PHP'])) {
 633     /// Error. No PHP section found
 634         $result->setStatus(false);
 635         $result->setErrorCode(NO_PHP_SECTION_FOUND);
 636         return $result;
 637     } else {
 638     /// Extract level and version
 639         $level = get_level($data['#']['PHP']['0']);
 640         if (!isset($data['#']['PHP']['0']['@']['version'])) {
 641             $result->setStatus(false);
 642             $result->setErrorCode(NO_PHP_VERSION_FOUND);
 643             return $result;
 644         } else {
 645             $needed_version = $data['#']['PHP']['0']['@']['version'];
 646         }
 647     }
 648
 649 /// Now search the version we are using
 650     $current_version = normalize_version(phpversion());
 651
 652 /// And finally compare them, saving results
 653     if (version_compare($current_version, $needed_version, '>=')) {
 654         $result->setStatus(true);
 655     } else {
 656         $result->setStatus(false);
 657     }
 658     $result->setLevel($level);
 659     $result->setCurrentVersion($current_version);
 660     $result->setNeededVersion($needed_version);
 661
 662 /// Do any actions defined in the XML file.
 663     process_environment_result($data['#']['PHP'][0], $result);
 664
 665     return $result;
 666 }
 667
 668
 669 /**
 670  * This function will check if unicode database requirements are satisfied
 671  * @param string $version xml version we are going to use to test this server
 672  * @return object results encapsulated in one environment_result object
 673  */
 674 function environment_check_unicode($version) {
 675     global $db;
 676
 677     $result = new environment_results('unicode');
 678
 679     /// Get the enviroment version we need
 680     if (!$data = get_environment_for_version($version)) {
 681     /// Error. No version data found
 682         $result->setStatus(false);
 683         $result->setErrorCode(NO_VERSION_DATA_FOUND);
 684         return $result;
 685     }
 686
 687     /// Extract the unicode part
 688
 689     if (!isset($data['#']['UNICODE'])) {
 690     /// Error. No UNICODE section found
 691         $result->setStatus(false);
 692         $result->setErrorCode(NO_UNICODE_SECTION_FOUND);
 693         return $result;
 694     } else {
 695     /// Extract level
 696         $level = get_level($data['#']['UNICODE']['0']);
 697     }
 698
 699     if (!$unicodedb = setup_is_unicodedb()) {
 700         $result->setStatus(false);
 701     } else {
 702         $result->setStatus(true);
 703     }
 704
 705     $result->setLevel($level);
 706
 707 /// Do any actions defined in the XML file.
 708     process_environment_result($data['#']['UNICODE'][0], $result);
 709
 710     return $result;
 711 }
 712
 713 /**
 714  * This function will check if database requirements are satisfied
 715  * @param string $version xml version we are going to use to test this server
 716  * @return object results encapsulated in one environment_result object
 717  */
 718 function environment_check_database($version) {
 719
 720     global $db;
 721
 722     $result = new environment_results('database');
 723
 724     $vendors = array();  //Array of vendors in version
 725
 726 /// Get the enviroment version we need
 727     if (!$data = get_environment_for_version($version)) {
 728     /// Error. No version data found
 729         $result->setStatus(false);
 730         $result->setErrorCode(NO_VERSION_DATA_FOUND);
 731         return $result;
 732     }
 733
 734 /// Extract the database part
 735     if (!isset($data['#']['DATABASE'])) {
 736     /// Error. No DATABASE section found
 737         $result->setStatus(false);
 738         $result->setErrorCode(NO_DATABASE_SECTION_FOUND);
 739         return $result;
 740     } else {
 741     /// Extract level
 742         $level = get_level($data['#']['DATABASE']['0']);
 743     }
 744
 745 /// Extract DB vendors. At least 2 are mandatory (mysql & postgres)
 746     if (!isset($data['#']['DATABASE']['0']['#']['VENDOR'])) {
 747     /// Error. No VENDORS found
 748         $result->setStatus(false);
 749         $result->setErrorCode(NO_DATABASE_VENDORS_FOUND);
 750         return $result;
 751     } else {
 752     /// Extract vendors
 753         foreach ($data['#']['DATABASE']['0']['#']['VENDOR'] as $vendor) {
 754             if (isset($vendor['@']['name']) && isset($vendor['@']['version'])) {
 755                 $vendors[$vendor['@']['name']] = $vendor['@']['version'];
 756                 $vendorsxml[$vendor['@']['name']] = $vendor;
 757             }
 758         }
 759     }
 760 /// Check we have the mysql vendor version
 761     if (empty($vendors['mysql'])) {
 762         $result->setStatus(false);
 763         $result->setErrorCode(NO_DATABASE_VENDOR_MYSQL_FOUND);
 764         return $result;
 765     }
 766 /// Check we have the postgres vendor version
 767     if (empty($vendors['postgres'])) {
 768         $result->setStatus(false);
 769         $result->setErrorCode(NO_DATABASE_VENDOR_POSTGRES_FOUND);
 770         return $result;
 771     }
 772
 773 /// Now search the version we are using (depending of vendor)
 774     $current_vendor = set_dbfamily();
 775
 776     $dbinfo = $db->ServerInfo();
 777     $current_version = normalize_version($dbinfo['version']);
 778     $needed_version = $vendors[$current_vendor];
 779
 780 /// Check we have a needed version
 781     if (!$needed_version) {
 782         $result->setStatus(false);
 783         $result->setErrorCode(NO_DATABASE_VENDOR_VERSION_FOUND);
 784         return $result;
 785     }
 786
 787 /// And finally compare them, saving results
 788     if (version_compare($current_version, $needed_version, '>=')) {
 789         $result->setStatus(true);
 790     } else {
 791         $result->setStatus(false);
 792     }
 793     $result->setLevel($level);
 794     $result->setCurrentVersion($current_version);
 795     $result->setNeededVersion($needed_version);
 796     $result->setInfo($current_vendor);
 797
 798 /// Do any actions defined in the XML file.
 799     process_environment_result($vendorsxml[$current_vendor], $result);
 800
 801     return $result;
 802
 803 }
 804
 805 /**
 806  * This function will post-process the result record by executing the specified
 807  * function, modifying it as necessary, also a custom message will be added
 808  * to the result object to be printed by the display layer.
 809  * Every bypass function must be defined in this file and it'll return
 810  * true/false to decide if the original test is bypassed or no. Also
 811  * such bypass functions are able to directly handling the result object
 812  * although it should be only under exceptional conditions.
 813  *
 814  * @param string xmldata containing the bypass data
 815  * @param object result object to be updated
 816  */
 817 function process_environment_bypass($xml, &$result) {
 818
 819 /// Only try to bypass if we were in error and it was required
 820     if ($result->getStatus() || $result->getLevel() == 'optional') {
 821         return;
 822     }
 823
 824 /// It there is bypass info (function and message)
 825     if (is_array($xml['#']) && isset($xml['#']['BYPASS'][0]['@']['function']) && isset($xml['#']['BYPASS'][0]['@']['message'])) {
 826         $function = $xml['#']['BYPASS'][0]['@']['function'];
 827         $message  = $xml['#']['BYPASS'][0]['@']['message'];
 828     /// Look for the function
 829         if (function_exists($function)) {
 830         /// Call it, and if bypass = true is returned, apply meesage
 831             if ($function($result)) {
 832             /// We only set the bypass message if the function itself hasn't defined it before
 833                 if (empty($result->getBypassStr)) {
 834                     $result->setBypassStr($message);
 835                 }
 836             }
 837         }
 838     }
 839 }
 840
 841 /**
 842  * This function will post-process the result record by executing the specified
 843  * function, modifying it as necessary, also a custom message will be added
 844  * to the result object to be printed by the display layer.
 845  * Every restrict function must be defined in this file and it'll return
 846  * true/false to decide if the original test is restricted or no. Also
 847  * such restrict functions are able to directly handling the result object
 848  * although it should be only under exceptional conditions.
 849  *
 850  * @param string xmldata containing the restrict data
 851  * @param object result object to be updated
 852  */
 853 function process_environment_restrict($xml, &$result) {
 854
 855 /// Only try to restrict if we were not in error and it was required
 856     if (!$result->getStatus() || $result->getLevel() == 'optional') {
 857         return;
 858     }
 859 /// It there is restrict info (function and message)
 860     if (is_array($xml['#']) && isset($xml['#']['RESTRICT'][0]['@']['function']) && isset($xml['#']['RESTRICT'][0]['@']['message'])) {
 861         $function = $xml['#']['RESTRICT'][0]['@']['function'];
 862         $message  = $xml['#']['RESTRICT'][0]['@']['message'];
 863     /// Look for the function
 864         if (function_exists($function)) {
 865         /// Call it, and if restrict = true is returned, apply meesage
 866             if ($function($result)) {
 867             /// We only set the restrict message if the function itself hasn't defined it before
 868                 if (empty($result->getRestrictStr)) {
 869                     $result->setRestrictStr($message);
 870                 }
 871             }
 872         }
 873     }
 874 }
 875
 876 /**
 877  * This function will detect if there is some message available to be added to the
 878  * result in order to clarify enviromental details.
 879  * @param string xmldata containing the feedback data
 880  * @param object reult object to be updated
 881  */
 882 function process_environment_messages($xml, &$result) {
 883
 884 /// If there is feedback info
 885     if (is_array($xml['#']) && isset($xml['#']['FEEDBACK'][0]['#'])) {
 886         $feedbackxml = $xml['#']['FEEDBACK'][0]['#'];
 887
 888         if (!$result->status and $result->getLevel() == 'required') {
 889             if (isset($feedbackxml['ON_ERROR'][0]['@']['message'])) {
 890                 $result->setFeedbackStr($feedbackxml['ON_ERROR'][0]['@']['message']);
 891             }
 892         } else if (!$result->status and $result->getLevel() == 'optional') {
 893             if (isset($feedbackxml['ON_CHECK'][0]['@']['message'])) {
 894                 $result->setFeedbackStr($feedbackxml['ON_CHECK'][0]['@']['message']);
 895             }
 896         } else {
 897             if (isset($feedbackxml['ON_OK'][0]['@']['message'])) {
 898                 $result->setFeedbackStr($feedbackxml['ON_OK'][0]['@']['message']);
 899             }
 900         }
 901     }
 902 }
 903
 904
 905 //--- Helper Class to return results to caller ---//
 906
 907
 908 /**
 909  * This class is used to return the results of the environment
 910  * main functions (environment_check_xxxx)
 911  */
 912 class environment_results {
 913
 914     var $part;            //which are we checking (database, php, php_extension)
 915     var $status;          //true/false
 916     var $error_code;      //integer. See constants at the beginning of the file
 917     var $level;           //required/optional
 918     var $current_version; //current version detected
 919     var $needed_version;  //version needed
 920     var $info;            //Aux. info (DB vendor, library...)
 921     var $feedback_str;    //String to show on error|on check|on ok
 922     var $bypass_str;      //String to show if some bypass has happened
 923     var $restrict_str;    //String to show if some restrict has happened
 924
 925     /**
 926      * Constructor of the environment_result class. Just set default values
 927      */
 928     function environment_results($part) {
 929         $this->part=$part;
 930         $this->status=false;
 931         $this->error_code=NO_ERROR;
 932         $this->level='required';
 933         $this->current_version='';
 934         $this->needed_version='';
 935         $this->info='';
 936         $this->feedback_str='';
 937         $this->bypass_str='';
 938         $this->restrict_str='';
 939     }
 940
 941     /**
 942      * Set the status
 943      * @param boolean the status (true/false)
 944      */
 945     function setStatus($status) {
 946         $this->status=$status;
 947         if ($status) {
 948             $this->setErrorCode(NO_ERROR);
 949         }
 950     }
 951
 952     /**
 953      * Set the error_code
 954      * @param integer the error code (see constants above)
 955      */
 956     function setErrorCode($error_code) {
 957         $this->error_code=$error_code;
 958     }
 959
 960     /**
 961      * Set the level
 962      * @param string the level (required, optional)
 963      */
 964     function setLevel($level) {
 965         $this->level=$level;
 966     }
 967
 968     /**
 969      * Set the current version
 970      * @param string the current version
 971      */
 972     function setCurrentVersion($current_version) {
 973         $this->current_version=$current_version;
 974     }
 975
 976     /**
 977      * Set the needed version
 978      * @param string the needed version
 979      */
 980     function setNeededVersion($needed_version) {
 981         $this->needed_version=$needed_version;
 982     }
 983
 984     /**
 985      * Set the auxiliary info
 986      * @param string the auxiliary info
 987      */
 988     function setInfo($info) {
 989         $this->info=$info;
 990     }
 991
 992     /**
 993      * Set the feedback string
 994      * @param mixed the feedback string that will be fetched from the admin lang file.
 995      *                  pass just the string or pass an array of params for get_string
 996      *                  You always should put your string in admin.php but a third param is useful
 997      *                  to pass an $a object / string to get_string
 998      */
 999     function setFeedbackStr($str) {
1000         $this->feedback_str=$str;
1001     }
1002
1003
1004     /**
1005      * Set the bypass string
1006      * @param string the bypass string that will be fetched from the admin lang file.
1007      *                  pass just the string or pass an array of params for get_string
1008      *                  You always should put your string in admin.php but a third param is useful
1009      *                  to pass an $a object / string to get_string
1010      */
1011     function setBypassStr($str) {
1012         $this->bypass_str=$str;
1013     }
1014
1015     /**
1016      * Set the restrict string
1017      * @param string the restrict string that will be fetched from the admin lang file.
1018      *                  pass just the string or pass an array of params for get_string
1019      *                  You always should put your string in admin.php but a third param is useful
1020      *                  to pass an $a object / string to get_string
1021      */
1022     function setRestrictStr($str) {
1023         $this->restrict_str=$str;
1024     }
1025
1026     /**
1027      * Get the status
1028      * @return boolean result
1029      */
1030     function getStatus() {
1031         return $this->status;
1032     }
1033
1034     /**
1035      * Get the error code
1036      * @return integer error code
1037      */
1038     function getErrorCode() {
1039         return $this->error_code;
1040     }
1041
1042     /**
1043      * Get the level
1044      * @return string level
1045      */
1046     function getLevel() {
1047         return $this->level;
1048     }
1049
1050     /**
1051      * Get the current version
1052      * @return string current version
1053      */
1054     function getCurrentVersion() {
1055         return $this->current_version;
1056     }
1057
1058     /**
1059      * Get the needed version
1060      * @return string needed version
1061      */
1062     function getNeededVersion() {
1063         return $this->needed_version;
1064     }
1065
1066     /**
1067      * Get the aux info
1068      * @return string info
1069      */
1070     function getInfo() {
1071         return $this->info;
1072     }
1073
1074     /**
1075      * Get the part this result belongs to
1076      * @return string part
1077      */
1078     function getPart() {
1079         return $this->part;
1080     }
1081
1082     /**
1083      * Get the feedback string
1084      * @return mixed feedback string (can be an array of params for get_string or a single string to fetch from
1085      *                  admin.php lang file).
1086      */
1087     function getFeedbackStr() {
1088         return $this->feedback_str;
1089     }
1090
1091     /**
1092      * Get the bypass string
1093      * @return mixed bypass string (can be an array of params for get_string or a single string to fetch from
1094      *                  admin.php lang file).
1095      */
1096     function getBypassStr() {
1097         return $this->bypass_str;
1098     }
1099
1100     /**
1101      * Get the restrict string
1102      * @return mixed restrict string (can be an array of params for get_string or a single string to fetch from
1103      *                  admin.php lang file).
1104      */
1105     function getRestrictStr() {
1106         return $this->restrict_str;
1107     }
1108
1109     /**
1110      * @param mixed $string params for get_string, either a string to fetch from admin.php or an array of
1111      *                       params for get_string.
1112      * @param string $class css class(es) for message.
1113      * @return string feedback string fetched from lang file wrapped in p tag with class $class or returns
1114      *                              empty string if $string is empty.
1115      */
1116     function strToReport($string, $class){
1117         if (!empty($string)){
1118             if (is_array($string)){
1119                 $str = call_user_func_array('get_string', $string);
1120             } else {
1121                 $str = get_string($string, 'admin');
1122             }
1123             return '<p class="'.$class.'">'.$str.'</p>';
1124         } else {
1125             return '';
1126         }
1127     }
1128 }
1129
1130 /// Here all the bypass functions are coded to be used by the environment
1131 /// checker. All those functions will receive the result object and will
1132 /// return it modified as needed (status and bypass string)
1133
1134 /**
1135  * This function will bypass MySQL 4.1.16 reqs if:
1136  *   - We are using MySQL > 4.1.12, informing about problems with non latin chars in the future
1137  *
1138  * @param object result object to handle
1139  * @return boolean true/false to determinate if the bypass has to be performed (true) or no (false)
1140  */
1141 function bypass_mysql416_reqs ($result) {
1142 /// See if we are running MySQL >= 4.1.12
1143     if (version_compare($result->getCurrentVersion(), '4.1.12', '>=')) {
1144         return true;
1145     }
1146
1147     return false;
1148 }
1149
1150 /// Here all the restrict functions are coded to be used by the environment
1151 /// checker. All those functions will receive the result object and will
1152 /// return it modified as needed (status and bypass string)
1153
1154 /**
1155  * This function will restrict PHP reqs if:
1156  *   - We are using PHP 5.0.x, informing about the buggy version
1157  *
1158  * @param object result object to handle
1159  * @return boolean true/false to determinate if the restrict has to be performed (true) or no (false)
1160  */
1161 function restrict_php50_version($result) {
1162     if (version_compare($result->getCurrentVersion(), '5.0.0', '>=')
1163       and version_compare($result->getCurrentVersion(), '5.0.99', '<')) {
1164         return true;
1165     }
1166     return false;
1167 }
1168
1169 /**
1170  * @param array $element the element from the environment.xml file that should have
1171  *      either a level="required" or level="optional" attribute.
1172  * @read string "required" or "optional".
1173  */
1174 function get_level($element) {
1175     $level = 'required';
1176     if (isset($element['@']['level'])) {
1177         $level = $element['@']['level'];
1178         if (!in_array($level, array('required', 'optional'))) {
1179             debugging('The level of a check in the environment.xml file must be "required" or "optional".', DEBUG_DEVELOPER);
1180             $level = 'required';
1181         }
1182     } else {
1183         debugging('Checks in the environment.xml file must have a level="required" or level="optional" attribute.', DEBUG_DEVELOPER);
1184     }
1185     return $level;
1186 }
1187
1188 /**
1189  * Once the result has been determined, look in the XML for any
1190  * messages, or other things that should be done depending on the outcome.
1191  * @param array $element the element from the environment.xml file which
1192  *      may have children defining what should be done with the outcome.
1193  * @param object $result the result of the test, which may be modified by
1194  *      this function as specified in the XML.
1195  */
1196 function process_environment_result($element, &$result) {
1197 /// Process messages, modifying the $result if needed.
1198     process_environment_messages($element, $result);
1199 /// Process bypass, modifying $result if needed.
1200     process_environment_bypass($element, $result);
1201 /// Process restrict, modifying $result if needed.
1202     process_environment_restrict($element, $result);
1203 }
1204 ?>