Class yii\web\Request

                protected function createCsrfCookie($token)
{
    $options = $this->csrfCookie;
    return Yii::createObject(array_merge($options, [
        'class' => 'yii\web\Cookie',
        'name' => $this->csrfParam,
        'value' => $token,
    ]));
}

            

                protected function filterHeaders(HeaderCollection $headerCollection)
{
    $trustedHeaders = $this->getTrustedHeaders();
    // remove all secure headers unless they are trusted
    foreach ($this->secureHeaders as $secureHeader) {
        if (!in_array($secureHeader, $trustedHeaders)) {
            $headerCollection->remove($secureHeader);
        }
    }
}

            

                protected function generateCsrfToken()
{
    $token = Yii::$app->getSecurity()->generateRandomString();
    if ($this->enableCsrfCookie) {
        $cookie = $this->createCsrfCookie($token);
        Yii::$app->getResponse()->getCookies()->add($cookie);
    } else {
        Yii::$app->getSession()->set($this->csrfParam, $token);
    }
    return $token;
}

            

                public function get($name = null, $defaultValue = null)
{
    if ($name === null) {
        return $this->getQueryParams();
    }
    return $this->getQueryParam($name, $defaultValue);
}

            

                public function getAbsoluteUrl()
{
    return $this->getHostInfo() . $this->getUrl();
}

            

                public function getAcceptableContentTypes()
{
    if ($this->_contentTypes === null) {
        if ($this->headers->get('Accept') !== null) {
            $this->_contentTypes = $this->parseAcceptHeader($this->headers->get('Accept'));
        } else {
            $this->_contentTypes = [];
        }
    }
    return $this->_contentTypes;
}

            

                public function getAcceptableLanguages()
{
    if ($this->_languages === null) {
        if ($this->headers->has('Accept-Language')) {
            $this->_languages = array_keys($this->parseAcceptHeader($this->headers->get('Accept-Language')));
        } else {
            $this->_languages = [];
        }
    }
    return $this->_languages;
}

            

                public function getAuthCredentials()
{
    $username = isset($_SERVER['PHP_AUTH_USER']) ? $_SERVER['PHP_AUTH_USER'] : null;
    $password = isset($_SERVER['PHP_AUTH_PW']) ? $_SERVER['PHP_AUTH_PW'] : null;
    if ($username !== null || $password !== null) {
        return [$username, $password];
    }
    /**
     * Apache with php-cgi does not pass HTTP Basic authentication to PHP by default.
     * To make it work, add one of the following lines to to your .htaccess file:
     *
     * SetEnvIf Authorization .+ HTTP_AUTHORIZATION=$0
     * --OR--
     * RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
     */
    $auth_token = $this->getHeaders()->get('Authorization');
    if ($auth_token !== null && strncasecmp($auth_token, 'basic', 5) === 0) {
        $parts = array_map(function ($value) {
            return strlen($value) === 0 ? null : $value;
        }, explode(':', base64_decode(mb_substr($auth_token, 6)), 2));
        if (count($parts) < 2) {
            return [$parts[0], null];
        }
        return $parts;
    }
    return [null, null];
}

            

                public function getAuthPassword()
{
    return $this->getAuthCredentials()[1];
}

            

                public function getAuthUser()
{
    return $this->getAuthCredentials()[0];
}

            

                public function getBaseUrl()
{
    if ($this->_baseUrl === null) {
        $this->_baseUrl = rtrim(dirname($this->getScriptUrl()), '\\/');
    }
    return $this->_baseUrl;
}

            

                public function getBodyParam($name, $defaultValue = null)
{
    $params = $this->getBodyParams();
    if (is_object($params)) {
        // unable to use `ArrayHelper::getValue()` due to different dots in key logic and lack of exception handling
        try {
            return isset($params->{$name}) ? $params->{$name} : $defaultValue;
        } catch (\Exception $e) {
            return $defaultValue;
        }
    }
    return isset($params[$name]) ? $params[$name] : $defaultValue;
}

            

                public function getBodyParams()
{
    if ($this->_bodyParams === null) {
        if (isset($_POST[$this->methodParam])) {
            $this->_bodyParams = $_POST;
            unset($this->_bodyParams[$this->methodParam]);
            return $this->_bodyParams;
        }
        $rawContentType = $this->getContentType();
        if (($pos = strpos((string)$rawContentType, ';')) !== false) {
            // e.g. text/html; charset=UTF-8
            $contentType = substr($rawContentType, 0, $pos);
        } else {
            $contentType = $rawContentType;
        }
        if (isset($this->parsers[$contentType])) {
            $parser = Yii::createObject($this->parsers[$contentType]);
            if (!($parser instanceof RequestParserInterface)) {
                throw new InvalidConfigException("The '$contentType' request parser is invalid. It must implement the yii\\web\\RequestParserInterface.");
            }
            $this->_bodyParams = $parser->parse($this->getRawBody(), $rawContentType);
        } elseif (isset($this->parsers['*'])) {
            $parser = Yii::createObject($this->parsers['*']);
            if (!($parser instanceof RequestParserInterface)) {
                throw new InvalidConfigException('The fallback request parser is invalid. It must implement the yii\\web\\RequestParserInterface.');
            }
            $this->_bodyParams = $parser->parse($this->getRawBody(), $rawContentType);
        } elseif ($this->getMethod() === 'POST') {
            // PHP has already parsed the body so we have all params in $_POST
            $this->_bodyParams = $_POST;
        } else {
            $this->_bodyParams = [];
            mb_parse_str($this->getRawBody(), $this->_bodyParams);
        }
    }
    return $this->_bodyParams;
}

            

                public function getContentType()
{
    if (isset($_SERVER['CONTENT_TYPE'])) {
        return $_SERVER['CONTENT_TYPE'];
    }
    //fix bug https://bugs.php.net/bug.php?id=66606
    return $this->headers->get('Content-Type') ?: '';
}

            

                public function getCookies()
{
    if ($this->_cookies === null) {
        $this->_cookies = new CookieCollection($this->loadCookies(), [
            'readOnly' => true,
        ]);
    }
    return $this->_cookies;
}

            

                public function getCsrfToken($regenerate = false)
{
    if ($this->_csrfToken === null || $regenerate) {
        $token = $this->loadCsrfToken();
        if ($regenerate || empty($token)) {
            $token = $this->generateCsrfToken();
        }
        $this->_csrfToken = Yii::$app->security->maskToken($token);
    }
    return $this->_csrfToken;
}

            

                public function getCsrfTokenFromHeader()
{
    return $this->headers->get(static::CSRF_HEADER);
}

            

                public function getETags()
{
    if ($this->headers->has('If-None-Match')) {
        return preg_split('/[\s,]+/', str_replace('-gzip', '', $this->headers->get('If-None-Match')), -1, PREG_SPLIT_NO_EMPTY);
    }
    return [];
}

            

                public function getHeaders()
{
    if ($this->_headers === null) {
        $this->_headers = new HeaderCollection();
        if (function_exists('getallheaders')) {
            $headers = getallheaders();
            foreach ($headers as $name => $value) {
                $this->_headers->add($name, $value);
            }
        } elseif (function_exists('http_get_request_headers')) {
            $headers = http_get_request_headers();
            foreach ($headers as $name => $value) {
                $this->_headers->add($name, $value);
            }
        } else {
            // ['prefix' => length]
            $headerPrefixes = ['HTTP_' => 5, 'REDIRECT_HTTP_' => 14];
            foreach ($_SERVER as $name => $value) {
                foreach ($headerPrefixes as $prefix => $length) {
                    if (strncmp($name, $prefix, $length) === 0) {
                        $name = str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', substr($name, $length)))));
                        $this->_headers->add($name, $value);
                        continue 2;
                    }
                }
            }
        }
        $this->filterHeaders($this->_headers);
    }
    return $this->_headers;
}

            

                public function getHostInfo()
{
    if ($this->_hostInfo === null) {
        $secure = $this->getIsSecureConnection();
        $http = $secure ? 'https' : 'http';
        if ($this->getSecureForwardedHeaderTrustedPart('host') !== null) {
            $this->_hostInfo = $http . '://' . $this->getSecureForwardedHeaderTrustedPart('host');
        } elseif ($this->headers->has('X-Forwarded-Host')) {
            $this->_hostInfo = $http . '://' . trim(explode(',', $this->headers->get('X-Forwarded-Host'))[0]);
        } elseif ($this->headers->has('X-Original-Host')) {
            $this->_hostInfo = $http . '://' . trim(explode(',', $this->headers->get('X-Original-Host'))[0]);
        } elseif ($this->headers->has('Host')) {
            $this->_hostInfo = $http . '://' . $this->headers->get('Host');
        } elseif (isset($_SERVER['SERVER_NAME'])) {
            $this->_hostInfo = $http . '://' . $_SERVER['SERVER_NAME'];
            $port = $secure ? $this->getSecurePort() : $this->getPort();
            if (($port !== 80 && !$secure) || ($port !== 443 && $secure)) {
                $this->_hostInfo .= ':' . $port;
            }
        }
    }
    return $this->_hostInfo;
}

            

                public function getHostName()
{
    if ($this->_hostName === null) {
        $this->_hostName = parse_url((string)$this->getHostInfo(), PHP_URL_HOST);
    }
    return $this->_hostName;
}

            

                protected function getIpValidator()
{
    return new IpValidator();
}

            

                public function getIsAjax()
{
    return $this->headers->get('X-Requested-With') === 'XMLHttpRequest';
}

            

                public function getIsDelete()
{
    return $this->getMethod() === 'DELETE';
}

            

                public function getIsFlash()
{
    $userAgent = $this->headers->get('User-Agent', '');
    return stripos($userAgent, 'Shockwave') !== false
        || stripos($userAgent, 'Flash') !== false;
}

            

                public function getIsGet()
{
    return $this->getMethod() === 'GET';
}

            

                public function getIsHead()
{
    return $this->getMethod() === 'HEAD';
}

            

                public function getIsOptions()
{
    return $this->getMethod() === 'OPTIONS';
}

            

                public function getIsPatch()
{
    return $this->getMethod() === 'PATCH';
}

            

                public function getIsPjax()
{
    return $this->getIsAjax() && $this->headers->has('X-Pjax');
}

            

                public function getIsPost()
{
    return $this->getMethod() === 'POST';
}

            

                public function getIsPut()
{
    return $this->getMethod() === 'PUT';
}

            

                public function getIsSecureConnection()
{
    if (isset($_SERVER['HTTPS']) && (strcasecmp($_SERVER['HTTPS'], 'on') === 0 || $_SERVER['HTTPS'] == 1)) {
        return true;
    }
    if (($proto = $this->getSecureForwardedHeaderTrustedPart('proto')) !== null) {
        return strcasecmp($proto, 'https') === 0;
    }
    foreach ($this->secureProtocolHeaders as $header => $values) {
        if (($headerValue = $this->headers->get($header, null)) !== null) {
            foreach ($values as $value) {
                if (strcasecmp($headerValue, $value) === 0) {
                    return true;
                }
            }
        }
    }
    return false;
}

            

                public function getMethod()
{
    if (
        isset($_POST[$this->methodParam])
        // Never allow to downgrade request from WRITE methods (POST, PATCH, DELETE, etc)
        // to read methods (GET, HEAD, OPTIONS) for security reasons.
        && !in_array(strtoupper($_POST[$this->methodParam]), ['GET', 'HEAD', 'OPTIONS'], true)
    ) {
        return strtoupper($_POST[$this->methodParam]);
    }
    if ($this->headers->has('X-Http-Method-Override')) {
        return strtoupper($this->headers->get('X-Http-Method-Override'));
    }
    if (isset($_SERVER['REQUEST_METHOD'])) {
        return strtoupper($_SERVER['REQUEST_METHOD']);
    }
    return 'GET';
}

            

                public function getOrigin()
{
    return $this->getHeaders()->get('origin');
}

            

                public function getPathInfo()
{
    if ($this->_pathInfo === null) {
        $this->_pathInfo = $this->resolvePathInfo();
    }
    return $this->_pathInfo;
}

            

                public function getPort()
{
    if ($this->_port === null) {
        $serverPort = $this->getServerPort();
        $this->_port = !$this->getIsSecureConnection() && $serverPort !== null ? $serverPort : 80;
    }
    return $this->_port;
}

            

                public function getPreferredLanguage(array $languages = [])
{
    if (empty($languages)) {
        return Yii::$app->language;
    }
    foreach ($this->getAcceptableLanguages() as $acceptableLanguage) {
        $acceptableLanguage = str_replace('_', '-', strtolower($acceptableLanguage));
        foreach ($languages as $language) {
            $normalizedLanguage = str_replace('_', '-', strtolower($language));
            if (
                $normalizedLanguage === $acceptableLanguage // en-us==en-us
                || strpos($acceptableLanguage, $normalizedLanguage . '-') === 0 // en==en-us
                || strpos($normalizedLanguage, $acceptableLanguage . '-') === 0 // en-us==en
            ) {
                return $language;
            }
        }
    }
    return reset($languages);
}

            

                public function getQueryParam($name, $defaultValue = null)
{
    $params = $this->getQueryParams();
    return isset($params[$name]) ? $params[$name] : $defaultValue;
}

            

                public function getQueryParams()
{
    if ($this->_queryParams === null) {
        return $_GET;
    }
    return $this->_queryParams;
}

            

                public function getQueryString()
{
    return isset($_SERVER['QUERY_STRING']) ? $_SERVER['QUERY_STRING'] : '';
}

            

                public function getRawBody()
{
    if ($this->_rawBody === null) {
        $this->_rawBody = file_get_contents('php://input');
    }
    return $this->_rawBody;
}

            

                public function getReferrer()
{
    return $this->headers->get('Referer');
}

            

                public function getRemoteHost()
{
    return isset($_SERVER['REMOTE_HOST']) ? $_SERVER['REMOTE_HOST'] : null;
}

            

                public function getRemoteIP()
{
    return isset($_SERVER['REMOTE_ADDR']) ? $_SERVER['REMOTE_ADDR'] : null;
}

            

                public function getScriptFile()
{
    if (isset($this->_scriptFile)) {
        return $this->_scriptFile;
    }
    if (isset($_SERVER['SCRIPT_FILENAME'])) {
        return $_SERVER['SCRIPT_FILENAME'];
    }
    throw new InvalidConfigException('Unable to determine the entry script file path.');
}

            

                public function getScriptUrl()
{
    if ($this->_scriptUrl === null) {
        $scriptFile = $this->getScriptFile();
        $scriptName = basename($scriptFile);
        if (isset($_SERVER['SCRIPT_NAME']) && basename($_SERVER['SCRIPT_NAME']) === $scriptName) {
            $this->_scriptUrl = $_SERVER['SCRIPT_NAME'];
        } elseif (isset($_SERVER['PHP_SELF']) && basename($_SERVER['PHP_SELF']) === $scriptName) {
            $this->_scriptUrl = $_SERVER['PHP_SELF'];
        } elseif (isset($_SERVER['ORIG_SCRIPT_NAME']) && basename($_SERVER['ORIG_SCRIPT_NAME']) === $scriptName) {
            $this->_scriptUrl = $_SERVER['ORIG_SCRIPT_NAME'];
        } elseif (isset($_SERVER['PHP_SELF']) && ($pos = strpos($_SERVER['PHP_SELF'], '/' . $scriptName)) !== false) {
            $this->_scriptUrl = substr($_SERVER['SCRIPT_NAME'], 0, $pos) . '/' . $scriptName;
        } elseif (!empty($_SERVER['DOCUMENT_ROOT']) && strpos($scriptFile, $_SERVER['DOCUMENT_ROOT']) === 0) {
            $this->_scriptUrl = str_replace([$_SERVER['DOCUMENT_ROOT'], '\\'], ['', '/'], $scriptFile);
        } else {
            throw new InvalidConfigException('Unable to determine the entry script URL.');
        }
    }
    return $this->_scriptUrl;
}

            

                protected function getSecureForwardedHeaderParts()
{
    if ($this->_secureForwardedHeaderParts !== null) {
        return $this->_secureForwardedHeaderParts;
    }
    if (count(preg_grep('/^forwarded$/i', $this->secureHeaders)) === 0) {
        return $this->_secureForwardedHeaderParts = [];
    }
    /*
     * First header is always correct, because proxy CAN add headers
     * after last one is found.
     * Keep in mind that it is NOT enforced, therefore we cannot be
     * sure, that this is really a first one.
     *
     * FPM keeps last header sent which is a bug. You need to merge
     * headers together on your web server before letting FPM handle it
     * @see https://bugs.php.net/bug.php?id=78844
     */
    $forwarded = $this->headers->get('Forwarded', '');
    if ($forwarded === '') {
        return $this->_secureForwardedHeaderParts = [];
    }
    preg_match_all('/(?:[^",]++|"[^"]++")+/', $forwarded, $forwardedElements);
    foreach ($forwardedElements[0] as $forwardedPairs) {
        preg_match_all('/(?P<key>\w+)\s*=\s*(?:(?P<value>[^",;]*[^",;\s])|"(?P<value2>[^"]+)")/', $forwardedPairs,
            $matches, PREG_SET_ORDER);
        $this->_secureForwardedHeaderParts[] = array_reduce($matches, function ($carry, $item) {
            $value = $item['value'];
            if (isset($item['value2']) && $item['value2'] !== '') {
                $value = $item['value2'];
            }
            $carry[strtolower($item['key'])] = $value;
            return $carry;
        }, []);
    }
    return $this->_secureForwardedHeaderParts;
}

            

                protected function getSecureForwardedHeaderTrustedPart($token)
{
    $token = strtolower($token);
    if ($parts = $this->getSecureForwardedHeaderTrustedParts()) {
        $lastElement = array_pop($parts);
        if ($lastElement && isset($lastElement[$token])) {
            return $lastElement[$token];
        }
    }
    return null;
}

            

                protected function getSecureForwardedHeaderTrustedParts()
{
    $validator = $this->getIpValidator();
    $trustedHosts = [];
    foreach ($this->trustedHosts as $trustedCidr => $trustedCidrOrHeaders) {
        if (!is_array($trustedCidrOrHeaders)) {
            $trustedCidr = $trustedCidrOrHeaders;
        }
        $trustedHosts[] = $trustedCidr;
    }
    $validator->setRanges($trustedHosts);
    return array_filter($this->getSecureForwardedHeaderParts(), function ($headerPart) use ($validator) {
        return isset($headerPart['for']) ? !$validator->validate($headerPart['for']) : true;
    });
}

            

                public function getSecurePort()
{
    if ($this->_securePort === null) {
        $serverPort = $this->getServerPort();
        $this->_securePort = $this->getIsSecureConnection() && $serverPort !== null ? $serverPort : 443;
    }
    return $this->_securePort;
}

            

                public function getServerName()
{
    return isset($_SERVER['SERVER_NAME']) ? $_SERVER['SERVER_NAME'] : null;
}

            

                public function getServerPort()
{
    foreach ($this->portHeaders as $portHeader) {
        if ($this->headers->has($portHeader)) {
            $port = $this->headers->get($portHeader);
            if ($port !== null) {
                return $port;
            }
        }
    }
    return isset($_SERVER['SERVER_PORT']) ? (int) $_SERVER['SERVER_PORT'] : null;
}

            

                protected function getTrustedHeaders()
{
    // do not trust any of the [[secureHeaders]] by default
    $trustedHeaders = [];
    // check if the client is a trusted host
    if (!empty($this->trustedHosts)) {
        $validator = $this->getIpValidator();
        $ip = $this->getRemoteIP();
        foreach ($this->trustedHosts as $cidr => $headers) {
            if (!is_array($headers)) {
                $cidr = $headers;
                $headers = $this->secureHeaders;
            }
            $validator->setRanges($cidr);
            if ($validator->validate($ip)) {
                $trustedHeaders = $headers;
                break;
            }
        }
    }
    return $trustedHeaders;
}

            

                public function getUrl()
{
    if ($this->_url === null) {
        $this->_url = $this->resolveRequestUri();
    }
    return $this->_url;
}

            

                public function getUserAgent()
{
    return $this->headers->get('User-Agent');
}

            

                public function getUserHost()
{
    $userIp = $this->getUserIpFromIpHeaders();
    if($userIp === null) {
        return $this->getRemoteHost();
    }
    return gethostbyaddr($userIp);
}

            

                public function getUserIP()
{
    $ip = $this->getUserIpFromIpHeaders();
    return $ip === null ? $this->getRemoteIP() : $ip;
}

            

                protected function getUserIpFromIpHeader($ips)
{
    $ips = trim($ips);
    if ($ips === '') {
        return null;
    }
    $ips = preg_split('/\s*,\s*/', $ips, -1, PREG_SPLIT_NO_EMPTY);
    krsort($ips);
    $validator = $this->getIpValidator();
    $resultIp = null;
    foreach ($ips as $ip) {
        $validator->setRanges('any');
        if (!$validator->validate($ip) /* checking IP format */) {
            break;
        }
        $resultIp = $ip;
        $isTrusted = false;
        foreach ($this->trustedHosts as $trustedCidr => $trustedCidrOrHeaders) {
            if (!is_array($trustedCidrOrHeaders)) {
                $trustedCidr = $trustedCidrOrHeaders;
            }
            $validator->setRanges($trustedCidr);
            if ($validator->validate($ip) /* checking trusted range */) {
                $isTrusted = true;
                break;
            }
        }
        if (!$isTrusted) {
            break;
        }
    }
    return $resultIp;
}

            

                protected function getUserIpFromIpHeaders()
{
    $ip = $this->getSecureForwardedHeaderTrustedPart('for');
    if ($ip !== null && preg_match(
        '/^\[?(?P<ip>(?:(?:(?:[0-9a-f]{1,4}:){1,6}(?:[0-9a-f]{1,4})?(?:(?::[0-9a-f]{1,4}){1,6}))|(?:\d{1,3}\.){3}\d{1,3}))\]?(?::(?P<port>\d+))?$/',
        $ip,
        $matches
    )) {
        $ip = $this->getUserIpFromIpHeader($matches['ip']);
        if ($ip !== null) {
            return $ip;
        }
    }
    foreach ($this->ipHeaders as $ipHeader) {
        if ($this->headers->has($ipHeader)) {
            $ip = $this->getUserIpFromIpHeader($this->headers->get($ipHeader));
            if ($ip !== null) {
                return $ip;
            }
        }
    }
    return null;
}

            

                protected function loadCookies()
{
    $cookies = [];
    if ($this->enableCookieValidation) {
        if ($this->cookieValidationKey == '') {
            throw new InvalidConfigException(get_class($this) . '::cookieValidationKey must be configured with a secret key.');
        }
        foreach ($_COOKIE as $name => $value) {
            if (!is_string($value)) {
                continue;
            }
            $data = Yii::$app->getSecurity()->validateData($value, $this->cookieValidationKey);
            if ($data === false) {
                continue;
            }
            if (defined('PHP_VERSION_ID') && PHP_VERSION_ID >= 70000) {
                $data = @unserialize($data, ['allowed_classes' => false]);
            } else {
                $data = @unserialize($data);
            }
            if (is_array($data) && isset($data[0], $data[1]) && $data[0] === $name) {
                $cookies[$name] = Yii::createObject([
                    'class' => 'yii\web\Cookie',
                    'name' => $name,
                    'value' => $data[1],
                    'expire' => null,
                ]);
            }
        }
    } else {
        foreach ($_COOKIE as $name => $value) {
            $cookies[$name] = Yii::createObject([
                'class' => 'yii\web\Cookie',
                'name' => $name,
                'value' => $value,
                'expire' => null,
            ]);
        }
    }
    return $cookies;
}

            

                protected function loadCsrfToken()
{
    if ($this->enableCsrfCookie) {
        return $this->getCookies()->getValue($this->csrfParam);
    }
    return Yii::$app->getSession()->get($this->csrfParam);
}