Class luya\web\Request

                public function __call($name, $params)
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $object) {
        if ($object->hasMethod($name)) {
            return call_user_func_array([$object, $name], $params);
        }
    }
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

            

                public function __clone()
{
    $this->_events = [];
    $this->_eventWildcards = [];
    $this->_behaviors = null;
}

            

                public function __construct($config = [])
{
    if (!empty($config)) {
        Yii::configure($this, $config);
    }
    $this->init();
}

            

                public function __get($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        // read property, e.g. getName()
        return $this->$getter();
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name;
        }
    }
    if (method_exists($this, 'set' . $name)) {
        throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __isset($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter() !== null;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name !== null;
        }
    }
    return false;
}

            

                public function __set($name, $value)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        // set property
        $this->$setter($value);
        return;
    } elseif (strncmp($name, 'on ', 3) === 0) {
        // on event: attach event handler
        $this->on(trim(substr($name, 3)), $value);
        return;
    } elseif (strncmp($name, 'as ', 3) === 0) {
        // as behavior: attach behavior
        $name = trim(substr($name, 3));
        $this->attachBehavior($name, $value instanceof Behavior ? $value : Yii::createObject($value));
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = $value;
            return;
        }
    }
    if (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __unset($name)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter(null);
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = null;
            return;
        }
    }
    throw new InvalidCallException('Unsetting an unknown or read-only property: ' . get_class($this) . '::' . $name);
}

            

                public function attachBehavior($name, $behavior)
{
    $this->ensureBehaviors();
    return $this->attachBehaviorInternal($name, $behavior);
}

            

                public function attachBehaviors($behaviors)
{
    $this->ensureBehaviors();
    foreach ($behaviors as $name => $behavior) {
        $this->attachBehaviorInternal($name, $behavior);
    }
}

            

                public function behaviors()
{
    return [];
}

            

                public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canGetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canSetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public static function className()
{
    return get_called_class();
}

            

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

            

                public function detachBehavior($name)
{
    $this->ensureBehaviors();
    if (isset($this->_behaviors[$name])) {
        $behavior = $this->_behaviors[$name];
        unset($this->_behaviors[$name]);
        $behavior->detach();
        return $behavior;
    }
    return null;
}

            

                public function detachBehaviors()
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $name => $behavior) {
        $this->detachBehavior($name);
    }
}

            

                public function ensureBehaviors()
{
    if ($this->_behaviors === null) {
        $this->_behaviors = [];
        foreach ($this->behaviors() as $name => $behavior) {
            $this->attachBehaviorInternal($name, $behavior);
        }
    }
}

            

                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 getBehavior($name)
{
    $this->ensureBehaviors();
    return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}

            

                public function getBehaviors()
{
    $this->ensureBehaviors();
    return $this->_behaviors;
}

            

                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 getIsConsoleRequest()
{
    return $this->_isConsoleRequest !== null ? $this->_isConsoleRequest : PHP_SAPI === 'cli';
}

            

                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;
}

            

                public function hasEventHandlers($name)
{
    $this->ensureBehaviors();
    if (!empty($this->_events[$name])) {
        return true;
    }
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (!empty($handlers) && StringHelper::matchWildcard($wildcard, $name)) {
            return true;
        }
    }
    return Event::hasHandlers($this, $name);
}

            

                public function hasMethod($name, $checkBehaviors = true)
{
    if (method_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->hasMethod($name)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
{
    return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
}

            

                public function init()
{
}

            

                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);
}

            

                public function off($name, $handler = null)
{
    $this->ensureBehaviors();
    if (empty($this->_events[$name]) && empty($this->_eventWildcards[$name])) {
        return false;
    }
    if ($handler === null) {
        unset($this->_events[$name], $this->_eventWildcards[$name]);
        return true;
    }
    $removed = false;
    // plain event names
    if (isset($this->_events[$name])) {
        foreach ($this->_events[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_events[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_events[$name] = array_values($this->_events[$name]);
            return true;
        }
    }
    // wildcard event names
    if (isset($this->_eventWildcards[$name])) {
        foreach ($this->_eventWildcards[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_eventWildcards[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_eventWildcards[$name] = array_values($this->_eventWildcards[$name]);
            // remove empty wildcards to save future redundant regex checks:
            if (empty($this->_eventWildcards[$name])) {
                unset($this->_eventWildcards[$name]);
            }
        }
    }
    return $removed;
}

            

                public function on($name, $handler, $data = null, $append = true)
{
    $this->ensureBehaviors();
    if (strpos($name, '*') !== false) {
        if ($append || empty($this->_eventWildcards[$name])) {
            $this->_eventWildcards[$name][] = [$handler, $data];
        } else {
            array_unshift($this->_eventWildcards[$name], [$handler, $data]);
        }
        return;
    }
    if ($append || empty($this->_events[$name])) {
        $this->_events[$name][] = [$handler, $data];
    } else {
        array_unshift($this->_events[$name], [$handler, $data]);
    }
}

            

                public function parseAcceptHeader($header)
{
    $accepts = [];
    foreach (explode(',', $header) as $i => $part) {
        $params = preg_split('/\s*;\s*/', trim($part), -1, PREG_SPLIT_NO_EMPTY);
        if (empty($params)) {
            continue;
        }
        $values = [
            'q' => [$i, array_shift($params), 1],
        ];
        foreach ($params as $param) {
            if (strpos($param, '=') !== false) {
                list($key, $value) = explode('=', $param, 2);
                if ($key === 'q') {
                    $values['q'][2] = (float) $value;
                } else {
                    $values[$key] = $value;
                }
            } else {
                $values[] = $param;
            }
        }
        $accepts[] = $values;
    }
    usort($accepts, function ($a, $b) {
        $a = $a['q']; // index, name, q
        $b = $b['q'];
        if ($a[2] > $b[2]) {
            return -1;
        }
        if ($a[2] < $b[2]) {
            return 1;
        }
        if ($a[1] === $b[1]) {
            return $a[0] > $b[0] ? 1 : -1;
        }
        if ($a[1] === '*/*') {
            return 1;
        }
        if ($b[1] === '*/*') {
            return -1;
        }
        $wa = $a[1][strlen($a[1]) - 1] === '*';
        $wb = $b[1][strlen($b[1]) - 1] === '*';
        if ($wa xor $wb) {
            return $wa ? 1 : -1;
        }
        return $a[0] > $b[0] ? 1 : -1;
    });
    $result = [];
    foreach ($accepts as $accept) {
        $name = $accept['q'][1];
        $accept['q'] = $accept['q'][2];
        $result[$name] = $accept;
    }
    return $result;
}

            

                public function post($name = null, $defaultValue = null)
{
    if ($name === null) {
        return $this->getBodyParams();
    }
    return $this->getBodyParam($name, $defaultValue);
}

            

                public function resolve()
{
    $result = Yii::$app->getUrlManager()->parseRequest($this);
    if ($result !== false) {
        list($route, $params) = $result;
        if ($this->_queryParams === null) {
            $_GET = $params + $_GET; // preserve numeric keys
        } else {
            $this->_queryParams = $params + $this->_queryParams;
        }
        return [$route, $this->getQueryParams()];
    }
    throw new NotFoundHttpException(Yii::t('yii', 'Page not found.'));
}

            

                protected function resolvePathInfo()
{
    $pathInfo = $this->getUrl();
    if (($pos = strpos($pathInfo, '?')) !== false) {
        $pathInfo = substr($pathInfo, 0, $pos);
    }
    $pathInfo = urldecode($pathInfo);
    // try to encode in UTF8 if not so
    // https://www.w3.org/International/questions/qa-forms-utf-8.en.html
    if (!preg_match('%^(?:
        [\x09\x0A\x0D\x20-\x7E]              # ASCII
        | [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
        | \xE0[\xA0-\xBF][\x80-\xBF]         # excluding overlongs
        | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
        | \xED[\x80-\x9F][\x80-\xBF]         # excluding surrogates
        | \xF0[\x90-\xBF][\x80-\xBF]{2}      # planes 1-3
        | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
        | \xF4[\x80-\x8F][\x80-\xBF]{2}      # plane 16
        )*$%xs', $pathInfo)
    ) {
        $pathInfo = $this->utf8Encode($pathInfo);
    }
    $scriptUrl = $this->getScriptUrl();
    $baseUrl = $this->getBaseUrl();
    if (strpos($pathInfo, $scriptUrl) === 0) {
        $pathInfo = substr($pathInfo, strlen($scriptUrl));
    } elseif ($baseUrl === '' || strpos($pathInfo, $baseUrl) === 0) {
        $pathInfo = substr($pathInfo, strlen($baseUrl));
    } elseif (isset($_SERVER['PHP_SELF']) && strpos($_SERVER['PHP_SELF'], $scriptUrl) === 0) {
        $pathInfo = substr($_SERVER['PHP_SELF'], strlen($scriptUrl));
    } else {
        throw new InvalidConfigException('Unable to determine the path info of the current request.');
    }
    if (strncmp($pathInfo, '/', 1) === 0) {
        $pathInfo = substr($pathInfo, 1);
    }
    return (string) $pathInfo;
}

            

                protected function resolveRequestUri()
{
    if ($this->headers->has('X-Rewrite-Url')) { // IIS
        $requestUri = $this->headers->get('X-Rewrite-Url');
    } elseif (isset($_SERVER['REQUEST_URI'])) {
        $requestUri = $_SERVER['REQUEST_URI'];
        if ($requestUri !== '' && $requestUri[0] !== '/') {
            $requestUri = preg_replace('/^(http|https):\/\/[^\/]+/i', '', $requestUri);
        }
    } elseif (isset($_SERVER['ORIG_PATH_INFO'])) { // IIS 5.0 CGI
        $requestUri = $_SERVER['ORIG_PATH_INFO'];
        if (!empty($_SERVER['QUERY_STRING'])) {
            $requestUri .= '?' . $_SERVER['QUERY_STRING'];
        }
    } else {
        throw new InvalidConfigException('Unable to determine the request URI.');
    }
    return $requestUri;
}

            

                public function setAcceptableContentTypes($value)
{
    $this->_contentTypes = $value;
}

            

                public function setAcceptableLanguages($value)
{
    $this->_languages = $value;
}

            

                public function setBaseUrl($value)
{
    $this->_baseUrl = $value;
}

            

                public function setBodyParams($values)
{
    $this->_bodyParams = $values;
}

            

                public function setHostInfo($value)
{
    $this->_hostName = null;
    $this->_hostInfo = $value === null ? null : rtrim($value, '/');
}

            

                public function setIsConsoleRequest($value)
{
    $this->_isConsoleRequest = $value;
}

            

                public function setPathInfo($value)
{
    $this->_pathInfo = $value === null ? null : ltrim($value, '/');
}

            

                public function setPort($value)
{
    if ($value != $this->_port) {
        $this->_port = (int) $value;
        $this->_hostInfo = null;
    }
}