video/system/core/Common.php

   1 <?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
   2 /**
   3  * CodeIgniter
   4  *
   5  * An open source application development framework for PHP 5.1.6 or newer
   6  *
   7  * @package             CodeIgniter
   8  * @author              ExpressionEngine Dev Team
   9  * @copyright   Copyright (c) 2008 - 2011, EllisLab, Inc.
  10  * @license             http://codeigniter.com/user_guide/license.html
  11  * @link                http://codeigniter.com
  12  * @since               Version 1.0
  13  * @filesource
  14  */
  15
  16 // ------------------------------------------------------------------------
  17
  18 /**
  19  * Common Functions
  20  *
  21  * Loads the base classes and executes the request.
  22  *
  23  * @package             CodeIgniter
  24  * @subpackage  codeigniter
  25  * @category    Common Functions
  26  * @author              ExpressionEngine Dev Team
  27  * @link                http://codeigniter.com/user_guide/
  28  */
  29
  30 // ------------------------------------------------------------------------
  31
  32 /**
  33 * Determines if the current version of PHP is greater then the supplied value
  34 *
  35 * Since there are a few places where we conditionally test for PHP > 5
  36 * we'll set a static variable.
  37 *
  38 * @access       public
  39 * @param        string
  40 * @return       bool    TRUE if the current version is $version or higher
  41 */
  42 if ( ! function_exists('is_php'))
  43 {
  44         function is_php($version = '5.0.0')
  45         {
  46                 static $_is_php;
  47                 $version = (string)$version;
  48
  49                 if ( ! isset($_is_php[$version]))
  50                 {
  51                         $_is_php[$version] = (version_compare(PHP_VERSION, $version) < 0) ? FALSE : TRUE;
  52                 }
  53
  54                 return $_is_php[$version];
  55         }
  56 }
  57
  58 // ------------------------------------------------------------------------
  59
  60 /**
  61  * Tests for file writability
  62  *
  63  * is_writable() returns TRUE on Windows servers when you really can't write to
  64  * the file, based on the read-only attribute.  is_writable() is also unreliable
  65  * on Unix servers if safe_mode is on.
  66  *
  67  * @access      private
  68  * @return      void
  69  */
  70 if ( ! function_exists('is_really_writable'))
  71 {
  72         function is_really_writable($file)
  73         {
  74                 // If we're on a Unix server with safe_mode off we call is_writable
  75                 if (DIRECTORY_SEPARATOR == '/' AND @ini_get("safe_mode") == FALSE)
  76                 {
  77                         return is_writable($file);
  78                 }
  79
  80                 // For windows servers and safe_mode "on" installations we'll actually
  81                 // write a file then read it.  Bah...
  82                 if (is_dir($file))
  83                 {
  84                         $file = rtrim($file, '/').'/'.md5(mt_rand(1,100).mt_rand(1,100));
  85
  86                         if (($fp = @fopen($file, FOPEN_WRITE_CREATE)) === FALSE)
  87                         {
  88                                 return FALSE;
  89                         }
  90
  91                         fclose($fp);
  92                         @chmod($file, DIR_WRITE_MODE);
  93                         @unlink($file);
  94                         return TRUE;
  95                 }
  96                 elseif ( ! is_file($file) OR ($fp = @fopen($file, FOPEN_WRITE_CREATE)) === FALSE)
  97                 {
  98                         return FALSE;
  99                 }
 100
 101                 fclose($fp);
 102                 return TRUE;
 103         }
 104 }
 105
 106 // ------------------------------------------------------------------------
 107
 108 /**
 109 * Class registry
 110 *
 111 * This function acts as a singleton.  If the requested class does not
 112 * exist it is instantiated and set to a static variable.  If it has
 113 * previously been instantiated the variable is returned.
 114 *
 115 * @access       public
 116 * @param        string  the class name being requested
 117 * @param        string  the directory where the class should be found
 118 * @param        string  the class name prefix
 119 * @return       object
 120 */
 121 if ( ! function_exists('load_class'))
 122 {
 123         function &load_class($class, $directory = 'libraries', $prefix = 'CI_')
 124         {
 125                 static $_classes = array();
 126
 127                 // Does the class exist?  If so, we're done...
 128                 if (isset($_classes[$class]))
 129                 {
 130                         return $_classes[$class];
 131                 }
 132
 133                 $name = FALSE;
 134
 135                 // Look for the class first in the local application/libraries folder
 136                 // then in the native system/libraries folder
 137                 foreach (array(APPPATH, BASEPATH) as $path)
 138                 {
 139                         if (file_exists($path.$directory.'/'.$class.'.php'))
 140                         {
 141                                 $name = $prefix.$class;
 142
 143                                 if (class_exists($name) === FALSE)
 144                                 {
 145                                         require($path.$directory.'/'.$class.'.php');
 146                                 }
 147
 148                                 break;
 149                         }
 150                 }
 151
 152                 // Is the request a class extension?  If so we load it too
 153                 if (file_exists(APPPATH.$directory.'/'.config_item('subclass_prefix').$class.'.php'))
 154                 {
 155                         $name = config_item('subclass_prefix').$class;
 156
 157                         if (class_exists($name) === FALSE)
 158                         {
 159                                 require(APPPATH.$directory.'/'.config_item('subclass_prefix').$class.'.php');
 160                         }
 161                 }
 162
 163                 // Did we find the class?
 164                 if ($name === FALSE)
 165                 {
 166                         // Note: We use exit() rather then show_error() in order to avoid a
 167                         // self-referencing loop with the Excptions class
 168                         exit('Unable to locate the specified class: '.$class.'.php');
 169                 }
 170
 171                 // Keep track of what we just loaded
 172                 is_loaded($class);
 173
 174                 $_classes[$class] = new $name();
 175                 return $_classes[$class];
 176         }
 177 }
 178
 179 // --------------------------------------------------------------------
 180
 181 /**
 182 * Keeps track of which libraries have been loaded.  This function is
 183 * called by the load_class() function above
 184 *
 185 * @access       public
 186 * @return       array
 187 */
 188 if ( ! function_exists('is_loaded'))
 189 {
 190         function &is_loaded($class = '')
 191         {
 192                 static $_is_loaded = array();
 193
 194                 if ($class != '')
 195                 {
 196                         $_is_loaded[strtolower($class)] = $class;
 197                 }
 198
 199                 return $_is_loaded;
 200         }
 201 }
 202
 203 // ------------------------------------------------------------------------
 204
 205 /**
 206 * Loads the main config.php file
 207 *
 208 * This function lets us grab the config file even if the Config class
 209 * hasn't been instantiated yet
 210 *
 211 * @access       private
 212 * @return       array
 213 */
 214 if ( ! function_exists('get_config'))
 215 {
 216         function &get_config($replace = array())
 217         {
 218                 static $_config;
 219
 220                 if (isset($_config))
 221                 {
 222                         return $_config[0];
 223                 }
 224
 225                 // Is the config file in the environment folder?
 226                 if ( ! defined('ENVIRONMENT') OR ! file_exists($file_path = APPPATH.'config/'.ENVIRONMENT.'/config.php'))
 227                 {
 228                         $file_path = APPPATH.'config/config.php';
 229                 }
 230
 231                 // Fetch the config file
 232                 if ( ! file_exists($file_path))
 233                 {
 234                         exit('The configuration file does not exist.');
 235                 }
 236
 237                 require($file_path);
 238
 239                 // Does the $config array exist in the file?
 240                 if ( ! isset($config) OR ! is_array($config))
 241                 {
 242                         exit('Your config file does not appear to be formatted correctly.');
 243                 }
 244
 245                 // Are any values being dynamically replaced?
 246                 if (count($replace) > 0)
 247                 {
 248                         foreach ($replace as $key => $val)
 249                         {
 250                                 if (isset($config[$key]))
 251                                 {
 252                                         $config[$key] = $val;
 253                                 }
 254                         }
 255                 }
 256
 257                 return $_config[0] =& $config;
 258         }
 259 }
 260
 261 // ------------------------------------------------------------------------
 262
 263 /**
 264 * Returns the specified config item
 265 *
 266 * @access       public
 267 * @return       mixed
 268 */
 269 if ( ! function_exists('config_item'))
 270 {
 271         function config_item($item)
 272         {
 273                 static $_config_item = array();
 274
 275                 if ( ! isset($_config_item[$item]))
 276                 {
 277                         $config =& get_config();
 278
 279                         if ( ! isset($config[$item]))
 280                         {
 281                                 return FALSE;
 282                         }
 283                         $_config_item[$item] = $config[$item];
 284                 }
 285
 286                 return $_config_item[$item];
 287         }
 288 }
 289
 290 // ------------------------------------------------------------------------
 291
 292 /**
 293 * Error Handler
 294 *
 295 * This function lets us invoke the exception class and
 296 * display errors using the standard error template located
 297 * in application/errors/errors.php
 298 * This function will send the error page directly to the
 299 * browser and exit.
 300 *
 301 * @access       public
 302 * @return       void
 303 */
 304 if ( ! function_exists('show_error'))
 305 {
 306         function show_error($message, $status_code = 500, $heading = 'An Error Was Encountered')
 307         {
 308                 $_error =& load_class('Exceptions', 'core');
 309                 echo $_error->show_error($heading, $message, 'error_general', $status_code);
 310                 exit;
 311         }
 312 }
 313
 314 // ------------------------------------------------------------------------
 315
 316 /**
 317 * 404 Page Handler
 318 *
 319 * This function is similar to the show_error() function above
 320 * However, instead of the standard error template it displays
 321 * 404 errors.
 322 *
 323 * @access       public
 324 * @return       void
 325 */
 326 if ( ! function_exists('show_404'))
 327 {
 328         function show_404($page = '', $log_error = TRUE)
 329         {
 330                 $_error =& load_class('Exceptions', 'core');
 331                 $_error->show_404($page, $log_error);
 332                 exit;
 333         }
 334 }
 335
 336 // ------------------------------------------------------------------------
 337
 338 /**
 339 * Error Logging Interface
 340 *
 341 * We use this as a simple mechanism to access the logging
 342 * class and send messages to be logged.
 343 *
 344 * @access       public
 345 * @return       void
 346 */
 347 if ( ! function_exists('log_message'))
 348 {
 349         function log_message($level = 'error', $message, $php_error = FALSE)
 350         {
 351                 static $_log;
 352
 353                 if (config_item('log_threshold') == 0)
 354                 {
 355                         return;
 356                 }
 357
 358                 $_log =& load_class('Log');
 359                 $_log->write_log($level, $message, $php_error);
 360         }
 361 }
 362
 363 // ------------------------------------------------------------------------
 364
 365 /**
 366  * Set HTTP Status Header
 367  *
 368  * @access      public
 369  * @param       int             the status code
 370  * @param       string
 371  * @return      void
 372  */
 373 if ( ! function_exists('set_status_header'))
 374 {
 375         function set_status_header($code = 200, $text = '')
 376         {
 377                 $stati = array(
 378                                                         200     => 'OK',
 379                                                         201     => 'Created',
 380                                                         202     => 'Accepted',
 381                                                         203     => 'Non-Authoritative Information',
 382                                                         204     => 'No Content',
 383                                                         205     => 'Reset Content',
 384                                                         206     => 'Partial Content',
 385
 386                                                         300     => 'Multiple Choices',
 387                                                         301     => 'Moved Permanently',
 388                                                         302     => 'Found',
 389                                                         304     => 'Not Modified',
 390                                                         305     => 'Use Proxy',
 391                                                         307     => 'Temporary Redirect',
 392
 393                                                         400     => 'Bad Request',
 394                                                         401     => 'Unauthorized',
 395                                                         403     => 'Forbidden',
 396                                                         404     => 'Not Found',
 397                                                         405     => 'Method Not Allowed',
 398                                                         406     => 'Not Acceptable',
 399                                                         407     => 'Proxy Authentication Required',
 400                                                         408     => 'Request Timeout',
 401                                                         409     => 'Conflict',
 402                                                         410     => 'Gone',
 403                                                         411     => 'Length Required',
 404                                                         412     => 'Precondition Failed',
 405                                                         413     => 'Request Entity Too Large',
 406                                                         414     => 'Request-URI Too Long',
 407                                                         415     => 'Unsupported Media Type',
 408                                                         416     => 'Requested Range Not Satisfiable',
 409                                                         417     => 'Expectation Failed',
 410
 411                                                         500     => 'Internal Server Error',
 412                                                         501     => 'Not Implemented',
 413                                                         502     => 'Bad Gateway',
 414                                                         503     => 'Service Unavailable',
 415                                                         504     => 'Gateway Timeout',
 416                                                         505     => 'HTTP Version Not Supported'
 417                                                 );
 418
 419                 if ($code == '' OR ! is_numeric($code))
 420                 {
 421                         show_error('Status codes must be numeric', 500);
 422                 }
 423
 424                 if (isset($stati[$code]) AND $text == '')
 425                 {
 426                         $text = $stati[$code];
 427                 }
 428
 429                 if ($text == '')
 430                 {
 431                         show_error('No status text available.  Please check your status code number or supply your own message text.', 500);
 432                 }
 433
 434                 $server_protocol = (isset($_SERVER['SERVER_PROTOCOL'])) ? $_SERVER['SERVER_PROTOCOL'] : FALSE;
 435
 436                 if (substr(php_sapi_name(), 0, 3) == 'cgi')
 437                 {
 438                         header("Status: {$code} {$text}", TRUE);
 439                 }
 440                 elseif ($server_protocol == 'HTTP/1.1' OR $server_protocol == 'HTTP/1.0')
 441                 {
 442                         header($server_protocol." {$code} {$text}", TRUE, $code);
 443                 }
 444                 else
 445                 {
 446                         header("HTTP/1.1 {$code} {$text}", TRUE, $code);
 447                 }
 448         }
 449 }
 450
 451 // --------------------------------------------------------------------
 452
 453 /**
 454 * Exception Handler
 455 *
 456 * This is the custom exception handler that is declaired at the top
 457 * of Codeigniter.php.  The main reason we use this is to permit
 458 * PHP errors to be logged in our own log files since the user may
 459 * not have access to server logs. Since this function
 460 * effectively intercepts PHP errors, however, we also need
 461 * to display errors based on the current error_reporting level.
 462 * We do that with the use of a PHP error template.
 463 *
 464 * @access       private
 465 * @return       void
 466 */
 467 if ( ! function_exists('_exception_handler'))
 468 {
 469         function _exception_handler($severity, $message, $filepath, $line)
 470         {
 471                  // We don't bother with "strict" notices since they tend to fill up
 472                  // the log file with excess information that isn't normally very helpful.
 473                  // For example, if you are running PHP 5 and you use version 4 style
 474                  // class functions (without prefixes like "public", "private", etc.)
 475                  // you'll get notices telling you that these have been deprecated.
 476                 if ($severity == E_STRICT)
 477                 {
 478                         return;
 479                 }
 480
 481                 $_error =& load_class('Exceptions', 'core');
 482
 483                 // Should we display the error? We'll get the current error_reporting
 484                 // level and add its bits with the severity bits to find out.
 485                 if (($severity & error_reporting()) == $severity)
 486                 {
 487                         $_error->show_php_error($severity, $message, $filepath, $line);
 488                 }
 489
 490                 // Should we log the error?  No?  We're done...
 491                 if (config_item('log_threshold') == 0)
 492                 {
 493                         return;
 494                 }
 495
 496                 $_error->log_exception($severity, $message, $filepath, $line);
 497         }
 498 }
 499
 500 // --------------------------------------------------------------------
 501
 502 /**
 503  * Remove Invisible Characters
 504  *
 505  * This prevents sandwiching null characters
 506  * between ascii characters, like Java\0script.
 507  *
 508  * @access      public
 509  * @param       string
 510  * @return      string
 511  */
 512 if ( ! function_exists('remove_invisible_characters'))
 513 {
 514         function remove_invisible_characters($str, $url_encoded = TRUE)
 515         {
 516                 $non_displayables = array();
 517
 518                 // every control character except newline (dec 10)
 519                 // carriage return (dec 13), and horizontal tab (dec 09)
 520
 521                 if ($url_encoded)
 522                 {
 523                         $non_displayables[] = '/%0[0-8bcef]/';  // url encoded 00-08, 11, 12, 14, 15
 524                         $non_displayables[] = '/%1[0-9a-f]/';   // url encoded 16-31
 525                 }
 526
 527                 $non_displayables[] = '/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]+/S';   // 00-08, 11, 12, 14-31, 127
 528
 529                 do
 530                 {
 531                         $str = preg_replace($non_displayables, '', $str, -1, $count);
 532                 }
 533                 while ($count);
 534
 535                 return $str;
 536         }
 537 }
 538
 539 // ------------------------------------------------------------------------
 540
 541 /**
 542 * Returns HTML escaped variable
 543 *
 544 * @access       public
 545 * @param        mixed
 546 * @return       mixed
 547 */
 548 if ( ! function_exists('html_escape'))
 549 {
 550         function html_escape($var)
 551         {
 552                 if (is_array($var))
 553                 {
 554                         return array_map('html_escape', $var);
 555                 }
 556                 else
 557                 {
 558                         return htmlspecialchars($var, ENT_QUOTES, config_item('charset'));
 559                 }
 560         }
 561 }
 562
 563 /* End of file Common.php */
 564 /* Location: ./system/core/Common.php */