MWHttpRequest.php

Go to the documentation of this file.

<?php
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
 
abstract class MWHttpRequest implements LoggerAwareInterface {
    public const SUPPORTS_FILE_POSTS = false;
 
    protected $timeout = 'default';
 
    protected $content;
    protected $headersOnly = null;
    protected $postData = null;
    protected $proxy = null;
    protected $noProxy = false;
    protected $sslVerifyHost = true;
    protected $sslVerifyCert = true;
    protected $caInfo = null;
    protected $method = "GET";
    protected $reqHeaders = [];
    protected $url;
    protected $parsedUrl;
    protected $callback;
    protected $maxRedirects = 5;
    protected $followRedirects = false;
    protected $connectTimeout;
 
    protected $cookieJar;
 
    protected $headerList = [];
    protected $respVersion = "0.9";
    protected $respStatus = "200 Ok";
    protected $respHeaders = [];
 
    protected $status;
 
    protected $profiler;
 
    protected $profileName;
 
    protected $logger;
 
    public function __construct(
        $url, array $options = [], $caller = __METHOD__, Profiler $profiler = null
    ) {
        $this->url = wfExpandUrl( $url, PROTO_HTTP );
        $this->parsedUrl = wfParseUrl( $this->url );
 
        $this->logger = $options['logger'] ?? new NullLogger();
 
        if ( !$this->parsedUrl || !self::isValidURI( $this->url ) ) {
            $this->status = StatusValue::newFatal( 'http-invalid-url', $url );
        } else {
            $this->status = StatusValue::newGood( 100 ); // continue
        }
 
        if ( isset( $options['timeout'] ) && $options['timeout'] != 'default' ) {
            $this->timeout = $options['timeout'];
        } else {
            // The timeout should always be set by HttpRequestFactory, so this
            // should only happen if the class was directly constructed
            wfDeprecated( __METHOD__ . ' without the timeout option', '1.35' );
            $httpTimeout = MediaWikiServices::getInstance()->getMainConfig()->get(
                MainConfigNames::HTTPTimeout );
            $this->timeout = $httpTimeout;
        }
        if ( isset( $options['connectTimeout'] ) && $options['connectTimeout'] != 'default' ) {
            $this->connectTimeout = $options['connectTimeout'];
        } else {
            // The timeout should always be set by HttpRequestFactory, so this
            // should only happen if the class was directly constructed
            wfDeprecated( __METHOD__ . ' without the connectTimeout option', '1.35' );
            $httpConnectTimeout = MediaWikiServices::getInstance()->getMainConfig()->get(
                MainConfigNames::HTTPConnectTimeout );
            $this->connectTimeout = $httpConnectTimeout;
        }
        if ( isset( $options['userAgent'] ) ) {
            $this->setUserAgent( $options['userAgent'] );
        }
        if ( isset( $options['username'] ) && isset( $options['password'] ) ) {
            $this->setHeader(
                'Authorization',
                'Basic ' . base64_encode( $options['username'] . ':' . $options['password'] )
            );
        }
        if ( isset( $options['originalRequest'] ) ) {
            $this->setOriginalRequest( $options['originalRequest'] );
        }
 
        $this->setHeader( 'X-Request-Id', WebRequest::getRequestId() );
 
        $members = [ "postData", "proxy", "noProxy", "sslVerifyHost", "caInfo",
                "method", "followRedirects", "maxRedirects", "sslVerifyCert", "callback" ];
 
        foreach ( $members as $o ) {
            if ( isset( $options[$o] ) ) {
                // ensure that MWHttpRequest::method is always
                // uppercased. T38137
                if ( $o == 'method' ) {
                    // @phan-suppress-next-line PhanTypePossiblyInvalidDimOffset False positive
                    $options[$o] = strtoupper( $options[$o] );
                }
                $this->$o = $options[$o];
            }
        }
 
        if ( $this->noProxy ) {
            $this->proxy = ''; // noProxy takes precedence
        }
 
        // Profile based on what's calling us
        $this->profiler = $profiler;
        $this->profileName = $caller;
    }
 
    public function setLogger( LoggerInterface $logger ) {
        $this->logger = $logger;
    }
 
    public static function canMakeRequests() {
        return function_exists( 'curl_init' ) || wfIniGetBool( 'allow_url_fopen' );
    }
 
    public static function factory( $url, array $options = null, $caller = __METHOD__ ) {
        wfDeprecated( __METHOD__, '1.34' );
        return MediaWikiServices::getInstance()->getHttpRequestFactory()
            ->create( $url, $options ?? [], $caller );
    }
 
    public function getContent() {
        return $this->content;
    }
 
    public function setData( array $args ) {
        $this->postData = $args;
    }
 
