webshell

Ghost Exploiter Team Official

Directory >> /home/whitjouh/public_html/core/vendor/symfony/http-foundation/

File / Folder	Size	Action
.	-
Exception	--	ren
File	--	ren
RateLimiter	--	ren
RequestMatcher	--	ren
Session	--	ren
Test	--	ren
AcceptHeader.php	3.355KB	edt ren
AcceptHeaderItem.php	3.188KB	edt ren
BinaryFileResponse.php	12.329KB	edt ren
CHANGELOG.md	19.114KB	edt ren
ChainRequestMatcher.php	0.853KB	edt ren
Cookie.php	11.93KB	edt ren
ExpressionRequestMatche...	1.934KB	edt ren
FileBag.php	3.743KB	edt ren
HeaderBag.php	7.123KB	edt ren
HeaderUtils.php	8.917KB	edt ren
InputBag.php	5.012KB	edt ren
IpUtils.php	7.447KB	edt ren
JsonResponse.php	6.639KB	edt ren
LICENSE	1.043KB	edt ren
ParameterBag.php	7.456KB	edt ren
README.md	0.514KB	edt ren
RedirectResponse.php	2.487KB	edt ren
Request.php	67.421KB	edt ren
RequestMatcher.php	5.21KB	edt ren
RequestMatcherInterface...	0.606KB	edt ren
RequestStack.php	2.638KB	edt ren
Response.php	40.163KB	edt ren
ResponseHeaderBag.php	7.788KB	edt ren
ServerBag.php	3.916KB	edt ren
StreamedJsonResponse.php	5.64KB	edt ren
StreamedResponse.php	2.997KB	edt ren
UriSigner.php	3.207KB	edt ren
UrlHelper.php	3.051KB	edt ren
composer.json	1.291KB	edt ren

<?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\HttpFoundation;

/**
 * HeaderBag is a container for HTTP headers.
 *
 * @author Fabien Potencier <fabien@symfony.com>
 *
 * @implements \IteratorAggregate<string, list<string|null>>
 */
