abstract class Zend_Controller_Plugin_Abstract{ protected $_request; protected $_response; public function setRequest(Zend_Controller_Request_Abstract $request) {  $this->_request = $request;  return $this; } public function getRequest() {  return $this->_request; } public function setResponse(Zend_Controller_Response_Abstract $response) {  $this->_response = $response;  return $this; } public function getResponse() {  return $this->_response; } /**  * Called before Zend_Controller_Front begins evaluating the  * request against its routes.  *  * @param Zend_Controller_Request_Abstract $request  * @return void  */ public function routeStartup(Zend_Controller_Request_Abstract $request) {} /**  * Called after Zend_Controller_Router exits.  *  * Called after Zend_Controller_Front exits from the router.  *  * @param Zend_Controller_Request_Abstract $request  * @return void  */ public function routeShutdown(Zend_Controller_Request_Abstract $request) {} /**  * Called before Zend_Controller_Front enters its dispatch loop.  *  * @param Zend_Controller_Request_Abstract $request  * @return void  */ public function dispatchLoopStartup(Zend_Controller_Request_Abstract $request) {} /**  * Called before an action is dispatched by Zend_Controller_Dispatcher.  *  * This callback allows for proxy or filter behavior. By altering the  * request and resetting its dispatched flag (via  * {@link Zend_Controller_Request_Abstract::setDispatched() setDispatched(false)}),  * the current action may be skipped.  *  * @param Zend_Controller_Request_Abstract $request  * @return void  */ public function preDispatch(Zend_Controller_Request_Abstract $request) {} /**  * Called after an action is dispatched by Zend_Controller_Dispatcher.  *  * This callback allows for proxy or filter behavior. By altering the  * request and resetting its dispatched flag (via  * {@link Zend_Controller_Request_Abstract::setDispatched() setDispatched(false)}),  * a new action may be specified for dispatching.  *  * @param Zend_Controller_Request_Abstract $request  * @return void  */ public function postDispatch(Zend_Controller_Request_Abstract $request) {} /**  * Called before Zend_Controller_Front exits its dispatch loop.  *  * @return void  */ public function dispatchLoopShutdown() {}}