    protected function proxySetup() {
        $httpProxy = MediaWikiServices::getInstance()->getMainConfig()->get(
            MainConfigNames::HTTPProxy );
        $localHTTPProxy = MediaWikiServices::getInstance()->getMainConfig()->get(
            MainConfigNames::LocalHTTPProxy );
        // If proxies are disabled, clear any other proxy
        if ( $this->noProxy ) {
            $this->proxy = '';
            return;
        }
 
        // If there is an explicit proxy already set, use it
        if ( $this->proxy ) {
            return;
        }
 
        // Otherwise, fallback to $wgLocalHTTPProxy for local URLs
        // or $wgHTTPProxy for everything else
        if ( self::isLocalURL( $this->url ) ) {
            if ( $localHTTPProxy !== false ) {
                $this->setReverseProxy( $localHTTPProxy );
            }
        } else {
            $this->proxy = (string)$httpProxy;
        }
    }
 
    protected function setReverseProxy( string $proxy ) {
        $parsedProxy = wfParseUrl( $proxy );
        if ( $parsedProxy === false ) {
            throw new Exception( "Invalid reverseProxy configured: $proxy" );
        }
        // Set the current host in the Host header
        $this->setHeader( 'Host', $this->parsedUrl['host'] );
        // Replace scheme, host and port in the request
        $this->parsedUrl['scheme'] = $parsedProxy['scheme'];
        $this->parsedUrl['host'] = $parsedProxy['host'];
        if ( isset( $parsedProxy['port'] ) ) {
            $this->parsedUrl['port'] = $parsedProxy['port'];
        } else {
            unset( $this->parsedUrl['port'] );
        }
        $this->url = wfAssembleUrl( $this->parsedUrl );
        // Mark that we're already using a proxy
        $this->noProxy = true;
    }
 
    private static function isLocalURL( $url ) {
        $commandLineMode = MediaWikiServices::getInstance()->getMainConfig()->get( 'CommandLineMode' );
        $localVirtualHosts = MediaWikiServices::getInstance()->getMainConfig()->get(
            MainConfigNames::LocalVirtualHosts );
        if ( $commandLineMode ) {
            return false;
        }
 
        // Extract host part
        $matches = [];
        if ( preg_match( '!^https?://([\w.-]+)[/:].*$!', $url, $matches ) ) {
            $host = $matches[1];
            // Split up dotwise
            $domainParts = explode( '.', $host );
            // Check if this domain or any superdomain is listed as a local virtual host
            $domainParts = array_reverse( $domainParts );
 
            $domain = '';
            $countParts = count( $domainParts );
            for ( $i = 0; $i < $countParts; $i++ ) {
                $domainPart = $domainParts[$i];
                if ( $i == 0 ) {
                    $domain = $domainPart;
                } else {
                    $domain = $domainPart . '.' . $domain;
                }
 
                if ( in_array( $domain, $localVirtualHosts ) ) {
                    return true;
                }
            }
        }
 
        return false;
    }
 
    public function setUserAgent( $UA ) {
        $this->setHeader( 'User-Agent', $UA );
    }
 
    public function setHeader( $name, $value ) {
        // I feel like I should normalize the case here...
        $this->reqHeaders[$name] = $value;
    }
 
    protected function getHeaderList() {
        $list = [];
 
        if ( $this->cookieJar ) {
            $this->reqHeaders['Cookie'] =
                $this->cookieJar->serializeToHttpRequest(
                    $this->parsedUrl['path'],
                    $this->parsedUrl['host']
                );
        }
 
        foreach ( $this->reqHeaders as $name => $value ) {
            $list[] = "$name: $value";
        }
 
        return $list;
    }
 
    public function setCallback( $callback ) {
        $this->doSetCallback( $callback );
    }
 
    protected function doSetCallback( $callback ) {
        if ( $callback === null ) {
            $callback = [ $this, 'read' ];
        } elseif ( !is_callable( $callback ) ) {
            $this->status->fatal( 'http-internal-error' );
            throw new InvalidArgumentException( __METHOD__ . ': invalid callback' );
        }
        $this->callback = $callback;
    }
 
    public function read( $fh, $content ) {
        $this->content .= $content;
        return strlen( $content );
    }
 
    public function execute() {
        throw new LogicException( 'children must override this' );
    }
 
    protected function prepare() {
        $this->content = "";
 
        if ( strtoupper( $this->method ) == "HEAD" ) {
            $this->headersOnly = true;
        }
 
        $this->proxySetup(); // set up any proxy as needed
 
        if ( !$this->callback ) {
            $this->doSetCallback( null );
        }
 
        if ( !isset( $this->reqHeaders['User-Agent'] ) ) {
            $http = MediaWikiServices::getInstance()->getHttpRequestFactory();
            $this->setUserAgent( $http->getUserAgent() );
        }
    }
 
    protected function parseHeader() {
        $lastname = "";
 
        // Failure without (valid) headers gets a response status of zero
        if ( !$this->status->isOK() ) {
            $this->respStatus = '0 Error';
        }
 
        foreach ( $this->headerList as $header ) {
            if ( preg_match( "#^HTTP/([0-9.]+) (.*)#", $header, $match ) ) {
                $this->respVersion = $match[1];
                $this->respStatus = $match[2];
            } elseif ( preg_match( "#^[ \t]#", $header ) ) {
                $last = count( $this->respHeaders[$lastname] ) - 1;
                $this->respHeaders[$lastname][$last] .= "\r\n$header";
            } elseif ( preg_match( "#^([^:]*):[\t ]*(.*)#", $header, $match ) ) {
                $this->respHeaders[strtolower( $match[1] )][] = $match[2];
                $lastname = strtolower( $match[1] );
            }
        }
 
        $this->parseCookies();
    }
 
