| <?php |
| |
| /** |
| * Zend Framework |
| * |
| * LICENSE |
| * |
| * This source file is subject to the new BSD license that is bundled |
| * with this package in the file LICENSE.txt. |
| * It is also available through the world-wide-web at this URL: |
| * http://framework.zend.com/license/new-bsd |
| * If you did not receive a copy of the license and are unable to |
| * obtain it through the world-wide-web, please send an email |
| * to license@zend.com so we can send you a copy immediately. |
| * |
| * @category Zend |
| * @package Zend_Http |
| * @subpackage Client |
| * @version $Id: Client.php 8064 2008-02-16 10:58:39Z thomas $ |
| * @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com) |
| * @license http://framework.zend.com/license/new-bsd New BSD License |
| */ |
| |
| require_once 'external/Zend/Loader.php'; |
| require_once 'external/Zend/Uri.php'; |
| require_once 'external/Zend/Http/Client/Adapter/Interface.php'; |
| require_once 'external/Zend/Http/Response.php'; |
| |
| /** |
| * Zend_Http_Client is an implemetation of an HTTP client in PHP. The client |
| * supports basic features like sending different HTTP requests and handling |
| * redirections, as well as more advanced features like proxy settings, HTTP |
| * authentication and cookie persistance (using a Zend_Http_CookieJar object) |
| * |
| * @todo Implement proxy settings |
| * @category Zend |
| * @package Zend_Http |
| * @subpackage Client |
| * @throws Zend_Http_Client_Exception |
| * @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com) |
| * @license http://framework.zend.com/license/new-bsd New BSD License |
| */ |
| class Zend_Http_Client { |
| /** |
| * HTTP request methods |
| */ |
| const GET = 'GET'; |
| const POST = 'POST'; |
| const PUT = 'PUT'; |
| const HEAD = 'HEAD'; |
| const DELETE = 'DELETE'; |
| const TRACE = 'TRACE'; |
| const OPTIONS = 'OPTIONS'; |
| const CONNECT = 'CONNECT'; |
| |
| /** |
| * Supported HTTP Authentication methods |
| */ |
| const AUTH_BASIC = 'basic'; |
| //const AUTH_DIGEST = 'digest'; <-- not implemented yet |
| |
| |
| /** |
| * HTTP protocol versions |
| */ |
| const HTTP_1 = '1.1'; |
| const HTTP_0 = '1.0'; |
| |
| /** |
| * POST data encoding methods |
| */ |
| const ENC_URLENCODED = 'application/x-www-form-urlencoded'; |
| const ENC_FORMDATA = 'multipart/form-data'; |
| |
| /** |
| * Configuration array, set using the constructor or using ::setConfig() |
| * |
| * @var unknown_type |
| */ |
| protected $config = array('maxredirects' => 5, 'strictredirects' => false, |
| 'useragent' => 'Zend_Http_Client', 'timeout' => 10, |
| 'adapter' => 'Zend_Http_Client_Adapter_Socket', 'httpversion' => self::HTTP_1, |
| 'keepalive' => false, 'storeresponse' => true, 'strict' => true); |
| |
| /** |
| * The adapter used to preform the actual connection to the server |
| * |
| * @var Zend_Http_Client_Adapter_Interface |
| */ |
| protected $adapter = null; |
| |
| /** |
| * Request URI |
| * |
| * @var Zend_Uri_Http |
| */ |
| protected $uri; |
| |
| /** |
| * Associative array of request headers |
| * |
| * @var array |
| */ |
| protected $headers = array(); |
| |
| /** |
| * HTTP request method |
| * |
| * @var string |
| */ |
| protected $method = self::GET; |
| |
| /** |
| * Associative array of GET parameters |
| * |
| * @var array |
| */ |
| protected $paramsGet = array(); |
| |
| /** |
| * Assiciative array of POST parameters |
| * |
| * @var array |
| */ |
| protected $paramsPost = array(); |
| |
| /** |
| * Request body content type (for POST requests) |
| * |
| * @var string |
| */ |
| protected $enctype = null; |
| |
| /** |
| * The raw post data to send. Could be set by setRawData($data, $enctype). |
| * |
| * @var string |
| */ |
| protected $raw_post_data = null; |
| |
| /** |
| * HTTP Authentication settings |
| * |
| * Expected to be an associative array with this structure: |
| * $this->auth = array('user' => 'username', 'password' => 'password', 'type' => 'basic') |
| * Where 'type' should be one of the supported authentication types (see the AUTH_* |
| * constants), for example 'basic' or 'digest'. |
| * |
| * If null, no authentication will be used. |
| * |
| * @var array|null |
| */ |
| protected $auth; |
| |
| /** |
| * File upload arrays (used in POST requests) |
| * |
| * An associative array, where each element is of the format: |
| * 'name' => array('filename.txt', 'text/plain', 'This is the actual file contents') |
| * |
| * @var array |
| */ |
| protected $files = array(); |
| |
| /** |
| * The client's cookie jar |
| * |
| * @var Zend_Http_CookieJar |
| */ |
| protected $cookiejar = null; |
| |
| /** |
| * The last HTTP request sent by the client, as string |
| * |
| * @var string |
| */ |
| protected $last_request = null; |
| |
| /** |
| * The last HTTP response received by the client |
| * |
| * @var Zend_Http_Response |
| */ |
| protected $last_response = null; |
| |
| /** |
| * Redirection counter |
| * |
| * @var int |
| */ |
| protected $redirectCounter = 0; |
| |
| /** |
| * Contructor method. Will create a new HTTP client. Accepts the target |
| * URL and optionally and array of headers. |
| * |
| * @param Zend_Uri_Http|string $uri |
| * @param array $headers Optional request headers to set |
| */ |
| public function __construct($uri = null, $config = null) { |
| if ($uri !== null) $this->setUri($uri); |
| if ($config !== null) $this->setConfig($config); |
| } |
| |
| /** |
| * Set the URI for the next request |
| * |
| * @param Zend_Uri_Http|string $uri |
| * @return Zend_Http_Client |
| * @throws Zend_Http_Client_Exception |
| */ |
| public function setUri($uri) { |
| if (is_string($uri)) { |
| $uri = Zend_Uri::factory($uri); |
| } |
| |
| if (! $uri instanceof Zend_Uri_Http) { |
| require_once 'external/Zend/Http/Client/Exception.php'; |
| throw new Zend_Http_Client_Exception('Passed parameter is not a valid HTTP URI.'); |
| } |
| |
| // We have no ports, set the defaults |
| if (! $uri->getPort()) { |
| $uri->setPort(($uri->getScheme() == 'https' ? 443 : 80)); |
| } |
| |
| $this->uri = $uri; |
| |
| return $this; |
| } |
| |
| /** |
| * Get the URI for the next request |
| * |
| * @param boolean $as_string If true, will return the URI as a string |
| * @return Zend_Uri_Http|string |
| */ |
| public function getUri($as_string = false) { |
| if ($as_string && $this->uri instanceof Zend_Uri_Http) { |
| return $this->uri->__toString(); |
| } else { |
| return $this->uri; |
| } |
| } |
| |
| /** |
| * Set configuration parameters for this HTTP client |
| * |
| * @param array $config |
| * @return Zend_Http_Client |
| */ |
| public function setConfig($config = array()) { |
| if (! is_array($config)) { |
| require_once 'external/Zend/Http/Client/Exception.php'; |
| throw new Zend_Http_Client_Exception('Expected array parameter, given ' . gettype($config)); |
| } |
| |
| foreach ($config as $k => $v) |
| $this->config[strtolower($k)] = $v; |
| |
| return $this; |
| } |
| |
| /** |
| * Set the next request's method |
| * |
| * Validated the passed method and sets it. If we have files set for |
| * POST requests, and the new method is not POST, the files are silently |
| * dropped. |
| * |
| * @param string $method |
| * @return Zend_Http_Client |
| */ |
| public function setMethod($method = self::GET) { |
| if (! preg_match('/^[A-Za-z_]+$/', $method)) { |
| require_once 'external/Zend/Http/Client/Exception.php'; |
| throw new Zend_Http_Client_Exception("'{$method}' is not a valid HTTP request method."); |
| } |
| |
| if ($method == self::POST && $this->enctype === null) $this->setEncType(self::ENC_URLENCODED); |
| |
| $this->method = $method; |
| |
| return $this; |
| } |
| |
| /** |
| * Set one or more request headers |
| * |
| * This function can be used in several ways to set the client's request |
| * headers: |
| * 1. By providing two parameters: $name as the header to set (eg. 'Host') |
| * and $value as it's value (eg. 'www.example.com'). |
| * 2. By providing a single header string as the only parameter |
| * eg. 'Host: www.example.com' |
| * 3. By providing an array of headers as the first parameter |
| * eg. array('host' => 'www.example.com', 'x-foo: bar'). In This case |
| * the function will call itself recursively for each array item. |
| * |
| * @param string|array $name Header name, full header string ('Header: value') |
| * or an array of headers |
| * @param mixed $value Header value or null |
| * @return Zend_Http_Client |
| */ |
| public function setHeaders($name, $value = null) { |
| // If we got an array, go recusive! |
| if (is_array($name)) { |
| foreach ($name as $k => $v) { |
| if (is_string($k)) { |
| $this->setHeaders($k, $v); |
| } else { |
| $this->setHeaders($v, null); |
| } |
| } |
| } else { |
| // Check if $name needs to be split |
| if ($value === null && (strpos($name, ':') > 0)) list($name, $value) = explode(':', $name, 2); |
| |
| // Make sure the name is valid if we are in strict mode |
| if ($this->config['strict'] && (! preg_match('/^[a-zA-Z0-9-]+$/', $name))) { |
| require_once 'external/Zend/Http/Client/Exception.php'; |
| throw new Zend_Http_Client_Exception("{$name} is not a valid HTTP header name"); |
| } |
| |
| $normalized_name = strtolower($name); |
| |
| // If $value is null or false, unset the header |
| if ($value === null || $value === false) { |
| unset($this->headers[$normalized_name]); |
| |
| // Else, set the header |
| } else { |
| // Header names are storred lowercase internally. |
| if (is_string($value)) $value = trim($value); |
| $this->headers[$normalized_name] = array($name, $value); |
| } |
| } |
| |
| return $this; |
| } |
| |
| /** |
| * Get the value of a specific header |
| * |
| * Note that if the header has more than one value, an array |
| * will be returned. |
| * |
| * @param unknown_type $key |
| * @return string|array|null The header value or null if it is not set |
| */ |
| public function getHeader($key) { |
| $key = strtolower($key); |
| if (isset($this->headers[$key])) { |
| return $this->headers[$key][1]; |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Set a GET parameter for the request. Wrapper around _setParameter |
| * |
| * @param string|array $name |
| * @param string $value |
| * @return Zend_Http_Client |
| */ |
| public function setParameterGet($name, $value = null) { |
| if (is_array($name)) { |
| foreach ($name as $k => $v) |
| $this->_setParameter('GET', $k, $v); |
| } else { |
| $this->_setParameter('GET', $name, $value); |
| } |
| |
| return $this; |
| } |
| |
| /** |
| * Set a POST parameter for the request. Wrapper around _setParameter |
| * |
| * @param string|array $name |
| * @param string $value |
| * @return Zend_Http_Client |
| */ |
| public function setParameterPost($name, $value = null) { |
| if (is_array($name)) { |
| foreach ($name as $k => $v) |
| $this->_setParameter('POST', $k, $v); |
| } else { |
| $this->_setParameter('POST', $name, $value); |
| } |
| |
| return $this; |
| } |
| |
| /** |
| * Set a GET or POST parameter - used by SetParameterGet and SetParameterPost |
| * |
| * @param string $type GET or POST |
| * @param string $name |
| * @param string $value |
| */ |
| protected function _setParameter($type, $name, $value) { |
| $parray = array(); |
| $type = strtolower($type); |
| switch ($type) { |
| case 'get': |
| $parray = &$this->paramsGet; |
| break; |
| case 'post': |
| $parray = &$this->paramsPost; |
| break; |
| } |
| |
| if ($value === null) { |
| if (isset($parray[$name])) unset($parray[$name]); |
| } else { |
| $parray[$name] = $value; |
| } |
| } |
| |
| /** |
| * Get the number of redirections done on the last request |
| * |
| * @return int |
| */ |
| public function getRedirectionsCount() { |
| return $this->redirectCounter; |
| } |
| |
| /** |
| * Set HTTP authentication parameters |
| * |
| * $type should be one of the supported types - see the self::AUTH_* |
| * constants. |
| * |
| * To enable authentication: |
| * <code> |
| * $this->setAuth('shahar', 'secret', Zend_Http_Client::AUTH_BASIC); |
| * </code> |
| * |
| * To disable authentication: |
| * <code> |
| * $this->setAuth(false); |
| * </code> |
| * |
| * @see http://www.faqs.org/rfcs/rfc2617.html |
| * @param string|false $user User name or false disable authentication |
| * @param string $password Password |
| * @param string $type Authentication type |
| * @return Zend_Http_Client |
| */ |
| public function setAuth($user, $password = '', $type = self::AUTH_BASIC) { |
| // If we got false or null, disable authentication |
| if ($user === false || $user === null) { |
| $this->auth = null; |
| |
| // Else, set up authentication |
| } else { |
| // Check we got a proper authentication type |
| if (! defined('self::AUTH_' . strtoupper($type))) { |
| require_once 'external/Zend/Http/Client/Exception.php'; |
| throw new Zend_Http_Client_Exception("Invalid or not supported authentication type: '$type'"); |
| } |
| |
| $this->auth = array('user' => (string)$user, 'password' => (string)$password, |
| 'type' => $type); |
| } |
| |
| return $this; |
| } |
| |
| /** |
| * Set the HTTP client's cookie jar. |
| * |
| * A cookie jar is an object that holds and maintains cookies across HTTP requests |
| * and responses. |
| * |
| * @param Zend_Http_CookieJar|boolean $cookiejar Existing cookiejar object, true to create a new one, false to disable |
| * @return Zend_Http_Client |
| */ |
| public function setCookieJar($cookiejar = true) { |
| if (! class_exists('Zend_Http_CookieJar')) require_once 'external/Zend/Http/CookieJar.php'; |
| |
| if ($cookiejar instanceof Zend_Http_CookieJar) { |
| $this->cookiejar = $cookiejar; |
| } elseif ($cookiejar === true) { |
| $this->cookiejar = new Zend_Http_CookieJar(); |
| } elseif (! $cookiejar) { |
| $this->cookiejar = null; |
| } else { |
| require_once 'external/Zend/Http/Client/Exception.php'; |
| throw new Zend_Http_Client_Exception('Invalid parameter type passed as CookieJar'); |
| } |
| |
| return $this; |
| } |
| |
| /** |
| * Return the current cookie jar or null if none. |
| * |
| * @return Zend_Http_CookieJar|null |
| */ |
| public function getCookieJar() { |
| return $this->cookiejar; |
| } |
| |
| /** |
| * Add a cookie to the request. If the client has no Cookie Jar, the cookies |
| * will be added directly to the headers array as "Cookie" headers. |
| * |
| * @param Zend_Http_Cookie|string $cookie |
| * @param string|null $value If "cookie" is a string, this is the cookie value. |
| * @return Zend_Http_Client |
| */ |
| public function setCookie($cookie, $value = null) { |
| if (! class_exists('Zend_Http_Cookie')) require_once 'external/Zend/Http/Cookie.php'; |
| |
| if (is_array($cookie)) { |
| foreach ($cookie as $c => $v) { |
| if (is_string($c)) { |
| $this->setCookie($c, $v); |
| } else { |
| $this->setCookie($v); |
| } |
| } |
| |
| return $this; |
| } |
| |
| if ($value !== null) $value = urlencode($value); |
| |
| if (isset($this->cookiejar)) { |
| if ($cookie instanceof Zend_Http_Cookie) { |
| $this->cookiejar->addCookie($cookie); |
| } elseif (is_string($cookie) && $value !== null) { |
| $cookie = Zend_Http_Cookie::fromString("{$cookie}={$value}", $this->uri); |
| $this->cookiejar->addCookie($cookie); |
| } |
| } else { |
| if ($cookie instanceof Zend_Http_Cookie) { |
| $name = $cookie->getName(); |
| $value = $cookie->getValue(); |
| $cookie = $name; |
| } |
| |
| if (preg_match("/[=,; \t\r\n\013\014]/", $cookie)) { |
| require_once 'external/Zend/Http/Client/Exception.php'; |
| throw new Zend_Http_Client_Exception("Cookie name cannot contain these characters: =,; \t\r\n\013\014 ({$cookie})"); |
| } |
| |
| $value = addslashes($value); |
| |
| if (! isset($this->headers['cookie'])) $this->headers['cookie'] = array('Cookie', ''); |
| $this->headers['cookie'][1] .= $cookie . '=' . $value . '; '; |
| } |
| |
| return $this; |
| } |
| |
| /** |
| * Set a file to upload (using a POST request) |
| * |
| * Can be used in two ways: |
| * |
| * 1. $data is null (default): $filename is treated as the name if a local file which |
| * will be read and sent. Will try to guess the content type using mime_content_type(). |
| * 2. $data is set - $filename is sent as the file name, but $data is sent as the file |
| * contents and no file is read from the file system. In this case, you need to |
| * manually set the content-type ($ctype) or it will default to |
| * application/octet-stream. |
| * |
| * @param string $filename Name of file to upload, or name to save as |
| * @param string $formname Name of form element to send as |
| * @param string $data Data to send (if null, $filename is read and sent) |
| * @param string $ctype Content type to use (if $data is set and $ctype is |
| * null, will be application/octet-stream) |
| * @return Zend_Http_Client |
| */ |
| public function setFileUpload($filename, $formname, $data = null, $ctype = null) { |
| if ($data === null) { |
| if (($data = @file_get_contents($filename)) === false) { |
| require_once 'external/Zend/Http/Client/Exception.php'; |
| throw new Zend_Http_Client_Exception("Unable to read file '{$filename}' for upload"); |
| } |
| |
| if (! $ctype && function_exists('mime_content_type')) $ctype = mime_content_type($filename); |
| } |
| |
| // Force enctype to multipart/form-data |
| $this->setEncType(self::ENC_FORMDATA); |
| |
| if ($ctype === null) $ctype = 'application/octet-stream'; |
| $this->files[$formname] = array(basename($filename), $ctype, $data); |
| |
| return $this; |
| } |
| |
| /** |
| * Set the encoding type for POST data |
| * |
| * @param string $enctype |
| * @return Zend_Http_Client |
| */ |
| public function setEncType($enctype = self::ENC_URLENCODED) { |
| $this->enctype = $enctype; |
| |
| return $this; |
| } |
| |
| /** |
| * Set the raw (already encoded) POST data. |
| * |
| * This function is here for two reasons: |
| * 1. For advanced user who would like to set their own data, already encoded |
| * 2. For backwards compatibilty: If someone uses the old post($data) method. |
| * this method will be used to set the encoded data. |
| * |
| * @param string $data |
| * @param string $enctype |
| * @return Zend_Http_Client |
| */ |
| public function setRawData($data, $enctype = null) { |
| $this->raw_post_data = $data; |
| $this->setEncType($enctype); |
| |
| return $this; |
| } |
| |
| /** |
| * Clear all GET and POST parameters |
| * |
| * Should be used to reset the request parameters if the client is |
| * used for several concurrent requests. |
| * |
| * @return Zend_Http_Client |
| */ |
| public function resetParameters() { |
| // Reset parameter data |
| $this->paramsGet = array(); |
| $this->paramsPost = array(); |
| $this->files = array(); |
| $this->raw_post_data = null; |
| |
| // Clear outdated headers |
| if (isset($this->headers['content-type'])) unset($this->headers['content-type']); |
| if (isset($this->headers['content-length'])) unset($this->headers['content-length']); |
| |
| return $this; |
| } |
| |
| /** |
| * Get the last HTTP request as string |
| * |
| * @return string |
| */ |
| public function getLastRequest() { |
| return $this->last_request; |
| } |
| |
| /** |
| * Get the last HTTP response received by this client |
| * |
| * If $config['storeresponse'] is set to false, or no response was |
| * stored yet, will return null |
| * |
| * @return Zend_Http_Response or null if none |
| */ |
| public function getLastResponse() { |
| return $this->last_response; |
| } |
| |
| /** |
| * Load the connection adapter |
| * |
| * While this method is not called more than one for a client, it is |
| * seperated from ->request() to preserve logic and readability |
| * |
| * @param Zend_Http_Client_Adapter_Interface|string $adapter |
| */ |
| public function setAdapter($adapter) { |
| if (is_string($adapter)) { |
| try { |
| Zend_Loader::loadClass($adapter); |
| } catch (Zend_Exception $e) { |
| require_once 'external/Zend/Http/Client/Exception.php'; |
| throw new Zend_Http_Client_Exception("Unable to load adapter '$adapter': {$e->getMessage()}"); |
| } |
| |
| $adapter = new $adapter(); |
| } |
| |
| if (! $adapter instanceof Zend_Http_Client_Adapter_Interface) { |
| require_once 'external/Zend/Http/Client/Exception.php'; |
| throw new Zend_Http_Client_Exception('Passed adapter is not a HTTP connection adapter'); |
| } |
| |
| $this->adapter = $adapter; |
| $config = $this->config; |
| unset($config['adapter']); |
| $this->adapter->setConfig($config); |
| } |
| |
| /** |
| * Send the HTTP request and return an HTTP response object |
| * |
| * @param string $method |
| * @return Zend_Http_Response |
| */ |
| public function request($method = null) { |
| if (! $this->uri instanceof Zend_Uri_Http) { |
| require_once 'external/Zend/Http/Client/Exception.php'; |
| throw new Zend_Http_Client_Exception('No valid URI has been passed to the client'); |
| } |
| |
| if ($method) $this->setMethod($method); |
| $this->redirectCounter = 0; |
| $response = null; |
| |
| // Make sure the adapter is loaded |
| if ($this->adapter == null) $this->setAdapter($this->config['adapter']); |
| |
| // Send the first request. If redirected, continue. |
| do { |
| // Clone the URI and add the additional GET parameters to it |
| $uri = clone $this->uri; |
| if (! empty($this->paramsGet)) { |
| $query = $uri->getQuery(); |
| if (! empty($query)) $query .= '&'; |
| $query .= http_build_query($this->paramsGet, null, '&'); |
| |
| $uri->setQuery($query); |
| } |
| |
| $body = $this->prepare_body(); |
| $headers = $this->prepare_headers(); |
| |
| // Open the connection, send the request and read the response |
| $this->adapter->connect($uri->getHost(), $uri->getPort(), ($uri->getScheme() == 'https' ? true : false)); |
| |
| $this->last_request = $this->adapter->write($this->method, $uri, $this->config['httpversion'], $headers, $body); |
| |
| $response = $this->adapter->read(); |
| if (! $response) { |
| require_once 'external/Zend/Http/Client/Exception.php'; |
| throw new Zend_Http_Client_Exception('Unable to read response, or response is empty'); |
| } |
| |
| $response = Zend_Http_Response::fromString($response); |
| if ($this->config['storeresponse']) $this->last_response = $response; |
| |
| // Load cookies into cookie jar |
| if (isset($this->cookiejar)) $this->cookiejar->addCookiesFromResponse($response, $uri); |
| |
| // If we got redirected, look for the Location header |
| if ($response->isRedirect() && ($location = $response->getHeader('location'))) { |
| |
| // Check whether we send the exact same request again, or drop the parameters |
| // and send a GET request |
| if ($response->getStatus() == 303 || ((! $this->config['strictredirects']) && ($response->getStatus() == 302 || $response->getStatus() == 301))) { |
| |
| $this->resetParameters(); |
| $this->setMethod(self::GET); |
| } |
| |
| // If we got a well formed absolute URI |
| if (Zend_Uri_Http::check($location)) { |
| $this->setHeaders('host', null); |
| $this->setUri($location); |
| |
| } else { |
| |
| // Split into path and query and set the query |
| if (strpos($location, '?') !== false) { |
| list($location, $query) = explode('?', $location, 2); |
| } else { |
| $query = ''; |
| } |
| $this->uri->setQuery($query); |
| |
| // Else, if we got just an absolute path, set it |
| if (strpos($location, '/') === 0) { |
| $this->uri->setPath($location); |
| |
| // Else, assume we have a relative path |
| } else { |
| // Get the current path directory, removing any trailing slashes |
| $path = $this->uri->getPath(); |
| $path = rtrim(substr($path, 0, strrpos($path, '/')), "/"); |
| $this->uri->setPath($path . '/' . $location); |
| } |
| } |
| ++ $this->redirectCounter; |
| |
| } else { |
| // If we didn't get any location, stop redirecting |
| break; |
| } |
| |
| } while ($this->redirectCounter < $this->config['maxredirects']); |
| |
| return $response; |
| } |
| |
| /** |
| * Prepare the request headers |
| * |
| * @return array |
| */ |
| protected function prepare_headers() { |
| $headers = array(); |
| |
| // Set the host header |
| if (! isset($this->headers['host'])) { |
| $host = $this->uri->getHost(); |
| |
| // If the port is not default, add it |
| if (! (($this->uri->getScheme() == 'http' && $this->uri->getPort() == 80) || ($this->uri->getScheme() == 'https' && $this->uri->getPort() == 443))) { |
| $host .= ':' . $this->uri->getPort(); |
| } |
| |
| $headers[] = "Host: {$host}"; |
| } |
| |
| // Set the connection header |
| if (! isset($this->headers['connection'])) { |
| if (! $this->config['keepalive']) $headers[] = "Connection: close"; |
| } |
| |
| // Set the Accept-encoding header if not set - depending on whether |
| // zlib is available or not. |
| if (! isset($this->headers['accept-encoding'])) { |
| if (function_exists('gzinflate')) { |
| $headers[] = 'Accept-encoding: gzip, deflate'; |
| } else { |
| $headers[] = 'Accept-encoding: identity'; |
| } |
| } |
| |
| // Set the content-type header |
| if ($this->method == self::POST && (! isset($this->headers['content-type']) && isset($this->enctype))) { |
| |
| $headers[] = "Content-type: {$this->enctype}"; |
| } |
| |
| // Set the user agent header |
| if (! isset($this->headers['user-agent']) && isset($this->config['useragent'])) { |
| $headers[] = "User-agent: {$this->config['useragent']}"; |
| } |
| |
| // Set HTTP authentication if needed |
| if (is_array($this->auth)) { |
| $auth = self::encodeAuthHeader($this->auth['user'], $this->auth['password'], $this->auth['type']); |
| $headers[] = "Authorization: {$auth}"; |
| } |
| |
| // Load cookies from cookie jar |
| if (isset($this->cookiejar)) { |
| $cookstr = $this->cookiejar->getMatchingCookies($this->uri, true, Zend_Http_CookieJar::COOKIE_STRING_CONCAT); |
| |
| if ($cookstr) $headers[] = "Cookie: {$cookstr}"; |
| } |
| |
| // Add all other user defined headers |
| foreach ($this->headers as $header) { |
| list($name, $value) = $header; |
| if (is_array($value)) $value = implode(', ', $value); |
| |
| $headers[] = "$name: $value"; |
| } |
| |
| return $headers; |
| } |
| |
| /** |
| * Prepare the request body (for POST and PUT requests) |
| * |
| * @return string |
| */ |
| protected function prepare_body() { |
| // According to RFC2616, a TRACE request should not have a body. |
| if ($this->method == self::TRACE) { |
| return ''; |
| } |
| |
| // If we have raw_post_data set, just use it as the body. |
| if (isset($this->raw_post_data)) { |
| $this->setHeaders('Content-length', strlen($this->raw_post_data)); |
| return $this->raw_post_data; |
| } |
| |
| $body = ''; |
| |
| // If we have files to upload, force enctype to multipart/form-data |
| if (count($this->files) > 0) $this->setEncType(self::ENC_FORMDATA); |
| |
| // If we have POST parameters or files, encode and add them to the body |
| if (count($this->paramsPost) > 0 || count($this->files) > 0) { |
| switch ($this->enctype) { |
| case self::ENC_FORMDATA: |
| // Encode body as multipart/form-data |
| $boundary = '---ZENDHTTPCLIENT-' . md5(microtime()); |
| $this->setHeaders('Content-type', self::ENC_FORMDATA . "; boundary={$boundary}"); |
| |
| // Get POST parameters and encode them |
| $params = $this->_getParametersRecursive($this->paramsPost); |
| foreach ($params as $pp) { |
| $body .= self::encodeFormData($boundary, $pp[0], $pp[1]); |
| } |
| |
| // Encode files |
| foreach ($this->files as $name => $file) { |
| $fhead = array('Content-type' => $file[1]); |
| $body .= self::encodeFormData($boundary, $name, $file[2], $file[0], $fhead); |
| } |
| |
| $body .= "--{$boundary}--\r\n"; |
| break; |
| |
| case self::ENC_URLENCODED: |
| // Encode body as application/x-www-form-urlencoded |
| $this->setHeaders('Content-type', self::ENC_URLENCODED); |
| $body = http_build_query($this->paramsPost, '', '&'); |
| break; |
| |
| default: |
| require_once 'external/Zend/Http/Client/Exception.php'; |
| throw new Zend_Http_Client_Exception("Cannot handle content type '{$this->enctype}' automatically." . " Please use Zend_Http_Client::setRawData to send this kind of content."); |
| break; |
| } |
| } |
| |
| if ($body) $this->setHeaders('Content-length', strlen($body)); |
| return $body; |
| } |
| |
| /** |
| * Helper method that gets a possibly multi-level parameters array (get or |
| * post) and flattens it. |
| * |
| * The method returns an array of (key, value) pairs (because keys are not |
| * necessarily unique. If one of the parameters in as array, it will also |
| * add a [] suffix to the key. |
| * |
| * @param array $parray The parameters array |
| * @param bool $urlencode Whether to urlencode the name and value |
| * @return array |
| */ |
| protected function _getParametersRecursive($parray, $urlencode = false) { |
| if (! is_array($parray)) return $parray; |
| $parameters = array(); |
| |
| foreach ($parray as $name => $value) { |
| if ($urlencode) $name = urlencode($name); |
| |
| // If $value is an array, iterate over it |
| if (is_array($value)) { |
| $name .= ($urlencode ? '%5B%5D' : '[]'); |
| foreach ($value as $subval) { |
| if ($urlencode) $subval = urlencode($subval); |
| $parameters[] = array($name, $subval); |
| } |
| } else { |
| if ($urlencode) $value = urlencode($value); |
| $parameters[] = array($name, $value); |
| } |
| } |
| |
| return $parameters; |
| } |
| |
| /** |
| * Encode data to a multipart/form-data part suitable for a POST request. |
| * |
| * @param string $boundary |
| * @param string $name |
| * @param mixed $value |
| * @param string $filename |
| * @param array $headers Associative array of optional headers @example ("Content-transfer-encoding" => "binary") |
| * @return string |
| */ |
| public static function encodeFormData($boundary, $name, $value, $filename = null, $headers = array()) { |
| $ret = "--{$boundary}\r\n" . 'Content-disposition: form-data; name="' . $name . '"'; |
| |
| if ($filename) $ret .= '; filename="' . $filename . '"'; |
| $ret .= "\r\n"; |
| |
| foreach ($headers as $hname => $hvalue) { |
| $ret .= "{$hname}: {$hvalue}\r\n"; |
| } |
| $ret .= "\r\n"; |
| |
| $ret .= "{$value}\r\n"; |
| |
| return $ret; |
| } |
| |
| /** |
| * Create a HTTP authentication "Authorization:" header according to the |
| * specified user, password and authentication method. |
| * |
| * @see http://www.faqs.org/rfcs/rfc2617.html |
| * @param string $user |
| * @param string $password |
| * @param string $type |
| * @return string |
| */ |
| public static function encodeAuthHeader($user, $password, $type = self::AUTH_BASIC) { |
| $authHeader = null; |
| |
| switch ($type) { |
| case self::AUTH_BASIC: |
| // In basic authentication, the user name cannot contain ":" |
| if (strpos($user, ':') !== false) { |
| require_once 'external/Zend/Http/Client/Exception.php'; |
| throw new Zend_Http_Client_Exception("The user name cannot contain ':' in 'Basic' HTTP authentication"); |
| } |
| |
| $authHeader = 'Basic ' . base64_encode($user . ':' . $password); |
| break; |
| |
| //case self::AUTH_DIGEST: |
| /** |
| * @todo Implement digest authentication |
| */ |
| // break; |
| |
| |
| default: |
| require_once 'external/Zend/Http/Client/Exception.php'; |
| throw new Zend_Http_Client_Exception("Not a supported HTTP authentication type: '$type'"); |
| } |
| |
| return $authHeader; |
| } |
| } |
