mahara.php

<?php
/**
 *
 * @package    mahara
 * @subpackage core
 * @author     Catalyst IT Ltd
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL version 3 or later
 * @copyright  For copyright information on Mahara, please see the README file distributed with this software.
 * @copyright  (C) portions from Moodle, (C) Martin Dougiamas http://dougiamas.com
 */

defined('INTERNAL') || die();

/** 
 * work around silly php settings
 * and broken setup stuff about the install
 * and raise a warning/fail depending on severity
 */
function ensure_sanity() {

    // PHP version
    $phpversionrequired = '5.3.0';
    if (version_compare(phpversion(), $phpversionrequired) < 0) {
        throw new ConfigSanityException(get_string('phpversion', 'error', $phpversionrequired));
    }

    // Various required extensions
    if (!extension_loaded('json')) {
        throw new ConfigSanityException(get_string('jsonextensionnotloaded', 'error'));
    }
    switch (get_config('dbtype')) {
    case 'postgres':
    case 'postgres8': // for legacy purposes we also accept "postgres8"
        if (!extension_loaded('pgsql')) {
            throw new ConfigSanityException(get_string('pgsqldbextensionnotloaded', 'error'));
        }
        break;
    case 'mysql':
    case 'mysql5': // for legacy purposes we also accept "mysql5"
        if (!extension_loaded('mysqli') && !extension_loaded('mysql')) {
            throw new ConfigSanityException(get_string('mysqldbextensionnotloaded', 'error'));
        }
        break;
    default:
        throw new ConfigSanityException(get_string('unknowndbtype', 'error'));
    }
    if (!extension_loaded('xml')) {
        throw new ConfigSanityException(get_string('xmlextensionnotloaded', 'error', 'xml'));
    }
    if (!extension_loaded('libxml')) {
        throw new ConfigSanityException(get_string('xmlextensionnotloaded', 'error', 'libxml'));
    }
    if (!extension_loaded('gd')) {
        throw new ConfigSanityException(get_string('gdextensionnotloaded', 'error'));
    }
    if (!extension_loaded('session')) {
        throw new ConfigSanityException(get_string('sessionextensionnotloaded', 'error'));
    }

    if(!extension_loaded('curl')) {
        throw new ConfigSanityException(get_string('curllibrarynotinstalled', 'error'));
    }
    if (!extension_loaded('dom')) {
        throw new ConfigSanityException(get_string('domextensionnotloaded', 'error'));
    }

    //Check for freetype in the gd extension
    $gd_info = gd_info();
    if (!$gd_info['FreeType Support']) {
        throw new ConfigSanityException(get_string('gdfreetypenotloaded', 'error'));
    }

    // register globals workaround
    if (ini_get_bool('register_globals')) {
        $massivearray = array_keys(array_merge($_POST, $_GET, $_COOKIE, $_SERVER, $_REQUEST, $_FILES));
        foreach ($massivearray as $tounset) {
            unset($GLOBALS[$tounset]);
        }
    }

    // magic_quotes_gpc workaround
    if (!defined('CRON') && ini_get_bool('magic_quotes_gpc')) {
        function stripslashes_deep($value) {
            $value = is_array($value) ?
                array_map('stripslashes_deep', $value) :
                stripslashes($value);
            return $value;
        }
        $_POST = array_map('stripslashes_deep', $_POST);
        $_GET = array_map('stripslashes_deep', $_GET);
        $_COOKIE = array_map('stripslashes_deep', $_COOKIE);
        $_REQUEST = array_map('stripslashes_deep', $_REQUEST);

        $servervars = array('REQUEST_URI','QUERY_STRING','HTTP_REFERER','PATH_INFO','PHP_SELF','PATH_TRANSLATED');
        foreach ($servervars as $tocheck) {
            if (array_key_exists($tocheck,$_SERVER) && !empty($_SERVER[$tocheck])) {
                $_SERVER[$tocheck] = stripslashes($_SERVER[$tocheck]);
            }
        }
    }

    if (ini_get_bool('magic_quotes_runtime')) {
        // Turn of magic_quotes_runtime. Anyone with this on deserves a slap in the face
        set_magic_quotes_runtime(0);
    }

    if (ini_get_bool('magic_quotes_sybase')) {
        // See above comment re. magic_quotes_runtime
        @ini_set('magic_quotes_sybase', 0);
    }

    if (ini_get_bool('safe_mode')) {
        // We don't run with safe mode
        throw new ConfigSanityException(get_string('safemodeon', 'error'));
    }

    if ('0' === ini_get('apc.stat') or 'off' === ini_get('apc.stat')) {
        // We don't run with apc.stat=0 (see https://bugs.launchpad.net/mahara/+bug/548333)
        throw new ConfigSanityException(get_string('apcstatoff', 'error'));
    }

    // Other things that might be worth checking:
    //    memory limit
    //    file_uploads (off|on)
    //    upload_max_filesize
    //    allow_url_fopen (only if we use this)
    //

    // dataroot inside document root.
    if (strpos(get_config('dataroot'), get_config('docroot')) !== false) {
        throw new ConfigSanityException(get_string('datarootinsidedocroot', 'error'));
    }

    // dataroot not writable..
    if (!check_dir_exists(get_config('dataroot')) || !is_writable(get_config('dataroot'))) {
        $message = get_string('datarootnotwritable', 'error', get_config('dataroot'));
        if ($openbasedir = ini_get('open_basedir')) {
            $message .= "\n(" . get_string('openbasedirenabled', 'error') . ' '
                . get_string('openbasedirpaths', 'error', htmlspecialchars($openbasedir)) // hsc() is not defined yet
                . ')';
        }
        throw new ConfigSanityException($message);
    }

    if (
        !check_dir_exists(get_config('dataroot') . 'smarty/compile') ||
        !check_dir_exists(get_config('dataroot') . 'smarty/cache') ||
        !check_dir_exists(get_config('dataroot') . 'temp') ||
        !check_dir_exists(get_config('dataroot') . 'langpacks') ||
        !check_dir_exists(get_config('dataroot') . 'htmlpurifier') ||
        !check_dir_exists(get_config('dataroot') . 'log') ||
        !check_dir_exists(get_config('dataroot') . 'images')) {
        throw new ConfigSanityException(get_string('couldnotmakedatadirectories', 'error'));
    }
    // Since sessionpath can now exist outside of the the dataroot, check it separately.
    // NOTE: If we implement separate session handlers, we may want to remove or alter this check
    if (!check_dir_exists(get_config('sessionpath')) || !is_writable(get_config('sessionpath'))) {
        throw new ConfigSanityException(get_string('sessionpathnotwritable', 'error', get_config('sessionpath')));
    }

    raise_memory_limit('128M');
}