    protected function setStatus() {
        if ( !$this->respHeaders ) {
            $this->parseHeader();
        }
 
        if ( (int)$this->respStatus > 0 && (int)$this->respStatus < 400 ) {
            $this->status->setResult( true, (int)$this->respStatus );
        } else {
            [ $code, $message ] = explode( " ", $this->respStatus, 2 );
            $this->status->setResult( false, (int)$this->respStatus );
            $this->status->fatal( "http-bad-status", $code, $message );
        }
    }
 
    public function getStatus() {
        if ( !$this->respHeaders ) {
            $this->parseHeader();
        }
 
        return (int)$this->respStatus;
    }
 
    public function isRedirect() {
        if ( !$this->respHeaders ) {
            $this->parseHeader();
        }
 
        $status = (int)$this->respStatus;
 
        if ( $status >= 300 && $status <= 303 ) {
            return true;
        }
 
        return false;
    }
 
    public function getResponseHeaders() {
        if ( !$this->respHeaders ) {
            $this->parseHeader();
        }
 
        return $this->respHeaders;
    }
 
    public function getResponseHeader( $header ) {
        if ( !$this->respHeaders ) {
            $this->parseHeader();
        }
 
        if ( isset( $this->respHeaders[strtolower( $header )] ) ) {
            $v = $this->respHeaders[strtolower( $header )];
            return $v[count( $v ) - 1];
        }
 
        return null;
    }
 
    public function setCookieJar( CookieJar $jar ) {
        $this->cookieJar = $jar;
    }
 
    public function getCookieJar() {
        if ( !$this->respHeaders ) {
            $this->parseHeader();
        }
 
        return $this->cookieJar;
    }
 
    public function setCookie( $name, $value, array $attr = [] ) {
        if ( !$this->cookieJar ) {
            $this->cookieJar = new CookieJar;
        }
 
        if ( $this->parsedUrl && !isset( $attr['domain'] ) ) {
            $attr['domain'] = $this->parsedUrl['host'];
        }
 
        $this->cookieJar->setCookie( $name, $value, $attr );
    }
 
    protected function parseCookies() {
        if ( !$this->cookieJar ) {
            $this->cookieJar = new CookieJar;
        }
 
        if ( isset( $this->respHeaders['set-cookie'] ) ) {
            $url = parse_url( $this->getFinalUrl() );
            if ( !isset( $url['host'] ) ) {
                $this->status->fatal( 'http-invalid-url', $url );
            } else {
                foreach ( $this->respHeaders['set-cookie'] as $cookie ) {
                    $this->cookieJar->parseCookieResponseHeader( $cookie, $url['host'] );
                }
            }
        }
    }
 
    public function getFinalUrl() {
        $headers = $this->getResponseHeaders();
 
        // return full url (fix for incorrect but handled relative location)
        if ( isset( $headers['location'] ) ) {
            $locations = $headers['location'];
            $domain = '';
            $foundRelativeURI = false;
            $countLocations = count( $locations );
 
            for ( $i = $countLocations - 1; $i >= 0; $i-- ) {
                $url = parse_url( $locations[$i] );
 
                if ( isset( $url['scheme'] ) && isset( $url['host'] ) ) {
                    $domain = $url['scheme'] . '://' . $url['host'];
                    break; // found correct URI (with host)
                } else {
                    $foundRelativeURI = true;
                }
            }
 
            if ( !$foundRelativeURI ) {
                return $locations[$countLocations - 1];
            }
            if ( $domain ) {
                return $domain . $locations[$countLocations - 1];
            }
            $url = parse_url( $this->url );
            if ( isset( $url['scheme'] ) && isset( $url['host'] ) ) {
                return $url['scheme'] . '://' . $url['host'] .
                    $locations[$countLocations - 1];
            }
        }
 
        return $this->url;
    }
 
    public function canFollowRedirects() {
        return true;
    }
 
    public function setOriginalRequest( $originalRequest ) {
        if ( $originalRequest instanceof WebRequest ) {
            $originalRequest = [
                'ip' => $originalRequest->getIP(),
                'userAgent' => $originalRequest->getHeader( 'User-Agent' ),
            ];
        } elseif (
            !is_array( $originalRequest )
            || array_diff( [ 'ip', 'userAgent' ], array_keys( $originalRequest ) )
        ) {
            throw new InvalidArgumentException( __METHOD__ . ': $originalRequest must be a '
                . "WebRequest or an array with 'ip' and 'userAgent' keys" );
        }
 
        $this->reqHeaders['X-Forwarded-For'] = $originalRequest['ip'];
        $this->reqHeaders['X-Original-User-Agent'] = $originalRequest['userAgent'];
    }
 
    public static function isValidURI( $uri ) {
        return (bool)preg_match(
            '/^https?:\/\/[^\/\s]\S*$/D',
            $uri
        );
    }
}