summaryrefslogtreecommitdiff
path: root/system/core
diff options
context:
space:
mode:
Diffstat (limited to 'system/core')
-rw-r--r--system/core/Benchmark.php126
-rw-r--r--system/core/Event.php231
-rw-r--r--system/core/Kohana.php1118
-rw-r--r--system/core/Kohana_Config.php329
-rw-r--r--system/core/Kohana_Exception.php622
5 files changed, 2426 insertions, 0 deletions
diff --git a/system/core/Benchmark.php b/system/core/Benchmark.php
new file mode 100644
index 0000000..79fadb6
--- /dev/null
+++ b/system/core/Benchmark.php
@@ -0,0 +1,126 @@
+<?php defined('SYSPATH') OR die('No direct access allowed.');
+/**
+ * Simple benchmarking.
+ *
+ * @package Kohana
+ * @author Kohana Team
+ * @copyright (c) 2007-2009 Kohana Team
+ * @license http://kohanaphp.com/license
+ */
+final class Benchmark {
+
+ // Benchmark timestamps
+ private static $marks;
+
+ /**
+ * Set a benchmark start point.
+ *
+ * @param string benchmark name
+ * @return void
+ */
+ public static function start($name)
+ {
+ if (isset(self::$marks[$name]) AND self::$marks[$name][0]['stop'] === FALSE)
+ throw new Kohana_Exception('A benchmark named :name is already running.', array(':name' => $name));
+
+ if ( ! isset(self::$marks[$name]))
+ {
+ self::$marks[$name] = array();
+ }
+
+ $mark = array
+ (
+ 'start' => microtime(TRUE),
+ 'stop' => FALSE,
+ 'memory_start' => self::memory_usage(),
+ 'memory_stop' => FALSE
+ );
+
+ array_unshift(self::$marks[$name], $mark);
+ }
+
+ /**
+ * Set a benchmark stop point.
+ *
+ * @param string benchmark name
+ * @return void
+ */
+ public static function stop($name)
+ {
+ if (isset(self::$marks[$name]) AND self::$marks[$name][0]['stop'] === FALSE)
+ {
+ self::$marks[$name][0]['stop'] = microtime(TRUE);
+ self::$marks[$name][0]['memory_stop'] = self::memory_usage();
+ }
+ }
+
+ /**
+ * Get the elapsed time between a start and stop.
+ *
+ * @param string benchmark name, TRUE for all
+ * @param integer number of decimal places to count to
+ * @return array
+ */
+ public static function get($name, $decimals = 4)
+ {
+ if ($name === TRUE)
+ {
+ $times = array();
+ $names = array_keys(self::$marks);
+
+ foreach ($names as $name)
+ {
+ // Get each mark recursively
+ $times[$name] = self::get($name, $decimals);
+ }
+
+ // Return the array
+ return $times;
+ }
+
+ if ( ! isset(self::$marks[$name]))
+ return FALSE;
+
+ if (self::$marks[$name][0]['stop'] === FALSE)
+ {
+ // Stop the benchmark to prevent mis-matched results
+ self::stop($name);
+ }
+
+ // Return a string version of the time between the start and stop points
+ // Properly reading a float requires using number_format or sprintf
+ $time = $memory = 0;
+ for ($i = 0; $i < count(self::$marks[$name]); $i++)
+ {
+ $time += self::$marks[$name][$i]['stop'] - self::$marks[$name][$i]['start'];
+ $memory += self::$marks[$name][$i]['memory_stop'] - self::$marks[$name][$i]['memory_start'];
+ }
+
+ return array
+ (
+ 'time' => number_format($time, $decimals),
+ 'memory' => $memory,
+ 'count' => count(self::$marks[$name])
+ );
+ }
+
+ /**
+ * Returns the current memory usage. This is only possible if the
+ * memory_get_usage function is supported in PHP.
+ *
+ * @return integer
+ */
+ private static function memory_usage()
+ {
+ static $func;
+
+ if ($func === NULL)
+ {
+ // Test if memory usage can be seen
+ $func = function_exists('memory_get_usage');
+ }
+
+ return $func ? memory_get_usage() : 0;
+ }
+
+} // End Benchmark
diff --git a/system/core/Event.php b/system/core/Event.php
new file mode 100644
index 0000000..ab839f4
--- /dev/null
+++ b/system/core/Event.php
@@ -0,0 +1,231 @@
+<?php defined('SYSPATH') OR die('No direct access allowed.');
+/**
+ * Process queuing/execution class. Allows an unlimited number of callbacks
+ * to be added to 'events'. Events can be run multiple times, and can also
+ * process event-specific data. By default, Kohana has several system events.
+ *
+ * @package Kohana
+ * @author Kohana Team
+ * @copyright (c) 2007-2009 Kohana Team
+ * @license http://kohanaphp.com/license
+ * @link http://docs.kohanaphp.com/general/events
+ */
+abstract class Event_Core {
+
+ // Event callbacks
+ protected static $events = array();
+
+ // Cache of events that have been run
+ protected static $has_run = array();
+
+ // Data that can be processed during events
+ public static $data;
+
+ /**
+ * Add a callback to an event queue.
+ *
+ * @param string event name
+ * @param array http://php.net/callback
+ * @param boolean prevent duplicates
+ * @return boolean
+ */
+ public static function add($name, $callback, $unique = FALSE)
+ {
+ if ( ! isset(Event::$events[$name]))
+ {
+ // Create an empty event if it is not yet defined
+ Event::$events[$name] = array();
+ }
+ elseif ($unique AND in_array($callback, Event::$events[$name], TRUE))
+ {
+ // The event already exists
+ return FALSE;
+ }
+
+ // Add the event
+ Event::$events[$name][] = $callback;
+
+ return TRUE;
+ }
+
+ /**
+ * Add a callback to an event queue, before a given event.
+ *
+ * @param string event name
+ * @param array existing event callback
+ * @param array event callback
+ * @return boolean
+ */
+ public static function add_before($name, $existing, $callback)
+ {
+ if (empty(Event::$events[$name]) OR ($key = array_search($existing, Event::$events[$name])) === FALSE)
+ {
+ // Just add the event if there are no events
+ return Event::add($name, $callback);
+ }
+ else
+ {
+ // Insert the event immediately before the existing event
+ return Event::insert_event($name, $key, $callback);
+ }
+ }
+
+ /**
+ * Add a callback to an event queue, after a given event.
+ *
+ * @param string event name
+ * @param array existing event callback
+ * @param array event callback
+ * @return boolean
+ */
+ public static function add_after($name, $existing, $callback)
+ {
+ if (empty(Event::$events[$name]) OR ($key = array_search($existing, Event::$events[$name])) === FALSE)
+ {
+ // Just add the event if there are no events
+ return Event::add($name, $callback);
+ }
+ else
+ {
+ // Insert the event immediately after the existing event
+ return Event::insert_event($name, $key + 1, $callback);
+ }
+ }
+
+ /**
+ * Inserts a new event at a specfic key location.
+ *
+ * @param string event name
+ * @param integer key to insert new event at
+ * @param array event callback
+ * @return void
+ */
+ private static function insert_event($name, $key, $callback)
+ {
+ if (in_array($callback, Event::$events[$name], TRUE))
+ return FALSE;
+
+ // Add the new event at the given key location
+ Event::$events[$name] = array_merge
+ (
+ // Events before the key
+ array_slice(Event::$events[$name], 0, $key),
+ // New event callback
+ array($callback),
+ // Events after the key
+ array_slice(Event::$events[$name], $key)
+ );
+
+ return TRUE;
+ }
+
+ /**
+ * Replaces an event with another event.
+ *
+ * @param string event name
+ * @param array event to replace
+ * @param array new callback
+ * @return boolean
+ */
+ public static function replace($name, $existing, $callback)
+ {
+ if (empty(Event::$events[$name]) OR ($key = array_search($existing, Event::$events[$name], TRUE)) === FALSE)
+ return FALSE;
+
+ if ( ! in_array($callback, Event::$events[$name], TRUE))
+ {
+ // Replace the exisiting event with the new event
+ Event::$events[$name][$key] = $callback;
+ }
+ else
+ {
+ // Remove the existing event from the queue
+ unset(Event::$events[$name][$key]);
+
+ // Reset the array so the keys are ordered properly
+ Event::$events[$name] = array_values(Event::$events[$name]);
+ }
+
+ return TRUE;
+ }
+
+ /**
+ * Get all callbacks for an event.
+ *
+ * @param string event name
+ * @return array
+ */
+ public static function get($name)
+ {
+ return empty(Event::$events[$name]) ? array() : Event::$events[$name];
+ }
+
+ /**
+ * Clear some or all callbacks from an event.
+ *
+ * @param string event name
+ * @param array specific callback to remove, FALSE for all callbacks
+ * @return void
+ */
+ public static function clear($name, $callback = FALSE)
+ {
+ if ($callback === FALSE)
+ {
+ Event::$events[$name] = array();
+ }
+ elseif (isset(Event::$events[$name]))
+ {
+ // Loop through each of the event callbacks and compare it to the
+ // callback requested for removal. The callback is removed if it
+ // matches.
+ foreach (Event::$events[$name] as $i => $event_callback)
+ {
+ if ($callback === $event_callback)
+ {
+ unset(Event::$events[$name][$i]);
+ }
+ }
+ }
+ }
+
+ /**
+ * Execute all of the callbacks attached to an event.
+ *
+ * @param string event name
+ * @param array data can be processed as Event::$data by the callbacks
+ * @return void
+ */
+ public static function run($name, & $data = NULL)
+ {
+ if ( ! empty(Event::$events[$name]))
+ {
+ // So callbacks can access Event::$data
+ Event::$data =& $data;
+ $callbacks = Event::get($name);
+
+ foreach ($callbacks as $callback)
+ {
+ call_user_func_array($callback, array(&$data));
+ }
+
+ // Do this to prevent data from getting 'stuck'
+ $clear_data = '';
+ Event::$data =& $clear_data;
+ }
+
+ // The event has been run!
+ Event::$has_run[$name] = $name;
+ }
+
+ /**
+ * Check if a given event has been run.
+ *
+ * @param string event name
+ * @return boolean
+ */
+ public static function has_run($name)
+ {
+ return isset(Event::$has_run[$name]);
+ }
+
+} // End Event \ No newline at end of file
diff --git a/system/core/Kohana.php b/system/core/Kohana.php
new file mode 100644
index 0000000..96d969e
--- /dev/null
+++ b/system/core/Kohana.php
@@ -0,0 +1,1118 @@
+<?php defined('SYSPATH') OR die('No direct access allowed.');
+/**
+ * Provides Kohana-specific helper functions. This is where the magic happens!
+ *
+ * @package Kohana
+ * @author Kohana Team
+ * @copyright (c) 2007-2009 Kohana Team
+ * @license http://kohanaphp.com/license
+ */
+
+// Test of Kohana is running in Windows
+define('KOHANA_IS_WIN', DIRECTORY_SEPARATOR === '\\');
+
+abstract class Kohana_Core {
+
+ const VERSION = '2.4';
+ const CODENAME = 'no_codename';
+ const CHARSET = 'UTF-8';
+ const LOCALE = 'en_US';
+
+ // The singleton instance of the controller
+ public static $instance;
+
+ // Output buffering level
+ protected static $buffer_level;
+
+ // The final output that will displayed by Kohana
+ public static $output = '';
+
+ // The current locale
+ public static $locale;
+
+ // Include paths
+ protected static $include_paths;
+ protected static $include_paths_hash = '';
+
+ // Cache lifetime
+ protected static $cache_lifetime;
+
+ // Internal caches and write status
+ protected static $internal_cache = array();
+ protected static $write_cache;
+ protected static $internal_cache_path;
+ protected static $internal_cache_key;
+ protected static $internal_cache_encrypt;
+
+ // Server API that PHP is using. Allows testing of different APIs.
+ public static $server_api = PHP_SAPI;
+
+ /**
+ * Sets up the PHP environment. Adds error/exception handling, output
+ * buffering, and adds an auto-loading method for loading classes.
+ *
+ * This method is run immediately when this file is loaded, and is
+ * benchmarked as environment_setup.
+ *
+ * For security, this function also destroys the $_REQUEST global variable.
+ * Using the proper global (GET, POST, COOKIE, etc) is inherently more secure.
+ * The recommended way to fetch a global variable is using the Input library.
+ * @see http://www.php.net/globals
+ *
+ * @return void
+ */
+ public static function setup()
+ {
+ static $run;
+
+ // Only run this function once
+ if ($run === TRUE)
+ return;
+
+ $run = TRUE;
+
+ // Start the environment setup benchmark
+ Benchmark::start(SYSTEM_BENCHMARK.'_environment_setup');
+
+ // Define Kohana error constant
+ define('E_KOHANA', 42);
+
+ // Define 404 error constant
+ define('E_PAGE_NOT_FOUND', 43);
+
+ // Define database error constant
+ define('E_DATABASE_ERROR', 44);
+
+ // Set the default charset for mb_* functions
+ mb_internal_encoding(Kohana::CHARSET);
+
+ if (Kohana_Config::instance()->loaded() === FALSE)
+ {
+ // Re-parse the include paths
+ Kohana::include_paths(TRUE);
+ }
+
+ if (Kohana::$cache_lifetime = Kohana::config('core.internal_cache'))
+ {
+ // Are we using encryption for caches?
+ Kohana::$internal_cache_encrypt = Kohana::config('core.internal_cache_encrypt');
+
+ if(Kohana::$internal_cache_encrypt===TRUE)
+ {
+ Kohana::$internal_cache_key = Kohana::config('core.internal_cache_key');
+
+ // Be sure the key is of acceptable length for the mcrypt algorithm used
+ Kohana::$internal_cache_key = substr(Kohana::$internal_cache_key, 0, 24);
+ }
+
+ // Set the directory to be used for the internal cache
+ if ( ! Kohana::$internal_cache_path = Kohana::config('core.internal_cache_path'))
+ {
+ Kohana::$internal_cache_path = APPPATH.'cache/';
+ }
+
+ // Load cached configuration and language files
+ Kohana::$internal_cache['configuration'] = Kohana::cache('configuration', Kohana::$cache_lifetime);
+ Kohana::$internal_cache['language'] = Kohana::cache('language', Kohana::$cache_lifetime);
+
+ // Load cached file paths
+ Kohana::$internal_cache['find_file_paths'] = Kohana::cache('find_file_paths', Kohana::$cache_lifetime);
+
+ // Enable cache saving
+ Event::add('system.shutdown', array('Kohana', 'internal_cache_save'));
+ }
+
+ // Start output buffering
+ ob_start(array('Kohana', 'output_buffer'));
+
+ // Save buffering level
+ Kohana::$buffer_level = ob_get_level();
+
+ // Set autoloader
+ spl_autoload_register(array('Kohana', 'auto_load'));
+
+ // Register a shutdown function to handle system.shutdown events
+ register_shutdown_function(array('Kohana', 'shutdown'));
+
+ // Send default text/html UTF-8 header
+ header('Content-Type: text/html; charset='.Kohana::CHARSET);
+
+ // Load i18n
+ new I18n;
+
+ // Enable exception handling
+ Kohana_Exception::enable();
+
+ // Enable error handling
+ Kohana_PHP_Exception::enable();
+
+ // Load locales
+ $locales = Kohana::config('locale.language');
+
+ // Make first locale the defined Kohana charset
+ $locales[0] .= '.'.Kohana::CHARSET;
+
+ // Set locale information
+ Kohana::$locale = setlocale(LC_ALL, $locales);
+
+ // Default to the default locale when none of the user defined ones where accepted
+ Kohana::$locale = ! Kohana::$locale ? Kohana::LOCALE.'.'.Kohana::CHARSET : Kohana::$locale;
+
+ // Set locale for the I18n system
+ I18n::set_locale(Kohana::$locale);
+
+ // Set and validate the timezone
+ date_default_timezone_set(Kohana::config('locale.timezone'));
+
+ // register_globals is enabled
+ if (ini_get('register_globals'))
+ {
+ if (isset($_REQUEST['GLOBALS']))
+ {
+ // Prevent GLOBALS override attacks
+ exit('Global variable overload attack.');
+ }
+
+ // Destroy the REQUEST global
+ $_REQUEST = array();
+
+ // These globals are standard and should not be removed
+ $preserve = array('GLOBALS', '_REQUEST', '_GET', '_POST', '_FILES', '_COOKIE', '_SERVER', '_ENV', '_SESSION');
+
+ // This loop has the same effect as disabling register_globals
+ foreach (array_diff(array_keys($GLOBALS), $preserve) as $key)
+ {
+ global $$key;
+ $$key = NULL;
+
+ // Unset the global variable
+ unset($GLOBALS[$key], $$key);
+ }
+
+ // Warn the developer about register globals
+ Kohana_Log::add('debug', 'Disable register_globals! It is evil and deprecated: http://php.net/register_globals');
+ }
+
+ // Enable Kohana routing
+ Event::add('system.routing', array('Router', 'find_uri'));
+ Event::add('system.routing', array('Router', 'setup'));
+
+ // Enable Kohana controller initialization
+ Event::add('system.execute', array('Kohana', 'instance'));
+
+ // Enable Kohana 404 pages
+ Event::add('system.404', array('Kohana_404_Exception', 'trigger'));
+
+ if (Kohana::config('core.enable_hooks') === TRUE)
+ {
+ // Find all the hook files
+ $hooks = Kohana::list_files('hooks', TRUE);
+
+ foreach ($hooks as $file)
+ {
+ // Load the hook
+ include $file;
+ }
+ }
+
+ // Stop the environment setup routine
+ Benchmark::stop(SYSTEM_BENCHMARK.'_environment_setup');
+ }
+
+ /**
+ * Cleans up the PHP environment. Disables error/exception handling and the
+ * auto-loading method and closes the output buffer.
+ *
+ * This method does not need to be called during normal system execution,
+ * however in some advanced situations it can be helpful. @see #1781
+ *
+ * @return void
+ */
+ public static function cleanup()
+ {
+ static $run;
+
+ // Only run this function once
+ if ($run === TRUE)
+ return;
+
+ $run = TRUE;
+
+ Kohana_Exception::disable();
+
+ Kohana_PHP_Exception::disable();
+
+ spl_autoload_unregister(array('Kohana', 'auto_load'));
+
+ Kohana::close_buffers();
+ }
+
+ /**
+ * Loads the controller and initializes it. Runs the pre_controller,
+ * post_controller_constructor, and post_controller events. Triggers
+ * a system.404 event when the route cannot be mapped to a controller.
+ *
+ * This method is benchmarked as controller_setup and controller_execution.
+ *
+ * @return object instance of controller
+ */
+ public static function & instance()
+ {
+ if (Kohana::$instance === NULL)
+ {
+ Benchmark::start(SYSTEM_BENCHMARK.'_controller_setup');
+
+ // Include the Controller file
+ require_once Router::$controller_path;
+
+ try
+ {
+ // Start validation of the controller
+ $class = new ReflectionClass(ucfirst(Router::$controller).'_Controller');
+ }
+ catch (ReflectionException $e)
+ {
+ // Controller does not exist
+ Event::run('system.404');
+ }
+
+ if ($class->isAbstract() OR (IN_PRODUCTION AND $class->getConstant('ALLOW_PRODUCTION') == FALSE))
+ {
+ // Controller is not allowed to run in production
+ Event::run('system.404');
+ }
+
+ // Run system.pre_controller
+ Event::run('system.pre_controller');
+
+ // Create a new controller instance
+ $controller = $class->newInstance();
+
+ // Controller constructor has been executed
+ Event::run('system.post_controller_constructor');
+
+ try
+ {
+ // Load the controller method
+ $method = $class->getMethod(Router::$method);
+
+ // Method exists
+ if (Router::$method[0] === '_')
+ {
+ // Do not allow access to hidden methods
+ Event::run('system.404');
+ }
+
+ if ($method->isProtected() or $method->isPrivate())
+ {
+ // Do not attempt to invoke protected methods
+ throw new ReflectionException('protected controller method');
+ }
+
+ // Default arguments
+ $arguments = Router::$arguments;
+ }
+ catch (ReflectionException $e)
+ {
+ // Use __call instead
+ $method = $class->getMethod('__call');
+
+ // Use arguments in __call format
+ $arguments = array(Router::$method, Router::$arguments);
+ }
+
+ // Stop the controller setup benchmark
+ Benchmark::stop(SYSTEM_BENCHMARK.'_controller_setup');
+
+ // Start the controller execution benchmark
+ Benchmark::start(SYSTEM_BENCHMARK.'_controller_execution');
+
+ // Execute the controller method
+ $method->invokeArgs($controller, $arguments);
+
+ // Controller method has been executed
+ Event::run('system.post_controller');
+
+ // Stop the controller execution benchmark
+ Benchmark::stop(SYSTEM_BENCHMARK.'_controller_execution');
+ }
+
+ return Kohana::$instance;
+ }
+
+ /**
+ * Get all include paths. APPPATH is the first path, followed by module
+ * paths in the order they are configured, follow by the SYSPATH.
+ *
+ * @param boolean re-process the include paths
+ * @return array
+ */
+ public static function include_paths($process = FALSE)
+ {
+ if ($process === TRUE)
+ {
+ // Add APPPATH as the first path
+ Kohana::$include_paths = array(APPPATH);
+
+ foreach (Kohana::config('core.modules') as $path)
+ {
+ if ($path = str_replace('\\', '/', realpath($path)))
+ {
+ // Add a valid path
+ Kohana::$include_paths[] = $path.'/';
+ }
+ }
+
+ // Add SYSPATH as the last path
+ Kohana::$include_paths[] = SYSPATH;
+
+ Kohana::$include_paths_hash = md5(serialize(Kohana::$include_paths));
+ }
+
+ return Kohana::$include_paths;
+ }
+
+ /**
+ * Get a config item or group proxies Kohana_Config.
+ *
+ * @param string item name
+ * @param boolean force a forward slash (/) at the end of the item
+ * @param boolean is the item required?
+ * @return mixed
+ */
+ public static function config($key, $slash = FALSE, $required = FALSE)
+ {
+ return Kohana_Config::instance()->get($key,$slash,$required);
+ }
+
+ /**
+ * Load data from a simple cache file. This should only be used internally,
+ * and is NOT a replacement for the Cache library.
+ *
+ * @param string unique name of cache
+ * @param integer expiration in seconds
+ * @return mixed
+ */
+ public static function cache($name, $lifetime)
+ {
+ if ($lifetime > 0)
+ {
+ $path = Kohana::$internal_cache_path.'kohana_'.$name;
+
+ if (is_file($path))
+ {
+ // Check the file modification time
+ if ((time() - filemtime($path)) < $lifetime)
+ {
+ // Cache is valid! Now, do we need to decrypt it?
+ if(Kohana::$internal_cache_encrypt===TRUE)
+ {
+ $data = file_get_contents($path);
+
+ $iv_size = mcrypt_get_iv_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_ECB);
+ $iv = mcrypt_create_iv($iv_size, MCRYPT_RAND);
+
+ $decrypted_text = mcrypt_decrypt(MCRYPT_RIJNDAEL_256, Kohana::$internal_cache_key, $data, MCRYPT_MODE_ECB, $iv);
+
+ $cache = unserialize($decrypted_text);
+
+ // If the key changed, delete the cache file
+ if(!$cache)
+ unlink($path);
+
+ // If cache is false (as above) return NULL, otherwise, return the cache
+ return ($cache ? $cache : NULL);
+ }
+ else
+ {
+ return unserialize(file_get_contents($path));
+ }
+ }
+ else
+ {
+ // Cache is invalid, delete it
+ unlink($path);
+ }
+ }
+ }
+
+ // No cache found
+ return NULL;
+ }
+
+ /**
+ * Save data to a simple cache file. This should only be used internally, and
+ * is NOT a replacement for the Cache library.
+ *
+ * @param string cache name
+ * @param mixed data to cache
+ * @param integer expiration in seconds
+ * @return boolean
+ */
+ public static function cache_save($name, $data, $lifetime)
+ {
+ if ($lifetime < 1)
+ return FALSE;
+
+ $path = Kohana::$internal_cache_path.'kohana_'.$name;
+
+ if ($data === NULL)
+ {
+ // Delete cache
+ return (is_file($path) and unlink($path));
+ }
+ else
+ {
+ // Using encryption? Encrypt the data when we write it
+ if(Kohana::$internal_cache_encrypt===TRUE)
+ {
+ // Encrypt and write data to cache file
+ $iv_size = mcrypt_get_iv_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_ECB);
+ $iv = mcrypt_create_iv($iv_size, MCRYPT_RAND);
+
+ // Serialize and encrypt!
+ $encrypted_text = mcrypt_encrypt(MCRYPT_RIJNDAEL_256, Kohana::$internal_cache_key, serialize($data), MCRYPT_MODE_ECB, $iv);
+
+ return (bool) file_put_contents($path, $encrypted_text);
+ }
+ else
+ {
+ // Write data to cache file
+ return (bool) file_put_contents($path, serialize($data));
+ }
+ }
+ }
+
+ /**
+ * Kohana output handler. Called during ob_clean, ob_flush, and their variants.
+ *
+ * @param string current output buffer
+ * @return string
+ */
+ public static function output_buffer($output)
+ {
+ // Could be flushing, so send headers first
+ if ( ! Event::has_run('system.send_headers'))
+ {
+ // Run the send_headers event
+ Event::run('system.send_headers');
+ }
+
+ // Set final output
+ Kohana::$output = $output;
+
+ // Set and return the final output
+ return Kohana::$output;
+ }
+
+ /**
+ * Closes all open output buffers, either by flushing or cleaning, and stores
+ * output buffer for display during shutdown.
+ *
+ * @param boolean disable to clear buffers, rather than flushing
+ * @return void
+ */
+ public static function close_buffers($flush = TRUE)
+ {
+ if (ob_get_level() >= Kohana::$buffer_level)
+ {
+ // Set the close function
+ $close = ($flush === TRUE) ? 'ob_end_flush' : 'ob_end_clean';
+
+ while (ob_get_level() > Kohana::$buffer_level)
+ {
+ // Flush or clean the buffer
+ $close();
+ }
+
+ // Store the Kohana output buffer. Apparently there was a change in PHP
+ // 5.4 such that if you call this you wind up with a blank page.
+ // Disabling it for now. See ticket #1839
+ if (version_compare(PHP_VERSION, "5.4", "<")) {
+ ob_end_clean();
+ }
+ }
+ }
+
+ /**
+ * Triggers the shutdown of Kohana by closing the output buffer, runs the system.display event.
+ *
+ * @return void
+ */
+ public static function shutdown()
+ {
+ static $run;
+
+ // Only run this function once
+ if ($run === TRUE)
+ return;
+
+ $run = TRUE;
+
+ // Run system.shutdown event
+ Event::run('system.shutdown');
+
+ // Close output buffers
+ Kohana::close_buffers(TRUE);
+
+ // Run the output event
+ Event::run('system.display', Kohana::$output);
+
+ // Render the final output
+ Kohana::render(Kohana::$output);
+ }
+
+ /**
+ * Inserts global Kohana variables into the generated output and prints it.
+ *
+ * @param string final output that will displayed
+ * @return void
+ */
+ public static function render($output)
+ {
+ if (Kohana::config('core.render_stats') === TRUE)
+ {
+ // Fetch memory usage in MB
+ $memory = function_exists('memory_get_usage') ? (memory_get_usage() / 1024 / 1024) : 0;
+
+ // Fetch benchmark for page execution time
+ $benchmark = Benchmark::get(SYSTEM_BENCHMARK.'_total_execution');
+
+ // Replace the global template variables
+ $output = str_replace(
+ array
+ (
+ '{kohana_version}',
+ '{kohana_codename}',
+ '{execution_time}',
+ '{memory_usage}',
+ '{included_files}',
+ ),
+ array
+ (
+ KOHANA::VERSION,
+ KOHANA::CODENAME,
+ $benchmark['time'],
+ number_format($memory, 2).'MB',
+ count(get_included_files()),
+ ),
+ $output
+ );
+ }
+
+ if ($level = Kohana::config('core.output_compression') AND ini_get('output_handler') !== 'ob_gzhandler' AND (int) ini_get('zlib.output_compression') === 0)
+ {
+ if ($compress = request::preferred_encoding(array('gzip','deflate'), TRUE))
+ {
+ if ($level < 1 OR $level > 9)
+ {
+ // Normalize the level to be an integer between 1 and 9. This
+ // step must be done to prevent gzencode from triggering an error
+ $level = max(1, min($level, 9));
+ }
+
+ if ($compress === 'gzip')
+ {
+ // Compress output using gzip
+ $output = gzencode($output, $level);
+ }
+ elseif ($compress === 'deflate')
+ {
+ // Compress output using zlib (HTTP deflate)
+ $output = gzdeflate($output, $level);
+ }
+
+ // This header must be sent with compressed content to prevent
+ // browser caches from breaking
+ header('Vary: Accept-Encoding');
+
+ // Send the content encoding header
+ header('Content-Encoding: '.$compress);
+
+ // Sending Content-Length in CGI can result in unexpected behavior
+ if (stripos(Kohana::$server_api, 'cgi') === FALSE)
+ {
+ header('Content-Length: '.strlen($output));
+ }
+ }
+ }
+
+ echo $output;
+ }
+
+ /**
+ * Provides class auto-loading.
+ *
+ * @throws Kohana_Exception
+ * @param string name of class
+ * @return bool
+ */
+ public static function auto_load($class)
+ {
+ if (class_exists($class, FALSE) OR interface_exists($class, FALSE))
+ return TRUE;
+
+ if (($suffix = strrpos($class, '_')) > 0)
+ {
+ // Find the class suffix
+ $suffix = substr($class, $suffix + 1);
+ }
+ else
+ {
+ // No suffix
+ $suffix = FALSE;
+ }
+
+ if ($suffix === 'Core')
+ {
+ $type = 'libraries';
+ $file = substr($class, 0, -5);
+ }
+ elseif ($suffix === 'Controller')
+ {
+ $type = 'controllers';
+ // Lowercase filename
+ $file = strtolower(substr($class, 0, -11));
+ }
+ elseif ($suffix === 'Model')
+ {
+ $type = 'models';
+ // Lowercase filename
+ $file = strtolower(substr($class, 0, -6));
+ }
+ elseif ($suffix === 'Driver')
+ {
+ $type = 'libraries/drivers';
+ $file = str_replace('_', '/', substr($class, 0, -7));
+ }
+ else
+ {
+ // This could be either a library or a helper, but libraries must
+ // always be capitalized, so we check if the first character is
+ // uppercase. If it is, we are loading a library, not a helper.
+ $type = ($class[0] < 'a') ? 'libraries' : 'helpers';
+ $file = $class;
+ }
+
+ if ($filename = Kohana::find_file($type, $file))
+ {
+ // Load the class
+ require $filename;
+ }
+ else
+ {
+ // The class could not be found
+ return FALSE;
+ }
+
+ if ($filename = Kohana::find_file($type, Kohana::config('core.extension_prefix').$class))
+ {
+ // Load the class extension
+ require $filename;
+ }
+ elseif ($suffix !== 'Core' AND class_exists($class.'_Core', FALSE))
+ {
+ // Class extension to be evaluated
+ $extension = 'class '.$class.' extends '.$class.'_Core { }';
+
+ // Start class analysis
+ $core = new ReflectionClass($class.'_Core');
+
+ if ($core->isAbstract())
+ {
+ // Make the extension abstract
+ $extension = 'abstract '.$extension;
+ }
+
+ // Transparent class extensions are handled using eval. This is
+ // a disgusting hack, but it gets the job done.
+ eval($extension);
+ }
+
+ return TRUE;
+ }
+
+ /**
+ * Find a resource file in a given directory. Files will be located according
+ * to the order of the include paths. Configuration and i18n files will be
+ * returned in reverse order.
+ *
+ * @throws Kohana_Exception if file is required and not found
+ * @param string directory to search in
+ * @param string filename to look for (without extension)
+ * @param boolean file required
+ * @param string file extension
+ * @return array if the type is config, i18n or l10n
+ * @return string if the file is found
+ * @return FALSE if the file is not found
+ */
+ public static function find_file($directory, $filename, $required = FALSE, $ext = FALSE)
+ {
+ // NOTE: This test MUST be not be a strict comparison (===), or empty
+ // extensions will be allowed!
+ if ($ext == '')
+ {
+ // Use the default extension
+ $ext = EXT;
+ }
+ else
+ {
+ // Add a period before the extension
+ $ext = '.'.$ext;
+ }
+
+ // Search path
+ $search = $directory.'/'.$filename.$ext;
+
+ if (isset(Kohana::$internal_cache['find_file_paths'][Kohana::$include_paths_hash][$search]))
+ return Kohana::$internal_cache['find_file_paths'][Kohana::$include_paths_hash][$search];
+
+ // Load include paths
+ $paths = Kohana::$include_paths;
+
+ // Nothing found, yet
+ $found = NULL;
+
+ if ($directory === 'config' OR $directory === 'messages' OR $directory === 'i18n')
+ {
+ // Search in reverse, for merging
+ $paths = array_reverse($paths);
+
+ foreach ($paths as $path)
+ {
+ if (is_file($path.$search))
+ {
+ // A matching file has been found
+ $found[] = $path.$search;
+ }
+ }
+ }
+ else
+ {
+ foreach ($paths as $path)
+ {
+ if (is_file($path.$search))
+ {
+ // A matching file has been found
+ $found = $path.$search;
+
+ // Stop searching
+ break;
+ }
+ }
+ }
+
+ if ($found === NULL)
+ {
+ if ($required === TRUE)
+ {
+ // If the file is required, throw an exception
+ throw new Kohana_Exception('The requested :resource:, :file:, could not be found', array(':resource:' => __($directory), ':file:' =>$filename));
+ }
+ else
+ {
+ // Nothing was found, return FALSE
+ $found = FALSE;
+ }
+ }
+
+ if ( ! isset(Kohana::$write_cache['find_file_paths']))
+ {
+ // Write cache at shutdown
+ Kohana::$write_cache['find_file_paths'] = TRUE;
+ }
+
+ return Kohana::$internal_cache['find_file_paths'][Kohana::$include_paths_hash][$search] = $found;
+ }
+
+ /**
+ * Lists all files and directories in a resource path.
+ *
+ * @param string directory to search
+ * @param boolean list all files to the maximum depth?
+ * @param string list all files having extension $ext
+ * @param string full path to search (used for recursion, *never* set this manually)
+ * @return array filenames and directories
+ */
+ public static function list_files($directory, $recursive = FALSE, $ext = EXT, $path = FALSE)
+ {
+ $files = array();
+
+ if ($path === FALSE)
+ {
+ $paths = array_reverse(Kohana::include_paths());
+
+ foreach ($paths as $path)
+ {
+ // Recursively get and merge all files
+ $files = array_merge($files, Kohana::list_files($directory, $recursive, $ext, $path.$directory));
+ }
+ }
+ else
+ {
+ $path = rtrim($path, '/').'/';
+
+ if (is_readable($path) AND $items = glob($path.'*'))
+ {
+ $ext_pos = 0 - strlen($ext);
+
+ foreach ($items as $index => $item)
+ {
+ $item = str_replace('\\', '/', $item);
+
+ if (is_dir($item))
+ {
+ // Handle recursion
+ if ($recursive === TRUE)
+ {
+ // Filename should only be the basename
+ $item = pathinfo($item, PATHINFO_BASENAME);
+
+ // Append sub-directory search
+ $files = array_merge($files, Kohana::list_files($directory, TRUE, $ext, $path.$item));
+ }
+ }
+ else
+ {
+ // File extension must match
+ if ($ext_pos === 0 OR substr($item, $ext_pos) === $ext)
+ {
+ $files[] = $item;
+ }
+ }
+ }
+ }
+ }
+
+ return $files;
+ }
+
+
+ /**
+ * Fetch a message item.
+ *
+ * @param string language key to fetch
+ * @param array additional information to insert into the line
+ * @return string i18n language string, or the requested key if the i18n item is not found
+ */
+ public static function message($key, $args = array())
+ {
+ // Extract the main group from the key
+ $group = explode('.', $key, 2);
+ $group = $group[0];
+
+ if ( ! isset(Kohana::$internal_cache['messages'][$group]))
+ {
+ // Messages for this group
+ $messages = array();
+
+ if ($file = Kohana::find_file('messages', $group))
+ {
+ include $file[0];
+ }
+
+ if ( ! isset(Kohana::$write_cache['messages']))
+ {
+ // Write language cache
+ Kohana::$write_cache['messages'] = TRUE;
+ }
+
+ Kohana::$internal_cache['messages'][$group] = $messages;
+ }
+
+ // Get the line from cache
+ $line = Kohana::key_string(Kohana::$internal_cache['messages'], $key);
+
+ if ($line === NULL)
+ {
+ Kohana_Log::add('error', 'Missing messages entry '.$key.' for message '.$group);
+
+ // Return the key string as fallback
+ return $key;
+ }
+
+ if (is_string($line) AND func_num_args() > 1)
+ {
+ $args = array_slice(func_get_args(), 1);
+
+ // Add the arguments into the line
+ $line = vsprintf($line, is_array($args[0]) ? $args[0] : $args);
+ }
+
+ return $line;
+ }
+
+ /**
+ * Returns the value of a key, defined by a 'dot-noted' string, from an array.
+ *
+ * @param array array to search
+ * @param string dot-noted string: foo.bar.baz
+ * @return string if the key is found
+ * @return void if the key is not found
+ */
+ public static function key_string($array, $keys)
+ {
+ if (empty($array))
+ return NULL;
+
+ // Prepare for loop
+ $keys = explode('.', $keys);
+
+ do
+ {
+ // Get the next key
+ $key = array_shift($keys);
+
+ if (isset($array[$key]))
+ {
+ if (is_array($array[$key]) AND ! empty($keys))
+ {
+ // Dig down to prepare the next loop
+ $array = $array[$key];
+ }
+ else
+ {
+ // Requested key was found
+ return $array[$key];
+ }
+ }
+ else
+ {
+ // Requested key is not set
+ break;
+ }
+ }
+ while ( ! empty($keys));
+
+ return NULL;
+ }
+
+ /**
+ * Sets values in an array by using a 'dot-noted' string.
+ *
+ * @param array array to set keys in (reference)
+ * @param string dot-noted string: foo.bar.baz
+ * @return mixed fill value for the key
+ * @return void
+ */
+ public static function key_string_set( & $array, $keys, $fill = NULL)
+ {
+ if (is_object($array) AND ($array instanceof ArrayObject))
+ {
+ // Copy the array
+ $array_copy = $array->getArrayCopy();
+
+ // Is an object
+ $array_object = TRUE;
+ }
+ else
+ {
+ if ( ! is_array($array))
+ {
+ // Must always be an array
+ $array = (array) $array;
+ }
+
+ // Copy is a reference to the array
+ $array_copy =& $array;
+ }
+
+ if (empty($keys))
+ return $array;
+
+ // Create keys
+ $keys = explode('.', $keys);
+
+ // Create reference to the array
+ $row =& $array_copy;
+
+ for ($i = 0, $end = count($keys) - 1; $i <= $end; $i++)
+ {
+ // Get the current key
+ $key = $keys[$i];
+
+ if ( ! isset($row[$key]))
+ {
+ if (isset($keys[$i + 1]))
+ {
+ // Make the value an array
+ $row[$key] = array();
+ }
+ else
+ {
+ // Add the fill key
+ $row[$key] = $fill;
+ }
+ }
+ elseif (isset($keys[$i + 1]))
+ {
+ // Make the value an array
+ $row[$key] = (array) $row[$key];
+ }
+
+ // Go down a level, creating a new row reference
+ $row =& $row[$key];
+ }
+
+ if (isset($array_object))
+ {
+ // Swap the array back in
+ $array->exchangeArray($array_copy);
+ }
+ }
+
+ /**
+ * Quick debugging of any variable. Any number of parameters can be set.
+ *
+ * @return string
+ */
+ public static function debug()
+ {
+ if (func_num_args() === 0)
+ return;
+
+ // Get params
+ $params = func_get_args();
+ $output = array();
+
+ foreach ($params as $var)
+ {
+ $value = is_bool($var) ? ($var ? 'true' : 'false') : print_r($var, TRUE);
+ $output[] = '<pre>('.gettype($var).') '.htmlspecialchars($value, ENT_QUOTES, Kohana::CHARSET).'</pre>';
+ }
+
+ return implode("\n", $output);
+ }
+
+ /**
+ * Saves the internal caches: configuration, include paths, etc.
+ *
+ * @return boolean
+ */
+ public static function internal_cache_save()
+ {
+ if ( ! is_array(Kohana::$write_cache))
+ return FALSE;
+
+ // Get internal cache names
+ $caches = array_keys(Kohana::$write_cache);
+
+ // Nothing written
+ $written = FALSE;
+
+ foreach ($caches as $cache)
+ {
+ if (isset(Kohana::$internal_cache[$cache]))
+ {
+ // Write the cache file
+ Kohana::cache_save($cache, Kohana::$internal_cache[$cache], Kohana::config('core.internal_cache'));
+
+ // A cache has been written
+ $written = TRUE;
+ }
+ }
+
+ return $written;
+ }
+
+} // End Kohana
diff --git a/system/core/Kohana_Config.php b/system/core/Kohana_Config.php
new file mode 100644
index 0000000..9abc5b6
--- /dev/null
+++ b/system/core/Kohana_Config.php
@@ -0,0 +1,329 @@
+<?php defined('SYSPATH') or die('No direct script access.');
+/**
+ * Provides a driver-based interface for setting and getting
+ * configuration options for the Kohana environment
+ *
+ * @package Kohana
+ * @author Kohana Team
+ * @copyright (c) 2007-2009 Kohana Team
+ * @license http://kohanaphp.com/license
+ */
+class Kohana_Config_Core implements ArrayAccess {
+
+ /**
+ * The default Kohana_Config driver
+ * to use for system setup
+ *
+ * @var string
+ * @static
+ */
+ public static $default_driver = 'array';
+
+ /**
+ * Kohana_Config instance
+ *
+ * @var array
+ * @static
+ */
+ protected static $instance;
+
+ /**
+ * Returns a new instance of the Kohana_Config library
+ * based on the singleton pattern
+ *
+ * @param string driver
+ * @return Kohana_Config
+ * @access public
+ * @static
+ */
+ public static function & instance()
+ {
+ // If the driver has not been initialised, intialise it
+ if ( empty(Kohana_Config::$instance))
+ {
+ //call a 1 time non singleton of Kohana_Config to get a list of drivers
+ $config = new Kohana_Config(array(
+ 'config_drivers'=>array(
+ ), 'internal_cache'=>FALSE
+ ));
+ $core_config = $config->get('core');
+ Kohana_Config::$instance = new Kohana_Config($core_config);
+ }
+
+ // Return the Kohana_Config driver requested
+ return Kohana_Config::$instance;
+ }
+
+ /**
+ * The drivers for this object
+ *
+ * @var Kohana_Config_Driver
+ */
+ protected $drivers;
+
+ /**
+ * Kohana_Config constructor to load the supplied driver.
+ * Enforces the singleton pattern.
+ *
+ * @param string driver
+ * @access protected
+ */
+ protected function __construct(array $core_config)
+ {
+ $drivers = $core_config['config_drivers'];
+
+ //remove array if it's found in config
+ if (in_array('array', $drivers))
+ unset($drivers[array_search('array', $drivers)]);
+
+ //add array at the very end
+ $this->drivers = $drivers = array_merge($drivers, array(
+ 'array'
+ ));
+
+ foreach ($this->drivers as & $driver)
+ {
+ // Create the driver name
+ $driver = 'Config_'.ucfirst($driver).'_Driver';
+
+ // Ensure the driver loads correctly
+ if (!Kohana::auto_load($driver))
+ throw new Kohana_Exception('The :driver: driver for the :library: library could not be found.', array(
+ ':driver:' => $driver, ':library:' => get_class($this)
+ ));
+
+ // Load the new driver
+ $driver = new $driver($core_config);
+
+ // Ensure the new driver is valid
+ if (!$driver instanceof Config_Driver)
+ throw new Kohana_Exception('The :driver: driver for the :library: library must implement the :interface: interface', array(
+ ':driver:' => $driver, ':library:' => get_class($this), ':interface:' => 'Config_Driver'
+ ));
+ }
+ }
+
+ /**
+ * Gets a value from the configuration driver
+ *
+ * @param string key
+ * @param bool slash
+ * @param bool required
+ * @return mixed
+ * @access public
+ */
+ public function get($key, $slash = FALSE, $required = FALSE)
+ {
+ foreach ($this->drivers as $driver)
+ {
+ try
+ {
+ return $driver->get($key, $slash, $required);
+ }
+ catch (Kohana_Config_Exception $e)
+ {
+ //if it's the last driver in the list and it threw an exception, re throw it
+ if ($driver === $this->drivers[(count($this->drivers) - 1)])
+ throw $e;
+ }
+ }
+ }
+
+ /**
+ * Sets a value to the configuration drivers
+ *
+ * @param string key
+ * @param mixed value
+ * @return bool
+ * @access public
+ */
+ public function set($key, $value)
+ {
+ foreach ($this->drivers as $driver)
+ {
+ try
+ {
+ $driver->set($key, $value);
+ }
+ catch (Kohana_Config_Exception $e)
+ {
+ //if it's the last driver in the list and it threw an exception, re throw it
+ if ($driver === $this->drivers[(count($this->drivers) - 1)])
+ throw $e;
+ }
+ }
+ return TRUE;
+ }
+
+ /**
+ * Clears a group from configuration
+ *
+ * @param string group
+ * @return bool
+ * @access public
+ */
+ public function clear($group)
+ {
+ foreach ($this->drivers as $driver)
+ {
+ try
+ {
+ $driver->clear($group);
+ }
+ catch (Kohana_Config_Exception $e)
+ {
+ //if it's the last driver in the list and it threw an exception, re throw it
+ if ($driver === $this->drivers[(count($this->drivers) - 1)])
+ throw $e;
+ }
+ }
+ return TRUE;
+ }
+
+ /**
+ * Loads a configuration group
+ *
+ * @param string group
+ * @param bool required
+ * @return array
+ * @access public
+ */
+ public function load($group, $required = FALSE)
+ {
+ foreach ($this->drivers as $driver)
+ {
+ try
+ {
+ return $driver->load($group, $required);
+ }
+ catch (Kohana_Config_Exception $e)
+ {
+ //if it's the last driver in the list and it threw an exception, re throw it
+ if ($driver === $this->drivers[(count($this->drivers) - 1)])
+ throw $e;
+ }
+ }
+ }
+
+ /**
+ * Returns true or false if any config has been loaded(either manually or from cache)
+ *
+ * @return boolean
+ */
+ public function loaded()
+ {
+ return $this->drivers[(count($this->drivers) - 1)]->loaded;
+ }
+
+ /**
+ * The following allows access using
+ * array syntax.
+ *
+ * @example $config['core.site_domain']
+ */
+
+ /**
+ * Allows access to configuration settings
+ * using the ArrayAccess interface
+ *
+ * @param string key
+ * @return mixed
+ * @access public
+ */
+ public function offsetGet($key)
+ {
+ foreach ($this->drivers as $driver)
+ {
+ try
+ {
+ return $driver->get($key);
+ }
+ catch (Kohana_Config_Exception $e)
+ {
+ //if it's the last driver in the list and it threw an exception, re throw it
+ if ($driver === $this->drivers[(count($this->drivers) - 1)])
+ throw $e;
+ }
+ }
+ }
+
+ /**
+ * Allows access to configuration settings
+ * using the ArrayAccess interface
+ *
+ * @param string key
+ * @param mixed value
+ * @return bool
+ * @access public
+ */
+ public function offsetSet($key, $value)
+ {
+ foreach ($this->drivers as $driver)
+ {
+ try
+ {
+ $driver->set($key, $value);
+ }
+ catch (Kohana_Config_Exception $e)
+ {
+ //if it's the last driver in the list and it threw an exception, re throw it
+ if ($driver === $this->drivers[(count($this->drivers) - 1)])
+ throw $e;
+ }
+ }
+ return TRUE;
+ }
+
+ /**
+ * Allows access to configuration settings
+ * using the ArrayAccess interface
+ *
+ * @param string key
+ * @return bool
+ * @access public
+ */
+ public function offsetExists($key)
+ {
+ foreach ($this->drivers as $driver)
+ {
+ try
+ {
+ return $driver->setting_exists($key);
+ }
+ catch (Kohana_Config_Exception $e)
+ {
+ //if it's the last driver in the list and it threw an exception, re throw it
+ if ($driver === $this->drivers[(count($this->drivers) - 1)])
+ throw $e;
+ }
+ }
+ }
+
+ /**
+ * Allows access to configuration settings
+ * using the ArrayAccess interface
+ *
+ * @param string key
+ * @return bool
+ * @access public
+ */
+ public function offsetUnset($key)
+ {
+ foreach ($this->drivers as $driver)
+ {
+ try
+ {
+ return $driver->set($key, NULL);
+ }
+ catch (Kohana_Config_Exception $e)
+ {
+ //if it's the last driver in the list and it threw an exception, re throw it
+ if ($driver === $this->drivers[(count($this->drivers) - 1)])
+ throw $e;
+ }
+ }
+ return TRUE;
+ }
+} // End KohanaConfig
+
+class Kohana_Config_Exception extends Kohana_Exception {}
diff --git a/system/core/Kohana_Exception.php b/system/core/Kohana_Exception.php
new file mode 100644
index 0000000..bc0efd1
--- /dev/null
+++ b/system/core/Kohana_Exception.php
@@ -0,0 +1,622 @@
+<?php defined('SYSPATH') OR die('No direct access allowed.');
+/**
+ * Kohana Exceptions
+ *
+ * @package Kohana
+ * @author Kohana Team
+ * @copyright (c) 2007-2009 Kohana Team
+ * @license http://kohanaphp.com/license
+ */
+
+class Kohana_Exception_Core extends Exception {
+
+ public static $enabled = FALSE;
+
+ // Template file
+ public static $template = 'kohana/error';
+
+ // Show stack traces in errors
+ public static $trace_output = TRUE;
+
+ // Show source code in errors
+ public static $source_output = TRUE;
+
+ // To hold unique identifier to distinguish error output
+ protected $instance_identifier;
+
+ // Error code
+ protected $code = E_KOHANA;
+
+ /**
+ * Creates a new translated exception.
+ *
+ * @param string error message
+ * @param array translation variables
+ * @return void
+ */
+ public function __construct($message, array $variables = NULL, $code = 0)
+ {
+ $this->instance_identifier = uniqid();
+
+ // Translate the error message
+ $message = __($message, $variables);
+
+ // Sets $this->message the proper way
+ parent::__construct($message, $code);
+ }
+
+ /**
+ * Enable Kohana exception handling.
+ *
+ * @uses Kohana_Exception::$template
+ * @return void
+ */
+ public static function enable()
+ {
+ if ( ! Kohana_Exception::$enabled)
+ {
+ set_exception_handler(array('Kohana_Exception', 'handle'));
+
+ Kohana_Exception::$enabled = TRUE;
+ }
+ }
+
+ /**
+ * Disable Kohana exception handling.
+ *
+ * @return void
+ */
+ public static function disable()
+ {
+ if (Kohana_Exception::$enabled)
+ {
+ restore_exception_handler();
+
+ Kohana_Exception::$enabled = FALSE;
+ }
+ }
+
+ /**
+ * Get a single line of text representing the exception:
+ *
+ * Error [ Code ]: Message ~ File [ Line ]
+ *
+ * @param object Exception
+ * @return string
+ */
+ public static function text($e)
+ {
+ return sprintf('%s [ %s ]: %s ~ %s [ %d ]',
+ get_class($e), $e->getCode(), strip_tags($e->getMessage()), Kohana_Exception::debug_path($e->getFile()), $e->getLine());
+ }
+
+ /**
+ * exception handler, displays the error message, source of the
+ * exception, and the stack trace of the error.
+ *
+ * @uses Kohana::message()
+ * @uses Kohana_Exception::text()
+ * @param object exception object
+ * @return void
+ */
+ public static function handle(Exception $e)
+ {
+ try
+ {
+ // Get the exception information
+ $type = get_class($e);
+ $code = $e->getCode();
+ $message = $e->getMessage();
+
+ // Create a text version of the exception
+ $error = Kohana_Exception::text($e);
+
+ // Add this exception to the log
+ Kohana_Log::add('error', $error);
+
+ // Manually save logs after exceptions
+ Kohana_Log::save();
+
+ if (Kohana::config('kohana/core.display_errors') === FALSE)
+ {
+ // Do not show the details
+ $file = $line = NULL;
+ $trace = array();
+
+ $template = '_disabled';
+ }
+ else
+ {
+ $file = $e->getFile();
+ $line = $e->getLine();
+ $trace = $e->getTrace();
+
+ $template = '';
+ }
+
+ if ($e instanceof Kohana_Exception)
+ {
+ $template = $e->getTemplate().$template;
+
+ if ( ! headers_sent())
+ {
+ $e->sendHeaders();
+ }
+
+ // Use the human-readable error name
+ $code = Kohana::message('kohana/core.errors.'.$code);
+ }
+ else
+ {
+ $template = Kohana_Exception::$template.$template;
+
+ if ( ! headers_sent())
+ {
+ header('HTTP/1.1 500 Internal Server Error');
+ }
+
+ if ($e instanceof ErrorException)
+ {
+ // Use the human-readable error name
+ $code = Kohana::message('kohana/core.errors.'.$e->getSeverity());
+
+ if (version_compare(PHP_VERSION, '5.3', '<'))
+ {
+ // Workaround for a bug in ErrorException::getTrace() that exists in
+ // all PHP 5.2 versions. @see http://bugs.php.net/45895
+ for ($i = count($trace) - 1; $i > 0; --$i)
+ {
+ if (isset($trace[$i - 1]['args']))
+ {
+ // Re-position the arguments
+ $trace[$i]['args'] = $trace[$i - 1]['args'];
+
+ unset($trace[$i - 1]['args']);
+ }
+ }
+ }
+ }
+ }
+
+ // Clean the output buffer if one exists
+ ob_get_level() and ob_clean();
+
+ if ($template = Kohana::find_file('views', $template))
+ {
+ include $template;
+ }
+ }
+ catch (Exception $e)
+ {
+ // Clean the output buffer if one exists
+ ob_get_level() and ob_clean();
+
+ // Display the exception text
+ echo Kohana_Exception::text($e), "\n";
+ }
+
+ if (Kohana::$server_api === 'cli')
+ {
+ // Exit with an error status
+ exit(1);
+ }
+ }
+
+ /**
+ * Returns the template for this exception.
+ *
+ * @uses Kohana_Exception::$template
+ * @return string
+ */
+ public function getTemplate()
+ {
+ return Kohana_Exception::$template;
+ }
+
+ /**
+ * Sends an Internal Server Error header.
+ *
+ * @return void
+ */
+ public function sendHeaders()
+ {
+ // Send the 500 header
+ header('HTTP/1.1 500 Internal Server Error');
+ }
+
+ /**
+ * Returns an HTML string of information about a single variable.
+ *
+ * Borrows heavily on concepts from the Debug class of {@link http://nettephp.com/ Nette}.
+ *
+ * @param mixed variable to dump
+ * @param integer maximum length of strings
+ * @param integer maximum levels of recursion
+ * @return string
+ */
+ public static function dump($value, $length = 128, $max_level = 5)
+ {
+ return Kohana_Exception::_dump($value, $length, $max_level);
+ }
+
+ /**
+ * Helper for Kohana_Exception::dump(), handles recursion in arrays and objects.
+ *
+ * @param mixed variable to dump
+ * @param integer maximum length of strings
+ * @param integer maximum levels of recursion
+ * @param integer current recursion level (internal)
+ * @return string
+ */
+ private static function _dump( & $var, $length = 128, $max_level = 5, $level = 0)
+ {
+ if ($var === NULL)
+ {
+ return '<small>NULL</small>';
+ }
+ elseif (is_bool($var))
+ {
+ return '<small>bool</small> '.($var ? 'TRUE' : 'FALSE');
+ }
+ elseif (is_float($var))
+ {
+ return '<small>float</small> '.$var;
+ }
+ elseif (is_resource($var))
+ {
+ if (($type = get_resource_type($var)) === 'stream' AND $meta = stream_get_meta_data($var))
+ {
+ $meta = stream_get_meta_data($var);
+
+ if (isset($meta['uri']))
+ {
+ $file = $meta['uri'];
+
+ if (function_exists('stream_is_local'))
+ {
+ // Only exists on PHP >= 5.2.4
+ if (stream_is_local($file))
+ {
+ $file = Kohana_Exception::debug_path($file);
+ }
+ }
+
+ return '<small>resource</small><span>('.$type.')</span> '.htmlspecialchars($file, ENT_NOQUOTES, Kohana::CHARSET);
+ }
+ }
+ else
+ {
+ return '<small>resource</small><span>('.$type.')</span>';
+ }
+ }
+ elseif (is_string($var))
+ {
+ if (strlen($var) > $length)
+ {
+ // Encode the truncated string
+ $str = htmlspecialchars(substr($var, 0, $length), ENT_NOQUOTES, Kohana::CHARSET).'&nbsp;&hellip;';
+ }
+ else
+ {
+ // Encode the string
+ $str = htmlspecialchars($var, ENT_NOQUOTES, Kohana::CHARSET);
+ }
+
+ return '<small>string</small><span>('.strlen($var).')</span> "'.$str.'"';
+ }
+ elseif (is_array($var))
+ {
+ $output = array();
+
+ // Indentation for this variable
+ $space = str_repeat($s = ' ', $level);
+
+ static $marker;
+
+ if ($marker === NULL)
+ {
+ // Make a unique marker
+ $marker = uniqid("\x00");
+ }
+
+ if (empty($var))
+ {
+ // Do nothing
+ }
+ elseif (isset($var[$marker]))
+ {
+ $output[] = "(\n$space$s*RECURSION*\n$space)";
+ }
+ elseif ($level <= $max_level)
+ {
+ $output[] = "<span>(";
+
+ $var[$marker] = TRUE;
+ foreach ($var as $key => & $val)
+ {
+ if ($key === $marker) continue;
+ if ( ! is_int($key))
+ {
+ $key = '"'.$key.'"';
+ }
+
+ $output[] = "$space$s$key => ".Kohana_Exception::_dump($val, $length, $max_level, $level + 1);
+ }
+ unset($var[$marker]);
+
+ $output[] = "$space)</span>";
+ }
+ else
+ {
+ // Depth too great
+ $output[] = "(\n$space$s...\n$space)";
+ }
+
+ return '<small>array</small><span>('.count($var).')</span> '.implode("\n", $output);
+ }
+ elseif (is_object($var))
+ {
+ // Copy the object as an array
+ $array = (array) $var;
+
+ $output = array();
+
+ // Indentation for this variable
+ $space = str_repeat($s = ' ', $level);
+
+ $hash = spl_object_hash($var);
+
+ // Objects that are being dumped
+ static $objects = array();
+
+ if (empty($var))
+ {
+ // Do nothing
+ }
+ elseif (isset($objects[$hash]))
+ {
+ $output[] = "{\n$space$s*RECURSION*\n$space}";
+ }
+ elseif ($level <= $max_level)
+ {
+ $output[] = "<code>{";
+
+ $objects[$hash] = TRUE;
+ foreach ($array as $key => & $val)
+ {
+ if ($key[0] === "\x00")
+ {
+ // Determine if the access is private or protected
+ $access = '<small>'.($key[1] === '*' ? 'protected' : 'private').'</small>';
+
+ // Remove the access level from the variable name
+ $key = substr($key, strrpos($key, "\x00") + 1);
+ }
+ else
+ {
+ $access = '<small>public</small>';
+ }
+
+ $output[] = "$space$s$access $key => ".Kohana_Exception::_dump($val, $length, $max_level, $level + 1);
+ }
+ unset($objects[$hash]);
+
+ $output[] = "$space}</code>";
+ }
+ else
+ {
+ // Depth too great
+ $output[] = "{\n$space$s...\n$space}";
+ }
+
+ return '<small>object</small> <span>'.get_class($var).'('.count($array).')</span> '.implode("\n", $output);
+ }
+ else
+ {
+ return '<small>'.gettype($var).'</small> '.htmlspecialchars(print_r($var, TRUE), ENT_NOQUOTES, Kohana::CHARSET);
+ }
+ }
+
+ /**
+ * Removes APPPATH, SYSPATH, MODPATH, and DOCROOT from filenames, replacing
+ * them with the plain text equivalents.
+ *
+ * @param string path to sanitize
+ * @return string
+ */
+ public static function debug_path($file)
+ {
+ // Normalize directory separator
+ $file = str_replace('\\', '/', $file);
+
+ if (strpos($file, APPPATH) === 0)
+ {
+ $file = 'APPPATH/'.substr($file, strlen(APPPATH));
+ }
+ elseif (strpos($file, SYSPATH) === 0)
+ {
+ $file = 'SYSPATH/'.substr($file, strlen(SYSPATH));
+ }
+ elseif (strpos($file, MODPATH) === 0)
+ {
+ $file = 'MODPATH/'.substr($file, strlen(MODPATH));
+ }
+ elseif (strpos($file, DOCROOT) === 0)
+ {
+ $file = 'DOCROOT/'.substr($file, strlen(DOCROOT));
+ }
+
+ return $file;
+ }
+
+ /**
+ * Returns an array of lines from a file.
+ *
+ * // Returns the current line of the current file
+ * echo Kohana_Exception::debug_source(__FILE__, __LINE__);
+ *
+ * @param string file to open
+ * @param integer line number to find
+ * @param integer number of padding lines
+ * @return array
+ */
+ public static function debug_source($file, $line_number, $padding = 5)
+ {
+ // Make sure we can read the source file
+ if ( ! is_readable($file))
+ return array();
+
+ // Open the file and set the line position
+ $file = fopen($file, 'r');
+ $line = 0;
+
+ // Set the reading range
+ $range = array('start' => $line_number - $padding, 'end' => $line_number + $padding);
+
+ // Set the zero-padding amount for line numbers
+ $format = '% '.strlen($range['end']).'d';
+
+ $source = array();
+ while (($row = fgets($file)) !== FALSE)
+ {
+ // Increment the line number
+ if (++$line > $range['end'])
+ break;
+
+ if ($line >= $range['start'])
+ {
+ $source[sprintf($format, $line)] = $row;
+ }
+ }
+
+ // Close the file
+ fclose($file);
+
+ return $source;
+ }
+
+ /**
+ * Returns an array of strings that represent each step in the backtrace.
+ *
+ * @param array trace to analyze
+ * @return array
+ */
+ public static function trace($trace = NULL)
+ {
+ if ($trace === NULL)
+ {
+ // Start a new trace
+ $trace = debug_backtrace();
+ }
+
+ // Non-standard function calls
+ $statements = array('include', 'include_once', 'require', 'require_once');
+
+ $output = array();
+ foreach ($trace as $step)
+ {
+ if ( ! isset($step['function']))
+ {
+ // Invalid trace step
+ continue;
+ }
+
+ if (isset($step['file']) AND isset($step['line']))
+ {
+ // Include the source of this step
+ $source = Kohana_Exception::debug_source($step['file'], $step['line']);
+ }
+
+ if (isset($step['file']))
+ {
+ $file = $step['file'];
+
+ if (isset($step['line']))
+ {
+ $line = $step['line'];
+ }
+ }
+
+ // function()
+ $function = $step['function'];
+
+ if (in_array($step['function'], $statements))
+ {
+ if (empty($step['args']))
+ {
+ // No arguments
+ $args = array();
+ }
+ else
+ {
+ // Sanitize the file path
+ $args = array($step['args'][0]);
+ }
+ }
+ elseif (isset($step['args']))
+ {
+ if ($step['function'] === '{closure}')
+ {
+ // Introspection on closures in a stack trace is impossible
+ $params = NULL;
+ }
+ else
+ {
+ if (isset($step['class']))
+ {
+ if (method_exists($step['class'], $step['function']))
+ {
+ $reflection = new ReflectionMethod($step['class'], $step['function']);
+ }
+ else
+ {
+ $reflection = new ReflectionMethod($step['class'], '__call');
+ }
+ }
+ else
+ {
+ $reflection = new ReflectionFunction($step['function']);
+ }
+
+ // Get the function parameters
+ $params = $reflection->getParameters();
+ }
+
+ $args = array();
+
+ foreach ($step['args'] as $i => $arg)
+ {
+ if (isset($params[$i]))
+ {
+ // Assign the argument by the parameter name
+ $args[$params[$i]->name] = $arg;
+ }
+ else
+ {
+ // Assign the argument by number
+ $args[$i] = $arg;
+ }
+ }
+ }
+
+ if (isset($step['class']))
+ {
+ // Class->method() or Class::method()
+ $function = $step['class'].$step['type'].$step['function'];
+ }
+
+ $output[] = array(
+ 'function' => $function,
+ 'args' => isset($args) ? $args : NULL,
+ 'file' => isset($file) ? $file : NULL,
+ 'line' => isset($line) ? $line : NULL,
+ 'source' => isset($source) ? $source : NULL,
+ );
+
+ unset($function, $args, $file, $line, $source);
+ }
+
+ return $output;
+ }
+
+} // End Kohana Exception
generated by cgit v1.0-28-g1787 at 2026-01-09 07:39:37 +0000