/**
 * Check sanity of things that we only check at installation time - not on 
 * every request, like ensure_sanity() does
 */
function ensure_install_sanity() {
    // Must must must be a UTF8 database!
    if (!db_is_utf8()) {
        throw new ConfigSanityException(get_string('dbnotutf8', 'error'));
    }
    if (is_postgres() && !postgres_create_language('plpgsql')) {
        throw new ConfigSanityException(get_string('plpgsqlnotavailable', 'error'));
    }
    if (is_mysql() && !mysql_has_trigger_privilege()) {
        throw new ConfigSanityException(get_string('mysqlnotriggerprivilege', 'error'));
    }
}

function ensure_upgrade_sanity() {
    // Check column collation is equal to the default
    if (is_mysql()) {
        require_once('ddl.php');
        if (table_exists(new XMLDBTable('event_type'))) {
            if (!column_collation_is_default('event_type', 'name')) {
                throw new ConfigSanityException(get_string('dbcollationmismatch', 'admin'));
            }
        }
        if (!mysql_has_trigger_privilege()) {
            throw new ConfigSanityException(get_string('mysqlnotriggerprivilege', 'error'));
        }
    }
    if (is_postgres() && !postgres_create_language('plpgsql')) {
        throw new ConfigSanityException(get_string('plpgsqlnotavailable', 'error'));
    }
}

/**
 * Upgrade/Install the specified mahara components
 *
 * @param array $upgrades The list of components to install or upgrade
 * @return void
 */
function upgrade_mahara($upgrades) {
    if (isset($upgrades['firstcoredata']) && $upgrades['firstcoredata']) {
        $install = true;
    }
    else {
        $install = false;
    }
    uksort($upgrades, 'sort_upgrades');
    foreach ($upgrades as $name => $data) {
        if ($name == 'disablelogin') {
            continue;
        }
        if ($install) {
            log_info(get_string('installingplugin', 'admin', $name));
        }
        else {
            log_info(get_string('upgradingplugin', 'admin', $name));
        }
        if ($name == 'firstcoredata' || $name == 'lastcoredata') {
            $funname = 'core_install_' . $name . '_defaults';
            $funname();
            continue;
        }
        else if ($install && $name == 'localpreinst') {
            $name(array('localdata' => true));
        }
        else if ($install && $name == 'localpostinst') {
            // Update local version
            $config = new StdClass;
            require(get_config('docroot') . 'local/version.php');
            set_config('localversion', $config->version);
            set_config('localrelease', $config->release);

            // Installation is finished
            set_config('installed', true);
            log_info('Installation complete.');
        }
        else {
            if ($name == 'core') {
                $funname = 'upgrade_core';
            }
            else if ($name == 'local') {
                $funname = 'upgrade_local';
            }
            else {
                $funname = 'upgrade_plugin';
            }
            $data->name = $name;
            $funname($data);
        }
    }
}

/**
 * Check to see if the internal plugins are installed. Die if they are not.
 */
function ensure_internal_plugins_exist() {
    // Internal things installed
    if (get_config('installed')) {
        foreach (plugin_types() as $type) {
            if (!record_exists($type . '_installed', 'name', 'internal')) {
                throw new ConfigSanityException(get_string($type . 'notinstalled'));
            }
        }
    }
}

