check_requirements.php

<?php
error_reporting(E_ALL);
$SYSTEM_ROOT = '';

if ((php_sapi_name() == 'cli')) {
    if (isset($_SERVER['argv'][1])) {
        $SYSTEM_ROOT = $_SERVER['argv'][1];
    }

    $err_msg = "ERROR: You need to supply the path to the System Root as the first argument\n";

} else {
    if (isset($_GET['SYSTEM_ROOT'])) {
        $SYSTEM_ROOT = $_GET['SYSTEM_ROOT'];
    }

    $err_msg = '
    <div style="background-color: red; color: white; font-weight: bold;">
        You need to supply the path to the System Root as a query string variable called SYSTEM_ROOT
    </div>
    ';
}

if (empty($SYSTEM_ROOT)) {
    $err_msg .= "Usage: php install/check_requirements.php <PATH_TO_MATRIX>\n";
    echo $err_msg;
    exit();
}

if (!is_dir($SYSTEM_ROOT) || !is_readable($SYSTEM_ROOT.'/core/include/init.inc')) {
    $err_msg = "ERROR: Path provided doesn't point to a Matrix installation's System Root. Please provide correct path and try again.\n";
    $err_msg .= "Usage: php install/check_requirements.php <PATH_TO_MATRIX>\n";
    echo $err_msg;
    exit();
}

if (ini_get('safe_mode') == 1) {
    echo "MySource Matrix is not compatible with safe-mode.\n";
    echo "You will need to disable safe_mode in your php.ini file(s).\n";
    echo "\n";
    echo "If your web server uses a different php.ini file to command line,\n";
    echo " (this is the case if you're running a debian based system),\n";
    echo " make sure you disable it in all php.ini files.\n";
    echo "\n";
    echo "Once you have done that, run this script again.\n";
    exit(1);
}

$missing_modules = array (
    'php_extension' => array (
        'required' => array(),
        'suggested' => array(),
        'out_of_date' => array(),
    ),
    'pear_package' => array (
        'required' => array(),
        'suggested' => array(),
        'out_of_date' => array(),
    ),
    'pecl_package' => array (
        'required' => array(),
        'suggested' => array(),
        'out_of_date' => array(),
    ),
    'external_program' => array (
        'required' => array(),
        'suggested' => array(),
        'out_of_date' => array(),
    ),
    'php_file' => array (
        'required' => array(),
        'suggested' => array(),
        'out_of_date' => array(),
    ),
);

check_requirement_file($SYSTEM_ROOT.'/core/assets/requirements.xml', 'core');

$xml_files = get_files($SYSTEM_ROOT . '/packages', 'requirements.xml', 2);
foreach ($xml_files as $xml_file) {
    $package_path = str_replace($SYSTEM_ROOT.'/packages/', '', $xml_file);

    $pkg_info = explode('/', $package_path);
    array_pop($pkg_info);
    $package_name = implode('/', $pkg_info);
    check_requirement_file($xml_file, $package_name);
}

$anything_missing = false;

$check_types = array_keys($missing_modules);
foreach ($check_types as $check_type) {
    $types = array_keys($missing_modules[$check_type]);

    switch ($check_type)
    {
        case 'php_extension':
            $prefix = 'These php extensions are ';
        break;
        case 'pear_package':
            $prefix = 'These pear packages are ';
        break;
        case 'pecl_package':
            $prefix = 'These pecl packages are ';
        break;
        case 'external_program':
            $prefix = 'These external programs are ';
        break;
        case 'php_file':
            $prefix = 'These external php scripts are ';
        break;
    }

    foreach ($types as $type) {
        if (empty($missing_modules[$check_type][$type])) {
            continue;
        }

        if ($anything_missing === false) {
            echo "The following requirements or suggestions are made:\n\n";
            $anything_missing = true;
        }

        switch ($type)
        {
            case 'required':
            case 'suggested':
                $heading = $type;
                $suffix = " by the %s package";
            break;
            case 'out_of_date':
                $heading = "found, but out of date";
                $suffix = " for the %s package";
            break;
        }

        $list = array();

        foreach ($missing_modules[$check_type][$type] as $item) {
            $req_by = $item['required_by'];
            if (!isset($list[$req_by])) {
                $list[$req_by] = array();
            }
            unset($item['required_by']);
            $list[$req_by][] = $item;
            sort($list[$req_by]);
        }

        asort($list);

        foreach ($list as $req_by => $details) {
            printf($prefix . $heading . $suffix . "\n", $req_by);
            echo str_repeat('-', 20) . "\n";
            foreach ($details as $item) {
                echo "\t" . $item['name'];
                if (isset($item['version_found'])) {
                    echo " (Found version " . $item['version_found'] . " but require at least " . $item['version_required'] . ")";
                }
                echo "\n";
            }
            echo "\n";
        }
    }
}

