wp-includes/SimplePie/gzdecode.php

   1 <?php
   2 /**
   3  * SimplePie
   4  *
   5  * A PHP-Based RSS and Atom Feed Framework.
   6  * Takes the hard work out of managing a complete RSS/Atom solution.
   7  *
   8  * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without modification, are
  12  * permitted provided that the following conditions are met:
  13  *
  14  *      * Redistributions of source code must retain the above copyright notice, this list of
  15  *        conditions and the following disclaimer.
  16  *
  17  *      * Redistributions in binary form must reproduce the above copyright notice, this list
  18  *        of conditions and the following disclaimer in the documentation and/or other materials
  19  *        provided with the distribution.
  20  *
  21  *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
  22  *        to endorse or promote products derived from this software without specific prior
  23  *        written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
  26  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  27  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
  28  * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  30  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  31  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  32  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33  * POSSIBILITY OF SUCH DAMAGE.
  34  *
  35  * @package SimplePie
  36  * @version 1.3.1
  37  * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
  38  * @author Ryan Parman
  39  * @author Geoffrey Sneddon
  40  * @author Ryan McCue
  41  * @link http://simplepie.org/ SimplePie
  42  * @license http://www.opensource.org/licenses/bsd-license.php BSD License
  43  */
  44
  45
  46 /**
  47  * Decode 'gzip' encoded HTTP data
  48  *
  49  * @package SimplePie
  50  * @subpackage HTTP
  51  * @link http://www.gzip.org/format.txt
  52  */
  53 class SimplePie_gzdecode
  54 {
  55         /**
  56          * Compressed data
  57          *
  58          * @access private
  59          * @var string
  60          * @see gzdecode::$data
  61          */
  62         var $compressed_data;
  63
  64         /**
  65          * Size of compressed data
  66          *
  67          * @access private
  68          * @var int
  69          */
  70         var $compressed_size;
  71
  72         /**
  73          * Minimum size of a valid gzip string
  74          *
  75          * @access private
  76          * @var int
  77          */
  78         var $min_compressed_size = 18;
  79
  80         /**
  81          * Current position of pointer
  82          *
  83          * @access private
  84          * @var int
  85          */
  86         var $position = 0;
  87
  88         /**
  89          * Flags (FLG)
  90          *
  91          * @access private
  92          * @var int
  93          */
  94         var $flags;
  95
  96         /**
  97          * Uncompressed data
  98          *
  99          * @access public
 100          * @see gzdecode::$compressed_data
 101          * @var string
 102          */
 103         var $data;
 104
 105         /**
 106          * Modified time
 107          *
 108          * @access public
 109          * @var int
 110          */
 111         var $MTIME;
 112
 113         /**
 114          * Extra Flags
 115          *
 116          * @access public
 117          * @var int
 118          */
 119         var $XFL;
 120
 121         /**
 122          * Operating System
 123          *
 124          * @access public
 125          * @var int
 126          */
 127         var $OS;
 128
 129         /**
 130          * Subfield ID 1
 131          *
 132          * @access public
 133          * @see gzdecode::$extra_field
 134          * @see gzdecode::$SI2
 135          * @var string
 136          */
 137         var $SI1;
 138
 139         /**
 140          * Subfield ID 2
 141          *
 142          * @access public
 143          * @see gzdecode::$extra_field
 144          * @see gzdecode::$SI1
 145          * @var string
 146          */
 147         var $SI2;
 148
 149         /**
 150          * Extra field content
 151          *
 152          * @access public
 153          * @see gzdecode::$SI1
 154          * @see gzdecode::$SI2
 155          * @var string
 156          */
 157         var $extra_field;
 158
 159         /**
 160          * Original filename
 161          *
 162          * @access public
 163          * @var string
 164          */
 165         var $filename;
 166
 167         /**
 168          * Human readable comment
 169          *
 170          * @access public
 171          * @var string
 172          */
 173         var $comment;
 174
 175         /**
 176          * Don't allow anything to be set
 177          *
 178          * @param string $name
 179          * @param mixed $value
 180          */
 181         public function __set($name, $value)
 182         {
 183                 trigger_error("Cannot write property $name", E_USER_ERROR);
 184         }
 185
 186         /**
 187          * Set the compressed string and related properties
 188          *
 189          * @param string $data
 190          */
 191         public function __construct($data)
 192         {
 193                 $this->compressed_data = $data;
 194                 $this->compressed_size = strlen($data);
 195         }
 196
 197         /**
 198          * Decode the GZIP stream
 199          *
 200          * @return bool Successfulness
 201          */
 202         public function parse()
 203         {
 204                 if ($this->compressed_size >= $this->min_compressed_size)
 205                 {
 206                         // Check ID1, ID2, and CM
 207                         if (substr($this->compressed_data, 0, 3) !== "\x1F\x8B\x08")
 208                         {
 209                                 return false;
 210                         }
 211
 212                         // Get the FLG (FLaGs)
 213                         $this->flags = ord($this->compressed_data[3]);
 214
 215                         // FLG bits above (1 << 4) are reserved
 216                         if ($this->flags > 0x1F)
 217                         {
 218                                 return false;
 219                         }
 220
 221                         // Advance the pointer after the above
 222                         $this->position += 4;
 223
 224                         // MTIME
 225                         $mtime = substr($this->compressed_data, $this->position, 4);
 226                         // Reverse the string if we're on a big-endian arch because l is the only signed long and is machine endianness
 227                         if (current(unpack('S', "\x00\x01")) === 1)
 228                         {
 229                                 $mtime = strrev($mtime);
 230                         }
 231                         $this->MTIME = current(unpack('l', $mtime));
 232                         $this->position += 4;
 233
 234                         // Get the XFL (eXtra FLags)
 235                         $this->XFL = ord($this->compressed_data[$this->position++]);
 236
 237                         // Get the OS (Operating System)
 238                         $this->OS = ord($this->compressed_data[$this->position++]);
 239
 240                         // Parse the FEXTRA
 241                         if ($this->flags & 4)
 242                         {
 243                                 // Read subfield IDs
 244                                 $this->SI1 = $this->compressed_data[$this->position++];
 245                                 $this->SI2 = $this->compressed_data[$this->position++];
 246
 247                                 // SI2 set to zero is reserved for future use
 248                                 if ($this->SI2 === "\x00")
 249                                 {
 250                                         return false;
 251                                 }
 252
 253                                 // Get the length of the extra field
 254                                 $len = current(unpack('v', substr($this->compressed_data, $this->position, 2)));
 255                                 $this->position += 2;
 256
 257                                 // Check the length of the string is still valid
 258                                 $this->min_compressed_size += $len + 4;
 259                                 if ($this->compressed_size >= $this->min_compressed_size)
 260                                 {
 261                                         // Set the extra field to the given data
 262                                         $this->extra_field = substr($this->compressed_data, $this->position, $len);
 263                                         $this->position += $len;
 264                                 }
 265                                 else
 266                                 {
 267                                         return false;
 268                                 }
 269                         }
 270
 271                         // Parse the FNAME
 272                         if ($this->flags & 8)
 273                         {
 274                                 // Get the length of the filename
 275                                 $len = strcspn($this->compressed_data, "\x00", $this->position);
 276
 277                                 // Check the length of the string is still valid
 278                                 $this->min_compressed_size += $len + 1;
 279                                 if ($this->compressed_size >= $this->min_compressed_size)
 280                                 {
 281                                         // Set the original filename to the given string
 282                                         $this->filename = substr($this->compressed_data, $this->position, $len);
 283                                         $this->position += $len + 1;
 284                                 }
 285                                 else
 286                                 {
 287                                         return false;
 288                                 }
 289                         }
 290
 291                         // Parse the FCOMMENT
 292                         if ($this->flags & 16)
 293                         {
 294                                 // Get the length of the comment
 295                                 $len = strcspn($this->compressed_data, "\x00", $this->position);
 296
 297                                 // Check the length of the string is still valid
 298                                 $this->min_compressed_size += $len + 1;
 299                                 if ($this->compressed_size >= $this->min_compressed_size)
 300                                 {
 301                                         // Set the original comment to the given string
 302                                         $this->comment = substr($this->compressed_data, $this->position, $len);
 303                                         $this->position += $len + 1;
 304                                 }
 305                                 else
 306                                 {
 307                                         return false;
 308                                 }
 309                         }
 310
 311                         // Parse the FHCRC
 312                         if ($this->flags & 2)
 313                         {
 314                                 // Check the length of the string is still valid
 315                                 $this->min_compressed_size += $len + 2;
 316                                 if ($this->compressed_size >= $this->min_compressed_size)
 317                                 {
 318                                         // Read the CRC
 319                                         $crc = current(unpack('v', substr($this->compressed_data, $this->position, 2)));
 320
 321                                         // Check the CRC matches
 322                                         if ((crc32(substr($this->compressed_data, 0, $this->position)) & 0xFFFF) === $crc)
 323                                         {
 324                                                 $this->position += 2;
 325                                         }
 326                                         else
 327                                         {
 328                                                 return false;
 329                                         }
 330                                 }
 331                                 else
 332                                 {
 333                                         return false;
 334                                 }
 335                         }
 336
 337                         // Decompress the actual data
 338                         if (($this->data = gzinflate(substr($this->compressed_data, $this->position, -8))) === false)
 339                         {
 340                                 return false;
 341                         }
 342                         else
 343                         {
 344                                 $this->position = $this->compressed_size - 8;
 345                         }
 346
 347                         // Check CRC of data
 348                         $crc = current(unpack('V', substr($this->compressed_data, $this->position, 4)));
 349                         $this->position += 4;
 350                         /*if (extension_loaded('hash') && sprintf('%u', current(unpack('V', hash('crc32b', $this->data)))) !== sprintf('%u', $crc))
 351                         {
 352                                 return false;
 353                         }*/
 354
 355                         // Check ISIZE of data
 356                         $isize = current(unpack('V', substr($this->compressed_data, $this->position, 4)));
 357                         $this->position += 4;
 358                         if (sprintf('%u', strlen($this->data) & 0xFFFFFFFF) !== sprintf('%u', $isize))
 359                         {
 360                                 return false;
 361                         }
 362
 363                         // Wow, against all odds, we've actually got a valid gzip string
 364                         return true;
 365                 }
 366                 else
 367                 {
 368                         return false;
 369                 }
 370         }
 371 }