function get_string($identifier, $section='mahara') {

    $variables = func_get_args();
    if (count($variables) > 2) { // we have some stuff we need to sprintf
        array_shift($variables);
        array_shift($variables); //shift off the first two.
    }
    else {
        $variables = array();
    }
    
    return get_string_location($identifier, $section, $variables);
}

function get_string_from_language($lang, $identifier, $section='mahara') {

    $variables = func_get_args();
    if (count($variables) > 3) { // we have some stuff we need to sprintf
        array_shift($variables);
        array_shift($variables);
        array_shift($variables); //shift off the first three.
    }
    else {
        $variables = array();
    }
    
    return get_string_location($identifier, $section, $variables, 'format_langstring', $lang);
}

function get_helpfile($plugintype, $pluginname, $form, $element, $page=null, $section=null) {
    if ($langfile = get_helpfile_location($plugintype, $pluginname, $form, $element, $page, $section)) {
        return file_get_contents($langfile);
    }
    return false;
}

function get_helpfile_location($plugintype, $pluginname, $form, $element, $page=null, $section=null) {

    $subdir = 'help/';

    if ($page) {
        $pagebits = explode('-', $page);
        $file = array_pop($pagebits) . '.html';
        if ($plugintype != 'core') {
            $subdir .= 'pages/' . join('/', $pagebits) . '/';
        }
        else {
            $subdir .= 'pages/' . $pluginname . '/' . join('/', $pagebits) . '/';
        } 
    }
    else if ($section) {
        $subdir .= 'sections/';
        $file = $section . '.html';
    }
    else if (!empty($form) && !empty($element)) {
        $subdir .= 'forms/';
        $file = $form . '.' . $element . '.html';
    }
    else if (!empty($form) && empty($element)) {
        $subdir .= 'forms/';
        $file = $form . '.html';
    }
    else {
        return false;
    }

    // now we have to try and locate the help file
    $lang = current_language();
    if ($lang == 'en.utf8') {
        $trieden = true;
    }
    else {
        $trieden = false;
    }

    //try the local settings
    $langfile = get_config('docroot') . 'local/lang/' . $lang . '/' . $subdir;
    if ($plugintype != 'core') {
        $langfile .= $plugintype . '.' . $pluginname . '.' . $file;
    }
    else {
        $langfile .= $file;
    }
    if (is_readable($langfile)) {
        return $langfile;
    }

    if ($plugintype == 'blocktype') { // these are a bit of a special case
        $bits = explode('/', $pluginname);
        if (count($bits) == 2) {
           $location = 'artefact/' . $bits[0] . '/blocktype/' . $bits[1] . '/lang/';
        }
        else {
            try {
                if ($artefactplugin = blocktype_artefactplugin($pluginname)) {
                    $location = 'artefact/' . $artefactplugin . '/blocktype/' . $pluginname . '/lang/';
                }
                else {
                    $location = 'blocktype/' . $pluginname . '/lang/';
                }
            }
            catch (SQLException $e) {
                if (get_config('installed')) {
                    throw $e;
                }
            }
        }
    }
    else if ($plugintype != 'core') {
        $location = $plugintype . '/' . $pluginname . '/lang/';
    }
    else {
        $location = 'lang/';
    }

    // try the current language
    $langfile = get_language_root() . $location . $lang . '/' . $subdir . $file;
    if (is_readable($langfile)) {
        return $langfile;
    }

    // if it's not found, try the parent language if there is one...
    if (empty($data) && empty($trieden)) {
        $langfile = get_language_root($lang) . 'lang/' . $lang . '/langconfig.php';
        if ($parentlang = get_string_from_file('parentlanguage', $langfile)) {
            if ($parentlang == 'en.utf8') {
                $trieden = true;
            }
            $langfile = get_language_root($parentlang) . $location . $parentlang . '/' . $subdir . $file;
            if (is_readable($langfile)) {
                return $langfile;
            }
        }
    }

    // if it's STILL not found, and we haven't already tried english ...
    if (empty($data) && empty($trieden)) {
        $langfile = get_language_root('en.utf8') . $location . 'en.utf8/' . $subdir . $file;
        if (is_readable($langfile)) {
            return $langfile;
        }
    }

    // if it's a form element, try the wildcard form name
    if (!empty($form) && !empty($element) && $form !== 'ANY') {
        return get_helpfile_location('core', '', 'ANY', $element, $page, $section);
    }

    return false;
}

// get a string without sprintfing it.
function get_raw_string($identifier, $section='mahara') {
    // For a raw string we don't want to format any arguments using
    // sprintf, so the replace function passed to get_string_location
    // should just return the first argument and ignore the second.
    return get_string_location($identifier, $section, array(), 'raw_langstring');
}


/**
 * This function gets a language string identified by $identifier from
 * an appropriate location, and formats the string and any arguments
 * in $variables using the function $replacefunc.
 *
 * @param string   $identifier
 * @param string   $section
 * @param array    $variables
 * @param function $replacefunc
 * @return string
 */
