Dispatcher.inc.php

<?php
 
class Dispatcher {
   var $_application;
 
   var $_routerNames = array();
 
   var $_routerInstances = array();
 
   var $_router;
 
   var $_requestCallbackHack;
 
   function &getApplication() {
      return $this->_application;
   }
 
   function setApplication($application) {
      $this->_application = $application;
   }
 
   function &getRouterNames() {
      return $this->_routerNames;
   }
 
   function addRouterName($routerName, $shortcut) {
      assert(is_array($this->_routerNames) && is_string($routerName));
      $this->_routerNames[$shortcut] = $routerName;
   }
 
   function dispatch($request) {
      // Make sure that we have at least one router configured
      $routerNames = $this->getRouterNames();
      assert(count($routerNames) > 0);
 
      // Go through all configured routers by priority
      // and find out whether one supports the incoming request
      foreach($routerNames as $shortcut => $routerCandidateName) {
         $routerCandidate =& $this->_instantiateRouter($routerCandidateName, $shortcut);
 
         // Does this router support the current request?
         if ($routerCandidate->supports($request)) {
            // Inject router and dispatcher into request
            $request->setRouter($routerCandidate);
            $request->setDispatcher($this);
 
            // We've found our router and can go on
            // to handle the request.
            $router =& $routerCandidate;
            $this->_router =& $router;
            break;
         }
      }
 
      // None of the router handles this request? This is a development-time
      // configuration error.
      if (is_null($router)) fatalError('None of the configured routers supports this request.');
 
      // Can we serve a cached response?
      if ($router->isCacheable($request)) {
         $this->_requestCallbackHack =& $request;
         if (Config::getVar('cache', 'web_cache')) {
            if ($this->_displayCached($router, $request)) exit(); // Success
            ob_start(array($this, '_cacheContent'));
         }
      } else {
         if (isset($_SERVER['HTTP_X_MOZ']) && $_SERVER['HTTP_X_MOZ'] == 'prefetch') {
            header('HTTP/1.0 403 Forbidden');
            echo '403: Forbidden<br><br>Pre-fetching not allowed.';
            exit;
         }
      }
 
      AppLocale::initialize($request);
      PluginRegistry::loadCategory('generic', true);
      PluginRegistry::loadCategory('pubIds', true);
 
      HookRegistry::call('Dispatcher::dispatch', $request);
 
      // Reload the context after generic plugins have loaded so that changes to
      // the context schema can take place
      import('classes.core.Services');
      $contextSchema = \Services::get('schema')->get(SCHEMA_CONTEXT, true);
      $request->getRouter()->getContext($request, 1, true);
 
      $router->route($request);
   }
 
   function url($request, $shortcut, $newContext = null, $handler = null, $op = null, $path = null,
            $params = null, $anchor = null, $escape = false) {
      // Instantiate the requested router
      assert(isset($this->_routerNames[$shortcut]));
      $routerName = $this->_routerNames[$shortcut];
      $router =& $this->_instantiateRouter($routerName, $shortcut);
 
      return $router->url($request, $newContext, $handler, $op, $path, $params, $anchor, $escape);
   }
 
   //
   // Private helper methods
   //
 
   function &_instantiateRouter($routerName, $shortcut) {
      if (!isset($this->_routerInstances[$shortcut])) {
         // Routers must belong to the classes.core or lib.pkp.classes.core package
         // NB: This prevents code inclusion attacks.
         $allowedRouterPackages = array(
            'classes.core',
            'lib.pkp.classes.core'
         );
 
         // Instantiate the router
         $router =& instantiate($routerName, 'PKPRouter', $allowedRouterPackages);
         if (!is_object($router)) {
            fatalError('Cannot instantiate requested router. Routers must belong to the core package and be of type "PKPRouter".');
         }
         $router->setApplication($this->_application);
         $router->setDispatcher($this);
 
         // Save the router instance for later re-use
         $this->_routerInstances[$shortcut] =& $router;
      }
 
      return $this->_routerInstances[$shortcut];
   }
 
   function _displayCached($router, $request) {
      $filename = $router->getCacheFilename($request);
      if (!file_exists($filename)) return false;
 
      // Allow a caching proxy to work its magic if possible
      $ifModifiedSince = $request->getIfModifiedSince();
      if ($ifModifiedSince !== null && $ifModifiedSince >= filemtime($filename)) {
         header('HTTP/1.1 304 Not Modified');
         exit();
      }
 
      $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;
   }
 
   function _cacheContent($contents) {
      assert(is_a($this->_router, 'PKPRouter'));
      if ($contents == '') return $contents; // Do not cache empties
      $filename = $this->_router->getCacheFilename($this->_requestCallbackHack);
      $fp = fopen($filename, 'w');
      if ($fp) {
         fwrite($fp, mktime() . ':' . $contents);
         fclose($fp);
      }
      return $contents;
   }
 
   function handle404() {
      header('HTTP/1.0 404 Not Found');
      fatalError('404 Not Found');
   }
}