Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
60.11% covered (warning)
60.11%
214 / 356
44.44% covered (danger)
44.44%
28 / 63
CRAP
0.00% covered (danger)
0.00%
0 / 1
WebRequest
60.28% covered (warning)
60.28%
214 / 355
44.44% covered (danger)
44.44%
28 / 63
2186.61
0.00% covered (danger)
0.00%
0 / 1
 __construct
n/a
0 / 0
n/a
0 / 0
1
 getServerInfo
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
2
 getPathInfo
0.00% covered (danger)
0.00%
0 / 38
0.00% covered (danger)
0.00%
0 / 1
156
 getRequestPathSuffix
100.00% covered (success)
100.00%
9 / 9
100.00% covered (success)
100.00%
1 / 1
3
 detectServer
100.00% covered (success)
100.00%
21 / 21
100.00% covered (success)
100.00%
1 / 1
9
 detectProtocol
100.00% covered (success)
100.00%
5 / 5
100.00% covered (success)
100.00%
1 / 1
5
 getElapsedTime
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 getRequestId
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 overrideRequestId
0.00% covered (danger)
0.00%
0 / 4
0.00% covered (danger)
0.00%
0 / 1
6
 getProtocol
0.00% covered (danger)
0.00%
0 / 2
0.00% covered (danger)
0.00%
0 / 1
2
 interpolateTitle
0.00% covered (danger)
0.00%
0 / 3
0.00% covered (danger)
0.00%
0 / 1
6
 extractTitle
0.00% covered (danger)
0.00%
0 / 10
0.00% covered (danger)
0.00%
0 / 1
30
 normalizeUnicode
100.00% covered (success)
100.00%
6 / 6
100.00% covered (success)
100.00%
1 / 1
3
 getGPCVal
75.00% covered (warning)
75.00%
9 / 12
0.00% covered (danger)
0.00%
0 / 1
6.56
 getRawVal
100.00% covered (success)
100.00%
5 / 5
100.00% covered (success)
100.00%
1 / 1
4
 getVal
100.00% covered (success)
100.00%
4 / 4
100.00% covered (success)
100.00%
1 / 1
3
 getText
100.00% covered (success)
100.00%
2 / 2
100.00% covered (success)
100.00%
1 / 1
1
 setVal
0.00% covered (danger)
0.00%
0 / 3
0.00% covered (danger)
0.00%
0 / 1
2
 unsetVal
0.00% covered (danger)
0.00%
0 / 5
0.00% covered (danger)
0.00%
0 / 1
6
 getArray
100.00% covered (success)
100.00%
4 / 4
100.00% covered (success)
100.00%
1 / 1
2
 getIntArray
100.00% covered (success)
100.00%
4 / 4
100.00% covered (success)
100.00%
1 / 1
2
 getInt
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 getIntOrNull
100.00% covered (success)
100.00%
2 / 2
100.00% covered (success)
100.00%
1 / 1
2
 getFloat
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 getBool
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 getFuzzyBool
100.00% covered (success)
100.00%
4 / 4
100.00% covered (success)
100.00%
1 / 1
3
 getCheck
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 getValues
100.00% covered (success)
100.00%
8 / 8
100.00% covered (success)
100.00%
1 / 1
4
 getValueNames
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 getQueryValues
n/a
0 / 0
n/a
0 / 0
1
 getQueryValuesOnly
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getPostValues
n/a
0 / 0
n/a
0 / 0
1
 getRawQueryString
n/a
0 / 0
n/a
0 / 0
1
 getRawPostString
0.00% covered (danger)
0.00%
0 / 3
0.00% covered (danger)
0.00%
0 / 1
6
 getRawInput
0.00% covered (danger)
0.00%
0 / 3
0.00% covered (danger)
0.00%
0 / 1
2
 getMethod
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
6
 wasPosted
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getSession
100.00% covered (success)
100.00%
7 / 7
100.00% covered (success)
100.00%
1 / 1
3
 setSessionId
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 getSessionId
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 getCookie
88.89% covered (warning)
88.89%
8 / 9
0.00% covered (danger)
0.00%
0 / 1
4.02
 getCrossSiteCookie
0.00% covered (danger)
0.00%
0 / 2
0.00% covered (danger)
0.00%
0 / 1
2
 getGlobalRequestURL
30.00% covered (danger)
30.00%
6 / 20
0.00% covered (danger)
0.00%
0 / 1
44.30
 getRequestURL
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
1
 getFullRequestURL
100.00% covered (success)
100.00%
4 / 4
100.00% covered (success)
100.00%
1 / 1
2
 appendQueryValue
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 appendQueryArray
0.00% covered (danger)
0.00%
0 / 4
0.00% covered (danger)
0.00%
0 / 1
2
 getLimitOffsetForUser
0.00% covered (danger)
0.00%
0 / 15
0.00% covered (danger)
0.00%
0 / 1
56
 getFileTempname
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getUploadError
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getFileName
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getUpload
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 response
0.00% covered (danger)
0.00%
0 / 3
0.00% covered (danger)
0.00%
0 / 1
6
 initHeaders
100.00% covered (success)
100.00%
3 / 3
100.00% covered (success)
100.00%
1 / 1
2
 getAllHeaders
0.00% covered (danger)
0.00%
0 / 2
0.00% covered (danger)
0.00%
0 / 1
2
 getHeader
100.00% covered (success)
100.00%
8 / 8
100.00% covered (success)
100.00%
1 / 1
3
 getSessionData
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 setSessionData
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 getAcceptLang
100.00% covered (success)
100.00%
20 / 20
100.00% covered (success)
100.00%
1 / 1
5
 getRawIP
83.33% covered (warning)
83.33%
5 / 6
0.00% covered (danger)
0.00%
0 / 1
3.04
 getIP
92.50% covered (success)
92.50%
37 / 40
0.00% covered (danger)
0.00%
0 / 1
16.11
 canonicalizeIPv6LoopbackAddress
66.67% covered (warning)
66.67%
2 / 3
0.00% covered (danger)
0.00%
0 / 1
2.15
 setIP
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 hasSafeMethod
0.00% covered (danger)
0.00%
0 / 3
0.00% covered (danger)
0.00%
0 / 1
6
 isSafeRequest
0.00% covered (danger)
0.00%
0 / 4
0.00% covered (danger)
0.00%
0 / 1
12
 markAsSafeRequest
0.00% covered (danger)
0.00%
0 / 2
0.00% covered (danger)
0.00%
0 / 1
2
 matchURLForCDN
