?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Removed dep on API
[ninja.git] / system / core / Kohana.php
blobdaa2fe50655ed9f1d33cf29b0db8bc49125aa002
1 <?php defined('SYSPATH') OR die('No direct access allowed.');
2
3 require_once('op5/log.php');
4
5 #
6 # Hack to enable PHP version < 5.2
7 #
8 if (!defined('E_RECOVERABLE_ERROR'))
9 define('E_RECOVERABLE_ERROR', 4096);
10 if (!defined('FILTER_VALIDATE_IP'))
11 define('FILTER_VALIDATE_IP', false);
12 if (!defined('FILTER_FLAG_IPV4'))
13 define('FILTER_FLAG_IPV4', false);
14
15 if (!function_exists('spl_object_hash')) {
16 /**
17 * Returns the hash of the unique identifier for the object.
18 *
19 * @param object $object Object
20 * @author Rafael M. Salvioni
21 * @return string
22 */
23 function spl_object_hash($object)
24 {
25 if (!is_object($object))
26 $object = arr::to_object($object);
27 if (is_object($object)) {
28 ob_start(); var_dump($object); $dump = ob_get_contents(); ob_end_clean();
29 if (preg_match('/^object\(([a-z0-9_]+)\)\#(\d)+/i', $dump, $match)) {
30 return md5($match[1] . $match[2]);
31 }
32 }
33 trigger_error(__FUNCTION__ . "() expects parameter 1 to be object", E_USER_WARNING);
34 return null;
35 }
36 }
37
38 if (!function_exists('filter_var')) {
39 function filter_var($input) {
40 return $input;
41 }
42 }
43 #
44 # End PHP version hack
45 #
46
47 /**
48 * Provides Kohana-specific helper functions. This is where the magic happens!
49 *
50 * $Id: Kohana.php 3917 2009-01-21 03:06:22Z zombor $
51 *
52 * @package Core
53 * @author Kohana Team
54 * @copyright (c) 2007-2008 Kohana Team
55 * @license http://kohanaphp.com/license.html
56 */
57 final class Kohana {
58
59 // The singleton instance of the controller
60 public static $instance;
61
62 // Output buffering level
63 private static $buffer_level;
64
65 // Will be set to TRUE when an exception is caught
66 public static $has_error = FALSE;
67
68 // The final output that will displayed by Kohana
69 public static $output = '';
70
71 // The current user agent
72 public static $user_agent;
73
74 // The current locale
75 public static $locale;
76
77 // Configuration
78 private static $configuration;
79
80 // Include paths
81 private static $include_paths;
82
83 // Logged messages
84 private static $log;
85
86 // Cache lifetime
87 private static $cache_lifetime;
88
89 // Internal caches and write status
90 private static $internal_cache = array();
91 private static $write_cache;
92
93 /**
94 * Sets up the PHP environment. Adds error/exception handling, output
95 * buffering, and adds an auto-loading method for loading classes.
96 *
97 * This method is run immediately when this file is loaded, and is
98 * benchmarked as environment_setup.
99 *
100 * For security, this function also destroys the $_REQUEST global variable.
101 * Using the proper global (GET, POST, COOKIE, etc) is inherently more secure.
102 * The recommended way to fetch a global variable is using the Input library.
103 * @see http://www.php.net/globals
104 *
105 * @return void
106 */
107 public static function setup()
108 {
109 static $run;
110
111 // This function can only be run once
112 if ($run === TRUE)
113 return;
114
115 // Start the environment setup benchmark
116 Benchmark::start(SYSTEM_BENCHMARK.'_environment_setup');
117
118 // Define Kohana error constant
119 define('E_KOHANA', 42);
120
121 // Define 404 error constant
122 define('E_PAGE_NOT_FOUND', 43);
123
124 // Define database error constant
125 define('E_DATABASE_ERROR', 44);
126
127 // Add APPPATH as the first path
128 self::$include_paths = array(APPPATH);
129 foreach (glob(MODPATH.'*', GLOB_ONLYDIR) as $path)
130 {
131 self::$include_paths[] = $path.'/';
132 }
133 // Add SYSPATH as the last path
134 self::$include_paths[] = SYSPATH;
135
136 if (self::$cache_lifetime = self::config('core.internal_cache'))
137 {
138 // Load cached configuration and language files
139 self::$internal_cache['configuration'] = self::cache('configuration', self::$cache_lifetime);
140 self::$internal_cache['language'] = self::cache('language', self::$cache_lifetime);
141
142 // Load cached file paths
143 self::$internal_cache['find_file_paths'] = self::cache('find_file_paths', self::$cache_lifetime);
144
145 // Enable cache saving
146 Event::add('system.shutdown', array(__CLASS__, 'internal_cache_save'));
147 }
148
149 // Disable notices and "strict" errors
150 $ER = error_reporting(~E_NOTICE & ~E_STRICT);
151
152 // Set the user agent
153 self::$user_agent = trim($_SERVER['HTTP_USER_AGENT']);
154
155 if (function_exists('date_default_timezone_set'))
156 {
157 $timezone = self::config('locale.timezone');
158
159 // Set default timezone, due to increased validation of date settings
160 // which cause massive amounts of E_NOTICEs to be generated in PHP 5.2+
161 date_default_timezone_set(empty($timezone) ? date_default_timezone_get() : $timezone);
162 }
163
164 // Restore error reporting
165 error_reporting($ER);
166
167 // Start output buffering
168 ob_start(array(__CLASS__, 'output_buffer'));
169
170 // Save buffering level
171 self::$buffer_level = ob_get_level();
172
173 // Set autoloader
174 spl_autoload_register(array('Kohana', 'auto_load'));
175
176 // Set error handler
177 if (PHP_SAPI !== 'cli' && !defined('SKIP_KOHANA')) {
178 set_error_handler(array('Kohana', 'exception_handler'));
179
180 // Set exception handler
181 set_exception_handler(array('Kohana', 'exception_handler'));
182
183 // Send default text/html UTF-8 header
184 header('Content-Type: text/html; charset=UTF-8');
185 }
186
187 // Load locales
188 $locales = self::config('locale.language');
189
190 // Make first locale UTF-8
191 $locales[0] .= '.UTF-8';
192
193 // Set locale information
194 self::$locale = setlocale(LC_ALL, $locales);
195
196 // Enable Kohana routing
197 Event::add('system.routing', array('Router', 'find_uri'));
198 Event::add('system.routing', array('Router', 'setup'));
199
200 // Enable Kohana controller initialization
201 Event::add('system.execute', array('Kohana', 'instance'));
202
203 // Enable Kohana 404 pages
204 Event::add('system.404', array('Kohana', 'show_404'));
205
206 // Enable Kohana output handling
207 Event::add('system.shutdown', array('Kohana', 'shutdown'));
208
209 if (self::config('core.enable_hooks') === TRUE)
210 {
211 // Find all the hook files
212 $hooks = self::list_files('hooks', TRUE);
213
214 foreach ($hooks as $file)
215 {
216 // Load the hook
217 include $file;
218 }
219 }
220
221 // Setup is complete, prevent it from being run again
222 $run = TRUE;
223
224 // Stop the environment setup routine
225 Benchmark::stop(SYSTEM_BENCHMARK.'_environment_setup');
226 }
227
228 /**
229 * Loads the controller and initializes it. Runs the pre_controller,
230 * post_controller_constructor, and post_controller events. Triggers
231 * a system.404 event when the route cannot be mapped to a controller.
232 *
233 * This method is benchmarked as controller_setup and controller_execution.
234 *
235 * @return object instance of controller
236 */
237 public static function & instance()
238 {
239 if (self::$instance === NULL)
240 {
241 Benchmark::start(SYSTEM_BENCHMARK.'_controller_setup');
242
243 if (Router::$method[0] === '_')
244 {
245 // Do not allow access to hidden methods
246 Event::run('system.404');
247 }
248
249 // Include the Controller file
250 require Router::$controller_path;
251
252 try
253 {
254 // Start validation of the controller
255 $class = new ReflectionClass(ucfirst(Router::$controller).'_Controller');
256 }
257 catch (ReflectionException $e)
258 {
259 // Controller does not exist
260 Event::run('system.404');
261 }
262
263 if ($class->isAbstract() OR (IN_PRODUCTION AND $class->getConstant('ALLOW_PRODUCTION') == FALSE))
264 {
265 // Controller is not allowed to run in production
266 Event::run('system.404');
267 }
268
269 // Run system.pre_controller
270 Event::run('system.pre_controller');
271
272 // Create a new controller instance
273 $controller = $class->newInstance();
274
275 // Controller constructor has been executed
276 Event::run('system.post_controller_constructor', $controller);
277
278 try
279 {
280 // Load the controller method
281 $method = $class->getMethod(Router::$method);
282
283 if ($method->isProtected() or $method->isPrivate())
284 {
285 // Do not attempt to invoke protected methods
286 throw new ReflectionException('protected controller method');
287 }
288
289 // Default arguments
290 $arguments = Router::$arguments;
291 }
292 catch (ReflectionException $e)
293 {
294 // Use __call instead
295 $method = $class->getMethod('__call');
296
297 // Use arguments in __call format
298 $arguments = array(Router::$method, Router::$arguments);
299 }
300
301 // Stop the controller setup benchmark
302 Benchmark::stop(SYSTEM_BENCHMARK.'_controller_setup');
303
304 // Start the controller execution benchmark
305 Benchmark::start(SYSTEM_BENCHMARK.'_controller_execution');
306
307 // Execute the controller method
308 $method->invokeArgs($controller, $arguments);
309
310 // Controller method has been executed
311 Event::run('system.post_controller', $controller);
312
313 // Stop the controller execution benchmark
314 Benchmark::stop(SYSTEM_BENCHMARK.'_controller_execution');
315 }
316
317 return self::$instance;
318 }
319
320 /**
321 * Get all include paths.
322 * APPPATH is the first path, followed by module
323 * paths in the order they are configured, follow by the SYSPATH.
324 *
325 * @param
326 * boolean re-process the include paths, we don't do that...
327 * ignore
328 * @return array
329 */
330 public static function include_paths($process = FALSE) {
331 return self::$include_paths;
332 }
333
334 /**
335 * Remove include paths given a certain pattern.
336 * Useful for replacing modules
337 * for testing
338 */
339 public static function remove_include_paths($pattern) {
340 self::$include_paths = array_filter(self::$include_paths,
341 function ($path) use($pattern) {
342 return !preg_match($pattern, $path);
343 });
344 }
345
346 /**
347 * Add include path, useful for unit testing of external libraries
348 */
349 public static function add_include_path($path) {
350 self::$include_paths[] = $path;
351 }
352
353 /**
354 * Get a config item or group.
355 *
356 * @param string item name
357 * @param boolean force a forward slash (/) at the end of the item
358 * @param boolean is the item required?
359 * @return mixed
360 */
361 public static function config($key, $slash = FALSE, $required = TRUE)
362 {
363 if (self::$configuration === NULL)
364 {
365 // Load core configuration
366 self::$configuration['core'] = self::config_load('core');
367
368 // Re-parse the include paths
369 self::include_paths(TRUE);
370 }
371
372 // Get the group name from the key
373 $group = explode('.', $key, 2);
374 $group = $group[0];
375
376 if ( ! isset(self::$configuration[$group]))
377 {
378 // Load the configuration group
379 self::$configuration[$group] = self::config_load($group, $required);
380 }
381
382 // Get the value of the key string
383 $value = self::key_string(self::$configuration, $key);
384
385 if ($slash === TRUE AND is_string($value) AND $value !== '')
386 {
387 // Force the value to end with "/"
388 $value = rtrim($value, '/').'/';
389 }
390
391 return $value;
392 }
393
394 /**
395 * Sets a configuration item, if allowed.
396 *
397 * @param string config key string
398 * @param string config value
399 * @return boolean
400 */
401 public static function config_set($key, $value)
402 {
403 // Do this to make sure that the config array is already loaded
404 self::config($key);
405
406 if (substr($key, 0, 7) === 'routes.')
407 {
408 // Routes cannot contain sub keys due to possible dots in regex
409 $keys = explode('.', $key, 2);
410 }
411 else
412 {
413 // Convert dot-noted key string to an array
414 $keys = explode('.', $key);
415 }
416
417 // Used for recursion
418 $conf =& self::$configuration;
419 $last = count($keys) - 1;
420
421 foreach ($keys as $i => $k)
422 {
423 if ($i === $last)
424 {
425 $conf[$k] = $value;
426 }
427 else
428 {
429 $conf =& $conf[$k];
430 }
431 }
432
433 if ($key === 'core.modules')
434 {
435 // Reprocess the include paths
436 self::include_paths(TRUE);
437 }
438
439 return TRUE;
440 }
441
442 /**
443 * Load a config file.
444 *
445 * @param string config filename, without extension
446 * @param boolean is the file required?
447 * @return array
448 */
449 public static function config_load($name, $required = TRUE)
450 {
451 if ($name === 'core')
452 {
453 // Load the application configuration file
454 require APPPATH.'config/config'.EXT;
455 if (is_file(APPPATH.'config/custom/config'.EXT))
456 include APPPATH.'config/custom/config'.EXT;
457
458 if ( ! isset($config['site_domain']))
459 {
460 // Invalid config file
461 die('Your Kohana application configuration file is not valid.');
462 }
463
464 return $config;
465 }
466
467 if (isset(self::$internal_cache['configuration'][$name]))
468 return self::$internal_cache['configuration'][$name];
469
470 // Load matching configs
471 $configuration = array();
472
473 if ($files = self::find_file('config', $name, $required))
474 {
475
476 foreach ($files as $file)
477 {
478 require $file;
479
480 if (isset($config) AND is_array($config))
481 {
482 // Merge in configuration
483 $configuration = array_merge($configuration, $config);
484 }
485 }
486 }
487
488 if ($files = self::find_file('config/custom', $name, false))
489 {
490 foreach ($files as $file)
491 {
492 require $file;
493 if (isset($config) and is_array($config))
494 {
495 $configuration = array_merge($configuration, $config);
496 }
497 }
498 }
499
500 if ( ! isset(self::$write_cache['configuration']))
501 {
502 // Cache has changed
503 self::$write_cache['configuration'] = TRUE;
504 }
505
506 return self::$internal_cache['configuration'][$name] = $configuration;
507 }
508
509 /**
510 * Clears a config group from the cached configuration.
511 *
512 * @param string config group
513 * @return void
514 */
515 public static function config_clear($group)
516 {
517 // Remove the group from config
518 unset(self::$configuration[$group], self::$internal_cache['configuration'][$group]);
519
520 if ( ! isset(self::$write_cache['configuration']))
521 {
522 // Cache has changed
523 self::$write_cache['configuration'] = TRUE;
524 }
525 }
526
527 /**
528 * Add a new message to the log.
529 *
530 * @param string type of message
531 * @param string message text
532 * @return void
533 */
534 public static function log($type, $message)
535 {
536 op5log::instance()->log('ninja', $type, $message);
537 }
538
539 /**
540 * Load data from a simple cache file. This should only be used internally,
541 * and is NOT a replacement for the Cache library.
542 *
543 * @param string unique name of cache
544 * @param integer expiration in seconds
545 * @return mixed
546 */
547 public static function cache($name, $lifetime)
548 {
549 if ($lifetime > 0)
550 {
551 $path = APPPATH.'cache/kohana_'.$name;
552
553 if (is_file($path))
554 {
555 // Check the file modification time
556 if ((time() - filemtime($path)) < $lifetime)
557 {
558 // Cache is valid
559 return unserialize(file_get_contents($path));
560 }
561 else
562 {
563 // Cache is invalid, delete it
564 unlink($path);
565 }
566 }
567 }
568
569 // No cache found
570 return NULL;
571 }
572
573 /**
574 * Save data to a simple cache file. This should only be used internally, and
575 * is NOT a replacement for the Cache library.
576 *
577 * @param string cache name
578 * @param mixed data to cache
579 * @param integer expiration in seconds
580 * @return boolean
581 */
582 public static function cache_save($name, $data, $lifetime)
583 {
584 if ($lifetime < 1)
585 return FALSE;
586
587 $path = APPPATH.'cache/kohana_'.$name;
588
589 if ($data === NULL)
590 {
591 // Delete cache
592 return (is_file($path) and unlink($path));
593 }
594 else
595 {
596 // Write data to cache file
597 return (bool) file_put_contents($path, serialize($data));
598 }
599 }
600
601 /**
602 * Kohana output handler.
603 *
604 * @param string current output buffer
605 * @return string
606 */
607 public static function output_buffer($output)
608 {
609 if ( ! Event::has_run('system.send_headers'))
610 {
611 // Run the send_headers event, specifically for cookies being set
612 Event::run('system.send_headers');
613 }
614
615 // Set final output
616 self::$output = $output;
617
618 // Set and return the final output
619 return $output;
620 }
621
622 /**
623 * Closes all open output buffers, either by flushing or cleaning all
624 * open buffers, including the Kohana output buffer.
625 *
626 * @param boolean disable to clear buffers, rather than flushing
627 * @return void
628 */
629 public static function close_buffers($flush = TRUE)
630 {
631 if (ob_get_level() >= self::$buffer_level)
632 {
633 // Set the close function
634 $close = ($flush === TRUE) ? 'ob_end_flush' : 'ob_end_clean';
635
636 while (ob_get_level() > self::$buffer_level)
637 {
638 // Flush or clean the buffer
639 $close();
640 }
641
642 // This will flush the Kohana buffer, which sets self::$output
643 ob_end_clean();
644
645 // Reset the buffer level
646 self::$buffer_level = ob_get_level();
647 }
648 }
649
650 /**
651 * Triggers the shutdown of Kohana by closing the output buffer, runs the system.display event.
652 *
653 * @return void
654 */
655 public static function shutdown()
656 {
657 // Close output buffers
658 self::close_buffers(TRUE);
659
660 // Run the output event
661 Event::run('system.display', self::$output);
662
663 // Render the final output
664 self::render(self::$output);
665 }
666
667 /**
668 * Inserts global Kohana variables into the generated output and prints it.
669 *
670 * @param string final output that will displayed
671 * @return void
672 */
673 public static function render($output)
674 {
675 // Fetch memory usage in MB
676 $memory = function_exists('memory_get_usage') ? (memory_get_usage() / 1024 / 1024) : 0;
677
678 // Fetch benchmark for page execution time
679 $benchmark = Benchmark::get(SYSTEM_BENCHMARK.'_total_execution');
680
681 if (self::config('core.render_stats') === TRUE)
682 {
683 // Replace the global template variables
684 $output = str_replace(
685 array
686 (
687 '{kohana_version}',
688 '{kohana_codename}',
689 '{execution_time}',
690 '{memory_usage}',
691 '{included_files}',
692 ),
693 array
694 (
695 KOHANA_VERSION,
696 KOHANA_CODENAME,
697 $benchmark['time'],
698 number_format($memory, 2).'MB',
699 count(get_included_files()),
700 ),
701 $output
702 );
703 }
704
705 if ($level = self::config('core.output_compression') AND ini_get('output_handler') !== 'ob_gzhandler' AND (int) ini_get('zlib.output_compression') === 0)
706 {
707 if ($level < 1 OR $level > 9)
708 {
709 // Normalize the level to be an integer between 1 and 9. This
710 // step must be done to prevent gzencode from triggering an error
711 $level = max(1, min($level, 9));
712 }
713
714 if (stripos(@$_SERVER['HTTP_ACCEPT_ENCODING'], 'gzip') !== FALSE)
715 {
716 $compress = 'gzip';
717 }
718 elseif (stripos(@$_SERVER['HTTP_ACCEPT_ENCODING'], 'deflate') !== FALSE)
719 {
720 $compress = 'deflate';
721 }
722 }
723
724 if (isset($compress) AND $level > 0)
725 {
726 switch ($compress)
727 {
728 case 'gzip':
729 // Compress output using gzip
730 $output = gzencode($output, $level);
731 break;
732 case 'deflate':
733 // Compress output using zlib (HTTP deflate)
734 $output = gzdeflate($output, $level);
735 break;
736 }
737
738 // This header must be sent with compressed content to prevent
739 // browser caches from breaking
740 header('Vary: Accept-Encoding');
741
742 // Send the content encoding header
743 header('Content-Encoding: '.$compress);
744
745 // Sending Content-Length in CGI can result in unexpected behavior
746 if (stripos(PHP_SAPI, 'cgi') === FALSE)
747 {
748 header('Content-Length: '.strlen($output));
749 }
750 }
751
752 echo $output;
753 }
754
755 /**
756 * Displays a 404 page.
757 *
758 * @throws Kohana_404_Exception
759 * @param string URI of page
760 * @param string custom template
761 * @return void
762 */
763 public static function show_404($page = FALSE, $template = FALSE)
764 {
765 throw new Kohana_404_Exception($page, $template);
766 }
767
768 /**
769 * Dual-purpose PHP error and exception handler. Uses the kohana_error_page
770 * view to display the message.
771 *
772 * @param integer|object exception object or error code
773 * @param string error message
774 * @param string filename
775 * @param integer line number
776 * @return void
777 */
778 public static function exception_handler($exception, $message = NULL, $file = NULL, $line = NULL)
779 {
780 try {
781 // PHP errors have 5 args, always
782 $PHP_ERROR = (func_num_args() === 5);
783
784 // Test to see if errors should be displayed
785 if ($PHP_ERROR AND (error_reporting() & $exception) === 0)
786 return;
787
788 // This is useful for hooks to determine if a page has an error
789 self::$has_error = TRUE;
790
791 // Error handling will use exactly 5 args, every time
792 if ($PHP_ERROR)
793 {
794 $code = $exception;
795 $type = 'PHP Error';
796 $template = 'kohana_error_page';
797 }
798 else
799 {
800 $code = $exception->getCode();
801 $type = get_class($exception);
802 $message = $exception->getMessage();
803 $file = $exception->getFile();
804 $line = $exception->getLine();
805 $template = ($exception instanceof Kohana_Exception) ? $exception->getTemplate() : 'kohana_error_page';
806 }
807
808 if (is_numeric($code))
809 {
810 $codes = self::lang('errors');
811
812 if ( ! empty($codes[$code]))
813 {
814 list($level, $error, $description) = $codes[$code];
815 }
816 else
817 {
818 $level = 1;
819 $error = $PHP_ERROR ? 'Unknown Error' : get_class($exception);
820 $description = '';
821 }
822 }
823 else
824 {
825 // Custom error message, this will never be logged
826 $level = 5;
827 $error = $code;
828 $description = '';
829 }
830
831 // Remove the DOCROOT from the path, as a security precaution
832 $file = str_replace('\\', '/', realpath($file));
833 $file = preg_replace('|^'.preg_quote(DOCROOT).'|', '', $file);
834
835 self::log('error', self::lang('core.uncaught_exception', $type, $message, $file, $line));
836
837 if ($PHP_ERROR)
838 {
839 $description = self::lang('errors.'.E_RECOVERABLE_ERROR);
840 $description = is_array($description) ? $description[2] : '';
841
842 if ( ! headers_sent())
843 {
844 header('HTTP/1.1 500 Internal Server Error');
845 }
846 }
847 else
848 {
849 if(!headers_sent()) {
850 if (method_exists($exception, 'sendHeaders'))
851 {
852 $exception->sendHeaders();
853 } else {
854 header('HTTP/1.1 500 Internal Server Error');
855 }
856 }
857 }
858
859 while (ob_get_level() > self::$buffer_level)
860 {
861 // Close open buffers
862 ob_end_clean();
863 }
864
865 // Test if display_errors is on
866 if (self::$configuration['core']['display_errors'] === TRUE)
867 {
868 if ($line != FALSE)
869 {
870 // Remove the first entry of debug_backtrace(), it is the exception_handler call
871 $trace = $PHP_ERROR ? array_slice(debug_backtrace(), 1) : $exception->getTrace();
872
873 // Beautify backtrace
874 $trace = self::backtrace($trace);
875 }
876
877 // Load the error
878 require self::find_file('views', empty($template) ? 'kohana_error_page' : $template);
879 }
880 else
881 {
882 // Get the i18n messages
883 $error = self::lang('core.generic_error');
884 $message = self::lang('core.errors_disabled', url::site(), url::site(Router::$current_uri));
885
886 // Load the errors_disabled view
887 require self::find_file('views', 'kohana_error_disabled');
888 }
889
890 if ( ! Event::has_run('system.shutdown'))
891 {
892 // Run the shutdown even to ensure a clean exit
893 Event::run('system.shutdown');
894 }
895
896 // Turn off error reporting
897 error_reporting(0);
898 } catch( Exception $e ) {
899 /* Exceptions in an exceptionhandler results in "Exception thrown without a stack trace in "Unkonwn"
900 * Better to just print the exception ugly, so we get some kind of useful information instaead
901 */
902 while( @ob_end_clean() ) {}
903 print "Exception during error handler: ".$e->getMessage()."\n";
904 print $e->getTraceAsString();
905
906 }
907 exit;
908 }
909
910 /**
911 * Provides class auto-loading.
912 *
913 * @throws Kohana_Exception
914 * @param string name of class
915 * @return bool
916 */
917 public static function auto_load($class)
918 {
919 if (class_exists($class, FALSE))
920 return TRUE;
921
922 if (($suffix = strrpos($class, '_')) > 0)
923 {
924 // Find the class suffix
925 $suffix = substr($class, $suffix + 1);
926 }
927 else
928 {
929 // No suffix
930 $suffix = FALSE;
931 }
932
933 if ($suffix === 'Core')
934 {
935 $type = 'libraries';
936 $file = substr($class, 0, -5);
937 }
938 elseif ($suffix === 'Controller')
939 {
940 $type = 'controllers';
941 // Lowercase filename
942 $file = strtolower(substr($class, 0, -11));
943 }
944 elseif ($suffix === 'Model')
945 {
946 $type = 'models';
947 // Lowercase filename
948 $file = strtolower(substr($class, 0, -6));
949 }
950 elseif ($suffix === 'Driver')
951 {
952 $type = 'libraries/drivers';
953 $file = str_replace('_', '/', substr($class, 0, -7));
954 }
955 elseif ($suffix === 'Widget')
956 {
957 $type = 'widgets';
958 $classname = substr($class, 0, -7);
959 $file = $classname . '/' . $classname;
960 }
961 else
962 {
963 // This could be either a library or a helper, but libraries must
964 // always be capitalized, so we check if the first character is
965 // uppercase. If it is, we are loading a library, not a helper.
966 $type = ($class[0] < 'a') ? 'libraries' : 'helpers';
967 $file = $class;
968 }
969
970 if ($filename = self::find_file($type, $file))
971 {
972 // Load the class
973 require $filename;
974 }
975 else
976 {
977 // The class could not be found
978 return FALSE;
979 }
980
981 if ($filename = self::find_file($type, self::$configuration['core']['extension_prefix'].$class))
982 {
983 // Load the class extension
984 require $filename;
985 }
986 elseif ($suffix !== 'Core' AND class_exists($class.'_Core', FALSE))
987 {
988 // Class extension to be evaluated
989 $extension = 'class '.$class.' extends '.$class.'_Core { }';
990
991 // Start class analysis
992 $core = new ReflectionClass($class.'_Core');
993
994 if ($core->isAbstract())
995 {
996 // Make the extension abstract
997 $extension = 'abstract '.$extension;
998 }
999
1000 // Transparent class extensions are handled using eval. This is
1001 // a disgusting hack, but it gets the job done.
1002 eval($extension);
1003 }
1004
1005 return TRUE;
1006 }
1007
1008 /**
1009 * Find a resource file in a given directory. Files will be located according
1010 * to the order of the include paths. Configuration and i18n files will be
1011 * returned in reverse order.
1012 *
1013 * @throws Kohana_Exception if file is required and not found
1014 * @param string directory to search in
1015 * @param string filename to look for (including extension only if 4th parameter is TRUE)
1016 * @param boolean file required
1017 * @param string file extension
1018 * @return array if the type is config, i18n or l10n
1019 * @return string if the file is found
1020 * @return FALSE if the file is not found
1021 */
1022 public static function find_file($directory, $filename, $required = FALSE, $ext = FALSE)
1023 {
1024 // NOTE: This test MUST be not be a strict comparison (===), or empty
1025 // extensions will be allowed!
1026 if ($ext == '')
1027 {
1028 // Use the default extension
1029 $ext = EXT;
1030 }
1031 else
1032 {
1033 // Add a period before the extension
1034 $ext = '.'.$ext;
1035 }
1036
1037 // Search path
1038 $search = $directory.'/'.$filename.$ext;
1039
1040 if (isset(self::$internal_cache['find_file_paths'][$search]))
1041 return self::$internal_cache['find_file_paths'][$search];
1042
1043 // Load include paths
1044 $paths = self::$include_paths;
1045
1046 // Nothing found, yet
1047 $found = NULL;
1048
1049 if ($directory === 'config' OR $directory === 'i18n' OR $directory === 'config/custom')
1050 {
1051 // Search in reverse, for merging
1052 $paths = array_reverse($paths);
1053
1054 foreach ($paths as $path)
1055 {
1056 if (is_file($path.$search))
1057 {
1058 // A matching file has been found
1059 $found[] = $path.$search;
1060 }
1061 }
1062 }
1063 else
1064 {
1065 foreach ($paths as $path)
1066 {
1067 if (is_file($path.$search))
1068 {
1069 // A matching file has been found
1070 $found = $path.$search;
1071
1072 // Stop searching
1073 break;
1074 }
1075 }
1076 }
1077
1078 if ($found === NULL)
1079 {
1080 if ($required === TRUE)
1081 {
1082 // Directory i18n key
1083 $directory = 'core.'.inflector::singular($directory);
1084
1085 // If the file is required, throw an exception
1086 throw new Kohana_Exception('core.resource_not_found', self::lang($directory), $filename);
1087 }
1088 else
1089 {
1090 // Nothing was found, return FALSE
1091 $found = FALSE;
1092 }
1093 }
1094
1095 if ( ! isset(self::$write_cache['find_file_paths']))
1096 {
1097 // Write cache at shutdown
1098 self::$write_cache['find_file_paths'] = TRUE;
1099 }
1100
1101 return self::$internal_cache['find_file_paths'][$search] = $found;
1102 }
1103
1104 /**
1105 * Lists all files and directories in a resource path.
1106 *
1107 * @param string directory to search
1108 * @param boolean list all files to the maximum depth?
1109 * @param string full path to search (used for recursion, *never* set this manually)
1110 * @return array filenames and directories
1111 */
1112 public static function list_files($directory, $recursive = FALSE, $path = FALSE)
1113 {
1114 $files = array();
1115
1116 if ($path === FALSE)
1117 {
1118 $paths = array_reverse(self::include_paths());
1119
1120 foreach ($paths as $path)
1121 {
1122 // Recursively get and merge all files
1123 $files = array_merge($files, self::list_files($directory, $recursive, $path.$directory));
1124 }
1125 }
1126 else
1127 {
1128 $path = rtrim($path, '/').'/';
1129
1130 if (is_readable($path))
1131 {
1132 $items = (array) glob($path.'*');
1133
1134 foreach ($items as $index => $item)
1135 {
1136 $files[] = $item = str_replace('\\', '/', $item);
1137
1138 // Handle recursion
1139 if (is_dir($item) AND $recursive == TRUE)
1140 {
1141 // Filename should only be the basename
1142 $item = pathinfo($item, PATHINFO_BASENAME);
1143
1144 // Append sub-directory search
1145 $files = array_merge($files, self::list_files($directory, TRUE, $path.$item));
1146 }
1147 }
1148 }
1149 }
1150
1151 return $files;
1152 }
1153
1154 /**
1155 * Fetch an i18n language item.
1156 *
1157 * @param string language key to fetch
1158 * @param array additional information to insert into the line
1159 * @return string i18n language string, or the requested key if the i18n item is not found
1160 */
1161 public static function lang($key, $args = array())
1162 {
1163 // Extract the main group from the key
1164 $group = explode('.', $key, 2);
1165 $group = $group[0];
1166
1167 // Get locale name
1168 $locale = self::config('locale.language.0');
1169
1170 if ( ! isset(self::$internal_cache['language'][$locale][$group]))
1171 {
1172 // Messages for this group
1173 $messages = array();
1174
1175 if ($files = self::find_file('i18n', $locale.'/'.$group))
1176 {
1177 foreach ($files as $file)
1178 {
1179 include $file;
1180
1181 // Merge in configuration
1182 if ( ! empty($lang) AND is_array($lang))
1183 {
1184 foreach ($lang as $k => $v)
1185 {
1186 $messages[$k] = $v;
1187 }
1188 }
1189 }
1190 }
1191
1192 if ( ! isset(self::$write_cache['language']))
1193 {
1194 // Write language cache
1195 self::$write_cache['language'] = TRUE;
1196 }
1197
1198 self::$internal_cache['language'][$locale][$group] = $messages;
1199 }
1200
1201 // Get the line from cache
1202 $line = self::key_string(self::$internal_cache['language'][$locale], $key);
1203
1204 if ($line === NULL)
1205 {
1206 self::log('error', 'Missing i18n entry '.$key.' for language '.$locale);
1207
1208 // Return the key string as fallback
1209 return $key;
1210 }
1211
1212 if (is_string($line) AND func_num_args() > 1)
1213 {
1214 $args = array_slice(func_get_args(), 1);
1215
1216 // Add the arguments into the line
1217 $line = vsprintf($line, is_array($args[0]) ? $args[0] : $args);
1218 }
1219
1220 return $line;
1221 }
1222
1223 /**
1224 * Returns the value of a key, defined by a 'dot-noted' string, from an array.
1225 *
1226 * @param array array to search
1227 * @param string dot-noted string: foo.bar.baz
1228 * @return string if the key is found
1229 * @return void if the key is not found
1230 */
1231 public static function key_string($array, $keys)
1232 {
1233 if (empty($array))
1234 return NULL;
1235
1236 // Prepare for loop
1237 $keys = explode('.', $keys);
1238
1239 do
1240 {
1241 // Get the next key
1242 $key = array_shift($keys);
1243
1244 if (isset($array[$key]))
1245 {
1246 if (is_array($array[$key]) AND ! empty($keys))
1247 {
1248 // Dig down to prepare the next loop
1249 $array = $array[$key];
1250 }
1251 else
1252 {
1253 // Requested key was found
1254 return $array[$key];
1255 }
1256 }
1257 else
1258 {
1259 // Requested key is not set
1260 break;
1261 }
1262 }
1263 while ( ! empty($keys));
1264
1265 return NULL;
1266 }
1267
1268 /**
1269 * Sets values in an array by using a 'dot-noted' string.
1270 *
1271 * @param array array to set keys in (reference)
1272 * @param string dot-noted string: foo.bar.baz
1273 * @return mixed fill value for the key
1274 * @return void
1275 */
1276 public static function key_string_set( & $array, $keys, $fill = NULL)
1277 {
1278 if (is_object($array) AND ($array instanceof ArrayObject))
1279 {
1280 // Copy the array
1281 $array_copy = $array->getArrayCopy();
1282
1283 // Is an object
1284 $array_object = TRUE;
1285 }
1286 else
1287 {
1288 if ( ! is_array($array))
1289 {
1290 // Must always be an array
1291 $array = (array) $array;
1292 }
1293
1294 // Copy is a reference to the array
1295 $array_copy =& $array;
1296 }
1297
1298 if (empty($keys))
1299 return $array;
1300
1301 // Create keys
1302 $keys = explode('.', $keys);
1303
1304 // Create reference to the array
1305 $row =& $array_copy;
1306
1307 for ($i = 0, $end = count($keys) - 1; $i <= $end; $i++)
1308 {
1309 // Get the current key
1310 $key = $keys[$i];
1311
1312 if ( ! isset($row[$key]))
1313 {
1314 if (isset($keys[$i + 1]))
1315 {
1316 // Make the value an array
1317 $row[$key] = array();
1318 }
1319 else
1320 {
1321 // Add the fill key
1322 $row[$key] = $fill;
1323 }
1324 }
1325 elseif (isset($keys[$i + 1]))
1326 {
1327 // Make the value an array
1328 $row[$key] = (array) $row[$key];
1329 }
1330
1331 // Go down a level, creating a new row reference
1332 $row =& $row[$key];
1333 }
1334
1335 if (isset($array_object))
1336 {
1337 // Swap the array back in
1338 $array->exchangeArray($array_copy);
1339 }
1340 }
1341
1342 /**
1343 * Retrieves current user agent information:
1344 * keys: browser, version, platform, mobile, robot, referrer, languages, charsets
1345 * tests: is_browser, is_mobile, is_robot, accept_lang, accept_charset
1346 *
1347 * @param string key or test name
1348 * @param string used with "accept" tests: user_agent(accept_lang, en)
1349 * @return array languages and charsets
1350 * @return string all other keys
1351 * @return boolean all tests
1352 */
1353 public static function user_agent($key = 'agent', $compare = NULL)
1354 {
1355 static $info;
1356
1357 // Return the raw string
1358 if ($key === 'agent')
1359 return self::$user_agent;
1360
1361 if ($info === NULL)
1362 {
1363 // Parse the user agent and extract basic information
1364 $agents = self::config('user_agents');
1365
1366 foreach ($agents as $type => $data)
1367 {
1368 foreach ($data as $agent => $name)
1369 {
1370 if (stripos(self::$user_agent, $agent) !== FALSE)
1371 {
1372 if ($type === 'browser' AND preg_match('|'.preg_quote($agent).'[^0-9.]*+([0-9.][0-9.a-z]*)|i', self::$user_agent, $match))
1373 {
1374 // Set the browser version
1375 $info['version'] = $match[1];
1376 }
1377
1378 // Set the agent name
1379 $info[$type] = $name;
1380 break;
1381 }
1382 }
1383 }
1384 }
1385
1386 if (empty($info[$key]))
1387 {
1388 switch ($key)
1389 {
1390 case 'is_robot':
1391 case 'is_browser':
1392 case 'is_mobile':
1393 // A boolean result
1394 $return = ! empty($info[substr($key, 3)]);
1395 break;
1396 case 'languages':
1397 $return = array();
1398 if ( ! empty($_SERVER['HTTP_ACCEPT_LANGUAGE']))
1399 {
1400 if (preg_match_all('/[-a-z]{2,}/', strtolower(trim($_SERVER['HTTP_ACCEPT_LANGUAGE'])), $matches))
1401 {
1402 // Found a result
1403 $return = $matches[0];
1404 }
1405 }
1406 break;
1407 case 'charsets':
1408 $return = array();
1409 if ( ! empty($_SERVER['HTTP_ACCEPT_CHARSET']))
1410 {
1411 if (preg_match_all('/[-a-z0-9]{2,}/', strtolower(trim($_SERVER['HTTP_ACCEPT_CHARSET'])), $matches))
1412 {
1413 // Found a result
1414 $return = $matches[0];
1415 }
1416 }
1417 break;
1418 case 'referrer':
1419 if ( ! empty($_SERVER['HTTP_REFERER']))
1420 {
1421 // Found a result
1422 $return = trim($_SERVER['HTTP_REFERER']);
1423 }
1424 break;
1425 }
1426
1427 // Cache the return value
1428 isset($return) and $info[$key] = $return;
1429 }
1430
1431 if ( ! empty($compare))
1432 {
1433 // The comparison must always be lowercase
1434 $compare = strtolower($compare);
1435
1436 switch ($key)
1437 {
1438 case 'accept_lang':
1439 // Check if the lange is accepted
1440 return in_array($compare, self::user_agent('languages'));
1441 break;
1442 case 'accept_charset':
1443 // Check if the charset is accepted
1444 return in_array($compare, self::user_agent('charsets'));
1445 break;
1446 default:
1447 // Invalid comparison
1448 return FALSE;
1449 break;
1450 }
1451 }
1452
1453 // Return the key, if set
1454 return isset($info[$key]) ? $info[$key] : NULL;
1455 }
1456
1457 /**
1458 * Quick debugging of any variable. Any number of parameters can be set.
1459 *
1460 * @return string
1461 */
1462 public static function debug()
1463 {
1464 if (func_num_args() === 0)
1465 return;
1466
1467 // Get params
1468 $params = func_get_args();
1469 $output = array();
1470
1471 foreach ($params as $var)
1472 {
1473 $output[] = '<pre>('.gettype($var).') '.html::specialchars(print_r($var, TRUE)).'</pre>';
1474 }
1475
1476 return implode("\n", $output);
1477 }
1478
1479 /**
1480 * Displays nice backtrace information.
1481 * @see http://php.net/debug_backtrace
1482 *
1483 * @param array backtrace generated by an exception or debug_backtrace
1484 * @return string
1485 */
1486 public static function backtrace($trace)
1487 {
1488 $arg_badword = array(
1489 'passw', /* password and passwd */
1490 'pwd',
1491 'secret'
1492 );
1493
1494
1495 if ( ! is_array($trace))
1496 return;
1497
1498 // Final output
1499 $output = array();
1500
1501 foreach ($trace as $entry)
1502 {
1503 $temp = '<li>';
1504
1505 if (isset($entry['file']))
1506 {
1507 $temp .= self::lang('core.error_file_line', preg_replace('!^'.preg_quote(DOCROOT).'!', '', $entry['file']), $entry['line']);
1508 }
1509
1510 $temp .= '<pre>';
1511
1512 $reflclass = false;
1513 if (isset($entry['class']))
1514 {
1515 // Add class and call type
1516 $temp .= $entry['class'].$entry['type'];
1517 try {
1518 $reflclass = new ReflectionClass($entry['class']);
1519 } catch( Exception $e ) {
1520 // Don't care about the problem... just don't expand variable names in that case
1521 $reflclass = false;
1522 }
1523 }
1524
1525 // Add function
1526 $temp .= $entry['function'].'( ';
1527
1528 $reflmethod = false;
1529 try {
1530 if( $reflclass )
1531 $reflmethod = $reflclass->getMethod($entry['function']);
1532 else
1533 $reflmethod = new ReflectionFunction($entry['function']);
1534 } catch( Exception $e ) {
1535 // Don't care about the problem... just don't expand variable names in that case
1536 $reflmethod = false;
1537 }
1538 // Add function args
1539 if (isset($entry['args']) AND is_array($entry['args']))
1540 {
1541 // Separator starts as nothing
1542 $sep = '';
1543
1544 $reflargs = false;
1545 try {
1546 if( $reflmethod )
1547 $reflargs = $reflmethod->getParameters();
1548 } catch( Exception $e ) {
1549 // Don't care about the problem... just don't expand variable names in that case
1550 $reflargs = false;
1551 }
1552
1553 while ($arg = array_shift($entry['args']))
1554 {
1555 $argname = "...";
1556 try {
1557 if( !empty($reflargs) )
1558 $argname = array_shift( $reflargs )->getName();
1559 } catch( Exception $e ) {
1560 // Don't care about the problem... just don't expand variable names in that case
1561 $argname = "...";
1562 }
1563
1564 if (is_string($arg) AND substr($arg, 0, 4) !== "unix" AND is_file($arg))
1565 {
1566 // Remove docroot from filename
1567 $arg = preg_replace('!^'.preg_quote(DOCROOT).'!', '', $arg);
1568 }
1569
1570 foreach($arg_badword as $badword) {
1571 if( stripos($argname, $badword) !== false )
1572 $arg = "*****";
1573 }
1574
1575 $temp .= $sep.$argname.' = '.html::specialchars(print_r($arg, TRUE));
1576
1577 // Change separator to a comma
1578 $sep = ', ';
1579 }
1580 }
1581
1582 $temp .= ' )</pre></li>';
1583
1584 $output[] = $temp;
1585 }
1586
1587 return '<ul class="backtrace">'.implode("\n", $output).'</ul>';
1588 }
1589
1590 /**
1591 * Saves the internal caches: configuration, include paths, etc.
1592 *
1593 * @return boolean
1594 */
1595 public static function internal_cache_save()
1596 {
1597 if ( ! is_array(self::$write_cache))
1598 return FALSE;
1599
1600 // Get internal cache names
1601 $caches = array_keys(self::$write_cache);
1602
1603 // Nothing written
1604 $written = FALSE;
1605
1606 foreach ($caches as $cache)
1607 {
1608 if (isset(self::$internal_cache[$cache]))
1609 {
1610 // Write the cache file
1611 self::cache_save($cache, self::$internal_cache[$cache], self::$configuration['core']['internal_cache']);
1612
1613 // A cache has been written
1614 $written = TRUE;
1615 }
1616 }
1617
1618 return $written;
1619 }
1620
1621 } // End Kohana
1622
1623 /**
1624 * Creates a generic i18n exception.
1625 */
1626 class Kohana_Exception extends Exception {
1627
1628 // Template file
1629 protected $template = 'kohana_error_page';
1630
1631 // Header
1632 protected $header = FALSE;
1633
1634 // Error code
1635 protected $code = E_KOHANA;
1636
1637 /**
1638 * Set exception message.
1639 *
1640 * @param string i18n language key for the message
1641 * @param array addition line parameters
1642 */
1643 public function __construct($error)
1644 {
1645 $args = array_slice(func_get_args(), 1);
1646
1647 // Fetch the error message
1648 $message = Kohana::lang($error, $args);
1649
1650 if ($message === $error OR empty($message))
1651 {
1652 // Unable to locate the message for the error
1653 $message = 'Unknown Exception: '.$error;
1654 }
1655
1656 // Sets $this->message the proper way
1657 parent::__construct($message);
1658 }
1659
1660 /**
1661 * Magic method for converting an object to a string.
1662 *
1663 * @return string i18n message
1664 */
1665 public function __toString()
1666 {
1667 return (string) $this->message;
1668 }
1669
1670 /**
1671 * Fetch the template name.
1672 *
1673 * @return string
1674 */
1675 public function getTemplate()
1676 {
1677 return $this->template;
1678 }
1679
1680 /**
1681 * Sends an Internal Server Error header.
1682 *
1683 * @return void
1684 */
1685 public function sendHeaders()
1686 {
1687 // Send the 500 header
1688 header('HTTP/1.1 500 Internal Server Error');
1689 }
1690
1691 } // End Kohana Exception
1692
1693 /**
1694 * Creates a custom exception.
1695 */
1696 class Kohana_User_Exception extends Kohana_Exception {
1697
1698 /**
1699 * Set exception title and message.
1700 *
1701 * @param string exception title string
1702 * @param string exception message string
1703 * @param string custom error template
1704 */
1705 public function __construct($title, $message, $template = FALSE)
1706 {
1707 Exception::__construct($message);
1708
1709 $this->code = $title;
1710
1711 if ($template !== FALSE)
1712 {
1713 $this->template = $template;
1714 }
1715 }
1716
1717 } // End Kohana PHP Exception
1718
1719 /**
1720 * Creates a Page Not Found exception.
1721 */
1722 class Kohana_404_Exception extends Kohana_Exception {
1723
1724 protected $code = E_PAGE_NOT_FOUND;
1725
1726 /**
1727 * Set internal properties.
1728 *
1729 * @param string URL of page
1730 * @param string custom error template
1731 */
1732 public function __construct($page = FALSE, $template = FALSE)
1733 {
1734 if ($page === FALSE)
1735 {
1736 // Construct the page URI using Router properties
1737 $page = Router::$current_uri.Router::$url_suffix.Router::$query_string;
1738 }
1739
1740 Exception::__construct(Kohana::lang('core.page_not_found', $page));
1741
1742 $this->template = $template;
1743 }
1744
1745 /**
1746 * Sends "File Not Found" headers, to emulate server behavior.
1747 *
1748 * @return void
1749 */
1750 public function sendHeaders()
1751 {
1752 // Send the 404 header
1753 header('HTTP/1.1 404 File Not Found');
1754 }
1755
1756 } // End Kohana 404 Exception
This is an effort to rewrite the Nagios GUI in PHP. It uses the Kohana framework to do much of the heavy lifting.