<?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$

* @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)

* @license http://framework.zend.com/license/new-bsd New BSD License

*/

/**

* @see Zend_Loader

*/

require_once 'Zend/Loader.php';

/**

* @see Zend_Uri

*/

require_once 'Zend/Uri.php';

/**

* @see Zend_Http_Client_Adapter_Interface

*/

require_once 'Zend/Http/Client/Adapter/Interface.php';

/**

* @see Zend_Http_Header_HeaderValue

*/

require_once 'Zend/Http/Header/HeaderValue.php';

/**

* @see Zend_Http_Response

*/

require_once 'Zend/Http/Response.php';

/**

* @see Zend_Http_Response_Stream

*/

require_once 'Zend/Http/Response/Stream.php';

/**

* Zend_Http_Client is an implementation 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 persistence (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-2015 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';

const MERGE = 'MERGE';

const PATCH = 'PATCH';

/**

* 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';

/**

* Content attributes

*/

const CONTENT_TYPE = 'Content-Type';

const CONTENT_LENGTH = 'Content-Length';

/**

* POST data encoding methods

*/

const ENC_URLENCODED = 'application/x-www-form-urlencoded';

const ENC_FORMDATA = 'multipart/form-data';

/**

* Value types for Body key/value pairs

*/

const VTYPE_SCALAR = 'SCALAR';

const VTYPE_FILE = 'FILE';

/**

* Configuration array, set using the constructor or using ::setConfig()

*

* @var array

*/

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,

'output_stream' => false,

'encodecookies' => true,

'rfc3986_strict' => false

);

/**

* The adapter used to perform the actual connection to the server

*

* @var Zend_Http_Client_Adapter_Interface

*/

protected $adapter = null;

/**

* Request URI

*

* @var Zend_Uri_Http

*/

protected $uri = null;

/**

* 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();

/**

* Associative 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();

/**

* Ordered list of keys from key/value pair data to include in body

*

* An associative array, where each element is of the format:

* '<field name>' => VTYPE_SCALAR | VTYPE_FILE

*

* @var array

*/

protected $body_field_order = 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;

/**

* Status for unmasking GET array params

*

* @var boolean

*/

protected $_unmaskStatus = false;

/**

* Status if the http_build_query function escapes brackets

*

* @var boolean

*/

protected $_queryBracketsEscaped = true;

/**

* Fileinfo magic database resource

*

* This variable is populated the first time _detectFileMimeType is called

* and is then reused on every call to this method

*

* @var resource

*/

protected static $_fileInfoDb = null;

/**

* Constructor method. Will create a new HTTP client. Accepts the target

* URL and optionally configuration array.

*

* @param Zend_Uri_Http|string $uri

* @param array $config Configuration key-value pairs.

*/

public function __construct($uri = null, $config = null)

{

if ($uri !== null) {

$this->setUri($uri);

}

if ($config !== null) {

$this->setConfig($config);

}

$this->_queryBracketsEscaped = version_compare(phpversion(), '5.1.3', '>=');

}

/**

* 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 ($uri instanceof Zend_Uri_Http) {

// clone the URI in order to keep the passed parameter constant

$uri = clone $uri;

} elseif (is_string($uri)) {

$uri = Zend_Uri::factory($uri);

}

if (!$uri instanceof Zend_Uri_Http) {

/** @see Zend_Http_Client_Exception */

require_once 'Zend/Http/Client/Exception.php';

throw new Zend_Http_Client_Exception('Passed parameter is not a valid HTTP URI.');

}

// Set auth if username and password has been specified in the uri

if ($uri->getUsername() && $uri->getPassword()) {

$this->setAuth($uri->getUsername(), $uri->getPassword());

}

// 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 Zend_Config | array $config

* @return Zend_Http_Client

* @throws Zend_Http_Client_Exception

*/

public function setConfig($config = array())

