diff options
Diffstat (limited to 'vendor/guzzle/guzzle/src/Guzzle/Plugin/Cookie/CookieJar')
3 files changed, 387 insertions, 0 deletions
diff --git a/vendor/guzzle/guzzle/src/Guzzle/Plugin/Cookie/CookieJar/ArrayCookieJar.php b/vendor/guzzle/guzzle/src/Guzzle/Plugin/Cookie/CookieJar/ArrayCookieJar.php new file mode 100644 index 0000000..6b67503 --- /dev/null +++ b/vendor/guzzle/guzzle/src/Guzzle/Plugin/Cookie/CookieJar/ArrayCookieJar.php @@ -0,0 +1,237 @@ +<?php + +namespace Guzzle\Plugin\Cookie\CookieJar; + +use Guzzle\Plugin\Cookie\Cookie; +use Guzzle\Http\Message\RequestInterface; +use Guzzle\Http\Message\Response; +use Guzzle\Parser\ParserRegistry; +use Guzzle\Plugin\Cookie\Exception\InvalidCookieException; + +/** + * Cookie cookieJar that stores cookies an an array + */ +class ArrayCookieJar implements CookieJarInterface, \Serializable +{ + /** @var array Loaded cookie data */ + protected $cookies = array(); + + /** @var bool Whether or not strict mode is enabled. When enabled, exceptions will be thrown for invalid cookies */ + protected $strictMode; + + /** + * @param bool $strictMode Set to true to throw exceptions when invalid cookies are added to the cookie jar + */ + public function __construct($strictMode = false) + { + $this->strictMode = $strictMode; + } + + /** + * Enable or disable strict mode on the cookie jar + * + * @param bool $strictMode Set to true to throw exceptions when invalid cookies are added. False to ignore them. + * + * @return self + */ + public function setStrictMode($strictMode) + { + $this->strictMode = $strictMode; + } + + public function remove($domain = null, $path = null, $name = null) + { + $cookies = $this->all($domain, $path, $name, false, false); + $this->cookies = array_filter($this->cookies, function (Cookie $cookie) use ($cookies) { + return !in_array($cookie, $cookies, true); + }); + + return $this; + } + + public function removeTemporary() + { + $this->cookies = array_filter($this->cookies, function (Cookie $cookie) { + return !$cookie->getDiscard() && $cookie->getExpires(); + }); + + return $this; + } + + public function removeExpired() + { + $currentTime = time(); + $this->cookies = array_filter($this->cookies, function (Cookie $cookie) use ($currentTime) { + return !$cookie->getExpires() || $currentTime < $cookie->getExpires(); + }); + + return $this; + } + + public function all($domain = null, $path = null, $name = null, $skipDiscardable = false, $skipExpired = true) + { + return array_values(array_filter($this->cookies, function (Cookie $cookie) use ( + $domain, + $path, + $name, + $skipDiscardable, + $skipExpired + ) { + return false === (($name && $cookie->getName() != $name) || + ($skipExpired && $cookie->isExpired()) || + ($skipDiscardable && ($cookie->getDiscard() || !$cookie->getExpires())) || + ($path && !$cookie->matchesPath($path)) || + ($domain && !$cookie->matchesDomain($domain))); + })); + } + + public function add(Cookie $cookie) + { + // Only allow cookies with set and valid domain, name, value + $result = $cookie->validate(); + if ($result !== true) { + if ($this->strictMode) { + throw new InvalidCookieException($result); + } else { + $this->removeCookieIfEmpty($cookie); + return false; + } + } + + // Resolve conflicts with previously set cookies + foreach ($this->cookies as $i => $c) { + + // Two cookies are identical, when their path, domain, port and name are identical + if ($c->getPath() != $cookie->getPath() || + $c->getDomain() != $cookie->getDomain() || + $c->getPorts() != $cookie->getPorts() || + $c->getName() != $cookie->getName() + ) { + continue; + } + + // The previously set cookie is a discard cookie and this one is not so allow the new cookie to be set + if (!$cookie->getDiscard() && $c->getDiscard()) { + unset($this->cookies[$i]); + continue; + } + + // If the new cookie's expiration is further into the future, then replace the old cookie + if ($cookie->getExpires() > $c->getExpires()) { + unset($this->cookies[$i]); + continue; + } + + // If the value has changed, we better change it + if ($cookie->getValue() !== $c->getValue()) { + unset($this->cookies[$i]); + continue; + } + + // The cookie exists, so no need to continue + return false; + } + + $this->cookies[] = $cookie; + + return true; + } + + /** + * Serializes the cookie cookieJar + * + * @return string + */ + public function serialize() + { + // Only serialize long term cookies and unexpired cookies + return json_encode(array_map(function (Cookie $cookie) { + return $cookie->toArray(); + }, $this->all(null, null, null, true, true))); + } + + /** + * Unserializes the cookie cookieJar + */ + public function unserialize($data) + { + $data = json_decode($data, true); + if (empty($data)) { + $this->cookies = array(); + } else { + $this->cookies = array_map(function (array $cookie) { + return new Cookie($cookie); + }, $data); + } + } + + /** + * Returns the total number of stored cookies + * + * @return int + */ + public function count() + { + return count($this->cookies); + } + + /** + * Returns an iterator + * + * @return \ArrayIterator + */ + public function getIterator() + { + return new \ArrayIterator($this->cookies); + } + + public function addCookiesFromResponse(Response $response, RequestInterface $request = null) + { + if ($cookieHeader = $response->getHeader('Set-Cookie')) { + $parser = ParserRegistry::getInstance()->getParser('cookie'); + foreach ($cookieHeader as $cookie) { + if ($parsed = $request + ? $parser->parseCookie($cookie, $request->getHost(), $request->getPath()) + : $parser->parseCookie($cookie) + ) { + // Break up cookie v2 into multiple cookies + foreach ($parsed['cookies'] as $key => $value) { + $row = $parsed; + $row['name'] = $key; + $row['value'] = $value; + unset($row['cookies']); + $this->add(new Cookie($row)); + } + } + } + } + } + + public function getMatchingCookies(RequestInterface $request) + { + // Find cookies that match this request + $cookies = $this->all($request->getHost(), $request->getPath()); + // Remove ineligible cookies + foreach ($cookies as $index => $cookie) { + if (!$cookie->matchesPort($request->getPort()) || ($cookie->getSecure() && $request->getScheme() != 'https')) { + unset($cookies[$index]); + } + }; + + return $cookies; + } + + /** + * If a cookie already exists and the server asks to set it again with a null value, the + * cookie must be deleted. + * + * @param \Guzzle\Plugin\Cookie\Cookie $cookie + */ + private function removeCookieIfEmpty(Cookie $cookie) + { + $cookieValue = $cookie->getValue(); + if ($cookieValue === null || $cookieValue === '') { + $this->remove($cookie->getDomain(), $cookie->getPath(), $cookie->getName()); + } + } +} diff --git a/vendor/guzzle/guzzle/src/Guzzle/Plugin/Cookie/CookieJar/CookieJarInterface.php b/vendor/guzzle/guzzle/src/Guzzle/Plugin/Cookie/CookieJar/CookieJarInterface.php new file mode 100644 index 0000000..7faa7d2 --- /dev/null +++ b/vendor/guzzle/guzzle/src/Guzzle/Plugin/Cookie/CookieJar/CookieJarInterface.php @@ -0,0 +1,85 @@ +<?php + +namespace Guzzle\Plugin\Cookie\CookieJar; + +use Guzzle\Plugin\Cookie\Cookie; +use Guzzle\Http\Message\RequestInterface; +use Guzzle\Http\Message\Response; + +/** + * Interface for persisting cookies + */ +interface CookieJarInterface extends \Countable, \IteratorAggregate +{ + /** + * Remove cookies currently held in the Cookie cookieJar. + * + * Invoking this method without arguments will empty the whole Cookie cookieJar. If given a $domain argument only + * cookies belonging to that domain will be removed. If given a $domain and $path argument, cookies belonging to + * the specified path within that domain are removed. If given all three arguments, then the cookie with the + * specified name, path and domain is removed. + * + * @param string $domain Set to clear only cookies matching a domain + * @param string $path Set to clear only cookies matching a domain and path + * @param string $name Set to clear only cookies matching a domain, path, and name + * + * @return CookieJarInterface + */ + public function remove($domain = null, $path = null, $name = null); + + /** + * Discard all temporary cookies. + * + * Scans for all cookies in the cookieJar with either no expire field or a true discard flag. To be called when the + * user agent shuts down according to RFC 2965. + * + * @return CookieJarInterface + */ + public function removeTemporary(); + + /** + * Delete any expired cookies + * + * @return CookieJarInterface + */ + public function removeExpired(); + + /** + * Add a cookie to the cookie cookieJar + * + * @param Cookie $cookie Cookie to add + * + * @return bool Returns true on success or false on failure + */ + public function add(Cookie $cookie); + + /** + * Add cookies from a {@see Guzzle\Http\Message\Response} object + * + * @param Response $response Response object + * @param RequestInterface $request Request that received the response + */ + public function addCookiesFromResponse(Response $response, RequestInterface $request = null); + + /** + * Get cookies matching a request object + * + * @param RequestInterface $request Request object to match + * + * @return array + */ + public function getMatchingCookies(RequestInterface $request); + + /** + * Get all of the matching cookies + * + * @param string $domain Domain of the cookie + * @param string $path Path of the cookie + * @param string $name Name of the cookie + * @param bool $skipDiscardable Set to TRUE to skip cookies with the Discard attribute. + * @param bool $skipExpired Set to FALSE to include expired + * + * @return array Returns an array of Cookie objects + */ + public function all($domain = null, $path = null, $name = null, $skipDiscardable = false, $skipExpired = true); +} diff --git a/vendor/guzzle/guzzle/src/Guzzle/Plugin/Cookie/CookieJar/FileCookieJar.php b/vendor/guzzle/guzzle/src/Guzzle/Plugin/Cookie/CookieJar/FileCookieJar.php new file mode 100644 index 0000000..99344cd --- /dev/null +++ b/vendor/guzzle/guzzle/src/Guzzle/Plugin/Cookie/CookieJar/FileCookieJar.php @@ -0,0 +1,65 @@ +<?php + +namespace Guzzle\Plugin\Cookie\CookieJar; + +use Guzzle\Common\Exception\RuntimeException; + +/** + * Persists non-session cookies using a JSON formatted file + */ +class FileCookieJar extends ArrayCookieJar +{ + /** @var string filename */ + protected $filename; + + /** + * Create a new FileCookieJar object + * + * @param string $cookieFile File to store the cookie data + * + * @throws RuntimeException if the file cannot be found or created + */ + public function __construct($cookieFile) + { + $this->filename = $cookieFile; + $this->load(); + } + + /** + * Saves the file when shutting down + */ + public function __destruct() + { + $this->persist(); + } + + /** + * Save the contents of the data array to the file + * + * @throws RuntimeException if the file cannot be found or created + */ + protected function persist() + { + if (false === file_put_contents($this->filename, $this->serialize())) { + // @codeCoverageIgnoreStart + throw new RuntimeException('Unable to open file ' . $this->filename); + // @codeCoverageIgnoreEnd + } + } + + /** + * Load the contents of the json formatted file into the data array and discard any unsaved state + */ + protected function load() + { + $json = file_get_contents($this->filename); + if (false === $json) { + // @codeCoverageIgnoreStart + throw new RuntimeException('Unable to open file ' . $this->filename); + // @codeCoverageIgnoreEnd + } + + $this->unserialize($json); + $this->cookies = $this->cookies ?: array(); + } +} |