classes/core/Request.inc.php

<?php

// $Id: Request.inc.php,v 1.58 2008/07/01 01:16:09 asmecher Exp $


// The base script through which all requests are routed
define('INDEX_SCRIPTNAME', 'index.php');

class Request {

   function redirectUrl($url) {
      if (HookRegistry::call('Request::redirect', array(&$url))) {
         return;
      }

      header("Location: $url");
      exit();
   }

   function redirect($journalPath = null, $page = null, $op = null, $path = null, $params = null, $anchor = null) {
      Request::redirectUrl(Request::url($journalPath, $page, $op, $path, $params, $anchor));
   }

   function redirectSSL() {
      $url = 'https://' . Request::getServerHost() . Request::getRequestPath();
      $queryString = Request::getQueryString();
      if (!empty($queryString)) $url .= "?$queryString";
      Request::redirectUrl($url);
   }

   function redirectNonSSL() {
      $url = 'http://' . Request::getServerHost() . Request::getRequestPath();
      $queryString = Request::getQueryString();
      if (!empty($queryString)) $url .= "?$queryString";
      Request::redirectUrl($url);
   }  

   function getBaseUrl() {
      static $baseUrl;

      if (!isset($baseUrl)) {
         $serverHost = Request::getServerHost(null);
         if ($serverHost !== null) {
            // Auto-detection worked.
            $baseUrl = Request::getProtocol() . '://' . Request::getServerHost() . Request::getBasePath();
         } else {
            // Auto-detection didn't work (e.g. this is a command-line call); use configuration param
            $baseUrl = Config::getVar('general', 'base_url');
         }
         HookRegistry::call('Request::getBaseUrl', array(&$baseUrl));
      }

      return $baseUrl;
   }

   function getBasePath() {
      static $basePath;

      if (!isset($basePath)) {
         $basePath = dirname($_SERVER['SCRIPT_NAME']);
         if ($basePath == '/' || $basePath == '\\') {
            $basePath = '';
         }
         HookRegistry::call('Request::getBasePath', array(&$basePath));
      }

      return $basePath;
   }

   function getIndexUrl() {
      static $indexUrl;

      if (!isset($indexUrl)) {
         $indexUrl = Request::getBaseUrl() . '/' . INDEX_SCRIPTNAME;
         HookRegistry::call('Request::getIndexUrl', array(&$indexUrl));
      }

      return $indexUrl;
   }

   function getCompleteUrl() {
      static $completeUrl;

      if (!isset($completeUrl)) {
         $completeUrl = Request::getRequestUrl();
         $queryString = Request::getQueryString();
         if (!empty($queryString)) $completeUrl .= "?$queryString";
         HookRegistry::call('Request::getCompleteUrl', array(&$completeUrl));
      }

      return $completeUrl;
   }

   function getRequestUrl() {
      static $requestUrl;

      if (!isset($requestUrl)) {
         $requestUrl = Request::getProtocol() . '://' . Request::getServerHost() . Request::getRequestPath();
         HookRegistry::call('Request::getRequestUrl', array(&$requestUrl));
      }

      return $requestUrl;
   }

   function getQueryString() {
      static $queryString;

      if (!isset($queryString)) {
         $queryString = isset($_SERVER['QUERY_STRING'])?$_SERVER['QUERY_STRING']:'';
         HookRegistry::call('Request::getQueryString', array(&$queryString));
      }

      return $queryString;
   }

   function getRequestPath() {
      static $requestPath;
      if (!isset($requestPath)) {
         $requestPath = $_SERVER['SCRIPT_NAME'];
         if (Request::isPathInfoEnabled()) {
            $requestPath .= isset($_SERVER['PATH_INFO']) ? $_SERVER['PATH_INFO'] : '';
         }
         HookRegistry::call('Request::getRequestPath', array(&$requestPath));
      }
      return $requestPath;
   }

   function getServerHost($default = 'localhost') {
      static $serverHost;
      if (!isset($serverHost)) {
         $serverHost = isset($_SERVER['HTTP_X_FORWARDED_HOST']) ? $_SERVER['HTTP_X_FORWARDED_HOST']
            : (isset($_SERVER['HTTP_HOST']) ? $_SERVER['HTTP_HOST']
            : (isset($_SERVER['HOSTNAME']) ? $_SERVER['HOSTNAME']
            : $default));
         HookRegistry::call('Request::getServerHost', array(&$serverHost));
      }
      return $serverHost;
   }

   function getProtocol() {
      static $protocol;
      if (!isset($protocol)) {
         $protocol = (!isset($_SERVER['HTTPS']) || strtolower($_SERVER['HTTPS']) != 'on') ? 'http' : 'https';
         HookRegistry::call('Request::getProtocol', array(&$protocol));
      }
      return $protocol;
   }