{

if ($config instanceof Zend_Config) {

$config = $config->toArray();

} elseif (! is_array($config)) {

/** @see Zend_Http_Client_Exception */

require_once 'Zend/Http/Client/Exception.php';

throw new Zend_Http_Client_Exception('Array or Zend_Config object expected, got ' . gettype($config));

}

foreach ($config as $k => $v) {

$this->config[strtolower($k)] = $v;

}

// Pass configuration options to the adapter if it exists

if ($this->adapter instanceof Zend_Http_Client_Adapter_Interface) {

$this->adapter->setConfig($config);

}

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

* @throws Zend_Http_Client_Exception

*/

public function setMethod($method = self::GET)

{

if (! preg_match('/^[^\x00-\x1f\x7f-\xff\(\)<>@,;:\\\\"\/\[\]\?={}\s]+$/', $method)) {

require_once 'Zend/Http/Client/Exception.php';

throw new Zend_Http_Client_Exception("'{$method}' is not a valid HTTP request method.");

}

if (($method == self::POST

|| $method == self::PUT

|| $method == self::DELETE

|| $method == self::PATCH

|| $method == self::OPTIONS)

&& $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 (e.g. 'Host')

* and $value as it's value (e.g. 'www.example.com').

* 2. By providing a single header string as the only parameter

* e.g. 'Host: www.example.com'

* 3. By providing an array of headers as the first parameter

* e.g. 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

* @throws Zend_Http_Client_Exception

*/

public function setHeaders($name, $value = null)

{

// If we got an array, go recursive!

if (is_array($name)) {

foreach ($name as $k => $v) {

if (is_string($k)) {

$this->setHeaders($k, $v);

continue;

}

$this->setHeaders($v, null);

}

return $this;

}

// 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 '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]);

return $this;

}

// Validate value

$this->_validateHeaderValue($value);

// Header names are stored 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 string $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

* @return null

*/

protected function _setParameter($type, $name, $value)

{

$parray = array();

$type = strtolower($type);

switch ($type) {

case 'get':

$parray = &$this->paramsGet;

break;

case 'post':

$parray = &$this->paramsPost;

if ( $value === null ) {

if (isset($this->body_field_order[$name]))

unset($this->body_field_order[$name]);

} else {

$this->body_field_order[$name] = self::VTYPE_SCALAR;

}

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

* @throws Zend_Http_Client_Exception

*/

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;

// Clear the auth information in the uri instance as well

if ($this->uri instanceof Zend_Uri_Http) {

$this->getUri()->setUsername('');

$this->getUri()->setPassword('');

}

// Else, set up authentication

} else {

// Check we got a proper authentication type

if (! defined('self::AUTH_' . strtoupper($type))) {

/** @see Zend_Http_Client_Exception */

require_once '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

* @throws Zend_Http_Client_Exception

*/

public function setCookieJar($cookiejar = true)

{

Zend_Loader::loadClass('Zend_Http_CookieJar');

if ($cookiejar instanceof Zend_Http_CookieJar) {

$this->cookiejar = $cookiejar;

} elseif ($cookiejar === true) {

$this->cookiejar = new Zend_Http_CookieJar();

} elseif (! $cookiejar) {

$this->cookiejar = null;

} else {

/** @see Zend_Http_Client_Exception */

require_once '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

* @throws Zend_Http_Client_Exception

*/

public function setCookie($cookie, $value = null)

{

Zend_Loader::loadClass('Zend_Http_Cookie');

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 && $this->config['encodecookies']) {

$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->config['encodecookies']);

$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)) {

/** @see Zend_Http_Client_Exception */

require_once '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

* @throws Zend_Http_Client_Exception

*/

public function setFileUpload($filename, $formname, $data = null, $ctype = null)

{

if ($data === null) {

if (($data = @file_get_contents($filename)) === false) {

/** @see Zend_Http_Client_Exception */

require_once 'Zend/Http/Client/Exception.php';

throw new Zend_Http_Client_Exception("Unable to read file '{$filename}' for upload");

}

if (! $ctype) {

$ctype = $this->_detectFileMimeType($filename);

}

}

// Force enctype to multipart/form-data

$this->setEncType(self::ENC_FORMDATA);

$this->files[] = array(

'formname' => $formname,

'filename' => basename($filename),

'ctype' => $ctype,

'data' => $data

);

$this->body_field_order[$formname] = self::VTYPE_FILE;

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.

*

* $data can also be stream (such as file) from which the data will be read.

*

* @param string|resource $data

* @param string $enctype

* @return Zend_Http_Client

*/

public function setRawData($data, $enctype = null)

{

$this->raw_post_data = $data;

$this->setEncType($enctype);

if (is_resource($data)) {

// We've got stream data

$stat = @fstat($data);

if($stat) {

$this->setHeaders(self::CONTENT_LENGTH, $stat['size']);

}

}

return $this;

}

/**

* Set the unmask feature for GET parameters as array

*

* Example:

* foo%5B0%5D=a&foo%5B1%5D=b

* becomes

* foo=a&foo=b

*

* This is usefull for some services

*

* @param boolean $status

* @return Zend_Http_Client

*/

public function setUnmaskStatus($status = true)

{

$this->_unmaskStatus = (BOOL)$status;

return $this;

}

/**

* Returns the currently configured unmask status

*

* @return boolean

*/

public function getUnmaskStatus()

{

return $this->_unmaskStatus;

}

/**

* Clear all GET and POST parameters

*

* Should be used to reset the request parameters if the client is

* used for several concurrent requests.

*

* clearAll parameter controls if we clean just parameters or also

* headers and last_*

*

* @param bool $clearAll Should all data be cleared?

* @return Zend_Http_Client

*/

public function resetParameters($clearAll = false)

{

// Reset parameter data

$this->paramsGet = array();

$this->paramsPost = array();

$this->files = array();

$this->raw_post_data = null;

$this->enctype = null;

if($clearAll) {

$this->headers = array();

$this->last_request = null;

$this->last_response = null;

} else {

// Clear outdated headers

if (isset($this->headers[strtolower(self::CONTENT_TYPE)])) {

unset($this->headers[strtolower(self::CONTENT_TYPE)]);

}

if (isset($this->headers[strtolower(self::CONTENT_LENGTH)])) {

unset($this->headers[strtolower(self::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

* @return null

* @throws Zend_Http_Client_Exception

*/

public function setAdapter($adapter)

{

if (is_string($adapter)) {

try {

Zend_Loader::loadClass($adapter);

} catch (Zend_Exception $e) {

/** @see Zend_Http_Client_Exception */

require_once 'Zend/Http/Client/Exception.php';

throw new Zend_Http_Client_Exception("Unable to load adapter '$adapter': {$e->getMessage()}", 0, $e);

}

$adapter = new $adapter;

}

if (! $adapter instanceof Zend_Http_Client_Adapter_Interface) {

/** @see Zend_Http_Client_Exception */

require_once '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);

}

/**

* Load the connection adapter

*

* @return Zend_Http_Client_Adapter_Interface $adapter

*/

public function getAdapter()

{

if (null === $this->adapter) {

$this->setAdapter($this->config['adapter']);

}

return $this->adapter;

}

/**

* Set streaming for received data

*

* @param string|boolean $streamfile Stream file, true for temp file, false/null for no streaming

* @return Zend_Http_Client

*/

public function setStream($streamfile = true)

{

$this->setConfig(array("output_stream" => $streamfile));

return $this;

}

/**

* Get status of streaming for received data

* @return boolean|string

*/

public function getStream()

{

return $this->config["output_stream"];

}

/**

* Create temporary stream

*

* @return resource

*/

protected function _openTempStream()

{

$this->_stream_name = $this->config['output_stream'];

if(!is_string($this->_stream_name)) {

// If name is not given, create temp name

$this->_stream_name = tempnam(isset($this->config['stream_tmp_dir'])?$this->config['stream_tmp_dir']:sys_get_temp_dir(),

'Zend_Http_Client');

}

if (false === ($fp = @fopen($this->_stream_name, "w+b"))) {

if ($this->adapter instanceof Zend_Http_Client_Adapter_Interface) {

$this->adapter->close();