100.00% covered (success)
100.00%
21 / 21
100.00% covered (success)
100.00%
1 / 1
8
1<?php
2/**
3 * Deal with importing all those nasty globals and things
4 *
5 * Copyright © 2003 Brooke Vibber <bvibber@wikimedia.org>
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
26namespace MediaWiki\Request;
27
28use FatalError;
29use MediaWiki\HookContainer\HookRunner;
30use MediaWiki\Http\Telemetry;
31use MediaWiki\MainConfigNames;
32use MediaWiki\MediaWikiServices;
33use MediaWiki\Session\Session;
34use MediaWiki\Session\SessionId;
35use MediaWiki\Session\SessionManager;
36use MediaWiki\User\UserIdentity;
37use MWException;
38use Wikimedia\IPUtils;
39
40// The point of this class is to be a wrapper around super globals
41// phpcs:disable MediaWiki.Usage.SuperGlobalsUsage.SuperGlobals
42
43/**
44 * The WebRequest class encapsulates getting at data passed in the
45 * URL or via a POSTed form, stripping illegal input characters, and
46 * normalizing Unicode sequences. This class should be used instead
47 * of accessing globals such as $_GET, $_POST, and $_COOKIE.
48 *
49 * @ingroup HTTP
50 */
51class WebRequest {
52    /**
53     * The parameters from $_GET, $_POST and the path router
54     * @var array
55     */
56    protected $data;
57
58    /**
59     * The parameters from $_GET. The parameters from the path router are
60     * added by interpolateTitle() during Setup.php.
61     * @var (string|string[])[]
62     */
63    protected $queryAndPathParams;
64
65    /**
66     * The parameters from $_GET only.
67     * @var (string|string[])[]
68     */
69    protected $queryParams;
70
71    /**
72     * Lazy-initialized request headers indexed by upper-case header name
73     * @var string[]
74     */
75    protected $headers = [];
76
77    /**
78     * Flag to make WebRequest::getHeader return an array of values.
79     * @since 1.26
80     */
81    public const GETHEADER_LIST = 1;
82
83    /**
84     * Lazy-init response object
85     * @var WebResponse
86     */
87    protected ?WebResponse $response = null;
88
89    /**
90     * Cached client IP address
91     * @var string
92     */
93    private $ip;
94
95    /**
96     * The timestamp of the start of the request, with microsecond precision.
97     * @var float
98     */
99    protected $requestTime;
100
101    /**
102     * Cached URL protocol
103     * @var string
104     */
105    protected $protocol;
106
107    /**
108     * @var SessionId|null Session ID to use for this
109     *  request. We can't save the session directly due to reference cycles not
110     *  working too well (slow GC).
111     *
112     * TODO: Investigate whether this GC slowness concern (added in a73c5b7395 with regard to
113     * PHP 5.6) still applies in PHP 7.2+.
114     */
115    protected $sessionId = null;
116
117    /** @var bool Whether this HTTP request is "safe" (even if it is an HTTP post) */
118    protected $markedAsSafe = false;
119
120    /**
121     * @codeCoverageIgnore
122     */
123    public function __construct() {
124        $this->requestTime = $_SERVER['REQUEST_TIME_FLOAT'];
125
126        // POST overrides GET data
127        // We don't use $_REQUEST here to avoid interference from cookies...
128        $this->data = $_POST + $_GET;
129
130        $this->queryAndPathParams = $this->queryParams = $_GET;
131    }
132
133    /**
134     * Returns an entry from the $_SERVER array.
135     * This exists mainly to allow us to inject fake values for testing.
136     *
137     * @param string $name A well known key for $_SERVER,
138     *        see <https://www.php.net/manual/en/reserved.variables.server.php>.
139     *        Only fields that contain string values are supported,
140     *        so 'argv' and 'argc' are not safe to use.
141     * @param ?string $default The value to return if no value is known for the
142     *        key $name.
143     *
144     * @return ?string
145     */
146    protected function getServerInfo( string $name, ?string $default = null ): ?string {
147        return isset( $_SERVER[$name] ) ? (string)$_SERVER[$name] : $default;
148    }
149
150    /**
151     * Extract relevant query arguments from the http request uri's path
152     * to be merged with the normal php provided query arguments.
153     * Tries to use the REQUEST_URI data if available and parses it
154     * according to the wiki's configuration looking for any known pattern.
155     *
156     * If the REQUEST_URI is not provided we'll fall back on the PATH_INFO
157     * provided by the server if any and use that to set a 'title' parameter.
158     *
159     * This internal method handles many odd cases and is tailored specifically for
160     * used by WebRequest::interpolateTitle, for index.php requests.
161     * Consider using WebRequest::getRequestPathSuffix for other path-related use cases.
162     *
163     * @param string $want If this is not 'all', then the function
164     * will return an empty array if it determines that the URL is
165     * inside a rewrite path.
166     *
167     * @return string[] Any query arguments found in path matches.
168     * @throws FatalError If invalid routes are configured (T48998)
169     */
170    protected function getPathInfo( $want = 'all' ) {
171        // PATH_INFO is mangled due to https://bugs.php.net/bug.php?id=31892
172        // And also by Apache 2.x, double slashes are converted to single slashes.
173        // So we will use REQUEST_URI if possible.
174        $url = $this->getServerInfo( 'REQUEST_URI' );
175        if ( $url !== null ) {
176            // Slurp out the path portion to examine...
177            if ( !preg_match( '!^https?://!', $url ) ) {
178                $url = 'http://unused' . $url;
179            }
180            $a = parse_url( $url );
181            if ( !$a ) {
182                return [];
183            }
184            $path = $a['path'] ?? '';
185
186            global $wgScript;
187            if ( $path == $wgScript && $want !== 'all' ) {
188                // Script inside a rewrite path?
189                // Abort to keep from breaking...
190                return [];
191            }
192
193            $router = new PathRouter;
194
195            // Raw PATH_INFO style
196            $router->add( "$wgScript/$1" );
197
198            global $wgArticlePath;
199            if ( $wgArticlePath ) {
200                $router->validateRoute( $wgArticlePath, 'wgArticlePath' );
201                $router->add( $wgArticlePath );
202            }
203
204            global $wgActionPaths;
205            $articlePaths = PathRouter::getActionPaths( $wgActionPaths, $wgArticlePath );
206            if ( $articlePaths ) {
207                $router->add( $articlePaths, [ 'action' => '$key' ] );
208            }
209
210            $services = MediaWikiServices::getInstance();
211            global $wgVariantArticlePath;
212            if ( $wgVariantArticlePath ) {
213                $router->validateRoute( $wgVariantArticlePath, 'wgVariantArticlePath' );
214                $router->add( $wgVariantArticlePath,
215                    [ 'variant' => '$2' ],
216                    [ '$2' => $services->getLanguageConverterFactory()
217                        ->getLanguageConverter( $services->getContentLanguage() )
218                        ->getVariants() ]
219                );
220            }
221
222            ( new HookRunner( $services->getHookContainer() ) )->onWebRequestPathInfoRouter( $router );
223
224            $matches = $router->parse( $path );
225        } else {
226            global $wgUsePathInfo;
227            $matches = [];
228            if ( $wgUsePathInfo ) {
229                $origPathInfo = $this->getServerInfo( 'ORIG_PATH_INFO' ) ?? '';
230                $pathInfo = $this->getServerInfo( 'PATH_INFO' ) ?? '';
231                if ( $origPathInfo !== '' ) {
232                    // Mangled PATH_INFO
233                    // https://bugs.php.net/bug.php?id=31892
234                    // Also reported when ini_get('cgi.fix_pathinfo')==false
235                    $matches['title'] = substr( $origPathInfo, 1 );
236                } elseif ( $pathInfo !== '' ) {
237                    // Regular old PATH_INFO yay
238                    $matches['title'] = substr( $pathInfo, 1 );
239                }
240            }
241        }
242
243        return $matches;
244    }
245
246    /**
247     * If the request URL matches a given base path, extract the path part of
248     * the request URL after that base, and decode escape sequences in it.
249     *
250     * If the request URL does not match, false is returned.
251     *
252     * @since 1.35
253     * @param string $basePath The base URL path. Trailing slashes will be
254     *   stripped.
255     * @param ?string $requestUrl The request URL to examine. If not given, the
256     *   URL returned by getGlobalRequestURL() will be used.
257     * @return string|false
258     */
259    public static function getRequestPathSuffix( string $basePath, ?string $requestUrl = null ) {
260        $basePath = rtrim( $basePath, '/' ) . '/';
261        $requestUrl ??= self::getGlobalRequestURL();
262        $qpos = strpos( $requestUrl, '?' );
263        if ( $qpos !== false ) {
264            $requestPath = substr( $requestUrl, 0, $qpos );
265        } else {
266            $requestPath = $requestUrl;
267        }
268        if ( !str_starts_with( $requestPath, $basePath ) ) {
269            return false;
270        }
271        return rawurldecode( substr( $requestPath, strlen( $basePath ) ) );
272    }
273
274    /**
275     * Work out an appropriate URL prefix containing scheme and host, based on
276     * information detected from $_SERVER
277     *
278     * @param bool|null $assumeProxiesUseDefaultProtocolPorts When the wiki is running behind a proxy
279     * and this is set to true, assumes that the proxy exposes the wiki on the standard ports
280     * (443 for https and 80 for http). Added in 1.38. Calls without this argument are
281     * supported for backwards compatibility but deprecated.
282     *
283     * @return string
284     */
285    public static function detectServer( $assumeProxiesUseDefaultProtocolPorts = null ) {
286        $assumeProxiesUseDefaultProtocolPorts ??= $GLOBALS['wgAssumeProxiesUseDefaultProtocolPorts'];
287
288        $proto = self::detectProtocol();
289        $stdPort = $proto === 'https' ? 443 : 80;
290
291        $varNames = [ 'HTTP_HOST', 'SERVER_NAME', 'HOSTNAME', 'SERVER_ADDR' ];
292        $host = 'localhost';
293        $port = $stdPort;
294        foreach ( $varNames as $varName ) {
295            if ( !isset( $_SERVER[$varName] ) ) {
296                continue;
297            }
298
299            $parts = IPUtils::splitHostAndPort( $_SERVER[$varName] );
300            if ( !$parts ) {
301                // Invalid, do not use
302                continue;
303            }
304
305            $host = $parts[0];
306            if ( $assumeProxiesUseDefaultProtocolPorts && isset( $_SERVER['HTTP_X_FORWARDED_PROTO'] ) ) {
307                // T72021: Assume that upstream proxy is running on the default
308                // port based on the protocol. We have no reliable way to determine
309                // the actual port in use upstream.
310                $port = $stdPort;
311            } elseif ( $parts[1] === false ) {
312                if ( isset( $_SERVER['SERVER_PORT'] ) ) {
313                    $port = intval( $_SERVER['SERVER_PORT'] );
314                } // else leave it as $stdPort
315            } else {
316                $port = $parts[1];
317            }
318            break;
319        }
320
321        return $proto . '://' . IPUtils::combineHostAndPort( $host, $port, $stdPort );
322    }
323
324    /**
325     * Detect the protocol from $_SERVER.
326     * This is for use prior to Setup.php, when no WebRequest object is available.
327     * At other times, use the non-static function getProtocol().
328     *
329     * @return string
330     */
331    public static function detectProtocol() {
332        if ( ( !empty( $_SERVER['HTTPS'] ) && $_SERVER['HTTPS'] !== 'off' ) ||
333            ( isset( $_SERVER['HTTP_X_FORWARDED_PROTO'] ) &&
334            $_SERVER['HTTP_X_FORWARDED_PROTO'] === 'https' ) ) {
335            return 'https';
336        } else {
337            return 'http';
338        }
339    }
340
341    /**
342     * Get the number of seconds to have elapsed since request start,
343     * in fractional seconds, with microsecond resolution.
344     *
345     * @return float
346     * @since 1.25
347     */
348    public function getElapsedTime() {
349        return microtime( true ) - $this->requestTime;
350    }
351
352    /**
353     * Get the current request ID.
354     *
355     * This is usually based on the `X-Request-Id` header, or the `UNIQUE_ID`
356     * environment variable, falling back to (process cached) randomly-generated string.
357     *
358     * @return string
359     * @since 1.27
360     */
361    public static function getRequestId() {
362        return Telemetry::getInstance()->getRequestId();
363    }
364
365    /**
366     * Override the unique request ID. This is for sub-requests, such as jobs,
367     * that wish to use the same id but are not part of the same execution context.
368     *
369     * @param string|null $newId
370     * @since 1.27
371     */
372    public static function overrideRequestId( $newId ) {
373        $telemetry = Telemetry::getInstance();
374        if ( $newId === null ) {
375            $telemetry->regenerateRequestId();
376        } else {
377            $telemetry->overrideRequestId( $newId );
378        }
379    }
380
381    /**
382     * Get the current URL protocol (http or https)
383     * @return string
384     */
385    public function getProtocol() {
386        $this->protocol ??= self::detectProtocol();
387        return $this->protocol;
388    }
389
390    /**
391     * Check for title, action, and/or variant data in the URL
392     * and interpolate it into the GET variables.
393     * This should only be run after the content language is available,
394     * as we may need the list of language variants to determine
395     * available variant URLs.
396     */
397    public function interpolateTitle() {
398        $matches = $this->getPathInfo( 'title' );
399        foreach ( $matches as $key => $val ) {
400            $this->data[$key] = $this->queryAndPathParams[$key] = $val;
401        }
402    }
403
404    /**
405     * URL rewriting function; tries to extract page title and,
406     * optionally, one other fixed parameter value from a URL path.
407     *
408     * @param string $path The URL path given from the client
409     * @param array $bases One or more URLs, optionally with $1 at the end
410     * @param string|false $key If provided, the matching key in $bases will be
411     *    passed on as the value of this URL parameter
412     * @return array Array of URL variables to interpolate; empty if no match
413     */
414    public static function extractTitle( $path, $bases, $key = false ) {
415        foreach ( (array)$bases as $keyValue => $base ) {
416            // Find the part after $wgArticlePath
417            $base = str_replace( '$1', '', $base );
418            if ( str_starts_with( $path, $base ) ) {
419                $raw = substr( $path, strlen( $base ) );
420                if ( $raw !== '' ) {
421                    $matches = [ 'title' => rawurldecode( $raw ) ];
422                    if ( $key ) {
423                        $matches[$key] = $keyValue;
424                    }
425                    return $matches;
426                }
427            }
428        }
429        return [];
430    }
431
432    /**
433     * Recursively normalizes UTF-8 strings in the given array.
434     *
435     * @param string|array $data
436     * @return array|string Cleaned-up version of the given
437     * @internal
438     */
439    public function normalizeUnicode( $data ) {
440        if ( is_array( $data ) ) {
441            foreach ( $data as $key => $val ) {
442                $data[$key] = $this->normalizeUnicode( $val );
443            }
444        } else {
445            $contLang = MediaWikiServices::getInstance()->getContentLanguage();
446            $data = $contLang->normalize( $data );
447        }
448        return $data;
449    }
450
451    /**
452     * Fetch a value from the given array or return $default if it's not set.
453     *
454     * @param array $arr
455     * @param string $name
456     * @param mixed $default
457     * @return mixed
458     * @return-taint tainted
459     */
460    private function getGPCVal( $arr, $name, $default ) {
461        # PHP is so nice to not touch input data, except sometimes:
462        # https://www.php.net/variables.external#language.variables.external.dot-in-names
463        # Work around PHP *feature* to avoid *bugs* elsewhere.
464        $name = strtr( $name, '.', '_' );
465
466        if ( !isset( $arr[$name] ) ) {
467            return $default;
468        }
469
470        $data = $arr[$name];
471        # Optimisation: Skip UTF-8 normalization and legacy transcoding for simple ASCII strings.
472        $isAsciiStr = ( is_string( $data ) && preg_match( '/[^\x20-\x7E]/', $data ) === 0 );
473        if ( !$isAsciiStr ) {
474            if ( isset( $_GET[$name] ) && is_string( $data ) ) {
475                # Check for alternate/legacy character encoding.
476                $data = MediaWikiServices::getInstance()
477                    ->getContentLanguage()
478                    ->checkTitleEncoding( $data );
479            }
480            $data = $this->normalizeUnicode( $data );
481        }
482
483        return $data;
484    }
485
486    /**
487     * Fetch a string from this web request's $_GET, $_POST or path router vars WITHOUT any
488     * Unicode or line break normalization. This is a fast alternative for values that are known
489     * to be simple, e.g. pure ASCII. When reading user input, use {@see getText} instead.
490     *
491     * Array values are discarded for security reasons. Use {@see getArray} or {@see getIntArray}.
492     *
493     * @since 1.28
494     * @param string $name
495     * @param string|null $default
496     * @return string|null The value, or $default if none set
497     * @return-taint tainted
498     */
499    public function getRawVal( $name, $default = null ) {
500        $name = strtr( $name, '.', '_' ); // See comment in self::getGPCVal()
501        if ( isset( $this->data[$name] ) && !is_array( $this->data[$name] ) ) {
502            $val = $this->data[$name];
503        } else {
504            $val = $default;
505        }
506
507        return $val === null ? null : (string)$val;
508    }
509
510    /**
511     * Fetch a text string from this web request's $_GET, $_POST or path router vars and partially
512     * normalize it.
513     *
514     * Use of this method is discouraged. It doesn't normalize line breaks and defaults to null
515     * instead of the empty string. Instead:
516     * - Use {@see getText} when reading user input or form fields that are expected to contain
517     *   non-ASCII characters.
518     * - Use {@see getRawVal} when reading ASCII strings, such as parameters used to select
519     *   predefined behaviour in the software.
520     *
521     * Array values are discarded for security reasons. Use {@see getArray} or {@see getIntArray}.
522     *
523     * @param string $name
524     * @param string|null $default
525     * @return string|null The input value, or $default if none set
526     * @return-taint tainted
527     */
528    public function getVal( $name, $default = null ) {
529        $val = $this->getGPCVal( $this->data, $name, $default );
530        if ( is_array( $val ) ) {
531            $val = $default;
532        }
533
534        return $val === null ? null : (string)$val;
535    }
536
537    /**
538     * Fetch a text string from this web request's $_GET, $_POST or path router vars and return it
539     * in normalized form.
540     *
541     * This normalizes Unicode sequences (via {@see getGPCVal}) and line breaks.
542     *
543     * This should be used for all user input and form fields that are expected to contain non-ASCII
544     * characters, especially if the value will be stored or compared against stored values. Without
545     * normalization, logically identically values might not match when they are typed on different
546     * OS' or keyboards.
547     *
548     * Array values are discarded for security reasons. Use {@see getArray} or {@see getIntArray}.
549     *
550     * @param string $name
551     * @param string $default
552     * @return string The normalized input value, or $default if none set
553     * @return-taint tainted
554     */
555    public function getText( $name, $default = '' ) {
556        $val = $this->getVal( $name, $default );
557        return str_replace( "\r\n", "\n", $val );
558    }
559
560    /**
561     * Set an arbitrary value into our get/post data.
562     *
563     * @param string $key Key name to use
564     * @param mixed $value Value to set
565     * @return mixed Old value if one was present, null otherwise
566     */
567    public function setVal( $key, $value ) {
568        $ret = $this->data[$key] ?? null;
569        $this->data[$key] = $value;
570        return $ret;
571    }
572
573    /**
574     * Unset an arbitrary value from our get/post data.
575     *
576     * @param string $key Key name to use
577     * @return mixed Old value if one was present, null otherwise
578     */
579    public function unsetVal( $key ) {
580        if ( !isset( $this->data[$key] ) ) {
581            $ret = null;
582        } else {
583            $ret = $this->data[$key];
584            unset( $this->data[$key] );
585        }
586        return $ret;
587    }
588
589    /**
590     * Fetch an array from this web request's $_GET, $_POST or path router vars,
591     * or return $default if it's not set. If source was scalar, will return an
592     * array with a single element. If no source and no default, returns null.
593     *
594     * @param string $name
595     * @param array|null $default Optional default (or null)
596     * @return array|null
597     * @return-taint tainted
598     */
599    public function getArray( $name, $default = null ) {
600        $val = $this->getGPCVal( $this->data, $name, $default );
601        if ( $val === null ) {
602            return null;
603        } else {
604            return (array)$val;
605        }
606    }
607
608    /**
609     * Fetch an array of integers from this web request's $_GET, $_POST or
610     * path router vars, or return $default if it's not set. If source was
611     * scalar, will return an array with a single element. If no source and
612     * no default, returns null. If an array is returned, contents are
613     * guaranteed to be integers.
614     *
615     * @param string $name
616     * @param array|null $default Option default (or null)
617     * @return int[]|null
618     * @return-taint none
619     */
620    public function getIntArray( $name, $default = null ) {
621        $val = $this->getArray( $name, $default );
622        if ( is_array( $val ) ) {
623            $val = array_map( 'intval', $val );
624        }
625        return $val;
626    }
627
628    /**
629     * Fetch an integer value from this web request's $_GET, $_POST or
630     * path router vars, or return $default if not set. Guaranteed to return
631     * an integer; non-numeric input will typically return 0.
632     *
633     * @param string $name
634     * @param int $default
635     * @return int
636     */
637    public function getInt( $name, $default = 0 ): int {
638        // @phan-suppress-next-line PhanTypeMismatchArgument getRawVal does not return null here
639        return intval( $this->getRawVal( $name, $default ) );
640    }
641
642    /**
643     * Fetch an integer value from this web request's $_GET, $_POST or
644     * path router vars, or return null if empty. Guaranteed to return an
645     * integer or null; non-numeric input will typically return null.
646     *
647     * @param string $name
648     * @return int|null
649     */
650    public function getIntOrNull( $name ): ?int {
651        $val = $this->getRawVal( $name );
652        return is_numeric( $val ) ? intval( $val ) : null;
653    }
654
655    /**
656     * Fetch a floating point value from this web request's $_GET, $_POST
657     * or path router vars, or return $default if not set. Guaranteed to
658     * return a float; non-numeric input will typically return 0.
659     *
660     * @since 1.23
661     * @param string $name
662     * @param float $default
663     * @return float
664     */
665    public function getFloat( $name, $default = 0.0 ): float {
666        // @phan-suppress-next-line PhanTypeMismatchArgument getRawVal does not return null here
667        return floatval( $this->getRawVal( $name, $default ) );
668    }
669
670    /**
671     * Fetch a boolean value from this web request's $_GET, $_POST or path
672     * router vars or return $default if not set. Guaranteed to return true
673     * or false, with normal PHP semantics for boolean interpretation of strings.
674     *
675     * @param string $name
676     * @param bool $default
677     * @return bool
678     */
679    public function getBool( $name, $default = false ): bool {
680        // @phan-suppress-next-line PhanTypeMismatchArgument getRawVal does not return null here
681        return (bool)$this->getRawVal( $name, $default );
682    }
683
684    /**
685     * Fetch a boolean value from this web request's $_GET, $_POST or path router
686     * vars or return $default if not set. Unlike getBool, the string "false" will
687     * result in boolean false, which is useful when interpreting information sent
688     * from JavaScript.
689     *
690     * @param string $name
691     * @param bool $default
692     * @return bool
693     */
694    public function getFuzzyBool( $name, $default = false ): bool {
695        $value = $this->getRawVal( $name );
696        if ( $value === null ) {
697            return (bool)$default;
698        }
699
700        return $value && strcasecmp( $value, 'false' ) !== 0;
701    }
702
703    /**
704     * Return true if the named value is set in this web request's $_GET,
705     * $_POST or path router vars, whatever that value is (even "0").
706     * Return false if the named value is not set. Example use is checking
707     * for the presence of check boxes in forms.
708     *
709     * @param string $name
710     * @return bool
711     */
712    public function getCheck( $name ): bool {
713        # Checkboxes and buttons are only present when clicked
714        # Presence connotes truth, absence false
715        return $this->getRawVal( $name, null ) !== null;
716    }
717
718    /**
719     * Extracts the (given) named values from this web request's $_GET, $_POST or path
720     * router vars into an array. No transformation is performed on the values.
721     *
722     * @param string ...$names If no arguments are given, returns all input values
723     * @return array
724     * @return-taint tainted
725     */
726    public function getValues( ...$names ) {
727        if ( $names === [] ) {
728            $names = array_keys( $this->data );
729        }
730
731        $retVal = [];
732        foreach ( $names as $name ) {
733            $value = $this->getGPCVal( $this->data, $name, null );
734            if ( $value !== null ) {
735                $retVal[$name] = $value;
736            }
737        }
738        return $retVal;
739    }
740
741    /**
742     * Returns the names of this web request's $_GET, $_POST or path router vars,
743     * excluding those in $exclude.
744     *
745     * @param array $exclude
746     * @return array
747     * @return-taint tainted
748     */
749    public function getValueNames( $exclude = [] ) {
750        return array_diff( array_keys( $this->getValues() ), $exclude );
751    }
752
753    /**
754     * Get the values passed in $_GET and the path router parameters.
755     * No transformation is performed on the values.
756     *
757     * @codeCoverageIgnore
758     * @return (string|string[])[] Might contain arrays in case there was a `&param[]=…` parameter
759     * @return-taint tainted
760     */
761    public function getQueryValues() {
762        return $this->queryAndPathParams;
763    }
764
765    /**
766     * Get the values passed in $_GET only, not including the path
767     * router parameters. This is less suitable for self-links to index.php but
768     * useful for other entry points. No transformation is performed on the
769     * values.
770     *
771     * @since 1.34
772     * @return (string|string[])[] Might contain arrays in case there was a `&param[]=…` parameter
773     */
774    public function getQueryValuesOnly() {
775        return $this->queryParams;
776    }
777
778    /**
779     * Get the values passed via POST.
780     * No transformation is performed on the values.
781     *
782     * @since 1.32
783     * @codeCoverageIgnore
784     * @return (string|string[])[] Might contain arrays in case there was a `&param[]=…` parameter
785     */
786    public function getPostValues() {
787        return $_POST;
788    }
789
790    /**
791     * Return the contents of the URL query string with no decoding. Use when you need to
792     * know exactly what was sent, e.g. for an OAuth signature over the elements.
793     *
794     * @codeCoverageIgnore
795     * @return string
796     * @return-taint tainted
797     */
798    public function getRawQueryString() {
799        return $this->getServerInfo( 'QUERY_STRING' ) ?? '';
800    }
801
802    /**
803     * Return the contents of the POST with no decoding. Use when you need to
804     * know exactly what was sent, e.g. for an OAuth signature over the elements.
805     *
806     * @return string
807     * @return-taint tainted
808     */
809    public function getRawPostString() {
810        if ( !$this->wasPosted() ) {
811            return '';
812        }
813        return $this->getRawInput();
814    }
815
816    /**
817     * Return the raw request body, with no processing. Cached since some methods
818     * disallow reading the stream more than once. As stated in the php docs, this
819     * does not work with enctype="multipart/form-data".
820     *
821     * @return string
822     * @return-taint tainted
823     */
824    public function getRawInput() {
825        static $input = null;
826        $input ??= file_get_contents( 'php://input' );
827        return $input;
828    }
829
830    /**
831     * Get the HTTP method used for this request.
832     *
833     * @return string
834     */
835    public function getMethod() {
836        return $this->getServerInfo( 'REQUEST_METHOD' ) ?: 'GET';
837    }
838
839    /**
840     * Returns true if the present request was reached by a POST operation,
841     * false otherwise (GET, HEAD, or command-line).
842     *
843     * Note that values retrieved by the object may come from the
844     * GET URL etc even on a POST request.
845     *
846     * @return bool
847     */
848    public function wasPosted() {
849        return $this->getMethod() == 'POST';
850    }
851
852    /**
853     * Return the session for this request
854     *
855     * This might unpersist an existing session if it was invalid.
856     *
857     * @since 1.27
858     * @note For performance, keep the session locally if you will be making
859     *  much use of it instead of calling this method repeatedly.
860     * @return Session
861     */
862    public function getSession(): Session {
863        if ( $this->sessionId !== null ) {
864            $session = SessionManager::singleton()->getSessionById( (string)$this->sessionId, true, $this );
865            if ( $session ) {
866                return $session;
867            }
868        }
869
870        $session = SessionManager::singleton()->getSessionForRequest( $this );
871        $this->sessionId = $session->getSessionId();
872        return $session;
873    }
874
875    /**
876     * Set the session for this request
877     * @since 1.27
878     * @internal For use by MediaWiki\Session classes only
879     * @param SessionId $sessionId
880     */
881    public function setSessionId( SessionId $sessionId ) {
882        $this->sessionId = $sessionId;
883    }
884
885    /**
886     * Get the session id for this request, if any
887     * @since 1.27
888     * @internal For use by MediaWiki\Session classes only
889     * @return SessionId|null
890     */
891    public function getSessionId() {
892        return $this->sessionId;
893    }
894
895    /**
896     * Get a cookie from the $_COOKIE jar
897     *
898     * @param string $key The name of the cookie
899     * @param string|null $prefix A prefix to use for the cookie name, if not $wgCookiePrefix
900     * @param mixed|null $default What to return if the value isn't found
901     * @return mixed Cookie value or $default if the cookie not set
902     * @return-taint tainted
903     */
904    public function getCookie( $key, $prefix = null, $default = null ) {
905        if ( $prefix === null ) {
906            global $wgCookiePrefix;
907            $prefix = $wgCookiePrefix;
908        }
909        $name = $prefix . $key;
910        // Work around mangling of $_COOKIE
911        $name = strtr( $name, '.', '_' );
912        if ( isset( $_COOKIE[$name] ) ) {
913            // For duplicate cookies in the format of name[]=value;name[]=value2,
914            // PHP will assign an array value for the 'name' cookie in $_COOKIE.
915            // Neither RFC 6265 nor its preceding RFCs define such behavior,
916            // and MediaWiki does not rely on it either, so treat the cookie as absent if so (T363980).
917            if ( is_array( $_COOKIE[$name] ) ) {
918                return $default;
919            }
920            return $_COOKIE[$name];
921        } else {
922            return $default;
923        }
924    }
925
926    /**
927     * Get a cookie set with SameSite=None.
928     *
929     * @deprecated since 1.42 use getCookie(), but note the different $prefix default
930     *
931     * @param string $key The name of the cookie
932     * @param string $prefix A prefix to use, empty by default
933     * @param mixed|null $default What to return if the value isn't found
934     * @return mixed Cookie value or $default if the cookie is not set
935     */
936    public function getCrossSiteCookie( $key, $prefix = '', $default = null ) {
937        wfDeprecated( __METHOD__, '1.42' );
938        return $this->getCookie( $key, $prefix, $default );
939    }
940
941    /**
942     * Return the path and query string portion of the main request URI.
943     * This will be suitable for use as a relative link in HTML output.
944     *
945     * @throws MWException
946     * @return string
947     * @return-taint tainted
948     */
949    public static function getGlobalRequestURL() {
950        // This method is called on fatal errors; it should not depend on anything complex.
951
952        if ( isset( $_SERVER['REQUEST_URI'] ) && strlen( $_SERVER['REQUEST_URI'] ) ) {
953            $base = $_SERVER['REQUEST_URI'];
954        } elseif ( isset( $_SERVER['HTTP_X_ORIGINAL_URL'] )
955            && strlen( $_SERVER['HTTP_X_ORIGINAL_URL'] )
956        ) {
957            // Probably IIS; doesn't set REQUEST_URI
958            $base = $_SERVER['HTTP_X_ORIGINAL_URL'];
959        } elseif ( isset( $_SERVER['SCRIPT_NAME'] ) ) {
960            $base = $_SERVER['SCRIPT_NAME'];
961            if ( isset( $_SERVER['QUERY_STRING'] ) && $_SERVER['QUERY_STRING'] != '' ) {
962                $base .= '?' . $_SERVER['QUERY_STRING'];
963            }
964        } else {
965            // This shouldn't happen!
966            throw new MWException(
967                "Web server doesn't provide either " .
968                "REQUEST_URI, HTTP_X_ORIGINAL_URL or SCRIPT_NAME. Report details " .
969                "of your web server configuration to https://phabricator.wikimedia.org/"
970            );
971        }
972        // User-agents should not send a fragment with the URI, but
973        // if they do, and the web server passes it on to us, we
974        // need to strip it or we get false-positive redirect loops
975        // or weird output URLs
976        $hash = strpos( $base, '#' );
977        if ( $hash !== false ) {
978            $base = substr( $base, 0, $hash );
979        }
980
981        if ( $base[0] == '/' ) {
982            // More than one slash will look like it is protocol relative
983            return preg_replace( '!^/+!', '/', $base );
984        } else {
985            // We may get paths with a host prepended; strip it.
986            return preg_replace( '!^[^:]+://[^/]+/+!', '/', $base );
987        }
988    }
989
990    /**
991     * Return the path and query string portion of the request URI.
992     * This will be suitable for use as a relative link in HTML output.
993     *
994     * @throws MWException
995     * @return string
996     * @return-taint tainted
997     */
998    public function getRequestURL() {
999        return self::getGlobalRequestURL();
1000    }
1001
1002    /**
1003     * Return the request URI with the canonical service and hostname, path,
1004     * and query string. This will be suitable for use as an absolute link
1005     * in HTML or other output.
1006     *
1007     * If $wgServer is protocol-relative, this will return a fully
1008     * qualified URL with the protocol of this request object.
1009     *
1010     * @return string
1011     * @return-taint tainted
1012     */
1013    public function getFullRequestURL() {
1014        $urlUtils = MediaWikiServices::getInstance()->getUrlUtils();
1015        // Pass an explicit PROTO constant instead of PROTO_CURRENT so that we
1016        // do not rely on state from the global $wgRequest object (which it would,
1017        // via wfGetServerUrl/UrlUtils::expand()/$wgRequest->protocol).
1018        if ( $this->getProtocol() === 'http' ) {
1019            return ( $urlUtils->getServer( PROTO_HTTP ) ?? '' ) . $this->getRequestURL();
1020        } else {
1021            return ( $urlUtils->getServer( PROTO_HTTPS ) ?? '' ) . $this->getRequestURL();
1022        }
1023    }
1024
1025    /**
1026     * @param string $key
1027     * @param string $value
1028     * @return string
1029     */
1030    public function appendQueryValue( $key, $value ) {
1031        return $this->appendQueryArray( [ $key => $value ] );
1032    }
1033
1034    /**
1035     * Appends or replaces value of query variables.
1036     *
1037     * @param array $array Array of values to replace/add to query
1038     * @return string
1039     */
1040    public function appendQueryArray( $array ) {
1041        $newquery = $this->getQueryValues();
1042        unset( $newquery['title'] );
1043        $newquery = array_merge( $newquery, $array );
1044
1045        return wfArrayToCgi( $newquery );
1046    }
1047
1048    /**
1049     * Check for limit and offset parameters on the input, and return sensible
1050     * defaults if not given. The limit must be positive and is capped at 5000.
1051     * Offset must be positive but is not capped.
1052     *
1053     * @param UserIdentity $user UserIdentity to get option for
1054     * @param int $deflimit Limit to use if no input and the user hasn't set the option.
1055     * @param string $optionname To specify an option other than rclimit to pull from.
1056     * @return int[] First element is limit, second is offset
1057     */
1058    public function getLimitOffsetForUser( UserIdentity $user, $deflimit = 50, $optionname = 'rclimit' ) {
1059        $limit = $this->getInt( 'limit', 0 );
1060        if ( $limit < 0 ) {
1061            $limit = 0;
1062        }
1063        if ( ( $limit == 0 ) && ( $optionname != '' ) ) {
1064            $limit = MediaWikiServices::getInstance()
1065                ->getUserOptionsLookup()
1066                ->getIntOption( $user, $optionname );
1067        }
1068        if ( $limit <= 0 ) {
1069            $limit = $deflimit;
1070        }
1071        if ( $limit > 5000 ) {
1072            $limit = 5000; # We have *some* limits...
1073        }
1074
1075        $offset = $this->getInt( 'offset', 0 );
1076        if ( $offset < 0 ) {
1077            $offset = 0;
1078        }
1079
1080        return [ $limit, $offset ];
1081    }
1082
1083    /**
1084     * Return the path to the temporary file where PHP has stored the upload.
1085     *
1086     * @param string $key
1087     * @return string|null String or null if no such file.
1088     */
1089    public function getFileTempname( $key ) {
1090        return $this->getUpload( $key )->getTempName();
1091    }
1092
1093    /**
1094     * Return the upload error or 0
1095     *
1096     * @param string $key
1097     * @return int
1098     */
1099    public function getUploadError( $key ) {
1100        return $this->getUpload( $key )->getError();
1101    }
1102
1103    /**
1104     * Return the original filename of the uploaded file, as reported by
1105     * the submitting user agent. HTML-style character entities are
1106     * interpreted and normalized to Unicode normalization form C, in part
1107     * to deal with weird input from Safari with non-ASCII filenames.
1108     *
1109     * Other than this the name is not verified for being a safe filename.
1110     *
1111     * @param string $key
1112     * @return string|null String or null if no such file.
1113     */
1114    public function getFileName( $key ) {
1115        return $this->getUpload( $key )->getName();
1116    }
1117
1118    /**
1119     * Return a MediaWiki\Request\WebRequestUpload object corresponding to the key
1120     *
1121     * @param string $key
1122     * @return WebRequestUpload
1123     */
1124    public function getUpload( $key ) {
1125        return new WebRequestUpload( $this, $key );
1126    }
1127
1128    /**
1129     * Return a handle to WebResponse style object, for setting cookies,
1130     * headers and other stuff, for Request being worked on.
1131     */
1132    public function response(): WebResponse {
1133        /* Lazy initialization of response object for this request */
1134        if ( !$this->response ) {
1135            $this->response = new WebResponse();
1136        }
1137        return $this->response;
1138    }
1139
1140    /**
1141     * Initialise the header list
1142     */
1143    protected function initHeaders() {
1144        if ( count( $this->headers ) ) {
1145            return;
1146        }
1147
1148        $this->headers = array_change_key_case( getallheaders(), CASE_UPPER );
1149    }
1150
1151    /**
1152     * Get an array containing all request headers
1153     *
1154     * @return string[] Mapping header name to its value
1155     * @return-taint tainted
1156     */
1157    public function getAllHeaders() {
1158        $this->initHeaders();
1159        return $this->headers;
1160    }
1161
1162    /**
1163     * Get a request header, or false if it isn't set.
1164     *
1165     * @param string $name Case-insensitive header name
1166     * @param int $flags Bitwise combination of:
1167     *   WebRequest::GETHEADER_LIST  Treat the header as a comma-separated list
1168     *                               of values, as described in RFC 2616 § 4.2.
1169     *                               (since 1.26).
1170     * @return string|string[]|false False if header is unset; otherwise the
1171     *  header value(s) as either a string (the default) or an array, if
1172     *  WebRequest::GETHEADER_LIST flag was set.
1173     * @return-taint tainted
1174     */
1175    public function getHeader( $name, $flags = 0 ) {
1176        $this->initHeaders();
1177        $name = strtoupper( $name );
1178        if ( !isset( $this->headers[$name] ) ) {
1179            return false;
1180        }
1181        $value = $this->headers[$name];
1182        if ( $flags & self::GETHEADER_LIST ) {
1183            $value = array_map( 'trim', explode( ',', $value ) );
1184        }
1185        return $value;
1186    }
1187
1188    /**
1189     * Get data from the session
1190     *
1191     * @note Prefer $this->getSession() instead if making multiple calls.
1192     * @param string $key Name of key in the session
1193     * @return mixed
1194     */
1195    public function getSessionData( $key ) {
1196        return $this->getSession()->get( $key );
1197    }
1198
1199    /**
1200     * @note Prefer $this->getSession() instead if making multiple calls.
1201     * @param string $key Name of key in the session
1202     * @param mixed $data
1203     */
1204    public function setSessionData( $key, $data ) {
1205        $this->getSession()->set( $key, $data );
1206    }
1207
1208    /**
1209     * Parse the Accept-Language header sent by the client into an array
1210     *
1211     * @return array [ languageCode => q-value ] sorted by q-value in
1212     *   descending order then appearing time in the header in ascending order.
1213     * May contain the "language" '*', which applies to languages other than those explicitly listed.
1214     *
1215     * This logic is aligned with RFC 7231 section 5 (previously RFC 2616 section 14),
1216     * at <https://tools.ietf.org/html/rfc7231#section-5.3.5>.
1217     *
1218     * Earlier languages in the list are preferred as per the RFC 23282 extension to HTTP/1.1,
1219     * at <https://tools.ietf.org/html/rfc3282>.
1220     * @return-taint tainted
1221     */
1222    public function getAcceptLang() {
1223        // Modified version of code found at
1224        // http://www.thefutureoftheweb.com/blog/use-accept-language-header
1225        $acceptLang = $this->getHeader( 'Accept-Language' );
1226        if ( !$acceptLang ) {
1227            return [];
1228        }
1229
1230        // Return the language codes in lower case
1231        $acceptLang = strtolower( $acceptLang );
1232
1233        // Break up string into pieces (languages and q factors)
1234        if ( !preg_match_all(
1235            '/
1236                # a language code or a star is required
1237                ([a-z]{1,8}(?:-[a-z]{1,8})*|\*)
1238                # from here everything is optional
1239                \s*
1240                (?:
1241                    # this accepts only numbers in the range ;q=0.000 to ;q=1.000
1242                    ;\s*q\s*=\s*
1243                    (1(?:\.0{0,3})?|0(?:\.\d{0,3})?)?
1244                )?
1245            /x',
1246            $acceptLang,
1247            $matches,
1248            PREG_SET_ORDER
1249        ) ) {
1250            return [];
1251        }
1252
1253        // Create a list like "en" => 0.8
1254        $langs = [];
1255        foreach ( $matches as $match ) {
1256            $languageCode = $match[1];
1257            // When not present, the default value is 1
1258            $qValue = (float)( $match[2] ?? 1.0 );
1259            if ( $qValue ) {
1260                $langs[$languageCode] = $qValue;
1261            }
1262        }
1263
1264        // Sort list by qValue
1265        arsort( $langs, SORT_NUMERIC );
1266        return $langs;
1267    }
1268
1269    /**
1270     * Fetch the raw IP from the request
1271     *
1272     * @since 1.19
1273     * @return string|null
1274     */
1275    protected function getRawIP() {
1276        $remoteAddr = $this->getServerInfo( 'REMOTE_ADDR' );
1277        if ( !$remoteAddr ) {
1278            return null;
1279        }
1280        if ( str_contains( $remoteAddr, ',' ) ) {
1281            throw new MWException( 'Remote IP must not contain multiple values' );
1282        }
1283
1284        return IPUtils::canonicalize( $remoteAddr );
1285    }
1286
1287    /**
1288     * Work out the IP address based on various globals
1289     * For trusted proxies, use the XFF client IP (first of the chain)
1290     *
1291     * @since 1.19
1292     * @return string
1293     */
1294    public function getIP(): string {
1295        global $wgUsePrivateIPs;
1296
1297        # Return cached result
1298        if ( $this->ip !== null ) {
1299            return $this->ip;
1300        }
1301
1302        # collect the originating IPs
1303        $ip = $this->getRawIP();
1304        if ( !$ip ) {
1305            throw new MWException( 'Unable to determine IP.' );
1306        }
1307
1308        $services = MediaWikiServices::getInstance();
1309        # Append XFF
1310        $forwardedFor = $this->getHeader( 'X-Forwarded-For' );
1311        if ( $forwardedFor !== false ) {
1312            $proxyLookup = $services->getProxyLookup();
1313            $isConfigured = $proxyLookup->isConfiguredProxy( $ip );
1314            $ipchain = array_map( 'trim', explode( ',', $forwardedFor ) );
1315            $ipchain = array_reverse( $ipchain );
1316            array_unshift( $ipchain, $ip );
1317
1318            # Step through XFF list and find the last address in the list which is a
1319            # trusted server. Set $ip to the IP address given by that trusted server,
1320            # unless the address is not sensible (e.g. private). However, prefer private
1321            # IP addresses over proxy servers controlled by this site (more sensible).
1322            # Note that some XFF values might be "unknown" with Squid/Varnish.
1323            foreach ( $ipchain as $i => $curIP ) {
1324                $curIP = IPUtils::sanitizeIP(
1325                    IPUtils::canonicalize(
1326                        self::canonicalizeIPv6LoopbackAddress( $curIP )
1327                    )
1328                );
1329                if ( !$curIP || !isset( $ipchain[$i + 1] ) || $ipchain[$i + 1] === 'unknown'
1330                    || !$proxyLookup->isTrustedProxy( $curIP )
1331                ) {
1332                    break; // IP is not valid/trusted or does not point to anything
1333                }
1334                if (
1335                    IPUtils::isPublic( $ipchain[$i + 1] ) ||
1336                    $wgUsePrivateIPs ||
1337                    // T50919; treat IP as valid
1338                    $proxyLookup->isConfiguredProxy( $curIP )
1339                ) {
1340                    $nextIP = $ipchain[$i + 1];
1341
1342                    // Follow the next IP according to the proxy
1343                    $nextIP = IPUtils::canonicalize(
1344                        self::canonicalizeIPv6LoopbackAddress( $nextIP )
1345                    );
1346                    if ( !$nextIP && $isConfigured ) {
1347                        // We have not yet made it past CDN/proxy servers of this site,
1348                        // so either they are misconfigured or there is some IP spoofing.
1349                        throw new MWException( "Invalid IP given in XFF '$forwardedFor'." );
1350                    }
1351                    $ip = $nextIP;
1352
1353                    // keep traversing the chain
1354                    continue;
1355                }
1356                break;
1357            }
1358        }
1359
1360        // Allow extensions to modify the result
1361        $hookContainer = $services->getHookContainer();
1362        // Optimisation: Hot code called on most requests (T85805).
1363        if ( $hookContainer->isRegistered( 'GetIP' ) ) {
1364            // @phan-suppress-next-line PhanTypeMismatchArgument Type mismatch on pass-by-ref args
1365            ( new HookRunner( $hookContainer ) )->onGetIP( $ip );
1366        }
1367
1368        if ( !$ip ) {
1369            throw new MWException( 'Unable to determine IP.' );
1370        }
1371
1372        $this->ip = $ip;
1373        return $ip;
1374    }
1375
1376    /**
1377     * Converts ::1 (IPv6 loopback address) to 127.0.0.1 (IPv4 loopback address);
1378     * assists in matching trusted proxies.
1379     *
1380     * @param string $ip
1381     * @return string either '127.0.0.1' or $ip
1382     * @since 1.36
1383     */
1384    public static function canonicalizeIPv6LoopbackAddress( $ip ) {
1385        // Code moved from IPUtils library. See T248237#6614927
1386        if ( preg_match( '/^0*' . IPUtils::RE_IPV6_GAP . '1$/', $ip ) ) {
1387            return '127.0.0.1';
1388        }
1389        return $ip;
1390    }
1391
1392    /**
1393     * @param string $ip
1394     * @return void
1395     * @since 1.21
1396     */
1397    public function setIP( $ip ) {
1398        $this->ip = $ip;
1399    }