3 * Class for performing HTTP requests
\r
5 * PHP versions 4 and 5
\r
9 * Copyright (c) 2002-2007, Richard Heyes
\r
10 * All rights reserved.
\r
12 * Redistribution and use in source and binary forms, with or without
\r
13 * modification, are permitted provided that the following conditions
\r
16 * o Redistributions of source code must retain the above copyright
\r
17 * notice, this list of conditions and the following disclaimer.
\r
18 * o Redistributions in binary form must reproduce the above copyright
\r
19 * notice, this list of conditions and the following disclaimer in the
\r
20 * documentation and/or other materials provided with the distribution.
\r
21 * o The names of the authors may not be used to endorse or promote
\r
22 * products derived from this software without specific prior written
\r
25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
\r
26 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
\r
27 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
\r
28 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
\r
29 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
\r
30 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
\r
31 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
\r
32 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
\r
33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
\r
34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
\r
35 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\r
38 * @package HTTP_Request
\r
39 * @author Richard Heyes <richard@phpguru.org>
\r
40 * @author Alexey Borzov <avb@php.net>
\r
41 * @copyright 2002-2007 Richard Heyes
\r
42 * @license http://opensource.org/licenses/bsd-license.php New BSD License
\r
43 * @version CVS: $Id: Request.php,v 1.63 2008/10/11 11:07:10 avb Exp $
\r
44 * @link http://pear.php.net/package/HTTP_Request/
\r
48 * PEAR and PEAR_Error classes (for error handling)
\r
50 require_once 'PEAR.php';
\r
54 require_once 'Net/Socket.php';
\r
56 * URL handling class
\r
58 require_once 'Net/URL.php';
\r
61 * Constants for HTTP request methods
\r
63 define('HTTP_REQUEST_METHOD_GET', 'GET', true);
\r
64 define('HTTP_REQUEST_METHOD_HEAD', 'HEAD', true);
\r
65 define('HTTP_REQUEST_METHOD_POST', 'POST', true);
\r
66 define('HTTP_REQUEST_METHOD_PUT', 'PUT', true);
\r
67 define('HTTP_REQUEST_METHOD_DELETE', 'DELETE', true);
\r
68 define('HTTP_REQUEST_METHOD_OPTIONS', 'OPTIONS', true);
\r
69 define('HTTP_REQUEST_METHOD_TRACE', 'TRACE', true);
\r
73 * Constants for HTTP request error codes
\r
75 define('HTTP_REQUEST_ERROR_FILE', 1);
\r
76 define('HTTP_REQUEST_ERROR_URL', 2);
\r
77 define('HTTP_REQUEST_ERROR_PROXY', 4);
\r
78 define('HTTP_REQUEST_ERROR_REDIRECTS', 8);
\r
79 define('HTTP_REQUEST_ERROR_RESPONSE', 16);
\r
80 define('HTTP_REQUEST_ERROR_GZIP_METHOD', 32);
\r
81 define('HTTP_REQUEST_ERROR_GZIP_READ', 64);
\r
82 define('HTTP_REQUEST_ERROR_GZIP_DATA', 128);
\r
83 define('HTTP_REQUEST_ERROR_GZIP_CRC', 256);
\r
87 * Constants for HTTP protocol versions
\r
89 define('HTTP_REQUEST_HTTP_VER_1_0', '1.0', true);
\r
90 define('HTTP_REQUEST_HTTP_VER_1_1', '1.1', true);
\r
93 if (extension_loaded('mbstring') && (2 & ini_get('mbstring.func_overload'))) {
\r
95 * Whether string functions are overloaded by their mbstring equivalents
\r
97 define('HTTP_REQUEST_MBSTRING', true);
\r
102 define('HTTP_REQUEST_MBSTRING', false);
\r
106 * Class for performing HTTP requests
\r
108 * Simple example (fetches yahoo.com and displays it):
\r
110 * $a = &new HTTP_Request('http://www.yahoo.com/');
\r
111 * $a->sendRequest();
\r
112 * echo $a->getResponseBody();
\r
116 * @package HTTP_Request
\r
117 * @author Richard Heyes <richard@phpguru.org>
\r
118 * @author Alexey Borzov <avb@php.net>
\r
119 * @version Release: 1.4.4
\r
127 * Instance of Net_URL
\r
148 var $_requestHeaders;
\r
151 * Basic Auth Username
\r
157 * Basic Auth Password
\r
205 * A list of methods that MUST NOT have a request body, per RFC 2616
\r
208 var $_bodyDisallowed = array('TRACE');
\r
211 * Methods having defined semantics for request body
\r
213 * Content-Length header (indicating that the body follows, section 4.3 of
\r
214 * RFC 2616) will be sent for these methods even if no body was added
\r
218 var $_bodyRequired = array('POST', 'PUT');
\r
224 var $_postFiles = array();
\r
227 * Connection timeout.
\r
233 * HTTP_Response object
\r
234 * @var HTTP_Response
\r
239 * Whether to allow redirects
\r
242 var $_allowRedirects;
\r
245 * Maximum redirects allowed
\r
248 var $_maxRedirects;
\r
251 * Current number of redirects
\r
257 * Whether to append brackets [] to array variables
\r
260 var $_useBrackets = true;
\r
263 * Attached listeners
\r
266 var $_listeners = array();
\r
269 * Whether to save response body in response object property
\r
272 var $_saveBody = true;
\r
275 * Timeout for reading from socket (array(seconds, microseconds))
\r
278 var $_readTimeout = null;
\r
281 * Options to pass to Net_Socket::connect. See stream_context_create
\r
284 var $_socketOptions = null;
\r
290 * Sets up the object
\r
291 * @param string The url to fetch/access
\r
292 * @param array Associative array of parameters which can have the following keys:
\r
294 * <li>method - Method to use, GET, POST etc (string)</li>
\r
295 * <li>http - HTTP Version to use, 1.0 or 1.1 (string)</li>
\r
296 * <li>user - Basic Auth username (string)</li>
\r
297 * <li>pass - Basic Auth password (string)</li>
\r
298 * <li>proxy_host - Proxy server host (string)</li>
\r
299 * <li>proxy_port - Proxy server port (integer)</li>
\r
300 * <li>proxy_user - Proxy auth username (string)</li>
\r
301 * <li>proxy_pass - Proxy auth password (string)</li>
\r
302 * <li>timeout - Connection timeout in seconds (float)</li>
\r
303 * <li>allowRedirects - Whether to follow redirects or not (bool)</li>
\r
304 * <li>maxRedirects - Max number of redirects to follow (integer)</li>
\r
305 * <li>useBrackets - Whether to append [] to array variable names (bool)</li>
\r
306 * <li>saveBody - Whether to save response body in response object property (bool)</li>
\r
307 * <li>readTimeout - Timeout for reading / writing data over the socket (array (seconds, microseconds))</li>
\r
308 * <li>socketOptions - Options to pass to Net_Socket object (array)</li>
\r
312 function HTTP_Request($url = '', $params = array())
\r
314 $this->_method = HTTP_REQUEST_METHOD_GET;
\r
315 $this->_http = HTTP_REQUEST_HTTP_VER_1_1;
\r
316 $this->_requestHeaders = array();
\r
317 $this->_postData = array();
\r
318 $this->_body = null;
\r
320 $this->_user = null;
\r
321 $this->_pass = null;
\r
323 $this->_proxy_host = null;
\r
324 $this->_proxy_port = null;
\r
325 $this->_proxy_user = null;
\r
326 $this->_proxy_pass = null;
\r
328 $this->_allowRedirects = false;
\r
329 $this->_maxRedirects = 3;
\r
330 $this->_redirects = 0;
\r
332 $this->_timeout = null;
\r
333 $this->_response = null;
\r
335 foreach ($params as $key => $value) {
\r
336 $this->{'_' . $key} = $value;
\r
339 if (!empty($url)) {
\r
340 $this->setURL($url);
\r
343 // Default useragent
\r
344 $this->addHeader('User-Agent', 'PEAR HTTP_Request class ( http://pear.php.net/ )');
\r
346 // We don't do keep-alives by default
\r
347 $this->addHeader('Connection', 'close');
\r
349 // Basic authentication
\r
350 if (!empty($this->_user)) {
\r
351 $this->addHeader('Authorization', 'Basic ' . base64_encode($this->_user . ':' . $this->_pass));
\r
354 // Proxy authentication (see bug #5913)
\r
355 if (!empty($this->_proxy_user)) {
\r
356 $this->addHeader('Proxy-Authorization', 'Basic ' . base64_encode($this->_proxy_user . ':' . $this->_proxy_pass));
\r
359 // Use gzip encoding if possible
\r
360 if (HTTP_REQUEST_HTTP_VER_1_1 == $this->_http && extension_loaded('zlib')) {
\r
361 $this->addHeader('Accept-Encoding', 'gzip');
\r
366 * Generates a Host header for HTTP/1.1 requests
\r
371 function _generateHostHeader()
\r
373 if ($this->_url->port != 80 AND strcasecmp($this->_url->protocol, 'http') == 0) {
\r
374 $host = $this->_url->host . ':' . $this->_url->port;
\r
376 } elseif ($this->_url->port != 443 AND strcasecmp($this->_url->protocol, 'https') == 0) {
\r
377 $host = $this->_url->host . ':' . $this->_url->port;
\r
379 } elseif ($this->_url->port == 443 AND strcasecmp($this->_url->protocol, 'https') == 0 AND strpos($this->_url->url, ':443') !== false) {
\r
380 $host = $this->_url->host . ':' . $this->_url->port;
\r
383 $host = $this->_url->host;
\r
390 * Resets the object to its initial state (DEPRECATED).
\r
391 * Takes the same parameters as the constructor.
\r
393 * @param string $url The url to be requested
\r
394 * @param array $params Associative array of parameters
\r
395 * (see constructor for details)
\r
397 * @deprecated deprecated since 1.2, call the constructor if this is necessary
\r
399 function reset($url, $params = array())
\r
401 $this->HTTP_Request($url, $params);
\r
405 * Sets the URL to be requested
\r
407 * @param string The url to be requested
\r
410 function setURL($url)
\r
412 $this->_url = &new Net_URL($url, $this->_useBrackets);
\r
414 if (!empty($this->_url->user) || !empty($this->_url->pass)) {
\r
415 $this->setBasicAuth($this->_url->user, $this->_url->pass);
\r
418 if (HTTP_REQUEST_HTTP_VER_1_1 == $this->_http) {
\r
419 $this->addHeader('Host', $this->_generateHostHeader());
\r
422 // set '/' instead of empty path rather than check later (see bug #8662)
\r
423 if (empty($this->_url->path)) {
\r
424 $this->_url->path = '/';
\r
429 * Returns the current request URL
\r
431 * @return string Current request URL
\r
436 return empty($this->_url)? '': $this->_url->getUrl();
\r
440 * Sets a proxy to be used
\r
442 * @param string Proxy host
\r
443 * @param int Proxy port
\r
444 * @param string Proxy username
\r
445 * @param string Proxy password
\r
448 function setProxy($host, $port = 8080, $user = null, $pass = null)
\r
450 $this->_proxy_host = $host;
\r
451 $this->_proxy_port = $port;
\r
452 $this->_proxy_user = $user;
\r
453 $this->_proxy_pass = $pass;
\r
455 if (!empty($user)) {
\r
456 $this->addHeader('Proxy-Authorization', 'Basic ' . base64_encode($user . ':' . $pass));
\r
461 * Sets basic authentication parameters
\r
463 * @param string Username
\r
464 * @param string Password
\r
466 function setBasicAuth($user, $pass)
\r
468 $this->_user = $user;
\r
469 $this->_pass = $pass;
\r
471 $this->addHeader('Authorization', 'Basic ' . base64_encode($user . ':' . $pass));
\r
475 * Sets the method to be used, GET, POST etc.
\r
477 * @param string Method to use. Use the defined constants for this
\r
480 function setMethod($method)
\r
482 $this->_method = $method;
\r
486 * Sets the HTTP version to use, 1.0 or 1.1
\r
488 * @param string Version to use. Use the defined constants for this
\r
491 function setHttpVer($http)
\r
493 $this->_http = $http;
\r
497 * Adds a request header
\r
499 * @param string Header name
\r
500 * @param string Header value
\r
503 function addHeader($name, $value)
\r
505 $this->_requestHeaders[strtolower($name)] = $value;
\r
509 * Removes a request header
\r
511 * @param string Header name to remove
\r
514 function removeHeader($name)
\r
516 if (isset($this->_requestHeaders[strtolower($name)])) {
\r
517 unset($this->_requestHeaders[strtolower($name)]);
\r
522 * Adds a querystring parameter
\r
524 * @param string Querystring parameter name
\r
525 * @param string Querystring parameter value
\r
526 * @param bool Whether the value is already urlencoded or not, default = not
\r
529 function addQueryString($name, $value, $preencoded = false)
\r
531 $this->_url->addQueryString($name, $value, $preencoded);
\r
535 * Sets the querystring to literally what you supply
\r
537 * @param string The querystring data. Should be of the format foo=bar&x=y etc
\r
538 * @param bool Whether data is already urlencoded or not, default = already encoded
\r
541 function addRawQueryString($querystring, $preencoded = true)
\r
543 $this->_url->addRawQueryString($querystring, $preencoded);
\r
547 * Adds postdata items
\r
549 * @param string Post data name
\r
550 * @param string Post data value
\r
551 * @param bool Whether data is already urlencoded or not, default = not
\r
554 function addPostData($name, $value, $preencoded = false)
\r
557 $this->_postData[$name] = $value;
\r
559 $this->_postData[$name] = $this->_arrayMapRecursive('urlencode', $value);
\r
564 * Recursively applies the callback function to the value
\r
566 * @param mixed Callback function
\r
567 * @param mixed Value to process
\r
569 * @return mixed Processed value
\r
571 function _arrayMapRecursive($callback, $value)
\r
573 if (!is_array($value)) {
\r
574 return call_user_func($callback, $value);
\r
577 foreach ($value as $k => $v) {
\r
578 $map[$k] = $this->_arrayMapRecursive($callback, $v);
\r
585 * Adds a file to form-based file upload
\r
587 * Used to emulate file upload via a HTML form. The method also sets
\r
588 * Content-Type of HTTP request to 'multipart/form-data'.
\r
590 * If you just want to send the contents of a file as the body of HTTP
\r
591 * request you should use setBody() method.
\r
594 * @param string name of file-upload field
\r
595 * @param mixed file name(s)
\r
596 * @param mixed content-type(s) of file(s) being uploaded
\r
597 * @return bool true on success
\r
598 * @throws PEAR_Error
\r
600 function addFile($inputName, $fileName, $contentType = 'application/octet-stream')
\r
602 if (!is_array($fileName) && !is_readable($fileName)) {
\r
603 return PEAR::raiseError("File '{$fileName}' is not readable", HTTP_REQUEST_ERROR_FILE);
\r
604 } elseif (is_array($fileName)) {
\r
605 foreach ($fileName as $name) {
\r
606 if (!is_readable($name)) {
\r
607 return PEAR::raiseError("File '{$name}' is not readable", HTTP_REQUEST_ERROR_FILE);
\r
611 $this->addHeader('Content-Type', 'multipart/form-data');
\r
612 $this->_postFiles[$inputName] = array(
\r
613 'name' => $fileName,
\r
614 'type' => $contentType
\r
620 * Adds raw postdata (DEPRECATED)
\r
622 * @param string The data
\r
623 * @param bool Whether data is preencoded or not, default = already encoded
\r
625 * @deprecated deprecated since 1.3.0, method setBody() should be used instead
\r
627 function addRawPostData($postdata, $preencoded = true)
\r
629 $this->_body = $preencoded ? $postdata : urlencode($postdata);
\r
633 * Sets the request body (for POST, PUT and similar requests)
\r
635 * @param string Request body
\r
638 function setBody($body)
\r
640 $this->_body = $body;
\r
644 * Clears any postdata that has been added (DEPRECATED).
\r
646 * Useful for multiple request scenarios.
\r
649 * @deprecated deprecated since 1.2
\r
651 function clearPostData()
\r
653 $this->_postData = null;
\r
657 * Appends a cookie to "Cookie:" header
\r
659 * @param string $name cookie name
\r
660 * @param string $value cookie value
\r
663 function addCookie($name, $value)
\r
665 $cookies = isset($this->_requestHeaders['cookie']) ? $this->_requestHeaders['cookie']. '; ' : '';
\r
666 $this->addHeader('Cookie', $cookies . $name . '=' . $value);
\r
670 * Clears any cookies that have been added (DEPRECATED).
\r
672 * Useful for multiple request scenarios
\r
675 * @deprecated deprecated since 1.2
\r
677 function clearCookies()
\r
679 $this->removeHeader('Cookie');
\r
683 * Sends the request
\r
686 * @param bool Whether to store response body in Response object property,
\r
687 * set this to false if downloading a LARGE file and using a Listener
\r
688 * @return mixed PEAR error on error, true otherwise
\r
690 function sendRequest($saveBody = true)
\r
692 if (!is_a($this->_url, 'Net_URL')) {
\r
693 return PEAR::raiseError('No URL given', HTTP_REQUEST_ERROR_URL);
\r
696 $host = isset($this->_proxy_host) ? $this->_proxy_host : $this->_url->host;
\r
697 $port = isset($this->_proxy_port) ? $this->_proxy_port : $this->_url->port;
\r
699 if (strcasecmp($this->_url->protocol, 'https') == 0) {
\r
700 // Bug #14127, don't try connecting to HTTPS sites without OpenSSL
\r
701 if (version_compare(PHP_VERSION, '4.3.0', '<') || !extension_loaded('openssl')) {
\r
702 return PEAR::raiseError('Need PHP 4.3.0 or later with OpenSSL support for https:// requests',
\r
703 HTTP_REQUEST_ERROR_URL);
\r
704 } elseif (isset($this->_proxy_host)) {
\r
705 return PEAR::raiseError('HTTPS proxies are not supported', HTTP_REQUEST_ERROR_PROXY);
\r
707 $host = 'ssl://' . $host;
\r
710 // magic quotes may fuck up file uploads and chunked response processing
\r
711 $magicQuotes = ini_get('magic_quotes_runtime');
\r
712 ini_set('magic_quotes_runtime', false);
\r
714 // RFC 2068, section 19.7.1: A client MUST NOT send the Keep-Alive
\r
715 // connection token to a proxy server...
\r
716 if (isset($this->_proxy_host) && !empty($this->_requestHeaders['connection']) &&
\r
717 'Keep-Alive' == $this->_requestHeaders['connection'])
\r
719 $this->removeHeader('connection');
\r
722 $keepAlive = (HTTP_REQUEST_HTTP_VER_1_1 == $this->_http && empty($this->_requestHeaders['connection'])) ||
\r
723 (!empty($this->_requestHeaders['connection']) && 'Keep-Alive' == $this->_requestHeaders['connection']);
\r
724 $sockets = &PEAR::getStaticProperty('HTTP_Request', 'sockets');
\r
725 $sockKey = $host . ':' . $port;
\r
726 unset($this->_sock);
\r
728 // There is a connected socket in the "static" property?
\r
729 if ($keepAlive && !empty($sockets[$sockKey]) &&
\r
730 !empty($sockets[$sockKey]->fp))
\r
732 $this->_sock =& $sockets[$sockKey];
\r
735 $this->_notify('connect');
\r
736 $this->_sock =& new Net_Socket();
\r
737 $err = $this->_sock->connect($host, $port, null, $this->_timeout, $this->_socketOptions);
\r
739 PEAR::isError($err) or $err = $this->_sock->write($this->_buildRequest());
\r
741 if (!PEAR::isError($err)) {
\r
742 if (!empty($this->_readTimeout)) {
\r
743 $this->_sock->setTimeout($this->_readTimeout[0], $this->_readTimeout[1]);
\r
746 $this->_notify('sentRequest');
\r
748 // Read the response
\r
749 $this->_response = &new HTTP_Response($this->_sock, $this->_listeners);
\r
750 $err = $this->_response->process(
\r
751 $this->_saveBody && $saveBody,
\r
752 HTTP_REQUEST_METHOD_HEAD != $this->_method
\r
756 $keepAlive = (isset($this->_response->_headers['content-length'])
\r
757 || (isset($this->_response->_headers['transfer-encoding'])
\r
758 && strtolower($this->_response->_headers['transfer-encoding']) == 'chunked'));
\r
760 if (isset($this->_response->_headers['connection'])) {
\r
761 $keepAlive = strtolower($this->_response->_headers['connection']) == 'keep-alive';
\r
763 $keepAlive = 'HTTP/'.HTTP_REQUEST_HTTP_VER_1_1 == $this->_response->_protocol;
\r
769 ini_set('magic_quotes_runtime', $magicQuotes);
\r
771 if (PEAR::isError($err)) {
\r
776 $this->disconnect();
\r
777 // Store the connected socket in "static" property
\r
778 } elseif (empty($sockets[$sockKey]) || empty($sockets[$sockKey]->fp)) {
\r
779 $sockets[$sockKey] =& $this->_sock;
\r
782 // Check for redirection
\r
783 if ( $this->_allowRedirects
\r
784 AND $this->_redirects <= $this->_maxRedirects
\r
785 AND $this->getResponseCode() > 300
\r
786 AND $this->getResponseCode() < 399
\r
787 AND !empty($this->_response->_headers['location'])) {
\r
790 $redirect = $this->_response->_headers['location'];
\r
793 if (preg_match('/^https?:\/\//i', $redirect)) {
\r
794 $this->_url = &new Net_URL($redirect);
\r
795 $this->addHeader('Host', $this->_generateHostHeader());
\r
797 } elseif ($redirect{0} == '/') {
\r
798 $this->_url->path = $redirect;
\r
801 } elseif (substr($redirect, 0, 3) == '../' OR substr($redirect, 0, 2) == './') {
\r
802 if (substr($this->_url->path, -1) == '/') {
\r
803 $redirect = $this->_url->path . $redirect;
\r
805 $redirect = dirname($this->_url->path) . '/' . $redirect;
\r
807 $redirect = Net_URL::resolvePath($redirect);
\r
808 $this->_url->path = $redirect;
\r
810 // Filename, no path
\r
812 if (substr($this->_url->path, -1) == '/') {
\r
813 $redirect = $this->_url->path . $redirect;
\r
815 $redirect = dirname($this->_url->path) . '/' . $redirect;
\r
817 $this->_url->path = $redirect;
\r
820 $this->_redirects++;
\r
821 return $this->sendRequest($saveBody);
\r
823 // Too many redirects
\r
824 } elseif ($this->_allowRedirects AND $this->_redirects > $this->_maxRedirects) {
\r
825 return PEAR::raiseError('Too many redirects', HTTP_REQUEST_ERROR_REDIRECTS);
\r
832 * Disconnect the socket, if connected. Only useful if using Keep-Alive.
\r
836 function disconnect()
\r
838 if (!empty($this->_sock) && !empty($this->_sock->fp)) {
\r
839 $this->_notify('disconnect');
\r
840 $this->_sock->disconnect();
\r
845 * Returns the response code
\r
848 * @return mixed Response code, false if not set
\r
850 function getResponseCode()
\r
852 return isset($this->_response->_code) ? $this->_response->_code : false;
\r
856 * Returns the response reason phrase
\r
859 * @return mixed Response reason phrase, false if not set
\r
861 function getResponseReason()
\r
863 return isset($this->_response->_reason) ? $this->_response->_reason : false;
\r
867 * Returns either the named header or all if no name given
\r
870 * @param string The header name to return, do not set to get all headers
\r
871 * @return mixed either the value of $headername (false if header is not present)
\r
872 * or an array of all headers
\r
874 function getResponseHeader($headername = null)
\r
876 if (!isset($headername)) {
\r
877 return isset($this->_response->_headers)? $this->_response->_headers: array();
\r
879 $headername = strtolower($headername);
\r
880 return isset($this->_response->_headers[$headername]) ? $this->_response->_headers[$headername] : false;
\r
885 * Returns the body of the response
\r
888 * @return mixed response body, false if not set
\r
890 function getResponseBody()
\r
892 return isset($this->_response->_body) ? $this->_response->_body : false;
\r
896 * Returns cookies set in response
\r
899 * @return mixed array of response cookies, false if none are present
\r
901 function getResponseCookies()
\r
903 return isset($this->_response->_cookies) ? $this->_response->_cookies : false;
\r
907 * Builds the request string
\r
910 * @return string The request string
\r
912 function _buildRequest()
\r
914 $separator = ini_get('arg_separator.output');
\r
915 ini_set('arg_separator.output', '&');
\r
916 $querystring = ($querystring = $this->_url->getQueryString()) ? '?' . $querystring : '';
\r
917 ini_set('arg_separator.output', $separator);
\r
919 $host = isset($this->_proxy_host) ? $this->_url->protocol . '://' . $this->_url->host : '';
\r
920 $port = (isset($this->_proxy_host) AND $this->_url->port != 80) ? ':' . $this->_url->port : '';
\r
921 $path = $this->_url->path . $querystring;
\r
922 $url = $host . $port . $path;
\r
924 if (!strlen($url)) {
\r
928 $request = $this->_method . ' ' . $url . ' HTTP/' . $this->_http . "\r\n";
\r
930 if (in_array($this->_method, $this->_bodyDisallowed) ||
\r
931 (0 == strlen($this->_body) && (HTTP_REQUEST_METHOD_POST != $this->_method ||
\r
932 (empty($this->_postData) && empty($this->_postFiles)))))
\r
934 $this->removeHeader('Content-Type');
\r
936 if (empty($this->_requestHeaders['content-type'])) {
\r
937 // Add default content-type
\r
938 $this->addHeader('Content-Type', 'application/x-www-form-urlencoded');
\r
939 } elseif ('multipart/form-data' == $this->_requestHeaders['content-type']) {
\r
940 $boundary = 'HTTP_Request_' . md5(uniqid('request') . microtime());
\r
941 $this->addHeader('Content-Type', 'multipart/form-data; boundary=' . $boundary);
\r
946 if (!empty($this->_requestHeaders)) {
\r
947 foreach ($this->_requestHeaders as $name => $value) {
\r
948 $canonicalName = implode('-', array_map('ucfirst', explode('-', $name)));
\r
949 $request .= $canonicalName . ': ' . $value . "\r\n";
\r
953 // Method does not allow a body, simply add a final CRLF
\r
954 if (in_array($this->_method, $this->_bodyDisallowed)) {
\r
956 $request .= "\r\n";
\r
958 // Post data if it's an array
\r
959 } elseif (HTTP_REQUEST_METHOD_POST == $this->_method &&
\r
960 (!empty($this->_postData) || !empty($this->_postFiles))) {
\r
962 // "normal" POST request
\r
963 if (!isset($boundary)) {
\r
964 $postdata = implode('&', array_map(
\r
965 create_function('$a', 'return $a[0] . \'=\' . $a[1];'),
\r
966 $this->_flattenArray('', $this->_postData)
\r
969 // multipart request, probably with file uploads
\r
972 if (!empty($this->_postData)) {
\r
973 $flatData = $this->_flattenArray('', $this->_postData);
\r
974 foreach ($flatData as $item) {
\r
975 $postdata .= '--' . $boundary . "\r\n";
\r
976 $postdata .= 'Content-Disposition: form-data; name="' . $item[0] . '"';
\r
977 $postdata .= "\r\n\r\n" . urldecode($item[1]) . "\r\n";
\r
980 foreach ($this->_postFiles as $name => $value) {
\r
981 if (is_array($value['name'])) {
\r
982 $varname = $name . ($this->_useBrackets? '[]': '');
\r
985 $value['name'] = array($value['name']);
\r
987 foreach ($value['name'] as $key => $filename) {
\r
988 $fp = fopen($filename, 'r');
\r
989 $basename = basename($filename);
\r
990 $type = is_array($value['type'])? @$value['type'][$key]: $value['type'];
\r
992 $postdata .= '--' . $boundary . "\r\n";
\r
993 $postdata .= 'Content-Disposition: form-data; name="' . $varname . '"; filename="' . $basename . '"';
\r
994 $postdata .= "\r\nContent-Type: " . $type;
\r
995 $postdata .= "\r\n\r\n" . fread($fp, filesize($filename)) . "\r\n";
\r
999 $postdata .= '--' . $boundary . "--\r\n";
\r
1001 $request .= 'Content-Length: ' .
\r
1002 (HTTP_REQUEST_MBSTRING? mb_strlen($postdata, 'iso-8859-1'): strlen($postdata)) .
\r
1004 $request .= $postdata;
\r
1006 // Explicitly set request body
\r
1007 } elseif (0 < strlen($this->_body)) {
\r
1009 $request .= 'Content-Length: ' .
\r
1010 (HTTP_REQUEST_MBSTRING? mb_strlen($this->_body, 'iso-8859-1'): strlen($this->_body)) .
\r
1012 $request .= $this->_body;
\r
1014 // No body: send a Content-Length header nonetheless (request #12900),
\r
1015 // but do that only for methods that require a body (bug #14740)
\r
1018 if (in_array($this->_method, $this->_bodyRequired)) {
\r
1019 $request .= "Content-Length: 0\r\n";
\r
1021 $request .= "\r\n";
\r
1028 * Helper function to change the (probably multidimensional) associative array
\r
1029 * into the simple one.
\r
1031 * @param string name for item
\r
1032 * @param mixed item's values
\r
1033 * @return array array with the following items: array('item name', 'item value');
\r
1036 function _flattenArray($name, $values)
\r
1038 if (!is_array($values)) {
\r
1039 return array(array($name, $values));
\r
1042 foreach ($values as $k => $v) {
\r
1043 if (empty($name)) {
\r
1045 } elseif ($this->_useBrackets) {
\r
1046 $newName = $name . '[' . $k . ']';
\r
1050 $ret = array_merge($ret, $this->_flattenArray($newName, $v));
\r
1058 * Adds a Listener to the list of listeners that are notified of
\r
1059 * the object's events
\r
1061 * Events sent by HTTP_Request object
\r
1062 * - 'connect': on connection to server
\r
1063 * - 'sentRequest': after the request was sent
\r
1064 * - 'disconnect': on disconnection from server
\r
1066 * Events sent by HTTP_Response object
\r
1067 * - 'gotHeaders': after receiving response headers (headers are passed in $data)
\r
1068 * - 'tick': on receiving a part of response body (the part is passed in $data)
\r
1069 * - 'gzTick': on receiving a gzip-encoded part of response body (ditto)
\r
1070 * - 'gotBody': after receiving the response body (passes the decoded body in $data if it was gzipped)
\r
1072 * @param HTTP_Request_Listener listener to attach
\r
1073 * @return boolean whether the listener was successfully attached
\r
1076 function attach(&$listener)
\r
1078 if (!is_a($listener, 'HTTP_Request_Listener')) {
\r
1081 $this->_listeners[$listener->getId()] =& $listener;
\r
1087 * Removes a Listener from the list of listeners
\r
1089 * @param HTTP_Request_Listener listener to detach
\r
1090 * @return boolean whether the listener was successfully detached
\r
1093 function detach(&$listener)
\r
1095 if (!is_a($listener, 'HTTP_Request_Listener') ||
\r
1096 !isset($this->_listeners[$listener->getId()])) {
\r
1099 unset($this->_listeners[$listener->getId()]);
\r
1105 * Notifies all registered listeners of an event.
\r
1107 * @param string Event name
\r
1108 * @param mixed Additional data
\r
1110 * @see HTTP_Request::attach()
\r
1112 function _notify($event, $data = null)
\r
1114 foreach (array_keys($this->_listeners) as $id) {
\r
1115 $this->_listeners[$id]->update($this, $event, $data);
\r
1122 * Response class to complement the Request class
\r
1125 * @package HTTP_Request
\r
1126 * @author Richard Heyes <richard@phpguru.org>
\r
1127 * @author Alexey Borzov <avb@php.net>
\r
1128 * @version Release: 1.4.4
\r
1130 class HTTP_Response
\r
1151 * Response reason phrase
\r
1157 * Response headers
\r
1163 * Cookies set in response
\r
1175 * Used by _readChunked(): remaining length of the current chunk
\r
1178 var $_chunkLength = 0;
\r
1181 * Attached listeners
\r
1184 var $_listeners = array();
\r
1187 * Bytes left to read from message-body
\r
1195 * @param Net_Socket socket to read the response from
\r
1196 * @param array listeners attached to request
\r
1198 function HTTP_Response(&$sock, &$listeners)
\r
1200 $this->_sock =& $sock;
\r
1201 $this->_listeners =& $listeners;
\r
1206 * Processes a HTTP response
\r
1208 * This extracts response code, headers, cookies and decodes body if it
\r
1209 * was encoded in some way
\r
1212 * @param bool Whether to store response body in object property, set
\r
1213 * this to false if downloading a LARGE file and using a Listener.
\r
1214 * This is assumed to be true if body is gzip-encoded.
\r
1215 * @param bool Whether the response can actually have a message-body.
\r
1216 * Will be set to false for HEAD requests.
\r
1217 * @throws PEAR_Error
\r
1218 * @return mixed true on success, PEAR_Error in case of malformed response
\r
1220 function process($saveBody = true, $canHaveBody = true)
\r
1223 $line = $this->_sock->readLine();
\r
1224 if (!preg_match('!^(HTTP/\d\.\d) (\d{3})(?: (.+))?!', $line, $s)) {
\r
1225 return PEAR::raiseError('Malformed response', HTTP_REQUEST_ERROR_RESPONSE);
\r
1227 $this->_protocol = $s[1];
\r
1228 $this->_code = intval($s[2]);
\r
1229 $this->_reason = empty($s[3])? null: $s[3];
\r
1231 while ('' !== ($header = $this->_sock->readLine())) {
\r
1232 $this->_processHeader($header);
\r
1234 } while (100 == $this->_code);
\r
1236 $this->_notify('gotHeaders', $this->_headers);
\r
1238 // RFC 2616, section 4.4:
\r
1239 // 1. Any response message which "MUST NOT" include a message-body ...
\r
1240 // is always terminated by the first empty line after the header fields
\r
1241 // 3. ... If a message is received with both a
\r
1242 // Transfer-Encoding header field and a Content-Length header field,
\r
1243 // the latter MUST be ignored.
\r
1244 $canHaveBody = $canHaveBody && $this->_code >= 200 &&
\r
1245 $this->_code != 204 && $this->_code != 304;
\r
1247 // If response body is present, read it and decode
\r
1248 $chunked = isset($this->_headers['transfer-encoding']) && ('chunked' == $this->_headers['transfer-encoding']);
\r
1249 $gzipped = isset($this->_headers['content-encoding']) && ('gzip' == $this->_headers['content-encoding']);
\r
1251 if ($canHaveBody && ($chunked || !isset($this->_headers['content-length']) ||
\r
1252 0 != $this->_headers['content-length']))
\r
1254 if ($chunked || !isset($this->_headers['content-length'])) {
\r
1255 $this->_toRead = null;
\r
1257 $this->_toRead = $this->_headers['content-length'];
\r
1259 while (!$this->_sock->eof() && (is_null($this->_toRead) || 0 < $this->_toRead)) {
\r
1261 $data = $this->_readChunked();
\r
1262 } elseif (is_null($this->_toRead)) {
\r
1263 $data = $this->_sock->read(4096);
\r
1265 $data = $this->_sock->read(min(4096, $this->_toRead));
\r
1266 $this->_toRead -= HTTP_REQUEST_MBSTRING? mb_strlen($data, 'iso-8859-1'): strlen($data);
\r
1268 if ('' == $data && (!$this->_chunkLength || $this->_sock->eof())) {
\r
1272 if ($saveBody || $gzipped) {
\r
1273 $this->_body .= $data;
\r
1275 $this->_notify($gzipped? 'gzTick': 'tick', $data);
\r
1281 // Uncompress the body if needed
\r
1283 $body = $this->_decodeGzip($this->_body);
\r
1284 if (PEAR::isError($body)) {
\r
1287 $this->_body = $body;
\r
1288 $this->_notify('gotBody', $this->_body);
\r
1290 $this->_notify('gotBody');
\r
1298 * Processes the response header
\r
1301 * @param string HTTP header
\r
1303 function _processHeader($header)
\r
1305 if (false === strpos($header, ':')) {
\r
1308 list($headername, $headervalue) = explode(':', $header, 2);
\r
1309 $headername = strtolower($headername);
\r
1310 $headervalue = ltrim($headervalue);
\r
1312 if ('set-cookie' != $headername) {
\r
1313 if (isset($this->_headers[$headername])) {
\r
1314 $this->_headers[$headername] .= ',' . $headervalue;
\r
1316 $this->_headers[$headername] = $headervalue;
\r
1319 $this->_parseCookie($headervalue);
\r
1325 * Parse a Set-Cookie header to fill $_cookies array
\r
1328 * @param string value of Set-Cookie header
\r
1330 function _parseCookie($headervalue)
\r
1333 'expires' => null,
\r
1339 // Only a name=value pair
\r
1340 if (!strpos($headervalue, ';')) {
\r
1341 $pos = strpos($headervalue, '=');
\r
1342 $cookie['name'] = trim(substr($headervalue, 0, $pos));
\r
1343 $cookie['value'] = trim(substr($headervalue, $pos + 1));
\r
1345 // Some optional parameters are supplied
\r
1347 $elements = explode(';', $headervalue);
\r
1348 $pos = strpos($elements[0], '=');
\r
1349 $cookie['name'] = trim(substr($elements[0], 0, $pos));
\r
1350 $cookie['value'] = trim(substr($elements[0], $pos + 1));
\r
1352 for ($i = 1; $i < count($elements); $i++) {
\r
1353 if (false === strpos($elements[$i], '=')) {
\r
1354 $elName = trim($elements[$i]);
\r
1357 list ($elName, $elValue) = array_map('trim', explode('=', $elements[$i]));
\r
1359 $elName = strtolower($elName);
\r
1360 if ('secure' == $elName) {
\r
1361 $cookie['secure'] = true;
\r
1362 } elseif ('expires' == $elName) {
\r
1363 $cookie['expires'] = str_replace('"', '', $elValue);
\r
1364 } elseif ('path' == $elName || 'domain' == $elName) {
\r
1365 $cookie[$elName] = urldecode($elValue);
\r
1367 $cookie[$elName] = $elValue;
\r
1371 $this->_cookies[] = $cookie;
\r
1376 * Read a part of response body encoded with chunked Transfer-Encoding
\r
1381 function _readChunked()
\r
1383 // at start of the next chunk?
\r
1384 if (0 == $this->_chunkLength) {
\r
1385 $line = $this->_sock->readLine();
\r
1386 if (preg_match('/^([0-9a-f]+)/i', $line, $matches)) {
\r
1387 $this->_chunkLength = hexdec($matches[1]);
\r
1388 // Chunk with zero length indicates the end
\r
1389 if (0 == $this->_chunkLength) {
\r
1390 $this->_sock->readLine(); // make this an eof()
\r
1397 $data = $this->_sock->read($this->_chunkLength);
\r
1398 $this->_chunkLength -= HTTP_REQUEST_MBSTRING? mb_strlen($data, 'iso-8859-1'): strlen($data);
\r
1399 if (0 == $this->_chunkLength) {
\r
1400 $this->_sock->readLine(); // Trailing CRLF
\r
1407 * Notifies all registered listeners of an event.
\r
1409 * @param string Event name
\r
1410 * @param mixed Additional data
\r
1412 * @see HTTP_Request::_notify()
\r
1414 function _notify($event, $data = null)
\r
1416 foreach (array_keys($this->_listeners) as $id) {
\r
1417 $this->_listeners[$id]->update($this, $event, $data);
\r
1423 * Decodes the message-body encoded by gzip
\r
1425 * The real decoding work is done by gzinflate() built-in function, this
\r
1426 * method only parses the header and checks data for compliance with
\r
1430 * @param string gzip-encoded data
\r
1431 * @return string decoded data
\r
1433 function _decodeGzip($data)
\r
1435 if (HTTP_REQUEST_MBSTRING) {
\r
1436 $oldEncoding = mb_internal_encoding();
\r
1437 mb_internal_encoding('iso-8859-1');
\r
1439 $length = strlen($data);
\r
1440 // If it doesn't look like gzip-encoded data, don't bother
\r
1441 if (18 > $length || strcmp(substr($data, 0, 2), "\x1f\x8b")) {
\r
1444 $method = ord(substr($data, 2, 1));
\r
1445 if (8 != $method) {
\r
1446 return PEAR::raiseError('_decodeGzip(): unknown compression method', HTTP_REQUEST_ERROR_GZIP_METHOD);
\r
1448 $flags = ord(substr($data, 3, 1));
\r
1449 if ($flags & 224) {
\r
1450 return PEAR::raiseError('_decodeGzip(): reserved bits are set', HTTP_REQUEST_ERROR_GZIP_DATA);
\r
1453 // header is 10 bytes minimum. may be longer, though.
\r
1454 $headerLength = 10;
\r
1455 // extra fields, need to skip 'em
\r
1457 if ($length - $headerLength - 2 < 8) {
\r
1458 return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
\r
1460 $extraLength = unpack('v', substr($data, 10, 2));
\r
1461 if ($length - $headerLength - 2 - $extraLength[1] < 8) {
\r
1462 return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
\r
1464 $headerLength += $extraLength[1] + 2;
\r
1466 // file name, need to skip that
\r
1468 if ($length - $headerLength - 1 < 8) {
\r
1469 return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
\r
1471 $filenameLength = strpos(substr($data, $headerLength), chr(0));
\r
1472 if (false === $filenameLength || $length - $headerLength - $filenameLength - 1 < 8) {
\r
1473 return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
\r
1475 $headerLength += $filenameLength + 1;
\r
1477 // comment, need to skip that also
\r
1478 if ($flags & 16) {
\r
1479 if ($length - $headerLength - 1 < 8) {
\r
1480 return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
\r
1482 $commentLength = strpos(substr($data, $headerLength), chr(0));
\r
1483 if (false === $commentLength || $length - $headerLength - $commentLength - 1 < 8) {
\r
1484 return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
\r
1486 $headerLength += $commentLength + 1;
\r
1488 // have a CRC for header. let's check
\r
1490 if ($length - $headerLength - 2 < 8) {
\r
1491 return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
\r
1493 $crcReal = 0xffff & crc32(substr($data, 0, $headerLength));
\r
1494 $crcStored = unpack('v', substr($data, $headerLength, 2));
\r
1495 if ($crcReal != $crcStored[1]) {
\r
1496 return PEAR::raiseError('_decodeGzip(): header CRC check failed', HTTP_REQUEST_ERROR_GZIP_CRC);
\r
1498 $headerLength += 2;
\r
1500 // unpacked data CRC and size at the end of encoded data
\r
1501 $tmp = unpack('V2', substr($data, -8));
\r
1502 $dataCrc = $tmp[1];
\r
1503 $dataSize = $tmp[2];
\r
1505 // finally, call the gzinflate() function
\r
1506 // don't pass $dataSize to gzinflate, see bugs #13135, #14370
\r
1507 $unpacked = gzinflate(substr($data, $headerLength, -8));
\r
1508 if (false === $unpacked) {
\r
1509 return PEAR::raiseError('_decodeGzip(): gzinflate() call failed', HTTP_REQUEST_ERROR_GZIP_READ);
\r
1510 } elseif ($dataSize != strlen($unpacked)) {
\r
1511 return PEAR::raiseError('_decodeGzip(): data size check failed', HTTP_REQUEST_ERROR_GZIP_READ);
\r
1512 } elseif ((0xffffffff & $dataCrc) != (0xffffffff & crc32($unpacked))) {
\r
1513 return PEAR::raiseError('_decodeGzip(): data CRC check failed', HTTP_REQUEST_ERROR_GZIP_CRC);
\r
1515 if (HTTP_REQUEST_MBSTRING) {
\r
1516 mb_internal_encoding($oldEncoding);
\r
1520 } // End class HTTP_Response
\r