Commit | Line | Data |
---|---|---|
b37eac91 | 1 | <?php |
d3f9f1f8 | 2 | |
b37eac91 | 3 | // This file is part of Moodle - http://moodle.org/ |
4 | // | |
5 | // Moodle is free software: you can redistribute it and/or modify | |
6 | // it under the terms of the GNU General Public License as published by | |
7 | // the Free Software Foundation, either version 3 of the License, or | |
8 | // (at your option) any later version. | |
9 | // | |
10 | // Moodle is distributed in the hope that it will be useful, | |
11 | // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | // GNU General Public License for more details. | |
14 | // | |
15 | // You should have received a copy of the GNU General Public License | |
16 | // along with Moodle. If not, see <http://www.gnu.org/licenses/>. | |
17 | ||
18 | ||
19 | /** | |
20 | * These functions are required very early in the Moodle | |
21 | * setup process, before any of the main libraries are | |
22 | * loaded. | |
30fa50d0 | 23 | * |
78bfb562 PS |
24 | * @package core |
25 | * @subpackage lib | |
26 | * @copyright 1999 onwards Martin Dougiamas {@link http://moodle.com} | |
27 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
b37eac91 | 28 | */ |
d3f9f1f8 | 29 | |
78bfb562 PS |
30 | defined('MOODLE_INTERNAL') || die(); |
31 | ||
c84a2dbe | 32 | /// Debug levels /// |
33 | /** no warnings at all */ | |
0f0f0768 | 34 | define('DEBUG_NONE', 0); |
c84a2dbe | 35 | /** E_ERROR | E_PARSE */ |
0f0f0768 | 36 | define('DEBUG_MINIMAL', 5); |
c84a2dbe | 37 | /** E_ERROR | E_PARSE | E_WARNING | E_NOTICE */ |
0f0f0768 | 38 | define('DEBUG_NORMAL', 15); |
c84a2dbe | 39 | /** E_ALL without E_STRICT for now, do show recoverable fatal errors */ |
0f0f0768 | 40 | define('DEBUG_ALL', 6143); |
c84a2dbe | 41 | /** DEBUG_ALL with extra Moodle debug messages - (DEBUG_ALL | 32768) */ |
0f0f0768 PS |
42 | define('DEBUG_DEVELOPER', 38911); |
43 | ||
44 | /** Remove any memory limits */ | |
45 | define('MEMORY_UNLIMITED', -1); | |
46 | /** Standard memory limit for given platform */ | |
47 | define('MEMORY_STANDARD', -2); | |
48 | /** | |
49 | * Large memory limit for given platform - used in cron, upgrade, and other places that need a lot of memory. | |
50 | * Can be overridden with $CFG->extramemorylimit setting. | |
51 | */ | |
52 | define('MEMORY_EXTRA', -3); | |
53 | /** Extremely large memory limit - not recommended for standard scripts */ | |
54 | define('MEMORY_HUGE', -4); | |
c84a2dbe | 55 | |
3d673fc4 DM |
56 | /** |
57 | * Software maturity levels used by the core and plugins | |
58 | */ | |
59 | define('MATURITY_ALPHA', 50); // internals can be tested using white box techniques | |
60 | define('MATURITY_BETA', 100); // feature complete, ready for preview and testing | |
61 | define('MATURITY_RC', 150); // tested, will be released unless there are fatal bugs | |
62 | define('MATURITY_STABLE', 200); // ready for production deployment | |
63 | ||
6a525ce2 | 64 | /** |
b08b3569 | 65 | * Simple class. It is usually used instead of stdClass because it looks |
1387fcdd | 66 | * more familiar to Java developers ;-) Do not use for type checking of |
4f92410f | 67 | * function parameters. Please use stdClass instead. |
b37eac91 | 68 | * |
47d2216e PS |
69 | * @package core |
70 | * @subpackage lib | |
71 | * @copyright 2009 Petr Skoda {@link http://skodak.org} | |
72 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
4f92410f | 73 | * @deprecated since 2.0 |
6a525ce2 | 74 | */ |
b08b3569 | 75 | class object extends stdClass {}; |
6a525ce2 | 76 | |
251387d0 | 77 | /** |
78 | * Base Moodle Exception class | |
b37eac91 | 79 | * |
c84a2dbe | 80 | * Although this class is defined here, you cannot throw a moodle_exception until |
81 | * after moodlelib.php has been included (which will happen very soon). | |
82 | * | |
47d2216e PS |
83 | * @package core |
84 | * @subpackage lib | |
85 | * @copyright 2008 Petr Skoda {@link http://skodak.org} | |
86 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
251387d0 | 87 | */ |
88 | class moodle_exception extends Exception { | |
89 | public $errorcode; | |
90 | public $module; | |
91 | public $a; | |
92 | public $link; | |
eee5d9bb | 93 | public $debuginfo; |
251387d0 | 94 | |
95 | /** | |
96 | * Constructor | |
97 | * @param string $errorcode The name of the string from error.php to print | |
98 | * @param string $module name of module | |
99 | * @param string $link The url where the user will be prompted to continue. If no url is provided the user will be directed to the site index page. | |
100 | * @param object $a Extra words and phrases that might be required in the error string | |
eee5d9bb | 101 | * @param string $debuginfo optional debugging information |
251387d0 | 102 | */ |
5ca18631 | 103 | function __construct($errorcode, $module='', $link='', $a=NULL, $debuginfo=null) { |
104 | if (empty($module) || $module == 'moodle' || $module == 'core') { | |
251387d0 | 105 | $module = 'error'; |
106 | } | |
107 | ||
5ca18631 | 108 | $this->errorcode = $errorcode; |
109 | $this->module = $module; | |
110 | $this->link = $link; | |
111 | $this->a = $a; | |
112 | $this->debuginfo = $debuginfo; | |
251387d0 | 113 | |
4f6be42c DM |
114 | if (get_string_manager()->string_exists($errorcode, $module)) { |
115 | $message = get_string($errorcode, $module, $a); | |
116 | } else { | |
117 | $message = $module . '/' . $errorcode; | |
118 | } | |
251387d0 | 119 | |
120 | parent::__construct($message, 0); | |
121 | } | |
122 | } | |
123 | ||
df997f84 PS |
124 | /** |
125 | * Course/activity access exception. | |
126 | * | |
127 | * This exception is thrown from require_login() | |
47d2216e PS |
128 | * |
129 | * @package core | |
130 | * @subpackage lib | |
131 | * @copyright 2010 Petr Skoda {@link http://skodak.org} | |
132 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
df997f84 PS |
133 | */ |
134 | class require_login_exception extends moodle_exception { | |
135 | function __construct($debuginfo) { | |
136 | parent::__construct('requireloginerror', 'error', '', NULL, $debuginfo); | |
137 | } | |
138 | } | |
139 | ||
559a5dbd | 140 | /** |
141 | * Web service parameter exception class | |
142 | * | |
143 | * This exception must be thrown to the web service client when a web service parameter is invalid | |
144 | * The error string is gotten from webservice.php | |
145 | */ | |
146 | class webservice_parameter_exception extends moodle_exception { | |
147 | /** | |
148 | * Constructor | |
149 | * @param string $errorcode The name of the string from webservice.php to print | |
150 | * @param string $a The name of the parameter | |
151 | */ | |
152 | function __construct($errorcode=null, $a = '') { | |
153 | parent::__construct($errorcode, 'webservice', '', $a, null); | |
154 | } | |
155 | } | |
156 | ||
9a0df45a | 157 | /** |
158 | * Exceptions indicating user does not have permissions to do something | |
159 | * and the execution can not continue. | |
47d2216e PS |
160 | * |
161 | * @package core | |
162 | * @subpackage lib | |
163 | * @copyright 2009 Petr Skoda {@link http://skodak.org} | |
164 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
9a0df45a | 165 | */ |
166 | class required_capability_exception extends moodle_exception { | |
167 | function __construct($context, $capability, $errormessage, $stringfile) { | |
168 | $capabilityname = get_capability_string($capability); | |
848fe203 PS |
169 | if ($context->contextlevel == CONTEXT_MODULE and preg_match('/:view$/', $capability)) { |
170 | // we can not go to mod/xx/view.php because we most probably do not have cap to view it, let's go to course instead | |
171 | $paranetcontext = get_context_instance_by_id(get_parent_contextid($context)); | |
172 | $link = get_context_url($paranetcontext); | |
173 | } else { | |
174 | $link = get_context_url($context); | |
175 | } | |
176 | parent::__construct($errormessage, $stringfile, $link, $capabilityname); | |
9a0df45a | 177 | } |
178 | } | |
179 | ||
655bbf51 | 180 | /** |
cce1b0b9 | 181 | * Exception indicating programming error, must be fixed by a programer. For example |
182 | * a core API might throw this type of exception if a plugin calls it incorrectly. | |
b37eac91 | 183 | * |
47d2216e PS |
184 | * @package core |
185 | * @subpackage lib | |
186 | * @copyright 2008 Petr Skoda {@link http://skodak.org} | |
187 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
655bbf51 | 188 | */ |
189 | class coding_exception extends moodle_exception { | |
655bbf51 | 190 | /** |
191 | * Constructor | |
192 | * @param string $hint short description of problem | |
193 | * @param string $debuginfo detailed information how to fix problem | |
194 | */ | |
195 | function __construct($hint, $debuginfo=null) { | |
196 | parent::__construct('codingerror', 'debug', '', $hint, $debuginfo); | |
a3f7cbf6 | 197 | } |
198 | } | |
199 | ||
200 | /** | |
201 | * Exception indicating malformed parameter problem. | |
202 | * This exception is not supposed to be thrown when processing | |
203 | * user submitted data in forms. It is more suitable | |
204 | * for WS and other low level stuff. | |
47d2216e PS |
205 | * |
206 | * @package core | |
207 | * @subpackage lib | |
208 | * @copyright 2009 Petr Skoda {@link http://skodak.org} | |
209 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
a3f7cbf6 | 210 | */ |
211 | class invalid_parameter_exception extends moodle_exception { | |
212 | /** | |
213 | * Constructor | |
214 | * @param string $debuginfo some detailed information | |
215 | */ | |
216 | function __construct($debuginfo=null) { | |
217 | parent::__construct('invalidparameter', 'debug', '', null, $debuginfo); | |
655bbf51 | 218 | } |
219 | } | |
220 | ||
d07ff72d | 221 | /** |
222 | * Exception indicating malformed response problem. | |
223 | * This exception is not supposed to be thrown when processing | |
224 | * user submitted data in forms. It is more suitable | |
225 | * for WS and other low level stuff. | |
226 | */ | |
227 | class invalid_response_exception extends moodle_exception { | |
228 | /** | |
229 | * Constructor | |
230 | * @param string $debuginfo some detailed information | |
231 | */ | |
232 | function __construct($debuginfo=null) { | |
233 | parent::__construct('invalidresponse', 'debug', '', null, $debuginfo); | |
234 | } | |
235 | } | |
236 | ||
cce1b0b9 | 237 | /** |
1387fcdd | 238 | * An exception that indicates something really weird happened. For example, |
cce1b0b9 | 239 | * if you do switch ($context->contextlevel), and have one case for each |
240 | * CONTEXT_... constant. You might throw an invalid_state_exception in the | |
f630a546 | 241 | * default case, to just in case something really weird is going on, and |
8dc0ae8f | 242 | * $context->contextlevel is invalid - rather than ignoring this possibility. |
b37eac91 | 243 | * |
47d2216e PS |
244 | * @package core |
245 | * @subpackage lib | |
246 | * @copyright 2009 onwards Martin Dougiamas {@link http://moodle.com} | |
247 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
cce1b0b9 | 248 | */ |
249 | class invalid_state_exception extends moodle_exception { | |
250 | /** | |
251 | * Constructor | |
252 | * @param string $hint short description of problem | |
253 | * @param string $debuginfo optional more detailed information | |
254 | */ | |
255 | function __construct($hint, $debuginfo=null) { | |
256 | parent::__construct('invalidstatedetected', 'debug', '', $hint, $debuginfo); | |
257 | } | |
258 | } | |
259 | ||
4031f6a2 PS |
260 | /** |
261 | * An exception that indicates incorrect permissions in $CFG->dataroot | |
262 | * | |
263 | * @package core | |
264 | * @subpackage lib | |
265 | * @copyright 2010 Petr Skoda {@link http://skodak.org} | |
266 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
267 | */ | |
268 | class invalid_dataroot_permissions extends moodle_exception { | |
269 | /** | |
270 | * Constructor | |
271 | * @param string $debuginfo optional more detailed information | |
272 | */ | |
273 | function __construct($debuginfo = NULL) { | |
274 | parent::__construct('invaliddatarootpermissions', 'error', '', NULL, $debuginfo); | |
275 | } | |
276 | } | |
277 | ||
cbad562e PS |
278 | /** |
279 | * An exception that indicates that file can not be served | |
280 | * | |
281 | * @package core | |
282 | * @subpackage lib | |
283 | * @copyright 2010 Petr Skoda {@link http://skodak.org} | |
284 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
285 | */ | |
286 | class file_serving_exception extends moodle_exception { | |
287 | /** | |
288 | * Constructor | |
289 | * @param string $debuginfo optional more detailed information | |
290 | */ | |
291 | function __construct($debuginfo = NULL) { | |
292 | parent::__construct('cannotservefile', 'error', '', NULL, $debuginfo); | |
293 | } | |
294 | } | |
295 | ||
251387d0 | 296 | /** |
1387fcdd | 297 | * Default exception handler, uncaught exceptions are equivalent to error() in 1.9 and earlier |
fd1a792e | 298 | * |
30fa50d0 | 299 | * @param Exception $ex |
c19bc39c | 300 | * @return void -does not return. Terminates execution! |
251387d0 | 301 | */ |
c19bc39c | 302 | function default_exception_handler($ex) { |
d9e07264 | 303 | global $CFG, $DB, $OUTPUT, $USER, $FULLME, $SESSION; |
1fbdf76d | 304 | |
305 | // detect active db transactions, rollback and log as error | |
695c5ec4 | 306 | abort_all_db_transactions(); |
1fe1d104 | 307 | |
d9e07264 SH |
308 | if (($ex instanceof required_capability_exception) && !CLI_SCRIPT && !AJAX_SCRIPT && !empty($CFG->autologinguests) && !empty($USER->autologinguest)) { |
309 | $SESSION->wantsurl = $FULLME; | |
310 | redirect(get_login_url()); | |
311 | } | |
312 | ||
c19bc39c | 313 | $info = get_exception_info($ex); |
34a2777c | 314 | |
c19bc39c | 315 | if (debugging('', DEBUG_MINIMAL)) { |
2e9b772f | 316 | $logerrmsg = "Default exception handler: ".$info->message.' Debug: '.$info->debuginfo."\n".format_backtrace($info->backtrace, true); |
695c5ec4 | 317 | error_log($logerrmsg); |
fd1a792e | 318 | } |
319 | ||
c19bc39c PS |
320 | if (is_early_init($info->backtrace)) { |
321 | echo bootstrap_renderer::early_error($info->message, $info->moreinfourl, $info->link, $info->backtrace, $info->debuginfo); | |
b7009474 | 322 | } else { |
3c1ea58b | 323 | try { |
a56c457e PS |
324 | if ($DB) { |
325 | // If you enable db debugging and exception is thrown, the print footer prints a lot of rubbish | |
326 | $DB->set_debug(0); | |
327 | } | |
3c1ea58b PS |
328 | echo $OUTPUT->fatal_error($info->message, $info->moreinfourl, $info->link, $info->backtrace, $info->debuginfo); |
329 | } catch (Exception $out_ex) { | |
330 | // default exception handler MUST not throw any exceptions!! | |
2e9b772f | 331 | // the problem here is we do not know if page already started or not, we only know that somebody messed up in outputlib or theme |
3c1ea58b | 332 | // so we just print at least something instead of "Exception thrown without a stack frame in Unknown on line 0":-( |
1adaa404 PS |
333 | if (CLI_SCRIPT or AJAX_SCRIPT) { |
334 | // just ignore the error and send something back using the safest method | |
335 | echo bootstrap_renderer::early_error($info->message, $info->moreinfourl, $info->link, $info->backtrace, $info->debuginfo); | |
336 | } else { | |
337 | echo bootstrap_renderer::early_error_content($info->message, $info->moreinfourl, $info->link, $info->backtrace, $info->debuginfo); | |
338 | $outinfo = get_exception_info($out_ex); | |
339 | echo bootstrap_renderer::early_error_content($outinfo->message, $outinfo->moreinfourl, $outinfo->link, $outinfo->backtrace, $outinfo->debuginfo); | |
340 | } | |
3c1ea58b | 341 | } |
7544d13c | 342 | } |
343 | ||
34a2777c | 344 | exit(1); // General error code |
345 | } | |
346 | ||
85ba1e78 PS |
347 | /** |
348 | * Default error handler, prevents some white screens. | |
349 | * @param int $errno | |
350 | * @param string $errstr | |
351 | * @param string $errfile | |
352 | * @param int $errline | |
353 | * @param array $errcontext | |
354 | * @return bool false means use default error handler | |
355 | */ | |
356 | function default_error_handler($errno, $errstr, $errfile, $errline, $errcontext) { | |
357 | if ($errno == 4096) { | |
358 | //fatal catchable error | |
359 | throw new coding_exception('PHP catchable fatal error', $errstr); | |
360 | } | |
361 | return false; | |
362 | } | |
363 | ||
695c5ec4 PS |
364 | /** |
365 | * Unconditionally abort all database transactions, this function | |
366 | * should be called from exception handlers only. | |
367 | * @return void | |
368 | */ | |
369 | function abort_all_db_transactions() { | |
370 | global $CFG, $DB, $SCRIPT; | |
371 | ||
d5a8d9aa | 372 | // default exception handler MUST not throw any exceptions!! |
03221650 | 373 | |
695c5ec4 PS |
374 | if ($DB && $DB->is_transaction_started()) { |
375 | error_log('Database transaction aborted automatically in ' . $CFG->dirroot . $SCRIPT); | |
d5a8d9aa PS |
376 | // note: transaction blocks should never change current $_SESSION |
377 | $DB->force_transaction_rollback(); | |
695c5ec4 PS |
378 | } |
379 | } | |
380 | ||
b7009474 | 381 | /** |
50764d37 PS |
382 | * This function encapsulates the tests for whether an exception was thrown in |
383 | * early init -- either during setup.php or during init of $OUTPUT. | |
b7009474 | 384 | * |
385 | * If another exception is thrown then, and if we do not take special measures, | |
386 | * we would just get a very cryptic message "Exception thrown without a stack | |
387 | * frame in Unknown on line 0". That makes debugging very hard, so we do take | |
388 | * special measures in default_exception_handler, with the help of this function. | |
389 | * | |
390 | * @param array $backtrace the stack trace to analyse. | |
391 | * @return boolean whether the stack trace is somewhere in output initialisation. | |
392 | */ | |
50764d37 | 393 | function is_early_init($backtrace) { |
b7009474 | 394 | $dangerouscode = array( |
395 | array('function' => 'header', 'type' => '->'), | |
396 | array('class' => 'bootstrap_renderer'), | |
50764d37 | 397 | array('file' => dirname(__FILE__).'/setup.php'), |
b7009474 | 398 | ); |
399 | foreach ($backtrace as $stackframe) { | |
400 | foreach ($dangerouscode as $pattern) { | |
401 | $matches = true; | |
402 | foreach ($pattern as $property => $value) { | |
403 | if (!isset($stackframe[$property]) || $stackframe[$property] != $value) { | |
404 | $matches = false; | |
405 | } | |
406 | } | |
407 | if ($matches) { | |
408 | return true; | |
409 | } | |
410 | } | |
411 | } | |
412 | return false; | |
413 | } | |
414 | ||
34a2777c | 415 | /** |
cbf05caa PS |
416 | * Abort execution by throwing of a general exception, |
417 | * default exception handler displays the error message in most cases. | |
34a2777c | 418 | * |
419 | * @param string $errorcode The name of the language string containing the error message. | |
420 | * Normally this should be in the error.php lang file. | |
421 | * @param string $module The language file to get the error message from. | |
422 | * @param string $link The url where the user will be prompted to continue. | |
423 | * If no url is provided the user will be directed to the site index page. | |
424 | * @param object $a Extra words and phrases that might be required in the error string | |
cbf05caa PS |
425 | * @param string $debuginfo optional debugging information |
426 | * @return void, always throws exception! | |
34a2777c | 427 | */ |
cbf05caa PS |
428 | function print_error($errorcode, $module = 'error', $link = '', $a = null, $debuginfo = null) { |
429 | throw new moodle_exception($errorcode, $module, $link, $a, $debuginfo); | |
34a2777c | 430 | } |
431 | ||
432 | /** | |
c19bc39c PS |
433 | * Returns detailed information about specified exception. |
434 | * @param exception $ex | |
435 | * @return object | |
34a2777c | 436 | */ |
c19bc39c | 437 | function get_exception_info($ex) { |
34a2777c | 438 | global $CFG, $DB, $SESSION; |
439 | ||
c19bc39c PS |
440 | if ($ex instanceof moodle_exception) { |
441 | $errorcode = $ex->errorcode; | |
442 | $module = $ex->module; | |
443 | $a = $ex->a; | |
444 | $link = $ex->link; | |
445 | $debuginfo = $ex->debuginfo; | |
446 | } else { | |
447 | $errorcode = 'generalexceptionmessage'; | |
448 | $module = 'error'; | |
449 | $a = $ex->getMessage(); | |
450 | $link = ''; | |
451 | $debuginfo = null; | |
34a2777c | 452 | } |
453 | ||
c19bc39c PS |
454 | $backtrace = $ex->getTrace(); |
455 | $place = array('file'=>$ex->getFile(), 'line'=>$ex->getLine(), 'exception'=>get_class($ex)); | |
456 | array_unshift($backtrace, $place); | |
457 | ||
c84a2dbe | 458 | // Be careful, no guarantee moodlelib.php is loaded. |
34a2777c | 459 | if (empty($module) || $module == 'moodle' || $module == 'core') { |
460 | $module = 'error'; | |
461 | } | |
4f6be42c DM |
462 | if (function_exists('get_string_manager')) { |
463 | if (get_string_manager()->string_exists($errorcode, $module)) { | |
464 | $message = get_string($errorcode, $module, $a); | |
465 | } elseif ($module == 'error' && get_string_manager()->string_exists($errorcode, 'moodle')) { | |
c84a2dbe | 466 | // Search in moodle file if error specified - needed for backwards compatibility |
467 | $message = get_string($errorcode, 'moodle', $a); | |
4f6be42c DM |
468 | } else { |
469 | $message = $module . '/' . $errorcode; | |
c84a2dbe | 470 | } |
471 | } else { | |
472 | $message = $module . '/' . $errorcode; | |
473 | } | |
474 | ||
475 | // Be careful, no guarantee weblib.php is loaded. | |
476 | if (function_exists('clean_text')) { | |
477 | $message = clean_text($message); | |
478 | } else { | |
479 | $message = htmlspecialchars($message); | |
34a2777c | 480 | } |
34a2777c | 481 | |
482 | if (!empty($CFG->errordocroot)) { | |
eea3341d | 483 | $errordoclink = $CFG->errordocroot . '/en/'; |
34a2777c | 484 | } else { |
eea3341d | 485 | $errordoclink = get_docs_url(); |
34a2777c | 486 | } |
eea3341d | 487 | |
34a2777c | 488 | if ($module === 'error') { |
489 | $modulelink = 'moodle'; | |
0ae8f5fc | 490 | } else { |
34a2777c | 491 | $modulelink = $module; |
251387d0 | 492 | } |
eea3341d | 493 | $moreinfourl = $errordoclink . 'error/' . $modulelink . '/' . $errorcode; |
34a2777c | 494 | |
d4a03c00 | 495 | if (empty($link)) { |
34a2777c | 496 | if (!empty($SESSION->fromurl)) { |
497 | $link = $SESSION->fromurl; | |
498 | unset($SESSION->fromurl); | |
499 | } else { | |
500 | $link = $CFG->wwwroot .'/'; | |
501 | } | |
502 | } | |
503 | ||
c8d3345c PS |
504 | // when printing an error the continue button should never link offsite |
505 | if (stripos($link, $CFG->wwwroot) === false && | |
506 | stripos($link, $CFG->httpswwwroot) === false) { | |
507 | $link = $CFG->wwwroot.'/'; | |
508 | } | |
509 | ||
365a5941 | 510 | $info = new stdClass(); |
c19bc39c PS |
511 | $info->message = $message; |
512 | $info->errorcode = $errorcode; | |
513 | $info->backtrace = $backtrace; | |
514 | $info->link = $link; | |
515 | $info->moreinfourl = $moreinfourl; | |
516 | $info->a = $a; | |
517 | $info->debuginfo = $debuginfo; | |
30fa50d0 | 518 | |
c19bc39c | 519 | return $info; |
34a2777c | 520 | } |
521 | ||
eea3341d AB |
522 | /** |
523 | * Returns the Moodle Docs URL in the users language | |
524 | * | |
525 | * @global object | |
526 | * @param string $path the end of the URL. | |
527 | * @return string The MoodleDocs URL in the user's language. for example {@link http://docs.moodle.org/en/ http://docs.moodle.org/en/$path} | |
528 | */ | |
529 | function get_docs_url($path=null) { | |
530 | global $CFG; | |
531 | // Check that $CFG->release has been set up, during installation it won't be. | |
532 | if (empty($CFG->release)) { | |
533 | // It's not there yet so look at version.php | |
534 | include($CFG->dirroot.'/version.php'); | |
535 | } else { | |
536 | // We can use $CFG->release and avoid having to include version.php | |
537 | $release = $CFG->release; | |
538 | } | |
539 | // Attempt to match the branch from the release | |
540 | if (preg_match('/^(.)\.(.)/', $release, $matches)) { | |
541 | // We should ALWAYS get here | |
542 | $branch = $matches[1].$matches[2]; | |
543 | } else { | |
544 | // We should never get here but in case we do lets set $branch to . | |
545 | // the smart one's will know that this is the current directory | |
546 | // and the smarter ones will know that there is some smart matching | |
547 | // that will ensure people end up at the latest version of the docs. | |
548 | $branch = '.'; | |
549 | } | |
550 | if (!empty($CFG->docroot)) { | |
551 | return $CFG->docroot . '/' . $branch . '/' . current_language() . '/' . $path; | |
552 | } else { | |
553 | return 'http://docs.moodle.org/'. $branch . '/en/' . $path; | |
554 | } | |
555 | } | |
556 | ||
34a2777c | 557 | /** |
558 | * Formats a backtrace ready for output. | |
559 | * | |
560 | * @param array $callers backtrace array, as returned by debug_backtrace(). | |
561 | * @param boolean $plaintext if false, generates HTML, if true generates plain text. | |
562 | * @return string formatted backtrace, ready for output. | |
563 | */ | |
564 | function format_backtrace($callers, $plaintext = false) { | |
a0394be4 | 565 | // do not use $CFG->dirroot because it might not be available in destructors |
34a2777c | 566 | $dirroot = dirname(dirname(__FILE__)); |
30fa50d0 | 567 | |
34a2777c | 568 | if (empty($callers)) { |
569 | return ''; | |
570 | } | |
571 | ||
572 | $from = $plaintext ? '' : '<ul style="text-align: left">'; | |
573 | foreach ($callers as $caller) { | |
574 | if (!isset($caller['line'])) { | |
575 | $caller['line'] = '?'; // probably call_user_func() | |
576 | } | |
577 | if (!isset($caller['file'])) { | |
578 | $caller['file'] = 'unknownfile'; // probably call_user_func() | |
579 | } | |
580 | $from .= $plaintext ? '* ' : '<li>'; | |
581 | $from .= 'line ' . $caller['line'] . ' of ' . str_replace($dirroot, '', $caller['file']); | |
582 | if (isset($caller['function'])) { | |
583 | $from .= ': call to '; | |
584 | if (isset($caller['class'])) { | |
585 | $from .= $caller['class'] . $caller['type']; | |
586 | } | |
587 | $from .= $caller['function'] . '()'; | |
588 | } else if (isset($caller['exception'])) { | |
589 | $from .= ': '.$caller['exception'].' thrown'; | |
590 | } | |
591 | $from .= $plaintext ? "\n" : '</li>'; | |
592 | } | |
593 | $from .= $plaintext ? '' : '</ul>'; | |
594 | ||
595 | return $from; | |
251387d0 | 596 | } |
6a525ce2 | 597 | |
cbad562e PS |
598 | /** |
599 | * This function makes the return value of ini_get consistent if you are | |
600 | * setting server directives through the .htaccess file in apache. | |
601 | * | |
602 | * Current behavior for value set from php.ini On = 1, Off = [blank] | |
603 | * Current behavior for value set from .htaccess On = On, Off = Off | |
604 | * Contributed by jdell @ unr.edu | |
605 | * | |
606 | * @param string $ini_get_arg The argument to get | |
607 | * @return bool True for on false for not | |
608 | */ | |
609 | function ini_get_bool($ini_get_arg) { | |
610 | $temp = ini_get($ini_get_arg); | |
611 | ||
612 | if ($temp == '1' or strtolower($temp) == 'on') { | |
613 | return true; | |
614 | } | |
615 | return false; | |
616 | } | |
617 | ||
fbf2c91e | 618 | /** |
619 | * This function verifies the sanity of PHP configuration | |
620 | * and stops execution if anything critical found. | |
621 | */ | |
622 | function setup_validate_php_configuration() { | |
623 | // this must be very fast - no slow checks here!!! | |
624 | ||
625 | if (ini_get_bool('register_globals')) { | |
626 | print_error('globalswarning', 'admin'); | |
627 | } | |
628 | if (ini_get_bool('session.auto_start')) { | |
629 | print_error('sessionautostartwarning', 'admin'); | |
630 | } | |
631 | if (ini_get_bool('magic_quotes_runtime')) { | |
632 | print_error('fatalmagicquotesruntime', 'admin'); | |
633 | } | |
634 | } | |
635 | ||
12bb0c3e PS |
636 | /** |
637 | * Initialise global $CFG variable | |
638 | * @return void | |
639 | */ | |
640 | function initialise_cfg() { | |
641 | global $CFG, $DB; | |
8b8aa060 | 642 | |
12bb0c3e PS |
643 | try { |
644 | if ($DB) { | |
645 | $localcfg = $DB->get_records_menu('config', array(), '', 'name,value'); | |
646 | foreach ($localcfg as $name=>$value) { | |
647 | if (property_exists($CFG, $name)) { | |
648 | // config.php settings always take precedence | |
649 | continue; | |
650 | } | |
651 | $CFG->{$name} = $value; | |
652 | } | |
653 | } | |
654 | } catch (dml_read_exception $e) { | |
655 | // most probably empty db, going to install soon | |
656 | } | |
657 | } | |
658 | ||
11e7b506 | 659 | /** |
75781f87 | 660 | * Initialises $FULLME and friends. Private function. Should only be called from |
661 | * setup.php. | |
11e7b506 | 662 | */ |
663 | function initialise_fullme() { | |
664 | global $CFG, $FULLME, $ME, $SCRIPT, $FULLSCRIPT; | |
665 | ||
75781f87 | 666 | // Detect common config error. |
84b88cfd | 667 | if (substr($CFG->wwwroot, -1) == '/') { |
668 | print_error('wwwrootslash', 'error'); | |
669 | } | |
670 | ||
75781f87 | 671 | if (CLI_SCRIPT) { |
672 | initialise_fullme_cli(); | |
673 | return; | |
37ccf1fe | 674 | } |
11e7b506 | 675 | |
75781f87 | 676 | $wwwroot = parse_url($CFG->wwwroot); |
677 | if (!isset($wwwroot['path'])) { | |
678 | $wwwroot['path'] = ''; | |
679 | } | |
680 | $wwwroot['path'] .= '/'; | |
681 | ||
682 | $rurl = setup_get_remote_url(); | |
11e7b506 | 683 | |
75781f87 | 684 | // Check that URL is under $CFG->wwwroot. |
685 | if (strpos($rurl['path'], $wwwroot['path']) === 0) { | |
686 | $SCRIPT = substr($rurl['path'], strlen($wwwroot['path'])-1); | |
687 | } else { | |
688 | // Probably some weird external script | |
689 | $SCRIPT = $FULLSCRIPT = $FULLME = $ME = null; | |
11e7b506 | 690 | return; |
691 | } | |
692 | ||
75781f87 | 693 | // $CFG->sslproxy specifies if external SSL appliance is used |
694 | // (That is, the Moodle server uses http, with an external box translating everything to https). | |
695 | if (empty($CFG->sslproxy)) { | |
56048f83 | 696 | if ($rurl['scheme'] === 'http' and $wwwroot['scheme'] === 'https') { |
75781f87 | 697 | print_error('sslonlyaccess', 'error'); |
698 | } | |
56048f83 PS |
699 | } else { |
700 | if ($wwwroot['scheme'] !== 'https') { | |
701 | throw new coding_exception('Must use https address in wwwroot when ssl proxy enabled!'); | |
702 | } | |
74162134 | 703 | $rurl['scheme'] = 'https'; // make moodle believe it runs on https, squid or something else it doing it |
75781f87 | 704 | } |
705 | ||
706 | // $CFG->reverseproxy specifies if reverse proxy server used. | |
707 | // Used in load balancing scenarios. | |
708 | // Do not abuse this to try to solve lan/wan access problems!!!!! | |
709 | if (empty($CFG->reverseproxy)) { | |
e0f2718f PS |
710 | if (empty($rurl['host'])) { |
711 | // missing host in request header, probably not a real browser, let's ignore them | |
712 | } else if (($rurl['host'] !== $wwwroot['host']) or | |
75781f87 | 713 | (!empty($wwwroot['port']) and $rurl['port'] != $wwwroot['port'])) { |
68a45361 | 714 | // Explain the problem and redirect them to the right URL |
df92ba9a PS |
715 | if (!defined('NO_MOODLE_COOKIES')) { |
716 | define('NO_MOODLE_COOKIES', true); | |
717 | } | |
68a45361 | 718 | redirect($CFG->wwwroot, get_string('wwwrootmismatch', 'error', $CFG->wwwroot), 3); |
75781f87 | 719 | } |
720 | } | |
721 | ||
722 | // hopefully this will stop all those "clever" admins trying to set up moodle | |
723 | // with two different addresses in intranet and Internet | |
e0f2718f | 724 | if (!empty($CFG->reverseproxy) && $rurl['host'] === $wwwroot['host']) { |
75781f87 | 725 | print_error('reverseproxyabused', 'error'); |
726 | } | |
727 | ||
728 | $hostandport = $rurl['scheme'] . '://' . $wwwroot['host']; | |
729 | if (!empty($wwwroot['port'])) { | |
730 | $hostandport .= ':'.$wwwroot['port']; | |
731 | } | |
732 | ||
733 | $FULLSCRIPT = $hostandport . $rurl['path']; | |
734 | $FULLME = $hostandport . $rurl['fullpath']; | |
735 | $ME = $rurl['fullpath']; | |
75781f87 | 736 | } |
737 | ||
738 | /** | |
739 | * Initialises $FULLME and friends for command line scripts. | |
740 | * This is a private method for use by initialise_fullme. | |
741 | */ | |
742 | function initialise_fullme_cli() { | |
80e30f25 | 743 | global $CFG, $FULLME, $ME, $SCRIPT, $FULLSCRIPT; |
744 | ||
75781f87 | 745 | // Urls do not make much sense in CLI scripts |
746 | $backtrace = debug_backtrace(); | |
747 | $topfile = array_pop($backtrace); | |
748 | $topfile = realpath($topfile['file']); | |
749 | $dirroot = realpath($CFG->dirroot); | |
750 | ||
751 | if (strpos($topfile, $dirroot) !== 0) { | |
752 | // Probably some weird external script | |
753 | $SCRIPT = $FULLSCRIPT = $FULLME = $ME = null; | |
754 | } else { | |
755 | $relativefile = substr($topfile, strlen($dirroot)); | |
756 | $relativefile = str_replace('\\', '/', $relativefile); // Win fix | |
757 | $SCRIPT = $FULLSCRIPT = $relativefile; | |
758 | $FULLME = $ME = null; | |
759 | } | |
760 | } | |
761 | ||
762 | /** | |
763 | * Get the URL that PHP/the web server thinks it is serving. Private function | |
764 | * used by initialise_fullme. In your code, use $PAGE->url, $SCRIPT, etc. | |
765 | * @return array in the same format that parse_url returns, with the addition of | |
766 | * a 'fullpath' element, which includes any slasharguments path. | |
767 | */ | |
768 | function setup_get_remote_url() { | |
11e7b506 | 769 | $rurl = array(); |
e0f2718f PS |
770 | if (isset($_SERVER['HTTP_HOST'])) { |
771 | list($rurl['host']) = explode(':', $_SERVER['HTTP_HOST']); | |
772 | } else { | |
773 | $rurl['host'] = null; | |
774 | } | |
11e7b506 | 775 | $rurl['port'] = $_SERVER['SERVER_PORT']; |
75781f87 | 776 | $rurl['path'] = $_SERVER['SCRIPT_NAME']; // Script path without slash arguments |
2a9c0d05 | 777 | $rurl['scheme'] = (empty($_SERVER['HTTPS']) or $_SERVER['HTTPS'] === 'off' or $_SERVER['HTTPS'] === 'Off' or $_SERVER['HTTPS'] === 'OFF') ? 'http' : 'https'; |
11e7b506 | 778 | |
779 | if (stripos($_SERVER['SERVER_SOFTWARE'], 'apache') !== false) { | |
780 | //Apache server | |
f49b359b | 781 | $rurl['fullpath'] = $_SERVER['REQUEST_URI']; |
7e13a265 | 782 | |
11e7b506 | 783 | } else if (stripos($_SERVER['SERVER_SOFTWARE'], 'iis') !== false) { |
199c1981 | 784 | //IIS - needs a lot of tweaking to make it work |
11e7b506 | 785 | $rurl['fullpath'] = $_SERVER['SCRIPT_NAME']; |
786 | ||
787 | // NOTE: ignore PATH_INFO because it is incorrectly encoded using 8bit filesystem legacy encoding in IIS | |
788 | // since 2.0 we rely on iis rewrite extenssion like Helicon ISAPI_rewrite | |
21517960 | 789 | // example rule: RewriteRule ^([^\?]+?\.php)(\/.+)$ $1\?file=$2 [QSA] |
11e7b506 | 790 | |
791 | if ($_SERVER['QUERY_STRING'] != '') { | |
991ec2ee | 792 | $rurl['fullpath'] .= '?'.$_SERVER['QUERY_STRING']; |
11e7b506 | 793 | } |
794 | $_SERVER['REQUEST_URI'] = $rurl['fullpath']; // extra IIS compatibility | |
795 | ||
f49b359b PS |
796 | /* NOTE: following servers are not fully tested! */ |
797 | ||
798 | } else if (stripos($_SERVER['SERVER_SOFTWARE'], 'lighttpd') !== false) { | |
799 | //lighttpd - not officially supported | |
f49b359b PS |
800 | $rurl['fullpath'] = $_SERVER['REQUEST_URI']; // TODO: verify this is always properly encoded |
801 | ||
802 | } else if (stripos($_SERVER['SERVER_SOFTWARE'], 'nginx') !== false) { | |
803 | //nginx - not officially supported | |
28ec73dc PS |
804 | if (!isset($_SERVER['SCRIPT_NAME'])) { |
805 | die('Invalid server configuration detected, please try to add "fastcgi_param SCRIPT_NAME $fastcgi_script_name;" to the nginx server configuration.'); | |
806 | } | |
f49b359b PS |
807 | $rurl['fullpath'] = $_SERVER['REQUEST_URI']; // TODO: verify this is always properly encoded |
808 | ||
199c1981 PS |
809 | } else if (stripos($_SERVER['SERVER_SOFTWARE'], 'cherokee') !== false) { |
810 | //cherokee - not officially supported | |
199c1981 PS |
811 | $rurl['fullpath'] = $_SERVER['REQUEST_URI']; // TODO: verify this is always properly encoded |
812 | ||
8b8aa060 PS |
813 | } else if (stripos($_SERVER['SERVER_SOFTWARE'], 'zeus') !== false) { |
814 | //zeus - not officially supported | |
8b8aa060 PS |
815 | $rurl['fullpath'] = $_SERVER['REQUEST_URI']; // TODO: verify this is always properly encoded |
816 | ||
f49b359b PS |
817 | } else if (stripos($_SERVER['SERVER_SOFTWARE'], 'LiteSpeed') !== false) { |
818 | //LiteSpeed - not officially supported | |
f49b359b PS |
819 | $rurl['fullpath'] = $_SERVER['REQUEST_URI']; // TODO: verify this is always properly encoded |
820 | ||
4e3e8464 PS |
821 | } else if ($_SERVER['SERVER_SOFTWARE'] === 'HTTPD') { |
822 | //obscure name found on some servers - this is definitely not supported | |
823 | $rurl['fullpath'] = $_SERVER['REQUEST_URI']; // TODO: verify this is always properly encoded | |
824 | ||
8b8aa060 | 825 | } else { |
75781f87 | 826 | throw new moodle_exception('unsupportedwebserver', 'error', '', $_SERVER['SERVER_SOFTWARE']); |
11e7b506 | 827 | } |
0ae36f66 PS |
828 | |
829 | // sanitize the url a bit more, the encoding style may be different in vars above | |
830 | $rurl['fullpath'] = str_replace('"', '%22', $rurl['fullpath']); | |
831 | $rurl['fullpath'] = str_replace('\'', '%27', $rurl['fullpath']); | |
832 | ||
75781f87 | 833 | return $rurl; |
11e7b506 | 834 | } |
835 | ||
d3f9f1f8 | 836 | /** |
837 | * Initializes our performance info early. | |
838 | * | |
839 | * Pairs up with get_performance_info() which is actually | |
251387d0 | 840 | * in moodlelib.php. This function is here so that we can |
841 | * call it before all the libs are pulled in. | |
d3f9f1f8 | 842 | * |
843 | * @uses $PERF | |
844 | */ | |
845 | function init_performance_info() { | |
846 | ||
6fc4ad72 | 847 | global $PERF, $CFG, $USER; |
251387d0 | 848 | |
365a5941 | 849 | $PERF = new stdClass(); |
d3f9f1f8 | 850 | $PERF->logwrites = 0; |
851 | if (function_exists('microtime')) { | |
852 | $PERF->starttime = microtime(); | |
c84a2dbe | 853 | } |
d3f9f1f8 | 854 | if (function_exists('memory_get_usage')) { |
855 | $PERF->startmemory = memory_get_usage(); | |
856 | } | |
857 | if (function_exists('posix_times')) { | |
251387d0 | 858 | $PERF->startposixtimes = posix_times(); |
d3f9f1f8 | 859 | } |
b65567f4 | 860 | if (function_exists('apd_set_pprof_trace')) { |
861 | // APD profiling | |
6fc4ad72 | 862 | if ($USER->id > 0 && $CFG->perfdebug >= 15) { |
7aa06e6d | 863 | $tempdir = $CFG->tempdir . '/profile/' . $USER->id; |
6fc4ad72 | 864 | mkdir($tempdir); |
865 | apd_set_pprof_trace($tempdir); | |
866 | $PERF->profiling = true; | |
867 | } | |
b65567f4 | 868 | } |
d3f9f1f8 | 869 | } |
870 | ||
31a99877 | 871 | /** |
872 | * Indicates whether we are in the middle of the initial Moodle install. | |
873 | * | |
874 | * Very occasionally it is necessary avoid running certain bits of code before the | |
875 | * Moodle installation has completed. The installed flag is set in admin/index.php | |
876 | * after Moodle core and all the plugins have been installed, but just before | |
877 | * the person doing the initial install is asked to choose the admin password. | |
878 | * | |
879 | * @return boolean true if the initial install is not complete. | |
880 | */ | |
881 | function during_initial_install() { | |
882 | global $CFG; | |
883 | return empty($CFG->rolesactive); | |
884 | } | |
885 | ||
76f3815b | 886 | /** |
887 | * Function to raise the memory limit to a new value. | |
888 | * Will respect the memory limit if it is higher, thus allowing | |
889 | * settings in php.ini, apache conf or command line switches | |
0f0f0768 | 890 | * to override it. |
76f3815b | 891 | * |
0f0f0768 PS |
892 | * The memory limit should be expressed with a constant |
893 | * MEMORY_STANDARD, MEMORY_EXTRA or MEMORY_HUGE. | |
894 | * It is possible to use strings or integers too (eg:'128M'). | |
76f3815b | 895 | * |
0f0f0768 PS |
896 | * @param mixed $newlimit the new memory limit |
897 | * @return bool success | |
76f3815b | 898 | */ |
11e7b506 | 899 | function raise_memory_limit($newlimit) { |
0f0f0768 | 900 | global $CFG; |
76f3815b | 901 | |
0f0f0768 PS |
902 | if ($newlimit == MEMORY_UNLIMITED) { |
903 | ini_set('memory_limit', -1); | |
904 | return true; | |
905 | ||
906 | } else if ($newlimit == MEMORY_STANDARD) { | |
cd3059b1 PS |
907 | if (PHP_INT_SIZE > 4) { |
908 | $newlimit = get_real_size('128M'); // 64bit needs more memory | |
909 | } else { | |
910 | $newlimit = get_real_size('96M'); | |
911 | } | |
0f0f0768 PS |
912 | |
913 | } else if ($newlimit == MEMORY_EXTRA) { | |
cd3059b1 PS |
914 | if (PHP_INT_SIZE > 4) { |
915 | $newlimit = get_real_size('384M'); // 64bit needs more memory | |
916 | } else { | |
917 | $newlimit = get_real_size('256M'); | |
918 | } | |
d827f7b8 | 919 | if (!empty($CFG->extramemorylimit)) { |
0f0f0768 PS |
920 | $extra = get_real_size($CFG->extramemorylimit); |
921 | if ($extra > $newlimit) { | |
922 | $newlimit = $extra; | |
923 | } | |
924 | } | |
925 | ||
926 | } else if ($newlimit == MEMORY_HUGE) { | |
927 | $newlimit = get_real_size('2G'); | |
928 | ||
929 | } else { | |
930 | $newlimit = get_real_size($newlimit); | |
931 | } | |
932 | ||
933 | if ($newlimit <= 0) { | |
934 | debugging('Invalid memory limit specified.'); | |
76f3815b | 935 | return false; |
936 | } | |
937 | ||
cbad562e | 938 | $cur = ini_get('memory_limit'); |
76f3815b | 939 | if (empty($cur)) { |
940 | // if php is compiled without --enable-memory-limits | |
941 | // apparently memory_limit is set to '' | |
0f0f0768 | 942 | $cur = 0; |
76f3815b | 943 | } else { |
944 | if ($cur == -1){ | |
945 | return true; // unlimited mem! | |
946 | } | |
0f0f0768 | 947 | $cur = get_real_size($cur); |
76f3815b | 948 | } |
949 | ||
0f0f0768 | 950 | if ($newlimit > $cur) { |
76f3815b | 951 | ini_set('memory_limit', $newlimit); |
7022dd39 | 952 | return true; |
953 | } | |
954 | return false; | |
955 | } | |
956 | ||
957 | /** | |
958 | * Function to reduce the memory limit to a new value. | |
959 | * Will respect the memory limit if it is lower, thus allowing | |
960 | * settings in php.ini, apache conf or command line switches | |
961 | * to override it | |
962 | * | |
963 | * The memory limit should be expressed with a string (eg:'64M') | |
964 | * | |
965 | * @param string $newlimit the new memory limit | |
966 | * @return bool | |
967 | */ | |
f630a546 | 968 | function reduce_memory_limit($newlimit) { |
7022dd39 | 969 | if (empty($newlimit)) { |
970 | return false; | |
971 | } | |
cbad562e | 972 | $cur = ini_get('memory_limit'); |
7022dd39 | 973 | if (empty($cur)) { |
974 | // if php is compiled without --enable-memory-limits | |
975 | // apparently memory_limit is set to '' | |
0f0f0768 | 976 | $cur = 0; |
7022dd39 | 977 | } else { |
978 | if ($cur == -1){ | |
979 | return true; // unlimited mem! | |
980 | } | |
981 | $cur = get_real_size($cur); | |
982 | } | |
983 | ||
984 | $new = get_real_size($newlimit); | |
985 | // -1 is smaller, but it means unlimited | |
986 | if ($new < $cur && $new != -1) { | |
987 | ini_set('memory_limit', $newlimit); | |
76f3815b | 988 | return true; |
989 | } | |
990 | return false; | |
991 | } | |
992 | ||
993 | /** | |
994 | * Converts numbers like 10M into bytes. | |
995 | * | |
0f0f0768 PS |
996 | * @param string $size The size to be converted |
997 | * @return int | |
76f3815b | 998 | */ |
0f0f0768 | 999 | function get_real_size($size = 0) { |
76f3815b | 1000 | if (!$size) { |
1001 | return 0; | |
1002 | } | |
11e7b506 | 1003 | $scan = array(); |
0f0f0768 PS |
1004 | $scan['GB'] = 1073741824; |
1005 | $scan['Gb'] = 1073741824; | |
1006 | $scan['G'] = 1073741824; | |
76f3815b | 1007 | $scan['MB'] = 1048576; |
1008 | $scan['Mb'] = 1048576; | |
1009 | $scan['M'] = 1048576; | |
1010 | $scan['m'] = 1048576; | |
1011 | $scan['KB'] = 1024; | |
1012 | $scan['Kb'] = 1024; | |
1013 | $scan['K'] = 1024; | |
1014 | $scan['k'] = 1024; | |
1015 | ||
1016 | while (list($key) = each($scan)) { | |
1017 | if ((strlen($size)>strlen($key))&&(substr($size, strlen($size) - strlen($key))==$key)) { | |
1018 | $size = substr($size, 0, strlen($size) - strlen($key)) * $scan[$key]; | |
1019 | break; | |
1020 | } | |
1021 | } | |
1022 | return $size; | |
1023 | } | |
1024 | ||
cbad562e | 1025 | /** |
871ed458 PS |
1026 | * Try to disable all output buffering and purge |
1027 | * all headers. | |
1028 | * | |
cbad562e PS |
1029 | * @private to be called only from lib/setup.php ! |
1030 | * @return void | |
1031 | */ | |
1032 | function disable_output_buffering() { | |
1033 | $olddebug = error_reporting(0); | |
1034 | ||
1035 | // disable compression, it would prevent closing of buffers | |
1036 | if (ini_get_bool('zlib.output_compression')) { | |
1037 | ini_set('zlib.output_compression', 'Off'); | |
1038 | } | |
1039 | ||
1040 | // try to flush everything all the time | |
1041 | ob_implicit_flush(true); | |
1042 | ||
1043 | // close all buffers if possible and discard any existing output | |
1044 | // this can actually work around some whitespace problems in config.php | |
1045 | while(ob_get_level()) { | |
1046 | if (!ob_end_clean()) { | |
1047 | // prevent infinite loop when buffer can not be closed | |
1048 | break; | |
1049 | } | |
1050 | } | |
1051 | ||
1052 | error_reporting($olddebug); | |
1053 | } | |
1054 | ||
5e39d7aa | 1055 | /** |
1056 | * Check whether a major upgrade is needed. That is defined as an upgrade that | |
1057 | * changes something really fundamental in the database, so nothing can possibly | |
1058 | * work until the database has been updated, and that is defined by the hard-coded | |
1059 | * version number in this function. | |
1060 | */ | |
1061 | function redirect_if_major_upgrade_required() { | |
1062 | global $CFG; | |
2c0b6ab2 | 1063 | $lastmajordbchanges = 2010111700; |
5e39d7aa | 1064 | if (empty($CFG->version) or (int)$CFG->version < $lastmajordbchanges or |
1065 | during_initial_install() or !empty($CFG->adminsetuppending)) { | |
1066 | try { | |
1067 | @session_get_instance()->terminate_current(); | |
1068 | } catch (Exception $e) { | |
1069 | // Ignore any errors, redirect to upgrade anyway. | |
1070 | } | |
a38c7a10 | 1071 | $url = $CFG->wwwroot . '/' . $CFG->admin . '/index.php'; |
5e39d7aa | 1072 | @header($_SERVER['SERVER_PROTOCOL'] . ' 303 See Other'); |
a38c7a10 PS |
1073 | @header('Location: ' . $url); |
1074 | echo bootstrap_renderer::plain_redirect_message(htmlspecialchars($url)); | |
5e39d7aa | 1075 | exit; |
1076 | } | |
1077 | } | |
1078 | ||
d3f9f1f8 | 1079 | /** |
4031f6a2 PS |
1080 | * Function to check if a directory exists and by default create it if not exists. |
1081 | * | |
1082 | * Previously this was accepting paths only from dataroot, but we now allow | |
1083 | * files outside of dataroot if you supply custom paths for some settings in config.php. | |
1084 | * This function does not verify that the directory is writable. | |
d3f9f1f8 | 1085 | * |
4031f6a2 PS |
1086 | * @param string $dir absolute directory path |
1087 | * @param boolean $create directory if does not exist | |
1088 | * @param boolean $recursive create directory recursively | |
1089 | * @return boolean true if directory exists or created, false otherwise | |
d3f9f1f8 | 1090 | */ |
4031f6a2 | 1091 | function check_dir_exists($dir, $create = true, $recursive = true) { |
d3f9f1f8 | 1092 | global $CFG; |
1093 | ||
4031f6a2 | 1094 | umask(0000); // just in case some evil code changed it |
d3f9f1f8 | 1095 | |
4031f6a2 PS |
1096 | if (is_dir($dir)) { |
1097 | return true; | |
1098 | } | |
d3f9f1f8 | 1099 | |
4031f6a2 PS |
1100 | if (!$create) { |
1101 | return false; | |
d100b8a0 | 1102 | } |
1103 | ||
4031f6a2 PS |
1104 | return mkdir($dir, $CFG->directorypermissions, $recursive); |
1105 | } | |
1106 | ||
1107 | /** | |
1108 | * Create a directory in dataroot and make sure it is writable. | |
1109 | * | |
1110 | * @param string $directory a string of directory names under $CFG->dataroot eg temp/something | |
1111 | * @param bool $exceptiononerror throw exception if error encountered | |
1112 | * @return string|false Returns full path to directory if successful, false if not; may throw exception | |
1113 | */ | |
1114 | function make_upload_directory($directory, $exceptiononerror = true) { | |
1115 | global $CFG; | |
1116 | ||
1117 | // Make sure a .htaccess file is here, JUST IN CASE the files area is in the open and .htaccess is supported | |
1118 | if (!file_exists("$CFG->dataroot/.htaccess")) { | |
1119 | if ($handle = fopen("$CFG->dataroot/.htaccess", 'w')) { // For safety | |
edaf04d4 | 1120 | @fwrite($handle, "deny from all\r\nAllowOverride None\r\nNote: this file is broken intentionally, we do not want anybody to undo it in subdirectory!\r\n"); |
d3f9f1f8 | 1121 | @fclose($handle); |
1122 | } | |
1123 | } | |
1124 | ||
4031f6a2 | 1125 | $dir = "$CFG->dataroot/$directory"; |
d3f9f1f8 | 1126 | |
4031f6a2 PS |
1127 | if (file_exists($dir) and !is_dir($dir)) { |
1128 | if ($exceptiononerror) { | |
1129 | throw new coding_exception($dir.' directory can not be created, file with the same name already exists.'); | |
1130 | } else { | |
1131 | return false; | |
1132 | } | |
1133 | } | |
1134 | ||
1135 | umask(0000); // just in case some evil code changed it | |
1136 | ||
1137 | if (!file_exists($dir)) { | |
1138 | if (!mkdir($dir, $CFG->directorypermissions, true)) { | |
1139 | if ($exceptiononerror) { | |
1140 | throw new invalid_dataroot_permissions($dir.' can not be created, check permissions.'); | |
1141 | } else { | |
d3f9f1f8 | 1142 | return false; |
1143 | } | |
d3f9f1f8 | 1144 | } |
1145 | } | |
1146 | ||
4031f6a2 PS |
1147 | if (!is_writable($dir)) { |
1148 | if ($exceptiononerror) { | |
1149 | throw new invalid_dataroot_permissions($dir.' is not writable, check permissions.'); | |
1150 | } else { | |
1151 | return false; | |
1152 | } | |
1153 | } | |
1154 | ||
1155 | return $dir; | |
d3f9f1f8 | 1156 | } |
1157 | ||
419e1d93 | 1158 | function init_memcached() { |
1159 | global $CFG, $MCACHE; | |
1160 | ||
f917d0ea | 1161 | include_once($CFG->libdir . '/memcached.class.php'); |
1162 | $MCACHE = new memcached; | |
1163 | if ($MCACHE->status()) { | |
1164 | return true; | |
251387d0 | 1165 | } |
f917d0ea | 1166 | unset($MCACHE); |
251387d0 | 1167 | return false; |
419e1d93 | 1168 | } |
1169 | ||
2142d492 | 1170 | function init_eaccelerator() { |
1171 | global $CFG, $MCACHE; | |
1172 | ||
1173 | include_once($CFG->libdir . '/eaccelerator.class.php'); | |
1174 | $MCACHE = new eaccelerator; | |
f917d0ea | 1175 | if ($MCACHE->status()) { |
2142d492 | 1176 | return true; |
251387d0 | 1177 | } |
2142d492 | 1178 | unset($MCACHE); |
1179 | return false; | |
1180 | } | |
1181 | ||
81b58cc2 PS |
1182 | /** |
1183 | * Checks if current user is a web crawler. | |
1184 | * | |
1185 | * This list can not be made complete, this is not a security | |
1186 | * restriction, we make the list only to help these sites | |
1187 | * especially when automatic guest login is disabled. | |
1188 | * | |
1189 | * If admin needs security they should enable forcelogin | |
1190 | * and disable guest access!! | |
1191 | * | |
1192 | * @return bool | |
1193 | */ | |
1194 | function is_web_crawler() { | |
1195 | if (!empty($_SERVER['HTTP_USER_AGENT'])) { | |
1196 | if (strpos($_SERVER['HTTP_USER_AGENT'], 'Googlebot') !== false ) { | |
1197 | return true; | |
1198 | } else if (strpos($_SERVER['HTTP_USER_AGENT'], 'google.com') !== false ) { // Google | |
1199 | return true; | |
1200 | } else if (strpos($_SERVER['HTTP_USER_AGENT'], 'Yahoo! Slurp') !== false ) { // Yahoo | |
1201 | return true; | |
1202 | } else if (strpos($_SERVER['HTTP_USER_AGENT'], '[ZSEBOT]') !== false ) { // Zoomspider | |
1203 | return true; | |
1204 | } else if (strpos($_SERVER['HTTP_USER_AGENT'], 'MSNBOT') !== false ) { // MSN Search | |
1205 | return true; | |
1206 | } else if (strpos($_SERVER['HTTP_USER_AGENT'], 'Yandex') !== false ) { | |
1207 | return true; | |
1208 | } else if (strpos($_SERVER['HTTP_USER_AGENT'], 'AltaVista') !== false ) { | |
1209 | return true; | |
1210 | } | |
1211 | } | |
1212 | return false; | |
1213 | } | |
2142d492 | 1214 | |
c84a2dbe | 1215 | /** |
1216 | * This class solves the problem of how to initialise $OUTPUT. | |
1217 | * | |
1218 | * The problem is caused be two factors | |
1219 | * <ol> | |
1220 | * <li>On the one hand, we cannot be sure when output will start. In particular, | |
30fa50d0 | 1221 | * an error, which needs to be displayed, could be thrown at any time.</li> |
c84a2dbe | 1222 | * <li>On the other hand, we cannot be sure when we will have all the information |
1223 | * necessary to correctly initialise $OUTPUT. $OUTPUT depends on the theme, which | |
1224 | * (potentially) depends on the current course, course categories, and logged in user. | |
1225 | * It also depends on whether the current page requires HTTPS.</li> | |
1226 | * </ol> | |
1227 | * | |
1228 | * So, it is hard to find a single natural place during Moodle script execution, | |
1229 | * which we can guarantee is the right time to initialise $OUTPUT. Instead we | |
1230 | * adopt the following strategy | |
1231 | * <ol> | |
1232 | * <li>We will initialise $OUTPUT the first time it is used.</li> | |
1233 | * <li>If, after $OUTPUT has been initialised, the script tries to change something | |
7e0d6675 | 1234 | * that $OUTPUT depends on, we throw an exception making it clear that the script |
c84a2dbe | 1235 | * did something wrong. |
1236 | * </ol> | |
1237 | * | |
1238 | * The only problem with that is, how do we initialise $OUTPUT on first use if, | |
1239 | * it is going to be used like $OUTPUT->somthing(...)? Well that is where this | |
1240 | * class comes in. Initially, we set up $OUTPUT = new bootstrap_renderer(). Then, | |
1241 | * when any method is called on that object, we initialise $OUTPUT, and pass the call on. | |
1242 | * | |
1243 | * Note that this class is used before lib/outputlib.php has been loaded, so we | |
1387fcdd | 1244 | * must be careful referring to classes/functions from there, they may not be |
c84a2dbe | 1245 | * defined yet, and we must avoid fatal errors. |
1246 | * | |
1247 | * @copyright 2009 Tim Hunt | |
1248 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
1249 | * @since Moodle 2.0 | |
1250 | */ | |
1251 | class bootstrap_renderer { | |
1252 | /** | |
1253 | * Handles re-entrancy. Without this, errors or debugging output that occur | |
1254 | * during the initialisation of $OUTPUT, cause infinite recursion. | |
1255 | * @var boolean | |
1256 | */ | |
1257 | protected $initialising = false; | |
1258 | ||
b7009474 | 1259 | /** |
1260 | * Have we started output yet? | |
1261 | * @return boolean true if the header has been printed. | |
1262 | */ | |
1263 | public function has_started() { | |
1264 | return false; | |
1265 | } | |
1266 | ||
c84a2dbe | 1267 | public function __call($method, $arguments) { |
b7009474 | 1268 | global $OUTPUT, $PAGE; |
c84a2dbe | 1269 | |
87b6851c | 1270 | $recursing = false; |
1271 | if ($method == 'notification') { | |
1387fcdd | 1272 | // Catch infinite recursion caused by debugging output during print_header. |
87b6851c | 1273 | $backtrace = debug_backtrace(); |
1274 | array_shift($backtrace); | |
1275 | array_shift($backtrace); | |
50764d37 | 1276 | $recursing = is_early_init($backtrace); |
87b6851c | 1277 | } |
1278 | ||
eb5bdb35 PS |
1279 | $earlymethods = array( |
1280 | 'fatal_error' => 'early_error', | |
1281 | 'notification' => 'early_notification', | |
1282 | ); | |
1283 | ||
c84a2dbe | 1284 | // If lib/outputlib.php has been loaded, call it. |
87b6851c | 1285 | if (!empty($PAGE) && !$recursing) { |
eb5bdb35 PS |
1286 | if (array_key_exists($method, $earlymethods)) { |
1287 | //prevent PAGE->context warnings - exceptions might appear before we set any context | |
1288 | $PAGE->set_context(null); | |
1289 | } | |
b7009474 | 1290 | $PAGE->initialise_theme_and_output(); |
1291 | return call_user_func_array(array($OUTPUT, $method), $arguments); | |
c84a2dbe | 1292 | } |
2142d492 | 1293 | |
c84a2dbe | 1294 | $this->initialising = true; |
eb5bdb35 | 1295 | |
c84a2dbe | 1296 | // Too soon to initialise $OUTPUT, provide a couple of key methods. |
c84a2dbe | 1297 | if (array_key_exists($method, $earlymethods)) { |
1298 | return call_user_func_array(array('bootstrap_renderer', $earlymethods[$method]), $arguments); | |
1299 | } | |
1300 | ||
1301 | throw new coding_exception('Attempt to start output before enough information is known to initialise the theme.'); | |
1302 | } | |
1303 | ||
1304 | /** | |
1387fcdd | 1305 | * Returns nicely formatted error message in a div box. |
30fa50d0 | 1306 | * @return string |
c84a2dbe | 1307 | */ |
3c1ea58b | 1308 | public static function early_error_content($message, $moreinfourl, $link, $backtrace, $debuginfo = null) { |
b7009474 | 1309 | global $CFG; |
1310 | ||
3c1ea58b PS |
1311 | $content = '<div style="margin-top: 6em; margin-left:auto; margin-right:auto; color:#990000; text-align:center; font-size:large; border-width:1px; |
1312 | border-color:black; background-color:#ffffee; border-style:solid; border-radius: 20px; border-collapse: collapse; | |
1313 | width: 80%; -moz-border-radius: 20px; padding: 15px"> | |
1314 | ' . $message . ' | |
1315 | </div>'; | |
1316 | if (!empty($CFG->debug) && $CFG->debug >= DEBUG_DEVELOPER) { | |
1317 | if (!empty($debuginfo)) { | |
c5d18164 PS |
1318 | $debuginfo = s($debuginfo); // removes all nasty JS |
1319 | $debuginfo = str_replace("\n", '<br />', $debuginfo); // keep newlines | |
1320 | $content .= '<div class="notifytiny">Debug info: ' . $debuginfo . '</div>'; | |
3c1ea58b PS |
1321 | } |
1322 | if (!empty($backtrace)) { | |
1323 | $content .= '<div class="notifytiny">Stack trace: ' . format_backtrace($backtrace, false) . '</div>'; | |
1324 | } | |
1325 | } | |
1326 | ||
1327 | return $content; | |
1328 | } | |
1329 | ||
1330 | /** | |
1331 | * This function should only be called by this class, or from exception handlers | |
1332 | * @return string | |
1333 | */ | |
1334 | public static function early_error($message, $moreinfourl, $link, $backtrace, $debuginfo = null) { | |
1adaa404 PS |
1335 | global $CFG; |
1336 | ||
1337 | if (CLI_SCRIPT) { | |
1338 | echo "!!! $message !!!\n"; | |
1339 | if (!empty($CFG->debug) and $CFG->debug >= DEBUG_DEVELOPER) { | |
1340 | if (!empty($debuginfo)) { | |
1341 | echo "\nDebug info: $debuginfo"; | |
1342 | } | |
1343 | if (!empty($backtrace)) { | |
1344 | echo "\nStack trace: " . format_backtrace($backtrace, true); | |
1345 | } | |
1346 | } | |
1347 | return; | |
1348 | ||
1349 | } else if (AJAX_SCRIPT) { | |
1350 | $e = new stdClass(); | |
1351 | $e->error = $message; | |
1352 | $e->stacktrace = NULL; | |
1353 | $e->debuginfo = NULL; | |
1354 | if (!empty($CFG->debug) and $CFG->debug >= DEBUG_DEVELOPER) { | |
1355 | if (!empty($debuginfo)) { | |
1356 | $e->debuginfo = $debuginfo; | |
1357 | } | |
1358 | if (!empty($backtrace)) { | |
1359 | $e->stacktrace = format_backtrace($backtrace, true); | |
1360 | } | |
1361 | } | |
8a7703ce | 1362 | @header('Content-Type: application/json; charset=utf-8'); |
1adaa404 PS |
1363 | echo json_encode($e); |
1364 | return; | |
1365 | } | |
1366 | ||
c84a2dbe | 1367 | // In the name of protocol correctness, monitoring and performance |
1387fcdd | 1368 | // profiling, set the appropriate error headers for machine consumption |
c84a2dbe | 1369 | if (isset($_SERVER['SERVER_PROTOCOL'])) { |
1370 | // Avoid it with cron.php. Note that we assume it's HTTP/1.x | |
1387fcdd | 1371 | // The 503 ode here means our Moodle does not work at all, the error happened too early |
c84a2dbe | 1372 | @header($_SERVER['SERVER_PROTOCOL'] . ' 503 Service Unavailable'); |
1373 | } | |
1374 | ||
1375 | // better disable any caching | |
1376 | @header('Content-Type: text/html; charset=utf-8'); | |
1377 | @header('Cache-Control: no-store, no-cache, must-revalidate'); | |
1378 | @header('Cache-Control: post-check=0, pre-check=0', false); | |
1379 | @header('Pragma: no-cache'); | |
1380 | @header('Expires: Mon, 20 Aug 1969 09:23:00 GMT'); | |
1381 | @header('Last-Modified: ' . gmdate('D, d M Y H:i:s') . ' GMT'); | |
1382 | ||
5e39d7aa | 1383 | if (function_exists('get_string')) { |
c84a2dbe | 1384 | $strerror = get_string('error'); |
1385 | } else { | |
c84a2dbe | 1386 | $strerror = 'Error'; |
1387 | } | |
1388 | ||
3c1ea58b | 1389 | $content = self::early_error_content($message, $moreinfourl, $link, $backtrace, $debuginfo); |
5e39d7aa | 1390 | |
1391 | return self::plain_page($strerror, $content); | |
c84a2dbe | 1392 | } |
1393 | ||
1394 | public static function early_notification($message, $classes = 'notifyproblem') { | |
1395 | return '<div class="' . $classes . '">' . $message . '</div>'; | |
1396 | } | |
5e39d7aa | 1397 | |
1398 | public static function plain_redirect_message($encodedurl) { | |
1399 | $message = '<p>' . get_string('pageshouldredirect') . '</p><p><a href="'. | |
1400 | $encodedurl .'">'. get_string('continue') .'</a></p>'; | |
a0a268d5 | 1401 | return self::plain_page(get_string('redirect'), $message); |
5e39d7aa | 1402 | } |
1403 | ||
1404 | protected static function plain_page($title, $content) { | |
1405 | if (function_exists('get_string') && function_exists('get_html_lang')) { | |
1406 | $htmllang = get_html_lang(); | |
1407 | } else { | |
1408 | $htmllang = ''; | |
1409 | } | |
1410 | ||
1411 | return '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> | |
1412 | <html xmlns="http://www.w3.org/1999/xhtml" ' . $htmllang . '> | |
1413 | <head> | |
1414 | <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> | |
1415 | <title>' . $title . '</title> | |
1416 | </head><body>' . $content . '</body></html>'; | |
1417 | } | |
c84a2dbe | 1418 | } |