lib/moodlelib.php

   1 <?php // $Id$
   2
   3 ///////////////////////////////////////////////////////////////////////////
   4 //                                                                       //
   5 // NOTICE OF COPYRIGHT                                                   //
   6 //                                                                       //
   7 // Moodle - Modular Object-Oriented Dynamic Learning Environment         //
   8 //          http://moodle.org                                            //
   9 //                                                                       //
  10 // Copyright (C) 1999-2004  Martin Dougiamas  http://dougiamas.com       //
  11 //                                                                       //
  12 // This program is free software; you can redistribute it and/or modify  //
  13 // it under the terms of the GNU General Public License as published by  //
  14 // the Free Software Foundation; either version 2 of the License, or     //
  15 // (at your option) any later version.                                   //
  16 //                                                                       //
  17 // This program is distributed in the hope that it will be useful,       //
  18 // but WITHOUT ANY WARRANTY; without even the implied warranty of        //
  19 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         //
  20 // GNU General Public License for more details:                          //
  21 //                                                                       //
  22 //          http://www.gnu.org/copyleft/gpl.html                         //
  23 //                                                                       //
  24 ///////////////////////////////////////////////////////////////////////////
  25
  26 /**
  27  * moodlelib.php - Moodle main library
  28  *
  29  * Main library file of miscellaneous general-purpose Moodle functions.
  30  * Other main libraries:
  31  *  - weblib.php      - functions that produce web output
  32  *  - datalib.php     - functions that access the database
  33  * @author Martin Dougiamas
  34  * @version $Id$
  35  * @license http://www.gnu.org/copyleft/gpl.html GNU Public License
  36  * @package moodlecore
  37  */
  38
  39 /// CONSTANTS (Encased in phpdoc proper comments)/////////////////////////
  40
  41 /**
  42  * Used by some scripts to check they are being called by Moodle
  43  */
  44 define('MOODLE_INTERNAL', true);
  45
  46 /**
  47  * No groups used?
  48  */
  49 define('NOGROUPS', 0);
  50
  51 /**
  52  * Groups used?
  53  */
  54 define('SEPARATEGROUPS', 1);
  55
  56 /**
  57  * Groups visible?
  58  */
  59 define('VISIBLEGROUPS', 2);
  60
  61 /// Date and time constants ///
  62 /**
  63  * Time constant - the number of seconds in a year
  64  */
  65
  66 define('YEARSECS', 31536000);
  67
  68 /**
  69  * Time constant - the number of seconds in a week
  70  */
  71 define('WEEKSECS', 604800);
  72
  73 /**
  74  * Time constant - the number of seconds in a day
  75  */
  76 define('DAYSECS', 86400);
  77
  78 /**
  79  * Time constant - the number of seconds in an hour
  80  */
  81 define('HOURSECS', 3600);
  82
  83 /**
  84  * Time constant - the number of seconds in a minute
  85  */
  86 define('MINSECS', 60);
  87
  88 /**
  89  * Time constant - the number of minutes in a day
  90  */
  91 define('DAYMINS', 1440);
  92
  93 /**
  94  * Time constant - the number of minutes in an hour
  95  */
  96 define('HOURMINS', 60);
  97
  98 /// Parameter constants - every call to optional_param(), required_param()  ///
  99 /// or clean_param() should have a specified type of parameter.  //////////////
 100
 101 /**
 102  * PARAM_RAW specifies a parameter that is not cleaned/processed in any way;
 103  * originally was 0, but changed because we need to detect unknown
 104  * parameter types and swiched order in clean_param().
 105  */
 106 define('PARAM_RAW', 666);
 107
 108 /**
 109  * PARAM_CLEAN - obsoleted, please try to use more specific type of parameter.
 110  * It was one of the first types, that is why it is abused so much ;-)
 111  */
 112 define('PARAM_CLEAN',    0x0001);
 113
 114 /**
 115  * PARAM_INT - integers only, use when expecting only numbers.
 116  */
 117 define('PARAM_INT',      0x0002);
 118
 119 /**
 120  * PARAM_INTEGER - an alias for PARAM_INT
 121  */
 122 define('PARAM_INTEGER',  0x0002);
 123
 124 /**
 125  * PARAM_NUMBER - a real/floating point number.
 126  */
 127 define('PARAM_NUMBER',  0x000a);
 128
 129 /**
 130  * PARAM_ALPHA - contains only english letters.
 131  */
 132 define('PARAM_ALPHA',    0x0004);
 133
 134 /**
 135  * PARAM_ACTION - an alias for PARAM_ALPHA, use for various actions in formas and urls
 136  * @TODO: should we alias it to PARAM_ALPHANUM ?
 137  */
 138 define('PARAM_ACTION',   0x0004);
 139
 140 /**
 141  * PARAM_FORMAT - an alias for PARAM_ALPHA, use for names of plugins, formats, etc.
 142  * @TODO: should we alias it to PARAM_ALPHANUM ?
 143  */
 144 define('PARAM_FORMAT',   0x0004);
 145
 146 /**
 147  * PARAM_NOTAGS - all html tags are stripped from the text. Do not abuse this type.
 148  */
 149 define('PARAM_NOTAGS',   0x0008);
 150
 151  /**
 152  * PARAM_MULTILANG - alias of PARAM_TEXT.
 153  */
 154 define('PARAM_MULTILANG',  0x0009);
 155
 156  /**
 157  * PARAM_TEXT - general plain text compatible with multilang filter, no other html tags.
 158  */
 159 define('PARAM_TEXT',  0x0009);
 160
 161 /**
 162  * PARAM_FILE - safe file name, all dangerous chars are stripped, protects against XSS, SQL injections and directory traversals
 163  */
 164 define('PARAM_FILE',     0x0010);
 165
 166 /**
 167  * PARAM_PATH - safe relative path name, all dangerous chars are stripped, protects against XSS, SQL injections and directory traversals
 168  * note: the leading slash is not removed, window drive letter is not allowed
 169  */
 170 define('PARAM_PATH',     0x0020);
 171
 172 /**
 173  * PARAM_HOST - expected fully qualified domain name (FQDN) or an IPv4 dotted quad (IP address)
 174  */
 175 define('PARAM_HOST',     0x0040);
 176
 177 /**
 178  * PARAM_URL - expected properly formatted URL.
 179  */
 180 define('PARAM_URL',      0x0080);
 181
 182 /**
 183  * PARAM_LOCALURL - expected properly formatted URL as well as one that refers to the local server itself. (NOT orthogonal to the others! Implies PARAM_URL!)
 184  */
 185 define('PARAM_LOCALURL', 0x0180);
 186
 187 /**
 188  * PARAM_CLEANFILE - safe file name, all dangerous and regional chars are removed,
 189  * use when you want to store a new file submitted by students
 190  */
 191 define('PARAM_CLEANFILE',0x0200);
 192
 193 /**
 194  * PARAM_ALPHANUM - expected numbers and letters only.
 195  */
 196 define('PARAM_ALPHANUM', 0x0400);
 197
 198 /**
 199  * PARAM_BOOL - converts input into 0 or 1, use for switches in forms and urls.
 200  */
 201 define('PARAM_BOOL',     0x0800);
 202
 203 /**
 204  * PARAM_CLEANHTML - cleans submitted HTML code and removes slashes
 205  * note: do not forget to addslashes() before storing into database!
 206  */
 207 define('PARAM_CLEANHTML',0x1000);
 208
 209 /**
 210  * PARAM_ALPHAEXT the same contents as PARAM_ALPHA plus the chars in quotes: "/-_" allowed,
 211  * suitable for include() and require()
 212  * @TODO: should we rename this function to PARAM_SAFEDIRS??
 213  */
 214 define('PARAM_ALPHAEXT', 0x2000);
 215
 216 /**
 217  * PARAM_SAFEDIR - safe directory name, suitable for include() and require()
 218  */
 219 define('PARAM_SAFEDIR',  0x4000);
 220
 221 /**
 222  * PARAM_SEQUENCE - expects a sequence of numbers like 8 to 1,5,6,4,6,8,9.  Numbers and comma only.
 223  */
 224 define('PARAM_SEQUENCE',  0x8000);
 225
 226 /**
 227  * PARAM_PEM - Privacy Enhanced Mail format
 228  */
 229 define('PARAM_PEM',      0x10000);
 230
 231 /**
 232  * PARAM_BASE64 - Base 64 encoded format
 233  */
 234 define('PARAM_BASE64',   0x20000);
 235
 236
 237 /// Page types ///
 238 /**
 239  * PAGE_COURSE_VIEW is a definition of a page type. For more information on the page class see moodle/lib/pagelib.php.
 240  */
 241 define('PAGE_COURSE_VIEW', 'course-view');
 242
 243 /// Debug levels ///
 244 /** no warnings at all */
 245 define ('DEBUG_NONE', 0);
 246 /** E_ERROR | E_PARSE */
 247 define ('DEBUG_MINIMAL', 5);
 248 /** E_ERROR | E_PARSE | E_WARNING | E_NOTICE */
 249 define ('DEBUG_NORMAL', 15);
 250 /** E_ALL without E_STRICT and E_RECOVERABLE_ERROR for now */
 251 define ('DEBUG_ALL', 2047);
 252 /** DEBUG_ALL with extra Moodle debug messages - (DEBUG_ALL | 32768) */
 253 define ('DEBUG_DEVELOPER', 34815);
 254
 255 /**
 256  * Blog access level constant declaration
 257  */
 258 define ('BLOG_USER_LEVEL', 1);
 259 define ('BLOG_GROUP_LEVEL', 2);
 260 define ('BLOG_COURSE_LEVEL', 3);
 261 define ('BLOG_SITE_LEVEL', 4);
 262 define ('BLOG_GLOBAL_LEVEL', 5);
 263
 264 /**
 265  * Authentication - error codes for user confirm
 266  */
 267 define('AUTH_CONFIRM_FAIL', 0);
 268 define('AUTH_CONFIRM_OK', 1);
 269 define('AUTH_CONFIRM_ALREADY', 2);
 270 define('AUTH_CONFIRM_ERROR', 3);
 271
 272
 273
 274 /// PARAMETER HANDLING ////////////////////////////////////////////////////
 275
 276 /**
 277  * Returns a particular value for the named variable, taken from
 278  * POST or GET.  If the parameter doesn't exist then an error is
 279  * thrown because we require this variable.
 280  *
 281  * This function should be used to initialise all required values
 282  * in a script that are based on parameters.  Usually it will be
 283  * used like this:
 284  *    $id = required_param('id');
 285  *
 286  * @param string $parname the name of the page parameter we want
 287  * @param int $type expected type of parameter
 288  * @return mixed
 289  */
 290 function required_param($parname, $type=PARAM_CLEAN) {
 291
 292     // detect_unchecked_vars addition
 293     global $CFG;
 294     if (!empty($CFG->detect_unchecked_vars)) {
 295         global $UNCHECKED_VARS;
 296         unset ($UNCHECKED_VARS->vars[$parname]);
 297     }
 298
 299     if (isset($_POST[$parname])) {       // POST has precedence
 300         $param = $_POST[$parname];
 301     } else if (isset($_GET[$parname])) {
 302         $param = $_GET[$parname];
 303     } else {
 304         error('A required parameter ('.$parname.') was missing');
 305     }
 306
 307     return clean_param($param, $type);
 308 }
 309
 310 /**
 311  * Returns a particular value for the named variable, taken from
 312  * POST or GET, otherwise returning a given default.
 313  *
 314  * This function should be used to initialise all optional values
 315  * in a script that are based on parameters.  Usually it will be
 316  * used like this:
 317  *    $name = optional_param('name', 'Fred');
 318  *
 319  * @param string $parname the name of the page parameter we want
 320  * @param mixed  $default the default value to return if nothing is found
 321  * @param int $type expected type of parameter
 322  * @return mixed
 323  */
 324 function optional_param($parname, $default=NULL, $type=PARAM_CLEAN) {
 325
 326     // detect_unchecked_vars addition
 327     global $CFG;
 328     if (!empty($CFG->detect_unchecked_vars)) {
 329         global $UNCHECKED_VARS;
 330         unset ($UNCHECKED_VARS->vars[$parname]);
 331     }
 332
 333     if (isset($_POST[$parname])) {       // POST has precedence
 334         $param = $_POST[$parname];
 335     } else if (isset($_GET[$parname])) {
 336         $param = $_GET[$parname];
 337     } else {
 338         return $default;
 339     }
 340
 341     return clean_param($param, $type);
 342 }
 343
 344 /**
 345  * Used by {@link optional_param()} and {@link required_param()} to
 346  * clean the variables and/or cast to specific types, based on
 347  * an options field.
 348  * <code>
 349  * $course->format = clean_param($course->format, PARAM_ALPHA);
 350  * $selectedgrade_item = clean_param($selectedgrade_item, PARAM_CLEAN);
 351  * </code>
 352  *
 353  * @uses $CFG
 354  * @uses PARAM_CLEAN
 355  * @uses PARAM_INT
 356  * @uses PARAM_INTEGER
 357  * @uses PARAM_ALPHA
 358  * @uses PARAM_ALPHANUM
 359  * @uses PARAM_NOTAGS
 360  * @uses PARAM_ALPHAEXT
 361  * @uses PARAM_BOOL
 362  * @uses PARAM_SAFEDIR
 363  * @uses PARAM_CLEANFILE
 364  * @uses PARAM_FILE
 365  * @uses PARAM_PATH
 366  * @uses PARAM_HOST
 367  * @uses PARAM_URL
 368  * @uses PARAM_LOCALURL
 369  * @uses PARAM_CLEANHTML
 370  * @uses PARAM_SEQUENCE
 371  * @param mixed $param the variable we are cleaning
 372  * @param int $type expected format of param after cleaning.
 373  * @return mixed
 374  */
 375 function clean_param($param, $type) {
 376
 377     global $CFG;
 378
 379     if (is_array($param)) {              // Let's loop
 380         $newparam = array();
 381         foreach ($param as $key => $value) {
 382             $newparam[$key] = clean_param($value, $type);
 383         }
 384         return $newparam;
 385     }
 386
 387     switch ($type) {
 388         case PARAM_RAW:          // no cleaning at all
 389             return $param;
 390
 391         case PARAM_CLEAN:        // General HTML cleaning, try to use more specific type if possible
 392             if (is_numeric($param)) {
 393                 return $param;
 394             }
 395             $param = stripslashes($param);   // Needed for kses to work fine
 396             $param = clean_text($param);     // Sweep for scripts, etc
 397             return addslashes($param);       // Restore original request parameter slashes
 398
 399         case PARAM_CLEANHTML:    // prepare html fragment for display, do not store it into db!!
 400             $param = stripslashes($param);   // Remove any slashes
 401             $param = clean_text($param);     // Sweep for scripts, etc
 402             return trim($param);
 403
 404         case PARAM_INT:
 405             return (int)$param;  // Convert to integer
 406
 407         case PARAM_NUMBER:
 408             return (float)$param;  // Convert to integer
 409
 410         case PARAM_ALPHA:        // Remove everything not a-z
 411             return eregi_replace('[^a-zA-Z]', '', $param);
 412
 413         case PARAM_ALPHANUM:     // Remove everything not a-zA-Z0-9
 414             return eregi_replace('[^A-Za-z0-9]', '', $param);
 415
 416         case PARAM_ALPHAEXT:     // Remove everything not a-zA-Z/_-
 417             return eregi_replace('[^a-zA-Z/_-]', '', $param);
 418
 419         case PARAM_SEQUENCE:     // Remove everything not 0-9,
 420             return eregi_replace('[^0-9,]', '', $param);
 421
 422         case PARAM_BOOL:         // Convert to 1 or 0
 423             $tempstr = strtolower($param);
 424             if ($tempstr == 'on' or $tempstr == 'yes' ) {
 425                 $param = 1;
 426             } else if ($tempstr == 'off' or $tempstr == 'no') {
 427                 $param = 0;
 428             } else {
 429                 $param = empty($param) ? 0 : 1;
 430             }
 431             return $param;
 432
 433         case PARAM_NOTAGS:       // Strip all tags
 434             return strip_tags($param);
 435
 436         case PARAM_TEXT:    // leave only tags needed for multilang
 437             return clean_param(strip_tags($param, '<lang><span>'), PARAM_CLEAN);
 438
 439         case PARAM_SAFEDIR:      // Remove everything not a-zA-Z0-9_-
 440             return eregi_replace('[^a-zA-Z0-9_-]', '', $param);
 441
 442         case PARAM_CLEANFILE:    // allow only safe characters
 443             return clean_filename($param);
 444
 445         case PARAM_FILE:         // Strip all suspicious characters from filename
 446             $param = ereg_replace('[[:cntrl:]]|[<>"`\|\':\\/]', '', $param);
 447             $param = ereg_replace('\.\.+', '', $param);
 448             if($param == '.') {
 449                 $param = '';
 450             }
 451             return $param;
 452
 453         case PARAM_PATH:         // Strip all suspicious characters from file path
 454             $param = str_replace('\\\'', '\'', $param);
 455             $param = str_replace('\\"', '"', $param);
 456             $param = str_replace('\\', '/', $param);
 457             $param = ereg_replace('[[:cntrl:]]|[<>"`\|\':]', '', $param);
 458             $param = ereg_replace('\.\.+', '', $param);
 459             $param = ereg_replace('//+', '/', $param);
 460             return ereg_replace('/(\./)+', '/', $param);
 461
 462         case PARAM_HOST:         // allow FQDN or IPv4 dotted quad
 463             preg_replace('/[^\.\d\w-]/','', $param ); // only allowed chars
 464             // match ipv4 dotted quad
 465             if (preg_match('/(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})/',$param, $match)){
 466                 // confirm values are ok
 467                 if ( $match[0] > 255
 468                      || $match[1] > 255
 469                      || $match[3] > 255
 470                      || $match[4] > 255 ) {
 471                     // hmmm, what kind of dotted quad is this?
 472                     $param = '';
 473                 }
 474             } elseif ( preg_match('/^[\w\d\.-]+$/', $param) // dots, hyphens, numbers
 475                        && !preg_match('/^[\.-]/',  $param) // no leading dots/hyphens
 476                        && !preg_match('/[\.-]$/',  $param) // no trailing dots/hyphens
 477                        ) {
 478                 // all is ok - $param is respected
 479             } else {
 480                 // all is not ok...
 481                 $param='';
 482             }
 483             return $param;
 484
 485         case PARAM_URL:          // allow safe ftp, http, mailto urls
 486             include_once($CFG->dirroot . '/lib/validateurlsyntax.php');
 487             if (!empty($param) && validateUrlSyntax($param, 's?H?S?F?E?u-P-a?I?p?f?q?r?')) {
 488                 // all is ok, param is respected
 489             } else {
 490                 $param =''; // not really ok
 491             }
 492             return $param;
 493
 494         case PARAM_LOCALURL:     // allow http absolute, root relative and relative URLs within wwwroot
 495             clean_param($param, PARAM_URL);
 496             if (!empty($param)) {
 497                 if (preg_match(':^/:', $param)) {
 498                     // root-relative, ok!
 499                 } elseif (preg_match('/^'.preg_quote($CFG->wwwroot, '/').'/i',$param)) {
 500                     // absolute, and matches our wwwroot
 501                 } else {
 502                     // relative - let's make sure there are no tricks
 503                     if (validateUrlSyntax($param, 's-u-P-a-p-f+q?r?')) {
 504                         // looks ok.
 505                     } else {
 506                         $param = '';
 507                     }
 508                 }
 509             }
 510             return $param;
 511         case PARAM_PEM:
 512             $param = trim($param);
 513             // PEM formatted strings may contain letters/numbers and the symbols
 514             // forward slash: /
 515             // plus sign:     +
 516             // equal sign:    =
 517             // , surrounded by BEGIN and END CERTIFICATE prefix and suffixes
 518             if (preg_match('/^-----BEGIN CERTIFICATE-----([\s\w\/\+=]+)-----END CERTIFICATE-----$/', trim($param), $matches)) {
 519                 list($wholething, $body) = $matches;
 520                 unset($wholething, $matches);
 521                 $b64 = clean_param($body, PARAM_BASE64);
 522                 if (!empty($b64)) {
 523                     return "-----BEGIN CERTIFICATE-----\n$b64\n-----END CERTIFICATE-----\n";
 524                 } else {
 525                     return '';
 526                 }
 527             }
 528             return '';
 529         case PARAM_BASE64:
 530             if (!empty($param)) {
 531                 // PEM formatted strings may contain letters/numbers and the symbols
 532                 // forward slash: /
 533                 // plus sign:     +
 534                 // equal sign:    =
 535                 if (0 >= preg_match('/^([\s\w\/\+=]+)$/', trim($param))) {
 536                     return '';
 537                 }
 538                 $lines = preg_split('/[\s]+/', $param, -1, PREG_SPLIT_NO_EMPTY);
 539                 // Each line of base64 encoded data must be 64 characters in
 540                 // length, except for the last line which may be less than (or
 541                 // equal to) 64 characters long.
 542                 for ($i=0, $j=count($lines); $i < $j; $i++) {
 543                     if ($i + 1 == $j) {
 544                         if (64 < strlen($lines[$i])) {
 545                             return '';
 546                         }
 547                         continue;
 548                     }
 549
 550                     if (64 != strlen($lines[$i])) {
 551                         return '';
 552                     }
 553                 }
 554                 return implode("\n",$lines);
 555             } else {
 556                 return '';
 557             }
 558         default:                 // throw error, switched parameters in optional_param or another serious problem
 559             error("Unknown parameter type: $type");
 560     }
 561 }
 562
 563
 564
 565 /**
 566  * Set a key in global configuration
 567  *
 568  * Set a key/value pair in both this session's {@link $CFG} global variable
 569  * and in the 'config' database table for future sessions.
 570  *
 571  * Can also be used to update keys for plugin-scoped configs in config_plugin table.
 572  * In that case it doesn't affect $CFG.
 573  *
 574  * @param string $name the key to set
 575  * @param string $value the value to set (without magic quotes)
 576  * @param string $plugin (optional) the plugin scope
 577  * @uses $CFG
 578  * @return bool
 579  */
 580 function set_config($name, $value, $plugin=NULL) {
 581 /// No need for get_config because they are usually always available in $CFG
 582
 583     global $CFG;
 584
 585     if (empty($plugin)) {
 586         $CFG->$name = $value;  // So it's defined for this invocation at least
 587
 588         if (get_field('config', 'name', 'name', $name)) {
 589             return set_field('config', 'value', addslashes($value), 'name', $name);
 590         } else {
 591             $config = new object();
 592             $config->name = $name;
 593             $config->value = addslashes($value);
 594             return insert_record('config', $config);
 595         }
 596     } else { // plugin scope
 597         if ($id = get_field('config_plugins', 'id', 'name', $name, 'plugin', $plugin)) {
 598             return set_field('config_plugins', 'value', addslashes($value), 'id', $id);
 599         } else {
 600             $config = new object();
 601             $config->plugin = addslashes($plugin);
 602             $config->name   = $name;
 603             $config->value  = addslashes($value);
 604             return insert_record('config_plugins', $config);
 605         }
 606     }
 607 }
 608
 609 /**
 610  * Get configuration values from the global config table
 611  * or the config_plugins table.
 612  *
 613  * If called with no parameters it will do the right thing
 614  * generating $CFG safely from the database without overwriting
 615  * existing values.
 616  *
 617  * If called with 2 parameters it will return a $string single
 618  * value or false of the value is not found.
 619  *
 620  * @param string $plugin
 621  * @param string $name
 622  * @uses $CFG
 623  * @return hash-like object or single value
 624  *
 625  */
 626 function get_config($plugin=NULL, $name=NULL) {
 627
 628     global $CFG;
 629
 630     if (!empty($name)) { // the user is asking for a specific value
 631         if (!empty($plugin)) {
 632             return get_field('config_plugins', 'value', 'plugin' , $plugin, 'name', $name);
 633         } else {
 634             return get_field('config', 'value', 'name', $name);
 635         }
 636     }
 637
 638     // the user is after a recordset
 639     if (!empty($plugin)) {
 640         if ($configs=get_records('config_plugins', 'plugin', $plugin, '', 'name,value')) {
 641             $configs = (array)$configs;
 642             $localcfg = array();
 643             foreach ($configs as $config) {
 644                 $localcfg[$config->name] = $config->value;
 645             }
 646             return (object)$localcfg;
 647         } else {
 648             return false;
 649         }
 650     } else {
 651         // this was originally in setup.php
 652         if ($configs = get_records('config')) {
 653             $localcfg = (array)$CFG;
 654             foreach ($configs as $config) {
 655                 if (!isset($localcfg[$config->name])) {
 656                     $localcfg[$config->name] = $config->value;
 657                 } else {
 658                     if ($localcfg[$config->name] != $config->value ) {
 659                         // complain if the DB has a different
 660                         // value than config.php does
 661                         error_log("\$CFG->{$config->name} in config.php ({$localcfg[$config->name]}) overrides database setting ({$config->value})");
 662                     }
 663                 }
 664             }
 665
 666             $localcfg = (object)$localcfg;
 667             return $localcfg;
 668         } else {
 669             // preserve $CFG if DB returns nothing or error
 670             return $CFG;
 671         }
 672
 673     }
 674 }
 675
 676 /**
 677  * Removes a key from global configuration
 678  *
 679  * @param string $name the key to set
 680  * @param string $plugin (optional) the plugin scope
 681  * @uses $CFG
 682  * @return bool
 683  */
 684 function unset_config($name, $plugin=NULL) {
 685
 686     global $CFG;
 687
 688     unset($CFG->$name);
 689
 690     if (empty($plugin)) {
 691         return delete_records('config', 'name', $name);
 692     } else {
 693         return delete_records('config_plugins', 'name', $name, 'plugin', $plugin);
 694     }
 695 }
 696
 697
 698 /**
 699  * Refresh current $USER session global variable with all their current preferences.
 700  * @uses $USER
 701  */
 702 function reload_user_preferences() {
 703
 704     global $USER;
 705
 706     //reset preference
 707     $USER->preference = array();
 708
 709     if (!isloggedin() or isguestuser()) {
 710         // no pernament storage for not-logged-in user and guest
 711
 712     } else if ($preferences = get_records('user_preferences', 'userid', $USER->id)) {
 713         foreach ($preferences as $preference) {
 714             $USER->preference[$preference->name] = $preference->value;
 715         }
 716     }
 717
 718     return true;
 719 }
 720
 721 /**
 722  * Sets a preference for the current user
 723  * Optionally, can set a preference for a different user object
 724  * @uses $USER
 725  * @todo Add a better description and include usage examples. Add inline links to $USER and user functions in above line.
 726
 727  * @param string $name The key to set as preference for the specified user
 728  * @param string $value The value to set forthe $name key in the specified user's record
 729  * @param int $otheruserid A moodle user ID
 730  * @return bool
 731  */
 732 function set_user_preference($name, $value, $otheruserid=NULL) {
 733
 734     global $USER;
 735
 736     if (!isset($USER->preference)) {
 737         reload_user_preferences();
 738     }
 739
 740     if (empty($name)) {
 741         return false;
 742     }
 743
 744     $nostore = false;
 745
 746     if (empty($otheruserid)){
 747         if (!isloggedin() or isguestuser()) {
 748             $nostore = true;
 749         }
 750         $userid = $USER->id;
 751     } else {
 752         if (isguestuser($otheruserid)) {
 753             $nostore = true;
 754         }
 755         $userid = $otheruserid;
 756     }
 757
 758     $return = true;
 759     if ($nostore) {
 760         // no pernament storage for not-logged-in user and guest
 761
 762     } else if ($preference = get_record('user_preferences', 'userid', $userid, 'name', addslashes($name))) {
 763         if (!set_field('user_preferences', 'value', addslashes((string)$value), 'id', $preference->id)) {
 764             $return = false;
 765         }
 766
 767     } else {
 768         $preference = new object();
 769         $preference->userid = $userid;
 770         $preference->name   = addslashes($name);
 771         $preference->value  = addslashes((string)$value);
 772         if (!insert_record('user_preferences', $preference)) {
 773             $return = false;
 774         }
 775     }
 776
 777     // update value in USER session if needed
 778     if ($userid == $USER->id) {
 779         $USER->preference[$name] = (string)$value;
 780     }
 781
 782     return $return;
 783 }
 784
 785 /**
 786  * Unsets a preference completely by deleting it from the database
 787  * Optionally, can set a preference for a different user id
 788  * @uses $USER
 789  * @param string  $name The key to unset as preference for the specified user
 790  * @param int $otheruserid A moodle user ID
 791  */
 792 function unset_user_preference($name, $otheruserid=NULL) {
 793
 794     global $USER;
 795
 796     if (!isset($USER->preference)) {
 797         reload_user_preferences();
 798     }
 799
 800     if (empty($otheruserid)){
 801         $userid = $USER->id;
 802     } else {
 803         $userid = $otheruserid;
 804     }
 805
 806     //Delete the preference from $USER if needed
 807     if ($userid == $USER->id) {
 808         unset($USER->preference[$name]);
 809     }
 810
 811     //Then from DB
 812     return delete_records('user_preferences', 'userid', $userid, 'name', addslashes($name));
 813 }
 814
 815
 816 /**
 817  * Sets a whole array of preferences for the current user
 818  * @param array $prefarray An array of key/value pairs to be set
 819  * @param int $otheruserid A moodle user ID
 820  * @return bool
 821  */
 822 function set_user_preferences($prefarray, $otheruserid=NULL) {
 823
 824     if (!is_array($prefarray) or empty($prefarray)) {
 825         return false;
 826     }
 827
 828     $return = true;
 829     foreach ($prefarray as $name => $value) {
 830         // The order is important; test for return is done first
 831         $return = (set_user_preference($name, $value, $otheruserid) && $return);
 832     }
 833     return $return;
 834 }
 835
 836 /**
 837  * If no arguments are supplied this function will return
 838  * all of the current user preferences as an array.
 839  * If a name is specified then this function
 840  * attempts to return that particular preference value.  If
 841  * none is found, then the optional value $default is returned,
 842  * otherwise NULL.
 843  * @param string $name Name of the key to use in finding a preference value
 844  * @param string $default Value to be returned if the $name key is not set in the user preferences
 845  * @param int $otheruserid A moodle user ID
 846  * @uses $USER
 847  * @return string
 848  */
 849 function get_user_preferences($name=NULL, $default=NULL, $otheruserid=NULL) {
 850     global $USER;
 851
 852     if (!isset($USER->preference)) {
 853         reload_user_preferences();
 854     }
 855
 856     if (empty($otheruserid)){
 857         $userid = $USER->id;
 858     } else {
 859         $userid = $otheruserid;
 860     }
 861
 862     if ($userid == $USER->id) {
 863         $preference = $USER->preference;
 864
 865     } else {
 866         $preference = array();
 867         if ($prefdata = get_records('user_preferences', 'userid', $userid)) {
 868             foreach ($prefdata as $pref) {
 869                 $preference[$pref->name] = $pref->value;
 870             }
 871         }
 872     }
 873
 874     if (empty($name)) {
 875         return $preference;            // All values
 876
 877     } else if (array_key_exists($name, $preference)) {
 878         return $preference[$name];    // The single value
 879
 880     } else {
 881         return $default;              // Default value (or NULL)
 882     }
 883 }
 884
 885
 886 /// FUNCTIONS FOR HANDLING TIME ////////////////////////////////////////////
 887
 888 /**
 889  * Given date parts in user time produce a GMT timestamp.
 890  *
 891  * @param int $year The year part to create timestamp of
 892  * @param int $month The month part to create timestamp of
 893  * @param int $day The day part to create timestamp of
 894  * @param int $hour The hour part to create timestamp of
 895  * @param int $minute The minute part to create timestamp of
 896  * @param int $second The second part to create timestamp of
 897  * @param float $timezone ?
 898  * @param bool $applydst ?
 899  * @return int timestamp
 900  * @todo Finish documenting this function
 901  */
 902 function make_timestamp($year, $month=1, $day=1, $hour=0, $minute=0, $second=0, $timezone=99, $applydst=true) {
 903
 904     $timezone = get_user_timezone_offset($timezone);
 905
 906     if (abs($timezone) > 13) {
 907         $time = mktime((int)$hour, (int)$minute, (int)$second, (int)$month, (int)$day, (int)$year);
 908     } else {
 909         $time = gmmktime((int)$hour, (int)$minute, (int)$second, (int)$month, (int)$day, (int)$year);
 910         $time = usertime($time, $timezone);
 911         if($applydst) {
 912             $time -= dst_offset_on($time);
 913         }
 914     }
 915
 916     return $time;
 917
 918 }
 919
 920 /**
 921  * Given an amount of time in seconds, returns string
 922  * formatted nicely as weeks, days, hours etc as needed
 923  *
 924  * @uses MINSECS
 925  * @uses HOURSECS
 926  * @uses DAYSECS
 927  * @uses YEARSECS
 928  * @param int $totalsecs ?
 929  * @param array $str ?
 930  * @return string
 931  */
 932  function format_time($totalsecs, $str=NULL) {
 933
 934     $totalsecs = abs($totalsecs);
 935
 936     if (!$str) {  // Create the str structure the slow way
 937         $str->day   = get_string('day');
 938         $str->days  = get_string('days');
 939         $str->hour  = get_string('hour');
 940         $str->hours = get_string('hours');
 941         $str->min   = get_string('min');
 942         $str->mins  = get_string('mins');
 943         $str->sec   = get_string('sec');
 944         $str->secs  = get_string('secs');
 945         $str->year  = get_string('year');
 946         $str->years = get_string('years');
 947     }
 948
 949
 950     $years     = floor($totalsecs/YEARSECS);
 951     $remainder = $totalsecs - ($years*YEARSECS);
 952     $days      = floor($remainder/DAYSECS);
 953     $remainder = $totalsecs - ($days*DAYSECS);
 954     $hours     = floor($remainder/HOURSECS);
 955     $remainder = $remainder - ($hours*HOURSECS);
 956     $mins      = floor($remainder/MINSECS);
 957     $secs      = $remainder - ($mins*MINSECS);
 958
 959     $ss = ($secs == 1)  ? $str->sec  : $str->secs;
 960     $sm = ($mins == 1)  ? $str->min  : $str->mins;
 961     $sh = ($hours == 1) ? $str->hour : $str->hours;
 962     $sd = ($days == 1)  ? $str->day  : $str->days;
 963     $sy = ($years == 1)  ? $str->year  : $str->years;
 964
 965     $oyears = '';
 966     $odays = '';
 967     $ohours = '';
 968     $omins = '';
 969     $osecs = '';
 970
 971     if ($years)  $oyears  = $years .' '. $sy;
 972     if ($days)  $odays  = $days .' '. $sd;
 973     if ($hours) $ohours = $hours .' '. $sh;
 974     if ($mins)  $omins  = $mins .' '. $sm;
 975     if ($secs)  $osecs  = $secs .' '. $ss;
 976
 977     if ($years)  return $oyears .' '. $odays;
 978     if ($days)  return $odays .' '. $ohours;
 979     if ($hours) return $ohours .' '. $omins;
 980     if ($mins)  return $omins .' '. $osecs;
 981     if ($secs)  return $osecs;
 982     return get_string('now');
 983 }
 984
 985 /**
 986  * Returns a formatted string that represents a date in user time
 987  * <b>WARNING: note that the format is for strftime(), not date().</b>
 988  * Because of a bug in most Windows time libraries, we can't use
 989  * the nicer %e, so we have to use %d which has leading zeroes.
 990  * A lot of the fuss in the function is just getting rid of these leading
 991  * zeroes as efficiently as possible.
 992  *
 993  * If parameter fixday = true (default), then take off leading
 994  * zero from %d, else mantain it.
 995  *
 996  * @uses HOURSECS
 997  * @param  int $date timestamp in GMT
 998  * @param string $format strftime format
 999  * @param float $timezone
1000  * @param bool $fixday If true (default) then the leading
1001  * zero from %d is removed. If false then the leading zero is mantained.
1002  * @return string
1003  */
1004 function userdate($date, $format='', $timezone=99, $fixday = true) {
1005
1006     global $CFG;
1007
1008     if (empty($format)) {
1009         $format = get_string('strftimedaydatetime');
1010     }
1011
1012     if (!empty($CFG->nofixday)) {  // Config.php can force %d not to be fixed.
1013         $fixday = false;
1014     } else if ($fixday) {
1015         $formatnoday = str_replace('%d', 'DD', $format);
1016         $fixday = ($formatnoday != $format);
1017     }
1018
1019     $date += dst_offset_on($date);
1020
1021     $timezone = get_user_timezone_offset($timezone);
1022
1023     if (abs($timezone) > 13) {   /// Server time
1024         if ($fixday) {
1025             $datestring = strftime($formatnoday, $date);
1026             $daystring  = str_replace(' 0', '', strftime(' %d', $date));
1027             $datestring = str_replace('DD', $daystring, $datestring);
1028         } else {
1029             $datestring = strftime($format, $date);
1030         }
1031     } else {
1032         $date += (int)($timezone * 3600);
1033         if ($fixday) {
1034             $datestring = gmstrftime($formatnoday, $date);
1035             $daystring  = str_replace(' 0', '', gmstrftime(' %d', $date));
1036             $datestring = str_replace('DD', $daystring, $datestring);
1037         } else {
1038             $datestring = gmstrftime($format, $date);
1039         }
1040     }
1041
1042 /// If we are running under Windows convert from windows encoding to UTF-8
1043 /// (because it's impossible to specify UTF-8 to fetch locale info in Win32)
1044
1045    if ($CFG->ostype == 'WINDOWS') {
1046        if ($localewincharset = get_string('localewincharset')) {
1047            $textlib = textlib_get_instance();
1048            $datestring = $textlib->convert($datestring, $localewincharset, 'utf-8');
1049        }
1050    }
1051
1052     return $datestring;
1053 }
1054
1055 /**
1056  * Given a $time timestamp in GMT (seconds since epoch),
1057  * returns an array that represents the date in user time
1058  *
1059  * @uses HOURSECS
1060  * @param int $time Timestamp in GMT
1061  * @param float $timezone ?
1062  * @return array An array that represents the date in user time
1063  * @todo Finish documenting this function
1064  */
1065 function usergetdate($time, $timezone=99) {
1066
1067     $timezone = get_user_timezone_offset($timezone);
1068
1069     if (abs($timezone) > 13) {    // Server time
1070         return getdate($time);
1071     }
1072
1073     // There is no gmgetdate so we use gmdate instead
1074     $time += dst_offset_on($time);
1075     $time += intval((float)$timezone * HOURSECS);
1076
1077     $datestring = gmstrftime('%S_%M_%H_%d_%m_%Y_%w_%j_%A_%B', $time);
1078
1079     list(
1080         $getdate['seconds'],
1081         $getdate['minutes'],
1082         $getdate['hours'],
1083         $getdate['mday'],
1084         $getdate['mon'],
1085         $getdate['year'],
1086         $getdate['wday'],
1087         $getdate['yday'],
1088         $getdate['weekday'],
1089         $getdate['month']
1090     ) = explode('_', $datestring);
1091
1092     return $getdate;
1093 }
1094
1095 /**
1096  * Given a GMT timestamp (seconds since epoch), offsets it by
1097  * the timezone.  eg 3pm in India is 3pm GMT - 7 * 3600 seconds
1098  *
1099  * @uses HOURSECS
1100  * @param  int $date Timestamp in GMT
1101  * @param float $timezone
1102  * @return int
1103  */
1104 function usertime($date, $timezone=99) {
1105
1106     $timezone = get_user_timezone_offset($timezone);
1107
1108     if (abs($timezone) > 13) {
1109         return $date;
1110     }
1111     return $date - (int)($timezone * HOURSECS);
1112 }
1113
1114 /**
1115  * Given a time, return the GMT timestamp of the most recent midnight
1116  * for the current user.
1117  *
1118  * @param int $date Timestamp in GMT
1119  * @param float $timezone ?
1120  * @return ?
1121  */
1122 function usergetmidnight($date, $timezone=99) {
1123
1124     $timezone = get_user_timezone_offset($timezone);
1125     $userdate = usergetdate($date, $timezone);
1126
1127     // Time of midnight of this user's day, in GMT
1128     return make_timestamp($userdate['year'], $userdate['mon'], $userdate['mday'], 0, 0, 0, $timezone);
1129
1130 }
1131
1132 /**
1133  * Returns a string that prints the user's timezone
1134  *
1135  * @param float $timezone The user's timezone
1136  * @return string
1137  */
1138 function usertimezone($timezone=99) {
1139
1140     $tz = get_user_timezone($timezone);
1141
1142     if (!is_float($tz)) {
1143         return $tz;
1144     }
1145
1146     if(abs($tz) > 13) { // Server time
1147         return get_string('serverlocaltime');
1148     }
1149
1150     if($tz == intval($tz)) {
1151         // Don't show .0 for whole hours
1152         $tz = intval($tz);
1153     }
1154
1155     if($tz == 0) {
1156         return 'GMT';
1157     }
1158     else if($tz > 0) {
1159         return 'GMT+'.$tz;
1160     }
1161     else {
1162         return 'GMT'.$tz;
1163     }
1164
1165 }
1166
1167 /**
1168  * Returns a float which represents the user's timezone difference from GMT in hours
1169  * Checks various settings and picks the most dominant of those which have a value
1170  *
1171  * @uses $CFG
1172  * @uses $USER
1173  * @param float $tz If this value is provided and not equal to 99, it will be returned as is and no other settings will be checked
1174  * @return int
1175  */
1176 function get_user_timezone_offset($tz = 99) {
1177
1178     global $USER, $CFG;
1179
1180     $tz = get_user_timezone($tz);
1181
1182     if (is_float($tz)) {
1183         return $tz;
1184     } else {
1185         $tzrecord = get_timezone_record($tz);
1186         if (empty($tzrecord)) {
1187             return 99.0;
1188         }
1189         return (float)$tzrecord->gmtoff / HOURMINS;
1190     }
1191 }
1192
1193 /**
1194  * Returns a float or a string which denotes the user's timezone
1195  * A float value means that a simple offset from GMT is used, while a string (it will be the name of a timezone in the database)
1196  * means that for this timezone there are also DST rules to be taken into account
1197  * Checks various settings and picks the most dominant of those which have a value
1198  *
1199  * @uses $USER
1200  * @uses $CFG
1201  * @param float $tz If this value is provided and not equal to 99, it will be returned as is and no other settings will be checked
1202  * @return mixed
1203  */
1204 function get_user_timezone($tz = 99) {
1205     global $USER, $CFG;
1206
1207     $timezones = array(
1208         $tz,
1209         isset($CFG->forcetimezone) ? $CFG->forcetimezone : 99,
1210         isset($USER->timezone) ? $USER->timezone : 99,
1211         isset($CFG->timezone) ? $CFG->timezone : 99,
1212         );
1213
1214     $tz = 99;
1215
1216     while(($tz == '' || $tz == 99) && $next = each($timezones)) {
1217         $tz = $next['value'];
1218     }
1219
1220     return is_numeric($tz) ? (float) $tz : $tz;
1221 }
1222
1223 /**
1224  * ?
1225  *
1226  * @uses $CFG
1227  * @uses $db
1228  * @param string $timezonename ?
1229  * @return object
1230  */
1231 function get_timezone_record($timezonename) {
1232     global $CFG, $db;
1233     static $cache = NULL;
1234
1235     if ($cache === NULL) {
1236         $cache = array();
1237     }
1238
1239     if (isset($cache[$timezonename])) {
1240         return $cache[$timezonename];
1241     }
1242
1243     return $cache[$timezonename] = get_record_sql('SELECT * FROM '.$CFG->prefix.'timezone
1244                                       WHERE name = '.$db->qstr($timezonename).' ORDER BY year DESC', true);
1245 }
1246
1247 /**
1248  * ?
1249  *
1250  * @uses $CFG
1251  * @uses $USER
1252  * @param ? $fromyear ?
1253  * @param ? $to_year ?
1254  * @return bool
1255  */
1256 function calculate_user_dst_table($from_year = NULL, $to_year = NULL) {
1257     global $CFG, $SESSION;
1258
1259     $usertz = get_user_timezone();
1260
1261     if (is_float($usertz)) {
1262         // Trivial timezone, no DST
1263         return false;
1264     }
1265
1266     if (!empty($SESSION->dst_offsettz) && $SESSION->dst_offsettz != $usertz) {
1267         // We have precalculated values, but the user's effective TZ has changed in the meantime, so reset
1268         unset($SESSION->dst_offsets);
1269         unset($SESSION->dst_range);
1270     }
1271
1272     if (!empty($SESSION->dst_offsets) && empty($from_year) && empty($to_year)) {
1273         // Repeat calls which do not request specific year ranges stop here, we have already calculated the table
1274         // This will be the return path most of the time, pretty light computationally
1275         return true;
1276     }
1277
1278     // Reaching here means we either need to extend our table or create it from scratch
1279
1280     // Remember which TZ we calculated these changes for
1281     $SESSION->dst_offsettz = $usertz;
1282
1283     if(empty($SESSION->dst_offsets)) {
1284         // If we 're creating from scratch, put the two guard elements in there
1285         $SESSION->dst_offsets = array(1 => NULL, 0 => NULL);
1286     }
1287     if(empty($SESSION->dst_range)) {
1288         // If creating from scratch
1289         $from = max((empty($from_year) ? intval(date('Y')) - 3 : $from_year), 1971);
1290         $to   = min((empty($to_year)   ? intval(date('Y')) + 3 : $to_year),   2035);
1291
1292         // Fill in the array with the extra years we need to process
1293         $yearstoprocess = array();
1294         for($i = $from; $i <= $to; ++$i) {
1295             $yearstoprocess[] = $i;
1296         }
1297
1298         // Take note of which years we have processed for future calls
1299         $SESSION->dst_range = array($from, $to);
1300     }
1301     else {
1302         // If needing to extend the table, do the same
1303         $yearstoprocess = array();
1304
1305         $from = max((empty($from_year) ? $SESSION->dst_range[0] : $from_year), 1971);
1306         $to   = min((empty($to_year)   ? $SESSION->dst_range[1] : $to_year),   2035);
1307
1308         if($from < $SESSION->dst_range[0]) {
1309             // Take note of which years we need to process and then note that we have processed them for future calls
1310             for($i = $from; $i < $SESSION->dst_range[0]; ++$i) {
1311                 $yearstoprocess[] = $i;
1312             }
1313             $SESSION->dst_range[0] = $from;
1314         }
1315         if($to > $SESSION->dst_range[1]) {
1316             // Take note of which years we need to process and then note that we have processed them for future calls
1317             for($i = $SESSION->dst_range[1] + 1; $i <= $to; ++$i) {
1318                 $yearstoprocess[] = $i;
1319             }
1320             $SESSION->dst_range[1] = $to;
1321         }
1322     }
1323
1324     if(empty($yearstoprocess)) {
1325         // This means that there was a call requesting a SMALLER range than we have already calculated
1326         return true;
1327     }
1328
1329     // From now on, we know that the array has at least the two guard elements, and $yearstoprocess has the years we need
1330     // Also, the array is sorted in descending timestamp order!
1331
1332     // Get DB data
1333     $presetrecords = get_records('timezone', 'name', $usertz, 'year DESC', 'year, gmtoff, dstoff, dst_month, dst_startday, dst_weekday, dst_skipweeks, dst_time, std_month, std_startday, std_weekday, std_skipweeks, std_time');
1334     if(empty($presetrecords)) {
1335         return false;
1336     }
1337
1338     // Remove ending guard (first element of the array)
1339     reset($SESSION->dst_offsets);
1340     unset($SESSION->dst_offsets[key($SESSION->dst_offsets)]);
1341
1342     // Add all required change timestamps
1343     foreach($yearstoprocess as $y) {
1344         // Find the record which is in effect for the year $y
1345         foreach($presetrecords as $year => $preset) {
1346             if($year <= $y) {
1347                 break;
1348             }
1349         }
1350
1351         $changes = dst_changes_for_year($y, $preset);
1352
1353         if($changes === NULL) {
1354             continue;
1355         }
1356         if($changes['dst'] != 0) {
1357             $SESSION->dst_offsets[$changes['dst']] = $preset->dstoff * MINSECS;
1358         }
1359         if($changes['std'] != 0) {
1360             $SESSION->dst_offsets[$changes['std']] = 0;
1361         }
1362     }
1363
1364     // Put in a guard element at the top
1365     $maxtimestamp = max(array_keys($SESSION->dst_offsets));
1366     $SESSION->dst_offsets[($maxtimestamp + DAYSECS)] = NULL; // DAYSECS is arbitrary, any "small" number will do
1367
1368     // Sort again
1369     krsort($SESSION->dst_offsets);
1370
1371     return true;
1372 }
1373
1374 function dst_changes_for_year($year, $timezone) {
1375
1376     if($timezone->dst_startday == 0 && $timezone->dst_weekday == 0 && $timezone->std_startday == 0 && $timezone->std_weekday == 0) {
1377         return NULL;
1378     }
1379
1380     $monthdaydst = find_day_in_month($timezone->dst_startday, $timezone->dst_weekday, $timezone->dst_month, $year);
1381     $monthdaystd = find_day_in_month($timezone->std_startday, $timezone->std_weekday, $timezone->std_month, $year);
1382
1383     list($dst_hour, $dst_min) = explode(':', $timezone->dst_time);
1384     list($std_hour, $std_min) = explode(':', $timezone->std_time);
1385
1386     $timedst = make_timestamp($year, $timezone->dst_month, $monthdaydst, 0, 0, 0, 99, false);
1387     $timestd = make_timestamp($year, $timezone->std_month, $monthdaystd, 0, 0, 0, 99, false);
1388
1389     // Instead of putting hour and minute in make_timestamp(), we add them afterwards.
1390     // This has the advantage of being able to have negative values for hour, i.e. for timezones
1391     // where GMT time would be in the PREVIOUS day than the local one on which DST changes.
1392
1393     $timedst += $dst_hour * HOURSECS + $dst_min * MINSECS;
1394     $timestd += $std_hour * HOURSECS + $std_min * MINSECS;
1395
1396     return array('dst' => $timedst, 0 => $timedst, 'std' => $timestd, 1 => $timestd);
1397 }
1398
1399 // $time must NOT be compensated at all, it has to be a pure timestamp
1400 function dst_offset_on($time) {
1401     global $SESSION;
1402
1403     if(!calculate_user_dst_table() || empty($SESSION->dst_offsets)) {
1404         return 0;
1405     }
1406
1407     reset($SESSION->dst_offsets);
1408     while(list($from, $offset) = each($SESSION->dst_offsets)) {
1409         if($from <= $time) {
1410             break;
1411         }
1412     }
1413
1414     // This is the normal return path
1415     if($offset !== NULL) {
1416         return $offset;
1417     }
1418
1419     // Reaching this point means we haven't calculated far enough, do it now:
1420     // Calculate extra DST changes if needed and recurse. The recursion always
1421     // moves toward the stopping condition, so will always end.
1422
1423     if($from == 0) {
1424         // We need a year smaller than $SESSION->dst_range[0]
1425         if($SESSION->dst_range[0] == 1971) {
1426             return 0;
1427         }
1428         calculate_user_dst_table($SESSION->dst_range[0] - 5, NULL);
1429         return dst_offset_on($time);
1430     }
1431     else {
1432         // We need a year larger than $SESSION->dst_range[1]
1433         if($SESSION->dst_range[1] == 2035) {
1434             return 0;
1435         }
1436         calculate_user_dst_table(NULL, $SESSION->dst_range[1] + 5);
1437         return dst_offset_on($time);
1438     }
1439 }
1440
1441 function find_day_in_month($startday, $weekday, $month, $year) {
1442
1443     $daysinmonth = days_in_month($month, $year);
1444
1445     if($weekday == -1) {
1446         // Don't care about weekday, so return:
1447         //    abs($startday) if $startday != -1
1448         //    $daysinmonth otherwise
1449         return ($startday == -1) ? $daysinmonth : abs($startday);
1450     }
1451
1452     // From now on we 're looking for a specific weekday
1453
1454     // Give "end of month" its actual value, since we know it
1455     if($startday == -1) {
1456         $startday = -1 * $daysinmonth;
1457     }
1458
1459     // Starting from day $startday, the sign is the direction
1460
1461     if($startday < 1) {
1462
1463         $startday = abs($startday);
1464         $lastmonthweekday  = strftime('%w', mktime(12, 0, 0, $month, $daysinmonth, $year, 0));
1465
1466         // This is the last such weekday of the month
1467         $lastinmonth = $daysinmonth + $weekday - $lastmonthweekday;
1468         if($lastinmonth > $daysinmonth) {
1469             $lastinmonth -= 7;
1470         }
1471
1472         // Find the first such weekday <= $startday
1473         while($lastinmonth > $startday) {
1474             $lastinmonth -= 7;
1475         }
1476
1477         return $lastinmonth;
1478
1479     }
1480     else {
1481
1482         $indexweekday = strftime('%w', mktime(12, 0, 0, $month, $startday, $year, 0));
1483
1484         $diff = $weekday - $indexweekday;
1485         if($diff < 0) {
1486             $diff += 7;
1487         }
1488
1489         // This is the first such weekday of the month equal to or after $startday
1490         $firstfromindex = $startday + $diff;
1491
1492         return $firstfromindex;
1493
1494     }
1495 }
1496
1497 /**
1498  * Calculate the number of days in a given month
1499  *
1500  * @param int $month The month whose day count is sought
1501  * @param int $year The year of the month whose day count is sought
1502  * @return int
1503  */
1504 function days_in_month($month, $year) {
1505    return intval(date('t', mktime(12, 0, 0, $month, 1, $year, 0)));
1506 }
1507
1508 /**
1509  * Calculate the position in the week of a specific calendar day
1510  *
1511  * @param int $day The day of the date whose position in the week is sought
1512  * @param int $month The month of the date whose position in the week is sought
1513  * @param int $year The year of the date whose position in the week is sought
1514  * @return int
1515  */
1516 function dayofweek($day, $month, $year) {
1517     // I wonder if this is any different from
1518     // strftime('%w', mktime(12, 0, 0, $month, $daysinmonth, $year, 0));
1519     return intval(date('w', mktime(12, 0, 0, $month, $day, $year, 0)));
1520 }
1521
1522 /// USER AUTHENTICATION AND LOGIN ////////////////////////////////////////
1523
1524 /**
1525  * Makes sure that $USER->sesskey exists, if $USER itself exists. It sets a new sesskey
1526  * if one does not already exist, but does not overwrite existing sesskeys. Returns the
1527  * sesskey string if $USER exists, or boolean false if not.
1528  *
1529  * @uses $USER
1530  * @return string
1531  */
1532 function sesskey() {
1533     global $USER;
1534
1535     if(!isset($USER)) {
1536         return false;
1537     }
1538
1539     if (empty($USER->sesskey)) {
1540         $USER->sesskey = random_string(10);
1541     }
1542
1543     return $USER->sesskey;
1544 }
1545
1546
1547 /**
1548  * For security purposes, this function will check that the currently
1549  * given sesskey (passed as a parameter to the script or this function)
1550  * matches that of the current user.
1551  *
1552  * @param string $sesskey optionally provided sesskey
1553  * @return bool
1554  */
1555 function confirm_sesskey($sesskey=NULL) {
1556     global $USER;
1557
1558     if (!empty($USER->ignoresesskey) || !empty($CFG->ignoresesskey)) {
1559         return true;
1560     }
1561
1562     if (empty($sesskey)) {
1563         $sesskey = required_param('sesskey', PARAM_RAW);  // Check script parameters
1564     }
1565
1566     if (!isset($USER->sesskey)) {
1567         return false;
1568     }
1569
1570     return ($USER->sesskey === $sesskey);
1571 }
1572
1573 /**
1574  * Setup all global $CFG course variables, set locale and also themes
1575  * This function can be used on pages that do not require login instead of require_login()
1576  *
1577  * @param mixed $courseorid id of the course or course object
1578  */
1579 function course_setup($courseorid=0) {
1580     global $COURSE, $CFG, $SITE;
1581
1582 /// Redefine global $COURSE if needed
1583     if (empty($courseorid)) {
1584         // no change in global $COURSE - for backwards compatibiltiy
1585         // if require_rogin() used after require_login($courseid);
1586     } else if (is_object($courseorid)) {
1587         $COURSE = clone($courseorid);
1588     } else {
1589         global $course; // used here only to prevent repeated fetching from DB - may be removed later
1590         if (!empty($course->id) and $course->id == SITEID) {
1591             $COURSE = clone($SITE);
1592         } else if (!empty($course->id) and $course->id == $courseorid) {
1593             $COURSE = clone($course);
1594         } else {
1595             if (!$COURSE = get_record('course', 'id', $courseorid)) {
1596                 error('Invalid course ID');
1597             }
1598         }
1599     }
1600
1601 /// set locale and themes
1602     moodle_setlocale();
1603     theme_setup();
1604
1605 }
1606
1607 /**
1608  * This function checks that the current user is logged in and has the
1609  * required privileges
1610  *
1611  * This function checks that the current user is logged in, and optionally
1612  * whether they are allowed to be in a particular course and view a particular
1613  * course module.
1614  * If they are not logged in, then it redirects them to the site login unless
1615  * $autologinguest is set and {@link $CFG}->autologinguests is set to 1 in which
1616  * case they are automatically logged in as guests.
1617  * If $courseid is given and the user is not enrolled in that course then the
1618  * user is redirected to the course enrolment page.
1619  * If $cm is given and the coursemodule is hidden and the user is not a teacher
1620  * in the course then the user is redirected to the course home page.
1621  *
1622  * @uses $CFG
1623  * @uses $SESSION
1624  * @uses $USER
1625  * @uses $FULLME
1626  * @uses SITEID
1627  * @uses $COURSE
1628  * @param mixed $courseorid id of the course or course object
1629  * @param bool $autologinguest
1630  * @param object $cm course module object
1631  */
1632 function require_login($courseorid=0, $autologinguest=true, $cm=null) {
1633
1634     global $CFG, $SESSION, $USER, $COURSE, $FULLME;
1635
1636 /// setup global $COURSE, themes, language and locale
1637     course_setup($courseorid);
1638
1639 /// If the user is not even logged in yet then make sure they are
1640     if (!isloggedin()) {
1641         //NOTE: $USER->site check was obsoleted by session test cookie,
1642         //      $USER->confirmed test is in login/index.php
1643         $SESSION->wantsurl = $FULLME;
1644         if (!empty($_SERVER['HTTP_REFERER'])) {
1645             $SESSION->fromurl  = $_SERVER['HTTP_REFERER'];
1646         }
1647         if ($autologinguest and !empty($CFG->autologinguests) and ($COURSE->id == SITEID or $COURSE->guest) ) {
1648             $loginguest = '?loginguest=true';
1649         } else {
1650             $loginguest = '';
1651         }
1652         if (empty($CFG->loginhttps) or $autologinguest) { //do not require https for guest logins
1653             redirect($CFG->wwwroot .'/login/index.php'. $loginguest);
1654         } else {
1655             $wwwroot = str_replace('http:','https:', $CFG->wwwroot);
1656             redirect($wwwroot .'/login/index.php');
1657         }
1658         exit;
1659     }
1660
1661 /// loginas as redirection if needed
1662     if ($COURSE->id != SITEID and !empty($USER->realuser)) {
1663         if ($USER->loginascontext->contextlevel == CONTEXT_COURSE) {
1664             if ($USER->loginascontext->instanceid != $COURSE->id) {
1665                 print_error('loginascourseredir', '', $CFG->wwwroot.'/course/view.php?id='.$USER->loginascontext->instanceid);
1666             }
1667         }
1668     }
1669
1670
1671 /// check whether the user should be changing password (but only if it is REALLY them)
1672     $userauth = get_auth_plugin($USER->auth);
1673     if (get_user_preferences('auth_forcepasswordchange') && empty($USER->realuser)) {
1674         if ($userauth->can_change_password()) {
1675             $SESSION->wantsurl = $FULLME;
1676             if (method_exists($userauth, 'change_password_url') and $userauth->change_password_url()) {
1677                 //use plugin custom url
1678                 redirect($userauth->change_password_url());
1679             } else {
1680                 //use moodle internal method
1681                 if (empty($CFG->loginhttps)) {
1682                     redirect($CFG->wwwroot .'/login/change_password.php');
1683                 } else {
1684                     $wwwroot = str_replace('http:','https:', $CFG->wwwroot);
1685                     redirect($wwwroot .'/login/change_password.php');
1686                 }
1687             }
1688         } else {
1689             error(get_strin('nopasswordchangeforced', 'auth'));
1690         }
1691     }
1692
1693 /// Check that the user account is properly set up
1694     if (user_not_fully_set_up($USER)) {
1695         $SESSION->wantsurl = $FULLME;
1696         redirect($CFG->wwwroot .'/user/edit.php?id='. $USER->id .'&amp;course='. SITEID);
1697     }
1698
1699 /// Make sure current IP matches the one for this session (if required)
1700     if (!empty($CFG->tracksessionip)) {
1701         if ($USER->sessionIP != md5(getremoteaddr())) {
1702             error(get_string('sessionipnomatch', 'error'));
1703         }
1704     }
1705
1706 /// Make sure the USER has a sesskey set up.  Used for checking script parameters.
1707     sesskey();
1708
1709     // Check that the user has agreed to a site policy if there is one
1710     if (!empty($CFG->sitepolicy)) {
1711         if (!$USER->policyagreed) {
1712             $SESSION->wantsurl = $FULLME;
1713             redirect($CFG->wwwroot .'/user/policy.php');
1714         }
1715     }
1716
1717 /// If the site is currently under maintenance, then print a message
1718     if (!has_capability('moodle/site:config',get_context_instance(CONTEXT_SYSTEM, SITEID))) {
1719         if (file_exists($CFG->dataroot.'/'.SITEID.'/maintenance.html')) {
1720             print_maintenance_message();
1721             exit;
1722         }
1723     }
1724
1725
1726     if ($COURSE->id == SITEID) {
1727 /// We can eliminate hidden site activities straight away
1728         if (!empty($cm) && !$cm->visible and !has_capability('moodle/course:viewhiddenactivities',
1729                                                       get_context_instance(CONTEXT_SYSTEM, SITEID))) {
1730             redirect($CFG->wwwroot, get_string('activityiscurrentlyhidden'));
1731         }
1732         return;
1733
1734     } else {
1735 /// Check if the user can be in a particular course
1736         if (!$context = get_context_instance(CONTEXT_COURSE, $COURSE->id)) {
1737             print_error('nocontext');
1738         }
1739
1740         if (empty($USER->switchrole[$context->id]) &&
1741             !($COURSE->visible && course_parent_visible($COURSE)) &&
1742                !has_capability('moodle/course:viewhiddencourses', get_context_instance(CONTEXT_COURSE, $COURSE->id)) ){
1743             print_header_simple();
1744             notice(get_string('coursehidden'), $CFG->wwwroot .'/');
1745         }
1746
1747     /// Non-guests who don't currently have access, check if they can be allowed in as a guest
1748
1749         if ($USER->username != 'guest' and !has_capability('moodle/course:view', $context)) {
1750             if ($COURSE->guest == 1) {
1751                  // Temporarily assign them guest role for this context, if it fails later user is asked to enrol
1752                  has_capability('clearcache');   // Must clear cache
1753                  $guestcaps = get_role_context_caps($CFG->guestroleid, $context);
1754                  $USER->capabilities = merge_role_caps($USER->capabilities, $guestcaps);
1755             }
1756         }
1757
1758     /// If the user is a guest then treat them according to the course policy about guests
1759
1760         if (has_capability('moodle/legacy:guest', $context, NULL, false)) {
1761             switch ($COURSE->guest) {    /// Check course policy about guest access
1762
1763                 case 1:    /// Guests always allowed
1764                     if (!has_capability('moodle/course:view', $context)) {    // Prohibited by capability
1765                         print_header_simple();
1766                         notice(get_string('guestsnotallowed', '', format_string($COURSE->fullname)), "$CFG->wwwroot/login/index.php");
1767                     }
1768                     if (!empty($cm) and !$cm->visible) { // Not allowed to see module, send to course page
1769                         redirect($CFG->wwwroot.'/course/view.php?id='.$cm->course,
1770                                  get_string('activityiscurrentlyhidden'));
1771                     }
1772
1773                     return;   // User is allowed to see this course
1774
1775                     break;
1776
1777                 case 2:    /// Guests allowed with key
1778                     if (!empty($USER->enrolkey[$COURSE->id])) {   // Set by enrol/manual/enrol.php
1779                         return true;
1780                     }
1781                     //  otherwise drop through to logic below (--> enrol.php)
1782                     break;
1783
1784                 default:    /// Guests not allowed
1785                     print_header_simple('', '', get_string('loggedinasguest'));
1786                     if (empty($USER->switchrole[$context->id])) {  // Normal guest
1787                         notice(get_string('guestsnotallowed', '', format_string($COURSE->fullname)), "$CFG->wwwroot/login/index.php");
1788                     } else {
1789                         notify(get_string('guestsnotallowed', '', format_string($COURSE->fullname)));
1790                         echo '<div class="notifyproblem">'.switchroles_form($COURSE->id).'</div>';
1791                         print_footer($COURSE);
1792                         exit;
1793                     }
1794                     break;
1795             }
1796
1797     /// For non-guests, check if they have course view access
1798
1799         } else if (has_capability('moodle/course:view', $context)) {
1800             if (!empty($USER->realuser)) {   // Make sure the REAL person can also access this course
1801                 if (!has_capability('moodle/course:view', $context, $USER->realuser)) {
1802                     print_header_simple();
1803                     notice(get_string('studentnotallowed', '', fullname($USER, true)), $CFG->wwwroot .'/');
1804                 }
1805             }
1806
1807         /// Make sure they can read this activity too, if specified
1808
1809             if (!empty($cm) and !$cm->visible and !has_capability('moodle/course:viewhiddenactivities', $context)) {
1810                 redirect($CFG->wwwroot.'/course/view.php?id='.$cm->course, get_string('activityiscurrentlyhidden'));
1811             }
1812             return;   // User is allowed to see this course
1813
1814         }
1815
1816
1817     /// Currently not enrolled in the course, so see if they want to enrol
1818         $SESSION->wantsurl = $FULLME;
1819         redirect($CFG->wwwroot .'/course/enrol.php?id='. $COURSE->id);
1820         die;
1821     }
1822 }
1823
1824
1825
1826 /**
1827  * This function just makes sure a user is logged out.
1828  *
1829  * @uses $CFG
1830  * @uses $USER
1831  */
1832 function require_logout() {
1833
1834     global $USER, $CFG, $SESSION;
1835
1836     if (isset($USER) and isset($USER->id)) {
1837         add_to_log(SITEID, "user", "logout", "view.php?id=$USER->id&course=".SITEID, $USER->id, 0, $USER->id);
1838
1839         if ($USER->auth == 'cas' && !empty($CFG->cas_enabled)) {
1840             require($CFG->dirroot.'/auth/cas/logout.php');
1841         }
1842
1843         if (extension_loaded('openssl')) {
1844             require($CFG->dirroot.'/auth/mnet/auth.php');
1845             $authplugin = new auth_plugin_mnet();
1846             $authplugin->logout();
1847         }
1848     }
1849
1850     if (ini_get_bool("register_globals") and check_php_version("4.3.0")) {
1851         // This method is just to try to avoid silly warnings from PHP 4.3.0
1852         session_unregister("USER");
1853         session_unregister("SESSION");
1854     }
1855
1856     setcookie('MoodleSessionTest'.$CFG->sessioncookie, '', time() - 3600, $CFG->sessioncookiepath);
1857     unset($_SESSION['USER']);
1858     unset($_SESSION['SESSION']);
1859
1860     unset($SESSION);
1861     unset($USER);
1862
1863 }
1864
1865 /**
1866  * This is a weaker version of {@link require_login()} which only requires login
1867  * when called from within a course rather than the site page, unless
1868  * the forcelogin option is turned on.
1869  *
1870  * @uses $CFG
1871  * @param mixed $courseorid The course object or id in question
1872  * @param bool $autologinguest Allow autologin guests if that is wanted
1873  * @param object $cm Course activity module if known
1874  */
1875 function require_course_login($courseorid, $autologinguest=true, $cm=null) {
1876     global $CFG;
1877     if (!empty($CFG->forcelogin)) {
1878         // login required for both SITE and courses
1879         require_login($courseorid, $autologinguest, $cm);
1880     } else if ((is_object($courseorid) and $courseorid->id == SITEID)
1881           or (!is_object($courseorid) and $courseorid == SITEID)) {
1882         //login for SITE not required
1883     } else {
1884         // course login always required
1885         require_login($courseorid, $autologinguest, $cm);
1886     }
1887 }
1888
1889 /**
1890  * Modify the user table by setting the currently logged in user's
1891  * last login to now.
1892  *
1893  * @uses $USER
1894  * @return bool
1895  */
1896 function update_user_login_times() {
1897     global $USER;
1898
1899     $user = new object();
1900     $USER->lastlogin = $user->lastlogin = $USER->currentlogin;
1901     $USER->currentlogin = $user->lastaccess = $user->currentlogin = time();
1902
1903     $user->id = $USER->id;
1904
1905     return update_record('user', $user);
1906 }
1907
1908 /**
1909  * Determines if a user has completed setting up their account.
1910  *
1911  * @param user $user A {@link $USER} object to test for the existance of a valid name and email
1912  * @return bool
1913  */
1914 function user_not_fully_set_up($user) {
1915     return ($user->username != 'guest' and (empty($user->firstname) or empty($user->lastname) or empty($user->email) or over_bounce_threshold($user)));
1916 }
1917
1918 function over_bounce_threshold($user) {
1919
1920     global $CFG;
1921
1922     if (empty($CFG->handlebounces)) {
1923         return false;
1924     }
1925     // set sensible defaults
1926     if (empty($CFG->minbounces)) {
1927         $CFG->minbounces = 10;
1928     }
1929     if (empty($CFG->bounceratio)) {
1930         $CFG->bounceratio = .20;
1931     }
1932     $bouncecount = 0;
1933     $sendcount = 0;
1934     if ($bounce = get_record('user_preferences','userid',$user->id,'name','email_bounce_count')) {
1935         $bouncecount = $bounce->value;
1936     }
1937     if ($send = get_record('user_preferences','userid',$user->id,'name','email_send_count')) {
1938         $sendcount = $send->value;
1939     }
1940     return ($bouncecount >= $CFG->minbounces && $bouncecount/$sendcount >= $CFG->bounceratio);
1941 }
1942
1943 /**
1944  * @param $user - object containing an id
1945  * @param $reset - will reset the count to 0
1946  */
1947 function set_send_count($user,$reset=false) {
1948     if ($pref = get_record('user_preferences','userid',$user->id,'name','email_send_count')) {
1949         $pref->value = (!empty($reset)) ? 0 : $pref->value+1;
1950         update_record('user_preferences',$pref);
1951     }
1952     else if (!empty($reset)) { // if it's not there and we're resetting, don't bother.
1953         // make a new one
1954         $pref->name = 'email_send_count';
1955         $pref->value = 1;
1956         $pref->userid = $user->id;
1957         insert_record('user_preferences',$pref, false);
1958     }
1959 }
1960
1961 /**
1962 * @param $user - object containing an id
1963  * @param $reset - will reset the count to 0
1964  */
1965 function set_bounce_count($user,$reset=false) {
1966     if ($pref = get_record('user_preferences','userid',$user->id,'name','email_bounce_count')) {
1967         $pref->value = (!empty($reset)) ? 0 : $pref->value+1;
1968         update_record('user_preferences',$pref);
1969     }
1970     else if (!empty($reset)) { // if it's not there and we're resetting, don't bother.
1971         // make a new one
1972         $pref->name = 'email_bounce_count';
1973         $pref->value = 1;
1974         $pref->userid = $user->id;
1975         insert_record('user_preferences',$pref, false);
1976     }
1977 }
1978
1979 /**
1980  * Keeps track of login attempts
1981  *
1982  * @uses $SESSION
1983  */
1984 function update_login_count() {
1985
1986     global $SESSION;
1987
1988     $max_logins = 10;
1989
1990     if (empty($SESSION->logincount)) {
1991         $SESSION->logincount = 1;
1992     } else {
1993         $SESSION->logincount++;
1994     }
1995
1996     if ($SESSION->logincount > $max_logins) {
1997         unset($SESSION->wantsurl);
1998         error(get_string('errortoomanylogins'));
1999     }
2000 }
2001
2002 /**
2003  * Resets login attempts
2004  *
2005  * @uses $SESSION
2006  */
2007 function reset_login_count() {
2008     global $SESSION;
2009
2010     $SESSION->logincount = 0;
2011 }
2012
2013 function sync_metacourses() {
2014
2015     global $CFG;
2016
2017     if (!$courses = get_records('course', 'metacourse', 1)) {
2018         return;
2019     }
2020
2021     foreach ($courses as $course) {
2022         sync_metacourse($course);
2023     }
2024 }
2025
2026 /**
2027  * Goes through all enrolment records for the courses inside the metacourse and sync with them.
2028  *
2029  * @param mixed $course the metacourse to synch. Either the course object itself, or the courseid.
2030  */
2031 function sync_metacourse($course) {
2032     global $CFG;
2033
2034     // Check the course is valid.
2035     if (!is_object($course)) {
2036         if (!$course = get_record('course', 'id', $course)) {
2037             return false; // invalid course id
2038         }
2039     }
2040
2041     // Check that we actually have a metacourse.
2042     if (empty($course->metacourse)) {
2043         return false;
2044     }
2045
2046     // Get a list of roles that should not be synced.
2047     if ($CFG->nonmetacoursesyncroleids) {
2048         $roleexclusions = 'ra.roleid NOT IN (' . $CFG->nonmetacoursesyncroleids . ') AND';
2049     } else {
2050         $roleexclusions = '';
2051     }
2052
2053     // Get the context of the metacourse.
2054     $context = get_context_instance(CONTEXT_COURSE, $course->id); // SITEID can not be a metacourse
2055
2056     // We do not ever want to unassign the list of metacourse manager, so get a list of them.
2057     if ($users = get_users_by_capability($context, 'moodle/course:managemetacourse')) {
2058         $managers = array_keys($users);
2059     } else {
2060         $managers = array();
2061     }
2062
2063     // Get assignments of a user to a role that exist in a child course, but
2064     // not in the meta coure. That is, get a list of the assignments that need to be made.
2065     if (!$assignments = get_records_sql("
2066             SELECT
2067                 ra.id, ra.roleid, ra.userid
2068             FROM
2069                 {$CFG->prefix}role_assignments ra,
2070                 {$CFG->prefix}context con,
2071                 {$CFG->prefix}course_meta cm
2072             WHERE
2073                 ra.contextid = con.id AND
2074                 con.contextlevel = " . CONTEXT_COURSE . " AND
2075                 con.instanceid = cm.child_course AND
2076                 cm.parent_course = {$course->id} AND
2077                 $roleexclusions
2078                 NOT EXISTS (
2079                     SELECT 1 FROM
2080                         {$CFG->prefix}role_assignments ra2
2081                     WHERE
2082                         ra2.userid = ra.userid AND
2083                         ra2.roleid = ra.roleid AND
2084                         ra2.contextid = {$context->id}
2085                 )
2086     ")) {
2087         $assignments = array();
2088     }
2089
2090     // Get assignments of a user to a role that exist in the meta course, but
2091     // not in any child courses. That is, get a list of the unassignments that need to be made.
2092     if (!$unassignments = get_records_sql("
2093             SELECT
2094                 ra.id, ra.roleid, ra.userid
2095             FROM
2096                 {$CFG->prefix}role_assignments ra
2097             WHERE
2098                 ra.contextid = {$context->id} AND
2099                 $roleexclusions
2100                 NOT EXISTS (
2101                     SELECT 1 FROM
2102                         {$CFG->prefix}role_assignments ra2,
2103                         {$CFG->prefix}context con2,
2104                         {$CFG->prefix}course_meta cm
2105                     WHERE
2106                         ra2.userid = ra.userid AND
2107                         ra2.roleid = ra.roleid AND
2108                         ra2.contextid = con2.id AND
2109                         con2.contextlevel = " . CONTEXT_COURSE . " AND
2110                         con2.instanceid = cm.child_course AND
2111                         cm.parent_course = {$course->id}
2112                 )
2113     ")) {
2114         $unassignments = array();
2115     }
2116
2117     $success = true;
2118
2119     // Make the unassignments, if they are not managers.
2120     foreach ($unassignments as $unassignment) {
2121         if (!in_array($unassignment->userid, $managers)) {
2122             $success = role_unassign($unassignment->roleid, $unassignment->userid, 0, $context->id) && $success;
2123         }
2124     }
2125
2126     // Make the assignments.
2127     foreach ($assignments as $assignment) {
2128         $success = role_assign($assignment->roleid, $assignment->userid, 0, $context->id) && $success;
2129     }
2130
2131     return $success;
2132
2133 // TODO: finish timeend and timestart
2134 // maybe we could rely on cron job to do the cleaning from time to time
2135 }
2136
2137 /**
2138  * Adds a record to the metacourse table and calls sync_metacoures
2139  */
2140 function add_to_metacourse ($metacourseid, $courseid) {
2141
2142     if (!$metacourse = get_record("course","id",$metacourseid)) {
2143         return false;
2144     }
2145
2146     if (!$course = get_record("course","id",$courseid)) {
2147         return false;
2148     }
2149
2150     if (!$record = get_record("course_meta","parent_course",$metacourseid,"child_course",$courseid)) {
2151         $rec = new object();
2152         $rec->parent_course = $metacourseid;
2153         $rec->child_course = $courseid;
2154         if (!insert_record('course_meta',$rec)) {
2155             return false;
2156         }
2157         return sync_metacourse($metacourseid);
2158     }
2159     return true;
2160
2161 }
2162
2163 /**
2164  * Removes the record from the metacourse table and calls sync_metacourse
2165  */
2166 function remove_from_metacourse($metacourseid, $courseid) {
2167
2168     if (delete_records('course_meta','parent_course',$metacourseid,'child_course',$courseid)) {
2169         return sync_metacourse($metacourseid);
2170     }
2171     return false;
2172 }
2173
2174
2175 /**
2176  * Determines if a user is currently logged in
2177  *
2178  * @uses $USER
2179  * @return bool
2180  */
2181 function isloggedin() {
2182     global $USER;
2183
2184     return (!empty($USER->id));
2185 }
2186
2187 /**
2188  * Determines if a user is logged in as real guest user with username 'guest'.
2189  * This function is similar to original isguest() in 1.6 and earlier.
2190  * Current isguest() is deprecated - do not use it anymore.
2191  *
2192  * @param $user mixed user object or id, $USER if not specified
2193  * @return bool true if user is the real guest user, false if not logged in or other user
2194  */
2195 function isguestuser($user=NULL) {
2196     global $USER;
2197     if ($user === NULL) {
2198         $user = $USER;
2199     } else if (is_numeric($user)) {
2200         $user = get_record('user', 'id', $user, '', '', '', '', 'id, username');
2201     }
2202
2203     if (empty($user->id)) {
2204         return false; // not logged in, can not be guest
2205     }
2206
2207     return ($user->username == 'guest');
2208 }
2209
2210 /**
2211  * Determines if the currently logged in user is in editing mode
2212  *
2213  * @uses $USER
2214  * @param int $courseid The id of the course being tested
2215  * @param user $user A {@link $USER} object. If null then the currently logged in user is used.
2216  * @return bool
2217  */
2218 function isediting($courseid, $user=NULL) {
2219     global $USER;
2220     if (!$user) {
2221         $user = $USER;
2222     }
2223     if (empty($user->editing)) {
2224         return false;
2225     }
2226
2227     $capcheck = false;
2228     $coursecontext = get_context_instance(CONTEXT_COURSE, $courseid);
2229
2230     if (has_capability('moodle/course:manageactivities', $coursecontext) ||
2231         has_capability('moodle/site:manageblocks', $coursecontext)) {
2232         $capcheck = true;
2233     } else {
2234         // loop through all child context, see if user has moodle/course:manageactivities or moodle/site:manageblocks
2235         if ($children = get_child_contexts($coursecontext)) {
2236             foreach ($children as $child) {
2237                 $childcontext = get_record('context', 'id', $child);
2238                 if (has_capability('moodle/course:manageactivities', $childcontext) ||
2239                     has_capability('moodle/site:manageblocks', $childcontext)) {
2240                     $capcheck = true;
2241                     break;
2242                 }
2243             }
2244         }
2245     }
2246
2247     return ($user->editing && $capcheck);
2248     //return ($user->editing and has_capability('moodle/course:manageactivities', get_context_instance(CONTEXT_COURSE, $courseid)));
2249 }
2250
2251 /**
2252  * Determines if the logged in user is currently moving an activity
2253  *
2254  * @uses $USER
2255  * @param int $courseid The id of the course being tested
2256  * @return bool
2257  */
2258 function ismoving($courseid) {
2259     global $USER;
2260
2261     if (!empty($USER->activitycopy)) {
2262         return ($USER->activitycopycourse == $courseid);
2263     }
2264     return false;
2265 }
2266
2267 /**
2268  * Given an object containing firstname and lastname
2269  * values, this function returns a string with the
2270  * full name of the person.
2271  * The result may depend on system settings
2272  * or language.  'override' will force both names
2273  * to be used even if system settings specify one.
2274  *
2275  * @uses $CFG
2276  * @uses $SESSION
2277  * @param object $user A {@link $USER} object to get full name of
2278  * @param bool $override If true then the name will be first name followed by last name rather than adhering to fullnamedisplay setting.
2279  */
2280 function fullname($user, $override=false) {
2281
2282     global $CFG, $SESSION;
2283
2284     if (!isset($user->firstname) and !isset($user->lastname)) {
2285         return '';
2286     }
2287
2288     if (!$override) {
2289         if (!empty($CFG->forcefirstname)) {
2290             $user->firstname = $CFG->forcefirstname;
2291         }
2292         if (!empty($CFG->forcelastname)) {
2293             $user->lastname = $CFG->forcelastname;
2294         }
2295     }
2296
2297     if (!empty($SESSION->fullnamedisplay)) {
2298         $CFG->fullnamedisplay = $SESSION->fullnamedisplay;
2299     }
2300
2301     if ($CFG->fullnamedisplay == 'firstname lastname') {
2302         return $user->firstname .' '. $user->lastname;
2303
2304     } else if ($CFG->fullnamedisplay == 'lastname firstname') {
2305         return $user->lastname .' '. $user->firstname;
2306
2307     } else if ($CFG->fullnamedisplay == 'firstname') {
2308         if ($override) {
2309             return get_string('fullnamedisplay', '', $user);
2310         } else {
2311             return $user->firstname;
2312         }
2313     }
2314
2315     return get_string('fullnamedisplay', '', $user);
2316 }
2317
2318 /**
2319  * Sets a moodle cookie with an encrypted string
2320  *
2321  * @uses $CFG
2322  * @uses DAYSECS
2323  * @uses HOURSECS
2324  * @param string $thing The string to encrypt and place in a cookie
2325  */
2326 function set_moodle_cookie($thing) {
2327     global $CFG;
2328
2329     if ($thing == 'guest') {  // Ignore guest account
2330         return;
2331     }
2332
2333     $cookiename = 'MOODLEID_'.$CFG->sessioncookie;
2334
2335     $days = 60;
2336     $seconds = DAYSECS*$days;
2337
2338     setCookie($cookiename, '', time() - HOURSECS, '/');
2339     setCookie($cookiename, rc4encrypt($thing), time()+$seconds, '/');
2340 }
2341
2342 /**
2343  * Gets a moodle cookie with an encrypted string
2344  *
2345  * @uses $CFG
2346  * @return string
2347  */
2348 function get_moodle_cookie() {
2349     global $CFG;
2350
2351     $cookiename = 'MOODLEID_'.$CFG->sessioncookie;
2352
2353     if (empty($_COOKIE[$cookiename])) {
2354         return '';
2355     } else {
2356         $thing = rc4decrypt($_COOKIE[$cookiename]);
2357         return ($thing == 'guest') ? '': $thing;  // Ignore guest account
2358     }
2359 }
2360
2361 /**
2362  * Returns whether a given authentication plugin exists.
2363  *
2364  * @uses $CFG
2365  * @param string $auth Form of authentication to check for. Defaults to the
2366  *        global setting in {@link $CFG}.
2367  * @return boolean Whether the plugin is available.
2368  */
2369 function exists_auth_plugin($auth) {
2370     global $CFG;
2371
2372     if (file_exists("{$CFG->dirroot}/auth/$auth/auth.php")) {
2373         return is_readable("{$CFG->dirroot}/auth/$auth/auth.php");
2374     }
2375     return false;
2376 }
2377
2378 /**
2379  * Checks if a given plugin is in the list of enabled authentication plugins.
2380  *
2381  * @param string $auth Authentication plugin.
2382  * @return boolean Whether the plugin is enabled.
2383  */
2384 function is_enabled_auth($auth) {
2385     global $CFG;
2386
2387     if (empty($auth)) {
2388         return false;
2389     } else if ($auth == 'manual') {
2390         return true;
2391     }
2392
2393     return in_array($auth, explode(',', $CFG->auth));
2394 }
2395
2396 /**
2397  * Returns an authentication plugin instance.
2398  *
2399  * @uses $CFG
2400  * @param string $auth name of authentication plugin
2401  * @return object An instance of the required authentication plugin.
2402  */
2403 function get_auth_plugin($auth) {
2404     global $CFG;
2405
2406     // check the plugin exists first
2407     if (! exists_auth_plugin($auth)) {
2408         error("Authentication plugin '$auth' not found.");
2409     }
2410
2411     // return auth plugin instance
2412     require_once "{$CFG->dirroot}/auth/$auth/auth.php";
2413     $class = "auth_plugin_$auth";
2414     return new $class;
2415 }
2416
2417 /**
2418  * Returns true if an internal authentication method is being used.
2419  * if method not specified then, global default is assumed
2420  *
2421  * @uses $CFG
2422  * @param string $auth Form of authentication required
2423  * @return bool
2424  */
2425 function is_internal_auth($auth) {
2426     $authplugin = get_auth_plugin($auth); // throws error if bad $auth
2427     return $authplugin->is_internal();
2428 }
2429
2430 /**
2431  * Returns an array of user fields
2432  *
2433  * @uses $CFG
2434  * @uses $db
2435  * @return array User field/column names
2436  */
2437 function get_user_fieldnames() {
2438
2439     global $CFG, $db;
2440
2441     $fieldarray = $db->MetaColumnNames($CFG->prefix.'user');
2442     unset($fieldarray['ID']);
2443
2444     return $fieldarray;
2445 }
2446
2447 /**
2448  * Creates a bare-bones user record
2449  *
2450  * @uses $CFG
2451  * @param string $username New user's username to add to record
2452  * @param string $password New user's password to add to record
2453  * @param string $auth Form of authentication required
2454  * @return object A {@link $USER} object
2455  * @todo Outline auth types and provide code example
2456  */
2457 function create_user_record($username, $password, $auth='') {
2458     global $CFG;
2459
2460     //just in case check text case
2461     $username = trim(moodle_strtolower($username));
2462
2463     $authplugin = get_auth_plugin($auth);
2464
2465     if (method_exists($authplugin, 'get_userinfo')) {
2466         if ($newinfo = $authplugin->get_userinfo($username)) {
2467             $newinfo = truncate_userinfo($newinfo);
2468             foreach ($newinfo as $key => $value){
2469                 $newuser->$key = addslashes($value);
2470             }
2471         }
2472     }
2473
2474     if (!empty($newuser->email)) {
2475         if (email_is_not_allowed($newuser->email)) {
2476             unset($newuser->email);
2477         }
2478     }
2479
2480     $newuser->auth = (empty($auth)) ? 'manual' : $auth;
2481     $newuser->username = $username;
2482
2483     // fix for MDL-8480
2484     // user CFG lang for user if $newuser->lang is empty
2485     // or $user->lang is not an installed language
2486     $sitelangs = array_keys(get_list_of_languages());
2487     if (empty($newuser->lang) || !in_array($newuser->lang, $sitelangs)) {
2488         $newuser -> lang = $CFG->lang;
2489     }
2490     $newuser->confirmed = 1;
2491     $newuser->lastip = getremoteaddr();
2492     $newuser->timemodified = time();
2493     $newuser->mnethostid = $CFG->mnet_localhost_id;
2494
2495     if (insert_record('user', $newuser)) {
2496         $user = get_complete_user_data('username', $newuser->username);
2497         if($CFG->{'auth_'.$newuser->auth.'_forcechangepassword'}){
2498             set_user_preference('auth_forcepasswordchange', 1, $user->id);
2499         }
2500         update_internal_user_password($user, $password);
2501         return $user;
2502     }
2503     return false;
2504 }
2505
2506 /**
2507  * Will update a local user record from an external source
2508  *
2509  * @uses $CFG
2510  * @param string $username New user's username to add to record
2511  * @return user A {@link $USER} object
2512  */
2513 function update_user_record($username, $authplugin) {
2514     if (method_exists($authplugin, 'get_userinfo')) {
2515         $username = trim(moodle_strtolower($username)); /// just in case check text case
2516
2517         $oldinfo = get_record('user', 'username', $username, '','','','', 'username, auth');
2518         $userauth = get_auth_plugin($oldinfo->auth);
2519
2520         if ($newinfo = $authplugin->get_userinfo($username)) {
2521             $newinfo = truncate_userinfo($newinfo);
2522             foreach ($newinfo as $key => $value){
2523                 $confkey = 'field_updatelocal_' . $key;
2524                 if (!empty($userauth->config->$confkey) and $userauth->config->$confkey === 'onlogin') {
2525                     $value = addslashes(stripslashes($value));   // Just in case
2526                     set_field('user', $key, $value, 'username', $username)
2527                         or error_log("Error updating $key for $username");
2528                 }
2529             }
2530         }
2531     }
2532     return get_complete_user_data('username', $username);
2533 }
2534
2535 function truncate_userinfo($info) {
2536 /// will truncate userinfo as it comes from auth_get_userinfo (from external auth)
2537 /// which may have large fields
2538
2539     // define the limits
2540     $limit = array(
2541                     'username'    => 100,
2542                     'idnumber'    =>  64,
2543                     'firstname'   => 100,
2544                     'lastname'    => 100,
2545                     'email'       => 100,
2546                     'icq'         =>  15,
2547                     'phone1'      =>  20,
2548                     'phone2'      =>  20,
2549                     'institution' =>  40,
2550                     'department'  =>  30,
2551                     'address'     =>  70,
2552                     'city'        =>  20,
2553                     'country'     =>   2,
2554                     'url'         => 255,
2555                     );
2556
2557     // apply where needed
2558     foreach (array_keys($info) as $key) {
2559         if (!empty($limit[$key])) {
2560             $info[$key] = trim(substr($info[$key],0, $limit[$key]));
2561         }
2562     }
2563
2564     return $info;
2565 }
2566
2567 /**
2568  * Retrieve the guest user object
2569  *
2570  * @uses $CFG
2571  * @return user A {@link $USER} object
2572  */
2573 function guest_user() {
2574     global $CFG;
2575
2576     if ($newuser = get_record('user', 'username', 'guest')) {
2577         $newuser->confirmed = 1;
2578         $newuser->lang = $CFG->lang;
2579         $newuser->lastip = getremoteaddr();
2580     }
2581
2582     return $newuser;
2583 }
2584
2585 /**
2586  * Given a username and password, this function looks them
2587  * up using the currently selected authentication mechanism,
2588  * and if the authentication is successful, it returns a
2589  * valid $user object from the 'user' table.
2590  *
2591  * Uses auth_ functions from the currently active auth module
2592  *
2593  * @uses $CFG
2594  * @param string $username  User's username
2595  * @param string $password  User's password
2596  * @return user|flase A {@link $USER} object or false if error
2597  */
2598 function authenticate_user_login($username, $password) {
2599
2600     global $CFG;
2601
2602     if (empty($CFG->auth)) {
2603         $authsenabled = array('manual');
2604     } else {
2605         $authsenabled = explode(',', 'manual,'.$CFG->auth);
2606     }
2607
2608     if ($user = get_complete_user_data('username', $username)) {
2609         $auth = empty($user->auth) ? 'manual' : $user->auth;  // use manual if auth not set
2610         if ($auth=='nologin' or !is_enabled_auth($auth)) {
2611             add_to_log(0, 'login', 'error', 'index.php', $username);
2612             error_log('[client '.$_SERVER['REMOTE_ADDR']."]  $CFG->wwwroot  Disabled Login:  $username  ".$_SERVER['HTTP_USER_AGENT']);
2613             return false;
2614         }
2615         if (!empty($user->deleted)) {
2616             add_to_log(0, 'login', 'error', 'index.php', $username);
2617             error_log('[client '.$_SERVER['REMOTE_ADDR']."]  $CFG->wwwroot  Deleted Login:  $username  ".$_SERVER['HTTP_USER_AGENT']);
2618             return false;
2619         }
2620         $auths = array($auth);
2621
2622     } else {
2623         $auths = $authsenabled;
2624         $user = new object();
2625         $user->id = 0;     // User does not exist
2626     }
2627
2628     foreach ($auths as $auth) {
2629         $authplugin = get_auth_plugin($auth);
2630
2631         // on auth fail fall through to the next plugin
2632         if (!$authplugin->user_login($username, $password)) {
2633             continue;
2634         }
2635
2636         // successful authentication
2637         if ($user->id) {                          // User already exists in database
2638             if (empty($user->auth)) {             // For some reason auth isn't set yet
2639                 set_field('user', 'auth', $auth, 'username', $username);
2640                 $user->auth = $auth;
2641             }
2642
2643             update_internal_user_password($user, $password); // just in case salt or encoding were changed (magic quotes too one day)
2644
2645             if (!$authplugin->is_internal()) {            // update user record from external DB
2646                 $user = update_user_record($username, get_auth_plugin($user->auth));
2647             }
2648         } else {
2649             // if user not found, create him
2650             $user = create_user_record($username, $password, $auth);
2651         }
2652         // fix for MDL-6928
2653         if (method_exists($authplugin, 'iscreator')) {
2654             $sitecontext = get_context_instance(CONTEXT_SYSTEM);
2655             if ($creatorroles = get_roles_with_capability('moodle/legacy:coursecreator', CAP_ALLOW)) {
2656                 $creatorrole = array_shift($creatorroles); // We can only use one, let's use the first one
2657                 // Check if the user is a creator
2658                 if ($authplugin->iscreator($username)) { // Following calls will not create duplicates
2659                     role_assign($creatorrole->id, $user->id, 0, $sitecontext->id, 0, 0, 0, $auth);
2660                 } else {
2661                     role_unassign($creatorrole->id, $user->id, 0, $sitecontext->id);
2662                 }
2663             }
2664         }
2665
2666     /// Log in to a second system if necessary
2667         if (!empty($CFG->sso)) {
2668             include_once($CFG->dirroot .'/sso/'. $CFG->sso .'/lib.php');
2669             if (function_exists('sso_user_login')) {
2670                 if (!sso_user_login($username, $password)) {   // Perform the signon process
2671                     notify('Second sign-on failed');
2672                 }
2673             }
2674         }
2675
2676         return $user;
2677
2678     }
2679
2680     // failed if all the plugins have failed
2681     add_to_log(0, 'login', 'error', 'index.php', $username);
2682     error_log('[client '.$_SERVER['REMOTE_ADDR']."]  $CFG->wwwroot  Failed Login:  $username  ".$_SERVER['HTTP_USER_AGENT']);
2683     return false;
2684 }
2685
2686 /**
2687  * Compare password against hash stored in internal user table.
2688  * If necessary it also updates the stored hash to new format.
2689  *
2690  * @param object user
2691  * @param string plain text password
2692  * @return bool is password valid?
2693  */
2694 function validate_internal_user_password(&$user, $password) {
2695     global $CFG;
2696
2697     if (!isset($CFG->passwordsaltmain)) {
2698         $CFG->passwordsaltmain = '';
2699     }
2700
2701     $validated = false;
2702
2703         // get password original encoding in case it was not updated to unicode yet
2704     $textlib = textlib_get_instance();
2705     $convpassword = $textlib->convert($password, 'utf-8', get_string('oldcharset'));
2706
2707     if ($user->password == md5($password.$CFG->passwordsaltmain) or $user->password == md5($password)
2708         or $user->password == md5($convpassword.$CFG->passwordsaltmain) or $user->password == md5($convpassword)) {
2709         $validated = true;
2710     } else {
2711         for ($i=1; $i<=20; $i++) { //20 alternative salts should be enough, right?
2712             $alt = 'passwordsaltalt'.$i;
2713             if (!empty($CFG->$alt)) {
2714                 if ($user->password == md5($password.$CFG->$alt) or $user->password == md5($convpassword.$CFG->$alt)) {
2715                     $validated = true;
2716                     break;
2717                 }
2718             }
2719         }
2720     }
2721
2722     if ($validated) {
2723         // force update of password hash using latest main password salt and encoding if needed
2724         update_internal_user_password($user, $password);
2725     }
2726
2727     return $validated;
2728 }
2729
2730 /**
2731  * Calculate hashed value from password using current hash mechanism.
2732  *
2733  * @param string password
2734  * @return string password hash
2735  */
2736 function hash_internal_user_password($password) {
2737     global $CFG;
2738
2739     if (isset($CFG->passwordsaltmain)) {
2740         return md5($password.$CFG->passwordsaltmain);
2741     } else {
2742         return md5($password);
2743     }
2744 }
2745
2746 /**
2747  * Update pssword hash in user object.
2748  *
2749  * @param object user
2750  * @param string plain text password
2751  * @param bool store changes also in db, default true
2752  * @return true if hash changed
2753  */
2754 function update_internal_user_password(&$user, $password) {
2755     global $CFG;
2756
2757     $authplugin = get_auth_plugin($user->auth);
2758     if (!empty($authplugin->config->preventpassindb)) {
2759         $hashedpassword = 'not cached';
2760     } else {
2761         $hashedpassword = hash_internal_user_password($password);
2762     }
2763
2764     return set_field('user', 'password',  $hashedpassword, 'id', $user->id);
2765 }
2766
2767 /**
2768  * Get a complete user record, which includes all the info
2769  * in the user record
2770  * Intended for setting as $USER session variable
2771  *
2772  * @uses $CFG
2773  * @uses SITEID
2774  * @param string $field The user field to be checked for a given value.
2775  * @param string $value The value to match for $field.
2776  * @return user A {@link $USER} object.
2777  */
2778 function get_complete_user_data($field, $value, $mnethostid=null) {
2779
2780     global $CFG;
2781
2782     if (!$field || !$value) {
2783         return false;
2784     }
2785
2786 /// Build the WHERE clause for an SQL query
2787
2788     $constraints = $field .' = \''. $value .'\' AND deleted <> \'1\'';
2789
2790     if (is_null($mnethostid)) {
2791         // if null, we restrict to local users
2792         // ** testing for local user can be done with
2793         //    mnethostid = $CFG->mnet_localhost_id
2794         //    or with
2795         //    auth != 'mnet'
2796         //    but the first one is FAST with our indexes
2797         $mnethostid = $CFG->mnet_localhost_id;
2798     }
2799     $mnethostid = (int)$mnethostid;
2800     $constraints .= ' AND mnethostid = \''.$mnethostid.'\'';
2801
2802 /// Get all the basic user data
2803
2804     if (! $user = get_record_select('user', $constraints)) {
2805         return false;
2806     }
2807
2808 /// Get various settings and preferences
2809
2810     if ($displays = get_records('course_display', 'userid', $user->id)) {
2811         foreach ($displays as $display) {
2812             $user->display[$display->course] = $display->display;
2813         }
2814     }
2815
2816     $user->preference = get_user_preferences(null, null, $user->id);
2817
2818     if ($lastaccesses = get_records('user_lastaccess', 'userid', $user->id)) {
2819         foreach ($lastaccesses as $lastaccess) {
2820             $user->lastcourseaccess[$lastaccess->courseid] = $lastaccess->timeaccess;
2821         }
2822     }
2823
2824     if ($groupids = groups_get_all_groups_for_user($user->id)) { //TODO:check.
2825         foreach ($groupids as $groupid) {
2826             $courseid = groups_get_course($groupid);
2827             //change this to 2D array so we can put multiple groups in a course
2828             $user->groupmember[$courseid][] = $groupid;
2829         }
2830     }
2831
2832 /// Rewrite some variables if necessary
2833     if (!empty($user->description)) {
2834         $user->description = true;   // No need to cart all of it around
2835     }
2836     if ($user->username == 'guest') {
2837         $user->lang       = $CFG->lang;               // Guest language always same as site
2838         $user->firstname  = get_string('guestuser');  // Name always in current language
2839         $user->lastname   = ' ';
2840     }
2841
2842     $user->sesskey  = random_string(10);
2843     $user->sessionIP = md5(getremoteaddr());   // Store the current IP in the session
2844
2845     return $user;
2846 }
2847
2848
2849
2850 /*
2851  * When logging in, this function is run to set certain preferences
2852  * for the current SESSION
2853  */
2854 function set_login_session_preferences() {
2855     global $SESSION, $CFG;
2856
2857     $SESSION->justloggedin = true;
2858
2859     unset($SESSION->lang);
2860
2861     // Restore the calendar filters, if saved
2862     if (intval(get_user_preferences('calendar_persistflt', 0))) {
2863         include_once($CFG->dirroot.'/calendar/lib.php');
2864         calendar_set_filters_status(get_user_preferences('calendav_savedflt', 0xff));
2865     }
2866 }
2867
2868
2869 /**
2870  * Delete a course, including all related data from the database,
2871  * and any associated files from the moodledata folder.
2872  *
2873  * @param int $courseid The id of the course to delete.
2874  * @param bool $showfeedback Whether to display notifications of each action the function performs.
2875  * @return bool true if all the removals succeeded. false if there were any failures. If this
2876  *             method returns false, some of the removals will probably have succeeded, and others
2877  *             failed, but you have no way of knowing which.
2878  */
2879 function delete_course($courseid, $showfeedback = true) {
2880     global $CFG;
2881     $result = true;
2882
2883     if (!remove_course_contents($courseid, $showfeedback)) {
2884         if ($showfeedback) {
2885             notify("An error occurred while deleting some of the course contents.");
2886         }
2887         $result = false;
2888     }
2889
2890     if (!delete_records("course", "id", $courseid)) {
2891         if ($showfeedback) {
2892             notify("An error occurred while deleting the main course record.");
2893         }
2894         $result = false;
2895     }
2896
2897     if (!delete_records('context', 'contextlevel', CONTEXT_COURSE, 'instanceid', $courseid)) {
2898         if ($showfeedback) {
2899             notify("An error occurred while deleting the main context record.");
2900         }
2901         $result = false;
2902     }
2903
2904     if (!fulldelete($CFG->dataroot.'/'.$courseid)) {
2905         if ($showfeedback) {
2906             notify("An error occurred while deleting the course files.");
2907         }
2908         $result = false;
2909     }
2910
2911     return $result;
2912 }
2913
2914 /**
2915  * Clear a course out completely, deleting all content
2916  * but don't delete the course itself
2917  *
2918  * @uses $CFG
2919  * @param int $courseid The id of the course that is being deleted
2920  * @param bool $showfeedback Whether to display notifications of each action the function performs.
2921  * @return bool true if all the removals succeeded. false if there were any failures. If this
2922  *             method returns false, some of the removals will probably have succeeded, and others
2923  *             failed, but you have no way of knowing which.
2924  */
2925 function remove_course_contents($courseid, $showfeedback=true) {
2926
2927     global $CFG;
2928
2929     $result = true;
2930
2931     if (! $course = get_record('course', 'id', $courseid)) {
2932         error('Course ID was incorrect (can\'t find it)');
2933     }
2934
2935     $strdeleted = get_string('deleted');
2936
2937 /// First delete every instance of every module
2938
2939     if ($allmods = get_records('modules') ) {
2940         foreach ($allmods as $mod) {
2941             $modname = $mod->name;
2942             $modfile = $CFG->dirroot .'/mod/'. $modname .'/lib.php';
2943             $moddelete = $modname .'_delete_instance';       // Delete everything connected to an instance
2944             $moddeletecourse = $modname .'_delete_course';   // Delete other stray stuff (uncommon)
2945             $count=0;
2946             if (file_exists($modfile)) {
2947                 include_once($modfile);
2948                 if (function_exists($moddelete)) {
2949                     if ($instances = get_records($modname, 'course', $course->id)) {
2950                         foreach ($instances as $instance) {
2951                             if ($cm = get_coursemodule_from_instance($modname, $instance->id, $course->id)) {
2952                                 delete_context(CONTEXT_MODULE, $cm->id);
2953                             }
2954                             if ($moddelete($instance->id)) {
2955                                 $count++;
2956
2957                             } else {
2958                                 notify('Could not delete '. $modname .' instance '. $instance->id .' ('. format_string($instance->name) .')');
2959                                 $result = false;
2960                             }
2961                         }
2962                     }
2963                 } else {
2964                     notify('Function '. $moddelete() .'doesn\'t exist!');
2965                     $result = false;
2966                 }
2967
2968                 if (function_exists($moddeletecourse)) {
2969                     $moddeletecourse($course, $showfeedback);
2970                 }
2971             }
2972             if ($showfeedback) {
2973                 notify($strdeleted .' '. $count .' x '. $modname);
2974             }
2975         }
2976     } else {
2977         error('No modules are installed!');
2978     }
2979
2980 /// Give local code a chance to delete its references to this course.
2981     require_once('locallib.php');
2982     notify_local_delete_course($courseid, $showfeedback);
2983
2984 /// Delete course blocks
2985
2986     if ($blocks = get_records_sql("SELECT *
2987                                    FROM {$CFG->prefix}block_instance
2988                                    WHERE pagetype = '".PAGE_COURSE_VIEW."'
2989                                    AND pageid = $course->id")) {
2990         if (delete_records('block_instance', 'pagetype', PAGE_COURSE_VIEW, 'pageid', $course->id)) {
2991             if ($showfeedback) {
2992                 notify($strdeleted .' block_instance');
2993             }
2994             foreach ($blocks as $block) {  /// Delete any associated contexts for this block
2995                 delete_context(CONTEXT_BLOCK, $block->id);
2996             }
2997         } else {
2998             $result = false;
2999         }
3000     }
3001
3002 /// Delete any groups, removing members and grouping/course links first.
3003     //TODO: If groups or groupings are to be shared between courses, think again!
3004     if ($groupids = groups_get_groups($course->id)) {
3005         foreach ($groupids as $groupid) {
3006             if (groups_remove_all_members($groupid)) {
3007                 if ($showfeedback) {
3008                     notify($strdeleted .' groups_members');
3009                 }
3010             } else {
3011                 $result = false;
3012             }
3013             /// Delete any associated context for this group ??
3014             delete_context(CONTEXT_GROUP, $groupid);
3015
3016             if (groups_delete_group($groupid)) {
3017                 if ($showfeedback) {
3018                     notify($strdeleted .' groups');
3019                 }
3020             } else {
3021                 $result = false;
3022             }
3023         }
3024     }
3025 /// Delete any groupings.
3026     $result = groups_delete_all_groupings($course->id);
3027     if ($result && $showfeedback) {
3028         notify($strdeleted .' groupings');
3029     }
3030
3031 /// Delete all related records in other tables that may have a courseid
3032 /// This array stores the tables that need to be cleared, as
3033 /// table_name => column_name that contains the course id.
3034
3035     $tablestoclear = array(
3036         'event' => 'courseid', // Delete events
3037         'log' => 'course', // Delete logs
3038         'course_sections' => 'course', // Delete any course stuff
3039         'course_modules' => 'course',
3040         'grade_category' => 'courseid', // Delete gradebook stuff
3041         'grade_exceptions' => 'courseid',
3042         'grade_item' => 'courseid',
3043         'grade_letter' => 'courseid',
3044         'grade_preferences' => 'courseid',
3045         'backup_courses' => 'courseid', // Delete scheduled backup stuff
3046         'backup_log' => 'courseid'
3047     );
3048     foreach ($tablestoclear as $table => $col) {
3049         if (delete_records($table, $col, $course->id)) {
3050             if ($showfeedback) {
3051                 notify($strdeleted . ' ' . $table);
3052             }
3053         } else {
3054             $result = false;
3055         }
3056     }
3057
3058
3059 /// Clean up metacourse stuff
3060
3061     if ($course->metacourse) {
3062         delete_records("course_meta","parent_course",$course->id);
3063         sync_metacourse($course->id); // have to do it here so the enrolments get nuked. sync_metacourses won't find it without the id.
3064         if ($showfeedback) {
3065             notify("$strdeleted course_meta");
3066         }
3067     } else {
3068         if ($parents = get_records("course_meta","child_course",$course->id)) {
3069             foreach ($parents as $parent) {
3070                 remove_from_metacourse($parent->parent_course,$parent->child_course); // this will do the unenrolments as well.
3071             }
3072             if ($showfeedback) {
3073                 notify("$strdeleted course_meta");
3074             }
3075         }
3076     }
3077
3078 /// Delete questions and question categories
3079     include_once($CFG->libdir.'/questionlib.php');
3080     question_delete_course($course, $showfeedback);
3081
3082 /// Delete all roles and overiddes in the course context (but keep the course context)
3083     if ($courseid != SITEID) {
3084         delete_context(CONTEXT_COURSE, $course->id);
3085     }
3086
3087     return $result;
3088 }
3089
3090
3091 /**
3092  * This function will empty a course of USER data as much as
3093 /// possible. It will retain the activities and the structure
3094 /// of the course.
3095  *
3096  * @uses $USER
3097  * @uses $SESSION
3098  * @uses $CFG
3099  * @param object $data an object containing all the boolean settings and courseid
3100  * @param bool $showfeedback  if false then do it all silently
3101  * @return bool
3102  * @todo Finish documenting this function
3103  */
3104 function reset_course_userdata($data, $showfeedback=true) {
3105
3106     global $CFG, $USER, $SESSION;
3107
3108     $result = true;
3109
3110     $strdeleted = get_string('deleted');
3111
3112     // Look in every instance of every module for data to delete
3113
3114     if ($allmods = get_records('modules') ) {
3115         foreach ($allmods as $mod) {
3116             $modname = $mod->name;
3117             $modfile = $CFG->dirroot .'/mod/'. $modname .'/lib.php';
3118             $moddeleteuserdata = $modname .'_delete_userdata';   // Function to delete user data
3119             if (file_exists($modfile)) {
3120                 @include_once($modfile);
3121                 if (function_exists($moddeleteuserdata)) {
3122                     $moddeleteuserdata($data, $showfeedback);
3123                 }
3124             }
3125         }
3126     } else {
3127         error('No modules are installed!');
3128     }
3129
3130     // Delete other stuff
3131     $coursecontext = get_context_instance(CONTEXT_COURSE, $data->courseid);
3132
3133     if (!empty($data->reset_students) or !empty($data->reset_teachers)) {
3134         $teachers     = array_keys(get_users_by_capability($coursecontext, 'moodle/course:update'));
3135         $participants = array_keys(get_users_by_capability($coursecontext, 'moodle/course:view'));
3136         $students     = array_diff($participants, $teachers);
3137
3138         if (!empty($data->reset_students)) {
3139             foreach ($students as $studentid) {
3140                 role_unassign(0, $studentid, 0, $coursecontext->id);
3141             }
3142             if ($showfeedback) {
3143                 notify($strdeleted .' '.get_string('students'), 'notifysuccess');
3144             }
3145
3146             /// Delete group members (but keep the groups) TODO:check.
3147             if ($groupids = groups_get_groups($data->courseid)) {
3148                 foreach ($groupids as $groupid) {
3149                     if (groups_remove_all_group_members($groupid)) {
3150                         if ($showfeedback) {
3151                             notify($strdeleted .' groups_members', 'notifysuccess');
3152                         }
3153                     } else {
3154                         $result = false;
3155                     }
3156                 }
3157             }
3158         }
3159
3160         if (!empty($data->reset_teachers)) {
3161             foreach ($teachers as $teacherid) {
3162                 role_unassign(0, $teacherid, 0, $coursecontext->id);
3163             }
3164             if ($showfeedback) {
3165                 notify($strdeleted .' '.get_string('teachers'), 'notifysuccess');
3166             }
3167         }
3168     }
3169
3170     if (!empty($data->reset_groups)) {
3171         if ($groupids = groups_get_groups($data->courseid)) {
3172             foreach ($groupids as $groupid) {
3173                 if (groups_delete_group($groupid)) {
3174                     if ($showfeedback) {
3175                         notify($strdeleted .' groups', 'notifysuccess');
3176                     }
3177                 } else {
3178                     $result = false;
3179                 }
3180             }
3181         }
3182     }
3183
3184     if (!empty($data->reset_events)) {
3185         if (delete_records('event', 'courseid', $data->courseid)) {
3186             if ($showfeedback) {
3187                 notify($strdeleted .' event', 'notifysuccess');
3188             }
3189         } else {
3190             $result = false;
3191         }
3192     }
3193
3194     if (!empty($data->reset_logs)) {
3195         if (delete_records('log', 'course', $data->courseid)) {
3196             if ($showfeedback) {
3197                 notify($strdeleted .' log', 'notifysuccess');
3198             }
3199         } else {
3200             $result = false;
3201         }
3202     }
3203
3204     // deletes all role assignments, and local override, these have no courseid in table and needs separate process
3205     $context = get_context_instance(CONTEXT_COURSE, $data->courseid);
3206     delete_records('role_capabilities', 'contextid', $context->id);
3207
3208     return $result;
3209 }
3210
3211
3212 require_once($CFG->dirroot.'/group/lib.php');
3213 /*TODO: functions moved to /group/lib/legacylib.php
3214
3215 ismember
3216 add_user_to_group
3217 mygroupid
3218 groupmode
3219 set_current_group
3220 ... */
3221
3222
3223 function generate_email_processing_address($modid,$modargs) {
3224     global $CFG;
3225
3226     if (empty($CFG->siteidentifier)) {    // Unique site identification code
3227         set_config('siteidentifier', random_string(32));
3228     }
3229
3230     $header = $CFG->mailprefix . substr(base64_encode(pack('C',$modid)),0,2).$modargs;
3231     return $header . substr(md5($header.$CFG->siteidentifier),0,16).'@'.$CFG->maildomain;
3232 }
3233
3234
3235 function moodle_process_email($modargs,$body) {
3236     // the first char should be an unencoded letter. We'll take this as an action
3237     switch ($modargs{0}) {
3238         case 'B': { // bounce
3239             list(,$userid) = unpack('V',base64_decode(substr($modargs,1,8)));
3240             if ($user = get_record_select("user","id=$userid","id,email")) {
3241                 // check the half md5 of their email
3242                 $md5check = substr(md5($user->email),0,16);
3243                 if ($md5check == substr($modargs, -16)) {
3244                     set_bounce_count($user);
3245                 }
3246                 // else maybe they've already changed it?
3247             }
3248         }
3249         break;
3250         // maybe more later?
3251     }
3252 }
3253
3254 /// CORRESPONDENCE  ////////////////////////////////////////////////
3255
3256 /**
3257  * Send an email to a specified user
3258  *
3259  * @uses $CFG
3260  * @uses $FULLME
3261  * @uses SITEID
3262  * @param user $user  A {@link $USER} object
3263  * @param user $from A {@link $USER} object
3264  * @param string $subject plain text subject line of the email
3265  * @param string $messagetext plain text version of the message
3266  * @param string $messagehtml complete html version of the message (optional)
3267  * @param string $attachment a file on the filesystem, relative to $CFG->dataroot
3268  * @param string $attachname the name of the file (extension indicates MIME)
3269  * @param bool $usetrueaddress determines whether $from email address should
3270  *          be sent out. Will be overruled by user profile setting for maildisplay
3271  * @return bool|string Returns "true" if mail was sent OK, "emailstop" if email
3272  *          was blocked by user and "false" if there was another sort of error.
3273  */
3274 function email_to_user($user, $from, $subject, $messagetext, $messagehtml='', $attachment='', $attachname='', $usetrueaddress=true, $replyto='', $replytoname='') {
3275
3276     global $CFG, $FULLME;
3277
3278     include_once($CFG->libdir .'/phpmailer/class.phpmailer.php');
3279
3280 /// We are going to use textlib services here
3281     $textlib = textlib_get_instance();
3282
3283     if (empty($user)) {
3284         return false;
3285     }
3286
3287     // skip mail to suspended users
3288     if (isset($user->auth) && $user->auth=='nologin') {
3289         return true;
3290     }
3291
3292     if (!empty($user->emailstop)) {
3293         return 'emailstop';
3294     }
3295
3296     if (over_bounce_threshold($user)) {
3297         error_log("User $user->id (".fullname($user).") is over bounce threshold! Not sending.");
3298         return false;
3299     }
3300
3301     $mail = new phpmailer;
3302
3303     $mail->Version = 'Moodle '. $CFG->version;           // mailer version
3304     $mail->PluginDir = $CFG->libdir .'/phpmailer/';      // plugin directory (eg smtp plugin)
3305
3306     $mail->CharSet = 'UTF-8';
3307
3308     if ($CFG->smtphosts == 'qmail') {
3309         $mail->IsQmail();                              // use Qmail system
3310
3311     } else if (empty($CFG->smtphosts)) {
3312         $mail->IsMail();                               // use PHP mail() = sendmail
3313
3314     } else {
3315         $mail->IsSMTP();                               // use SMTP directly
3316         if (!empty($CFG->debugsmtp)) {
3317             echo '<pre>' . "\n";
3318             $mail->SMTPDebug = true;
3319         }
3320         $mail->Host = $CFG->smtphosts;               // specify main and backup servers
3321
3322         if ($CFG->smtpuser) {                          // Use SMTP authentication
3323             $mail->SMTPAuth = true;
3324             $mail->Username = $CFG->smtpuser;
3325             $mail->Password = $CFG->smtppass;
3326         }
3327     }
3328
3329     $adminuser = get_admin();
3330
3331     // make up an email address for handling bounces
3332     if (!empty($CFG->handlebounces)) {
3333         $modargs = 'B'.base64_encode(pack('V',$user->id)).substr(md5($user->email),0,16);
3334         $mail->Sender = generate_email_processing_address(0,$modargs);
3335     }
3336     else {
3337         $mail->Sender   = $adminuser->email;
3338     }
3339
3340     if (is_string($from)) { // So we can pass whatever we want if there is need
3341         $mail->From     = $CFG->noreplyaddress;
3342         $mail->FromName = $from;
3343     } else if ($usetrueaddress and $from->maildisplay) {
3344         $mail->From     = $from->email;
3345         $mail->FromName = fullname($from);
3346     } else {
3347         $mail->From     = $CFG->noreplyaddress;
3348         $mail->FromName = fullname($from);
3349         if (empty($replyto)) {
3350             $mail->AddReplyTo($CFG->noreplyaddress,get_string('noreplyname'));
3351         }
3352     }
3353
3354     if (!empty($replyto)) {
3355         $mail->AddReplyTo($replyto,$replytoname);
3356     }
3357
3358     $mail->Subject = substr(stripslashes($subject), 0, 900);
3359
3360     $mail->AddAddress($user->email, fullname($user) );
3361
3362     $mail->WordWrap = 79;                               // set word wrap
3363
3364     if (!empty($from->customheaders)) {                 // Add custom headers
3365         if (is_array($from->customheaders)) {
3366             foreach ($from->customheaders as $customheader) {
3367                 $mail->AddCustomHeader($customheader);
3368             }
3369         } else {
3370             $mail->AddCustomHeader($from->customheaders);
3371         }
3372     }
3373
3374     if (!empty($from->priority)) {
3375         $mail->Priority = $from->priority;
3376     }
3377
3378     if ($messagehtml && $user->mailformat == 1) { // Don't ever send HTML to users who don't want it
3379         $mail->IsHTML(true);
3380         $mail->Encoding = 'quoted-printable';           // Encoding to use
3381         $mail->Body    =  $messagehtml;
3382         $mail->AltBody =  "\n$messagetext\n";
3383     } else {
3384         $mail->IsHTML(false);
3385         $mail->Body =  "\n$messagetext\n";
3386     }
3387
3388     if ($attachment && $attachname) {
3389         if (ereg( "\\.\\." ,$attachment )) {    // Security check for ".." in dir path
3390             $mail->AddAddress($adminuser->email, fullname($adminuser) );
3391             $mail->AddStringAttachment('Error in attachment.  User attempted to attach a filename with a unsafe name.', 'error.txt', '8bit', 'text/plain');
3392         } else {
3393             require_once($CFG->libdir.'/filelib.php');
3394             $mimetype = mimeinfo('type', $attachname);
3395             $mail->AddAttachment($CFG->dataroot .'/'. $attachment, $attachname, 'base64', $mimetype);
3396         }
3397     }
3398
3399
3400
3401 /// If we are running under Unicode and sitemailcharset or allowusermailcharset are set, convert the email
3402 /// encoding to the specified one
3403     if ((!empty($CFG->sitemailcharset) || !empty($CFG->allowusermailcharset))) {
3404     /// Set it to site mail charset
3405         $charset = $CFG->sitemailcharset;
3406     /// Overwrite it with the user mail charset
3407         if (!empty($CFG->allowusermailcharset)) {
3408             if ($useremailcharset = get_user_preferences('mailcharset', '0', $user->id)) {
3409                 $charset = $useremailcharset;
3410             }
3411         }
3412     /// If it has changed, convert all the necessary strings
3413         $charsets = get_list_of_charsets();
3414         unset($charsets['UTF-8']);
3415         if (in_array($charset, $charsets)) {
3416         /// Save the new mail charset
3417             $mail->CharSet = $charset;
3418         /// And convert some strings
3419             $mail->FromName = $textlib->convert($mail->FromName, 'utf-8', $mail->CharSet); //From Name
3420             foreach ($mail->ReplyTo as $key => $rt) {                                      //ReplyTo Names
3421                 $mail->ReplyTo[$key][1] = $textlib->convert($rt, 'utf-8', $mail->CharSet);
3422             }
3423             $mail->Subject = $textlib->convert($mail->Subject, 'utf-8', $mail->CharSet);   //Subject
3424             foreach ($mail->to as $key => $to) {
3425                 $mail->to[$key][1] = $textlib->convert($to, 'utf-8', $mail->CharSet);      //To Names
3426             }
3427             $mail->Body = $textlib->convert($mail->Body, 'utf-8', $mail->CharSet);         //Body
3428             $mail->AltBody = $textlib->convert($mail->AltBody, 'utf-8', $mail->CharSet);   //Subject
3429         }
3430     }
3431
3432     if ($mail->Send()) {
3433         set_send_count($user);
3434         $mail->IsSMTP();                               // use SMTP directly
3435         if (!empty($CFG->debugsmtp)) {
3436             echo '</pre>';
3437         }
3438         return true;
3439     } else {
3440         mtrace('ERROR: '. $mail->ErrorInfo);
3441         add_to_log(SITEID, 'library', 'mailer', $FULLME, 'ERROR: '. $mail->ErrorInfo);
3442         if (!empty($CFG->debugsmtp)) {
3443             echo '</pre>';
3444         }
3445         return false;
3446     }
3447 }
3448
3449 /**
3450  * Sets specified user's password and send the new password to the user via email.
3451  *
3452  * @uses $CFG
3453  * @param user $user A {@link $USER} object
3454  * @return boolean|string Returns "true" if mail was sent OK, "emailstop" if email
3455  *          was blocked by user and "false" if there was another sort of error.
3456  */
3457 function setnew_password_and_mail($user) {
3458
3459     global $CFG;
3460
3461     $site  = get_site();
3462     $from = get_admin();
3463
3464     $newpassword = generate_password();
3465
3466     if (! set_field('user', 'password', md5($newpassword), 'id', $user->id) ) {
3467         trigger_error('Could not set user password!');
3468         return false;
3469     }
3470
3471     $a = new object();
3472     $a->firstname   = $user->firstname;
3473     $a->sitename    = $site->fullname;
3474     $a->username    = $user->username;
3475     $a->newpassword = $newpassword;
3476     $a->link        = $CFG->wwwroot .'/login/';
3477     $a->signoff     = fullname($from, true).' ('. $from->email .')';
3478
3479     $message = get_string('newusernewpasswordtext', '', $a);
3480
3481     $subject  = $site->fullname .': '. get_string('newusernewpasswordsubj');
3482
3483     return email_to_user($user, $from, $subject, $message);
3484
3485 }
3486
3487 /**
3488  * Resets specified user's password and send the new password to the user via email.
3489  *
3490  * @uses $CFG
3491  * @param user $user A {@link $USER} object
3492  * @return bool|string Returns "true" if mail was sent OK, "emailstop" if email
3493  *          was blocked by user and "false" if there was another sort of error.
3494  */
3495 function reset_password_and_mail($user) {
3496
3497     global $CFG;
3498
3499     $site  = get_site();
3500     $from = get_admin();
3501
3502     $userauth = get_auth_plugin($user->auth);
3503     if (!$userauth->can_reset_password()) {
3504         trigger_error("Attempt to reset user password for user $user->username with Auth $user->auth.");
3505         return false;
3506     }
3507
3508     $newpassword = generate_password();
3509
3510     if (!$userauth->user_update_password(addslashes_recursive($user), addslashes($newpassword))) {
3511         error("Could not set user password!");
3512     }
3513
3514     $a = new object();
3515     $a->firstname = $user->firstname;
3516     $a->sitename = $site->fullname;
3517     $a->username = $user->username;
3518     $a->newpassword = $newpassword;
3519     $a->link = $CFG->httpswwwroot .'/login/change_password.php';
3520     $a->signoff = fullname($from, true).' ('. $from->email .')';
3521
3522     $message = get_string('newpasswordtext', '', $a);
3523
3524     $subject  = $site->fullname .': '. get_string('changedpassword');
3525
3526     return email_to_user($user, $from, $subject, $message);
3527
3528 }
3529
3530 /**
3531  * Send email to specified user with confirmation text and activation link.
3532  *
3533  * @uses $CFG
3534  * @param user $user A {@link $USER} object
3535  * @return bool|string Returns "true" if mail was sent OK, "emailstop" if email
3536  *          was blocked by user and "false" if there was another sort of error.
3537  */
3538  function send_confirmation_email($user) {
3539
3540     global $CFG;
3541
3542     $site = get_site();
3543     $from = get_admin();
3544
3545     $data = new object();
3546     $data->firstname = fullname($user);
3547     $data->sitename = $site->fullname;
3548     $data->admin = fullname($from) .' ('. $from->email .')';
3549
3550     $subject = get_string('emailconfirmationsubject', '', $site->fullname);
3551
3552     $data->link = $CFG->wwwroot .'/login/confirm.php?data='. $user->secret .'/'. $user->username;
3553     $message     = get_string('emailconfirmation', '', $data);
3554     $messagehtml = text_to_html(get_string('emailconfirmation', '', $data), false, false, true);
3555
3556     $user->mailformat = 1;  // Always send HTML version as well
3557
3558     return email_to_user($user, $from, $subject, $message, $messagehtml);
3559
3560 }
3561
3562 /**
3563  * send_password_change_confirmation_email.
3564  *
3565  * @uses $CFG
3566  * @param user $user A {@link $USER} object
3567  * @return bool|string Returns "true" if mail was sent OK, "emailstop" if email
3568  *          was blocked by user and "false" if there was another sort of error.
3569  */
3570 function send_password_change_confirmation_email($user) {
3571
3572     global $CFG;
3573
3574     $site = get_site();
3575     $from = get_admin();
3576
3577     $data = new object();
3578     $data->firstname = $user->firstname;
3579     $data->sitename = $site->fullname;
3580     $data->link = $CFG->httpswwwroot .'/login/forgot_password.php?p='. $user->secret .'&s='. $user->username;
3581     $data->admin = fullname($from).' ('. $from->email .')';
3582
3583     $message = get_string('emailpasswordconfirmation', '', $data);
3584     $subject = get_string('emailpasswordconfirmationsubject', '', $site->fullname);
3585
3586     return email_to_user($user, $from, $subject, $message);
3587
3588 }
3589
3590 /**
3591  * send_password_change_info.
3592  *
3593  * @uses $CFG
3594  * @param user $user A {@link $USER} object
3595  * @return bool|string Returns "true" if mail was sent OK, "emailstop" if email
3596  *          was blocked by user and "false" if there was another sort of error.
3597  */
3598 function send_password_change_info($user) {
3599
3600     global $CFG;
3601
3602     $site = get_site();
3603     $from = get_admin();
3604
3605     $data = new object();
3606     $data->firstname = $user->firstname;
3607     $data->sitename = $site->fullname;
3608     $data->admin = fullname($from).' ('. $from->email .')';
3609
3610      $userauth = get_auth_plugin($user->auth);
3611     if ($userauth->can_change_password() and method_exists($userauth, 'change_password_url') and $userauth->change_password_url()) {
3612         // we have some external url for password cahnging
3613         $data->link .= $userauth->change_password_url();
3614
3615     } else {
3616         //no way to change password, sorry
3617         $data->link = '';
3618     }
3619
3620     if (!empty($data->link)) {
3621         $message = get_string('emailpasswordchangeinfo', '', $data);
3622         $subject = get_string('emailpasswordchangeinfosubject', '', $site->fullname);
3623     } else {
3624         $message = get_string('emailpasswordchangeinfofail', '', $data);
3625         $subject = get_string('emailpasswordchangeinfosubject', '', $site->fullname);
3626     }
3627
3628     return email_to_user($user, $from, $subject, $message);
3629
3630 }
3631
3632 /**
3633  * Check that an email is allowed.  It returns an error message if there
3634  * was a problem.
3635  *
3636  * @uses $CFG
3637  * @param  string $email Content of email
3638  * @return string|false
3639  */
3640 function email_is_not_allowed($email) {
3641
3642     global $CFG;
3643
3644     if (!empty($CFG->allowemailaddresses)) {
3645         $allowed = explode(' ', $CFG->allowemailaddresses);
3646         foreach ($allowed as $allowedpattern) {
3647             $allowedpattern = trim($allowedpattern);
3648             if (!$allowedpattern) {
3649                 continue;
3650             }
3651             if (strpos(strrev($email), strrev($allowedpattern)) === 0) { // Match!   (bug 5250)
3652                 return false;
3653             }
3654         }
3655         return get_string('emailonlyallowed', '', $CFG->allowemailaddresses);
3656
3657     } else if (!empty($CFG->denyemailaddresses)) {
3658         $denied = explode(' ', $CFG->denyemailaddresses);
3659         foreach ($denied as $deniedpattern) {
3660             $deniedpattern = trim($deniedpattern);
3661             if (!$deniedpattern) {
3662                 continue;
3663             }
3664             if (strpos(strrev($email), strrev($deniedpattern)) === 0) { // Match!   (bug 5250)
3665                 return get_string('emailnotallowed', '', $CFG->denyemailaddresses);
3666             }
3667         }
3668     }
3669
3670     return false;
3671 }
3672
3673 function email_welcome_message_to_user($course, $user=NULL) {
3674     global $CFG, $USER;
3675
3676     if (empty($user)) {
3677         if (!isloggedin()) {
3678             return false;
3679         }
3680         $user = $USER;
3681     }
3682
3683     if (!empty($course->welcomemessage)) {
3684         $subject = get_string('welcometocourse', '', format_string($course->fullname));
3685
3686         $a->coursename = $course->fullname;
3687         $a->profileurl = "$CFG->wwwroot/user/view.php?id=$USER->id&course=$course->id";
3688         //$message = get_string("welcometocoursetext", "", $a);
3689         $message = $course->welcomemessage;
3690
3691         if (! $teacher = get_teacher($course->id)) {
3692             $teacher = get_admin();
3693         }
3694         email_to_user($user, $teacher, $subject, $message);
3695     }
3696 }
3697
3698 /// FILE HANDLING  /////////////////////////////////////////////
3699
3700
3701 /**
3702  * Makes an upload directory for a particular module.
3703  *
3704  * @uses $CFG
3705  * @param int $courseid The id of the course in question - maps to id field of 'course' table.
3706  * @return string|false Returns full path to directory if successful, false if not
3707  */
3708 function make_mod_upload_directory($courseid) {
3709     global $CFG;
3710
3711     if (! $moddata = make_upload_directory($courseid .'/'. $CFG->moddata)) {
3712         return false;
3713     }
3714
3715     $strreadme = get_string('readme');
3716
3717     if (file_exists($CFG->dirroot .'/lang/'. $CFG->lang .'/docs/module_files.txt')) {
3718         copy($CFG->dirroot .'/lang/'. $CFG->lang .'/docs/module_files.txt', $moddata .'/'. $strreadme .'.txt');
3719     } else {
3720         copy($CFG->dirroot .'/lang/en_utf8/docs/module_files.txt', $moddata .'/'. $strreadme .'.txt');
3721     }
3722     return $moddata;
3723 }
3724
3725 /**
3726  * Returns current name of file on disk if it exists.
3727  *
3728  * @param string $newfile File to be verified
3729  * @return string Current name of file on disk if true
3730  */
3731 function valid_uploaded_file($newfile) {
3732     if (empty($newfile)) {
3733         return '';
3734     }
3735     if (is_uploaded_file($newfile['tmp_name']) and $newfile['size'] > 0) {
3736         return $newfile['tmp_name'];
3737     } else {
3738         return '';
3739     }
3740 }
3741
3742 /**
3743  * Returns the maximum size for uploading files.
3744  *
3745  * There are seven possible upload limits:
3746  * 1. in Apache using LimitRequestBody (no way of checking or changing this)
3747  * 2. in php.ini for 'upload_max_filesize' (can not be changed inside PHP)
3748  * 3. in .htaccess for 'upload_max_filesize' (can not be changed inside PHP)
3749  * 4. in php.ini for 'post_max_size' (can not be changed inside PHP)
3750  * 5. by the Moodle admin in $CFG->maxbytes
3751  * 6. by the teacher in the current course $course->maxbytes
3752  * 7. by the teacher for the current module, eg $assignment->maxbytes
3753  *
3754  * These last two are passed to this function as arguments (in bytes).
3755  * Anything defined as 0 is ignored.
3756  * The smallest of all the non-zero numbers is returned.
3757  *
3758  * @param int $sizebytes ?
3759  * @param int $coursebytes Current course $course->maxbytes (in bytes)
3760  * @param int $modulebytes Current module ->maxbytes (in bytes)
3761  * @return int The maximum size for uploading files.
3762  * @todo Finish documenting this function
3763  */
3764 function get_max_upload_file_size($sitebytes=0, $coursebytes=0, $modulebytes=0) {
3765
3766     if (! $filesize = ini_get('upload_max_filesize')) {
3767         $filesize = '5M';
3768     }
3769     $minimumsize = get_real_size($filesize);
3770
3771     if ($postsize = ini_get('post_max_size')) {
3772         $postsize = get_real_size($postsize);
3773         if ($postsize < $minimumsize) {
3774             $minimumsize = $postsize;
3775         }
3776     }
3777
3778     if ($sitebytes and $sitebytes < $minimumsize) {
3779         $minimumsize = $sitebytes;
3780     }
3781
3782     if ($coursebytes and $coursebytes < $minimumsize) {
3783         $minimumsize = $coursebytes;
3784     }
3785
3786     if ($modulebytes and $modulebytes < $minimumsize) {
3787         $minimumsize = $modulebytes;
3788     }
3789
3790     return $minimumsize;
3791 }
3792
3793 /**
3794  * Related to {@link get_max_upload_file_size()} - this function returns an
3795  * array of possible sizes in an array, translated to the
3796  * local language.
3797  *
3798  * @uses SORT_NUMERIC
3799  * @param int $sizebytes ?
3800  * @param int $coursebytes Current course $course->maxbytes (in bytes)
3801  * @param int $modulebytes Current module ->maxbytes (in bytes)
3802  * @return int
3803  * @todo Finish documenting this function
3804  */
3805 function get_max_upload_sizes($sitebytes=0, $coursebytes=0, $modulebytes=0) {
3806
3807     if (!$maxsize = get_max_upload_file_size($sitebytes, $coursebytes, $modulebytes)) {
3808         return array();
3809     }
3810
3811     $filesize[$maxsize] = display_size($maxsize);
3812
3813     $sizelist = array(10240, 51200, 102400, 512000, 1048576, 2097152,
3814                       5242880, 10485760, 20971520, 52428800, 104857600);
3815
3816     foreach ($sizelist as $sizebytes) {
3817        if ($sizebytes < $maxsize) {
3818            $filesize[$sizebytes] = display_size($sizebytes);
3819        }
3820     }
3821
3822     krsort($filesize, SORT_NUMERIC);
3823
3824     return $filesize;
3825 }
3826
3827 /**
3828  * If there has been an error uploading a file, print the appropriate error message
3829  * Numerical constants used as constant definitions not added until PHP version 4.2.0
3830  *
3831  * $filearray is a 1-dimensional sub-array of the $_FILES array
3832  * eg $filearray = $_FILES['userfile1']
3833  * If left empty then the first element of the $_FILES array will be used
3834  *
3835  * @uses $_FILES
3836  * @param array $filearray  A 1-dimensional sub-array of the $_FILES array
3837  * @param bool $returnerror If true then a string error message will be returned. Otherwise the user will be notified of the error in a notify() call.
3838  * @return bool|string
3839  */
3840 function print_file_upload_error($filearray = '', $returnerror = false) {
3841
3842     if ($filearray == '' or !isset($filearray['error'])) {
3843
3844         if (empty($_FILES)) return false;
3845
3846         $files = $_FILES; /// so we don't mess up the _FILES array for subsequent code
3847         $filearray = array_shift($files); /// use first element of array
3848     }
3849
3850     switch ($filearray['error']) {
3851
3852         case 0: // UPLOAD_ERR_OK
3853             if ($filearray['size'] > 0) {
3854                 $errmessage = get_string('uploadproblem', $filearray['name']);
3855             } else {
3856                 $errmessage = get_string('uploadnofilefound'); /// probably a dud file name
3857             }
3858             break;
3859
3860         case 1: // UPLOAD_ERR_INI_SIZE
3861             $errmessage = get_string('uploadserverlimit');
3862             break;
3863
3864         case 2: // UPLOAD_ERR_FORM_SIZE
3865             $errmessage = get_string('uploadformlimit');
3866             break;
3867
3868         case 3: // UPLOAD_ERR_PARTIAL
3869             $errmessage = get_string('uploadpartialfile');
3870             break;
3871
3872         case 4: // UPLOAD_ERR_NO_FILE
3873             $errmessage = get_string('uploadnofilefound');
3874             break;
3875
3876         default:
3877             $errmessage = get_string('uploadproblem', $filearray['name']);
3878     }
3879
3880     if ($returnerror) {
3881         return $errmessage;
3882     } else {
3883         notify($errmessage);
3884         return true;
3885     }
3886
3887 }
3888
3889 /**
3890  * handy function to loop through an array of files and resolve any filename conflicts
3891  * both in the array of filenames and for what is already on disk.
3892  * not really compatible with the similar function in uploadlib.php
3893  * but this could be used for files/index.php for moving files around.
3894  */
3895
3896 function resolve_filename_collisions($destination,$files,$format='%s_%d.%s') {
3897     foreach ($files as $k => $f) {
3898         if (check_potential_filename($destination,$f,$files)) {
3899             $bits = explode('.', $f);
3900             for ($i = 1; true; $i++) {
3901                 $try = sprintf($format, $bits[0], $i, $bits[1]);
3902                 if (!check_potential_filename($destination,$try,$files)) {
3903                     $files[$k] = $try;
3904                     break;
3905                 }
3906             }
3907         }
3908     }
3909     return $files;
3910 }
3911
3912 /**
3913  * @used by resolve_filename_collisions
3914  */
3915 function check_potential_filename($destination,$filename,$files) {
3916     if (file_exists($destination.'/'.$filename)) {
3917         return true;
3918     }
3919     if (count(array_keys($files,$filename)) > 1) {
3920         return true;
3921     }
3922     return false;
3923 }
3924
3925
3926 /**
3927  * Returns an array with all the filenames in
3928  * all subdirectories, relative to the given rootdir.
3929  * If excludefile is defined, then that file/directory is ignored
3930  * If getdirs is true, then (sub)directories are included in the output
3931  * If getfiles is true, then files are included in the output
3932  * (at least one of these must be true!)
3933  *
3934  * @param string $rootdir  ?
3935  * @param string $excludefile  If defined then the specified file/directory is ignored
3936  * @param bool $descend  ?
3937  * @param bool $getdirs  If true then (sub)directories are included in the output
3938  * @param bool $getfiles  If true then files are included in the output
3939  * @return array An array with all the filenames in
3940  * all subdirectories, relative to the given rootdir
3941  * @todo Finish documenting this function. Add examples of $excludefile usage.
3942  */
3943 function get_directory_list($rootdir, $excludefiles='', $descend=true, $getdirs=false, $getfiles=true) {
3944
3945     $dirs = array();
3946
3947     if (!$getdirs and !$getfiles) {   // Nothing to show
3948         return $dirs;
3949     }
3950
3951     if (!is_dir($rootdir)) {          // Must be a directory
3952         return $dirs;
3953     }
3954
3955     if (!$dir = opendir($rootdir)) {  // Can't open it for some reason
3956         return $dirs;
3957     }
3958
3959     if (!is_array($excludefiles)) {
3960         $excludefiles = array($excludefiles);
3961     }
3962
3963     while (false !== ($file = readdir($dir))) {
3964         $firstchar = substr($file, 0, 1);
3965         if ($firstchar == '.' or $file == 'CVS' or in_array($file, $excludefiles)) {
3966             continue;
3967         }
3968         $fullfile = $rootdir .'/'. $file;
3969         if (filetype($fullfile) == 'dir') {
3970             if ($getdirs) {
3971                 $dirs[] = $file;
3972             }
3973             if ($descend) {
3974                 $subdirs = get_directory_list($fullfile, $excludefiles, $descend, $getdirs, $getfiles);
3975                 foreach ($subdirs as $subdir) {
3976                     $dirs[] = $file .'/'. $subdir;
3977                 }
3978             }
3979         } else if ($getfiles) {
3980             $dirs[] = $file;
3981         }
3982     }
3983     closedir($dir);
3984
3985     asort($dirs);
3986
3987     return $dirs;
3988 }
3989
3990
3991 /**
3992  * Adds up all the files in a directory and works out the size.
3993  *
3994  * @param string $rootdir  ?
3995  * @param string $excludefile  ?
3996  * @return array
3997  * @todo Finish documenting this function
3998  */
3999 function get_directory_size($rootdir, $excludefile='') {
4000
4001     global $CFG;
4002
4003     // do it this way if we can, it's much faster
4004     if (!empty($CFG->pathtodu) && is_executable(trim($CFG->pathtodu))) {
4005         $command = trim($CFG->pathtodu).' -sk --apparent-size '.escapeshellarg($rootdir);
4006         $output = null;
4007         $return = null;
4008         exec($command,$output,$return);
4009         if (is_array($output)) {
4010             return get_real_size(intval($output[0]).'k'); // we told it to return k.
4011         }
4012     }
4013
4014     if (!is_dir($rootdir)) {          // Must be a directory
4015         return 0;
4016     }
4017
4018     if (!$dir = @opendir($rootdir)) {  // Can't open it for some reason
4019         return 0;
4020     }
4021
4022     $size = 0;
4023
4024     while (false !== ($file = readdir($dir))) {
4025         $firstchar = substr($file, 0, 1);
4026         if ($firstchar == '.' or $file == 'CVS' or $file == $excludefile) {
4027             continue;
4028         }
4029         $fullfile = $rootdir .'/'. $file;
4030         if (filetype($fullfile) == 'dir') {
4031             $size += get_directory_size($fullfile, $excludefile);
4032         } else {
4033             $size += filesize($fullfile);
4034         }
4035     }
4036     closedir($dir);
4037
4038     return $size;
4039 }
4040
4041 /**
4042  * Converts bytes into display form
4043  *
4044  * @param string $size  ?
4045  * @return string
4046  * @staticvar string $gb Localized string for size in gigabytes
4047  * @staticvar string $mb Localized string for size in megabytes
4048  * @staticvar string $kb Localized string for size in kilobytes
4049  * @staticvar string $b Localized string for size in bytes
4050  * @todo Finish documenting this function. Verify return type.
4051  */
4052 function display_size($size) {
4053
4054     static $gb, $mb, $kb, $b;
4055
4056     if (empty($gb)) {
4057         $gb = get_string('sizegb');
4058         $mb = get_string('sizemb');
4059         $kb = get_string('sizekb');
4060         $b  = get_string('sizeb');
4061     }
4062
4063     if ($size >= 1073741824) {
4064         $size = round($size / 1073741824 * 10) / 10 . $gb;
4065     } else if ($size >= 1048576) {
4066         $size = round($size / 1048576 * 10) / 10 . $mb;
4067     } else if ($size >= 1024) {
4068         $size = round($size / 1024 * 10) / 10 . $kb;
4069     } else {
4070         $size = $size .' '. $b;
4071     }
4072     return $size;
4073 }
4074
4075 /**
4076  * Cleans a given filename by removing suspicious or troublesome characters
4077  * Only these are allowed: alphanumeric _ - .
4078  * Unicode characters can be enabled by setting $CFG->unicodecleanfilename = true in config.php
4079  *
4080  * WARNING: unicode characters may not be compatible with zip compression in backup/restore,
4081  *          because native zip binaries do weird character conversions. Use PHP zipping instead.
4082  *
4083  * @param string $string  file name
4084  * @return string cleaned file name
4085  */
4086 function clean_filename($string) {
4087     global $CFG;
4088     if (empty($CFG->unicodecleanfilename)) {
4089         $textlib = textlib_get_instance();
4090         $string = $textlib->specialtoascii($string);
4091         $string = preg_replace('/[^\.a-zA-Z\d\_-]/','_', $string ); // only allowed chars
4092     } else {
4093         //clean only ascii range
4094         $string = preg_replace("/[\\000-\\x2c\\x2f\\x3a-\\x40\\x5b-\\x5e\\x60\\x7b-\\177]/s", '_', $string);
4095     }
4096     $string = preg_replace("/_+/", '_', $string);
4097     $string = preg_replace("/\.\.+/", '.', $string);
4098     return $string;
4099 }
4100
4101
4102 /// STRING TRANSLATION  ////////////////////////////////////////
4103
4104 /**
4105  * Returns the code for the current language
4106  *
4107  * @uses $CFG
4108  * @param $USER
4109  * @param $SESSION
4110  * @return string
4111  */
4112 function current_language() {
4113     global $CFG, $USER, $SESSION, $COURSE;
4114
4115     if (!empty($COURSE->id) and $COURSE->id != SITEID and !empty($COURSE->lang)) {    // Course language can override all other settings for this page
4116         $return = $COURSE->lang;
4117
4118     } else if (!empty($SESSION->lang)) {    // Session language can override other settings
4119         $return = $SESSION->lang;
4120
4121     } else if (!empty($USER->lang)) {
4122         $return = $USER->lang;
4123
4124     } else {
4125         $return = $CFG->lang;
4126     }
4127
4128     if ($return == 'en') {
4129         $return = 'en_utf8';
4130     }
4131
4132     return $return;
4133 }
4134
4135 /**
4136  * Prints out a translated string.
4137  *
4138  * Prints out a translated string using the return value from the {@link get_string()} function.
4139  *
4140  * Example usage of this function when the string is in the moodle.php file:<br/>
4141  * <code>
4142  * echo '<strong>';
4143  * print_string('wordforstudent');
4144  * echo '</strong>';
4145  * </code>
4146  *
4147  * Example usage of this function when the string is not in the moodle.php file:<br/>
4148  * <code>
4149  * echo '<h1>';
4150  * print_string('typecourse', 'calendar');
4151  * echo '</h1>';
4152  * </code>
4153  *
4154  * @param string $identifier The key identifier for the localized string
4155  * @param string $module The module where the key identifier is stored. If none is specified then moodle.php is used.
4156  * @param mixed $a An object, string or number that can be used
4157  * within translation strings
4158  */
4159 function print_string($identifier, $module='', $a=NULL) {
4160     echo get_string($identifier, $module, $a);
4161 }
4162
4163 /**
4164  * fix up the optional data in get_string()/print_string() etc
4165  * ensure possible sprintf() format characters are escaped correctly
4166  * needs to handle arbitrary strings and objects
4167  * @param mixed $a An object, string or number that can be used
4168  * @return mixed the supplied parameter 'cleaned'
4169  */
4170 function clean_getstring_data( $a ) {
4171     if (is_string($a)) {
4172         return str_replace( '%','%%',$a );
4173     }
4174     elseif (is_object($a)) {
4175         $a_vars = get_object_vars( $a );
4176         $new_a_vars = array();
4177         foreach ($a_vars as $fname => $a_var) {
4178             $new_a_vars[$fname] = clean_getstring_data( $a_var );
4179         }
4180         return (object)$new_a_vars;
4181     }
4182     else {
4183         return $a;
4184     }
4185 }
4186
4187 /**
4188  * @return array places to look for lang strings based on the prefix to the
4189  * module name. For example qtype_ in question/type. Used by get_string and
4190  * help.php.
4191  */
4192 function places_to_search_for_lang_strings() {
4193     global $CFG;
4194
4195     return array(
4196         '__exceptions' => array('moodle', 'langconfig'),
4197         'assignment_' => array('mod/assignment/type'),
4198         'auth_' => array('auth'),
4199         'block_' => array('blocks'),
4200         'datafield_' => array('mod/data/field'),
4201         'datapreset_' => array('mod/data/preset'),
4202         'enrol_' => array('enrol'),
4203         'format_' => array('course/format'),
4204         'qtype_' => array('question/type'),
4205         'report_' => array($CFG->admin.'/report', 'course/report', 'mod/quiz/report'),
4206         'resource_' => array('mod/resource/type'),
4207         '' => array('mod')
4208     );
4209 }
4210
4211 /**
4212  * Returns a localized string.
4213  *
4214  * Returns the translated string specified by $identifier as
4215  * for $module.  Uses the same format files as STphp.
4216  * $a is an object, string or number that can be used
4217  * within translation strings
4218  *
4219  * eg "hello \$a->firstname \$a->lastname"
4220  * or "hello \$a"
4221  *
4222  * If you would like to directly echo the localized string use
4223  * the function {@link print_string()}
4224  *
4225  * Example usage of this function involves finding the string you would
4226  * like a local equivalent of and using its identifier and module information
4227  * to retrive it.<br/>
4228  * If you open moodle/lang/en/moodle.php and look near line 1031
4229  * you will find a string to prompt a user for their word for student
4230  * <code>
4231  * $string['wordforstudent'] = 'Your word for Student';
4232  * </code>
4233  * So if you want to display the string 'Your word for student'
4234  * in any language that supports it on your site
4235  * you just need to use the identifier 'wordforstudent'
4236  * <code>
4237  * $mystring = '<strong>'. get_string('wordforstudent') .'</strong>';
4238 or
4239  * </code>
4240  * If the string you want is in another file you'd take a slightly
4241  * different approach. Looking in moodle/lang/en/calendar.php you find
4242  * around line 75:
4243  * <code>
4244  * $string['typecourse'] = 'Course event';
4245  * </code>
4246  * If you want to display the string "Course event" in any language
4247  * supported you would use the identifier 'typecourse' and the module 'calendar'
4248  * (because it is in the file calendar.php):
4249  * <code>
4250  * $mystring = '<h1>'. get_string('typecourse', 'calendar') .'</h1>';
4251  * </code>
4252  *
4253  * As a last resort, should the identifier fail to map to a string
4254  * the returned string will be [[ $identifier ]]
4255  *
4256  * @uses $CFG
4257  * @param string $identifier The key identifier for the localized string
4258  * @param string $module The module where the key identifier is stored. If none is specified then moodle.php is used.
4259  * @param mixed $a An object, string or number that can be used
4260  * within translation strings
4261  * @param array $extralocations An array of strings with other locations to look for string files
4262  * @return string The localized string.
4263  */
4264 function get_string($identifier, $module='', $a=NULL, $extralocations=NULL) {
4265
4266     global $CFG;
4267
4268 /// originally these special strings were stored in moodle.php now we are only in langconfig.php
4269     $langconfigstrs = array('alphabet', 'backupnameformat', 'firstdayofweek', 'locale',
4270                             'localewin', 'localewincharset', 'oldcharset',
4271                             'parentlanguage', 'strftimedate', 'strftimedateshort', 'strftimedatetime',
4272                             'strftimedaydate', 'strftimedaydatetime', 'strftimedayshort', 'strftimedaytime',
4273                             'strftimemonthyear', 'strftimerecent', 'strftimerecentfull', 'strftimetime',
4274                             'thischarset', 'thisdirection', 'thislanguage');
4275
4276     $filetocheck = 'langconfig.php';
4277     $defaultlang = 'en_utf8';
4278     if (in_array($identifier, $langconfigstrs)) {
4279         $module = 'langconfig';  //This strings are under langconfig.php for 1.6 lang packs
4280     }
4281
4282     $lang = current_language();
4283
4284     if ($module == '') {
4285         $module = 'moodle';
4286     }
4287
4288     // if $a happens to have % in it, double it so sprintf() doesn't break
4289     if ($a) {
4290         $a = clean_getstring_data( $a );
4291     }
4292
4293 /// Define the two or three major locations of language strings for this module
4294     $locations = array();
4295
4296     if (!empty($extralocations)) {   // Calling code has a good idea where to look
4297         if (is_array($extralocations)) {
4298             $locations += $extralocations;
4299         } else if (is_string($extralocations)) {
4300             $locations[] = $extralocations;
4301         } else {
4302             debugging('Bad lang path provided');
4303         }
4304     }
4305
4306     if (isset($CFG->running_installer)) {
4307         $module = 'installer';
4308         $filetocheck = 'installer.php';
4309         $locations += array( $CFG->dirroot.'/install/lang/', $CFG->dataroot.'/lang/',  $CFG->dirroot.'/lang/' );
4310         $defaultlang = 'en_utf8';
4311     } else {
4312         $locations += array( $CFG->dataroot.'/lang/',  $CFG->dirroot.'/lang/' );
4313     }
4314
4315 /// Add extra places to look for strings for particular plugin types.
4316     $rules = places_to_search_for_lang_strings();
4317     $exceptions = $rules['__exceptions'];
4318     unset($rules['__exceptions']);
4319
4320     if (!in_array($module, $exceptions)) {
4321         $dividerpos = strpos($module, '_');
4322         if ($dividerpos === false) {
4323             $type = '';
4324             $plugin = $module;
4325         } else {
4326             $type = substr($module, 0, $dividerpos + 1);
4327             $plugin = substr($module, $dividerpos + 1);
4328         }
4329         if (!empty($rules[$type])) {
4330             foreach ($rules[$type] as $location) {
4331                 $locations[] = $CFG->dirroot . "/$location/$plugin/lang/";
4332             }
4333         }
4334     }
4335
4336 /// First check all the normal locations for the string in the current language
4337     $resultstring = '';
4338     foreach ($locations as $location) {
4339         $locallangfile = $location.$lang.'_local'.'/'.$module.'.php';    //first, see if there's a local file
4340         if (file_exists($locallangfile)) {
4341             if ($result = get_string_from_file($identifier, $locallangfile, "\$resultstring")) {
4342                 eval($result);
4343                 return $resultstring;
4344             }
4345         }
4346         //if local directory not found, or particular string does not exist in local direcotry
4347         $langfile = $location.$lang.'/'.$module.'.php';
4348         if (file_exists($langfile)) {
4349             if ($result = get_string_from_file($identifier, $langfile, "\$resultstring")) {
4350                 eval($result);
4351                 return $resultstring;
4352             }
4353         }
4354     }
4355
4356 /// If the preferred language was English (utf8) we can abort now
4357 /// saving some checks beacuse it's the only "root" lang
4358     if ($lang == 'en_utf8') {
4359         return '[['. $identifier .']]';
4360     }
4361
4362 /// Is a parent language defined?  If so, try to find this string in a parent language file
4363
4364     foreach ($locations as $location) {
4365         $langfile = $location.$lang.'/'.$filetocheck;
4366         if (file_exists($langfile)) {
4367             if ($result = get_string_from_file('parentlanguage', $langfile, "\$parentlang")) {
4368                 eval($result);
4369                 if (!empty($parentlang)) {   // found it!
4370
4371                     //first, see if there's a local file for parent
4372                     $locallangfile = $location.$parentlang.'_local'.'/'.$module.'.php';
4373                     if (file_exists($locallangfile)) {
4374                         if ($result = get_string_from_file($identifier, $locallangfile, "\$resultstring")) {
4375                             eval($result);
4376                             return $resultstring;
4377                         }
4378                     }
4379
4380                     //if local directory not found, or particular string does not exist in local direcotry
4381                     $langfile = $location.$parentlang.'/'.$module.'.php';
4382                     if (file_exists($langfile)) {
4383                         if ($result = get_string_from_file($identifier, $langfile, "\$resultstring")) {
4384                             eval($result);
4385                             return $resultstring;
4386                         }
4387                     }
4388                 }
4389             }
4390         }
4391     }
4392
4393 /// Our only remaining option is to try English
4394
4395     foreach ($locations as $location) {
4396         $locallangfile = $location.$defaultlang.'_local/'.$module.'.php';    //first, see if there's a local file
4397         if (file_exists($locallangfile)) {
4398             if ($result = get_string_from_file($identifier, $locallangfile, "\$resultstring")) {
4399                 eval($result);
4400                 return $resultstring;
4401             }
4402         }
4403
4404         //if local_en not found, or string not found in local_en
4405         $langfile = $location.$defaultlang.'/'.$module.'.php';
4406
4407         if (file_exists($langfile)) {
4408             if ($result = get_string_from_file($identifier, $langfile, "\$resultstring")) {
4409                 eval($result);
4410                 return $resultstring;
4411             }
4412         }
4413     }
4414
4415 /// And, because under 1.6 en is defined as en_utf8 child, me must try
4416 /// if it hasn't been queried before.
4417     if ($defaultlang  == 'en') {
4418         $defaultlang = 'en_utf8';
4419         foreach ($locations as $location) {
4420             $locallangfile = $location.$defaultlang.'_local/'.$module.'.php';    //first, see if there's a local file
4421             if (file_exists($locallangfile)) {
4422                 if ($result = get_string_from_file($identifier, $locallangfile, "\$resultstring")) {
4423                     eval($result);
4424                     return $resultstring;
4425                 }
4426             }
4427
4428             //if local_en not found, or string not found in local_en
4429             $langfile = $location.$defaultlang.'/'.$module.'.php';
4430
4431             if (file_exists($langfile)) {
4432                 if ($result = get_string_from_file($identifier, $langfile, "\$resultstring")) {
4433                     eval($result);
4434                     return $resultstring;
4435                 }
4436             }
4437         }
4438     }
4439
4440     return '[['.$identifier.']]';  // Last resort
4441 }
4442
4443 /**
4444  * This function is only used from {@link get_string()}.
4445  *
4446  * @internal Only used from get_string, not meant to be public API
4447  * @param string $identifier ?
4448  * @param string $langfile ?
4449  * @param string $destination ?
4450  * @return string|false ?
4451  * @staticvar array $strings Localized strings
4452  * @access private
4453  * @todo Finish documenting this function.
4454  */
4455 function get_string_from_file($identifier, $langfile, $destination) {
4456
4457     static $strings;    // Keep the strings cached in memory.
4458
4459     if (empty($strings[$langfile])) {
4460         $string = array();
4461         include ($langfile);
4462         $strings[$langfile] = $string;
4463     } else {
4464         $string = &$strings[$langfile];
4465     }
4466
4467     if (!isset ($string[$identifier])) {
4468         return false;
4469     }
4470
4471     return $destination .'= sprintf("'. $string[$identifier] .'");';
4472 }
4473
4474 /**
4475  * Converts an array of strings to their localized value.
4476  *
4477  * @param array $array An array of strings
4478  * @param string $module The language module that these strings can be found in.
4479  * @return string
4480  */
4481 function get_strings($array, $module='') {
4482
4483    $string = NULL;
4484    foreach ($array as $item) {
4485        $string->$item = get_string($item, $module);
4486    }
4487    return $string;
4488 }
4489
4490 /**
4491  * Returns a list of language codes and their full names
4492  * hides the _local files from everyone.
4493  * @uses $CFG
4494  * @return array An associative array with contents in the form of LanguageCode => LanguageName
4495  */
4496 function get_list_of_languages() {
4497
4498     global $CFG;
4499
4500     $languages = array();
4501
4502     $filetocheck = 'langconfig.php';
4503
4504     if ( (!defined('FULLME') || FULLME !== 'cron')
4505          && !empty($CFG->langcache) && file_exists($CFG->dataroot .'/cache/languages')) {
4506         // read from cache
4507
4508         $lines = file($CFG->dataroot .'/cache/languages');
4509         foreach ($lines as $line) {
4510             $line = trim($line);
4511             if (preg_match('/^(\w+)\s+(.+)/', $line, $matches)) {
4512                 $languages[$matches[1]] = $matches[2];
4513             }
4514         }
4515         unset($lines); unset($line); unset($matches);
4516         return $languages;
4517     }
4518
4519     if (!empty($CFG->langlist)) {       // use admin's list of languages
4520
4521         $langlist = explode(',', $CFG->langlist);
4522         foreach ($langlist as $lang) {
4523             $lang = trim($lang);   //Just trim spaces to be a bit more permissive
4524             if (strstr($lang, '_local')!==false) {
4525                 continue;
4526             }
4527             if (substr($lang, -5) == '_utf8') {   //Remove the _utf8 suffix from the lang to show
4528                 $shortlang = substr($lang, 0, -5);
4529             } else {
4530                 $shortlang = $lang;
4531             }
4532         /// Search under dirroot/lang
4533             if (file_exists($CFG->dirroot .'/lang/'. $lang .'/'. $filetocheck)) {
4534                 include($CFG->dirroot .'/lang/'. $lang .'/'. $filetocheck);
4535                 if (!empty($string['thislanguage'])) {
4536                     $languages[$lang] = $string['thislanguage'].' ('. $shortlang .')';
4537                 }
4538                 unset($string);
4539             }
4540         /// And moodledata/lang
4541             if (file_exists($CFG->dataroot .'/lang/'. $lang .'/'. $filetocheck)) {
4542                 include($CFG->dataroot .'/lang/'. $lang .'/'. $filetocheck);
4543                 if (!empty($string['thislanguage'])) {
4544                     $languages[$lang] = $string['thislanguage'].' ('. $shortlang .')';
4545                 }
4546                 unset($string);
4547             }
4548         }
4549     } else {
4550     /// Fetch langs from moodle/lang directory
4551         $langdirs = get_list_of_plugins('lang');
4552     /// Fetch langs from moodledata/lang directory
4553         $langdirs2 = get_list_of_plugins('lang', '', $CFG->dataroot);
4554     /// Merge both lists of langs
4555         $langdirs = array_merge($langdirs, $langdirs2);
4556     /// Sort all
4557         asort($langdirs);
4558     /// Get some info from each lang (first from moodledata, then from moodle)
4559         foreach ($langdirs as $lang) {
4560             if (strstr($lang, '_local')!==false) {
4561                 continue;
4562             }
4563             if (substr($lang, -5) == '_utf8') {   //Remove the _utf8 suffix from the lang to show
4564                 $shortlang = substr($lang, 0, -5);
4565             } else {
4566                 $shortlang = $lang;
4567             }
4568         /// Search under moodledata/lang
4569             if (file_exists($CFG->dataroot .'/lang/'. $lang .'/'. $filetocheck)) {
4570                 include($CFG->dataroot .'/lang/'. $lang .'/'. $filetocheck);
4571                 if (!empty($string['thislanguage'])) {
4572                     $languages[$lang] = $string['thislanguage'] .' ('. $shortlang .')';
4573                 }
4574                 unset($string);
4575             }
4576         /// And dirroot/lang
4577             if (file_exists($CFG->dirroot .'/lang/'. $lang .'/'. $filetocheck)) {
4578                 include($CFG->dirroot .'/lang/'. $lang .'/'. $filetocheck);
4579                 if (!empty($string['thislanguage'])) {
4580                     $languages[$lang] = $string['thislanguage'] .' ('. $shortlang .')';
4581                 }
4582                 unset($string);
4583             }
4584         }
4585     }
4586
4587     if ( defined('FULLME') && FULLME === 'cron' && !empty($CFG->langcache)) {
4588         if ($file = fopen($CFG->dataroot .'/cache/languages', 'w')) {
4589             foreach ($languages as $key => $value) {
4590                 fwrite($file, "$key $value\n");
4591             }
4592             fclose($file);
4593         }
4594     }
4595
4596     return $languages;
4597 }
4598
4599 /**
4600  * Returns a list of charset codes. It's hardcoded, so they should be added manually
4601  * (cheking that such charset is supported by the texlib library!)
4602  *
4603  * @return array And associative array with contents in the form of charset => charset
4604  */
4605 function get_list_of_charsets() {
4606
4607     $charsets = array(
4608         'EUC-JP'     => 'EUC-JP',
4609         'ISO-2022-JP'=> 'ISO-2022-JP',
4610         'ISO-8859-1' => 'ISO-8859-1',
4611         'SHIFT-JIS'  => 'SHIFT-JIS',
4612         'GB2312'     => 'GB2312',
4613         'GB18030'    => 'GB18030', // gb18030 not supported by typo and mbstring
4614         'UTF-8'      => 'UTF-8');
4615
4616     asort($charsets);
4617
4618     return $charsets;
4619 }
4620
4621 /**
4622  * Returns a list of country names in the current language
4623  *
4624  * @uses $CFG
4625  * @uses $USER
4626  * @return array
4627  */
4628 function get_list_of_countries() {
4629     global $CFG, $USER;
4630
4631     $lang = current_language();
4632
4633     if (!file_exists($CFG->dirroot .'/lang/'. $lang .'/countries.php') &&
4634         !file_exists($CFG->dataroot.'/lang/'. $lang .'/countries.php')) {
4635         if ($parentlang = get_string('parentlanguage')) {
4636             if (file_exists($CFG->dirroot .'/lang/'. $parentlang .'/countries.php') ||
4637                 file_exists($CFG->dataroot.'/lang/'. $parentlang .'/countries.php')) {
4638                 $lang = $parentlang;
4639             } else {
4640                 $lang = 'en_utf8';  // countries.php must exist in this pack
4641             }
4642         } else {
4643             $lang = 'en_utf8';  // countries.php must exist in this pack
4644         }
4645     }
4646
4647     if (file_exists($CFG->dataroot .'/lang/'. $lang .'/countries.php')) {
4648         include($CFG->dataroot .'/lang/'. $lang .'/countries.php');
4649     } else if (file_exists($CFG->dirroot .'/lang/'. $lang .'/countries.php')) {
4650         include($CFG->dirroot .'/lang/'. $lang .'/countries.php');
4651     }
4652
4653     if (!empty($string)) {
4654         asort($string);
4655     }
4656
4657     return $string;
4658 }
4659
4660 /**
4661  * Returns a list of valid and compatible themes
4662  *
4663  * @uses $CFG
4664  * @return array
4665  */
4666 function get_list_of_themes() {
4667
4668     global $CFG;
4669
4670     $themes = array();
4671
4672     if (!empty($CFG->themelist)) {       // use admin's list of themes
4673         $themelist = explode(',', $CFG->themelist);
4674     } else {
4675         $themelist = get_list_of_plugins("theme");
4676     }
4677
4678     foreach ($themelist as $key => $theme) {
4679         if (!file_exists("$CFG->themedir/$theme/config.php")) {   // bad folder
4680             continue;
4681         }
4682         $THEME = new object();    // Note this is not the global one!!  :-)
4683         include("$CFG->themedir/$theme/config.php");
4684         if (!isset($THEME->sheets)) {   // Not a valid 1.5 theme
4685             continue;
4686         }
4687         $themes[$theme] = $theme;
4688     }
4689     asort($themes);
4690
4691     return $themes;
4692 }
4693
4694
4695 /**
4696  * Returns a list of picture names in the current or specified language
4697  *
4698  * @uses $CFG
4699  * @return array
4700  */
4701 function get_list_of_pixnames($lang = '') {
4702     global $CFG;
4703
4704     if (empty($lang)) {
4705         $lang = current_language();
4706     }
4707
4708     $string = array();
4709
4710     $path = $CFG->dirroot .'/lang/en_utf8/pix.php'; // always exists
4711
4712     if (file_exists($CFG->dataroot .'/lang/'. $lang .'_local/pix.php')) {
4713         $path = $CFG->dataroot .'/lang/'. $lang .'_local/pix.php';
4714
4715     } else if (file_exists($CFG->dirroot .'/lang/'. $lang .'/pix.php')) {
4716         $path = $CFG->dirroot .'/lang/'. $lang .'/pix.php';
4717
4718     } else if (file_exists($CFG->dataroot .'/lang/'. $lang .'/pix.php')) {
4719         $path = $CFG->dataroot .'/lang/'. $lang .'/pix.php';
4720
4721     } else if ($parentlang = get_string('parentlanguage') and $parentlang != '[[parentlanguage]]') {
4722         return get_list_of_pixnames($parentlang); //return pixnames from parent language instead
4723     }
4724
4725     include($path);
4726
4727     return $string;
4728 }
4729
4730 /**
4731  * Returns a list of timezones in the current language
4732  *
4733  * @uses $CFG
4734  * @return array
4735  */
4736 function get_list_of_timezones() {
4737     global $CFG;
4738
4739     $timezones = array();
4740
4741     if ($rawtimezones = get_records_sql('SELECT MAX(id), name FROM '.$CFG->prefix.'timezone GROUP BY name')) {
4742         foreach($rawtimezones as $timezone) {
4743             if (!empty($timezone->name)) {
4744                 $timezones[$timezone->name] = get_string(strtolower($timezone->name), 'timezones');
4745                 if (substr($timezones[$timezone->name], 0, 1) == '[') {  // No translation found
4746                     $timezones[$timezone->name] = $timezone->name;
4747                 }
4748             }
4749         }
4750     }
4751
4752     asort($timezones);
4753
4754     for ($i = -13; $i <= 13; $i += .5) {
4755         $tzstring = 'GMT';
4756         if ($i < 0) {
4757             $timezones[sprintf("%.1f", $i)] = $tzstring . $i;
4758         } else if ($i > 0) {
4759             $timezones[sprintf("%.1f", $i)] = $tzstring . '+' . $i;
4760         } else {
4761             $timezones[sprintf("%.1f", $i)] = $tzstring;
4762         }
4763     }
4764
4765     return $timezones;
4766 }
4767
4768 /**
4769  * Returns a list of currencies in the current language
4770  *
4771  * @uses $CFG
4772  * @uses $USER
4773  * @return array
4774  */
4775 function get_list_of_currencies() {
4776     global $CFG, $USER;
4777
4778     $lang = current_language();
4779
4780     if (!file_exists($CFG->dataroot .'/lang/'. $lang .'/currencies.php')) {
4781         if ($parentlang = get_string('parentlanguage')) {
4782             if (file_exists($CFG->dataroot .'/lang/'. $parentlang .'/currencies.php')) {
4783                 $lang = $parentlang;
4784             } else {
4785                 $lang = 'en_utf8';  // currencies.php must exist in this pack
4786             }
4787         } else {
4788             $lang = 'en_utf8';  // currencies.php must exist in this pack
4789         }
4790     }
4791
4792     if (file_exists($CFG->dataroot .'/lang/'. $lang .'/currencies.php')) {
4793         include_once($CFG->dataroot .'/lang/'. $lang .'/currencies.php');
4794     } else {    //if en_utf8 is not installed in dataroot
4795         include_once($CFG->dirroot .'/lang/'. $lang .'/currencies.php');
4796     }
4797
4798     if (!empty($string)) {
4799         asort($string);
4800     }
4801
4802     return $string;
4803 }
4804
4805
4806
4807 /**
4808  * Can include a given document file (depends on second
4809  * parameter) or just return info about it.
4810  *
4811  * @uses $CFG
4812  * @param string $file ?
4813  * @param bool $include ?
4814  * @return ?
4815  * @todo Finish documenting this function
4816  */
4817 function document_file($file, $include=true) {
4818     global $CFG;
4819
4820     $file = clean_filename($file);
4821
4822     if (empty($file)) {
4823         return false;
4824     }
4825
4826     $langs = array(current_language(), get_string('parentlanguage'), 'en');
4827
4828     foreach ($langs as $lang) {
4829         $info = new object();
4830         $info->filepath = $CFG->dirroot .'/lang/'. $lang .'/docs/'. $file;
4831         $info->urlpath  = $CFG->wwwroot .'/lang/'. $lang .'/docs/'. $file;
4832
4833         if (file_exists($info->filepath)) {
4834             if ($include) {
4835                 include($info->filepath);
4836             }
4837             return $info;
4838         }
4839     }
4840
4841     return false;
4842 }
4843
4844 /// ENCRYPTION  ////////////////////////////////////////////////
4845
4846 /**
4847  * rc4encrypt
4848  *
4849  * @param string $data ?
4850  * @return string
4851  * @todo Finish documenting this function
4852  */
4853 function rc4encrypt($data) {
4854     $password = 'nfgjeingjk';
4855     return endecrypt($password, $data, '');
4856 }
4857
4858 /**
4859  * rc4decrypt
4860  *
4861  * @param string $data ?
4862  * @return string
4863  * @todo Finish documenting this function
4864  */
4865 function rc4decrypt($data) {
4866     $password = 'nfgjeingjk';
4867     return endecrypt($password, $data, 'de');
4868 }
4869
4870 /**
4871  * Based on a class by Mukul Sabharwal [mukulsabharwal @ yahoo.com]
4872  *
4873  * @param string $pwd ?
4874  * @param string $data ?
4875  * @param string $case ?
4876  * @return string
4877  * @todo Finish documenting this function
4878  */
4879 function endecrypt ($pwd, $data, $case) {
4880
4881     if ($case == 'de') {
4882         $data = urldecode($data);
4883     }
4884
4885     $key[] = '';
4886     $box[] = '';
4887     $temp_swap = '';
4888     $pwd_length = 0;
4889
4890     $pwd_length = strlen($pwd);
4891
4892     for ($i = 0; $i <= 255; $i++) {
4893         $key[$i] = ord(substr($pwd, ($i % $pwd_length), 1));
4894         $box[$i] = $i;
4895     }
4896
4897     $x = 0;
4898
4899     for ($i = 0; $i <= 255; $i++) {
4900         $x = ($x + $box[$i] + $key[$i]) % 256;
4901         $temp_swap = $box[$i];
4902         $box[$i] = $box[$x];
4903         $box[$x] = $temp_swap;
4904     }
4905
4906     $temp = '';
4907     $k = '';
4908
4909     $cipherby = '';
4910     $cipher = '';
4911
4912     $a = 0;
4913     $j = 0;
4914
4915     for ($i = 0; $i < strlen($data); $i++) {
4916         $a = ($a + 1) % 256;
4917         $j = ($j + $box[$a]) % 256;
4918         $temp = $box[$a];
4919         $box[$a] = $box[$j];
4920         $box[$j] = $temp;
4921         $k = $box[(($box[$a] + $box[$j]) % 256)];
4922         $cipherby = ord(substr($data, $i, 1)) ^ $k;
4923         $cipher .= chr($cipherby);
4924     }
4925
4926     if ($case == 'de') {
4927         $cipher = urldecode(urlencode($cipher));
4928     } else {
4929         $cipher = urlencode($cipher);
4930     }
4931
4932     return $cipher;
4933 }
4934
4935
4936 /// CALENDAR MANAGEMENT  ////////////////////////////////////////////////////////////////
4937
4938
4939 /**
4940  * Call this function to add an event to the calendar table
4941  *  and to call any calendar plugins
4942  *
4943  * @uses $CFG
4944  * @param array $event An associative array representing an event from the calendar table. The event will be identified by the id field. The object event should include the following:
4945  *  <ul>
4946  *    <li><b>$event->name</b> - Name for the event
4947  *    <li><b>$event->description</b> - Description of the event (defaults to '')
4948  *    <li><b>$event->format</b> - Format for the description (using formatting types defined at the top of weblib.php)
4949  *    <li><b>$event->courseid</b> - The id of the course this event belongs to (0 = all courses)
4950  *    <li><b>$event->groupid</b> - The id of the group this event belongs to (0 = no group)
4951  *    <li><b>$event->userid</b> - The id of the user this event belongs to (0 = no user)
4952  *    <li><b>$event->modulename</b> - Name of the module that creates this event
4953  *    <li><b>$event->instance</b> - Instance of the module that owns this event
4954  *    <li><b>$event->eventtype</b> - The type info together with the module info could
4955  *             be used by calendar plugins to decide how to display event
4956  *    <li><b>$event->timestart</b>- Timestamp for start of event
4957  *    <li><b>$event->timeduration</b> - Duration (defaults to zero)
4958  *    <li><b>$event->visible</b> - 0 if the event should be hidden (e.g. because the activity that created it is hidden)
4959  *  </ul>
4960  * @return int The id number of the resulting record
4961  */
4962  function add_event($event) {
4963
4964     global $CFG;
4965
4966     $event->timemodified = time();
4967
4968     if (!$event->id = insert_record('event', $event)) {
4969         return false;
4970     }
4971
4972     if (!empty($CFG->calendar)) { // call the add_event function of the selected calendar
4973         if (file_exists($CFG->dirroot .'/calendar/'. $CFG->calendar .'/lib.php')) {
4974             include_once($CFG->dirroot .'/calendar/'. $CFG->calendar .'/lib.php');
4975             $calendar_add_event = $CFG->calendar.'_add_event';
4976             if (function_exists($calendar_add_event)) {
4977                 $calendar_add_event($event);
4978             }
4979         }
4980     }
4981
4982     return $event->id;
4983 }
4984
4985 /**
4986  * Call this function to update an event in the calendar table
4987  * the event will be identified by the id field of the $event object.
4988  *
4989  * @uses $CFG
4990  * @param array $event An associative array representing an event from the calendar table. The event will be identified by the id field.
4991  * @return bool
4992  */
4993 function update_event($event) {
4994
4995     global $CFG;
4996
4997     $event->timemodified = time();
4998
4999     if (!empty($CFG->calendar)) { // call the update_event function of the selected calendar
5000         if (file_exists($CFG->dirroot .'/calendar/'. $CFG->calendar .'/lib.php')) {
5001             include_once($CFG->dirroot .'/calendar/'. $CFG->calendar .'/lib.php');
5002             $calendar_update_event = $CFG->calendar.'_update_event';
5003             if (function_exists($calendar_update_event)) {
5004                 $calendar_update_event($event);
5005             }
5006         }
5007     }
5008     return update_record('event', $event);
5009 }
5010
5011 /**
5012  * Call this function to delete the event with id $id from calendar table.
5013  *
5014  * @uses $CFG
5015  * @param int $id The id of an event from the 'calendar' table.
5016  * @return array An associative array with the results from the SQL call.
5017  * @todo Verify return type
5018  */
5019 function delete_event($id) {
5020
5021     global $CFG;
5022
5023     if (!empty($CFG->calendar)) { // call the delete_event function of the selected calendar
5024         if (file_exists($CFG->dirroot .'/calendar/'. $CFG->calendar .'/lib.php')) {
5025             include_once($CFG->dirroot .'/calendar/'. $CFG->calendar .'/lib.php');
5026             $calendar_delete_event = $CFG->calendar.'_delete_event';
5027             if (function_exists($calendar_delete_event)) {
5028                 $calendar_delete_event($id);
5029             }
5030         }
5031     }
5032     return delete_records('event', 'id', $id);
5033 }
5034
5035 /**
5036  * Call this function to hide an event in the calendar table
5037  * the event will be identified by the id field of the $event object.
5038  *
5039  * @uses $CFG
5040  * @param array $event An associative array representing an event from the calendar table. The event will be identified by the id field.
5041  * @return array An associative array with the results from the SQL call.
5042  * @todo Verify return type
5043  */
5044 function hide_event($event) {
5045     global $CFG;
5046
5047     if (!empty($CFG->calendar)) { // call the update_event function of the selected calendar
5048         if (file_exists($CFG->dirroot .'/calendar/'. $CFG->calendar .'/lib.php')) {
5049             include_once($CFG->dirroot .'/calendar/'. $CFG->calendar .'/lib.php');
5050             $calendar_hide_event = $CFG->calendar.'_hide_event';
5051             if (function_exists($calendar_hide_event)) {
5052                 $calendar_hide_event($event);
5053             }
5054         }
5055     }
5056     return set_field('event', 'visible', 0, 'id', $event->id);
5057 }
5058
5059 /**
5060  * Call this function to unhide an event in the calendar table
5061  * the event will be identified by the id field of the $event object.
5062  *
5063  * @uses $CFG
5064  * @param array $event An associative array representing an event from the calendar table. The event will be identified by the id field.
5065  * @return array An associative array with the results from the SQL call.
5066  * @todo Verify return type
5067  */
5068 function show_event($event) {
5069     global $CFG;
5070
5071     if (!empty($CFG->calendar)) { // call the update_event function of the selected calendar
5072         if (file_exists($CFG->dirroot .'/calendar/'. $CFG->calendar .'/lib.php')) {
5073             include_once($CFG->dirroot .'/calendar/'. $CFG->calendar .'/lib.php');
5074             $calendar_show_event = $CFG->calendar.'_show_event';
5075             if (function_exists($calendar_show_event)) {
5076                 $calendar_show_event($event);
5077             }
5078         }
5079     }
5080     return set_field('event', 'visible', 1, 'id', $event->id);
5081 }
5082
5083
5084 /// ENVIRONMENT CHECKING  ////////////////////////////////////////////////////////////
5085
5086 /**
5087  * Lists plugin directories within some directory
5088  *
5089  * @uses $CFG
5090  * @param string $plugin dir under we'll look for plugins (defaults to 'mod')
5091  * @param string $exclude dir name to exclude from the list (defaults to none)
5092  * @param string $basedir full path to the base dir where $plugin resides (defaults to $CFG->dirroot)
5093  * @return array of plugins found under the requested parameters
5094  */
5095 function get_list_of_plugins($plugin='mod', $exclude='', $basedir='') {
5096
5097     global $CFG;
5098
5099     $plugins = array();
5100
5101     if (empty($basedir)) {
5102
5103         # This switch allows us to use the appropiate theme directory - and potentialy alternatives for other plugins
5104         switch ($plugin) {
5105         case "theme":
5106             $basedir = $CFG->themedir;
5107             break;
5108
5109         default:
5110             $basedir = $CFG->dirroot .'/'. $plugin;
5111         }
5112
5113     } else {
5114         $basedir = $basedir .'/'. $plugin;
5115     }
5116
5117     if (file_exists($basedir) && filetype($basedir) == 'dir') {
5118         $dirhandle = opendir($basedir);
5119         while (false !== ($dir = readdir($dirhandle))) {
5120             $firstchar = substr($dir, 0, 1);
5121             if ($firstchar == '.' or $dir == 'CVS' or $dir == '_vti_cnf' or $dir == $exclude) {
5122                 continue;
5123             }
5124             if (filetype($basedir .'/'. $dir) != 'dir') {
5125                 continue;
5126             }
5127             $plugins[] = $dir;
5128         }
5129         closedir($dirhandle);
5130     }
5131     if ($plugins) {
5132         asort($plugins);
5133     }
5134     return $plugins;
5135 }
5136
5137 /**
5138  * Returns true if the current version of PHP is greater that the specified one.
5139  *
5140  * @param string $version The version of php being tested.
5141  * @return bool
5142  */
5143 function check_php_version($version='4.1.0') {
5144     return (version_compare(phpversion(), $version) >= 0);
5145 }
5146
5147
5148 /**
5149  * Checks to see if is a browser matches the specified
5150  * brand and is equal or better version.
5151  *
5152  * @uses $_SERVER
5153  * @param string $brand The browser identifier being tested
5154  * @param int $version The version of the browser
5155  * @return bool true if the given version is below that of the detected browser
5156  */
5157  function check_browser_version($brand='MSIE', $version=5.5) {
5158     if (empty($_SERVER['HTTP_USER_AGENT'])) {
5159         return false;
5160     }
5161
5162     $agent = $_SERVER['HTTP_USER_AGENT'];
5163
5164     switch ($brand) {
5165
5166       case 'Camino':   /// Mozilla Firefox browsers
5167
5168               if (preg_match("/Camino\/([0-9\.]+)/i", $agent, $match)) {
5169                   if (version_compare($match[1], $version) >= 0) {
5170                       return true;
5171                   }
5172               }
5173               break;
5174
5175
5176       case 'Firefox':   /// Mozilla Firefox browsers
5177
5178           if (preg_match("/Firefox\/([0-9\.]+)/i", $agent, $match)) {
5179               if (version_compare($match[1], $version) >= 0) {
5180                   return true;
5181               }
5182           }
5183           break;
5184
5185
5186       case 'Gecko':   /// Gecko based browsers
5187
5188           if (substr_count($agent, 'Camino')) {
5189               // MacOS X Camino support
5190               $version = 20041110;
5191           }
5192
5193           // the proper string - Gecko/CCYYMMDD Vendor/Version
5194           // Faster version and work-a-round No IDN problem.
5195           if (preg_match("/Gecko\/([0-9]+)/i", $agent, $match)) {
5196               if ($match[1] > $version) {
5197                       return true;
5198                   }
5199               }
5200           break;
5201
5202
5203       case 'MSIE':   /// Internet Explorer
5204
5205           if (strpos($agent, 'Opera')) {     // Reject Opera
5206               return false;
5207           }
5208           $string = explode(';', $agent);
5209           if (!isset($string[1])) {
5210               return false;
5211           }
5212           $string = explode(' ', trim($string[1]));
5213           if (!isset($string[0]) and !isset($string[1])) {
5214               return false;
5215           }
5216           if ($string[0] == $brand and (float)$string[1] >= $version ) {
5217               return true;
5218           }
5219           break;
5220
5221       case 'Opera':  /// Opera
5222
5223           if (preg_match("/Opera\/([0-9\.]+)/i", $agent, $match)) {
5224               if (version_compare($match[1], $version) >= 0) {
5225                   return true;
5226               }
5227           }
5228           break;
5229
5230       case 'Safari':  /// Safari
5231           // Look for AppleWebKit, excluding strings with OmniWeb, Shiira and SimbianOS
5232           if (strpos($agent, 'OmniWeb')) { // Reject OmniWeb
5233               return false;
5234           } elseif (strpos($agent, 'Shiira')) { // Reject Shiira
5235               return false;
5236           } elseif (strpos($agent, 'SimbianOS')) { // Reject SimbianOS
5237               return false;
5238           }
5239
5240           if (preg_match("/AppleWebKit\/([0-9]+)/i", $agent, $match)) {
5241               if (version_compare($match[1], $version) >= 0) {
5242                   return true;
5243               }
5244           }
5245
5246           break;
5247
5248     }
5249
5250     return false;
5251 }
5252
5253 /**
5254  * This function makes the return value of ini_get consistent if you are
5255  * setting server directives through the .htaccess file in apache.
5256  * Current behavior for value set from php.ini On = 1, Off = [blank]
5257  * Current behavior for value set from .htaccess On = On, Off = Off
5258  * Contributed by jdell @ unr.edu
5259  *
5260  * @param string $ini_get_arg ?
5261  * @return bool
5262  * @todo Finish documenting this function
5263  */
5264 function ini_get_bool($ini_get_arg) {
5265     $temp = ini_get($ini_get_arg);
5266
5267     if ($temp == '1' or strtolower($temp) == 'on') {
5268         return true;
5269     }
5270     return false;
5271 }
5272
5273 /**
5274  * Compatibility stub to provide backward compatibility
5275  *
5276  * Determines if the HTML editor is enabled.
5277  * @deprecated Use {@link can_use_html_editor()} instead.
5278  */
5279  function can_use_richtext_editor() {
5280     return can_use_html_editor();
5281 }
5282
5283 /**
5284  * Determines if the HTML editor is enabled.
5285  *
5286  * This depends on site and user
5287  * settings, as well as the current browser being used.
5288  *
5289  * @return string|false Returns false if editor is not being used, otherwise
5290  * returns 'MSIE' or 'Gecko'.
5291  */
5292  function can_use_html_editor() {
5293     global $USER, $CFG;
5294
5295     if (!empty($USER->htmleditor) and !empty($CFG->htmleditor)) {
5296         if (check_browser_version('MSIE', 5.5)) {
5297             return 'MSIE';
5298         } else if (check_browser_version('Gecko', 20030516)) {
5299             return 'Gecko';
5300         }
5301     }
5302     return false;
5303 }
5304
5305 /**
5306  * Hack to find out the GD version by parsing phpinfo output
5307  *
5308  * @return int GD version (1, 2, or 0)
5309  */
5310 function check_gd_version() {
5311     $gdversion = 0;
5312
5313     if (function_exists('gd_info')){
5314         $gd_info = gd_info();
5315         if (substr_count($gd_info['GD Version'], '2.')) {
5316             $gdversion = 2;
5317         } else if (substr_count($gd_info['GD Version'], '1.')) {
5318             $gdversion = 1;
5319         }
5320
5321     } else {
5322         ob_start();
5323         phpinfo(8);
5324         $phpinfo = ob_get_contents();
5325         ob_end_clean();
5326
5327         $phpinfo = explode("\n", $phpinfo);
5328
5329
5330         foreach ($phpinfo as $text) {
5331             $parts = explode('</td>', $text);
5332             foreach ($parts as $key => $val) {
5333                 $parts[$key] = trim(strip_tags($val));
5334             }
5335             if ($parts[0] == 'GD Version') {
5336                 if (substr_count($parts[1], '2.0')) {
5337                     $parts[1] = '2.0';
5338                 }
5339                 $gdversion = intval($parts[1]);
5340             }
5341         }
5342     }
5343
5344     return $gdversion;   // 1, 2 or 0
5345 }
5346
5347 /**
5348  * Determine if moodle installation requires update
5349  *
5350  * Checks version numbers of main code and all modules to see
5351  * if there are any mismatches
5352  *
5353  * @uses $CFG
5354  * @return bool
5355  */
5356 function moodle_needs_upgrading() {
5357     global $CFG;
5358
5359     $version = null;
5360     include_once($CFG->dirroot .'/version.php');  # defines $version and upgrades
5361     if ($CFG->version) {
5362         if ($version > $CFG->version) {
5363             return true;
5364         }
5365         if ($mods = get_list_of_plugins('mod')) {
5366             foreach ($mods as $mod) {
5367                 $fullmod = $CFG->dirroot .'/mod/'. $mod;
5368                 $module = new object();
5369                 if (!is_readable($fullmod .'/version.php')) {
5370                     notify('Module "'. $mod .'" is not readable - check permissions');
5371                     continue;
5372                 }
5373                 include_once($fullmod .'/version.php');  # defines $module with version etc
5374                 if ($currmodule = get_record('modules', 'name', $mod)) {
5375                     if ($module->version > $currmodule->version) {
5376                         return true;
5377                     }
5378                 }
5379             }
5380         }
5381     } else {
5382         return true;
5383     }
5384     return false;
5385 }
5386
5387
5388 /// MISCELLANEOUS ////////////////////////////////////////////////////////////////////
5389
5390 /**
5391  * Notify admin users or admin user of any failed logins (since last notification).
5392  *
5393  * @uses $CFG
5394  * @uses $db
5395  * @uses HOURSECS
5396  */
5397 function notify_login_failures() {
5398     global $CFG, $db;
5399
5400     switch ($CFG->notifyloginfailures) {
5401         case 'mainadmin' :
5402             $recip = array(get_admin());
5403             break;
5404         case 'alladmins':
5405             $recip = get_admins();
5406             break;
5407     }
5408
5409     if (empty($CFG->lastnotifyfailure)) {
5410         $CFG->lastnotifyfailure=0;
5411     }
5412
5413     // we need to deal with the threshold stuff first.
5414     if (empty($CFG->notifyloginthreshold)) {
5415         $CFG->notifyloginthreshold = 10; // default to something sensible.
5416     }
5417
5418     $notifyipsrs = $db->Execute('SELECT ip FROM '. $CFG->prefix .'log WHERE time > '. $CFG->lastnotifyfailure .'
5419                           AND module=\'login\' AND action=\'error\' GROUP BY ip HAVING count(*) > '. $CFG->notifyloginthreshold);
5420
5421     $notifyusersrs = $db->Execute('SELECT info FROM '. $CFG->prefix .'log WHERE time > '. $CFG->lastnotifyfailure .'
5422                           AND module=\'login\' AND action=\'error\' GROUP BY info HAVING count(*) > '. $CFG->notifyloginthreshold);
5423
5424     if ($notifyipsrs) {
5425         $ipstr = '';
5426         while ($row = rs_fetch_next_record($notifyipsrs)) {
5427             $ipstr .= "'". $row->ip ."',";
5428         }
5429         rs_close($notifyipsrs);
5430         $ipstr = substr($ipstr,0,strlen($ipstr)-1);
5431     }
5432     if ($notifyusersrs) {
5433         $userstr = '';
5434         while ($row = rs_fetch_next_record($notifyusersrs)) {
5435             $userstr .= "'". $row->info ."',";
5436         }
5437         rs_close($notifyusersrs);
5438         $userstr = substr($userstr,0,strlen($userstr)-1);
5439     }
5440
5441     if (strlen($userstr) > 0 || strlen($ipstr) > 0) {
5442         $count = 0;
5443         $logs = get_logs('time > '. $CFG->lastnotifyfailure .' AND module=\'login\' AND action=\'error\' '
5444                  .((strlen($ipstr) > 0 && strlen($userstr) > 0) ? ' AND ( ip IN ('. $ipstr .') OR info IN ('. $userstr .') ) '
5445                  : ((strlen($ipstr) != 0) ? ' AND ip IN ('. $ipstr .') ' : ' AND info IN ('. $userstr .') ')), 'l.time DESC', '', '', $count);
5446
5447         // if we haven't run in the last hour and we have something useful to report and we are actually supposed to be reporting to somebody
5448         if (is_array($recip) and count($recip) > 0 and ((time() - HOURSECS) > $CFG->lastnotifyfailure)
5449             and is_array($logs) and count($logs) > 0) {
5450
5451             $message = '';
5452             $site = get_site();
5453             $subject = get_string('notifyloginfailuressubject', '', $site->fullname);
5454             $message .= get_string('notifyloginfailuresmessagestart', '', $CFG->wwwroot)
5455                  .(($CFG->lastnotifyfailure != 0) ? '('.userdate($CFG->lastnotifyfailure).')' : '')."\n\n";
5456             foreach ($logs as $log) {
5457                 $log->time = userdate($log->time);
5458                 $message .= get_string('notifyloginfailuresmessage','',$log)."\n";
5459             }
5460             $message .= "\n\n".get_string('notifyloginfailuresmessageend','',$CFG->wwwroot)."\n\n";
5461             foreach ($recip as $admin) {
5462                 mtrace('Emailing '. $admin->username .' about '. count($logs) .' failed login attempts');
5463                 email_to_user($admin,get_admin(),$subject,$message);
5464             }
5465             $conf = new object();
5466             $conf->name = 'lastnotifyfailure';
5467             $conf->value = time();
5468             if ($current = get_record('config', 'name', 'lastnotifyfailure')) {
5469                 $conf->id = $current->id;
5470                 if (! update_record('config', $conf)) {
5471                     mtrace('Could not update last notify time');
5472                 }
5473
5474             } else if (! insert_record('config', $conf)) {
5475                 mtrace('Could not set last notify time');
5476             }
5477         }
5478     }
5479 }
5480
5481 /**
5482  * moodle_setlocale
5483  *
5484  * @uses $CFG
5485  * @param string $locale ?
5486  * @todo Finish documenting this function
5487  */
5488 function moodle_setlocale($locale='') {
5489
5490     global $CFG;
5491
5492     static $currentlocale = ''; // last locale caching
5493
5494     $oldlocale = $currentlocale;
5495
5496 /// Fetch the correct locale based on ostype
5497     if($CFG->ostype == 'WINDOWS') {
5498         $stringtofetch = 'localewin';
5499     } else {
5500         $stringtofetch = 'locale';
5501     }
5502
5503 /// the priority is the same as in get_string() - parameter, config, course, session, user, global language
5504     if (!empty($locale)) {
5505         $currentlocale = $locale;
5506     } else if (!empty($CFG->locale)) { // override locale for all language packs
5507         $currentlocale = $CFG->locale;
5508     } else {
5509         $currentlocale = get_string($stringtofetch);
5510     }
5511
5512 /// do nothing if locale already set up
5513     if ($oldlocale == $currentlocale) {
5514         return;
5515     }
5516
5517 /// Due to some strange BUG we cannot set the LC_TIME directly, so we fetch current values,
5518 /// set LC_ALL and then set values again. Just wondering why we cannot set LC_ALL only??? - stronk7
5519 /// Some day, numeric, monetary and other categories should be set too, I think. :-/
5520
5521 /// Get current values
5522     $monetary= setlocale (LC_MONETARY, 0);
5523     $numeric = setlocale (LC_NUMERIC, 0);
5524     $ctype   = setlocale (LC_CTYPE, 0);
5525     if ($CFG->ostype != 'WINDOWS') {
5526         $messages= setlocale (LC_MESSAGES, 0);
5527     }
5528 /// Set locale to all
5529     setlocale (LC_ALL, $currentlocale);
5530 /// Set old values
5531     setlocale (LC_MONETARY, $monetary);
5532     setlocale (LC_NUMERIC, $numeric);
5533     if ($CFG->ostype != 'WINDOWS') {
5534         setlocale (LC_MESSAGES, $messages);
5535     }
5536     if ($currentlocale == 'tr_TR' or $currentlocale == 'tr_TR.UTF-8') { // To workaround a well-known PHP problem with Turkish letter Ii
5537         setlocale (LC_CTYPE, $ctype);
5538     }
5539 }
5540
5541 /**
5542  * Converts string to lowercase using most compatible function available.
5543  *
5544  * @param string $string The string to convert to all lowercase characters.
5545  * @param string $encoding The encoding on the string.
5546  * @return string
5547  * @todo Add examples of calling this function with/without encoding types
5548  * @deprecated Use textlib->strtolower($text) instead.
5549  */
5550 function moodle_strtolower ($string, $encoding='') {
5551
5552     //If not specified use utf8
5553     if (empty($encoding)) {
5554         $encoding = 'UTF-8';
5555     }
5556     //Use text services
5557     $textlib = textlib_get_instance();
5558
5559     return $textlib->strtolower($string, $encoding);
5560 }
5561
5562 /**
5563  * Count words in a string.
5564  *
5565  * Words are defined as things between whitespace.
5566  *
5567  * @param string $string The text to be searched for words.
5568  * @return int The count of words in the specified string
5569  */
5570 function count_words($string) {
5571     $string = strip_tags($string);
5572     return count(preg_split("/\w\b/", $string)) - 1;
5573 }
5574
5575 /** Count letters in a string.
5576  *
5577  * Letters are defined as chars not in tags and different from whitespace.
5578  *
5579  * @param string $string The text to be searched for letters.
5580  * @return int The count of letters in the specified text.
5581  */
5582 function count_letters($string) {
5583 /// Loading the textlib singleton instance. We are going to need it.
5584     $textlib = textlib_get_instance();
5585
5586     $string = strip_tags($string); // Tags are out now
5587     $string = ereg_replace('[[:space:]]*','',$string); //Whitespace are out now
5588
5589     return $textlib->strlen($string);
5590 }
5591
5592 /**
5593  * Generate and return a random string of the specified length.
5594  *
5595  * @param int $length The length of the string to be created.
5596  * @return string
5597  */
5598 function random_string ($length=15) {
5599     $pool  = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
5600     $pool .= 'abcdefghijklmnopqrstuvwxyz';
5601     $pool .= '0123456789';
5602     $poollen = strlen($pool);
5603     mt_srand ((double) microtime() * 1000000);
5604     $string = '';
5605     for ($i = 0; $i < $length; $i++) {
5606         $string .= substr($pool, (mt_rand()%($poollen)), 1);
5607     }
5608     return $string;
5609 }
5610
5611 /*
5612  * Given some text (which may contain HTML) and an ideal length,
5613  * this function truncates the text neatly on a word boundary if possible
5614  */
5615 function shorten_text($text, $ideal=30) {
5616
5617    global $CFG;
5618
5619
5620    $i = 0;
5621    $tag = false;
5622    $length = strlen($text);
5623    $count = 0;
5624    $stopzone = false;
5625    $truncate = 0;
5626
5627    if ($length <= $ideal) {
5628        return $text;
5629    }
5630
5631    for ($i=0; $i<$length; $i++) {
5632        $char = $text[$i];
5633
5634        switch ($char) {
5635            case "<":
5636                $tag = true;
5637                break;
5638            case ">":
5639                $tag = false;
5640                break;
5641            default:
5642                if (!$tag) {
5643                    if ($stopzone) {
5644                        if ($char == '.' or $char == ' ') {
5645                            $truncate = $i+1;
5646                            break 2;
5647                        } else if (ord($char) >= 0xE0) {  // Chinese/Japanese/Korean text
5648                            $truncate = $i;               // can be truncated at any UTF-8
5649                            break 2;                      // character boundary.
5650                        }
5651                    }
5652                    $count++;
5653                }
5654                break;
5655        }
5656        if (!$stopzone) {
5657            if ($count > $ideal) {
5658                $stopzone = true;
5659            }
5660        }
5661    }
5662
5663    if (!$truncate) {
5664        $truncate = $i;
5665    }
5666
5667    $ellipse = ($truncate < $length) ? '...' : '';
5668
5669    return substr($text, 0, $truncate).$ellipse;
5670 }
5671
5672
5673 /**
5674  * Given dates in seconds, how many weeks is the date from startdate
5675  * The first week is 1, the second 2 etc ...
5676  *
5677  * @uses WEEKSECS
5678  * @param ? $startdate ?
5679  * @param ? $thedate ?
5680  * @return string
5681  * @todo Finish documenting this function
5682  */
5683 function getweek ($startdate, $thedate) {
5684     if ($thedate < $startdate) {   // error
5685         return 0;
5686     }
5687
5688     return floor(($thedate - $startdate) / WEEKSECS) + 1;
5689 }
5690
5691 /**
5692  * returns a randomly generated password of length $maxlen.  inspired by
5693  * {@link http://www.phpbuilder.com/columns/jesus19990502.php3}
5694  *
5695  * @param int $maxlength  The maximum size of the password being generated.
5696  * @return string
5697  */
5698 function generate_password($maxlen=10) {
5699     global $CFG;
5700
5701     $fillers = '1234567890!$-+';
5702     $wordlist = file($CFG->wordlist);
5703
5704     srand((double) microtime() * 1000000);
5705     $word1 = trim($wordlist[rand(0, count($wordlist) - 1)]);
5706     $word2 = trim($wordlist[rand(0, count($wordlist) - 1)]);
5707     $filler1 = $fillers[rand(0, strlen($fillers) - 1)];
5708
5709     return substr($word1 . $filler1 . $word2, 0, $maxlen);
5710 }
5711
5712 /**
5713  * Given a float, prints it nicely
5714  *
5715  * @param float $num The float to print
5716  * @param int $places The number of decimal places to print.
5717  * @return string
5718  */
5719 function format_float($num, $places=1) {
5720     return sprintf("%.$places"."f", $num);
5721 }
5722
5723 /**
5724  * Given a simple array, this shuffles it up just like shuffle()
5725  * Unlike PHP's shuffle() ihis function works on any machine.
5726  *
5727  * @param array $array The array to be rearranged
5728  * @return array
5729  */
5730 function swapshuffle($array) {
5731
5732     srand ((double) microtime() * 10000000);
5733     $last = count($array) - 1;
5734     for ($i=0;$i<=$last;$i++) {
5735         $from = rand(0,$last);
5736         $curr = $array[$i];
5737         $array[$i] = $array[$from];
5738         $array[$from] = $curr;
5739     }
5740     return $array;
5741 }
5742
5743 /**
5744  * Like {@link swapshuffle()}, but works on associative arrays
5745  *
5746  * @param array $array The associative array to be rearranged
5747  * @return array
5748  */
5749 function swapshuffle_assoc($array) {
5750 ///
5751
5752     $newkeys = swapshuffle(array_keys($array));
5753     foreach ($newkeys as $newkey) {
5754         $newarray[$newkey] = $array[$newkey];
5755     }
5756     return $newarray;
5757 }
5758
5759 /**
5760  * Given an arbitrary array, and a number of draws,
5761  * this function returns an array with that amount
5762  * of items.  The indexes are retained.
5763  *
5764  * @param array $array ?
5765  * @param ? $draws ?
5766  * @return ?
5767  * @todo Finish documenting this function
5768  */
5769 function draw_rand_array($array, $draws) {
5770     srand ((double) microtime() * 10000000);
5771
5772     $return = array();
5773
5774     $last = count($array);
5775
5776     if ($draws > $last) {
5777         $draws = $last;
5778     }
5779
5780     while ($draws > 0) {
5781         $last--;
5782
5783         $keys = array_keys($array);
5784         $rand = rand(0, $last);
5785
5786         $return[$keys[$rand]] = $array[$keys[$rand]];
5787         unset($array[$keys[$rand]]);
5788
5789         $draws--;
5790     }
5791
5792     return $return;
5793 }
5794
5795 /**
5796  * microtime_diff
5797  *
5798  * @param string $a ?
5799  * @param string $b ?
5800  * @return string
5801  * @todo Finish documenting this function
5802  */
5803 function microtime_diff($a, $b) {
5804     list($a_dec, $a_sec) = explode(' ', $a);
5805     list($b_dec, $b_sec) = explode(' ', $b);
5806     return $b_sec - $a_sec + $b_dec - $a_dec;
5807 }
5808
5809 /**
5810  * Given a list (eg a,b,c,d,e) this function returns
5811  * an array of 1->a, 2->b, 3->c etc
5812  *
5813  * @param array $list ?
5814  * @param string $separator ?
5815  * @todo Finish documenting this function
5816  */
5817 function make_menu_from_list($list, $separator=',') {
5818
5819     $array = array_reverse(explode($separator, $list), true);
5820     foreach ($array as $key => $item) {
5821         $outarray[$key+1] = trim($item);
5822     }
5823     return $outarray;
5824 }
5825
5826 /**
5827  * Creates an array that represents all the current grades that
5828  * can be chosen using the given grading type.  Negative numbers
5829  * are scales, zero is no grade, and positive numbers are maximum
5830  * grades.
5831  *
5832  * @param int $gradingtype ?
5833  * return int
5834  * @todo Finish documenting this function
5835  */
5836 function make_grades_menu($gradingtype) {
5837     $grades = array();
5838     if ($gradingtype < 0) {
5839         if ($scale = get_record('scale', 'id', - $gradingtype)) {
5840             return make_menu_from_list($scale->scale);
5841         }
5842     } else if ($gradingtype > 0) {
5843         for ($i=$gradingtype; $i>=0; $i--) {
5844             $grades[$i] = $i .' / '. $gradingtype;
5845         }
5846         return $grades;
5847     }
5848     return $grades;
5849 }
5850
5851 /**
5852  * This function returns the nummber of activities
5853  * using scaleid in a courseid
5854  *
5855  * @param int $courseid ?
5856  * @param int $scaleid ?
5857  * @return int
5858  * @todo Finish documenting this function
5859  */
5860 function course_scale_used($courseid, $scaleid) {
5861
5862     global $CFG;
5863
5864     $return = 0;
5865
5866     if (!empty($scaleid)) {
5867         if ($cms = get_course_mods($courseid)) {
5868             foreach ($cms as $cm) {
5869                 //Check cm->name/lib.php exists
5870                 if (file_exists($CFG->dirroot.'/mod/'.$cm->modname.'/lib.php')) {
5871                     include_once($CFG->dirroot.'/mod/'.$cm->modname.'/lib.php');
5872                     $function_name = $cm->modname.'_scale_used';
5873                     if (function_exists($function_name)) {
5874                         if ($function_name($cm->instance,$scaleid)) {
5875                             $return++;
5876                         }
5877                     }
5878                 }
5879             }
5880         }
5881     }
5882     return $return;
5883 }
5884
5885 /**
5886  * This function returns the nummber of activities
5887  * using scaleid in the entire site
5888  *
5889  * @param int $scaleid ?
5890  * @return int
5891  * @todo Finish documenting this function. Is return type correct?
5892  */
5893 function site_scale_used($scaleid,&$courses) {
5894
5895     global $CFG;
5896
5897     $return = 0;
5898
5899     if (!is_array($courses) || count($courses) == 0) {
5900         $courses = get_courses("all",false,"c.id,c.shortname");
5901     }
5902
5903     if (!empty($scaleid)) {
5904         if (is_array($courses) && count($courses) > 0) {
5905             foreach ($courses as $course) {
5906                 $return += course_scale_used($course->id,$scaleid);
5907             }
5908         }
5909     }
5910     return $return;
5911 }
5912
5913 /**
5914  * make_unique_id_code
5915  *
5916  * @param string $extra ?
5917  * @return string
5918  * @todo Finish documenting this function
5919  */
5920 function make_unique_id_code($extra='') {
5921
5922     $hostname = 'unknownhost';
5923     if (!empty($_SERVER['HTTP_HOST'])) {
5924         $hostname = $_SERVER['HTTP_HOST'];
5925     } else if (!empty($_ENV['HTTP_HOST'])) {
5926         $hostname = $_ENV['HTTP_HOST'];
5927     } else if (!empty($_SERVER['SERVER_NAME'])) {
5928         $hostname = $_SERVER['SERVER_NAME'];
5929     } else if (!empty($_ENV['SERVER_NAME'])) {
5930         $hostname = $_ENV['SERVER_NAME'];
5931     }
5932
5933     $date = gmdate("ymdHis");
5934
5935     $random =  random_string(6);
5936
5937     if ($extra) {
5938         return $hostname .'+'. $date .'+'. $random .'+'. $extra;
5939     } else {
5940         return $hostname .'+'. $date .'+'. $random;
5941     }
5942 }
5943
5944
5945 /**
5946  * Function to check the passed address is within the passed subnet
5947  *
5948  * The parameter is a comma separated string of subnet definitions.
5949  * Subnet strings can be in one of three formats:
5950  *   1: xxx.xxx.xxx.xxx/xx
5951  *   2: xxx.xxx
5952  *   3: xxx.xxx.xxx.xxx-xxx   //a range of IP addresses in the last group.
5953  * Code for type 1 modified from user posted comments by mediator at
5954  * {@link http://au.php.net/manual/en/function.ip2long.php}
5955  *
5956  * @param string $addr    The address you are checking
5957  * @param string $subnetstr    The string of subnet addresses
5958  * @return bool
5959  */
5960 function address_in_subnet($addr, $subnetstr) {
5961
5962     $subnets = explode(',', $subnetstr);
5963     $found = false;
5964     $addr = trim($addr);
5965
5966     foreach ($subnets as $subnet) {
5967         $subnet = trim($subnet);
5968         if (strpos($subnet, '/') !== false) { /// type 1
5969             list($ip, $mask) = explode('/', $subnet);
5970             $mask = 0xffffffff << (32 - $mask);
5971             $found = ((ip2long($addr) & $mask) == (ip2long($ip) & $mask));
5972         } else if (strpos($subnet, '-') !== false)  {/// type 3
5973             $subnetparts = explode('.', $subnet);
5974             $addrparts = explode('.', $addr);
5975             $subnetrange = explode('-', array_pop($subnetparts));
5976             if (count($subnetrange) == 2) {
5977                 $lastaddrpart = array_pop($addrparts);
5978                 $found = ($subnetparts == $addrparts &&
5979                         $subnetrange[0] <= $lastaddrpart && $lastaddrpart <= $subnetrange[1]);
5980             }
5981         } else { /// type 2
5982             $found = (strpos($addr, $subnet) === 0);
5983         }
5984
5985         if ($found) {
5986             break;
5987         }
5988     }
5989     return $found;
5990 }
5991
5992 /**
5993  * This function sets the $HTTPSPAGEREQUIRED global
5994  * (used in some parts of moodle to change some links)
5995  * and calculate the proper wwwroot to be used
5996  *
5997  * By using this function properly, we can ensure 100% https-ized pages
5998  * at our entire discretion (login, forgot_password, change_password)
5999  */
6000 function httpsrequired() {
6001
6002     global $CFG, $HTTPSPAGEREQUIRED;
6003
6004     if (!empty($CFG->loginhttps)) {
6005         $HTTPSPAGEREQUIRED = true;
6006         $CFG->httpswwwroot = str_replace('http:', 'https:', $CFG->wwwroot);
6007         $CFG->httpsthemewww = str_replace('http:', 'https:', $CFG->themewww);
6008
6009         // change theme URLs to https
6010         theme_setup();
6011
6012     } else {
6013         $CFG->httpswwwroot = $CFG->wwwroot;
6014         $CFG->httpsthemewww = $CFG->themewww;
6015     }
6016 }
6017
6018 /**
6019  * For outputting debugging info
6020  *
6021  * @uses STDOUT
6022  * @param string $string ?
6023  * @param string $eol ?
6024  * @todo Finish documenting this function
6025  */
6026 function mtrace($string, $eol="\n", $sleep=0) {
6027
6028     if (defined('STDOUT')) {
6029         fwrite(STDOUT, $string.$eol);
6030     } else {
6031         echo $string . $eol;
6032     }
6033
6034     flush();
6035
6036     //delay to keep message on user's screen in case of subsequent redirect
6037     if ($sleep) {
6038         sleep($sleep);
6039     }
6040 }
6041
6042 //Replace 1 or more slashes or backslashes to 1 slash
6043 function cleardoubleslashes ($path) {
6044     return preg_replace('/(\/|\\\){1,}/','/',$path);
6045 }
6046
6047 function zip_files ($originalfiles, $destination) {
6048 //Zip an array of files/dirs to a destination zip file
6049 //Both parameters must be FULL paths to the files/dirs
6050
6051     global $CFG;
6052
6053     //Extract everything from destination
6054     $path_parts = pathinfo(cleardoubleslashes($destination));
6055     $destpath = $path_parts["dirname"];       //The path of the zip file
6056     $destfilename = $path_parts["basename"];  //The name of the zip file
6057     $extension = $path_parts["extension"];    //The extension of the file
6058
6059     //If no file, error
6060     if (empty($destfilename)) {
6061         return false;
6062     }
6063
6064     //If no extension, add it
6065     if (empty($extension)) {
6066         $extension = 'zip';
6067         $destfilename = $destfilename.'.'.$extension;
6068     }
6069
6070     //Check destination path exists
6071     if (!is_dir($destpath)) {
6072         return false;
6073     }
6074
6075     //Check destination path is writable. TODO!!
6076
6077     //Clean destination filename
6078     $destfilename = clean_filename($destfilename);
6079
6080     //Now check and prepare every file
6081     $files = array();
6082     $origpath = NULL;
6083
6084     foreach ($originalfiles as $file) {  //Iterate over each file
6085         //Check for every file
6086         $tempfile = cleardoubleslashes($file); // no doubleslashes!
6087         //Calculate the base path for all files if it isn't set
6088         if ($origpath === NULL) {
6089             $origpath = rtrim(cleardoubleslashes(dirname($tempfile)), "/");
6090         }
6091         //See if the file is readable
6092         if (!is_readable($tempfile)) {  //Is readable
6093             continue;
6094         }
6095         //See if the file/dir is in the same directory than the rest
6096         if (rtrim(cleardoubleslashes(dirname($tempfile)), "/") != $origpath) {
6097             continue;
6098         }
6099         //Add the file to the array
6100         $files[] = $tempfile;
6101     }
6102
6103     //Everything is ready:
6104     //    -$origpath is the path where ALL the files to be compressed reside (dir).
6105     //    -$destpath is the destination path where the zip file will go (dir).
6106     //    -$files is an array of files/dirs to compress (fullpath)
6107     //    -$destfilename is the name of the zip file (without path)
6108
6109     //print_object($files);                  //Debug
6110
6111     if (empty($CFG->zip)) {    // Use built-in php-based zip function
6112
6113         include_once("$CFG->libdir/pclzip/pclzip.lib.php");
6114         //rewrite filenames because the old method with PCLZIP_OPT_REMOVE_PATH does not work under win32
6115         $zipfiles = array();
6116         $start = strlen($origpath)+1;
6117         foreach($files as $file) {
6118             $tf = array();
6119             $tf[PCLZIP_ATT_FILE_NAME] = $file;
6120             $tf[PCLZIP_ATT_FILE_NEW_FULL_NAME] = substr($file, $start);
6121             $zipfiles[] = $tf;
6122         }
6123         //create the archive
6124         $archive = new PclZip(cleardoubleslashes("$destpath/$destfilename"));
6125         if (($list = $archive->create($zipfiles) == 0)) {
6126             notice($archive->errorInfo(true));
6127             return false;
6128         }
6129
6130     } else {                   // Use external zip program
6131
6132         $filestozip = "";
6133         foreach ($files as $filetozip) {
6134             $filestozip .= escapeshellarg(basename($filetozip));
6135             $filestozip .= " ";
6136         }
6137         //Construct the command
6138         $separator = strtoupper(substr(PHP_OS, 0, 3)) === 'WIN' ? ' &' : ' ;';
6139         $command = 'cd '.escapeshellarg($origpath).$separator.
6140                     escapeshellarg($CFG->zip).' -r '.
6141                     escapeshellarg(cleardoubleslashes("$destpath/$destfilename")).' '.$filestozip;
6142         //All converted to backslashes in WIN
6143         if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
6144             $command = str_replace('/','\\',$command);
6145         }
6146         Exec($command);
6147     }
6148     return true;
6149 }
6150
6151 function unzip_file ($zipfile, $destination = '', $showstatus = true) {
6152 //Unzip one zip file to a destination dir
6153 //Both parameters must be FULL paths
6154 //If destination isn't specified, it will be the
6155 //SAME directory where the zip file resides.
6156
6157     global $CFG;
6158
6159     //Extract everything from zipfile
6160     $path_parts = pathinfo(cleardoubleslashes($zipfile));
6161     $zippath = $path_parts["dirname"];       //The path of the zip file
6162     $zipfilename = $path_parts["basename"];  //The name of the zip file
6163     $extension = $path_parts["extension"];    //The extension of the file
6164
6165     //If no file, error
6166     if (empty($zipfilename)) {
6167         return false;
6168     }
6169
6170     //If no extension, error
6171     if (empty($extension)) {
6172         return false;
6173     }
6174
6175     //Clear $zipfile
6176     $zipfile = cleardoubleslashes($zipfile);
6177
6178     //Check zipfile exists
6179     if (!file_exists($zipfile)) {
6180         return false;
6181     }
6182
6183     //If no destination, passed let's go with the same directory
6184     if (empty($destination)) {
6185         $destination = $zippath;
6186     }
6187
6188     //Clear $destination
6189     $destpath = rtrim(cleardoubleslashes($destination), "/");
6190
6191     //Check destination path exists
6192     if (!is_dir($destpath)) {
6193         return false;
6194     }
6195
6196     //Check destination path is writable. TODO!!
6197
6198     //Everything is ready:
6199     //    -$zippath is the path where the zip file resides (dir)
6200     //    -$zipfilename is the name of the zip file (without path)
6201     //    -$destpath is the destination path where the zip file will uncompressed (dir)
6202
6203     $list = null;
6204
6205     if (empty($CFG->unzip)) {    // Use built-in php-based unzip function
6206
6207         include_once("$CFG->libdir/pclzip/pclzip.lib.php");
6208         $archive = new PclZip(cleardoubleslashes("$zippath/$zipfilename"));
6209         if (!$list = $archive->extract(PCLZIP_OPT_PATH, $destpath,
6210                                        PCLZIP_CB_PRE_EXTRACT, 'unzip_cleanfilename',
6211                                        PCLZIP_OPT_EXTRACT_DIR_RESTRICTION, $destpath)) {
6212             notice($archive->errorInfo(true));
6213             return false;
6214         }
6215
6216     } else {                     // Use external unzip program
6217
6218         $separator = strtoupper(substr(PHP_OS, 0, 3)) === 'WIN' ? ' &' : ' ;';
6219         $redirection = strtoupper(substr(PHP_OS, 0, 3)) === 'WIN' ? '' : ' 2>&1';
6220
6221         $command = 'cd '.escapeshellarg($zippath).$separator.
6222                     escapeshellarg($CFG->unzip).' -o '.
6223                     escapeshellarg(cleardoubleslashes("$zippath/$zipfilename")).' -d '.
6224                     escapeshellarg($destpath).$redirection;
6225         //All converted to backslashes in WIN
6226         if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
6227             $command = str_replace('/','\\',$command);
6228         }
6229         Exec($command,$list);
6230     }
6231
6232     //Display some info about the unzip execution
6233     if ($showstatus) {
6234         unzip_show_status($list,$destpath);
6235     }
6236
6237     return true;
6238 }
6239
6240 function unzip_cleanfilename ($p_event, &$p_header) {
6241 //This function is used as callback in unzip_file() function
6242 //to clean illegal characters for given platform and to prevent directory traversal.
6243 //Produces the same result as info-zip unzip.
6244     $p_header['filename'] = ereg_replace('[[:cntrl:]]', '', $p_header['filename']); //strip control chars first!
6245     $p_header['filename'] = ereg_replace('\.\.+', '', $p_header['filename']); //directory traversal protection
6246     if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
6247         $p_header['filename'] = ereg_replace('[:*"?<>|]', '_', $p_header['filename']); //replace illegal chars
6248         $p_header['filename'] = ereg_replace('^([a-zA-Z])_', '\1:', $p_header['filename']); //repair drive letter
6249     } else {
6250         //Add filtering for other systems here
6251         // BSD: none (tested)
6252         // Linux: ??
6253         // MacosX: ??
6254     }
6255     $p_header['filename'] = cleardoubleslashes($p_header['filename']); //normalize the slashes/backslashes
6256     return 1;
6257 }
6258
6259 function unzip_show_status ($list,$removepath) {
6260 //This function shows the results of the unzip execution
6261 //depending of the value of the $CFG->zip, results will be
6262 //text or an array of files.
6263
6264     global $CFG;
6265
6266     if (empty($CFG->unzip)) {    // Use built-in php-based zip function
6267         $strname = get_string("name");
6268         $strsize = get_string("size");
6269         $strmodified = get_string("modified");
6270         $strstatus = get_string("status");
6271         echo "<table width=\"640\">";
6272         echo "<tr><th class=\"header\" scope=\"col\">$strname</th>";
6273         echo "<th class=\"header\" align=\"right\" scope=\"col\">$strsize</th>";
6274         echo "<th class=\"header\" align=\"right\" scope=\"col\">$strmodified</th>";
6275         echo "<th class=\"header\" align=\"right\" scope=\"col\">$strstatus</th></tr>";
6276         foreach ($list as $item) {
6277             echo "<tr>";
6278             $item['filename'] = str_replace(cleardoubleslashes($removepath).'/', "", $item['filename']);
6279             print_cell("left", s($item['filename']));
6280             if (! $item['folder']) {
6281                 print_cell("right", display_size($item['size']));
6282             } else {
6283                 echo "<td>&nbsp;</td>";
6284             }
6285             $filedate  = userdate($item['mtime'], get_string("strftimedatetime"));
6286             print_cell("right", $filedate);
6287             print_cell("right", $item['status']);
6288             echo "</tr>";
6289         }
6290         echo "</table>";
6291
6292     } else {                   // Use external zip program
6293         print_simple_box_start("center");
6294         echo "<pre>";
6295         foreach ($list as $item) {
6296             echo s(str_replace(cleardoubleslashes($removepath.'/'), '', $item)).'<br />';
6297         }
6298         echo "</pre>";
6299         print_simple_box_end();
6300     }
6301 }
6302
6303 /**
6304  * Returns most reliable client address
6305  *
6306  * @return string The remote IP address
6307  */
6308  function getremoteaddr() {
6309     if (!empty($_SERVER['HTTP_CLIENT_IP'])) {
6310         return cleanremoteaddr($_SERVER['HTTP_CLIENT_IP']);
6311     }
6312     if (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
6313         return cleanremoteaddr($_SERVER['HTTP_X_FORWARDED_FOR']);
6314     }
6315     if (!empty($_SERVER['REMOTE_ADDR'])) {
6316         return cleanremoteaddr($_SERVER['REMOTE_ADDR']);
6317     }
6318     return '';
6319 }
6320
6321 /**
6322  * Cleans a remote address ready to put into the log table
6323  */
6324 function cleanremoteaddr($addr) {
6325     $originaladdr = $addr;
6326     $matches = array();
6327     // first get all things that look like IP addresses.
6328     if (!preg_match_all('/(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})/',$addr,$matches,PREG_SET_ORDER)) {
6329         return '';
6330     }
6331     $goodmatches = array();
6332     $lanmatches = array();
6333     foreach ($matches as $match) {
6334         //        print_r($match);
6335         // check to make sure it's not an internal address.
6336         // the following are reserved for private lans...
6337         // 10.0.0.0 - 10.255.255.255
6338         // 172.16.0.0 - 172.31.255.255
6339         // 192.168.0.0 - 192.168.255.255
6340         // 169.254.0.0 -169.254.255.255
6341         $bits = explode('.',$match[0]);
6342         if (count($bits) != 4) {
6343             // weird, preg match shouldn't give us it.
6344             continue;
6345         }
6346         if (($bits[0] == 10)
6347             || ($bits[0] == 172 && $bits[1] >= 16 && $bits[1] <= 31)
6348             || ($bits[0] == 192 && $bits[1] == 168)
6349             || ($bits[0] == 169 && $bits[1] == 254)) {
6350             $lanmatches[] = $match[0];
6351             continue;
6352         }
6353         // finally, it's ok
6354         $goodmatches[] = $match[0];
6355     }
6356     if (!count($goodmatches)) {
6357         // perhaps we have a lan match, it's probably better to return that.
6358         if (!count($lanmatches)) {
6359             return '';
6360         } else {
6361             return array_pop($lanmatches);
6362         }
6363     }
6364     if (count($goodmatches) == 1) {
6365         return $goodmatches[0];
6366     }
6367     error_log("NOTICE: cleanremoteaddr gives us something funny: $originaladdr had ".count($goodmatches)." matches");
6368     // we need to return something, so
6369     return array_pop($goodmatches);
6370 }
6371
6372 /**
6373  * file_put_contents is only supported by php 5.0 and higher
6374  * so if it is not predefined, define it here
6375  *
6376  * @param $file full path of the file to write
6377  * @param $contents contents to be sent
6378  * @return number of bytes written (false on error)
6379  */
6380 if(!function_exists('file_put_contents')) {
6381     function file_put_contents($file, $contents) {
6382         $result = false;
6383         if ($f = fopen($file, 'w')) {
6384             $result = fwrite($f, $contents);
6385             fclose($f);
6386         }
6387         return $result;
6388     }
6389 }
6390
6391 /**
6392  * The clone keyword is only supported from PHP 5 onwards.
6393  * The behaviour of $obj2 = $obj1 differs fundamentally
6394  * between PHP 4 and PHP 5. In PHP 4 a copy of $obj1 was
6395  * created, in PHP 5 $obj1 is referenced. To create a copy
6396  * in PHP 5 the clone keyword was introduced. This function
6397  * simulates this behaviour for PHP < 5.0.0.
6398  * See also: http://mjtsai.com/blog/2004/07/15/php-5-object-references/
6399  *
6400  * Modified 2005-09-29 by Eloy (from Julian Sedding proposal)
6401  * Found a better implementation (more checks and possibilities) from PEAR:
6402  * http://cvs.php.net/co.php/pear/PHP_Compat/Compat/Function/clone.php
6403  *
6404  * @param object $obj
6405  * @return object
6406  */
6407 if(!check_php_version('5.0.0')) {
6408 // the eval is needed to prevent PHP 5 from getting a parse error!
6409 eval('
6410     function clone($obj) {
6411     /// Sanity check
6412         if (!is_object($obj)) {
6413             user_error(\'clone() __clone method called on non-object\', E_USER_WARNING);
6414             return;
6415         }
6416
6417     /// Use serialize/unserialize trick to deep copy the object
6418         $obj = unserialize(serialize($obj));
6419
6420     /// If there is a __clone method call it on the "new" class
6421         if (method_exists($obj, \'__clone\')) {
6422             $obj->__clone();
6423         }
6424
6425         return $obj;
6426     }
6427
6428     // Supply the PHP5 function scandir() to older versions.
6429     function scandir($directory) {
6430         $files = array();
6431         if ($dh = opendir($directory)) {
6432             while (($file = readdir($dh)) !== false) {
6433                $files[] = $file;
6434             }
6435             closedir($dh);
6436         }
6437         return $files;
6438     }
6439
6440     // Supply the PHP5 function array_combine() to older versions.
6441     function array_combine($keys, $values) {
6442         if (!is_array($keys) || !is_array($values) || count($keys) != count($values)) {
6443             return false;
6444         }
6445         reset($values);
6446         $result = array();
6447         foreach ($keys as $key) {
6448             $result[$key] = current($values);
6449             next($values);
6450         }
6451         return $result;
6452     }
6453 ');
6454 }
6455
6456 /**
6457  * This function will make a complete copy of anything it's given,
6458  * regardless of whether it's an object or not.
6459  * @param mixed $thing
6460  * @return mixed
6461  */
6462 function fullclone($thing) {
6463     return unserialize(serialize($thing));
6464 }
6465
6466
6467 /**
6468  * If new messages are waiting for the current user, then return
6469  * Javascript code to create a popup window
6470  *
6471  * @return string Javascript code
6472  */
6473 function message_popup_window() {
6474     global $USER;
6475
6476     $popuplimit = 30;     // Minimum seconds between popups
6477
6478     if (!defined('MESSAGE_WINDOW')) {
6479         if (isset($USER->id)) {
6480             if (!isset($USER->message_lastpopup)) {
6481                 $USER->message_lastpopup = 0;
6482             }
6483             if ((time() - $USER->message_lastpopup) > $popuplimit) {  /// It's been long enough
6484                 if (get_user_preferences('message_showmessagewindow', 1) == 1) {
6485                     if (count_records_select('message', 'useridto = \''.$USER->id.'\' AND timecreated > \''.$USER->message_lastpopup.'\'')) {
6486                         $USER->message_lastpopup = time();
6487                         return '<script type="text/javascript">'."\n//<![CDATA[\n openpopup('/message/index.php', 'message',
6488                         'menubar=0,location=0,scrollbars,status,resizable,width=400,height=500', 0);\n//]]>\n</script>";
6489                     }
6490                 }
6491             }
6492         }
6493     }
6494
6495     return '';
6496 }
6497
6498 // Used to make sure that $min <= $value <= $max
6499 function bounded_number($min, $value, $max) {
6500     if($value < $min) {
6501         return $min;
6502     }
6503     if($value > $max) {
6504         return $max;
6505     }
6506     return $value;
6507 }
6508
6509 function array_is_nested($array) {
6510     foreach ($array as $value) {
6511         if (is_array($value)) {
6512             return true;
6513         }
6514     }
6515     return false;
6516 }
6517
6518 /**
6519  *** get_performance_info() pairs up with init_performance_info()
6520  *** loaded in setup.php. Returns an array with 'html' and 'txt'
6521  *** values ready for use, and each of the individual stats provided
6522  *** separately as well.
6523  ***
6524  **/
6525 function get_performance_info() {
6526     global $CFG, $PERF, $rcache;
6527
6528     $info = array();
6529     $info['html'] = '';         // holds userfriendly HTML representation
6530     $info['txt']  = me() . ' '; // holds log-friendly representation
6531
6532     $info['realtime'] = microtime_diff($PERF->starttime, microtime());
6533
6534     $info['html'] .= '<span class="timeused">'.$info['realtime'].' secs</span> ';
6535     $info['txt'] .= 'time: '.$info['realtime'].'s ';
6536
6537     if (function_exists('memory_get_usage')) {
6538         $info['memory_total'] = memory_get_usage();
6539         $info['memory_growth'] = memory_get_usage() - $PERF->startmemory;
6540         $info['html'] .= '<span class="memoryused">RAM: '.display_size($info['memory_total']).'</span> ';
6541         $info['txt']  .= 'memory_total: '.$info['memory_total'].'B (' . display_size($info['memory_total']).') memory_growth: '.$info['memory_growth'].'B ('.display_size($info['memory_growth']).') ';
6542     }
6543
6544     $inc = get_included_files();
6545     //error_log(print_r($inc,1));
6546     $info['includecount'] = count($inc);
6547     $info['html'] .= '<span class="included">Included '.$info['includecount'].' files</span> ';
6548     $info['txt']  .= 'includecount: '.$info['includecount'].' ';
6549
6550     if (!empty($PERF->dbqueries)) {
6551         $info['dbqueries'] = $PERF->dbqueries;
6552         $info['html'] .= '<span class="dbqueries">DB queries '.$info['dbqueries'].'</span> ';
6553         $info['txt'] .= 'dbqueries: '.$info['dbqueries'].' ';
6554     }
6555
6556     if (!empty($PERF->logwrites)) {
6557         $info['logwrites'] = $PERF->logwrites;
6558         $info['html'] .= '<span class="logwrites">Log writes '.$info['logwrites'].'</span> ';
6559         $info['txt'] .= 'logwrites: '.$info['logwrites'].' ';
6560     }
6561
6562     if (!empty($PERF->profiling)) {
6563         require_once($CFG->dirroot .'/lib/profilerlib.php');
6564         $profiler = new Profiler();
6565         $info['html'] .= '<span class="profilinginfo">'.$profiler->get_profiling().'</span>';
6566     }
6567
6568     if (function_exists('posix_times')) {
6569         $ptimes = posix_times();
6570         if (is_array($ptimes)) {
6571             foreach ($ptimes as $key => $val) {
6572                 $info[$key] = $ptimes[$key] -  $PERF->startposixtimes[$key];
6573             }
6574             $info['html'] .= "<span class=\"posixtimes\">ticks: $info[ticks] user: $info[utime] sys: $info[stime] cuser: $info[cutime] csys: $info[cstime]</span> ";
6575             $info['txt'] .= "ticks: $info[ticks] user: $info[utime] sys: $info[stime] cuser: $info[cutime] csys: $info[cstime] ";
6576         }
6577     }
6578
6579     // Grab the load average for the last minute
6580     // /proc will only work under some linux configurations
6581     // while uptime is there under MacOSX/Darwin and other unices
6582     if (is_readable('/proc/loadavg') && $loadavg = @file('/proc/loadavg')) {
6583         list($server_load) = explode(' ', $loadavg[0]);
6584         unset($loadavg);
6585     } else if ( function_exists('is_executable') && is_executable('/usr/bin/uptime') && $loadavg = `/usr/bin/uptime` ) {
6586         if (preg_match('/load averages?: (\d+[\.,:]\d+)/', $loadavg, $matches)) {
6587             $server_load = $matches[1];
6588         } else {
6589             trigger_error('Could not parse uptime output!');
6590         }
6591     }
6592     if (!empty($server_load)) {
6593         $info['serverload'] = $server_load;
6594         $info['html'] .= '<span class="serverload">Load average: '.$info['serverload'].'</span> ';
6595         $info['txt'] .= "serverload: {$info['serverload']} ";
6596     }
6597
6598     if (isset($rcache->hits) && isset($rcache->misses)) {
6599         $info['rcachehits'] = $rcache->hits;
6600         $info['rcachemisses'] = $rcache->misses;
6601         $info['html'] .= '<span class="rcache">Record cache hit/miss ratio : '.
6602             "{$rcache->hits}/{$rcache->misses}</span> ";
6603         $info['txt'] .= 'rcache: '.
6604             "{$rcache->hits}/{$rcache->misses} ";
6605     }
6606     $info['html'] = '<div class="performanceinfo">'.$info['html'].'</div>';
6607     return $info;
6608 }
6609
6610 function apd_get_profiling() {
6611     return shell_exec('pprofp -u ' . ini_get('apd.dumpdir') . '/pprof.' . getmypid() . '.*');
6612 }
6613
6614 function remove_dir($dir, $content_only=false) {
6615     // if content_only=true then delete all but
6616     // the directory itself
6617
6618     $handle = opendir($dir);
6619     while (false!==($item = readdir($handle))) {
6620         if($item != '.' && $item != '..') {
6621             if(is_dir($dir.'/'.$item)) {
6622                 remove_dir($dir.'/'.$item);
6623             }else{
6624                 unlink($dir.'/'.$item);
6625             }
6626         }
6627     }
6628     closedir($handle);
6629     if ($content_only) {
6630         return true;
6631     }
6632     return rmdir($dir);
6633 }
6634
6635 /**
6636  * Function to check if a directory exists and optionally create it.
6637  *
6638  * @param string absolute directory path
6639  * @param boolean create directory if does not exist
6640  * @param boolean create directory recursively
6641  *
6642  * @return boolean true if directory exists or created
6643  */
6644 function check_dir_exists($dir, $create=false, $recursive=false) {
6645
6646     global $CFG;
6647
6648     $status = true;
6649
6650     if(!is_dir($dir)) {
6651         if (!$create) {
6652             $status = false;
6653         } else {
6654             umask(0000);
6655             if ($recursive) {
6656                 // PHP 5.0 has recursive mkdir parameter, but 4.x does not :-(
6657                 $dir = str_replace('\\', '/', $dir); //windows compatibility
6658                 $dirs = explode('/', $dir);
6659                 $dir = array_shift($dirs).'/'; //skip root or drive letter
6660                 foreach ($dirs as $part) {
6661                     if ($part == '') {
6662                         continue;
6663                     }
6664                     $dir .= $part.'/';
6665                     if (!is_dir($dir)) {
6666                         if (!mkdir($dir, $CFG->directorypermissions)) {
6667                             $status = false;
6668                             break;
6669                         }
6670                     }
6671                 }
6672             } else {
6673                 $status = mkdir($dir, $CFG->directorypermissions);
6674             }
6675         }
6676     }
6677     return $status;
6678 }
6679
6680 function report_session_error() {
6681     global $CFG, $FULLME;
6682
6683     if (empty($CFG->lang)) {
6684         $CFG->lang = "en";
6685     }
6686     // Set up default theme and locale
6687     theme_setup();
6688     moodle_setlocale();
6689
6690     //clear session cookies
6691     setcookie('MoodleSession'.$CFG->sessioncookie, '', time() - 3600, $CFG->sessioncookiepath);
6692     setcookie('MoodleSessionTest'.$CFG->sessioncookie, '', time() - 3600, $CFG->sessioncookiepath);
6693     //increment database error counters
6694     if (isset($CFG->session_error_counter)) {
6695         set_config('session_error_counter', 1 + $CFG->session_error_counter);
6696     } else {
6697         set_config('session_error_counter', 1);
6698     }
6699     redirect($FULLME, get_string('sessionerroruser2', 'error'), 5);
6700 }
6701
6702
6703 /**
6704  * Detect if an object or a class contains a given property
6705  * will take an actual object or the name of a class
6706  * @param mix $obj Name of class or real object to test
6707  * @param string $property name of property to find
6708  * @return bool true if property exists
6709  */
6710 function object_property_exists( $obj, $property ) {
6711     if (is_string( $obj )) {
6712         $properties = get_class_vars( $obj );
6713     }
6714     else {
6715         $properties = get_object_vars( $obj );
6716     }
6717     return array_key_exists( $property, $properties );
6718 }
6719
6720
6721 /**
6722  * Detect a custom script replacement in the data directory that will
6723  * replace an existing moodle script
6724  * @param string $urlpath path to the original script
6725  * @return string full path name if a custom script exists
6726  * @return bool false if no custom script exists
6727  */
6728 function custom_script_path($urlpath='') {
6729     global $CFG;
6730
6731     // set default $urlpath, if necessary
6732     if (empty($urlpath)) {
6733         $urlpath = qualified_me(); // e.g. http://www.this-server.com/moodle/this-script.php
6734     }
6735
6736     // $urlpath is invalid if it is empty or does not start with the Moodle wwwroot
6737     if (empty($urlpath) or (strpos($urlpath, $CFG->wwwroot) === false )) {
6738         return false;
6739     }
6740
6741     // replace wwwroot with the path to the customscripts folder and clean path
6742     $scriptpath = $CFG->customscripts . clean_param(substr($urlpath, strlen($CFG->wwwroot)), PARAM_PATH);
6743
6744     // remove the query string, if any
6745     if (($strpos = strpos($scriptpath, '?')) !== false) {
6746         $scriptpath = substr($scriptpath, 0, $strpos);
6747     }
6748
6749     // remove trailing slashes, if any
6750     $scriptpath = rtrim($scriptpath, '/\\');
6751
6752     // append index.php, if necessary
6753     if (is_dir($scriptpath)) {
6754         $scriptpath .= '/index.php';
6755     }
6756
6757     // check the custom script exists
6758     if (file_exists($scriptpath)) {
6759         return $scriptpath;
6760     } else {
6761         return false;
6762     }
6763 }
6764
6765 /**
6766  * Wrapper function to load necessary editor scripts
6767  * to $CFG->editorsrc array. Params can be coursei id
6768  * or associative array('courseid' => value, 'name' => 'editorname').
6769  * @uses $CFG
6770  * @param mixed $args Courseid or associative array.
6771  */
6772 function loadeditor($args) {
6773     global $CFG;
6774     include($CFG->libdir .'/editorlib.php');
6775     return editorObject::loadeditor($args);
6776 }
6777
6778 /**
6779  * Returns whether or not the user object is a remote MNET user. This function
6780  * is in moodlelib because it does not rely on loading any of the MNET code.
6781  *
6782  * @param object $user A valid user object
6783  * @return bool        True if the user is from a remote Moodle.
6784  */
6785 function is_mnet_remote_user($user) {
6786     global $CFG;
6787
6788     if (!isset($CFG->mnet_localhost_id)) {
6789         include_once $CFG->dirroot . '/mnet/lib.php';
6790         $env = new mnet_environment();
6791         $env->init();
6792         unset($env);
6793     }
6794
6795     return (!empty($user->mnethostid) && $user->mnethostid != $CFG->mnet_localhost_id);
6796 }
6797
6798 /**
6799  * Checks if a given plugin is in the list of enabled enrolment plugins.
6800  *
6801  * @param string $auth Enrolment plugin.
6802  * @return boolean Whether the plugin is enabled.
6803  */
6804 function is_enabled_enrol($enrol='') {
6805     global $CFG;
6806
6807     // use the global default if not specified
6808     if ($enrol == '') {
6809         $enrol = $CFG->enrol;
6810     }
6811     return in_array($enrol, explode(',', $CFG->enrol_plugins_enabled));
6812 }
6813
6814 /**
6815  * This function will search for browser prefereed languages, setting Moodle
6816  * to use the best one available if $SESSION->lang is undefined
6817  */
6818 function setup_lang_from_browser() {
6819
6820     global $CFG, $SESSION, $USER;
6821
6822     if (!empty($SESSION->lang) or !empty($USER->lang)) {
6823         // Lang is defined in session or user profile, nothing to do
6824         return;
6825     }
6826
6827     if (!isset($_SERVER['HTTP_ACCEPT_LANGUAGE'])) { // There isn't list of browser langs, nothing to do
6828         return;
6829     }
6830
6831 /// Extract and clean langs from headers
6832     $rawlangs = $_SERVER['HTTP_ACCEPT_LANGUAGE'];
6833     $rawlangs = str_replace('-', '_', $rawlangs);         // we are using underscores
6834     $rawlangs = explode(',', $rawlangs);                  // Convert to array
6835     $langs = array();
6836
6837     $order = 1.0;
6838     foreach ($rawlangs as $lang) {
6839         if (strpos($lang, ';') === false) {
6840             $langs[(string)$order] = $lang;
6841             $order = $order-0.01;
6842         } else {
6843             $parts = explode(';', $lang);
6844             $pos = strpos($parts[1], '=');
6845             $langs[substr($parts[1], $pos+1)] = $parts[0];
6846         }
6847     }
6848     krsort($langs, SORT_NUMERIC);
6849
6850 /// Look for such langs under standard locations
6851     foreach ($langs as $lang) {
6852         $lang = clean_param($lang.'_utf8', PARAM_SAFEDIR); // clean it properly for include
6853         if (file_exists($CFG->dataroot .'/lang/'. $lang) or file_exists($CFG->dirroot .'/lang/'. $lang)) {
6854             $SESSION->lang = $lang; /// Lang exists, set it in session
6855             break; /// We have finished. Go out
6856         }
6857     }
6858     return;
6859 }
6860
6861 // vim:autoindent:expandtab:shiftwidth=4:tabstop=4:tw=140:
6862 ?>