function get_string_location($identifier, $section, $variables, $replacefunc='format_langstring', $lang='') {

    $langconfigstrs = array('parentlanguage', 'thislanguage');

    if ($section == 'mahara' &&
        (in_array($identifier, $langconfigstrs)
         || strpos($identifier, 'strftime') === 0
         || strpos($identifier, 'strfday')  === 0)) {
        $section = 'langconfig';
    }

    if (empty($lang)) {
        $lang = current_language();
    }

    // Define the locations of language strings for this section
    $langstringroot = get_language_root($lang);
    $langdirectory  = ''; // The directory in which the language file for this string should ideally reside, if the language has implemented it
    
    if (false === strpos($section, '.')) {
        $langdirectory = 'lang/';
    }
    else {
        $extras = plugin_types(); // more later..
        foreach ($extras as $tocheck) {
            if (strpos($section, $tocheck . '.') === 0) {
                $pluginname = substr($section ,strlen($tocheck) + 1);
                if ($tocheck == 'blocktype' && 
                    strpos($pluginname, '/') !== false) { // it belongs to an artefact plugin
                    $bits = explode('/', $pluginname);
                    $langdirectory = 'artefact/' . $bits[0] . '/blocktype/' . $bits[1] . '/lang/';
                    $section = 'blocktype.' . $bits[1];
                }
                else {
                    $langdirectory = $tocheck . '/' . $pluginname . '/lang/';
                }
            }
        }
    }

    // First check all the normal locations for the string in the current language
    $result = get_string_local($langstringroot . $langdirectory, $lang . '/' . $section . '.php', $identifier);
    if ($result !== false) {
        return $replacefunc($result, $variables, $lang);
    }

    // If the preferred language was English (utf8) we can abort now
    // saving some checks beacuse it's the only "root" lang
    if ($lang == 'en.utf8') {
        return '[[' . $identifier . '/' . $section . ']]';
    }

    // Is a parent language defined?  If so, try to find this string in a parent language file
    $langfile = $langstringroot . 'lang/' . $lang . '/langconfig.php';
    if (is_readable($langfile)) {
        if ($parentlang = get_string_from_file('parentlanguage', $langfile)) {
            $result = get_string_local(get_language_root($parentlang) . 'lang/', $parentlang . '/' . $section . '.php', $identifier);
            if ($result !== false) {
                return $replacefunc($result, $variables, $parentlang);
            }
        }
    }

    /// Our only remaining option is to try English
    $result = get_string_local(get_config('docroot') . $langdirectory, 'en.utf8/' . $section . '.php', $identifier);
    if ($result !== false) {
        return $replacefunc($result, $variables);
    }

    return '[[' . $identifier . '/' . $section . ']]';  // Last resort
}


/**
 * Get string from a file, checking the appropriate local customisation directory first
 *
 */
function get_string_local($langpath, $langfile, $identifier) {
    foreach (array(get_config('docroot') . 'local/lang/', $langpath) as $dir) {
        $file = $dir . $langfile;
        if (is_readable($file)) {
            $result = get_string_from_file($identifier, $file);
            if ($result !== false) {
                return $result;
            }
        }
    }
    return false;
}


/**
 * Return a list of available languages
 *
 */
function get_languages() {
    static $langs = array();

    if (!$langs) {
        foreach (language_get_searchpaths() as $searchpath) {
            $langbase = $searchpath . 'lang/';
            if ($langdir = @opendir($langbase)) {
                while (false !== ($subdir = readdir($langdir))) {
                    if (preg_match('/\.utf8$/', $subdir) && is_dir($langbase . $subdir)) {
                        $langfile = $langbase . $subdir . '/langconfig.php';
                        if (is_readable($langfile)) {
                            if ($langname = get_string_from_file('thislanguage', $langfile)) {
                                $langs[$subdir] = $langname;
                            }
                        }
                    }
                }
                closedir($langdir);
                asort($langs);
            }
            else {
                log_warn('Unable to read language directory ' . $langbase);
            }
        }
    }

    return $langs;
}

/**
 * Returns whether the given language is installed/available for use
 */
function language_installed($lang) {
    foreach (language_get_searchpaths() as $searchpath) {
        if (is_readable($searchpath . 'lang/' . $lang . '/langconfig.php')) {
            return true;
        }
    }
    return false;
}

/**
 * Returns a list of directories in which to search for language packs.
 *
 * This is influenced by the configuration variable 'langpacksearchpaths'
 */
