Source for file jRequest.class.php

Documentation is available at jRequest.class.php

  1. <?php
  2. /**
  3. @package    jelix
  4. @subpackage core
  5. @author     Laurent Jouanneau
  6. @contributor Yannick Le Guédart
  7. @copyright  2005-2013 Laurent Jouanneau, 2010 Yannick Le Guédart
  8. @link        http://www.jelix.org
  9. @licence    GNU Lesser General Public Licence see LICENCE file or http://www.gnu.org/licenses/lgpl.html
  10. */
  11.  
  12.  
  13. /**
  14.  * base class for object which retrieve all parameters of an http request. The
  15.  * process depends on the type of request (ex: xmlrpc..)
  16.  *
  17.  * @package  jelix
  18.  * @subpackage core
  19.  */
  20. abstract class jRequest {
  21.  
  22.    /**
  23.     * request parameters
  24.     * could set from $_GET, $_POST, or from data processing of $HTTP_RAW_POST_DATA
  25.     * @var array 
  26.     */
  27.     public $params;
  28.  
  29.     /**
  30.      * the request type code
  31.      * @var string 
  32.      */
  33.     public $type;
  34.  
  35.     /**
  36.      * the type of the default response
  37.      * @var string 
  38.      */
  39.     public $defaultResponseType = '';
  40.  
  41.     /**
  42.      * @var string the name of the base class for an allowed response for the current request
  43.      */
  44.     public $authorizedResponseClass = '';
  45.  
  46.     /**
  47.      * the path of the entry point in the url (basePath included)
  48.      * if the url is /foo/index.php/bar, its value is /foo/
  49.      * @var string 
  50.      */
  51.     public $urlScriptPath;
  52.  
  53.     /**
  54.      * the name of the entry point
  55.      * if the url is /foo/index.php/bar, its value is index.php
  56.      * @var string 
  57.      */
  58.     public $urlScriptName;
  59.  
  60.     /**
  61.      * the path to the entry point in the url
  62.      * if the url is /foo/index.php/bar, its value is /foo/index.php.
  63.      * Warning: if the app is behind a proxy, the path includes the backendBasePath,
  64.      * not the basePath. Use urlScriptPath and urlScriptName to have the
  65.      * "public" url, as needed for the frontend HTTP server
  66.      * @var string 
  67.      */
  68.     public $urlScript;
  69.  
  70.     /**
  71.      * the pathinfo part of the url
  72.      * if the url is /foo/index.php/bar, its value is /bar
  73.      * @var string 
  74.      */
  75.     public $urlPathInfo;
  76.  
  77.     /**
  78.      * the module name
  79.      * @var string 
  80.      */
  81.     public $module = '';
  82.  
  83.     /**
  84.      * the action name ("controller:method")
  85.      * @var string 
  86.      */
  87.     public $action = '';
  88.  
  89.     function __construct(){  }
  90.  
  91.     /**
  92.      * initialize the request : analyse of http request etc..
  93.      */
  94.     public function init(){
  95.         $this->_initUrlData();
  96.         $this->_initParams();
  97.     }
  98.  
  99.     /**
  100.      * analyse the http request and sets the params property
  101.      */
  102.     abstract protected function _initParams();
  103.  
  104.     /**
  105.      * init the url* properties
  106.      */
  107.     protected function _initUrlData(){
  108.         $conf &jApp::config()->urlengine;
  109.  
  110.         $this->urlScript = $conf['urlScript'];
  111.         $this->urlScriptPath = $conf['urlScriptPath'];
  112.         $this->urlScriptName = $conf['urlScriptName'];
  113.  
  114.         $piiqp $conf['pathInfoInQueryParameter'];
  115.         if ($piiqp{
  116.             if (isset($_GET[$piiqp])) {
  117.                 $pathinfo $_GET[$piiqp];
  118.                 unset($_GET[$piiqp]);
  119.             else
  120.                 $pathinfo '';
  121.         else if(isset($_SERVER['PATH_INFO'])){
  122.             $pathinfo $_SERVER['PATH_INFO'];
  123.         else if(isset($_SERVER['ORIG_PATH_INFO'])){
  124.             $pathinfo $_SERVER['ORIG_PATH_INFO'];
  125.         else
  126.             $pathinfo '';
  127.  
  128.         if($pathinfo == $this->urlScript{
  129.             //when php is used as cgi and if there isn't pathinfo in the url
  130.             $pathinfo '';
  131.         }
  132.  
  133.         if (jApp::config()->isWindows && $pathinfo && strpos($pathinfo$this->urlScript!== false){
  134.             //under IIS, we may get  /subdir/index.php/mypath/myaction as PATH_INFO, so we fix it
  135.             $pathinfo substr ($pathinfostrlen ($this->urlScript));
  136.         }
  137.  
  138.         $this->urlPathInfo = $pathinfo;
  139.     }
  140.  
  141.     /**
  142.      * retrieve module and action
  143.      * fills also $module and $action properties
  144.      */
  145.     public function getModuleAction({
  146.         $conf jApp::config();
  147.  
  148.         if (isset($this->params['module']&& trim($this->params['module']!= ''{
  149.             $this->module = $this->params['module'];
  150.         }
  151.         else {
  152.             $this->module = $conf->startModule;
  153.         }
  154.  
  155.         if (isset($this->params['action']&& trim($this->params['action']!= ''{
  156.             $this->action = $this->params['action'];
  157.         }
  158.         else {
  159.             if($this->module == $conf->startModule)
  160.                 $this->action = $conf->startAction;
  161.             else {
  162.                 $this->action = 'default:index';
  163.             }
  164.         }
  165.         return array($this->module$this->action);
  166.     }
  167.  
  168.     /**
  169.     * Gets the value of a request parameter. If not defined, gets its default value.
  170.     * @param string  $name           the name of the request parameter
  171.     * @param mixed   $defaultValue   the default returned value if the parameter doesn't exists
  172.     * @param boolean $useDefaultIfEmpty true: says to return the default value if the parameter value is ""
  173.     * @return mixed the request parameter value
  174.     */
  175.     public function getParam($name$defaultValue=null$useDefaultIfEmpty=false){
  176.  
  177.         if(isset($this->params[$name])){
  178.             if($useDefaultIfEmpty && trim($this->params[$name]== ''){
  179.                 return $defaultValue;
  180.             }else{
  181.                 return $this->params[$name];
  182.             }
  183.         }else{
  184.             return $defaultValue;
  185.         }
  186.     }
  187.  
  188.     /**
  189.      * @param jResponse $response the response
  190.      * @return boolean true if the given class is allowed for the current request
  191.      */
  192.     public function isAllowedResponse($response){
  193.         return ( ($response instanceof $this->authorizedResponseClass)
  194.                 || ($c get_class($response)) == 'jResponseRedirect'
  195.                 || $c == 'jResponseRedirectUrl'
  196.                 );
  197.     }
  198.  
  199.     /**
  200.      * get a response object.
  201.      * @param string $name the name of the response type (ex: "html")
  202.      * @param boolean $useOriginal true:don't use the response object redefined by the application
  203.      * @return jResponse the response object
  204.      */
  205.     public function getResponse($type=''$useOriginal false){
  206.  
  207.         if($type == ''){
  208.             $type $this->defaultResponseType;
  209.         }
  210.  
  211.         if ($useOriginal)
  212.             $responses &jApp::config()->_coreResponses;
  213.         else
  214.             $responses &jApp::config()->responses;
  215.  
  216.         $coord jApp::coord();
  217.         if(!isset($responses[$type])){
  218.             if ($coord->action{
  219.                $action $coord->action->resource;
  220.                $path $coord->action->getPath();
  221.             }
  222.             else {
  223.                $action $coord->moduleName.'~'.$coord->actionName;
  224.                $path '';
  225.             }
  226.             if ($type == $this->defaultResponseType)
  227.                throw new jException('jelix~errors.default.response.type.unknown',array($action,$type));
  228.             else
  229.                throw new jException('jelix~errors.ad.response.type.unknown',array($action$type$path));
  230.         }
  231.  
  232.         $respclass $responses[$type];
  233.         $path $responses[$type.'.path'];
  234.  
  235.         if(!class_exists($respclass,false))
  236.             require($path);
  237.         $response new $respclass();
  238.  
  239.         if (!$this->isAllowedResponse($response)){
  240.             throw new jException('jelix~errors.ad.response.type.notallowed',array($coord->action->resource$type$coord->action->getPath()));
  241.         }
  242.  
  243.         $coord->response $response;
  244.  
  245.         return $response;
  246.     }
  247.  
  248.     /**
  249.      * @return jResponse 
  250.      */
  251.     public function getErrorResponse($currentResponse{
  252.       try {
  253.          return $this->getResponse(''true);
  254.       }
  255.       catch(Exception $e{
  256.          require_once(JELIX_LIB_CORE_PATH.'response/jResponseText.class.php');
  257.          return new jResponseText();
  258.       }
  259.     }
  260.  
  261.     /**
  262.      * return the ip address of the user
  263.      * @return string the ip
  264.      */
  265.     function getIP({
  266.         if (isset ($_SERVER['HTTP_X_FORWARDED_FOR']&& $_SERVER['HTTP_X_FORWARDED_FOR']){
  267.             // it may content ips of all traversed proxies.
  268.             $list preg_split('/[\s,]+/'$_SERVER['HTTP_X_FORWARDED_FOR']);
  269.             $list array_reverse($list);
  270.             $lastIp '';
  271.             foreach($list as $ip{
  272.                 $ip trim($ip);
  273.                 if(preg_match('/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/',$ip,$m)) {
  274.                     if ($m[1== '10' || $m[1== '010'
  275.                         || ($m[1== '172' && (intval($m[2]240 == 16))
  276.                         || ($m[1== '192' && $m[2== '168'))
  277.                         break// stop at first private address. we just want the last public address
  278.                     $lastIp $ip;
  279.                 }
  280.                 elseif (preg_match('/^(?:[a-f0-9]{1,4})(?::(?:[a-f0-9]{1,4})){7}$/i',$ip)) {
  281.                     $lastIp $ip;
  282.                 }
  283.             }
  284.             if ($lastIp)
  285.                 return $lastIp;
  286.         }
  287.  
  288.         if (isset ($_SERVER['HTTP_CLIENT_IP']&& $_SERVER['HTTP_CLIENT_IP']){
  289.             return  $_SERVER['HTTP_CLIENT_IP'];
  290.         }else{
  291.             return $_SERVER['REMOTE_ADDR'];
  292.         }
  293.     }
  294.  
  295.     /**
  296.      * return the protocol
  297.      * @return string  http:// or https://
  298.      * @since 1.2
  299.      */
  300.    function getProtocol({
  301.       return (isset($_SERVER['HTTPS']&& $_SERVER['HTTPS'&& $_SERVER['HTTPS'!= 'off' 'https://':'http://');
  302.    }
  303.  
  304.    /**
  305.     * says if this is an ajax request
  306.     * @return boolean true if it is an ajax request
  307.     * @since 1.3a1
  308.     */
  309.    function isAjax({
  310.       if (isset($_SERVER['HTTP_X_REQUESTED_WITH']))
  311.          return ($_SERVER['HTTP_X_REQUESTED_WITH'=== "XMLHttpRequest");
  312.       else
  313.          return false;
  314.    }
  315.  
  316.    /**
  317.     * return the application domain name
  318.     * @return string 
  319.     * @since 1.2.3
  320.     */
  321.    function getDomainName({
  322.       if (jApp::config()->domainName != ''{
  323.          return jApp::config()->domainName;
  324.       }
  325.       elseif (isset($_SERVER['SERVER_NAME'])) {
  326.          return $_SERVER['SERVER_NAME'];
  327.       }
  328.       elseif (isset($_SERVER['HTTP_HOST'])) {
  329.          if (($pos strpos($_SERVER['HTTP_HOST']':')) !== false)
  330.             return substr($_SERVER['HTTP_HOST'],0$pos);
  331.          return $_SERVER['HTTP_HOST'];
  332.       }
  333.       return '';
  334.    }
  335.  
  336.    /**
  337.     * return the server URI of the application (protocol + server name + port)
  338.     * @return string the serveur uri
  339.     * @since 1.2.4
  340.     */
  341.    function getServerURI($forceHttps null{
  342.       $isHttps (isset($_SERVER['HTTPS']&& $_SERVER['HTTPS'&& $_SERVER['HTTPS'!= 'off');
  343.  
  344.       if ( ($forceHttps === null && $isHttps|| $forceHttps{
  345.          $uri 'https://';
  346.       }
  347.       else {
  348.          $uri 'http://';
  349.       }
  350.  
  351.       $uri .= $this->getDomainName();
  352.       $uri .= $this->getPort($forceHttps);
  353.       return $uri;
  354.    }
  355.  
  356.    /**
  357.     * return the server port of the application
  358.     * @return string the ":port" or empty string
  359.     * @since 1.2.4
  360.     */
  361.    function getPort($forceHttps null{
  362.       $isHttps (isset($_SERVER['HTTPS']&& $_SERVER['HTTPS'&& $_SERVER['HTTPS'!= 'off');
  363.  
  364.       if ($forceHttps === null)
  365.          $https $isHttps;
  366.       else
  367.          $https $forceHttps;
  368.  
  369.       $forcePort ($https jApp::config()->forceHTTPSPort jApp::config()->forceHTTPPort);
  370.       if ($forcePort === true{
  371.          return '';
  372.       }
  373.       else if ($forcePort// a number
  374.          $port $forcePort;
  375.       }
  376.       else if($isHttps != $https || !isset($_SERVER['SERVER_PORT'])) {
  377.          // the asked protocol is different from the current protocol
  378.          // we use the standard port for the asked protocol
  379.          return '';
  380.       else {
  381.          $port $_SERVER['SERVER_PORT'];
  382.       }
  383.       if (($port === NULL|| ($port == ''|| ($https && $port == '443' || (!$https && $port == '80' ))
  384.          return '';
  385.       return ':'.$port;
  386.    }
  387.  
  388.    /**
  389.     * call it when you want to read the content of the body of a request
  390.     * when the method is not GET or POST
  391.     * @return mixed    array of parameters or a single string when the content-type is unknown
  392.     * @since 1.2
  393.     */
  394.    public function readHttpBody({
  395.       $input file_get_contents("php://input");
  396.       $values array();
  397.  
  398.       if (strpos($_SERVER["CONTENT_TYPE"]"application/x-www-form-urlencoded"=== 0{
  399.          parse_str($input$values);
  400.          return $values;
  401.       }
  402.       else if (strpos($_SERVER["CONTENT_TYPE"]"multipart/form-data"=== 0{
  403.  
  404.          if (!preg_match("/boundary=([a-zA-Z0-9]+)/"$_SERVER["CONTENT_TYPE"]$m))
  405.             return $input;
  406.  
  407.          $parts explode('--'.$m[1]$input);
  408.          foreach($parts as $part{
  409.             if (trim($part== '' || $part == '--')
  410.                continue;
  411.             list($header$valueexplode("\r\n\r\n"$part);
  412.             if (preg_match('/content\-disposition\:(?: *)form\-data\;(?: *)name="([^"]+)"(\;(?: *)filename="([^"]+)")?/i'$header$m)) {
  413.                if (isset($m[2]&& $m[3!= '')
  414.                   $return[$m[1]] array$m[3]$value);
  415.                else
  416.                   $return[$m[1]] $value;
  417.             }
  418.          }
  419.          if (count($values))
  420.             return $values;
  421.          else
  422.             return $input;
  423.       }
  424.       else {
  425.          return $input;
  426.       }
  427.    }
  428.  
  429.    private $_headers null;
  430.  
  431.    private function _generateHeaders({
  432.       if (is_null($this->_headers)) {
  433.          if (function_exists('apache_response_headers')) {
  434.             $this->_headers apache_request_headers();
  435.          }
  436.          else {
  437.             $this->_headers array();
  438.  
  439.             foreach($_SERVER as $key => $value{
  440.                if (substr($key,0,5== "HTTP_"{
  441.                   $key str_replace(" ""-",
  442.                           ucwords(strtolower(str_replace('_'' 'substr($key,5)))));
  443.                   $this->_headers[$key$value;
  444.                }
  445.             }
  446.          }
  447.       }
  448.    }
  449.  
  450.    public function header($name{
  451.       $this->_generateHeaders();
  452.       if (isset($this->_headers[$name])) {
  453.          return $this->_headers[$name];
  454.       }
  455.       return null;
  456.    }
  457.  
  458.    public function headers({
  459.       $this->_generateHeaders();
  460.       return $this->_headers;
  461.    }
  462.  
  463.  
  464. }

Documentation generated on Mon, 26 Oct 2015 21:55:22 +0100 by phpDocumentor 1.4.3