Class Yiisoft\ProxyMiddleware\TrustedHostsNetworkResolver

                public function __construct()
{
}

            

                public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
{
    /** @var string|null $remoteAddr */
    $remoteAddr = $request->getServerParams()['REMOTE_ADDR'] ?? null;
    if (empty($remoteAddr)) {
        return $this->handleNotTrusted($request, $handler);
    }
    [$forwardedHeaderGroup, $connectionChainItems] = $this->getConnectionChainItems($remoteAddr, $request);
    $request = $this->filterTypicalForwardedHeaders($forwardedHeaderGroup, $request);
    $validatedConnectionChainItems = [];
    $connectionChainItem = $this->iterateConnectionChainItems(
        $connectionChainItems,
        $validatedConnectionChainItems,
        $request,
    );
    if ($this->connectionChainItemsAttribute !== null) {
        $request = $request->withAttribute($this->connectionChainItemsAttribute, $validatedConnectionChainItems);
    }
    $uri = $request->getUri();
    $protocol = $connectionChainItem['protocol'];
    if ($protocol !== null) {
        $uri = $uri->withScheme($protocol);
    }
    $host = $connectionChainItem['host'];
    if ($host !== null) {
        $uri = $uri->withHost($host);
    }
    $port = $connectionChainItem['port'];
    if ($port !== null) {
        $uri = $uri->withPort($port);
    }
    $request = $request
        ->withUri($uri)
        ->withAttribute(self::ATTRIBUTE_REQUEST_CLIENT_IP, $connectionChainItem['ip']);
    return $handler->handle($request);
}

            

                protected function reverseObfuscateIpIdentifier(
    string $ipIdentifier,
    array $validatedConnectionChainItems,
    array $remainingConnectionChainItems,
    RequestInterface $request,
): ?array {
    return null;
}

            

                public function withConnectionChainItemsAttribute(?string $attribute): self
{
    if (is_string($attribute)) {
        $this->assertNonEmpty($attribute, 'Attribute');
    }
    /** @var ?non-empty-string $attribute */
    $new = clone $this;
    $new->connectionChainItemsAttribute = $attribute;
    return $new;
}

            

                public function withForwardedHeaderGroups(array $headerGroups): self
{
    $this->assertNonEmpty($headerGroups, 'Forwarded header groups');
    /** @psalm-var non-empty-array $headerGroups */
    $allowedHeaderGroupKeys = ['ip', 'protocol', 'host', 'port'];
    $validatedHeaderGroups = [];
    foreach ($headerGroups as $headerGroup) {
        if ($headerGroup === self::FORWARDED_HEADER_GROUP_RFC) {
            $validatedHeaderGroups[] = $headerGroup;
        } elseif (is_array($headerGroup)) {
            $this->assertNonEmpty($headerGroup, 'Forwarded header group array');
            $this->assertExactKeysForArray($allowedHeaderGroupKeys, $headerGroup, 'forwarded header group');
            $validatedHeaderGroup = [];
            foreach (['ip', 'host', 'port'] as $key) {
                $this->assertIsNonEmptyString($headerGroup[$key], "Header name for \"$key\"");
                $validatedHeaderGroup[$key] = $this->normalizeHeaderName($headerGroup[$key]);
            }
            if (is_string($headerGroup['protocol'])) {
                $this->assertNonEmpty($headerGroup['protocol'], 'Header name for "protocol"');
                $validatedHeaderGroup['protocol'] = $this->normalizeHeaderName($headerGroup['protocol']);
            } elseif (is_array($headerGroup['protocol'])) {
                $this->assertNonEmpty($headerGroup['protocol'], 'Protocol header config array');
                $this->assertExactKeysForArray([0, 1], $headerGroup['protocol'], 'protocol header config');
                $this->assertIsNonEmptyString($headerGroup['protocol'][0], 'Header name for "protocol"');
                $headerName = $this->normalizeHeaderName($headerGroup['protocol'][0]);
                if (is_array($headerGroup['protocol'][1])) {
                    $this->assertNonEmpty($headerGroup['protocol'][1], 'Values in mapping for protocol header');
                    foreach ($headerGroup['protocol'][1] as $key => $value) {
                        $this->assertIsNonEmptyString($key, 'Key in mapping for protocol header');
                        $this->assertIsAllowedProtocol($value, 'Value in mapping for protocol header');
                    }
                } elseif (!is_callable($headerGroup['protocol'][1])) {
                    $message = 'Protocol header resolving must be specified either via an associative array or a ' .
                        'callable.';
                    throw new InvalidArgumentException($message);
                }
                $validatedHeaderGroup['protocol'] = [$headerName, $headerGroup['protocol'][1]];
            } else {
                throw new InvalidArgumentException('Protocol header config must be either a string or an array.');
            }
            /** @psalm-var SeparateForwardedHeaderGroup $validatedHeaderGroup */
            $validatedHeaderGroups[] = $validatedHeaderGroup;
        } else {
            $message = 'Forwarded header group must be either an associative array or ' .
                'TrustedHostsNetworkResolver::FORWARDED_HEADER_GROUP_RFC constant.';
            throw new InvalidArgumentException($message);
        }
    }
    $new = clone $this;
    $new->forwardedHeaderGroups = $validatedHeaderGroups;
    return $new;
}

            

                public function withTrustedIps(array $trustedIps): self
{
    $validatedIps = [];
    foreach ($trustedIps as $ip) {
        $this->assertIsNonEmptyString($ip, 'Trusted IP');
        if (!IpValidator::isIp($ip)) {
            throw new InvalidArgumentException("\"$ip\" is not a valid IP.");
        }
        $validatedIps[] = $ip;
    }
    $new = clone $this;
    $new->trustedIps = $validatedIps;
    return $new;
}

            

                public function withTypicalForwardedHeaders(array $headerNames): self
{
    $this->assertNonEmpty($headerNames, 'Typical forwarded headers');
    $normalizedHeaderNames = [];
    foreach ($headerNames as $headerName) {
        $this->assertIsNonEmptyString($headerName, 'Typical forwarded header');
        $normalizedHeaderNames[] = $this->normalizeHeaderName($headerName);
    }
    $new = clone $this;
    $new->typicalForwardedHeaders = $normalizedHeaderNames;
    return $new;
}