Source for file Request.php
Documentation is available at Request.php
// +-----------------------------------------------------------------------+
// | Copyright (c) 2002-2003, Richard Heyes |
// | All rights reserved. |
// | Redistribution and use in source and binary forms, with or without |
// | modification, are permitted provided that the following conditions |
// | o Redistributions of source code must retain the above copyright |
// | notice, this list of conditions and the following disclaimer. |
// | o Redistributions in binary form must reproduce the above copyright |
// | notice, this list of conditions and the following disclaimer in the |
// | documentation and/or other materials provided with the distribution.|
// | o The names of the authors may not be used to endorse or promote |
// | products derived from this software without specific prior written |
// | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
// | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
// | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
// | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
// | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
// | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
// | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
// | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
// | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
// | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
// | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
// +-----------------------------------------------------------------------+
// | Author: Richard Heyes <richard@phpguru.org> |
// +-----------------------------------------------------------------------+
// $Id: Request.php,v 1.43 2005/11/06 18:29:14 avb Exp $
// Simple example, (Fetches yahoo.com and displays it):
// $a = &new HTTP_Request('http://www.yahoo.com/');
// echo $a->getResponseBody();
require_once 'Net/Socket.php';
require_once 'Net/URL.php';
define('HTTP_REQUEST_METHOD_GET', 'GET', true );
define('HTTP_REQUEST_METHOD_HEAD', 'HEAD', true );
define('HTTP_REQUEST_METHOD_POST', 'POST', true );
define('HTTP_REQUEST_METHOD_PUT', 'PUT', true );
define('HTTP_REQUEST_METHOD_DELETE', 'DELETE', true );
define('HTTP_REQUEST_METHOD_OPTIONS', 'OPTIONS', true );
define('HTTP_REQUEST_METHOD_TRACE', 'TRACE', true );
define('HTTP_REQUEST_HTTP_VER_1_0', '1.0', true );
define('HTTP_REQUEST_HTTP_VER_1_1', '1.1', true );
* A list of methods that MUST NOT have a request body, per RFC 2616
var $_bodyDisallowed = array ('TRACE');
var $_postFiles = array ();
* @var object HTTP_Response
* Whether to allow redirects
* Maximum redirects allowed
* Current number of redirects
* Whether to append brackets [] to array variables
var $_useBrackets = true;
var $_listeners = array ();
* Whether to save response body in response object property
* Timeout for reading from socket (array(seconds, microseconds))
var $_readTimeout = null;
* Options to pass to Net_Socket::connect. See stream_context_create
var $_socketOptions = null;
* @param string The url to fetch/access
* @param array Associative array of parameters which can have the following keys:
* <li>method - Method to use, GET, POST etc (string)</li>
* <li>http - HTTP Version to use, 1.0 or 1.1 (string)</li>
* <li>user - Basic Auth username (string)</li>
* <li>pass - Basic Auth password (string)</li>
* <li>proxy_host - Proxy server host (string)</li>
* <li>proxy_port - Proxy server port (integer)</li>
* <li>proxy_user - Proxy auth username (string)</li>
* <li>proxy_pass - Proxy auth password (string)</li>
* <li>timeout - Connection timeout in seconds (float)</li>
* <li>allowRedirects - Whether to follow redirects or not (bool)</li>
* <li>maxRedirects - Max number of redirects to follow (integer)</li>
* <li>useBrackets - Whether to append [] to array variable names (bool)</li>
* <li>saveBody - Whether to save response body in response object property (bool)</li>
* <li>readTimeout - Timeout for reading / writing data over the socket (array (seconds, microseconds))</li>
* <li>socketOptions - Options to pass to Net_Socket object (array)</li>
function HTTP_Request ($url = '', $params = array ())
$this->_sock = &new Net_Socket ();
$this->_requestHeaders = array ();
$this->_postData = array ();
$this->_proxy_host = null;
$this->_proxy_port = null;
$this->_proxy_user = null;
$this->_proxy_pass = null;
$this->_allowRedirects = false;
$this->_maxRedirects = 3;
foreach ($params as $key => $value) {
$this->{'_' . $key} = $value;
$this->addHeader ('User-Agent', 'PEAR HTTP_Request class ( http://pear.php.net/ )');
// Make sure keepalives dont knobble us
$this->addHeader ('Connection', 'close');
if (!empty ($this->_user )) {
$this->addHeader ('Authorization', 'Basic ' . base64_encode($this->_user . ':' . $this->_pass ));
// Use gzip encoding if possible
// Avoid gzip encoding if using multibyte functions (see #1781)
0 == (2 & ini_get('mbstring.func_overload'))) {
$this->addHeader ('Accept-Encoding', 'gzip');
* Generates a Host header for HTTP/1.1 requests
function _generateHostHeader ()
if ($this->_url ->port != 80 AND strcasecmp($this->_url ->protocol , 'http') == 0 ) {
$host = $this->_url ->host . ':' . $this->_url ->port;
} elseif ($this->_url ->port != 443 AND strcasecmp($this->_url ->protocol , 'https') == 0 ) {
$host = $this->_url ->host . ':' . $this->_url ->port;
} elseif ($this->_url ->port == 443 AND strcasecmp($this->_url ->protocol , 'https') == 0 AND strpos($this->_url ->url , ':443') !== false ) {
$host = $this->_url ->host . ':' . $this->_url ->port;
$host = $this->_url ->host;
* Resets the object to its initial state (DEPRECATED).
* Takes the same parameters as the constructor.
* @param string $url The url to be requested
* @param array $params Associative array of parameters
* (see constructor for details)
* @deprecated deprecated since 1.2, call the constructor if this is necessary
function reset($url, $params = array ())
$this->HTTP_Request ($url, $params);
* Sets the URL to be requested
* @param string The url to be requested
$this->_url = &new Net_URL ($url, $this->_useBrackets );
if (!empty ($this->_url ->user ) || !empty ($this->_url ->pass )) {
$this->setBasicAuth ($this->_url ->user , $this->_url ->pass );
$this->addHeader ('Host', $this->_generateHostHeader ());
* Sets a proxy to be used
* @param string Proxy host
* @param string Proxy username
* @param string Proxy password
function setProxy ($host, $port = 8080 , $user = null , $pass = null )
$this->_proxy_host = $host;
$this->_proxy_port = $port;
$this->_proxy_user = $user;
$this->_proxy_pass = $pass;
$this->addHeader ('Proxy-Authorization', 'Basic ' . base64_encode($user . ':' . $pass));
* Sets basic authentication parameters
function setBasicAuth ($user, $pass)
$this->addHeader ('Authorization', 'Basic ' . base64_encode($user . ':' . $pass));
* Sets the method to be used, GET, POST etc.
* @param string Method to use. Use the defined constants for this
function setMethod ($method)
$this->_method = $method;
* Sets the HTTP version to use, 1.0 or 1.1
* @param string Version to use. Use the defined constants for this
function setHttpVer ($http)
* @param string Header name
* @param string Header value
function addHeader ($name, $value)
$this->_requestHeaders [strtolower($name)] = $value;
* Removes a request header
* @param string Header name to remove
function removeHeader ($name)
if (isset ($this->_requestHeaders [strtolower($name)])) {
* Adds a querystring parameter
* @param string Querystring parameter name
* @param string Querystring parameter value
* @param bool Whether the value is already urlencoded or not, default = not
function addQueryString ($name, $value, $preencoded = false )
$this->_url ->addQueryString ($name, $value, $preencoded);
* Sets the querystring to literally what you supply
* @param string The querystring data. Should be of the format foo=bar&x=y etc
* @param bool Whether data is already urlencoded or not, default = already encoded
function addRawQueryString ($querystring, $preencoded = true )
$this->_url ->addRawQueryString ($querystring, $preencoded);
* @param string Post data name
* @param string Post data value
* @param bool Whether data is already urlencoded or not, default = not
function addPostData ($name, $value, $preencoded = false )
$this->_postData [$name] = $value;
$this->_postData [$name] = $this->_arrayMapRecursive ('urlencode', $value);
* Recursively applies the callback function to the value
* @param mixed Callback function
* @param mixed Value to process
* @return mixed Processed value
function _arrayMapRecursive ($callback, $value)
foreach ($value as $k => $v) {
$map[$k] = $this->_arrayMapRecursive ($callback, $v);
* This also changes content-type to 'multipart/form-data' for proper upload
* @param string name of file-upload field
* @param mixed file name(s)
* @param mixed content-type(s) of file(s) being uploaded
* @return bool true on success
function addFile ($inputName, $fileName, $contentType = 'application/octet-stream')
return PEAR ::raiseError (" File '{$fileName}' is not readable" );
foreach ($fileName as $name) {
return PEAR ::raiseError (" File '{$name}' is not readable" );
$this->addHeader ('Content-Type', 'multipart/form-data');
$this->_postFiles [$inputName] = array (
* Adds raw postdata (DEPRECATED)
* @param bool Whether data is preencoded or not, default = already encoded
* @deprecated deprecated since 1.3.0, method addBody() should be used instead
function addRawPostData ($postdata, $preencoded = true )
$this->_body = $preencoded ? $postdata : urlencode($postdata);
* Sets the request body (for POST, PUT and similar requests)
* @param string Request body
* Clears any postdata that has been added (DEPRECATED).
* Useful for multiple request scenarios.
* @deprecated deprecated since 1.2
* Appends a cookie to "Cookie:" header
* @param string $name cookie name
* @param string $value cookie value
function addCookie ($name, $value)
$cookies = isset ($this->_requestHeaders ['cookie']) ? $this->_requestHeaders ['cookie']. '; ' : '';
$this->addHeader ('Cookie', $cookies . $name . '=' . $value);
* Clears any cookies that have been added (DEPRECATED).
* Useful for multiple request scenarios
* @deprecated deprecated since 1.2
$this->removeHeader ('Cookie');
* @param bool Whether to store response body in Response object property,
* set this to false if downloading a LARGE file and using a Listener
* @return mixed PEAR error on error, true otherwise
function sendRequest ($saveBody = true )
if (!is_a($this->_url , 'Net_URL')) {
return PEAR ::raiseError ('No URL given.');
$host = isset ($this->_proxy_host ) ? $this->_proxy_host : $this->_url ->host;
$port = isset ($this->_proxy_port ) ? $this->_proxy_port : $this->_url ->port;
// 4.3.0 supports SSL connections using OpenSSL. The function test determines
// we running on at least 4.3.0
if (isset ($this->_proxy_host )) {
return PEAR ::raiseError ('HTTPS proxies are not supported.');
$host = 'ssl://' . $host;
// magic quotes may fuck up file uploads and chunked response processing
$magicQuotes = ini_get('magic_quotes_runtime');
ini_set('magic_quotes_runtime', false );
// If this is a second request, we may get away without
// re-connecting if they're on the same server
$err = $this->_sock ->connect ($host, $port, null , $this->_timeout , $this->_socketOptions );
PEAR ::isError ($err) or $err = $this->_sock ->write ($this->_buildRequest ());
if (!PEAR ::isError ($err)) {
if (!empty ($this->_readTimeout )) {
$this->_sock ->setTimeout ($this->_readTimeout [0 ], $this->_readTimeout [1 ]);
$this->_notify ('sentRequest');
$this->_response = &new HTTP_Response ($this->_sock , $this->_listeners );
$err = $this->_response ->process ($this->_saveBody && $saveBody);
ini_set('magic_quotes_runtime', $magicQuotes);
if (PEAR ::isError ($err)) {
if ( $this->_allowRedirects
AND $this->_redirects <= $this->_maxRedirects
AND $this->getResponseCode () > 300
AND $this->getResponseCode () < 399
AND !empty ($this->_response ->_headers ['location'])) {
$redirect = $this->_response ->_headers ['location'];
$this->_url = &new Net_URL ($redirect);
$this->addHeader ('Host', $this->_generateHostHeader ());
} elseif ($redirect{0 } == '/') {
$this->_url ->path = $redirect;
} elseif (substr($redirect, 0 , 3 ) == '../' OR substr($redirect, 0 , 2 ) == './') {
if (substr($this->_url ->path , -1 ) == '/') {
$redirect = $this->_url ->path . $redirect;
$redirect = dirname($this->_url ->path ) . '/' . $redirect;
$redirect = Net_URL ::resolvePath ($redirect);
$this->_url ->path = $redirect;
if (substr($this->_url ->path , -1 ) == '/') {
$redirect = $this->_url ->path . $redirect;
$redirect = dirname($this->_url ->path ) . '/' . $redirect;
$this->_url ->path = $redirect;
return $this->sendRequest ($saveBody);
} elseif ($this->_allowRedirects AND $this->_redirects > $this->_maxRedirects ) {
return PEAR ::raiseError ('Too many redirects');
$this->_sock ->disconnect ();
* Returns the response code
* @return mixed Response code, false if not set
function getResponseCode ()
return isset ($this->_response ->_code ) ? $this->_response ->_code : false;
* Returns either the named header or all if no name given
* @param string The header name to return, do not set to get all headers
* @return mixed either the value of $headername (false if header is not present)
* or an array of all headers
function getResponseHeader ($headername = null )
if (!isset ($headername)) {
return isset ($this->_response ->_headers )? $this->_response ->_headers: array ();
return isset ($this->_response ->_headers [$headername]) ? $this->_response ->_headers [$headername] : false;
* Returns the body of the response
* @return mixed response body, false if not set
function getResponseBody ()
return isset ($this->_response ->_body ) ? $this->_response ->_body : false;
* Returns cookies set in response
* @return mixed array of response cookies, false if none are present
function getResponseCookies ()
return isset ($this->_response ->_cookies ) ? $this->_response ->_cookies : false;
* Builds the request string
* @return string The request string
$separator = ini_get('arg_separator.output');
ini_set('arg_separator.output', '&');
$querystring = ($querystring = $this->_url ->getQueryString ()) ? '?' . $querystring : '';
ini_set('arg_separator.output', $separator);
$host = isset ($this->_proxy_host ) ? $this->_url ->protocol . '://' . $this->_url ->host : '';
$port = (isset ($this->_proxy_host ) AND $this->_url ->port != 80 ) ? ':' . $this->_url ->port : '';
$path = (empty ($this->_url ->path )? '/': $this->_url ->path ) . $querystring;
$url = $host . $port . $path;
$request = $this->_method . ' ' . $url . ' HTTP/' . $this->_http . "\r\n";
if (in_array($this->_method , $this->_bodyDisallowed ) ||
$this->removeHeader ('Content-Type');
if (empty ($this->_requestHeaders ['content-type'])) {
// Add default content-type
$this->addHeader ('Content-Type', 'application/x-www-form-urlencoded');
} elseif ('multipart/form-data' == $this->_requestHeaders ['content-type']) {
$this->addHeader ('Content-Type', 'multipart/form-data; boundary=' . $boundary);
if (!empty ($this->_requestHeaders )) {
foreach ($this->_requestHeaders as $name => $value) {
$request .= $canonicalName . ': ' . $value . "\r\n";
// No post data or wrong method, so simply add a final CRLF
if (in_array($this->_method , $this->_bodyDisallowed ) ||
// Post data if it's an array
(!empty ($this->_postData ) || !empty ($this->_postFiles ))) {
$this->_flattenArray ('', $this->_postData )
// multipart request, probably with file uploads
if (!empty ($this->_postData )) {
$flatData = $this->_flattenArray ('', $this->_postData );
foreach ($flatData as $item) {
$postdata .= '--' . $boundary . "\r\n";
$postdata .= 'Content-Disposition: form-data; name="' . $item[0 ] . '"';
$postdata .= "\r\n\r\n" . urldecode($item[1 ]) . "\r\n";
foreach ($this->_postFiles as $name => $value) {
$varname = $name . ($this->_useBrackets? '[]': '');
$value['name'] = array ($value['name']);
foreach ($value['name'] as $key => $filename) {
$fp = fopen($filename, 'r');
$type = is_array($value['type'])? @$value['type'][$key]: $value['type'];
$postdata .= '--' . $boundary . "\r\n";
$postdata .= 'Content-Disposition: form-data; name="' . $varname . '"; filename="' . $basename . '"';
$postdata .= "\r\nContent-Type: " . $type;
$postdata .= "\r\n\r\n" . $data . "\r\n";
$postdata .= '--' . $boundary . "--\r\n";
$request .= 'Content-Length: ' . strlen($postdata) . "\r\n\r\n";
// Explicitly set request body
} elseif (!empty ($this->_body )) {
$request .= 'Content-Length: ' . strlen($this->_body ) . "\r\n\r\n";
$request .= $this->_body;
* Helper function to change the (probably multidimensional) associative array
* @param string name for item
* @param mixed item's values
* @return array array with the following items: array('item name', 'item value');
function _flattenArray ($name, $values)
return array (array ($name, $values));
foreach ($values as $k => $v) {
} elseif ($this->_useBrackets ) {
$newName = $name . '[' . $k . ']';
$ret = array_merge($ret, $this->_flattenArray ($newName, $v));
* Adds a Listener to the list of listeners that are notified of
* @param object HTTP_Request_Listener instance to attach
* @return boolean whether the listener was successfully attached
function attach (&$listener)
if (!is_a($listener, 'HTTP_Request_Listener')) {
$this->_listeners [$listener->getId ()] = & $listener;
* Removes a Listener from the list of listeners
* @param object HTTP_Request_Listener instance to detach
* @return boolean whether the listener was successfully detached
function detach (&$listener)
if (!is_a($listener, 'HTTP_Request_Listener') ||
!isset ($this->_listeners [$listener->getId ()])) {
unset ($this->_listeners [$listener->getId ()]);
* Notifies all registered listeners of an event.
* Events sent by HTTP_Request object
* 'sentRequest': after the request was sent
* Events sent by HTTP_Response object
* 'gotHeaders': after receiving response headers (headers are passed in $data)
* 'tick': on receiving a part of response body (the part is passed in $data)
* 'gzTick': on receiving a gzip-encoded part of response body (ditto)
* 'gotBody': after receiving the response body (passes the decoded body in $data if it was gzipped)
* @param string Event name
* @param mixed Additional data
function _notify ($event, $data = null )
$this->_listeners [$id]->update ($this, $event, $data);
* Response class to complement the Request class
* Cookies set in response
* Used by _readChunked(): remaining length of the current chunk
var $_listeners = array ();
* @param object Net_Socket socket to read the response from
* @param array listeners attached to request
* @return mixed PEAR Error on error, true otherwise
function HTTP_Response (&$sock, &$listeners)
$this->_listeners = & $listeners;
* Processes a HTTP response
* This extracts response code, headers, cookies and decodes body if it
* was encoded in some way
* @param bool Whether to store response body in object property, set
* this to false if downloading a LARGE file and using a Listener.
* This is assumed to be true if body is gzip-encoded.
* @return mixed true on success, PEAR_Error in case of malformed response
function process ($saveBody = true )
$line = $this->_sock->readLine ();
if (sscanf($line, 'HTTP/%s %s', $http_version, $returncode) != 2 ) {
return PEAR ::raiseError ('Malformed response.');
$this->_protocol = 'HTTP/' . $http_version;
$this->_code = intval($returncode);
while ('' !== ($header = $this->_sock->readLine ())) {
$this->_processHeader ($header);
} while (100 == $this->_code);
$this->_notify ('gotHeaders', $this->_headers);
// If response body is present, read it and decode
$chunked = isset ($this->_headers['transfer-encoding']) && ('chunked' == $this->_headers['transfer-encoding']);
$gzipped = isset ($this->_headers['content-encoding']) && ('gzip' == $this->_headers['content-encoding']);
if (!isset ($this->_headers['content-length']) || 0 != $this->_headers['content-length']) {
while (!$this->_sock->eof ()) {
$data = $this->_readChunked ();
$data = $this->_sock->read (4096 );
if ($saveBody || $gzipped) {
$this->_notify ($gzipped? 'gzTick': 'tick', $data);
// Uncompress the body if needed
$this->_notify ('gotBody', $this->_body);
$this->_notify ('gotBody');
* Processes the response header
* @param string HTTP header
function _processHeader ($header)
list ($headername, $headervalue) = explode(':', $header, 2 );
$headervalue = ltrim($headervalue);
if ('set-cookie' != $headername) {
if (isset ($this->_headers[$headername])) {
$this->_headers[$headername] .= ',' . $headervalue;
$this->_headers[$headername] = $headervalue;
$this->_parseCookie ($headervalue);
* Parse a Set-Cookie header to fill $_cookies array
* @param string value of Set-Cookie header
function _parseCookie ($headervalue)
// Only a name=value pair
if (!strpos($headervalue, ';')) {
$pos = strpos($headervalue, '=');
$cookie['name'] = trim(substr($headervalue, 0 , $pos));
$cookie['value'] = trim(substr($headervalue, $pos + 1 ));
// Some optional parameters are supplied
$elements = explode(';', $headervalue);
$pos = strpos($elements[0 ], '=');
$cookie['name'] = trim(substr($elements[0 ], 0 , $pos));
$cookie['value'] = trim(substr($elements[0 ], $pos + 1 ));
for ($i = 1; $i < count($elements); $i++ ) {
if (false === strpos($elements[$i], '=')) {
$elName = trim($elements[$i]);
if ('secure' == $elName) {
$cookie['secure'] = true;
} elseif ('expires' == $elName) {
} elseif ('path' == $elName || 'domain' == $elName) {
$cookie[$elName] = $elValue;
$this->_cookies[] = $cookie;
* Read a part of response body encoded with chunked Transfer-Encoding
// at start of the next chunk?
if (0 == $this->_chunkLength) {
$line = $this->_sock->readLine ();
if (preg_match('/^([0-9a-f]+)/i', $line, $matches)) {
$this->_chunkLength = hexdec($matches[1 ]);
// Chunk with zero length indicates the end
if (0 == $this->_chunkLength) {
$this->_sock->readLine (); // make this an eof()
$data = $this->_sock->read ($this->_chunkLength);
$this->_chunkLength -= strlen($data);
if (0 == $this->_chunkLength) {
$this->_sock->readLine (); // Trailing CRLF
* Notifies all registered listeners of an event.
* @param string Event name
* @param mixed Additional data
* @see HTTP_Request::_notify()
function _notify ($event, $data = null )
$this->_listeners[$id]->update ($this, $event, $data);
} // End class HTTP_Response
Documentation generated on Mon, 11 Mar 2019 14:10:29 -0400 by phpDocumentor 1.4.4. PEAR Logo Copyright © PHP Group 2004.
|