| /vendor/guzzlehttp/guzzle/src/Cookie/SetCookie.php |
|---|
| @@ -0,0 +1,410 @@ |
|---|
| <?php |
| |
| namespace GuzzleHttp\Cookie; |
| |
| use GuzzleHttp\ToArrayInterface; |
| |
| /** |
| * Set-Cookie object |
| */ |
| class SetCookie implements ToArrayInterface |
| { |
| /** @var array */ |
| private static $defaults = [ |
| 'Name' => null, |
| 'Value' => null, |
| 'Domain' => null, |
| 'Path' => '/', |
| 'Max-Age' => null, |
| 'Expires' => null, |
| 'Secure' => false, |
| 'Discard' => false, |
| 'HttpOnly' => false |
| ]; |
| |
| /** @var array Cookie data */ |
| private $data; |
| |
| /** |
| * Create a new SetCookie object from a string |
| * |
| * @param string $cookie Set-Cookie header string |
| * |
| * @return self |
| */ |
| public static function fromString($cookie) |
| { |
| // Create the default return array |
| $data = self::$defaults; |
| // Explode the cookie string using a series of semicolons |
| $pieces = array_filter(array_map('trim', explode(';', $cookie))); |
| // The name of the cookie (first kvp) must include an equal sign. |
| if (empty($pieces) || !strpos($pieces[0], '=')) { |
| return new self($data); |
| } |
| |
| // Add the cookie pieces into the parsed data array |
| foreach ($pieces as $part) { |
| |
| $cookieParts = explode('=', $part, 2); |
| $key = trim($cookieParts[0]); |
| $value = isset($cookieParts[1]) |
| ? trim($cookieParts[1], " \n\r\t\0\x0B\"") |
| : true; |
| |
| // Only check for non-cookies when cookies have been found |
| if (empty($data['Name'])) { |
| $data['Name'] = $key; |
| $data['Value'] = $value; |
| } else { |
| foreach (array_keys(self::$defaults) as $search) { |
| if (!strcasecmp($search, $key)) { |
| $data[$search] = $value; |
| continue 2; |
| } |
| } |
| $data[$key] = $value; |
| } |
| } |
| |
| return new self($data); |
| } |
| |
| /** |
| * @param array $data Array of cookie data provided by a Cookie parser |
| */ |
| public function __construct(array $data = []) |
| { |
| $this->data = array_replace(self::$defaults, $data); |
| // Extract the Expires value and turn it into a UNIX timestamp if needed |
| if (!$this->getExpires() && $this->getMaxAge()) { |
| // Calculate the Expires date |
| $this->setExpires(time() + $this->getMaxAge()); |
| } elseif ($this->getExpires() && !is_numeric($this->getExpires())) { |
| $this->setExpires($this->getExpires()); |
| } |
| } |
| |
| public function __toString() |
| { |
| $str = $this->data['Name'] . '=' . $this->data['Value'] . '; '; |
| foreach ($this->data as $k => $v) { |
| if ($k != 'Name' && $k != 'Value' && $v !== null && $v !== false) { |
| if ($k == 'Expires') { |
| $str .= 'Expires=' . gmdate('D, d M Y H:i:s \G\M\T', $v) . '; '; |
| } else { |
| $str .= ($v === true ? $k : "{$k}={$v}") . '; '; |
| } |
| } |
| } |
| |
| return rtrim($str, '; '); |
| } |
| |
| public function toArray() |
| { |
| return $this->data; |
| } |
| |
| /** |
| * Get the cookie name |
| * |
| * @return string |
| */ |
| public function getName() |
| { |
| return $this->data['Name']; |
| } |
| |
| /** |
| * Set the cookie name |
| * |
| * @param string $name Cookie name |
| * |
| * @return self |
| */ |
| public function setName($name) |
| { |
| $this->data['Name'] = $name; |
| |
| return $this; |
| } |
| |
| /** |
| * Get the cookie value |
| * |
| * @return string |
| */ |
| public function getValue() |
| { |
| return $this->data['Value']; |
| } |
| |
| /** |
| * Set the cookie value |
| * |
| * @param string $value Cookie value |
| * |
| * @return self |
| */ |
| public function setValue($value) |
| { |
| $this->data['Value'] = $value; |
| |
| return $this; |
| } |
| |
| /** |
| * Get the domain |
| * |
| * @return string|null |
| */ |
| public function getDomain() |
| { |
| return $this->data['Domain']; |
| } |
| |
| /** |
| * Set the domain of the cookie |
| * |
| * @param string $domain |
| * |
| * @return self |
| */ |
| public function setDomain($domain) |
| { |
| $this->data['Domain'] = $domain; |
| |
| return $this; |
| } |
| |
| /** |
| * Get the path |
| * |
| * @return string |
| */ |
| public function getPath() |
| { |
| return $this->data['Path']; |
| } |
| |
| /** |
| * Set the path of the cookie |
| * |
| * @param string $path Path of the cookie |
| * |
| * @return self |
| */ |
| public function setPath($path) |
| { |
| $this->data['Path'] = $path; |
| |
| return $this; |
| } |
| |
| /** |
| * Maximum lifetime of the cookie in seconds |
| * |
| * @return int|null |
| */ |
| public function getMaxAge() |
| { |
| return $this->data['Max-Age']; |
| } |
| |
| /** |
| * Set the max-age of the cookie |
| * |
| * @param int $maxAge Max age of the cookie in seconds |
| * |
| * @return self |
| */ |
| public function setMaxAge($maxAge) |
| { |
| $this->data['Max-Age'] = $maxAge; |
| |
| return $this; |
| } |
| |
| /** |
| * The UNIX timestamp when the cookie Expires |
| * |
| * @return mixed |
| */ |
| public function getExpires() |
| { |
| return $this->data['Expires']; |
| } |
| |
| /** |
| * Set the unix timestamp for which the cookie will expire |
| * |
| * @param int $timestamp Unix timestamp |
| * |
| * @return self |
| */ |
| public function setExpires($timestamp) |
| { |
| $this->data['Expires'] = is_numeric($timestamp) |
| ? (int) $timestamp |
| : strtotime($timestamp); |
| |
| return $this; |
| } |
| |
| /** |
| * Get whether or not this is a secure cookie |
| * |
| * @return null|bool |
| */ |
| public function getSecure() |
| { |
| return $this->data['Secure']; |
| } |
| |
| /** |
| * Set whether or not the cookie is secure |
| * |
| * @param bool $secure Set to true or false if secure |
| * |
| * @return self |
| */ |
| public function setSecure($secure) |
| { |
| $this->data['Secure'] = $secure; |
| |
| return $this; |
| } |
| |
| /** |
| * Get whether or not this is a session cookie |
| * |
| * @return null|bool |
| */ |
| public function getDiscard() |
| { |
| return $this->data['Discard']; |
| } |
| |
| /** |
| * Set whether or not this is a session cookie |
| * |
| * @param bool $discard Set to true or false if this is a session cookie |
| * |
| * @return self |
| */ |
| public function setDiscard($discard) |
| { |
| $this->data['Discard'] = $discard; |
| |
| return $this; |
| } |
| |
| /** |
| * Get whether or not this is an HTTP only cookie |
| * |
| * @return bool |
| */ |
| public function getHttpOnly() |
| { |
| return $this->data['HttpOnly']; |
| } |
| |
| /** |
| * Set whether or not this is an HTTP only cookie |
| * |
| * @param bool $httpOnly Set to true or false if this is HTTP only |
| * |
| * @return self |
| */ |
| public function setHttpOnly($httpOnly) |
| { |
| $this->data['HttpOnly'] = $httpOnly; |
| |
| return $this; |
| } |
| |
| /** |
| * Check if the cookie matches a path value |
| * |
| * @param string $path Path to check against |
| * |
| * @return bool |
| */ |
| public function matchesPath($path) |
| { |
| return !$this->getPath() || 0 === stripos($path, $this->getPath()); |
| } |
| |
| /** |
| * Check if the cookie matches a domain value |
| * |
| * @param string $domain Domain to check against |
| * |
| * @return bool |
| */ |
| public function matchesDomain($domain) |
| { |
| // Remove the leading '.' as per spec in RFC 6265. |
| // http://tools.ietf.org/html/rfc6265#section-5.2.3 |
| $cookieDomain = ltrim($this->getDomain(), '.'); |
| |
| // Domain not set or exact match. |
| if (!$cookieDomain || !strcasecmp($domain, $cookieDomain)) { |
| return true; |
| } |
| |
| // Matching the subdomain according to RFC 6265. |
| // http://tools.ietf.org/html/rfc6265#section-5.1.3 |
| if (filter_var($domain, FILTER_VALIDATE_IP)) { |
| return false; |
| } |
| |
| return (bool) preg_match('/\.' . preg_quote($cookieDomain) . '$/i', $domain); |
| } |
| |
| /** |
| * Check if the cookie is expired |
| * |
| * @return bool |
| */ |
| public function isExpired() |
| { |
| return $this->getExpires() && time() > $this->getExpires(); |
| } |
| |
| /** |
| * Check if the cookie is valid according to RFC 6265 |
| * |
| * @return bool|string Returns true if valid or an error message if invalid |
| */ |
| public function validate() |
| { |
| // Names must not be empty, but can be 0 |
| $name = $this->getName(); |
| if (empty($name) && !is_numeric($name)) { |
| return 'The cookie name must not be empty'; |
| } |
| |
| // Check if any of the invalid characters are present in the cookie name |
| if (preg_match("/[=,; \t\r\n\013\014]/", $name)) { |
| return "Cookie name must not cannot invalid characters: =,; \\t\\r\\n\\013\\014"; |
| } |
| |
| // Value must not be empty, but can be 0 |
| $value = $this->getValue(); |
| if (empty($value) && !is_numeric($value)) { |
| return 'The cookie value must not be empty'; |
| } |
| |
| // Domains must not be empty, but can be 0 |
| // A "0" is not a valid internet domain, but may be used as server name |
| // in a private network. |
| $domain = $this->getDomain(); |
| if (empty($domain) && !is_numeric($domain)) { |
| return 'The cookie domain must not be empty'; |
| } |
| |
| return true; |
| } |
| } |