function language_get_searchpaths() {
    static $searchpaths = array();

    if (!$searchpaths) {
        // Construct the search path
        $docrootpath = array(get_config('docroot'));

        // Paths to language files in dataroot
        $datarootbase = get_config('dataroot') . 'langpacks/*';
        $datarootpaths = glob($datarootbase, GLOB_MARK | GLOB_ONLYDIR);
        if ($datarootpaths === false) {
            log_warn("Problem searching for langfiles at this path: " . $datarootbase);
            $datarootpaths = array();
        }

        // langpacksearchpaths configuration variable - for experts :)
        $lpsearchpaths = (array)get_config('langpacksearchpaths');
        $langpacksearchpaths = array();
        foreach ($lpsearchpaths as $path) {
            if (is_dir($path)) {
                $langpacksearchpaths[] = (substr($path, -1) == '/') ? $path : "$path/";
            }
            else {
                log_warn("Path in langpacksearchpaths is not a directory: $path");
            }
        }

        $searchpaths = array_merge($docrootpath, $datarootpaths, $langpacksearchpaths);
    }

    return $searchpaths;
}

/**
 * Get the directory in which the specified language pack resides.
 *
 * Defaults to getting the directory for the current_language() - i.e. the 
 * language the user is using
 *
 * Returns null if the language can't be found
 *
 * @param string $language The language to look for
 */
function get_language_root($language=null) {
    static $language_root_cache = array();

    if (!isset($language_root_cache[$language])) {
        if ($language == null) {
            $language = current_language();
        }

        foreach (language_get_searchpaths() as $path) {
            if (is_dir("$path/lang/$language")) {
                return $language_root_cache[$language] = $path;
            }
        }

        // Oh noes, can't be found
        $language_root_cache[$language] = null;

    }

    return $language_root_cache[$language];
}

/**
 * Return a list of all available themes.
 * @return array subdir => name
 */
function get_all_themes() {
    static $themes = null;

    if (is_null($themes)) {
        $themes = array();
        $themelist = get_all_theme_objects();
        foreach ($themelist AS $subdir => $theme) {
            $themes[$subdir] = isset($theme->displayname) ? $theme->displayname : $subdir;
        }
    }

    return $themes;
}

/**
 * Return a list of themes available to this user
 * If the user is a member of any institutions, only themes available to
 * those institutions are returned; or
 * If a user is not a member of any institution, all themes not marked as
 * institution specific are returned.
 * @return array subdir => name
 */
function get_user_accessible_themes() {
    global $USER;

    $themes = array();
    if ($institutions = $USER->get('institutions')) {
        // Get themes for all of this users institutions
        foreach ($institutions AS $i) {
            $themes = array_merge($themes, get_institution_themes($i->institution));
        }
    }
    else {
        $themelist = get_all_theme_objects();
        foreach ($themelist AS $subdir => $theme) {
            if (!isset($theme->institutions) || !is_array($theme->institutions)) {
                $themes[$subdir] = isset($theme->displayname) ? $theme->displayname : $subdir;
            }
        }

    }
    $themes = array_merge(array('sitedefault' => get_string('nothemeselected', 'view')), $themes);
    unset($themes['custom']);

    return $themes;
}

/**
 * Return a list of themes available to the specified institution
 * @param string institution the name of the institution to load themes for
 * @return array subdir => name
 * @throws SystemException if unable to read the theme directory
 */
function get_institution_themes($institution) {
    static $institutionthemes = array();
    if (!isset($institutionthemes[$institution])) {
        $themes = get_all_theme_objects();
        $r = array();
        foreach ($themes AS $subdir => $theme) {
            if (empty($theme->institutions) || !is_array($theme->institutions) || in_array($institution, $theme->institutions)) {
                $r[$subdir] = isset($theme->displayname) ? $theme->displayname : $subdir;
            }
        }
        $institutionthemes[$institution] = $r;
    }

    return $institutionthemes[$institution];
}

/**
 * Return a list of all themes available on the system
 * @return array An array of theme objects
 * @throws SystemException if unable to read the theme directory
 */
function get_all_theme_objects() {
    static $themes = null;

    if (is_null($themes)) {
        $themes = array();
        $themebase = get_config('docroot') . 'theme/';
        if (!$themedir = opendir($themebase)) {
            throw new SystemException('Unable to read theme directory '.$themebase);
        }
        while (false !== ($subdir = readdir($themedir))) {
            if (substr($subdir, 0, 1) != "." && is_dir($themebase . $subdir)) {
                // is the theme directory name valid?
                if (!Theme::name_is_valid($subdir)) {
                    log_warn(get_string('themenameinvalid', 'error', $subdir));
                } else {
                    $config_path = $themebase . $subdir . '/themeconfig.php';
                    if (is_readable($config_path)) {
                        require($config_path);
                        if (empty($theme->disabled) || !$theme->disabled) {
                            $themes[$subdir] = $theme;
                        }
                    }
                }
            }
        }
        closedir($themedir);
        asort($themes);
    }

    return $themes;
}


/**
 * This function is only used from {@link get_string()}.
 *
 * @internal Only used from get_string, not meant to be public API
 * @param string $identifier ?
 * @param string $langfile ?
 * @param string $destination ?
 * @return string|false ?
 * @staticvar array $strings Localized strings
 * @access private
 * @todo Finish documenting this function.
 */
