Debian Codegraph @

vendor/guzzlehttp/guzzle/src/Cookie/CookieJar.php

raw
1 <?php
2
3 namespace GuzzleHttp\Cookie;
4
5 use Psr\Http\Message\RequestInterface;
6 use Psr\Http\Message\ResponseInterface;
7
8 /**
9 * Cookie jar that stores cookies as an array
10 */
11 class CookieJar implements CookieJarInterface
12 {
13 /**
14 * @var SetCookie[] Loaded cookie data
15 */
16 private $cookies = [];
17
18 /**
19 * @var bool
20 */
21 private $strictMode;
22
23 /**
24 * @param bool $strictMode Set to true to throw exceptions when invalid
25 * cookies are added to the cookie jar.
26 * @param array $cookieArray Array of SetCookie objects or a hash of
27 * arrays that can be used with the SetCookie
28 * constructor
29 */
30 public function __construct(bool $strictMode = false, array $cookieArray = [])
31 {
32 $this->strictMode = $strictMode;
33
34 foreach ($cookieArray as $cookie) {
35 if (!$cookie instanceof SetCookie) {
36 $cookie = new SetCookie($cookie);
37 }
38 $this->setCookie($cookie);
39 }
40 }
41
42 /**
43 * Create a new Cookie jar from an associative array and domain.
44 *
45 * @param array $cookies Cookies to create the jar from
46 * @param string $domain Domain to set the cookies to
47 */
48 public static function fromArray(array $cookies, string $domain): self
49 {
50 $cookieJar = new self();
51 foreach ($cookies as $name => $value) {
52 $cookieJar->setCookie(new SetCookie([
53 'Domain' => $domain,
54 'Name' => $name,
55 'Value' => $value,
56 'Discard' => true,
57 ]));
58 }
59
60 return $cookieJar;
61 }
62
63 /**
64 * Evaluate if this cookie should be persisted to storage
65 * that survives between requests.
66 *
67 * @param SetCookie $cookie Being evaluated.
68 * @param bool $allowSessionCookies If we should persist session cookies
69 */
70 public static function shouldPersist(SetCookie $cookie, bool $allowSessionCookies = false): bool
71 {
72 if ($cookie->getExpires() || $allowSessionCookies) {
73 if (!$cookie->getDiscard()) {
74 return true;
75 }
76 }
77
78 return false;
79 }
80
81 /**
82 * Finds and returns the cookie based on the name
83 *
84 * @param string $name cookie name to search for
85 *
86 * @return SetCookie|null cookie that was found or null if not found
87 */
88 public function getCookieByName(string $name): ?SetCookie
89 {
90 foreach ($this->cookies as $cookie) {
91 if ($cookie->getName() !== null && \strcasecmp($cookie->getName(), $name) === 0) {
92 return $cookie;
93 }
94 }
95
96 return null;
97 }
98
99 public function toArray(): array
100 {
101 return \array_map(static function (SetCookie $cookie): array {
102 return $cookie->toArray();
103 }, $this->getIterator()->getArrayCopy());
104 }
105
106 public function clear(?string $domain = null, ?string $path = null, ?string $name = null): void
107 {
108 if ($domain === null) {
109 $this->cookies = [];
110
111 return;
112 } elseif ($path === null) {
113 $this->cookies = \array_filter(
114 $this->cookies,
115 static function (SetCookie $cookie) use ($domain): bool {
116 return $cookie->getDomain() === null || !$cookie->matchesDomain($domain);
117 }
118 );
119 } elseif ($name === null) {
120 $this->cookies = \array_filter(
121 $this->cookies,
122 static function (SetCookie $cookie) use ($path, $domain): bool {
123 return !($cookie->getDomain() !== null
124 && $cookie->matchesPath($path)
125 && $cookie->matchesDomain($domain));
126 }
127 );
128 } else {
129 $this->cookies = \array_filter(
130 $this->cookies,
131 static function (SetCookie $cookie) use ($path, $domain, $name) {
132 return !($cookie->getDomain() !== null
133 && $cookie->getName() === $name
134 && $cookie->matchesPath($path)
135 && $cookie->matchesDomain($domain));
136 }
137 );
138 }
139 }
140
141 public function clearSessionCookies(): void
142 {
143 $this->cookies = \array_filter(
144 $this->cookies,
145 static function (SetCookie $cookie): bool {
146 return !$cookie->getDiscard() && $cookie->getExpires();
147 }
148 );
149 }
150
151 public function setCookie(SetCookie $cookie): bool
152 {
153 // If the name string is empty (but not 0), ignore the set-cookie
154 // string entirely.
155 $name = $cookie->getName();
156 if (!$name && $name !== '0') {
157 return false;
158 }
159
160 // Only allow cookies with set and valid domain, name, value
161 $result = $cookie->validate();
162 if ($result !== true) {
163 if ($this->strictMode) {
164 throw new \RuntimeException('Invalid cookie: '.$result);
165 }
166 $this->removeCookieIfEmpty($cookie);
167
168 return false;
169 }
170
171 $maxAge = $cookie->getMaxAge();
172 if ($maxAge !== null && $maxAge <= 0) {
173 if ($cookie->getDomain() !== null) {
174 $this->clear($cookie->getDomain(), $cookie->getPath(), $cookie->getName());
175 }
176
177 return false;
178 }
179
180 // Resolve conflicts with previously set cookies
181 foreach ($this->cookies as $i => $c) {
182 // Two cookies are identical, when their path, and domain are
183 // identical.
184 if ($c->getPath() !== $cookie->getPath()
185 || $c->getDomain() !== $cookie->getDomain()
186 || $c->getName() !== $cookie->getName()
187 ) {
188 continue;
189 }
190
191 // The previously set cookie is a discard cookie and this one is
192 // not so allow the new cookie to be set
193 if (!$cookie->getDiscard() && $c->getDiscard()) {
194 unset($this->cookies[$i]);
195 continue;
196 }
197
198 // If the new cookie's expiration is further into the future, then
199 // replace the old cookie
200 if ($cookie->getExpires() > $c->getExpires()) {
201 unset($this->cookies[$i]);
202 continue;
203 }
204
205 // If the value has changed, we better change it
206 if ($cookie->getValue() !== $c->getValue()) {
207 unset($this->cookies[$i]);
208 continue;
209 }
210
211 // The cookie exists, so no need to continue
212 return false;
213 }
214
215 $this->cookies[] = $cookie;
216
217 return true;
218 }
219
220 public function count(): int
221 {
222 return \count($this->cookies);
223 }
224
225 /**
226 * @return \ArrayIterator<int, SetCookie>
227 */
228 public function getIterator(): \ArrayIterator
229 {
230 return new \ArrayIterator(\array_values($this->cookies));
231 }
232
233 public function extractCookies(RequestInterface $request, ResponseInterface $response): void
234 {
235 if ($cookieHeader = $response->getHeader('Set-Cookie')) {
236 foreach ($cookieHeader as $cookie) {
237 $sc = SetCookie::fromString($cookie);
238 $domain = $sc->getDomain();
239 if ($domain === null || $domain === '') {
240 $sc->setDomain($request->getUri()->getHost());
241 } elseif (\substr($domain, -1) === '.' && '' !== \trim($domain, '.')) {
242 // Keep pure-dot domains rejected by the dot-only fix.
243 $sc->setDomain($request->getUri()->getHost());
244 }
245 if (0 !== \strpos($sc->getPath(), '/')) {
246 $sc->setPath($this->getCookiePathFromRequest($request));
247 }
248 if (!$sc->matchesDomain($request->getUri()->getHost())) {
249 continue;
250 }
251 // Note: At this point `$sc->getDomain()` being a public suffix should
252 // be rejected, but we don't want to pull in the full PSL dependency.
253 $this->setCookie($sc);
254 }
255 }
256 }
257
258 /**
259 * Computes cookie path following RFC 6265 section 5.1.4
260 *
261 * @see https://datatracker.ietf.org/doc/html/rfc6265#section-5.1.4
262 */
263 private function getCookiePathFromRequest(RequestInterface $request): string
264 {
265 $uriPath = $request->getUri()->getPath();
266 if ('' === $uriPath) {
267 return '/';
268 }
269 if (0 !== \strpos($uriPath, '/')) {
270 return '/';
271 }
272 if ('/' === $uriPath) {
273 return '/';
274 }
275 $lastSlashPos = \strrpos($uriPath, '/');
276 if (0 === $lastSlashPos || false === $lastSlashPos) {
277 return '/';
278 }
279
280 return \substr($uriPath, 0, $lastSlashPos);
281 }
282
283 public function withCookieHeader(RequestInterface $request): RequestInterface
284 {
285 $values = [];
286 $uri = $request->getUri();
287 $scheme = $uri->getScheme();
288 $host = $uri->getHost();
289 $path = $uri->getPath() ?: '/';
290
291 foreach ($this->cookies as $cookie) {
292 if ($cookie->getDomain() !== null
293 && $cookie->matchesPath($path)
294 && $cookie->matchesDomain($host)
295 && !$cookie->isExpired()
296 && (!$cookie->getSecure() || $scheme === 'https')
297 ) {
298 $values[] = $cookie->getName().'='
299 .$cookie->getValue();
300 }
301 }
302
303 return $values
304 ? $request->withHeader('Cookie', \implode('; ', $values))
305 : $request;
306 }
307
308 /**
309 * If a cookie already exists and the server asks to set it again with a
310 * null value, the cookie must be deleted.
311 */
312 private function removeCookieIfEmpty(SetCookie $cookie): void
313 {
314 $cookieValue = $cookie->getValue();
315 if (($cookieValue === null || $cookieValue === '') && $cookie->getDomain() !== null) {
316 $this->clear(
317 $cookie->getDomain(),
318 $cookie->getPath(),
319 $cookie->getName()
320 );
321 }
322 }
323 }