includes/FauxRequest.php

   1 <?php
   2 /**
   3  * Deal with importing all those nasty globals and things
   4  *
   5  * Copyright © 2003 Brion Vibber <brion@pobox.com>
   6  * https://www.mediawiki.org/
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  21  * http://www.gnu.org/copyleft/gpl.html
  22  *
  23  * @file
  24  */
  25
  26 use MediaWiki\Session\SessionManager;
  27
  28 /**
  29  * WebRequest clone which takes values from a provided array.
  30  *
  31  * @ingroup HTTP
  32  */
  33 class FauxRequest extends WebRequest {
  34         private $wasPosted = false;
  35         private $requestUrl;
  36         protected $cookies = [];
  37
  38         /**
  39          * @param array $data Array of *non*-urlencoded key => value pairs, the
  40          *   fake GET/POST values
  41          * @param bool $wasPosted Whether to treat the data as POST
  42          * @param MediaWiki\Session\Session|array|null $session Session, session
  43          *  data array, or null
  44          * @param string $protocol 'http' or 'https'
  45          * @throws MWException
  46          */
  47         public function __construct( $data = [], $wasPosted = false,
  48                 $session = null, $protocol = 'http'
  49         ) {
  50                 $this->requestTime = microtime( true );
  51
  52                 if ( is_array( $data ) ) {
  53                         $this->data = $data;
  54                 } else {
  55                         throw new MWException( "FauxRequest() got bogus data" );
  56                 }
  57                 $this->wasPosted = $wasPosted;
  58                 if ( $session instanceof MediaWiki\Session\Session ) {
  59                         $this->sessionId = $session->getSessionId();
  60                 } elseif ( is_array( $session ) ) {
  61                         $mwsession = SessionManager::singleton()->getEmptySession( $this );
  62                         $this->sessionId = $mwsession->getSessionId();
  63                         foreach ( $session as $key => $value ) {
  64                                 $mwsession->set( $key, $value );
  65                         }
  66                 } elseif ( $session !== null ) {
  67                         throw new MWException( "FauxRequest() got bogus session" );
  68                 }
  69                 $this->protocol = $protocol;
  70         }
  71
  72         /**
  73          * Initialise the header list
  74          */
  75         protected function initHeaders() {
  76                 // Nothing to init
  77         }
  78
  79         /**
  80          * @param string $name
  81          * @param string $default
  82          * @return string
  83          */
  84         public function getText( $name, $default = '' ) {
  85                 # Override; don't recode since we're using internal data
  86                 return (string)$this->getVal( $name, $default );
  87         }
  88
  89         /**
  90          * @return array
  91          */
  92         public function getValues() {
  93                 return $this->data;
  94         }
  95
  96         /**
  97          * @return array
  98          */
  99         public function getQueryValues() {
 100                 if ( $this->wasPosted ) {
 101                         return [];
 102                 } else {
 103                         return $this->data;
 104                 }
 105         }
 106
 107         public function getMethod() {
 108                 return $this->wasPosted ? 'POST' : 'GET';
 109         }
 110
 111         /**
 112          * @return bool
 113          */
 114         public function wasPosted() {
 115                 return $this->wasPosted;
 116         }
 117
 118         public function getCookie( $key, $prefix = null, $default = null ) {
 119                 if ( $prefix === null ) {
 120                         global $wgCookiePrefix;
 121                         $prefix = $wgCookiePrefix;
 122                 }
 123                 $name = $prefix . $key;
 124                 return $this->cookies[$name] ?? $default;
 125         }
 126
 127         /**
 128          * @since 1.26
 129          * @param string $key Unprefixed name of the cookie to set
 130          * @param string|null $value Value of the cookie to set
 131          * @param string|null $prefix Cookie prefix. Defaults to $wgCookiePrefix
 132          */
 133         public function setCookie( $key, $value, $prefix = null ) {
 134                 $this->setCookies( [ $key => $value ], $prefix );
 135         }
 136
 137         /**
 138          * @since 1.26
 139          * @param array $cookies
 140          * @param string|null $prefix Cookie prefix. Defaults to $wgCookiePrefix
 141          */
 142         public function setCookies( $cookies, $prefix = null ) {
 143                 if ( $prefix === null ) {
 144                         global $wgCookiePrefix;
 145                         $prefix = $wgCookiePrefix;
 146                 }
 147                 foreach ( $cookies as $key => $value ) {
 148                         $name = $prefix . $key;
 149                         $this->cookies[$name] = $value;
 150                 }
 151         }
 152
 153         /**
 154          * @since 1.25
 155          * @param string $url
 156          */
 157         public function setRequestURL( $url ) {
 158                 $this->requestUrl = $url;
 159         }
 160
 161         /**
 162          * @since 1.25 MWException( "getRequestURL not implemented" )
 163          * no longer thrown.
 164          * @return string
 165          */
 166         public function getRequestURL() {
 167                 if ( $this->requestUrl === null ) {
 168                         throw new MWException( 'Request URL not set' );
 169                 }
 170                 return $this->requestUrl;
 171         }
 172
 173         public function getProtocol() {
 174                 return $this->protocol;
 175         }
 176
 177         /**
 178          * @param string $name
 179          * @param string $val
 180          */
 181         public function setHeader( $name, $val ) {
 182                 $this->setHeaders( [ $name => $val ] );
 183         }
 184
 185         /**
 186          * @since 1.26
 187          * @param array $headers
 188          */
 189         public function setHeaders( $headers ) {
 190                 foreach ( $headers as $name => $val ) {
 191                         $name = strtoupper( $name );
 192                         $this->headers[$name] = $val;
 193                 }
 194         }
 195
 196         /**
 197          * @return array|null
 198          */
 199         public function getSessionArray() {
 200                 if ( $this->sessionId !== null ) {
 201                         return iterator_to_array( $this->getSession() );
 202                 }
 203                 return null;
 204         }
 205
 206         /**
 207          * FauxRequests shouldn't depend on raw request data (but that could be implemented here)
 208          * @return string
 209          */
 210         public function getRawQueryString() {
 211                 return '';
 212         }
 213
 214         /**
 215          * FauxRequests shouldn't depend on raw request data (but that could be implemented here)
 216          * @return string
 217          */
 218         public function getRawPostString() {
 219                 return '';
 220         }
 221
 222         /**
 223          * FauxRequests shouldn't depend on raw request data (but that could be implemented here)
 224          * @return string
 225          */
 226         public function getRawInput() {
 227                 return '';
 228         }
 229
 230         /**
 231          * @codeCoverageIgnore
 232          * @param array $extWhitelist
 233          * @return bool
 234          */
 235         public function checkUrlExtension( $extWhitelist = [] ) {
 236                 return true;
 237         }
 238
 239         /**
 240          * @codeCoverageIgnore
 241          * @return string
 242          */
 243         protected function getRawIP() {
 244                 return '127.0.0.1';
 245         }
 246 }