<?php/** Zend_Controller_Plugin_Abstract */require_once 'Zend/Controller/Plugin/Abstract.php';class Zend_Controller_Plugin_Broker extends Zend_Controller_Plugin_Abstract{ protected $_plugins = array(); /**  * Register a plugin.  *  * @param Zend_Controller_Plugin_Abstract $plugin  * @param int $stackIndex  * @return Zend_Controller_Plugin_Broker  */ public function registerPlugin(Zend_Controller_Plugin_Abstract $plugin, $stackIndex = null) {  if (false !== array_search($plugin, $this->_plugins, true)) {   require_once 'Zend/Controller/Exception.php';   throw new Zend_Controller_Exception('Plugin already registered');  }  $stackIndex = (int) $stackIndex;  if ($stackIndex) {   if (isset($this->_plugins[$stackIndex])) {    require_once 'Zend/Controller/Exception.php';    throw new Zend_Controller_Exception('Plugin with stackIndex "' . $stackIndex . '" already registered');   }   $this->_plugins[$stackIndex] = $plugin;  } else {   $stackIndex = count($this->_plugins);   while (isset($this->_plugins[$stackIndex])) {    ++$stackIndex;   }   $this->_plugins[$stackIndex] = $plugin;  }  $request = $this->getRequest();  if ($request) {   $this->_plugins[$stackIndex]->setRequest($request);  }  $response = $this->getResponse();  if ($response) {   $this->_plugins[$stackIndex]->setResponse($response);  }  ksort($this->_plugins);  return $this; } /**  * Unregister a plugin.  *  * @param string|Zend_Controller_Plugin_Abstract $plugin Plugin object or class name  * @return Zend_Controller_Plugin_Broker  */ public function unregisterPlugin($plugin) {  if ($plugin instanceof Zend_Controller_Plugin_Abstract) {   // Given a plugin object, find it in the array   $key = array_search($plugin, $this->_plugins, true);   if (false === $key) {    require_once 'Zend/Controller/Exception.php';    throw new Zend_Controller_Exception('Plugin never registered.');   }   unset($this->_plugins[$key]);  } elseif (is_string($plugin)) {   // Given a plugin class, find all plugins of that class and unset them   foreach ($this->_plugins as $key => $_plugin) {    $type = get_class($_plugin);    if ($plugin == $type) {     unset($this->_plugins[$key]);    }   }  }  return $this; } /**  * Is a plugin of a particular class registered?  *  * @param string $class  * @return bool  */ public function hasPlugin($class) {  foreach ($this->_plugins as $plugin) {   $type = get_class($plugin);   if ($class == $type) {    return true;   }  }  return false; } /**  * Retrieve a plugin or plugins by class  *  * @param string $class Class name of plugin(s) desired  * @return false|Zend_Controller_Plugin_Abstract|array Returns false if none found, plugin if only one found, and array of plugins if multiple plugins of same class found  */ public function getPlugin($class) {  $found = array();  foreach ($this->_plugins as $plugin) {   $type = get_class($plugin);   if ($class == $type) {    $found[] = $plugin;   }  }  switch (count($found)) {   case 0:    return false;   case 1:    return $found[0];   default:    return $found;  } } /**  * Retrieve all plugins  *  * @return array  */ public function getPlugins() {  return $this->_plugins; } /**  * Set request object, and register with each plugin  *  * @param Zend_Controller_Request_Abstract $request  * @return Zend_Controller_Plugin_Broker  */ public function setRequest(Zend_Controller_Request_Abstract $request) {  $this->_request = $request;  foreach ($this->_plugins as $plugin) {   $plugin->setRequest($request);  }  return $this; } /**  * Get request object  *  * @return Zend_Controller_Request_Abstract $request  */ public function getRequest() {  return $this->_request; } /**  * Set response object  *  * @param Zend_Controller_Response_Abstract $response  * @return Zend_Controller_Plugin_Broker  */ public function setResponse(Zend_Controller_Response_Abstract $response) {  $this->_response = $response;  foreach ($this->_plugins as $plugin) {   $plugin->setResponse($response);  }  return $this; } /**  * Get response object  *  * @return Zend_Controller_Response_Abstract $response  */ public function getResponse() {  return $this->_response; } /**  * Called before Zend_Controller_Front begins evaluating the  * request against its routes.  *  * @param Zend_Controller_Request_Abstract $request  * @return void  */ public function routeStartup(Zend_Controller_Request_Abstract $request) {  foreach ($this->_plugins as $plugin) {   try {    $plugin->routeStartup($request);   } catch (Exception $e) {    if (Zend_Controller_Front::getInstance()->throwExceptions()) {     throw new Zend_Controller_Exception($e->getMessage() . $e->getTraceAsString(), $e->getCode(), $e);    } else {     $this->getResponse()->setException($e);    }   }  } } /**  * Called before Zend_Controller_Front exits its iterations over  * the route set.  *  * @param Zend_Controller_Request_Abstract $request  * @return void  */ public function routeShutdown(Zend_Controller_Request_Abstract $request) {  foreach ($this->_plugins as $plugin) {   try {    $plugin->routeShutdown($request);   } catch (Exception $e) {    if (Zend_Controller_Front::getInstance()->throwExceptions()) {     throw new Zend_Controller_Exception($e->getMessage() . $e->getTraceAsString(), $e->getCode(), $e);    } else {     $this->getResponse()->setException($e);    }   }  } } /**  * Called before Zend_Controller_Front enters its dispatch loop.  *  * During the dispatch loop, Zend_Controller_Front keeps a  * Zend_Controller_Request_Abstract object, and uses  * Zend_Controller_Dispatcher to dispatch the  * Zend_Controller_Request_Abstract object to controllers/actions.  *  * @param Zend_Controller_Request_Abstract $request  * @return void  */ public function dispatchLoopStartup(Zend_Controller_Request_Abstract $request) {  foreach ($this->_plugins as $plugin) {   try {    $plugin->dispatchLoopStartup($request);   } catch (Exception $e) {    if (Zend_Controller_Front::getInstance()->throwExceptions()) {     throw new Zend_Controller_Exception($e->getMessage() . $e->getTraceAsString(), $e->getCode(), $e);    } else {     $this->getResponse()->setException($e);    }   }  } } /**  * Called before an action is dispatched by Zend_Controller_Dispatcher.  *  * @param Zend_Controller_Request_Abstract $request  * @return void  */ public function preDispatch(Zend_Controller_Request_Abstract $request) {  foreach ($this->_plugins as $plugin) {   try {    $plugin->preDispatch($request);   } catch (Exception $e) {    if (Zend_Controller_Front::getInstance()->throwExceptions()) {     throw new Zend_Controller_Exception($e->getMessage() . $e->getTraceAsString(), $e->getCode(), $e);    } else {     $this->getResponse()->setException($e);     // skip rendering of normal dispatch give the error handler a try     $this->getRequest()->setDispatched(false);    }   }  } } /**  * Called after an action is dispatched by Zend_Controller_Dispatcher.  *  * @param Zend_Controller_Request_Abstract $request  * @return void  */ public function postDispatch(Zend_Controller_Request_Abstract $request) {  foreach ($this->_plugins as $plugin) {   try {    $plugin->postDispatch($request);   } catch (Exception $e) {    if (Zend_Controller_Front::getInstance()->throwExceptions()) {     throw new Zend_Controller_Exception($e->getMessage() . $e->getTraceAsString(), $e->getCode(), $e);    } else {     $this->getResponse()->setException($e);    }   }  } } /**  * Called before Zend_Controller_Front exits its dispatch loop.  *  * @param Zend_Controller_Request_Abstract $request  * @return void  */ public function dispatchLoopShutdown() {  foreach ($this->_plugins as $plugin) {   try {    $plugin->dispatchLoopShutdown();   } catch (Exception $e) {    if (Zend_Controller_Front::getInstance()->throwExceptions()) {     throw new Zend_Controller_Exception($e->getMessage() . $e->getTraceAsString(), $e->getCode(), $e);    } else {     $this->getResponse()->setException($e);    }   }  } }}

<?php/** Zend_Controller_Plugin_Abstract */require_once 'Zend/Controller/Plugin/Abstract.php';/** Zend_Registry */require_once 'Zend/Registry.php';class Zend_Controller_Plugin_ActionStack extends Zend_Controller_Plugin_Abstract{ /** @var Zend_Registry */ protected $_registry; /**  * Registry key under which actions are stored  * @var string  */ protected $_registryKey = 'Zend_Controller_Plugin_ActionStack'; /**  * Valid keys for stack items  * @var array  */ protected $_validKeys = array(  'module',  'controller',  'action',  'params' ); /**  * Flag to determine whether request parameters are cleared between actions, or whether new parameters  * are added to existing request parameters.  *  * @var Bool  */ protected $_clearRequestParams = false; /**  * Constructor  *  * @param Zend_Registry $registry  * @param string $key  * @return void  */ public function __construct(Zend_Registry $registry = null, $key = null) {  if (null === $registry) {   $registry = Zend_Registry::getInstance();  }  $this->setRegistry($registry);  if (null !== $key) {   $this->setRegistryKey($key);  } else {   $key = $this->getRegistryKey();  }  $registry[$key] = array(); } /**  * Set registry object  *  * @param Zend_Registry $registry  * @return Zend_Controller_Plugin_ActionStack  */ public function setRegistry(Zend_Registry $registry) {  $this->_registry = $registry;  return $this; } /**  * Retrieve registry object  *  * @return Zend_Registry  */ public function getRegistry() {  return $this->_registry; } /**  * Retrieve registry key  *  * @return string  */ public function getRegistryKey() {  return $this->_registryKey; } /**  * Set registry key  *  * @param string $key  * @return Zend_Controller_Plugin_ActionStack  */ public function setRegistryKey($key) {  $this->_registryKey = (string) $key;  return $this; } /**  * Set clearRequestParams flag  *  * @param bool $clearRequestParams  * @return Zend_Controller_Plugin_ActionStack  */ public function setClearRequestParams($clearRequestParams) {  $this->_clearRequestParams = (bool) $clearRequestParams;  return $this; } /**  * Retrieve clearRequestParams flag  *  * @return bool  */ public function getClearRequestParams() {  return $this->_clearRequestParams; } /**  * Retrieve action stack  *  * @return array  */ public function getStack() {  $registry = $this->getRegistry();  $stack = $registry[$this->getRegistryKey()];  return $stack; } /**  * Save stack to registry  *  * @param array $stack  * @return Zend_Controller_Plugin_ActionStack  */ protected function _saveStack(array $stack) {  $registry = $this->getRegistry();  $registry[$this->getRegistryKey()] = $stack;  return $this; } /**  * Push an item onto the stack  *  * @param Zend_Controller_Request_Abstract $next  * @return Zend_Controller_Plugin_ActionStack  */ public function pushStack(Zend_Controller_Request_Abstract $next) {  $stack = $this->getStack();  array_push($stack, $next);  return $this->_saveStack($stack); } /**  * Pop an item off the action stack  *  * @return false|Zend_Controller_Request_Abstract  */ public function popStack() {  $stack = $this->getStack();  if (0 == count($stack)) {   return false;  }  $next = array_pop($stack);  $this->_saveStack($stack);  if (!$next instanceof Zend_Controller_Request_Abstract) {   require_once 'Zend/Controller/Exception.php';   throw new Zend_Controller_Exception('ArrayStack should only contain request objects');  }  $action = $next->getActionName();  if (empty($action)) {   return $this->popStack($stack);  }  $request = $this->getRequest();  $controller = $next->getControllerName();  if (empty($controller)) {   $next->setControllerName($request->getControllerName());  }  $module = $next->getModuleName();  if (empty($module)) {   $next->setModuleName($request->getModuleName());  }  return $next; } /**  * postDispatch() plugin hook -- check for actions in stack, and dispatch if any found  *  * @param Zend_Controller_Request_Abstract $request  * @return void  */ public function postDispatch(Zend_Controller_Request_Abstract $request) {  // Don't move on to next request if this is already an attempt to  // forward  if (!$request->isDispatched()) {   return;  }  $this->setRequest($request);  $stack = $this->getStack();  if (empty($stack)) {   return;  }  $next = $this->popStack();  if (!$next) {   return;  }  $this->forward($next); } /**  * Forward request with next action  *  * @param array $next  * @return void  */ public function forward(Zend_Controller_Request_Abstract $next) {  $request = $this->getRequest();  if ($this->getClearRequestParams()) {   $request->clearParams();  }  $request->setModuleName($next->getModuleName())    ->setControllerName($next->getControllerName())    ->setActionName($next->getActionName())    ->setParams($next->getParams())    ->setDispatched(false); }}

<?php/** Zend_Controller_Plugin_Abstract */require_once 'Zend/Controller/Plugin/Abstract.php';class Zend_Controller_Plugin_ErrorHandler extends Zend_Controller_Plugin_Abstract{ /**  * Const - No controller exception; controller does not exist  */ const EXCEPTION_NO_CONTROLLER = 'EXCEPTION_NO_CONTROLLER'; /**  * Const - No action exception; controller exists, but action does not  */ const EXCEPTION_NO_ACTION = 'EXCEPTION_NO_ACTION'; /**  * Const - No route exception; no routing was possible  */ const EXCEPTION_NO_ROUTE = 'EXCEPTION_NO_ROUTE'; /**  * Const - Other Exception; exceptions thrown by application controllers  */ const EXCEPTION_OTHER = 'EXCEPTION_OTHER'; /**  * Module to use for errors; defaults to default module in dispatcher  * @var string  */ protected $_errorModule; /**  * Controller to use for errors; defaults to 'error'  * @var string  */ protected $_errorController = 'error'; /**  * Action to use for errors; defaults to 'error'  * @var string  */ protected $_errorAction = 'error'; /**  * Flag; are we already inside the error handler loop?  * @var bool  */ protected $_isInsideErrorHandlerLoop = false; /**  * Exception count logged at first invocation of plugin  * @var int  */ protected $_exceptionCountAtFirstEncounter = 0; /**  * Constructor  *  * Options may include:  * - module  * - controller  * - action  *  * @param Array $options  * @return void  */ public function __construct(Array $options = array()) {  $this->setErrorHandler($options); } /**  * setErrorHandler() - setup the error handling options  *  * @param array $options  * @return Zend_Controller_Plugin_ErrorHandler  */ public function setErrorHandler(Array $options = array()) {  if (isset($options['module'])) {   $this->setErrorHandlerModule($options['module']);  }  if (isset($options['controller'])) {   $this->setErrorHandlerController($options['controller']);  }  if (isset($options['action'])) {   $this->setErrorHandlerAction($options['action']);  }  return $this; } /**  * Set the module name for the error handler  *  * @param string $module  * @return Zend_Controller_Plugin_ErrorHandler  */ public function setErrorHandlerModule($module) {  $this->_errorModule = (string) $module;  return $this; } /**  * Retrieve the current error handler module  *  * @return string  */ public function getErrorHandlerModule() {  if (null === $this->_errorModule) {   $this->_errorModule = Zend_Controller_Front::getInstance()->getDispatcher()->getDefaultModule();  }  return $this->_errorModule; } /**  * Set the controller name for the error handler  *  * @param string $controller  * @return Zend_Controller_Plugin_ErrorHandler  */ public function setErrorHandlerController($controller) {  $this->_errorController = (string) $controller;  return $this; } /**  * Retrieve the current error handler controller  *  * @return string  */ public function getErrorHandlerController() {  return $this->_errorController; } /**  * Set the action name for the error handler  *  * @param string $action  * @return Zend_Controller_Plugin_ErrorHandler  */ public function setErrorHandlerAction($action) {  $this->_errorAction = (string) $action;  return $this; } /**  * Retrieve the current error handler action  *  * @return string  */ public function getErrorHandlerAction() {  return $this->_errorAction; } /**  * Route shutdown hook -- Ccheck for router exceptions  *  * @param Zend_Controller_Request_Abstract $request  */ public function routeShutdown(Zend_Controller_Request_Abstract $request) {  $this->_handleError($request); } /**  * Pre dispatch hook -- check for exceptions and dispatch error handler if  * necessary  *  * @param Zend_Controller_Request_Abstract $request  */ public function preDispatch(Zend_Controller_Request_Abstract $request) {  $this->_handleError($request); } /**  * Post dispatch hook -- check for exceptions and dispatch error handler if  * necessary  *  * @param Zend_Controller_Request_Abstract $request  */ public function postDispatch(Zend_Controller_Request_Abstract $request) {  $this->_handleError($request); } /**  * Handle errors and exceptions  *  * If the 'noErrorHandler' front controller flag has been set,  * returns early.  *  * @param Zend_Controller_Request_Abstract $request  * @return void  */ protected function _handleError(Zend_Controller_Request_Abstract $request) {  $frontController = Zend_Controller_Front::getInstance();  if ($frontController->getParam('noErrorHandler')) {   return;  }  $response = $this->getResponse();  if ($this->_isInsideErrorHandlerLoop) {   $exceptions = $response->getException();   if (count($exceptions) > $this->_exceptionCountAtFirstEncounter) {    // Exception thrown by error handler; tell the front controller to throw it    $frontController->throwExceptions(true);    throw array_pop($exceptions);   }  }  // check for an exception AND allow the error handler controller the option to forward  if (($response->isException()) && (!$this->_isInsideErrorHandlerLoop)) {   $this->_isInsideErrorHandlerLoop = true;   // Get exception information   $error   = new ArrayObject(array(), ArrayObject::ARRAY_AS_PROPS);   $exceptions  = $response->getException();   $exception  = $exceptions[0];   $exceptionType = get_class($exception);   $error->exception = $exception;   switch ($exceptionType) {    case 'Zend_Controller_Router_Exception':     if (404 == $exception->getCode()) {      $error->type = self::EXCEPTION_NO_ROUTE;     } else {      $error->type = self::EXCEPTION_OTHER;     }     break;    case 'Zend_Controller_Dispatcher_Exception':     $error->type = self::EXCEPTION_NO_CONTROLLER;     break;    case 'Zend_Controller_Action_Exception':     if (404 == $exception->getCode()) {      $error->type = self::EXCEPTION_NO_ACTION;     } else {      $error->type = self::EXCEPTION_OTHER;     }     break;    default:     $error->type = self::EXCEPTION_OTHER;     break;   }   // Keep a copy of the original request   $error->request = clone $request;   // get a count of the number of exceptions encountered   $this->_exceptionCountAtFirstEncounter = count($exceptions);   // Forward to the error handler   $request->setParam('error_handler', $error)     ->setModuleName($this->getErrorHandlerModule())     ->setControllerName($this->getErrorHandlerController())     ->setActionName($this->getErrorHandlerAction())     ->setDispatched(false);  } }}

<?phprequire_once 'Zend/Controller/Plugin/Abstract.php';require_once 'Zend/Controller/Request/Http.php';class Zend_Controller_Plugin_PutHandler extends Zend_Controller_Plugin_Abstract{ /**  * Before dispatching, digest PUT request body and set params  *  * @param Zend_Controller_Request_Abstract $request  */ public function preDispatch(Zend_Controller_Request_Abstract $request) {  if (!$request instanceof Zend_Controller_Request_Http) {   return;  }  if ($this->_request->isPut()) {   $putParams = array();   parse_str($this->_request->getRawBody(), $putParams);   $request->setParams($putParams);  } }}