function get_string_from_file($identifier, $langfile) {

    static $strings;    // Keep the strings cached in memory.

    if (empty($strings[$langfile])) {
        $string = array();
        include ($langfile);
        $strings[$langfile] = $string;
    } else {
        $string = &$strings[$langfile];
    }

    if (!isset ($string[$identifier])) {
        return false;
    }

    return $string[$identifier];
}

/**
 * This function makes the return value of ini_get consistent if you are
 * setting server directives through the .htaccess file in apache.
 * Current behavior for value set from php.ini On = 1, Off = [blank]
 * Current behavior for value set from .htaccess On = On, Off = Off
 * Contributed by jdell @ unr.edu
 *
 * @param string $ini_get_arg setting to look for
 * @return bool
 */
function ini_get_bool($ini_get_arg) {
    $temp = ini_get($ini_get_arg);

    if ($temp == '1' or strtolower($temp) == 'on') {
        return true;
    }
    return false;
}

/**
 * This function loads up the basic $CFG
 * from the database table
 * note that it doesn't load plugin config
 * as not every page needs them
 * @return boolean false if the assignment fails (generally if the databse is not installed)
 */
function load_config() {
   global $CFG;
   global $OVERRIDDEN;    // array containing the config fields overridden by $CFG

   // Get a full list of overridden fields
   foreach ($CFG as $field => $value) {
        $OVERRIDDEN[] = $field;
   }

   $dbconfig = get_records_array('config', '', '', '', 'field, value');
   foreach ($dbconfig as $cfg) {
       if (!isset($CFG->{$cfg->field})) {
           $CFG->{$cfg->field} = $cfg->value;
       }
   }

   return true;
}

/**
 * This function returns a value from $CFG
 * or null if it is not found
 * 
 * @param string $key config setting to look for 
 * @return mixed
 */
function get_config($key) {
    global $CFG;
    if (isset($CFG->$key)) {
        return $CFG->$key;
    }
    return null;
}


/**
 * This function sets a config variable
 * both in $CFG and in the database
 *
 * @param string $key config field to set
 * @param string $value config value
 */
function set_config($key, $value) {
    global $CFG;

    db_ignore_sql_exceptions(true);
    if (get_record('config', 'field', $key)) {
        if (set_field('config', 'value', $value, 'field', $key)) {
            $status = true;
        }
    } 
    else {
        $config = new StdClass;
        $config->field = $key;
        $config->value = $value;
        $status = insert_record('config', $config);
    }
    db_ignore_sql_exceptions(false);

    if (!empty($status)) {
        $CFG->{$key} = $value;
        return true;
    }

    return false;
}

/**
 * This function returns a value for $CFG for a plugin
 * or null if it is not found.
 *
 * It will give precedence to config values set in config.php like so:
 * $cfg->plugin->{$plugintype}->{$pluginname}->{$key} = 'whatever';
 *
 * If it doesn't find one of those, it will look for the config value in
 * the database.
 *
 * @param string $plugintype eg artefact
 * @param string $pluginname eg blog
 * @param string $key the config setting to look for
 * @return mixed The value of the key if found, or NULL if not found
 */
function get_config_plugin($plugintype, $pluginname, $key) {
    global $CFG;

    // If we've already fetched this value, then return it
    if (isset($CFG->plugin->{$plugintype}->{$pluginname}->{$key})) {
        return $CFG->plugin->{$plugintype}->{$pluginname}->{$key};
    }
    // If we have already fetched this plugin's data from the database, then return NULL.
    // (Note that some values may come from config.php before we hit the database.)
    else if (isset($CFG->plugin->pluginsfetched->{$plugintype}->{$pluginname})) {
        return null;
    }
    // We haven't fetched this plugin's data yet. So do it!
    else {

        // First build the object structure for it.
        if (!isset($CFG->plugin)) {
            $CFG->plugin = new stdClass();
        }
        if (!isset($CFG->plugin->{$plugintype})) {
            $CFG->plugin->{$plugintype} = new stdClass();
        }
        if (!isset($CFG->plugin->{$plugintype}->{$pluginname})) {
            $CFG->plugin->{$plugintype}->{$pluginname} = new stdClass();
        }

        // To minimize database calls, get all the records for this plugin from the database at once.
        $records = get_records_array($plugintype . '_config', 'plugin', $pluginname, 'field');
        if (!empty($records)) {
            foreach ($records as $record) {
                if (!isset($CFG->plugin->{$plugintype}->{$pluginname}->{$record->field})) {
                    $CFG->plugin->{$plugintype}->{$pluginname}->{$record->field} = $record->value;
                }
            }
        }

        // Make a note that we've now hit the database over this one.
        if (!isset($CFG->plugin->pluginsfetched)) {
            $CFG->plugin->pluginsfetched = new stdClass();
        }
        if (!isset($CFG->plugin->pluginsfetched->{$plugintype})) {
            $CFG->plugin->pluginsfetched->{$plugintype} = new stdClass();
        }
        $CFG->plugin->pluginsfetched->{$plugintype}->{$pluginname} = true;

        // Now, return it if we found it, otherwise null.
        // (This could be done by a recursive call to get_config_plugin(), but it's
        // less error-prone to do it this way and it doesn't cause that much duplication)
        if (isset($CFG->plugin->{$plugintype}->{$pluginname}->{$key})) {
            return $CFG->plugin->{$plugintype}->{$pluginname}->{$key};
        }
        else {
            return null;
        }
    }
}