if (!$anything_missing) {
    echo "Everything appears to be available and up to date.\n";
}

function check_requirement_file($file='', $package_name='core')
{
    if (!is_file($file)) {
        trigger_error("File '".$file."' doesn't exist", E_USER_WARNING);
        return;
    }

    try {
        $requirement_list = new SimpleXMLElement($file, LIBXML_NOCDATA, TRUE);
    } catch (Exception $e) {
        trigger_error('Could not parse requirements XML file (' . $file . '): '.$e->getMessage(), E_USER_WARNING);
        return;
    }

    foreach ($requirement_list->requirement as $requirement_check) {
        check_requirement($requirement_check, $package_name);
    }
}

function check_requirement($requirement_check, $package_name='core')
{
    global $missing_modules;

    static $pear_package_list = array();
    static $pecl_package_list = array();
    static $php_extension_list = array();

    if (empty($pear_package_list)) {
        $rc = -1;
        $pear_list = array();
        exec('pear list 2>/dev/null', $pear_list, $rc);

        if (empty($pear_list) || $rc !== 0) {
            $msg = "Unable to exec the 'pear list' command.\n";
            $msg .= "Please check pear is installed and in your path then try again.\n";
            echo $msg;
            exit(1);
        }

        unset($pear_list[0]);
        unset($pear_list[1]);
        unset($pear_list[2]);

        foreach ($pear_list as $line) {
            $line = preg_replace('/\s+/', ' ', $line);
            list($name, $version, $state) = explode(' ', $line);
            $pear_package_list[strtolower($name)] = $version;
        }
    }

    if (empty($pecl_package_list)) {
        $rc = -1;
        $pecl_list = array();
        exec('pecl list 2>/dev/null', $pecl_list, $rc);

        if (empty($pecl_list) || $rc !== 0) {
            $msg = "Unable to exec the 'pecl list' command.\n";
            $msg .= "Please check pecl is installed and in your path then try again.\n";
            echo $msg;
            exit(1);
        }

        unset($pecl_list[0]);
        unset($pecl_list[1]);
        unset($pecl_list[2]);

        foreach ($pecl_list as $line) {
            $line = preg_replace('/\s+/', ' ', $line);
            list($name, $version, $state) = explode(' ', $line);
            $pecl_package_list[strtolower($name)] = $version;
        }
    }

    if (empty($php_extension_list)) {
        $php_extension_list = get_loaded_extensions();
    }

    $check_type = null;
    if (isset($requirement_check->php_extension)) {
        $check_type = 'php_extension';
    }

    if (isset($requirement_check->pear_package)) {
        $check_type = 'pear_package';
    }

    if (isset($requirement_check->pecl_package)) {
        $check_type = 'pecl_package';
    }

    if (isset($requirement_check->external_program)) {
        $check_type = 'external_program';
    }

    if (isset($requirement_check->php_file)) {
        $check_type = 'php_file';
    }

    $check_ok = false;
    $check_alternative = true;
    $check_version = false;

    $extra_info = '';

    $description = '';
    if ($requirement_check->description) {
        $description = (string)$requirement_check->description;
    }

    switch ($check_type)
    {
        case 'php_extension':
            $check_name = (string)$requirement_check->php_extension;
            if (in_array($check_name, $php_extension_list)) {
                $check_ok = true;
                if (!$requirement_check->suggested) {
                    $check_alternative = false;
                }
                if ($requirement_check->version) {
                    $check_version = true;
                    $version_found = phpversion($check_name);
                    $version_required = (string)$requirement_check->version;
                }
                break;
            }
        break;

        case 'pear_package':
            $check_name = strtolower($requirement_check->pear_package);

            if (isset($pear_package_list[$check_name])) {
                $check_version = true;
                $check_ok = true;
                $version_found = $pear_package_list[$check_name];
                $version_required = (string)$requirement_check->version;
            }
        break;

        case 'pecl_package':
            $check_name = strtolower($requirement_check->pecl_package);

            if (isset($pecl_package_list[$check_name])) {
                $check_version = true;
                $check_ok = true;
                $version_found = $pecl_package_list[$check_name];
                $version_required = (string)$requirement_check->version;
            }
        break;

        case 'external_program':
            $external_program = (string)$requirement_check->external_program;
            $program_path = '';
            if (isset($requirement_check->path)) {
                $program_path = (string)$requirement_check->path;
                $program_path = rtrim($program_path, '/').'/';
            }//end if

            $version_required = (string)$requirement_check->version;

            $cmd = $program_path.$external_program;
            $check_name = $external_program;

            if ($external_program === 'padre-iw') {
                if (!empty($program_path) && is_dir($program_path)) {
                    $cmd = 'export SEARCH_HOME='.dirname($program_path).';'.$cmd;
                }
            }

            if (isset($requirement_check->version_arguments)) {
                $cmd .= ' ' . escapeshellarg((string)$requirement_check->version_arguments);
            }

            if (isset($requirement_check->uses_stderr)) {
                $cmd .= ' 2>&1';
            } else {
                $cmd .= ' 2>/dev/null';
            }

            $cmd_output = array();
            $cmd_return_code = -1;
            exec($cmd, $cmd_output, $cmd_return_code);

            $expected_return_code = 0;
            if (isset($requirement_check->expected_return_code)) {
                $expected_return_code = $requirement_check->expected_return_code;
            }

            if ($cmd_return_code != $expected_return_code || empty($cmd_output)) {
                break;
            }

            $check_version = true;

            switch ($external_program)
            {
                case 'pdftohtml':
                    $check_ok = true;

                    $check_version = false;

                    $version_line = $cmd_output[0];
                    list($intro, $version_kw, $version_found) = explode(' ', $version_line);

                    $version_info = explode('.', $version_found);

                    // If it's 'a.b' we can directly check that.
                    if (count($version_info) == 2) {
                        $version_check = version_compare($version_found, $version_required, '>=');
                        if ($version_check !== true) {
                            $missing_modules['external_program']['out_of_date'][] = array(
                                'name' => $external_program,
                                'version_found' => $version_found,
                                'version_required' => $version_required,
                                'required_by' => $package_name,
                            );
                        }
                    } else {
                        // It's 'a.b.c', we'll check ourselves.
                        // We'll check the copyright line, make sure it mentions 2009.
                        // If it does, we're good to go, if it doesn't, we're out of date.
                        $_found = FALSE;
                        foreach ($cmd_output as $output_line) {
                            if (strpos($output_line, 'Copyright 2005-2009') !== FALSE) {
                                $_found = TRUE;
                                break;
                            }
                        }

                        if ($_found === FALSE) {
                            $missing_modules['external_program']['out_of_date'][] = array(
                                'name' => $external_program,
                                'version_found' => $version_found,
                                'version_required' => $version_required,
                                'required_by' => $package_name,
                            );
                        }
                    }
                break;

                case 'tidy':
                    $check_version = false;

                    $version_line = $cmd_output[0];
                    $match_found = preg_match('/released on (.*)$/', $version_line, $matches);
                    if (!$match_found) {
                        $extra_info = " (version checking not working)";
                        break;
                    }
                    $check_ok = true;

                    $version_found = $matches[1];
                    $version_found_date = strtotime($version_found);
                    $version_required_date = strtotime($version_required);

                    if ($version_found_date < $version_required_date) {
                        $missing_modules['external_program']['out_of_date'][] = array(
                            'name' => $external_program,
                            'version_found' => $version_found,
                            'version_required' => $version_required,
                            'required_by' => $package_name,
                        );
                    }
                break;

                case 'antiword':
                    if (!isset($cmd_output[3])) {
                        $extra_info = " (version checking not working)";
                        break;
                    }

                    $version_line = $cmd_output[3];
                    $match_found = preg_match('/Version: (.*?)\s+/', $version_line, $matches);
                    if ($match_found) {
                        $check_ok = true;
                        $version_found = $matches[1];
                    } else {
                        $extra_info = " (version checking not working)";
                    }
                break;

                case 'squidclient':
                    $check_ok = true;
                    $check_version = false;
                break;

                case 'clamscan':
                    $version_line = $cmd_output[0];
                    $match_found = preg_match('%ClamAV (.*?)/%', $version_line, $matches);
                    if ($match_found) {
                        $check_ok = true;
                        $version_found = $matches[1];
                    } else {
                        $extra_info = " (version checking not working)";
                    }
                break;

                case 'fpscan':
                    if (!isset($cmd_output[1])) {
                        $extra_info = " (version checking not working)";
                        break;
                    }
                    $version_line = $cmd_output[1];
                    $match_found = preg_match('/ version (.*?) /', $version_line, $matches);
                    if ($match_found) {
                        $check_ok = true;
                        $version_found = $matches[1];
                    } else {
                        $extra_info = " (version checking not working)";
                    }

                break;

                case 'padre-iw':
                    if (!isset($cmd_output[0])) {
                        $extra_info = " (version checking not working)";
                        break;
                    }
                    $version_line = $cmd_output[0];
                    $match_found = preg_match('/FUNNELBACK_PADRE_([0-9\.]*)/', $version_line, $matches);
                    if ($match_found) {
                        $check_ok = true;
                        $version_found = $matches[1];
                    } else {
                        $extra_info = " (version checking not working)";
                    }

                break;

                case 'js':
                    $check_ok = true;
                    $version_line = $cmd_output[0];
                    list($junk, $version_found, $date) = explode(' ', $version_line);
                break;

                default:
                    $missing_modules['external_program']['required'][] = array (
                        'name' => $external_program . " (Unknown program, can't check version numbers)",
                        'required_by' => $package_name,
                    );
                    return;
                break;

            }
        break;

        case 'php_file':
            $check_version = false;

            $php_file = (string)$requirement_check->php_file;

            $check_name = $php_file;

            if (is_file($php_file)) {
                $check_ok = true;
            } else {
                $extra_info = " (only the php include_path was checked, if it is not in one of those paths the file has not been found)";
            }
        break;

        case null:
            echo "Unknown type ('" . $check_type . "')\n";
            return;
        break;

    }

    if ($check_version) {
        $version_check = version_compare($version_found, $version_required, '>=');
        if ($version_check !== true) {
            $missing_modules[$check_type]['out_of_date'][] = array(
                'name' => $check_name . $description . $extra_info,
                'version_found' => $version_found,
                'version_required' => $version_required,
                'required_by' => $package_name
            );
        }
    }

    $alternative_ok = null;
    $alternative_suggested = false;
    if ($check_alternative && $requirement_check->alternative) {
        $alternative_suggested = $requirement_check->alternative->suggested;
        $alternative_ok = check_requirement($requirement_check->alternative, $package_name);
    }

    if ($alternative_ok !== null) {
        if (!$alternative_suggested && !$check_ok) {
            $check_ok = $alternative_ok;
        }
    }

    if (!$check_ok) {
        if ($requirement_check->suggested) {
            $missing_modules[$check_type]['suggested'][] = array(
                'name' => $check_name . $description . $extra_info,
                'required_by' => $package_name
            );
        } else {
            $missing_modules[$check_type]['required'][] = array(
                'name' => $check_name . $description . $extra_info,
                'required_by' => $package_name
            );
        }
    }

    return $check_ok;
}

function get_files($dir='', $filename='', $max_depth=0, $_depth=0)
{
    $list = array();
    if (empty($dir) || empty($filename)) {
        return $list;
    }

    if (!is_dir($dir)) {
        return $list;
    }

    if ($max_depth > 0 && $_depth > $max_depth) {
        return $list;
    }

    $d = dir($dir);

    while (FALSE !== ($entry = $d->read())) {
        if ($entry == '.' || $entry == '..') {
            continue;
        }

        if (is_dir($dir.'/'.$entry)) {
            $sub_list = get_files($dir.'/'.$entry, $filename, $max_depth, ($_depth+1));
            $list = array_merge($sub_list, $list);
            continue;
        }

        if ($entry == $filename) {
            $list[] = $dir.'/'.$entry;
        }
    }
    $d->close();
    return $list;
}