class HeaderBag implements \IteratorAggregate, \Countable, \Stringable
{
    protected const UPPER = '_ABCDEFGHIJKLMNOPQRSTUVWXYZ';
    protected const LOWER = '-abcdefghijklmnopqrstuvwxyz';

/**
     * @var array<string, list<string|null>>
     */
    protected $headers = [];
    protected $cacheControl = [];

public function __construct(array $headers = [])
    {
        foreach ($headers as $key => $values) {
            $this->set($key, $values);
        }
    }

/**
     * Returns the headers as a string.
     */
    public function __toString(): string
    {
        if (!$headers = $this->all()) {
            return '';
        }

ksort($headers);
        $max = max(array_map('strlen', array_keys($headers))) + 1;
        $content = '';
        foreach ($headers as $name => $values) {
            $name = ucwords($name, '-');
            foreach ($values as $value) {
                $content .= sprintf("%-{$max}s %s\r\n", $name.':', $value);
            }
        }

return $content;
    }

/**
     * Returns the headers.
     *
     * @param string|null $key The name of the headers to return or null to get them all
     *
     * @return ($key is null ? array<string, list<string|null>> : list<string|null>)
     */
    public function all(?string $key = null): array
    {
        if (null !== $key) {
            return $this->headers[strtr($key, self::UPPER, self::LOWER)] ?? [];
        }

return $this->headers;
    }

/**
     * Returns the parameter keys.
     *
     * @return string[]
     */
    public function keys(): array
    {
        return array_keys($this->all());
    }

/**
     * Replaces the current HTTP headers by a new set.
     *
     * @return void
     */
    public function replace(array $headers = [])
    {
        $this->headers = [];
        $this->add($headers);
    }

/**
     * Adds new headers the current HTTP headers set.
     *
     * @return void
     */
    public function add(array $headers)
    {
        foreach ($headers as $key => $values) {
            $this->set($key, $values);
        }
    }

/**
     * Returns the first header by name or the default one.
     */
    public function get(string $key, ?string $default = null): ?string
    {
        $headers = $this->all($key);

if (!$headers) {
            return $default;
        }

if (null === $headers[0]) {
            return null;
        }

return (string) $headers[0];
    }

/**
     * Sets a header by name.
     *
     * @param string|string[]|null $values  The value or an array of values
     * @param bool                 $replace Whether to replace the actual value or not (true by default)
     *
     * @return void
     */
    public function set(string $key, string|array|null $values, bool $replace = true)
    {
        $key = strtr($key, self::UPPER, self::LOWER);

if (\is_array($values)) {
            $values = array_values($values);

if (true === $replace || !isset($this->headers[$key])) {
                $this->headers[$key] = $values;
            } else {
                $this->headers[$key] = array_merge($this->headers[$key], $values);
            }
        } else {
            if (true === $replace || !isset($this->headers[$key])) {
                $this->headers[$key] = [$values];
            } else {
                $this->headers[$key][] = $values;
            }
        }

if ('cache-control' === $key) {
            $this->cacheControl = $this->parseCacheControl(implode(', ', $this->headers[$key]));
        }
    }

/**
     * Returns true if the HTTP header is defined.
     */
    public function has(string $key): bool
    {
        return \array_key_exists(strtr($key, self::UPPER, self::LOWER), $this->all());
    }

/**
     * Returns true if the given HTTP header contains the given value.
     */
    public function contains(string $key, string $value): bool
    {
        return \in_array($value, $this->all($key));
    }

/**
     * Removes a header.
     *
     * @return void
     */
    public function remove(string $key)
    {
        $key = strtr($key, self::UPPER, self::LOWER);

unset($this->headers[$key]);

if ('cache-control' === $key) {
            $this->cacheControl = [];
        }
    }

/**
     * Returns the HTTP header value converted to a date.
     *
     * @return \DateTimeImmutable|null
     *
     * @throws \RuntimeException When the HTTP header is not parseable
     */
    public function getDate(string $key, ?\DateTimeInterface $default = null): ?\DateTimeInterface
    {
        if (null === $value = $this->get($key)) {
            return null !== $default ? \DateTimeImmutable::createFromInterface($default) : null;
        }

if (false === $date = \DateTimeImmutable::createFromFormat(\DATE_RFC2822, $value)) {
            throw new \RuntimeException(sprintf('The "%s" HTTP header is not parseable (%s).', $key, $value));
        }

return $date;
    }

/**
     * Adds a custom Cache-Control directive.
     *
     * @return void
     */
    public function addCacheControlDirective(string $key, bool|string $value = true)
    {
        $this->cacheControl[$key] = $value;

$this->set('Cache-Control', $this->getCacheControlHeader());
    }

/**
     * Returns true if the Cache-Control directive is defined.
     */
    public function hasCacheControlDirective(string $key): bool
    {
        return \array_key_exists($key, $this->cacheControl);
    }

/**
     * Returns a Cache-Control directive value by name.
     */
    public function getCacheControlDirective(string $key): bool|string|null
    {
        return $this->cacheControl[$key] ?? null;
    }

/**
     * Removes a Cache-Control directive.
     *
     * @return void
     */
    public function removeCacheControlDirective(string $key)
    {
        unset($this->cacheControl[$key]);

$this->set('Cache-Control', $this->getCacheControlHeader());
    }

/**
     * Returns an iterator for headers.
     *
     * @return \ArrayIterator<string, list<string|null>>
     */
    public function getIterator(): \ArrayIterator
    {
        return new \ArrayIterator($this->headers);
    }

/**
     * Returns the number of headers.
     */
    public function count(): int
    {
        return \count($this->headers);
    }

/**
     * @return string
     */
    protected function getCacheControlHeader()
    {
        ksort($this->cacheControl);

return HeaderUtils::toString($this->cacheControl, ',');
    }

/**
     * Parses a Cache-Control HTTP header.
     */
    protected function parseCacheControl(string $header): array
    {
        $parts = HeaderUtils::split($header, ',=');

return HeaderUtils::combine($parts);
    }
}

<=Back