function set_config_plugin($plugintype, $pluginname, $key, $value) {
    global $CFG;
    $table = $plugintype . '_config';

    if (false !== get_field($table, 'value', 'plugin', $pluginname, 'field', $key)) {
        //if (set_field($table, 'value', $key, 'plugin', $pluginname, 'field', $value)) {
        if (set_field($table, 'value', $value, 'plugin', $pluginname, 'field', $key)) {
            $status = true;
        }
    }
    else {
        $pconfig = new StdClass;
        $pconfig->plugin = $pluginname;
        $pconfig->field  = $key;
        $pconfig->value  = $value;
        $status = insert_record($table, $pconfig);
    }
    // Now update the cached version
    if ($status) {
        if (!isset($CFG->plugin)) {
            $CFG->plugin = new stdClass();
        }
        if (!isset($CFG->plugin->{$plugintype})) {
            $CFG->plugin->{$plugintype} = new stdClass();
        }
        if (!isset($CFG->plugin->{$plugintype}->{$pluginname})) {
            $CFG->plugin->{$plugintype}->{$pluginname} = new stdClass();
        }

        $CFG->plugin->{$plugintype}->{$pluginname}->{$key} = $value;
        return true;
    }
    return false;
}

/**
 * This function returns a value for $CFG for a plugin instance
 * or null if it is not found. Initially this is interesting only 
 * for multiauth. Note that it may go and look in the database
 *
 * @param string $plugintype   E.g. auth
 * @param string $pluginname   E.g. internal
 * @param string $pluginid     Instance id
 * @param string $key          The config setting to look for
 */
function get_config_plugin_instance($plugintype, $pluginid, $key) {
    global $CFG;

    // Must be unlikely to exist as a config option for any plugin
    $instance = '_i_n_s_t'.$pluginid;

    // Suppress NOTICE with @ in case $key is not yet cached
    @$value = $CFG->plugin->{$plugintype}->{$instance}->{$key};
    if (isset($value)) {
        return $value;
    }

    $records = get_records_array($plugintype . '_instance_config', 'instance', $pluginid, 'field', 'field, value');
    if (!empty($records)) {
        foreach($records as $record) {
            $CFG->plugin->{$plugintype}->{$instance}->{$record->field} = $record->value;
            if ($record->field == $key) {
                $value = $record->value;
            }
        }
    }

    return $value;
}

/**
 * This function returns a value for $CFG for a plugin instance
 * or null if it is not found. Initially this is interesting only 
 * for multiauth. Note that it may go and look in the database
 *
 * @param string $plugintype   E.g. auth
 * @param string $pluginname   E.g. internal
 * @param string $pluginid     Instance id
 * @param string $key          The config setting to look for
 */
function set_config_plugin_instance($plugintype, $pluginname, $pluginid, $key, $value) {
    global $CFG;
    $table = $plugintype . '_instance_config';

    if (false !== get_field($table, 'value', 'instance', $pluginid, 'field', $key)) {
        if (set_field($table, 'value', $value, 'instance', $pluginid, 'field', $key)) {
            $status = true;
        }
    }
    else {
        $pconfig = new StdClass;
        $pconfig->instance = $pluginid;
        $pconfig->field  = $key;
        $pconfig->value  = $value;
        $status = insert_record($table, $pconfig);
    }
    if ($status) {
        // Must be unlikely to exist as a config option for any plugin
        $instance = '_i_n_s_t'.$pluginid;
        $CFG->plugin->{$plugintype}->{$pluginname}->{$instance}->{$key} = $value;
        return true;
    }
    return false;
}

/**
 * Fetch an institution configuration (from either the "institution" or "institution_config" table)
 *
 * TODO: If needed, create a corresponding set_config_institution(). This would be most useful if there's
 * a situation where you need to manipulate individual institution configs. If you want to manipulate
 * them in batch, you can use the Institution class's __set() and commit() methods.
 *
 * @param string $institutionname
 * @param string $key
 * @return mixed The value of the key or NULL if the key is not valid
 */
function get_config_institution($institutionname, $key) {
    global $CFG;
    require_once(get_config('docroot').'/lib/institution.php');

    // First, check the cache for an Institution object with this name
    if (isset($CFG->fetchedinst->{$institutionname})) {
        $inst = $CFG->fetchedinst->{$institutionname};
    }
    else {
        // No cache hit, so instatiate a new Institution object
        try {
            $inst = new Institution($institutionname);

            // Cache it (in $CFG so if we ever write set_config_institution() we can make it update the cache)
            if (!isset($CFG->fetchedinst)) {
                $CFG->fetchedinst = new stdClass();
            }
            $CFG->fetchedinst->{$institutionname} = $inst;
        }
        catch (ParamOutOfRangeException $e) {
            return null;
        }
    }

    // Use the magical __get() function of the Institution class
    return $inst->{$key};
}