   function getRequestMethod() {
      return $_SERVER['REQUEST_METHOD'];
   }

   function isPost() {
      return (Request::getRequestMethod() == 'POST');
   }

   function isGet() {
      return (Request::getRequestMethod() == 'GET');
   }

   function getRemoteAddr() {
      static $ipaddr;
      if (!isset($ipaddr)) {
         if (isset($_SERVER['HTTP_X_FORWARDED_FOR'])) {
            $ipaddr = $_SERVER['HTTP_X_FORWARDED_FOR'];
         } else if (isset($_SERVER['REMOTE_ADDR'])) {
            $ipaddr = $_SERVER['REMOTE_ADDR'];
         }
         if (!isset($ipaddr) || empty($ipaddr)) {
            $ipaddr = getenv('REMOTE_ADDR');
         }
         if (!isset($ipaddr) || $ipaddr == false) {
            $ipaddr = '';
         }

         // If multiple addresses are listed, take the first. (Supports ipv6.)
         if (preg_match('/^([0-9.a-fA-F:]+)/', $ipaddr, $matches)) {
            $ipaddr = $matches[1];
         }
         HookRegistry::call('Request::getRemoteAddr', array(&$ipaddr));
      }
      return $ipaddr;
   }

   function getRemoteDomain() {
      static $remoteDomain;
      if (!isset($remoteDomain)) {
         $remoteDomain = null;
         $remoteDomain = @getHostByAddr(Request::getRemoteAddr());
         HookRegistry::call('Request::getRemoteDomain', array(&$remoteDomain));
      }
      return $remoteDomain;
   }

   function getUserAgent() {
      static $userAgent;
      if (!isset($userAgent)) {
         if (isset($_SERVER['HTTP_USER_AGENT'])) {
            $userAgent = $_SERVER['HTTP_USER_AGENT'];
         }
         if (!isset($userAgent) || empty($userAgent)) {
            $userAgent = getenv('HTTP_USER_AGENT');
         }
         if (!isset($userAgent) || $userAgent == false) {
            $userAgent = '';
         }
         HookRegistry::call('Request::getUserAgent', array(&$userAgent));
      }
      return $userAgent;
   }

   function isBot() {
      static $isBot;
      if (!isset($isBot)) {
         $userAgent = Request::getUserAgent();
         $isBot = false;
         $userAgentsFile = Config::getVar('general', 'registry_dir') . DIRECTORY_SEPARATOR . 'botAgents.txt';
         $regexps = array_filter(file($userAgentsFile), create_function('&$a', 'return ($a = trim($a)) && !empty($a) && $a[0] != \'#\';'));
         foreach ($regexps as $regexp) {
            if (String::regexp_match($regexp, $userAgent)) {
               $isBot = true;
               return $isBot;
            }
         }
      }
      return $isBot;
   }

   function isPathInfoEnabled() {
      static $isPathInfoEnabled;
      if (!isset($isPathInfoEnabled)) {
         $isPathInfoEnabled = Config::getVar('general', 'disable_path_info')?false:true;
      }
      return $isPathInfoEnabled;
   }

   function getRequestedJournalPath() {
      static $journal;

      if (!isset($journal)) {
         if (Request::isPathInfoEnabled()) {
            $journal = '';
            if (isset($_SERVER['PATH_INFO'])) {
               $vars = explode('/', $_SERVER['PATH_INFO']);
               if (count($vars) >= 2) {
                  $journal = Core::cleanFileVar($vars[1]);
               }
            }
         } else {
            $journal = Request::getUserVar('journal');
         }

         $journal = empty($journal) ? 'index' : $journal;
         HookRegistry::call('Request::getRequestedJournalPath', array(&$journal));
      }

      return $journal;
   }

   function &getSite() {
      static $site;

      if (!isset($site)) {
         $siteDao = &DAORegistry::getDAO('SiteDAO');
         $site = $siteDao->getSite();
      }

      return $site;
   }

   function &getSession() {
      static $session;

      if (!isset($session)) {
         $sessionManager = &SessionManager::getManager();
         $session = $sessionManager->getUserSession();
      }

      return $session;
   }

   function &getUser() {
      static $user;

      if (!isset($user)) {
         $sessionManager = &SessionManager::getManager();
         $session = &$sessionManager->getUserSession();
         $user = $session->getUser();
      }

      return $user;
   }

   function &getJournal() {
      static $journal;

      if (!isset($journal)) {
         $path = Request::getRequestedJournalPath();
         if ($path != 'index') {
            $journalDao = &DAORegistry::getDAO('JournalDAO');
            $journal = $journalDao->getJournalByPath(Request::getRequestedJournalPath());
         }
      }

      return $journal;
   }

