[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * Cookie holder object
   4   *
   5   * @package Requests\Cookies
   6   */
   7  
   8  namespace WpOrg\Requests\Cookie;
   9  
  10  use ArrayAccess;
  11  use ArrayIterator;
  12  use IteratorAggregate;
  13  use ReturnTypeWillChange;
  14  use WpOrg\Requests\Cookie;
  15  use WpOrg\Requests\Exception;
  16  use WpOrg\Requests\Exception\InvalidArgument;
  17  use WpOrg\Requests\HookManager;
  18  use WpOrg\Requests\Iri;
  19  use WpOrg\Requests\Response;
  20  
  21  /**
  22   * Cookie holder object
  23   *
  24   * @package Requests\Cookies
  25   */
  26  class Jar implements ArrayAccess, IteratorAggregate {
  27      /**
  28       * Actual item data
  29       *
  30       * @var array
  31       */
  32      protected $cookies = [];
  33  
  34      /**
  35       * Create a new jar
  36       *
  37       * @param array $cookies Existing cookie values
  38       *
  39       * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed argument is not an array.
  40       */
  41  	public function __construct($cookies = []) {
  42          if (is_array($cookies) === false) {
  43              throw InvalidArgument::create(1, '$cookies', 'array', gettype($cookies));
  44          }
  45  
  46          $this->cookies = $cookies;
  47      }
  48  
  49      /**
  50       * Normalise cookie data into a \WpOrg\Requests\Cookie
  51       *
  52       * @param string|\WpOrg\Requests\Cookie $cookie Cookie header value, possibly pre-parsed (object).
  53       * @param string                        $key    Optional. The name for this cookie.
  54       * @return \WpOrg\Requests\Cookie
  55       */
  56  	public function normalize_cookie($cookie, $key = '') {
  57          if ($cookie instanceof Cookie) {
  58              return $cookie;
  59          }
  60  
  61          return Cookie::parse($cookie, $key);
  62      }
  63  
  64      /**
  65       * Check if the given item exists
  66       *
  67       * @param string $offset Item key
  68       * @return boolean Does the item exist?
  69       */
  70      #[ReturnTypeWillChange]
  71  	public function offsetExists($offset) {
  72          return isset($this->cookies[$offset]);
  73      }
  74  
  75      /**
  76       * Get the value for the item
  77       *
  78       * @param string $offset Item key
  79       * @return string|null Item value (null if offsetExists is false)
  80       */
  81      #[ReturnTypeWillChange]
  82  	public function offsetGet($offset) {
  83          if (!isset($this->cookies[$offset])) {
  84              return null;
  85          }
  86  
  87          return $this->cookies[$offset];
  88      }
  89  
  90      /**
  91       * Set the given item
  92       *
  93       * @param string $offset Item name
  94       * @param string $value Item value
  95       *
  96       * @throws \WpOrg\Requests\Exception On attempting to use dictionary as list (`invalidset`)
  97       */
  98      #[ReturnTypeWillChange]
  99  	public function offsetSet($offset, $value) {
 100          if ($offset === null) {
 101              throw new Exception('Object is a dictionary, not a list', 'invalidset');
 102          }
 103  
 104          $this->cookies[$offset] = $value;
 105      }
 106  
 107      /**
 108       * Unset the given header
 109       *
 110       * @param string $offset The key for the item to unset.
 111       */
 112      #[ReturnTypeWillChange]
 113  	public function offsetUnset($offset) {
 114          unset($this->cookies[$offset]);
 115      }
 116  
 117      /**
 118       * Get an iterator for the data
 119       *
 120       * @return \ArrayIterator
 121       */
 122      #[ReturnTypeWillChange]
 123  	public function getIterator() {
 124          return new ArrayIterator($this->cookies);
 125      }
 126  
 127      /**
 128       * Register the cookie handler with the request's hooking system
 129       *
 130       * @param \WpOrg\Requests\HookManager $hooks Hooking system
 131       */
 132  	public function register(HookManager $hooks) {
 133          $hooks->register('requests.before_request', [$this, 'before_request']);
 134          $hooks->register('requests.before_redirect_check', [$this, 'before_redirect_check']);
 135      }
 136  
 137      /**
 138       * Add Cookie header to a request if we have any
 139       *
 140       * As per RFC 6265, cookies are separated by '; '
 141       *
 142       * @param string $url
 143       * @param array $headers
 144       * @param array $data
 145       * @param string $type
 146       * @param array $options
 147       */
 148  	public function before_request($url, &$headers, &$data, &$type, &$options) {
 149          if (!$url instanceof Iri) {
 150              $url = new Iri($url);
 151          }
 152  
 153          if (!empty($this->cookies)) {
 154              $cookies = [];
 155              foreach ($this->cookies as $key => $cookie) {
 156                  $cookie = $this->normalize_cookie($cookie, $key);
 157  
 158                  // Skip expired cookies
 159                  if ($cookie->is_expired()) {
 160                      continue;
 161                  }
 162  
 163                  if ($cookie->domain_matches($url->host)) {
 164                      $cookies[] = $cookie->format_for_header();
 165                  }
 166              }
 167  
 168              $headers['Cookie'] = implode('; ', $cookies);
 169          }
 170      }
 171  
 172      /**
 173       * Parse all cookies from a response and attach them to the response
 174       *
 175       * @param \WpOrg\Requests\Response $response Response as received.
 176       */
 177  	public function before_redirect_check(Response $response) {
 178          $url = $response->url;
 179          if (!$url instanceof Iri) {
 180              $url = new Iri($url);
 181          }
 182  
 183          $cookies           = Cookie::parse_from_headers($response->headers, $url);
 184          $this->cookies     = array_merge($this->cookies, $cookies);
 185          $response->cookies = $this;
 186      }
 187  }