/**
 * Fetch a config setting for the specified user's institutions (from either the "institution" or "institution_config" table)
 *
 * @param string $key
 * @param int $userid (Optional) If not supplied, fetch for the current user's institutions
 * @return array The results for the all the users' institutions, in the order
 *               supplied by load_user_institutions(). Array key is institution name.
 */
function get_configs_user_institutions($key, $userid = null) {
    global $USER, $CFG;
    if ($userid === null) {
        $userid = $USER->id;
    }

    // Check for the user and key in the cache (The cache is stored in $CFG so it can be cleared/updated
    // if we ever write a set_config_institution() method)
    $userobj = "user{$userid}";
    if (isset($CFG->userinstconf->{$userobj}->{$key})) {
        return $CFG->userinstconf->{$userobj}->{$key};
    }

    // We didn't hit the cache, so retrieve the config from their
    // institution.

    // First, get a list of their institution names
    if (!$userid) {
        // The logged-out user has no institutions.
        $institutions = false;
    }
    else if ($userid == $USER->id) {
        // Institutions for current logged-in user
        $institutions = $USER->get('institutions');
    }
    else {
        $institutions = load_user_institutions($userid);
    }

    // If the user belongs to no institution, check the Mahara institution
    if (!$institutions) {
        // For compatibility with $USER->get('institutions') and
        // load_user_institutions(), we only really care about the
        // array keys
        $institutions = array('mahara' => 'mahara');
    }
    $results = array();
    foreach ($institutions as $instname => $inst) {
        $results[$instname] = get_config_institution($instname, $key);
    }

    // Cache the result
    if (!isset($CFG->userinstconf)) {
        $CFG->userinstconf = new stdClass();
    }
    if (!isset($CFG->userinstconf->{$userobj})) {
        $CFG->userinstconf->{$userobj} = new stdClass();
    }
    $CFG->userinstconf->{$userobj}->{$key} = $results;

    return $results;
}


/**
 * This function prints an array or object
 * wrapped inside <pre></pre>
 * 
 * @param $mixed value to print
 */
function print_object($mixed) {
    echo '<pre>';
    print_r($mixed);
    echo '</pre>';
}

/**
 * Reads the locales string from a language pack and attempts to set the current locale
 * based on the contents of that string.
 *
 * @param string $lang
 */
function set_locale_for_language($lang) {
    if (empty($lang)) {
        return;
    }

    if ($args = explode(',', get_string_location('locales', 'langconfig', array(), 'raw_langstring', $lang))) {
        array_unshift($args, LC_ALL);
        call_user_func_array('setlocale', $args);
    }
}

/**
 * This function returns the current language to use, either for a given user
 * or sitewide, or the default.
 *
 * This method is invoked in every call to get_string(), so make it performant!
 *
 * @return string
 */
function current_language() {
    global $USER, $CFG, $SESSION;

    static $userlang, $lastlang, $instlang;

    $loggedin = $USER instanceof User && $USER->is_logged_in();

    // Retrieve & cache the user lang pref (if the user is logged in)
    if (!isset($userlang) && $loggedin) {
        $userlang = $USER->get_account_preference('lang');
        if ($userlang !== null && $userlang != 'default') {
            if (!language_installed($userlang)) {
                $USER->set_account_preference('lang', 'default');
                $userlang = 'default';
            }
        }
    }

    // Retrieve & cache the institution language (if the user is logged in)
    if (!isset($instlang) && $loggedin) {
        $instlang = get_user_institution_language();
    }

    // Retrieve the $SESSION lang (from the user selecting a language while logged-out)
    // Note that if the user selected a language while logged out, and then logs in,
    // we will have set their user account pref to match that lang, over in
    // LiveUser->authenticate().
    if (!$loggedin && is_a($SESSION, 'Session')) {
        $sesslang = $SESSION->get('lang');
    }
    else {
        $sesslang = null;
    }

    // Logged-in user's language preference
    if (!empty($userlang) && $userlang != 'default') {
        $lang = $userlang;
    }
    // Logged-out user's language menu selection
    else if (!empty($sesslang) && $sesslang != 'default') {
        $lang = $sesslang;
    }
    // Logged-in user's institution language setting
    else if (!empty($instlang) && $instlang != 'default') {
        $lang = $instlang;
    }

    // If there's no language from the user pref or the logged-out lang menu...
    if (empty($lang)) {
        $lang = !empty($CFG->lang) ? $CFG->lang : 'en.utf8';
    }

    if ($lang == $lastlang) {
        return $lang;
    }

    set_locale_for_language($lang);

    return $lastlang = $lang;
}