   function getRequestedPage() {
      static $page;

      if (!isset($page)) {
         if (Request::isPathInfoEnabled()) {
            $page = '';
            if (isset($_SERVER['PATH_INFO'])) {
               $vars = explode('/', $_SERVER['PATH_INFO']);
               if (count($vars) >= 3) {
                  $page = Core::cleanFileVar($vars[2]);
               }
            }
         } else {
            $page = Request::getUserVar('page');
         }
      }

      return $page;
   }

   function getRequestedOp() {
      static $op;

      if (!isset($op)) {
         if (Request::isPathInfoEnabled()) {
            $op = '';
            if (isset($_SERVER['PATH_INFO'])) {
               $vars = explode('/', $_SERVER['PATH_INFO']);
               if (count($vars) >= 4) {
                  $op = Core::cleanFileVar($vars[3]);
               }
            }
         } else {
            return Request::getUserVar('op');
         }
         $op = empty($op) ? 'index' : $op;
      }

      return $op;
   }

   function getRequestedArgs() {
      if (Request::isPathInfoEnabled()) {
         $args = array();
         if (isset($_SERVER['PATH_INFO'])) {
            $vars = explode('/', $_SERVER['PATH_INFO']);
            if (count($vars) > 3) {
               $args = array_slice($vars, 4);
               for ($i=0, $count=count($args); $i<$count; $i++) {
                  $args[$i] = Core::cleanVar(get_magic_quotes_gpc() ? stripslashes($args[$i]) : $args[$i]);
               }
            }
         }
      } else {
         $args = Request::getUserVar('path');
         if (empty($args)) $args = array();
         elseif (!is_array($args)) $args = array($args);
      }
      return $args;  
   }

   function getUserVar($key) {
      static $vars;

      if (!isset($vars)) {
         $vars = array_merge($_GET, $_POST);
      }

      if (isset($vars[$key])) {
         // FIXME Do not clean vars again if function is called more than once?
         Request::cleanUserVar($vars[$key]);
         return $vars[$key];
      } else {
         return null;
      }
   }

   function getUserDateVar($prefix, $defaultDay = null, $defaultMonth = null, $defaultYear = null, $defaultHour = 0, $defaultMinute = 0, $defaultSecond = 0) {
      $monthPart = Request::getUserVar($prefix . 'Month');
      $dayPart = Request::getUserVar($prefix . 'Day');
      $yearPart = Request::getUserVar($prefix . 'Year');
      $hourPart = Request::getUserVar($prefix . 'Hour');
      $minutePart = Request::getUserVar($prefix . 'Minute');
      $secondPart = Request::getUserVar($prefix . 'Second');

      switch (Request::getUserVar($prefix . 'Meridian')) {
         case 'pm':
            if (is_numeric($hourPart) && $hourPart != 12) $hourPart += 12;
            break;
         case 'am':
         default: 
            // Do nothing.
            break;
      }

      if (empty($dayPart)) $dayPart = $defaultDay;
      if (empty($monthPart)) $monthPart = $defaultMonth;
      if (empty($yearPart)) $yearPart = $defaultYear;
      if (empty($hourPart)) $hourPart = $defaultHour;
      if (empty($minutePart)) $minutePart = $defaultMinute;
      if (empty($secondPart)) $secondPart = $defaultSecond;

      if (empty($monthPart) || empty($dayPart) || empty($yearPart)) return null;
      return mktime($hourPart, $minutePart, $secondPart, $monthPart, $dayPart, $yearPart);
   }

   function cleanUserVar(&$var, $stripHtml = false) {
      if (isset($var) && is_array($var)) {
         foreach ($var as $key => $value) {
            Request::cleanUserVar($var[$key], $stripHtml);
         }
      } else if (isset($var)) {
         $var = Core::cleanVar(get_magic_quotes_gpc() ? stripslashes($var) : $var);

      } else {
         return null;
      }
   }

   function getCookieVar($key) {
      if (isset($_COOKIE[$key])) {
         $value = $_COOKIE[$key];
         Request::cleanUserVar($value);
         return $value;
      } else {
         return null;
      }
   }

   function setCookieVar($key, $value) {
      setcookie($key, $value, 0, Request::getBasePath());
      $_COOKIE[$key] = $value;
   }

