1. sfWebRequest.class.php
  2. /**
 * sfWebRequest class.
 *
 * This class manages web requests. It parses input from the request and store them as parameters.
 *
 * @package    symfony
 * @subpackage request
 * @author     Fabien Potencier 
 * @author     Sean Kerr 
 * @version    SVN: $Id: sfWebRequest.class.php 24265 2009-11-23 11:55:33Z Kris.Wallsmith $
 */
  3. class sfWebRequest extends sfRequest
  4. {
  5.   protected
  6.     $languages              = null,
  7.     $charsets               = null,
  8.     $acceptableContentTypes = null,
  9.     $pathInfoArray          = null,
  10.     $relativeUrlRoot        = null,
  11.     $getParameters          = null,
  12.     $postParameters         = null,
  13.     $requestParameters      = null,
  14.     $formats                = array(),
  15.     $format                 = null,
  16.     $fixedFileArray         = false;
  18.   /**
  19.    * Initializes this sfRequest.
  20.    *
  21.    * Available options:
  22.    *
  23.    *  * formats:           The list of supported format and their associated mime-types
  24.    *  * path_info_key:     The path info key (default to PATH_INFO)
  25.    *  * path_info_array:   The path info array (default to SERVER)
  26.    *  * relative_url_root: The relative URL root
  27.    *
  28.    * @param  sfEventDispatcher $dispatcher  An sfEventDispatcher instance
  29.    * @param  array             $parameters  An associative array of initialization parameters
  30.    * @param  array             $attributes  An associative array of initialization attributes
  31.    * @param  array             $options     An associative array of options
  32.    *
  33.    * @return bool true, if initialization completes successfully, otherwise false
  34.    *
  35.    * @throws <b>sfInitializationException</b> If an error occurs while initializing this sfRequest
  36.    *
  37.    * @see sfRequest
  38.    */
  39.   public function initialize(sfEventDispatcher $dispatcher, $parameters = array(), $attributes = array(), $options = array())
  40.   {
  41.     $options = array_merge(array(
  42.       'path_info_key'   => 'PATH_INFO',
  43.       'path_info_array' => 'SERVER',
  44.       'default_format'  => null, // to maintain bc
  45.     ), $options);
  46.     parent::initialize($dispatcher, $parameters, $attributes, $options);
  48.     // GET parameters
  49.     $this->getParameters = get_magic_quotes_gpc() ? sfToolkit::stripslashesDeep($_GET) : $_GET;
  50.     $this->parameterHolder->add($this->getParameters);
  52.     $postParameters = $_POST;
  54.     if (isset($_SERVER['REQUEST_METHOD']))
  55.     {
  56.       switch ($_SERVER['REQUEST_METHOD'])
  57.       {
  58.         case 'GET':
  59.           $this->setMethod(self::GET);
  60.           break;
  62.         case 'POST':
  63.           if (isset($_POST['sf_method']))
  64.           {
  65.             $this->setMethod(strtoupper($_POST['sf_method']));
  66.             unset($postParameters['sf_method']);
  67.           }
  68.           elseif (isset($_GET['sf_method']))
  69.           {
  70.             $this->setMethod(strtoupper($_GET['sf_method']));
  71.             unset($_GET['sf_method']);
  72.           }
  73.           else
  74.           {
  75.             $this->setMethod(self::POST);
  76.           }
  77.           $this->parameterHolder->remove('sf_method');
  78.           break;
  80.         case 'PUT':
  81.           $this->setMethod(self::PUT);
  82.           if ('application/x-www-form-urlencoded' === $this->getContentType())
  83.           {
  84.             parse_str($this->getContent(), $postParameters);
  85.           }
  86.           break;
  88.         case 'DELETE':
  89.           $this->setMethod(self::DELETE);
  90.           if ('application/x-www-form-urlencoded' === $this->getContentType())
  91.           {
  92.             parse_str($this->getContent(), $postParameters);
  93.           }
  94.           break;
  96.         case 'HEAD':
  97.           $this->setMethod(self::HEAD);
  98.           break;
  100.         default:
  101.           $this->setMethod(self::GET);
  102.       }
  103.     }
  104.     else
  105.     {
  106.       // set the default method
  107.       $this->setMethod(self::GET);
  108.     }
  110.     $this->postParameters = get_magic_quotes_gpc() ? sfToolkit::stripslashesDeep($postParameters) : $postParameters;
  111.     $this->parameterHolder->add($this->postParameters);
  113.     if (isset($this->options['formats']))
  114.     {
  115.       foreach ($this->options['formats'] as $format => $mimeTypes)
  116.       {
  117.         $this->setFormat($format, $mimeTypes);
  118.       }
  119.     }
  121.     // additional parameters
  122.     $this->requestParameters = $this->parseRequestParameters();
  123.     $this->parameterHolder->add($this->requestParameters);
  125.     $this->fixParameters();
  126.   }
  128.   /**
  129.    * Returns the content type of the current request.
  130.    *
  131.    * @param  Boolean $trimmed If false the full Content-Type header will be returned
  132.    *
  133.    * @return string
  134.    */
  135.   public function getContentType($trim = true)
  136.   {
  137.     $contentType = $this->getHttpHeader('Content-Type', null);
  139.     if ($trim && false !== $pos = strpos($contentType, ';'))
  140.     {
  141.       $contentType = substr($contentType, 0, $pos);
  142.     }
  144.     return $contentType;
  145.   }
  147.   /**
  148.    * Retrieves the uniform resource identifier for the current web request.
  149.    *
  150.    * @return string Unified resource identifier
  151.    */
  152.   public function getUri()
  153.   {
  154.     $pathArray = $this->getPathInfoArray();
  156.     // for IIS with rewrite module (IIFR, ISAPI Rewrite, ...)
  157.     if ('HTTP_X_REWRITE_URL' == $this->options['path_info_key'])
  158.     {
  159.       $uri = isset($pathArray['HTTP_X_REWRITE_URL']) ? $pathArray['HTTP_X_REWRITE_URL'] : '';
  160.     }
  161.     else
  162.     {
  163.       $uri = isset($pathArray['REQUEST_URI']) ? $pathArray['REQUEST_URI'] : '';
  164.     }
  166.     return $this->isAbsUri() ? $uri : $this->getUriPrefix().$uri;
  167.   }
  169.   /**
  170.    * See if the client is using absolute uri
  171.    *
  172.    * @return boolean true, if is absolute uri otherwise false
  173.    */
  174.   public function isAbsUri()
  175.   {
  176.     $pathArray = $this->getPathInfoArray();
  178.     return isset($pathArray['REQUEST_URI']) ? preg_match('/^http/', $pathArray['REQUEST_URI']) : false;
  179.   }
  181.   /**
  182.    * Returns Uri prefix, including protocol, hostname and server port.
  183.    *
  184.    * @return string Uniform resource identifier prefix
  185.    */
  186.   public function getUriPrefix()
  187.   {
  188.     $pathArray = $this->getPathInfoArray();
  189.     if ($this->isSecure())
  190.     {
  191.       $standardPort = '443';
  192.       $protocol = 'https';
  193.     }
  194.     else
  195.     {
  196.       $standardPort = '80';
  197.       $protocol = 'http';
  198.     }
  200.     $host = explode(':', $this->getHost());
  201.     if (count($host) == 1)
  202.     {
  203.       $host[] = isset($pathArray['SERVER_PORT']) ? $pathArray['SERVER_PORT'] : '';
  204.     }
  206.     if ($host[1] == $standardPort || empty($host[1]))
  207.     {
  208.       unset($host[1]);
  209.     }
  211.     return $protocol.'://'.implode(':', $host);
  212.   }
  214.   /**
  215.    * Retrieves the path info for the current web request.
  216.    *
  217.    * @return string Path info
  218.    */
  219.   public function getPathInfo()
  220.   {
  221.     $pathInfo = '';
  223.     $pathArray = $this->getPathInfoArray();
  225.     // simulate PATH_INFO if needed
  226.     $sf_path_info_key = $this->options['path_info_key'];
  227.     if (!isset($pathArray[$sf_path_info_key]) || !$pathArray[$sf_path_info_key])
  228.     {
  229.       if (isset($pathArray['REQUEST_URI']))
  230.       {
  231.         $script_name = $this->getScriptName();
  232.         $uri_prefix = $this->isAbsUri() ? $this->getUriPrefix() : '';
  233.         $pathInfo = preg_replace('/^'.preg_quote($uri_prefix, '/').'/','',$pathArray['REQUEST_URI']);
  234.         $pathInfo = preg_replace('/^'.preg_quote($script_name, '/').'/', '', $pathInfo);
  235.         $prefix_name = preg_replace('#/[^/]+$#', '', $script_name);
  236.         $pathInfo = preg_replace('/^'.preg_quote($prefix_name, '/').'/', '', $pathInfo);
  237.         $pathInfo = preg_replace('/\??'.preg_quote($pathArray['QUERY_STRING'], '/').'$/', '', $pathInfo);
  238.       }
  239.     }
  240.     else
  241.     {
  242.       $pathInfo = $pathArray[$sf_path_info_key];
  243.       if ($relativeUrlRoot = $this->getRelativeUrlRoot())
  244.       {
  245.         $pathInfo = preg_replace('/^'.str_replace('/', '\\/', $relativeUrlRoot).'\//', '', $pathInfo);
  246.       }
  247.     }
  249.     // for IIS
  250.     if (isset($_SERVER['SERVER_SOFTWARE']) && false !== stripos($_SERVER['SERVER_SOFTWARE'], 'iis') && $pos = stripos($pathInfo, '.php'))
  251.     {
  252.       $pathInfo = substr($pathInfo, $pos + 4);
  253.     }
  255.     if (!$pathInfo)
  256.     {
  257.       $pathInfo = '/';
  258.     }
  260.     return $pathInfo;
  261.   }
  263.   public function getPathInfoPrefix()
  264.   {
  265.     $prefix = $this->getRelativeUrlRoot();
  267.     if (!isset($this->options['no_script_name']) || !$this->options['no_script_name'])
  268.     {
  269.       $scriptName = $this->getScriptName();
  270.       $prefix = null === $prefix ? $scriptName : $prefix.'/'.basename($scriptName);
  271.     }
  273.     return $prefix;
  274.   }
  276.   public function getGetParameters()
  277.   {
  278.     return $this->getParameters;
  279.   }
  281.   public function getPostParameters()
  282.   {
  283.     return $this->postParameters;
  284.   }
  286.   public function getRequestParameters()
  287.   {
  288.     return $this->requestParameters;
  289.   }
  291.   public function addRequestParameters($parameters)
  292.   {
  293.     $this->requestParameters = array_merge($this->requestParameters, $parameters);
  294.     $this->getParameterHolder()->add($parameters);
  296.     $this->fixParameters();
  297.   }
  299.   /**
  300.    * Returns referer.
  301.    *
  302.    * @return string
  303.    */
  304.   public function getReferer()
  305.   {
  306.     $pathArray = $this->getPathInfoArray();
  308.     return isset($pathArray['HTTP_REFERER']) ? $pathArray['HTTP_REFERER'] : '';
  309.   }
  311.   /**
  312.    * Returns current host name.
  313.    *
  314.    * @return string
  315.    */
  316.   public function getHost()
  317.   {
  318.     $pathArray = $this->getPathInfoArray();
  320.     return isset($pathArray['HTTP_X_FORWARDED_HOST']) ? $pathArray['HTTP_X_FORWARDED_HOST'] : (isset($pathArray['HTTP_HOST']) ? $pathArray['HTTP_HOST'] : '');
  321.   }
  323.   /**
  324.    * Returns current script name.
  325.    *
  326.    * @return string
  327.    */
  328.   public function getScriptName()
  329.   {
  330.     $pathArray = $this->getPathInfoArray();
  332.     return isset($pathArray['SCRIPT_NAME']) ? $pathArray['SCRIPT_NAME'] : (isset($pathArray['ORIG_SCRIPT_NAME']) ? $pathArray['ORIG_SCRIPT_NAME'] : '');
  333.   }
  335.   /**
  336.    * Checks if the request method is the given one.
  337.    *
  338.    * @param  string $method  The method name
  339.    *
  340.    * @return bool true if the current method is the given one, false otherwise
  341.    */
  342.   public function isMethod($method)
  343.   {
  344.     return strtoupper($method) == $this->getMethod();
  345.   }
  347.   /**
  348.    * Returns the preferred culture for the current request.
  349.    *
  350.    * @param  array  $cultures  An array of ordered cultures available
  351.    *
  352.    * @return string The preferred culture
  353.    */
  354.   public function getPreferredCulture(array $cultures = null)
  355.   {
  356.     $preferredCultures = $this->getLanguages();
  358.     if (null === $cultures)
  359.     {
  360.       return isset($preferredCultures[0]) ? $preferredCultures[0] : null;
  361.     }
  363.     if (!$preferredCultures)
  364.     {
  365.       return $cultures[0];
  366.     }
  368.     $preferredCultures = array_values(array_intersect($preferredCultures, $cultures));
  370.     return isset($preferredCultures[0]) ? $preferredCultures[0] : $cultures[0];
  371.   }
  373.   /**
  374.    * Gets a list of languages acceptable by the client browser
  375.    *
  376.    * @return array Languages ordered in the user browser preferences
  377.    */
  378.   public function getLanguages()
  379.   {
  380.     if ($this->languages)
  381.     {
  382.       return $this->languages;
  383.     }
  385.     if (!isset($_SERVER['HTTP_ACCEPT_LANGUAGE']))
  386.     {
  387.       return array();
  388.     }
  390.     $languages = $this->splitHttpAcceptHeader($_SERVER['HTTP_ACCEPT_LANGUAGE']);
  391.     foreach ($languages as $lang)
  392.     {
  393.       if (strstr($lang, '-'))
  394.       {
  395.         $codes = explode('-', $lang);
  396.         if ($codes[0] == 'i')
  397.         {
  398.           // Language not listed in ISO 639 that are not variants
  399.           // of any listed language, which can be registerd with the
  400.           // i-prefix, such as i-cherokee
  401.           if (count($codes) > 1)
  402.           {
  403.             $lang = $codes[1];
  404.           }
  405.         }
  406.         else
  407.         {
  408.           for ($i = 0, $max = count($codes); $i < $max; $i++)
  409.           {
  410.             if ($i == 0)
  411.             {
  412.               $lang = strtolower($codes[0]);
  413.             }
  414.             else
  415.             {
  416.               $lang .= '_'.strtoupper($codes[$i]);
  417.             }
  418.           }
  419.         }
  420.       }
  422.       $this->languages[] = $lang;
  423.     }
  425.     return $this->languages;
  426.   }
  428.   /**
  429.    * Gets a list of charsets acceptable by the client browser.
  430.    *
  431.    * @return array List of charsets in preferable order
  432.    */
  433.   public function getCharsets()
  434.   {
  435.     if ($this->charsets)
  436.     {
  437.       return $this->charsets;
  438.     }
  440.     if (!isset($_SERVER['HTTP_ACCEPT_CHARSET']))
  441.     {
  442.       return array();
  443.     }
  445.     $this->charsets = $this->splitHttpAcceptHeader($_SERVER['HTTP_ACCEPT_CHARSET']);
  447.     return $this->charsets;
  448.   }
  450.   /**
  451.    * Gets a list of content types acceptable by the client browser
  452.    *
  453.    * @return array Languages ordered in the user browser preferences
  454.    */
  455.   public function getAcceptableContentTypes()
  456.   {
  457.     if ($this->acceptableContentTypes)
  458.     {
  459.       return $this->acceptableContentTypes;
  460.     }
  462.     if (!isset($_SERVER['HTTP_ACCEPT']))
  463.     {
  464.       return array();
  465.     }
  467.     $this->acceptableContentTypes = $this->splitHttpAcceptHeader($_SERVER['HTTP_ACCEPT']);
  469.     return $this->acceptableContentTypes;
  470.   }
  472.   /**
  473.    * Returns true if the request is a XMLHttpRequest.
  474.    *
  475.    * It works if your JavaScript library set an X-Requested-With HTTP header.
  476.    * Works with Prototype, Mootools, jQuery, and perhaps others.
  477.    *
  478.    * @return bool true if the request is an XMLHttpRequest, false otherwise
  479.    */
  480.   public function isXmlHttpRequest()
  481.   {
  482.     return ($this->getHttpHeader('X_REQUESTED_WITH') == 'XMLHttpRequest');
  483.   }
  485.   public function getHttpHeader($name, $prefix = 'http')
  486.   {
  487.     if ($prefix)
  488.     {
  489.       $prefix = strtoupper($prefix).'_';
  490.     }
  492.     $name = $prefix.strtoupper(strtr($name, '-', '_'));
  494.     $pathArray = $this->getPathInfoArray();
  496.     return isset($pathArray[$name]) ? sfToolkit::stripslashesDeep($pathArray[$name]) : null;
  497.   }
  499.   /**
  500.    * Gets a cookie value.
  501.    *
  502.    * @param  string $name          Cookie name
  503.    * @param  string $defaultValue  Default value returned when no cookie with given name is found
  504.    *
  505.    * @return mixed
  506.    */
  507.   public function getCookie($name, $defaultValue = null)
  508.   {
  509.     $retval = $defaultValue;
  511.     if (isset($_COOKIE[$name]))
  512.     {
  513.       $retval = get_magic_quotes_gpc() ? sfToolkit::stripslashesDeep($_COOKIE[$name]) : $_COOKIE[$name];
  514.     }
  516.     return $retval;
  517.   }
  519.   /**
  520.    * Returns true if the current request is secure (HTTPS protocol).
  521.    *
  522.    * @return boolean
  523.    */
  524.   public function isSecure()
  525.   {
  526.     $pathArray = $this->getPathInfoArray();
  528.     return (
  529.       (isset($pathArray['HTTPS']) && (strtolower($pathArray['HTTPS']) == 'on' || $pathArray['HTTPS'] == 1))
  530.       ||
  531.       (isset($pathArray['HTTP_SSL_HTTPS']) && (strtolower($pathArray['HTTP_SSL_HTTPS']) == 'on' || $pathArray['HTTP_SSL_HTTPS'] == 1))
  532.       ||
  533.       (isset($pathArray['HTTP_X_FORWARDED_PROTO']) && strtolower($pathArray['HTTP_X_FORWARDED_PROTO']) == 'https')
  534.     );
  535.   }
  537.   /**
  538.    * Retrieves relative root url.
  539.    *
  540.    * @return string URL
  541.    */
  542.   public function getRelativeUrlRoot()
  543.   {
  544.     if (null === $this->relativeUrlRoot)
  545.     {
  546.       if (!isset($this->options['relative_url_root']))
  547.       {
  548.         $this->relativeUrlRoot = preg_replace('#/[^/]+\.php5?$#', '', $this->getScriptName());
  549.       }
  550.       else
  551.       {
  552.         $this->relativeUrlRoot = $this->options['relative_url_root'];
  553.       }
  554.     }
  556.     return $this->relativeUrlRoot;
  557.   }
  559.   /**
  560.    * Sets the relative root url for the current web request.
  561.    *
  562.    * @param string $value  Value for the url
  563.    */
  564.   public function setRelativeUrlRoot($value)
  565.   {
  566.     $this->relativeUrlRoot = $value;
  567.   }
  569.   /**
  570.    * Splits an HTTP header for the current web request.
  571.    *
  572.    * @param string $header  Header to split
  573.    */
  574.   public function splitHttpAcceptHeader($header)
  575.   {
  576.     $values = array();
  577.     foreach (array_filter(explode(',', $header)) as $value)
  578.     {
  579.       // Cut off any q-value that might come after a semi-colon
  580.       if ($pos = strpos($value, ';'))
  581.       {
  582.         $q     = (float) trim(substr($value, $pos + 3));
  583.         $value = trim(substr($value, 0, $pos));
  584.       }
  585.       else
  586.       {
  587.         $q = 1;
  588.       }
  590.       $values[$value] = $q;
  591.     }
  593.     arsort($values);
  595.     return array_keys($values);
  596.   }
  598.   /**
  599.    * Returns the array that contains all request information ($_SERVER or $_ENV).
  600.    *
  601.    * This information is stored in the path_info_array option.
  602.    *
  603.    * @return  array Path information
  604.    */
  605.   public function getPathInfoArray()
  606.   {
  607.     if (!$this->pathInfoArray)
  608.     {
  609.       // parse PATH_INFO
  610.       switch ($this->options['path_info_array'])
  611.       {
  612.         case 'SERVER':
  613.           $this->pathInfoArray =& $_SERVER;
  614.           break;
  616.         case 'ENV':
  617.         default:
  618.           $this->pathInfoArray =& $_ENV;
  619.       }
  620.     }
  622.     return $this->pathInfoArray;
  623.   }
  625.   /**
  626.    * Gets the mime type associated with the format.
  627.    *
  628.    * @param  string $format  The format
  629.    *
  630.    * @return string The associated mime type (null if not found)
  631.    */
  632.   public function getMimeType($format)
  633.   {
  634.     return isset($this->formats[$format]) ? $this->formats[$format][0] : null;
  635.   }
  637.   /**
  638.    * Gets the format associated with the mime type.
  639.    *
  640.    * @param  string $mimeType  The associated mime type
  641.    *
  642.    * @return string The format (null if not found)
  643.    */
  644.   public function getFormat($mimeType)
  645.   {
  646.     foreach ($this->formats as $format => $mimeTypes)
  647.     {
  648.       if (in_array($mimeType, $mimeTypes))
  649.       {
  650.         return $format;
  651.       }
  652.     }
  654.     return null;
  655.   }
  657.   /**
  658.    * Associates a format with mime types.
  659.    *
  660.    * @param string       $format     The format
  661.    * @param string|array $mimeTypes  The associated mime types (the preferred one must be the first as it will be used as the content type)
  662.    */
  663.   public function setFormat($format, $mimeTypes)
  664.   {
  665.     $this->formats[$format] = is_array($mimeTypes) ? $mimeTypes : array($mimeTypes);
  666.   }
  668.   /**
  669.    * Sets the request format.
  670.    *
  671.    * @param string $format  The request format
  672.    */
  673.   public function setRequestFormat($format)
  674.   {
  675.     $this->format = $format;
  676.   }
  678.   /**
  679.    * Gets the request format.
  680.    *
  681.    * Here is the process to determine the format:
  682.    *
  683.    *  * format defined by the user (with setRequestFormat())
  684.    *  * sf_format request parameter
  685.    *  * default format from factories
  686.    *
  687.    * @return string The request format
  688.    */
  689.   public function getRequestFormat()
  690.   {
  691.     if (null === $this->format)
  692.     {
  693.       $this->setRequestFormat($this->getParameter('sf_format', $this->options['default_format']));
  694.     }
  696.     return $this->format;
  697.   }
  699.   /**
  700.    * Retrieves an array of files.
  701.    *
  702.    * @param  string $key  A key
  703.    * @return array  An associative array of files
  704.    */
  705.   public function getFiles($key = null)
  706.   {
  707.     if (false === $this->fixedFileArray)
  708.     {
  709.       $this->fixedFileArray = self::convertFileInformation($_FILES);
  710.     }
  712.     return null === $key ? $this->fixedFileArray : (isset($this->fixedFileArray[$key]) ? $this->fixedFileArray[$key] : array());
  713.   }
  715.   /**
  716.    * Converts uploaded file array to a format following the $_GET and $POST naming convention.
  717.    *
  718.    * It's safe to pass an already converted array, in which case this method just returns the original array unmodified.
  719.    *
  720.    * @param  array $taintedFiles An array representing uploaded file information
  721.    *
  722.    * @return array An array of re-ordered uploaded file information
  723.    */
  724.   static public function convertFileInformation(array $taintedFiles)
  725.   {
  726.     $files = array();
  727.     foreach ($taintedFiles as $key => $data)
  728.     {
  729.       $files[$key] = self::fixPhpFilesArray($data);
  730.     }
  732.     return $files;
  733.   }
  735.   static protected function fixPhpFilesArray($data)
  736.   {
  737.     $fileKeys = array('error', 'name', 'size', 'tmp_name', 'type');
  738.     $keys = array_keys($data);
  739.     sort($keys);
  741.     if ($fileKeys != $keys || !isset($data['name']) || !is_array($data['name']))
  742.     {
  743.       return $data;
  744.     }
  746.     $files = $data;
  747.     foreach ($fileKeys as $k)
  748.     {
  749.       unset($files[$k]);
  750.     }
  751.     foreach (array_keys($data['name']) as $key)
  752.     {
  753.       $files[$key] = self::fixPhpFilesArray(array(
  754.         'error'    => $data['error'][$key],
  755.         'name'     => $data['name'][$key],
  756.         'type'     => $data['type'][$key],
  757.         'tmp_name' => $data['tmp_name'][$key],
  758.         'size'     => $data['size'][$key],
  759.       ));
  760.     }
  762.     return $files;
  763.   }
  765.   /**
  766.    * Returns the value of a GET parameter.
  767.    *
  768.    * @param  string $name     The GET parameter name
  769.    * @param  string $default  The default value
  770.    *
  771.    * @return string The GET parameter value
  772.    */
  773.   public function getGetParameter($name, $default = null)
  774.   {
  775.     if (isset($this->getParameters[$name]))
  776.     {
  777.       return $this->getParameters[$name];
  778.     }
  779.     else
  780.     {
  781.       return sfToolkit::getArrayValueForPath($this->getParameters, $name, $default);
  782.     }
  783.   }
  785.   /**
  786.    * Returns the value of a POST parameter.
  787.    *
  788.    * @param  string $name     The POST parameter name
  789.    * @param  string $default  The default value
  790.    *
  791.    * @return string The POST parameter value
  792.    */
  793.   public function getPostParameter($name, $default = null)
  794.   {
  795.     if (isset($this->postParameters[$name]))
  796.     {
  797.       return $this->postParameters[$name];
  798.     }
  799.     else
  800.     {
  801.       return sfToolkit::getArrayValueForPath($this->postParameters, $name, $default);
  802.     }
  803.   }
  805.   /**
  806.    * Returns the value of a parameter passed as a URL segment.
  807.    *
  808.    * @param  string $name     The parameter name
  809.    * @param  string $default  The default value
  810.    *
  811.    * @return string The parameter value
  812.    */
  813.   public function getUrlParameter($name, $default = null)
  814.   {
  815.     if (isset($this->requestParameters[$name]))
  816.     {
  817.       return $this->requestParameters[$name];
  818.     }
  819.     else
  820.     {
  821.       return sfToolkit::getArrayValueForPath($this->requestParameters, $name, $default);
  822.     }
  823.   }
  825.   /**
  826.    * Returns the remote IP address that made the request.
  827.    *
  828.    * @return string The remote IP address
  829.    */
  830.   public function getRemoteAddress()
  831.   {
  832.     $pathInfo = $this->getPathInfoArray();
  834.     return $pathInfo['REMOTE_ADDR'];
  835.   }
  837.   /**
  838.    * Returns an array containing a list of IPs, the first being the client address
  839.    * and the others the addresses of each proxy that passed the request. The address
  840.    * for the last proxy can be retrieved via getRemoteAddress().
  841.    *
  842.    * This method returns null if no proxy passed this request. Note that some proxies
  843.    * do not use this header, and act as if they were the client.
  844.    *
  845.    * @return string|null An array of IP from the client and the proxies that passed
  846.    * the request, or null if no proxy was used.
  847.    */
  848.   public function getForwardedFor()
  849.   {
  850.     $pathInfo = $this->getPathInfoArray();
  852.     if (empty($pathInfo['HTTP_X_FORWARDED_FOR']))
  853.     {
  854.       return null;
  855.     }
  857.     return explode(', ', $pathInfo['HTTP_X_FORWARDED_FOR']);
  858.   }
  860.   public function checkCSRFProtection()
  861.   {
  862.     $form = new BaseForm();
  863.     $form->bind($form->isCSRFProtected() ? array($form->getCSRFFieldName() => $this->getParameter($form->getCSRFFieldName())) : array());
  865.     if (!$form->isValid())
  866.     {
  867.       throw $form->getErrorSchema();
  868.     }
  869.   }
  871.   /**
  872.    * Parses the request parameters.
  873.    *
  874.    * This method notifies the request.filter_parameters event.
  875.    *
  876.    * @return array An array of request parameters.
  877.    */
  878.   protected function parseRequestParameters()
  879.   {
  880.     return $this->dispatcher->filter(new sfEvent($this, 'request.filter_parameters', $this->getRequestContext()), array())->getReturnValue();
  881.   }
  883.   /**
  884.    * Returns the request context used.
  885.    *
  886.    * @return array An array of values representing the current request
  887.    */
  888.   public function getRequestContext()
  889.   {
  890.     return array(
  891.       'path_info'   => $this->getPathInfo(),
  892.       'prefix'      => $this->getPathInfoPrefix(),
  893.       'method'      => $this->getMethod(),
  894.       'format'      => $this->getRequestFormat(),
  895.       'host'        => $this->getHost(),
  896.       'is_secure'   => $this->isSecure(),
  897.       'request_uri' => $this->getUri(),
  898.     );
  899.   }
  901.   protected function fixParameters()
  902.   {
  903.     // move symfony parameters to attributes (parameters prefixed with _sf_)
  904.     foreach ($this->parameterHolder->getAll() as $key => $value)
  905.     {
  906.       if (0 === stripos($key, '_sf_'))
  907.       {
  908.         $this->parameterHolder->remove($key);
  909.         $this->setAttribute(substr($key, 1), $value);
  910.       }
  911.     }
  912.   }
  913. }
Debug toolbar