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  * HTTP Response Parser
 48  *
 49  * @package SimplePie
 50  * @subpackage HTTP
 51  */
 52 class SimplePie_HTTP_Parser
 53 {
 54     /**
 55      * HTTP Version
 56      *
 57      * @var float
 58      */
 59     public $http_version = 0.0;
 60 
 61     /**
 62      * Status code
 63      *
 64      * @var int
 65      */
 66     public $status_code = 0;
 67 
 68     /**
 69      * Reason phrase
 70      *
 71      * @var string
 72      */
 73     public $reason = '';
 74 
 75     /**
 76      * Key/value pairs of the headers
 77      *
 78      * @var array
 79      */
 80     public $headers = array();
 81 
 82     /**
 83      * Body of the response
 84      *
 85      * @var string
 86      */
 87     public $body = '';
 88 
 89     /**
 90      * Current state of the state machine
 91      *
 92      * @var string
 93      */
 94     protected $state = 'http_version';
 95 
 96     /**
 97      * Input data
 98      *
 99      * @var string
100      */
101     protected $data = '';
102 
103     /**
104      * Input data length (to avoid calling strlen() everytime this is needed)
105      *
106      * @var int
107      */
108     protected $data_length = 0;
109 
110     /**
111      * Current position of the pointer
112      *
113      * @var int
114      */
115     protected $position = 0;
116 
117     /**
118      * Name of the hedaer currently being parsed
119      *
120      * @var string
121      */
122     protected $name = '';
123 
124     /**
125      * Value of the hedaer currently being parsed
126      *
127      * @var string
128      */
129     protected $value = '';
130 
131     /**
132      * Create an instance of the class with the input data
133      *
134      * @param string $data Input data
135      */
136     public function __construct($data)
137     {
138         $this->data = $data;
139         $this->data_length = strlen($this->data);
140     }
141 
142     /**
143      * Parse the input data
144      *
145      * @return bool true on success, false on failure
146      */
147     public function parse()
148     {
149         while ($this->state && $this->state !== 'emit' && $this->has_data())
150         {
151             $state = $this->state;
152             $this->$state();
153         }
154         $this->data = '';
155         if ($this->state === 'emit' || $this->state === 'body')
156         {
157             return true;
158         }
159         else
160         {
161             $this->http_version = '';
162             $this->status_code = '';
163             $this->reason = '';
164             $this->headers = array();
165             $this->body = '';
166             return false;
167         }
168     }
169 
170     /**
171      * Check whether there is data beyond the pointer
172      *
173      * @return bool true if there is further data, false if not
174      */
175     protected function has_data()
176     {
177         return (bool) ($this->position < $this->data_length);
178     }
179 
180     /**
181      * See if the next character is LWS
182      *
183      * @return bool true if the next character is LWS, false if not
184      */
185     protected function is_linear_whitespace()
186     {
187         return (bool) ($this->data[$this->position] === "\x09"
188             || $this->data[$this->position] === "\x20"
189             || ($this->data[$this->position] === "\x0A"
190                 && isset($this->data[$this->position + 1])
191                 && ($this->data[$this->position + 1] === "\x09" || $this->data[$this->position + 1] === "\x20")));
192     }
193 
194     /**
195      * Parse the HTTP version
196      */
197     protected function http_version()
198     {
199         if (strpos($this->data, "\x0A") !== false && strtoupper(substr($this->data, 0, 5)) === 'HTTP/')
200         {
201             $len = strspn($this->data, '0123456789.', 5);
202             $this->http_version = substr($this->data, 5, $len);
203             $this->position += 5 + $len;
204             if (substr_count($this->http_version, '.') <= 1)
205             {
206                 $this->http_version = (float) $this->http_version;
207                 $this->position += strspn($this->data, "\x09\x20", $this->position);
208                 $this->state = 'status';
209             }
210             else
211             {
212                 $this->state = false;
213             }
214         }
215         else
216         {
217             $this->state = false;
218         }
219     }
220 
221     /**
222      * Parse the status code
223      */
224     protected function status()
225     {
226         if ($len = strspn($this->data, '0123456789', $this->position))
227         {
228             $this->status_code = (int) substr($this->data, $this->position, $len);
229             $this->position += $len;
230             $this->state = 'reason';
231         }
232         else
233         {
234             $this->state = false;
235         }
236     }
237 
238     /**
239      * Parse the reason phrase
240      */
241     protected function reason()
242     {
243         $len = strcspn($this->data, "\x0A", $this->position);
244         $this->reason = trim(substr($this->data, $this->position, $len), "\x09\x0D\x20");
245         $this->position += $len + 1;
246         $this->state = 'new_line';
247     }
248 
249     /**
250      * Deal with a new line, shifting data around as needed
251      */
252     protected function new_line()
253     {
254         $this->value = trim($this->value, "\x0D\x20");
255         if ($this->name !== '' && $this->value !== '')
256         {
257             $this->name = strtolower($this->name);
258             // We should only use the last Content-Type header. c.f. issue #1
259             if (isset($this->headers[$this->name]) && $this->name !== 'content-type')
260             {
261                 $this->headers[$this->name] .= ', ' . $this->value;
262             }
263             else
264             {
265                 $this->headers[$this->name] = $this->value;
266             }
267         }
268         $this->name = '';
269         $this->value = '';
270         if (substr($this->data[$this->position], 0, 2) === "\x0D\x0A")
271         {
272             $this->position += 2;
273             $this->state = 'body';
274         }
275         elseif ($this->data[$this->position] === "\x0A")
276         {
277             $this->position++;
278             $this->state = 'body';
279         }
280         else
281         {
282             $this->state = 'name';
283         }
284     }
285 
286     /**
287      * Parse a header name
288      */
289     protected function name()
290     {
291         $len = strcspn($this->data, "\x0A:", $this->position);
292         if (isset($this->data[$this->position + $len]))
293         {
294             if ($this->data[$this->position + $len] === "\x0A")
295             {
296                 $this->position += $len;
297                 $this->state = 'new_line';
298             }
299             else
300             {
301                 $this->name = substr($this->data, $this->position, $len);
302                 $this->position += $len + 1;
303                 $this->state = 'value';
304             }
305         }
306         else
307         {
308             $this->state = false;
309         }
310     }
311 
312     /**
313      * Parse LWS, replacing consecutive LWS characters with a single space
314      */
315     protected function linear_whitespace()
316     {
317         do
318         {
319             if (substr($this->data, $this->position, 2) === "\x0D\x0A")
320             {
321                 $this->position += 2;
322             }
323             elseif ($this->data[$this->position] === "\x0A")
324             {
325                 $this->position++;
326             }
327             $this->position += strspn($this->data, "\x09\x20", $this->position);
328         } while ($this->has_data() && $this->is_linear_whitespace());
329         $this->value .= "\x20";
330     }
331 
332     /**
333      * See what state to move to while within non-quoted header values
334      */
335     protected function value()
336     {
337         if ($this->is_linear_whitespace())
338         {
339             $this->linear_whitespace();
340         }
341         else
342         {
343             switch ($this->data[$this->position])
344             {
345                 case '"':
346                     // Workaround for ETags: we have to include the quotes as
347                     // part of the tag.
348                     if (strtolower($this->name) === 'etag')
349                     {
350                         $this->value .= '"';
351                         $this->position++;
352                         $this->state = 'value_char';
353                         break;
354                     }
355                     $this->position++;
356                     $this->state = 'quote';
357                     break;
358 
359                 case "\x0A":
360                     $this->position++;
361                     $this->state = 'new_line';
362                     break;
363 
364                 default:
365                     $this->state = 'value_char';
366                     break;
367             }
368         }
369     }
370 
371     /**
372      * Parse a header value while outside quotes
373      */
374     protected function value_char()
375     {
376         $len = strcspn($this->data, "\x09\x20\x0A\"", $this->position);
377         $this->value .= substr($this->data, $this->position, $len);
378         $this->position += $len;
379         $this->state = 'value';
380     }
381 
382     /**
383      * See what state to move to while within quoted header values
384      */
385     protected function quote()
386     {
387         if ($this->is_linear_whitespace())
388         {
389             $this->linear_whitespace();
390         }
391         else
392         {
393             switch ($this->data[$this->position])
394             {
395                 case '"':
396                     $this->position++;
397                     $this->state = 'value';
398                     break;
399 
400                 case "\x0A":
401                     $this->position++;
402                     $this->state = 'new_line';
403                     break;
404 
405                 case '\\':
406                     $this->position++;
407                     $this->state = 'quote_escaped';
408                     break;
409 
410                 default:
411                     $this->state = 'quote_char';
412                     break;
413             }
414         }
415     }
416 
417     /**
418      * Parse a header value while within quotes
419      */
420     protected function quote_char()
421     {
422         $len = strcspn($this->data, "\x09\x20\x0A\"\\", $this->position);
423         $this->value .= substr($this->data, $this->position, $len);
424         $this->position += $len;
425         $this->state = 'value';
426     }
427 
428     /**
429      * Parse an escaped character within quotes
430      */
431     protected function quote_escaped()
432     {
433         $this->value .= $this->data[$this->position];
434         $this->position++;
435         $this->state = 'quote';
436     }
437 
438     /**
439      * Parse the body
440      */
441     protected function body()
442     {
443         $this->body = substr($this->data, $this->position);
444         if (!empty($this->headers['transfer-encoding']))
445         {
446             unset($this->headers['transfer-encoding']);
447             $this->state = 'chunked';
448         }
449         else
450         {
451             $this->state = 'emit';
452         }
453     }
454 
455     /**
456      * Parsed a "Transfer-Encoding: chunked" body
457      */
458     protected function chunked()
459     {
460         if (!preg_match('/^([0-9a-f]+)[^\r\n]*\r\n/i', trim($this->body)))
461         {
462             $this->state = 'emit';
463             return;
464         }
465 
466         $decoded = '';
467         $encoded = $this->body;
468 
469         while (true)
470         {
471             $is_chunked = (bool) preg_match( '/^([0-9a-f]+)[^\r\n]*\r\n/i', $encoded, $matches );
472             if (!$is_chunked)
473             {
474                 // Looks like it's not chunked after all
475                 $this->state = 'emit';
476                 return;
477             }
478 
479             $length = hexdec(trim($matches[1]));
480             if ($length === 0)
481             {
482                 // Ignore trailer headers
483                 $this->state = 'emit';
484                 $this->body = $decoded;
485                 return;
486             }
487 
488             $chunk_length = strlen($matches[0]);
489             $decoded .= $part = substr($encoded, $chunk_length, $length);
490             $encoded = substr($encoded, $chunk_length + $length + 2);
491 
492             if (trim($encoded) === '0' || empty($encoded))
493             {
494                 $this->state = 'emit';
495                 $this->body = $decoded;
496                 return;
497             }
498         }
499     }
500 }
501 

Joomla! Framework TM API documentation generated by ApiGen 2.8.0
Joomla!® and Joomla! Framework™ are trademarks of Open Source Matters, Inc. in the United States and other countries.