| <?php |
| /** |
| * Zend Framework |
| * |
| * LICENSE |
| * |
| * This source file is subject to version 1.0 of the Zend Framework |
| * license, that is bundled with this package in the file LICENSE.txt, |
| * and is available through the world-wide-web at the following URL: |
| * http://framework.zend.com/license/new-bsd. If you did not |
| * receive a copy of the Zend Framework license and are unable to |
| * obtain it through the world-wide-web, please send a note to |
| * license@zend.com so we can mail you a copy immediately. |
| * |
| * @category Zend |
| * @package Zend_Http |
| * @subpackage CookieJar |
| * @version $Id: CookieJar.php 8064 2008-02-16 10:58:39Z thomas $ |
| * @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com/) |
| * @license http://framework.zend.com/license/new-bsd New BSD License |
| */ |
| |
| require_once "Zend/Uri.php"; |
| require_once "Zend/Http/Cookie.php"; |
| require_once "Zend/Http/Response.php"; |
| |
| /** |
| * A Zend_Http_CookieJar object is designed to contain and maintain HTTP cookies, and should |
| * be used along with Zend_Http_Client in order to manage cookies across HTTP requests and |
| * responses. |
| * |
| * The class contains an array of Zend_Http_Cookie objects. Cookies can be added to the jar |
| * automatically from a request or manually. Then, the jar can find and return the cookies |
| * needed for a specific HTTP request. |
| * |
| * A special parameter can be passed to all methods of this class that return cookies: Cookies |
| * can be returned either in their native form (as Zend_Http_Cookie objects) or as strings - |
| * the later is suitable for sending as the value of the "Cookie" header in an HTTP request. |
| * You can also choose, when returning more than one cookie, whether to get an array of strings |
| * (by passing Zend_Http_CookieJar::COOKIE_STRING_ARRAY) or one unified string for all cookies |
| * (by passing Zend_Http_CookieJar::COOKIE_STRING_CONCAT). |
| * |
| * @link http://wp.netscape.com/newsref/std/cookie_spec.html for some specs. |
| * |
| * @category Zend |
| * @package Zend_Http |
| * @subpackage CookieJar |
| * @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com/) |
| * @license http://framework.zend.com/license/new-bsd New BSD License |
| */ |
| class Zend_Http_CookieJar { |
| /** |
| * Return cookie(s) as a Zend_Http_Cookie object |
| * |
| */ |
| const COOKIE_OBJECT = 0; |
| |
| /** |
| * Return cookie(s) as a string (suitable for sending in an HTTP request) |
| * |
| */ |
| const COOKIE_STRING_ARRAY = 1; |
| |
| /** |
| * Return all cookies as one long string (suitable for sending in an HTTP request) |
| * |
| */ |
| const COOKIE_STRING_CONCAT = 2; |
| |
| /** |
| * Array storing cookies |
| * |
| * Cookies are stored according to domain and path: |
| * $cookies |
| * + www.mydomain.com |
| * + / |
| * - cookie1 |
| * - cookie2 |
| * + /somepath |
| * - othercookie |
| * + www.otherdomain.net |
| * + / |
| * - alsocookie |
| * |
| * @var array |
| */ |
| protected $cookies = array(); |
| |
| /** |
| * Construct a new CookieJar object |
| * |
| */ |
| public function __construct() {} |
| |
| /** |
| * Add a cookie to the jar. Cookie should be passed either as a Zend_Http_Cookie object |
| * or as a string - in which case an object is created from the string. |
| * |
| * @param Zend_Http_Cookie|string $cookie |
| * @param Zend_Uri_Http|string $ref_uri Optional reference URI (for domain, path, secure) |
| */ |
| public function addCookie($cookie, $ref_uri = null) { |
| if (is_string($cookie)) { |
| $cookie = Zend_Http_Cookie::fromString($cookie, $ref_uri); |
| } |
| |
| if ($cookie instanceof Zend_Http_Cookie) { |
| $domain = $cookie->getDomain(); |
| $path = $cookie->getPath(); |
| if (! isset($this->cookies[$domain])) $this->cookies[$domain] = array(); |
| if (! isset($this->cookies[$domain][$path])) $this->cookies[$domain][$path] = array(); |
| $this->cookies[$domain][$path][$cookie->getName()] = $cookie; |
| } else { |
| require_once 'external/Zend/Http/Exception.php'; |
| throw new Zend_Http_Exception('Supplient argument is not a valid cookie string or object'); |
| } |
| } |
| |
| /** |
| * Parse an HTTP response, adding all the cookies set in that response |
| * to the cookie jar. |
| * |
| * @param Zend_Http_Response $response |
| * @param Zend_Uri_Http|string $ref_uri Requested URI |
| */ |
| public function addCookiesFromResponse($response, $ref_uri) { |
| if (! $response instanceof Zend_Http_Response) { |
| require_once 'external/Zend/Http/Exception.php'; |
| throw new Zend_Http_Exception('$response is expected to be a Response object, ' . gettype($response) . ' was passed'); |
| } |
| |
| $cookie_hdrs = $response->getHeader('Set-Cookie'); |
| |
| if (is_array($cookie_hdrs)) { |
| foreach ($cookie_hdrs as $cookie) { |
| $this->addCookie($cookie, $ref_uri); |
| } |
| } elseif (is_string($cookie_hdrs)) { |
| $this->addCookie($cookie_hdrs, $ref_uri); |
| } |
| } |
| |
| /** |
| * Get all cookies in the cookie jar as an array |
| * |
| * @param int $ret_as Whether to return cookies as objects of Zend_Http_Cookie or as strings |
| * @return array|string |
| */ |
| public function getAllCookies($ret_as = self::COOKIE_OBJECT) { |
| $cookies = $this->_flattenCookiesArray($this->cookies, $ret_as); |
| return $cookies; |
| } |
| |
| /** |
| * Return an array of all cookies matching a specific request according to the request URI, |
| * whether session cookies should be sent or not, and the time to consider as "now" when |
| * checking cookie expiry time. |
| * |
| * @param string|Zend_Uri_Http $uri URI to check against (secure, domain, path) |
| * @param boolean $matchSessionCookies Whether to send session cookies |
| * @param int $ret_as Whether to return cookies as objects of Zend_Http_Cookie or as strings |
| * @param int $now Override the current time when checking for expiry time |
| * @return array|string |
| */ |
| public function getMatchingCookies($uri, $matchSessionCookies = true, $ret_as = self::COOKIE_OBJECT, $now = null) { |
| if (is_string($uri)) $uri = Zend_Uri::factory($uri); |
| if (! $uri instanceof Zend_Uri_Http) { |
| require_once 'external/Zend/Http/Exception.php'; |
| throw new Zend_Http_Exception("Invalid URI string or object passed"); |
| } |
| |
| // Set path |
| $path = $uri->getPath(); |
| $path = substr($path, 0, strrpos($path, '/')); |
| if (! $path) $path = '/'; |
| |
| // First, reduce the array of cookies to only those matching domain and path |
| $cookies = $this->_matchDomain($uri->getHost()); |
| $cookies = $this->_matchPath($cookies, $path); |
| $cookies = $this->_flattenCookiesArray($cookies, self::COOKIE_OBJECT); |
| |
| // Next, run Cookie->match on all cookies to check secure, time and session mathcing |
| $ret = array(); |
| foreach ($cookies as $cookie) |
| if ($cookie->match($uri, $matchSessionCookies, $now)) $ret[] = $cookie; |
| |
| // Now, use self::_flattenCookiesArray again - only to convert to the return format ;) |
| $ret = $this->_flattenCookiesArray($ret, $ret_as); |
| |
| return $ret; |
| } |
| |
| /** |
| * Get a specific cookie according to a URI and name |
| * |
| * @param Zend_Uri_Http|string $uri The uri (domain and path) to match |
| * @param string $cookie_name The cookie's name |
| * @param int $ret_as Whether to return cookies as objects of Zend_Http_Cookie or as strings |
| * @return Zend_Http_Cookie|string |
| */ |
| public function getCookie($uri, $cookie_name, $ret_as = self::COOKIE_OBJECT) { |
| if (is_string($uri)) { |
| $uri = Zend_Uri::factory($uri); |
| } |
| |
| if (! $uri instanceof Zend_Uri_Http) { |
| require_once 'external/Zend/Http/Exception.php'; |
| throw new Zend_Http_Exception('Invalid URI specified'); |
| } |
| |
| // Get correct cookie path |
| $path = $uri->getPath(); |
| $path = substr($path, 0, strrpos($path, '/')); |
| if (! $path) $path = '/'; |
| |
| if (isset($this->cookies[$uri->getHost()][$path][$cookie_name])) { |
| $cookie = $this->cookies[$uri->getHost()][$path][$cookie_name]; |
| |
| switch ($ret_as) { |
| case self::COOKIE_OBJECT: |
| return $cookie; |
| break; |
| |
| case self::COOKIE_STRING_ARRAY: |
| case self::COOKIE_STRING_CONCAT: |
| return $cookie->__toString(); |
| break; |
| |
| default: |
| require_once 'external/Zend/Http/Exception.php'; |
| throw new Zend_Http_Exception("Invalid value passed for \$ret_as: {$ret_as}"); |
| break; |
| } |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * Helper function to recursivly flatten an array. Shoud be used when exporting the |
| * cookies array (or parts of it) |
| * |
| * @param Zend_Http_Cookie|array $ptr |
| * @param int $ret_as What value to return |
| * @return array|string |
| */ |
| protected function _flattenCookiesArray($ptr, $ret_as = self::COOKIE_OBJECT) { |
| if (is_array($ptr)) { |
| $ret = ($ret_as == self::COOKIE_STRING_CONCAT ? '' : array()); |
| foreach ($ptr as $item) { |
| if ($ret_as == self::COOKIE_STRING_CONCAT) { |
| $ret .= $this->_flattenCookiesArray($item, $ret_as); |
| } else { |
| $ret = array_merge($ret, $this->_flattenCookiesArray($item, $ret_as)); |
| } |
| } |
| return $ret; |
| } elseif ($ptr instanceof Zend_Http_Cookie) { |
| switch ($ret_as) { |
| case self::COOKIE_STRING_ARRAY: |
| return array($ptr->__toString()); |
| break; |
| |
| case self::COOKIE_STRING_CONCAT: |
| return $ptr->__toString(); |
| break; |
| |
| case self::COOKIE_OBJECT: |
| default: |
| return array($ptr); |
| break; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Return a subset of the cookies array matching a specific domain |
| * |
| * Returned array is actually an array of pointers to items in the $this->cookies array. |
| * |
| * @param string $domain |
| * @return array |
| */ |
| protected function _matchDomain($domain) { |
| $ret = array(); |
| |
| foreach (array_keys($this->cookies) as $cdom) { |
| $regex = "/" . preg_quote($cdom, "/") . "$/i"; |
| if (preg_match($regex, $domain)) $ret[$cdom] = &$this->cookies[$cdom]; |
| } |
| |
| return $ret; |
| } |
| |
| /** |
| * Return a subset of a domain-matching cookies that also match a specified path |
| * |
| * Returned array is actually an array of pointers to items in the $passed array. |
| * |
| * @param array $dom_array |
| * @param string $path |
| * @return array |
| */ |
| protected function _matchPath($domains, $path) { |
| $ret = array(); |
| if (substr($path, - 1) != '/') $path .= '/'; |
| |
| foreach ($domains as $dom => $paths_array) { |
| foreach (array_keys($paths_array) as $cpath) { |
| $regex = "|^" . preg_quote($cpath, "|") . "|i"; |
| if (preg_match($regex, $path)) { |
| if (! isset($ret[$dom])) $ret[$dom] = array(); |
| $ret[$dom][$cpath] = &$paths_array[$cpath]; |
| } |
| } |
| } |
| |
| return $ret; |
| } |
| |
| /** |
| * Create a new CookieJar object and automatically load into it all the |
| * cookies set in an Http_Response object. If $uri is set, it will be |
| * considered as the requested URI for setting default domain and path |
| * of the cookie. |
| * |
| * @param Zend_Http_Response $response HTTP Response object |
| * @param Zend_Uri_Http|string $uri The requested URI |
| * @return Zend_Http_CookieJar |
| * @todo Add the $uri functionality. |
| */ |
| public static function fromResponse(Zend_Http_Response $response, $ref_uri) { |
| $jar = new self(); |
| $jar->addCookiesFromResponse($response, $ref_uri); |
| return $jar; |
| } |
| } |