   function url($journalPath = null, $page = null, $op = null, $path = null, $params = null, $anchor = null, $escape = false) {
      $pathInfoDisabled = !Request::isPathInfoEnabled();

      $amp = $escape?'&amp;':'&';
      $prefix = $pathInfoDisabled?$amp:'?';

      // Establish defaults for page and op
      $defaultPage = Request::getRequestedPage();
      $defaultOp = Request::getRequestedOp();

      // If a journal has been specified, don't supply default
      // page or op.
      if ($journalPath) {
         $journalPath = rawurlencode($journalPath);
         $defaultPage = null;
         $defaultOp = null;
      } else {
         $journal =& Request::getJournal();
         if ($journal) $journalPath = $journal->getPath();
         else $journalPath = 'index';
      }

      // Get overridden base URLs (if available).
      $overriddenBaseUrl = Config::getVar('general', "base_url[$journalPath]");

      // If a page has been specified, don't supply a default op.
      if ($page) {
         $page = rawurlencode($page);
         $defaultOp = null;
      } else {
         $page = $defaultPage;
      }

      // Encode the op.
      if ($op) $op = rawurlencode($op);
      else $op = $defaultOp;

      // Process additional parameters
      $additionalParams = '';
      if (!empty($params)) foreach ($params as $key => $value) {
         if (is_array($value)) foreach($value as $element) {
            $additionalParams .= $prefix . $key . '%5B%5D=' . rawurlencode($element);
            $prefix = $amp;
         } else {
            $additionalParams .= $prefix . $key . '=' . rawurlencode($value);
            $prefix = $amp;
         }
      }

      // Process anchor
      if (!empty($anchor)) $anchor = '#' . rawurlencode($anchor);
      else $anchor = '';

      if (!empty($path)) {
         if (is_array($path)) $path = array_map('rawurlencode', $path);
         else $path = array(rawurlencode($path));
         if (!$page) $page = 'index';
         if (!$op) $op = 'index';
      }

      $pathString = '';
      if ($pathInfoDisabled) {
         $joiner = $amp . 'path%5B%5D=';
         if (!empty($path)) $pathString = $joiner . implode($joiner, $path);
         if (empty($overriddenBaseUrl)) $baseParams = "?journal=$journalPath";
         else $baseParams = '';

         if (!empty($page) || !empty($overriddenBaseUrl)) {
            $baseParams .= empty($baseParams)?'?':$amp . "page=$page";
            if (!empty($op)) {
               $baseParams .= $amp . "op=$op";
            }
         }
      } else {
         if (!empty($path)) $pathString = '/' . implode('/', $path);
         if (empty($overriddenBaseUrl)) $baseParams = "/$journalPath";
         else $baseParams = '';

         if (!empty($page)) {
            $baseParams .= "/$page";
            if (!empty($op)) {
               $baseParams .= "/$op";
            }
         }
      }

      return ((empty($overriddenBaseUrl)?Request::getIndexUrl():$overriddenBaseUrl) . $baseParams . $pathString . $additionalParams . $anchor);
   }

   function isCacheable() {
      if (defined('SESSION_DISABLE_INIT')) return false;
      if (!Config::getVar('general', 'installed')) return false;
      if (!empty($_POST) || Validation::isLoggedIn()) return false;
      if (!Config::getVar('cache', 'web_cache')) return false;
      if (!Request::isPathInfoEnabled()) {
         $ok = array('journal', 'page', 'op', 'path');
         if (!empty($_GET) && count(array_diff(array_keys($_GET), $ok)) != 0) {
            return false;
         }
      } else {
         if (!empty($_GET)) return false;
      }

      if (in_array(Request::getRequestedPage(), array(
         'about', 'announcement', 'help', 'index', 'information', 'rt', 'issue', ''
      ))) return true;

      return false;
   }

   function getCacheFilename() {
      static $cacheFilename;
      if (!isset($cacheFilename)) {
         if (Request::isPathInfoEnabled()) {
            $id = isset($_SERVER['PATH_INFO'])?$_SERVER['PATH_INFO']:'index';
            $id .= '-' . Locale::getLocale();
         } else {
            $id = Request::getUserVar('journal') . '-' . Request::getUserVar('page') . '-' . Request::getUserVar('op') . '-' . Request::getUserVar('path') . '-' . Locale::getLocale();
         }
         $path = dirname(dirname(dirname(__FILE__)));
         $cacheFilename = $path . '/cache/wc-' . md5($id) . '.html';
      }
      return $cacheFilename;
   }

   function cacheContent($contents) {
      $filename = Request::getCacheFilename();
      $fp = fopen($filename, 'w');
      if ($fp) {
         fwrite($fp, mktime() . ':' . $contents);
         fclose($fp);
      }
      return $contents;
   }

   function displayCached() {
      $filename = Request::getCacheFilename();
      if (!file_exists($filename)) return false;

      $fp = fopen($filename, 'r');
      $data = fread($fp, filesize($filename));
      fclose($fp);

      $i = strpos($data, ':');
      $time = substr($data, 0, $i);
      $contents = substr($data, $i+1);

      if (mktime() > $time + Config::getVar('cache', 'web_cache_hours') * 60 * 60) return false;

      header('Content-Type: text/html; charset=' . Config::getVar('i18n', 'client_charset'));

      echo $contents;
      return true;
   }
}

?>

---