| Current File : /home/k/a/r/karenpetzb/www/items/category/Client.php.tar |
home/karenpetzb/library/Zend/Gdata/Photos/Extension/Client.php 0000604 00000003327 15071325201 0020401 0 ustar 00 <?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_Gdata
* @subpackage Photos
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
/**
* @see Zend_Gdata_Extension
*/
require_once 'Zend/Gdata/Extension.php';
/**
* @see Zend_Gdata_Photos
*/
require_once 'Zend/Gdata/Photos.php';
/**
* Represents the gphoto:client element used by the API.
* This is an optional field that can be used to indicate the
* client which created a photo.
*
* @category Zend
* @package Zend_Gdata
* @subpackage Photos
* @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_Gdata_Photos_Extension_Client extends Zend_Gdata_Extension
{
protected $_rootNamespace = 'gphoto';
protected $_rootElement = 'client';
/**
* Constructs a new Zend_Gdata_Photos_Extension_Client object.
*
* @param string $text (optional) The value to represent.
*/
public function __construct($text = null)
{
$this->registerAllNamespaces(Zend_Gdata_Photos::$namespaces);
parent::__construct();
$this->setText($text);
}
}
home/karenpetzb/library/Zend/XmlRpc/Client.php 0000604 00000023443 15071360216 0015344 0 ustar 00 <?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_XmlRpc
* @subpackage Client
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
/**
* For handling the HTTP connection to the XML-RPC service
* @see Zend_Http_Client
*/
require_once 'Zend/Http/Client.php';
/**
* Enables object chaining for calling namespaced XML-RPC methods.
* @see Zend_XmlRpc_Client_ServerProxy
*/
require_once 'Zend/XmlRpc/Client/ServerProxy.php';
/**
* Introspects remote servers using the XML-RPC de facto system.* methods
* @see Zend_XmlRpc_Client_ServerIntrospection
*/
require_once 'Zend/XmlRpc/Client/ServerIntrospection.php';
/**
* Represent a native XML-RPC value, used both in sending parameters
* to methods and as the parameters retrieve from method calls
* @see Zend_XmlRpc_Value
*/
require_once 'Zend/XmlRpc/Value.php';
/**
* XML-RPC Request
* @see Zend_XmlRpc_Request
*/
require_once 'Zend/XmlRpc/Request.php';
/**
* XML-RPC Response
* @see Zend_XmlRpc_Response
*/
require_once 'Zend/XmlRpc/Response.php';
/**
* XML-RPC Fault
* @see Zend_XmlRpc_Fault
*/
require_once 'Zend/XmlRpc/Fault.php';
/**
* An XML-RPC client implementation
*
* @category Zend
* @package Zend_XmlRpc
* @subpackage Client
* @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_XmlRpc_Client
{
/**
* Full address of the XML-RPC service
* @var string
* @example http://time.xmlrpc.com/RPC2
*/
protected $_serverAddress;
/**
* HTTP Client to use for requests
* @var Zend_Http_Client
*/
protected $_httpClient = null;
/**
* Introspection object
* @var Zend_Http_Client_Introspector
*/
protected $_introspector = null;
/**
* Request of the last method call
* @var Zend_XmlRpc_Request
*/
protected $_lastRequest = null;
/**
* Response received from the last method call
* @var Zend_XmlRpc_Response
*/
protected $_lastResponse = null;
/**
* Proxy object for more convenient method calls
* @var array of Zend_XmlRpc_Client_ServerProxy
*/
protected $_proxyCache = array();
/**
* Flag for skipping system lookup
* @var bool
*/
protected $_skipSystemLookup = false;
/**
* Create a new XML-RPC client to a remote server
*
* @param string $server Full address of the XML-RPC service
* (e.g. http://time.xmlrpc.com/RPC2)
* @param Zend_Http_Client $httpClient HTTP Client to use for requests
* @return void
*/
public function __construct($server, Zend_Http_Client $httpClient = null)
{
if ($httpClient === null) {
$this->_httpClient = new Zend_Http_Client();
} else {
$this->_httpClient = $httpClient;
}
$this->_introspector = new Zend_XmlRpc_Client_ServerIntrospection($this);
$this->_serverAddress = $server;
}
/**
* Sets the HTTP client object to use for connecting the XML-RPC server.
*
* @param Zend_Http_Client $httpClient
* @return Zend_Http_Client
*/
public function setHttpClient(Zend_Http_Client $httpClient)
{
return $this->_httpClient = $httpClient;
}
/**
* Gets the HTTP client object.
*
* @return Zend_Http_Client
*/
public function getHttpClient()
{
return $this->_httpClient;
}
/**
* Sets the object used to introspect remote servers
*
* @param Zend_XmlRpc_Client_ServerIntrospection
* @return Zend_XmlRpc_Client_ServerIntrospection
*/
public function setIntrospector(Zend_XmlRpc_Client_ServerIntrospection $introspector)
{
return $this->_introspector = $introspector;
}
/**
* Gets the introspection object.
*
* @return Zend_XmlRpc_Client_ServerIntrospection
*/
public function getIntrospector()
{
return $this->_introspector;
}
/**
* The request of the last method call
*
* @return Zend_XmlRpc_Request
*/
public function getLastRequest()
{
return $this->_lastRequest;
}
/**
* The response received from the last method call
*
* @return Zend_XmlRpc_Response
*/
public function getLastResponse()
{
return $this->_lastResponse;
}
/**
* Returns a proxy object for more convenient method calls
*
* @param $namespace Namespace to proxy or empty string for none
* @return Zend_XmlRpc_Client_ServerProxy
*/
public function getProxy($namespace = '')
{
if (empty($this->_proxyCache[$namespace])) {
$proxy = new Zend_XmlRpc_Client_ServerProxy($this, $namespace);
$this->_proxyCache[$namespace] = $proxy;
}
return $this->_proxyCache[$namespace];
}
/**
* Set skip system lookup flag
*
* @param bool $flag
* @return Zend_XmlRpc_Client
*/
public function setSkipSystemLookup($flag = true)
{
$this->_skipSystemLookup = (bool) $flag;
return $this;
}
/**
* Skip system lookup when determining if parameter should be array or struct?
*
* @return bool
*/
public function skipSystemLookup()
{
return $this->_skipSystemLookup;
}
/**
* Perform an XML-RPC request and return a response.
*
* @param Zend_XmlRpc_Request $request
* @param null|Zend_XmlRpc_Response $response
* @return void
* @throws Zend_XmlRpc_Client_HttpException
*/
public function doRequest($request, $response = null)
{
$this->_lastRequest = $request;
iconv_set_encoding('input_encoding', 'UTF-8');
iconv_set_encoding('output_encoding', 'UTF-8');
iconv_set_encoding('internal_encoding', 'UTF-8');
$http = $this->getHttpClient();
if($http->getUri() === null) {
$http->setUri($this->_serverAddress);
}
$http->setHeaders(array(
'Content-Type: text/xml; charset=utf-8',
'User-Agent: Zend_XmlRpc_Client',
'Accept: text/xml',
));
$xml = $this->_lastRequest->__toString();
$http->setRawData($xml);
$httpResponse = $http->request(Zend_Http_Client::POST);
if (! $httpResponse->isSuccessful()) {
/**
* Exception thrown when an HTTP error occurs
* @see Zend_XmlRpc_Client_HttpException
*/
require_once 'Zend/XmlRpc/Client/HttpException.php';
throw new Zend_XmlRpc_Client_HttpException(
$httpResponse->getMessage(),
$httpResponse->getStatus());
}
if ($response === null) {
$response = new Zend_XmlRpc_Response();
}
$this->_lastResponse = $response;
$this->_lastResponse->loadXml($httpResponse->getBody());
}
/**
* Send an XML-RPC request to the service (for a specific method)
*
* @param string $method Name of the method we want to call
* @param array $params Array of parameters for the method
* @throws Zend_XmlRpc_Client_FaultException
*/
public function call($method, $params=array())
{
if (!$this->skipSystemLookup() && ('system.' != substr($method, 0, 7))) {
// Ensure empty array/struct params are cast correctly
// If system.* methods are not available, bypass. (ZF-2978)
$success = true;
try {
$signatures = $this->getIntrospector()->getMethodSignature($method);
} catch (Zend_XmlRpc_Exception $e) {
$success = false;
}
if ($success) {
foreach ($params as $key => $param) {
if (is_array($param) && empty($param)) {
$type = 'array';
foreach ($signatures as $signature) {
if (!is_array($signature)) {
continue;
}
if (array_key_exists($key + 1, $signature)) {
$type = $signature[$key + 1];
$type = (in_array($type, array('array', 'struct'))) ? $type : 'array';
break;
}
}
$params[$key] = array(
'type' => $type,
'value' => $param
);
}
}
}
}
$request = new Zend_XmlRpc_Request($method, $params);
$this->doRequest($request);
if ($this->_lastResponse->isFault()) {
$fault = $this->_lastResponse->getFault();
/**
* Exception thrown when an XML-RPC fault is returned
* @see Zend_XmlRpc_Client_FaultException
*/
require_once 'Zend/XmlRpc/Client/FaultException.php';
throw new Zend_XmlRpc_Client_FaultException($fault->getMessage(),
$fault->getCode());
}
return $this->_lastResponse->getReturnValue();
}
}
home/karenpetzb/library/Zend/Soap/Client.php 0000604 00000053245 15071410263 0015042 0 ustar 00 <?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_Soap
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
/** Zend_Soap_Client_Exception */
require_once 'Zend/Soap/Client/Exception.php';
/** Zend_Soap_Server */
require_once 'Zend/Soap/Server.php';
/** Zend_Soap_Client_Local */
require_once 'Zend/Soap/Client/Local.php';
/** Zend_Soap_Client_Common */
require_once 'Zend/Soap/Client/Common.php';
/**
* Zend_Soap_Client
*
* @category Zend
* @package Zend_Soap
* @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_Soap_Client
{
/**
* Encoding
* @var string
*/
protected $_encoding = 'UTF-8';
/**
* Array of SOAP type => PHP class pairings for handling return/incoming values
* @var array
*/
protected $_classmap = null;
/**
* Registered fault exceptions
* @var array
*/
protected $_faultExceptions = array();
/**
* SOAP version to use; SOAP_1_2 by default, to allow processing of headers
* @var int
*/
protected $_soapVersion = SOAP_1_2;
/** Set of other SoapClient options */
protected $_uri = null;
protected $_location = null;
protected $_style = null;
protected $_use = null;
protected $_login = null;
protected $_password = null;
protected $_proxy_host = null;
protected $_proxy_port = null;
protected $_proxy_login = null;
protected $_proxy_password = null;
protected $_local_cert = null;
protected $_passphrase = null;
protected $_compression = null;
protected $_connection_timeout = null;
/**
* WSDL used to access server
* It also defines Zend_Soap_Client working mode (WSDL vs non-WSDL)
*
* @var string
*/
protected $_wsdl = null;
/**
* SoapClient object
*
* @var SoapClient
*/
protected $_soapClient;
/**
* Last invoked method
*
* @var string
*/
protected $_lastMethod = '';
/**
* Constructor
*
* @param string $wsdl
* @param array $options
*/
public function __construct($wsdl = null, $options = null)
{
if (!extension_loaded('soap')) {
throw new Zend_Soap_Client_Exception('SOAP extension is not loaded.');
}
if ($wsdl !== null) {
$this->setWsdl($wsdl);
}
if ($options !== null) {
$this->setOptions($options);
}
}
/**
* Set wsdl
*
* @param string $wsdl
* @return Zend_Soap_Client
*/
public function setWsdl($wsdl)
{
$this->_wsdl = $wsdl;
$this->_soapClient = null;
return $this;
}
/**
* Get wsdl
*
* @return string
*/
public function getWsdl()
{
return $this->_wsdl;
}
/**
* Set Options
*
* Allows setting options as an associative array of option => value pairs.
*
* @param array $options
* @return Zend_Soap_Client
* @throws Zend_SoapClient_Exception
*/
public function setOptions(array $options)
{
foreach ($options as $key => $value) {
switch ($key) {
case 'classmap':
case 'classMap':
$this->setClassmap($value);
break;
case 'encoding':
$this->setEncoding($value);
break;
case 'soapVersion':
case 'soap_version':
$this->setSoapVersion($value);
break;
case 'wsdl':
$this->setWsdl($value);
break;
case 'uri':
$this->setUri($value);
break;
case 'location':
$this->setLocation($value);
break;
case 'style':
$this->setStyle($value);
break;
case 'use':
$this->setEncodingMethod($value);
break;
case 'login':
$this->setHttpLogin($value);
break;
case 'password':
$this->setHttpPassword($value);
break;
case 'proxy_host':
$this->setProxyHost($value);
break;
case 'proxy_port':
$this->setProxyPort($value);
break;
case 'proxy_login':
$this->setProxyLogin($value);
break;
case 'proxy_password':
$this->setProxyPassword($value);
break;
case 'local_cert':
$this->setHttpsCertificate($value);
break;
case 'passphrase':
$this->setHttpsCertPassphrase($value);
break;
case 'compression':
$this->setCompressionOptions($value);
break;
// Not used now
// case 'connection_timeout':
// $this->_connection_timeout = $value;
// break;
default:
throw new Zend_Soap_Client_Exception('Unknown SOAP client option');
break;
}
}
return $this;
}
/**
* Return array of options suitable for using with SoapClient constructor
*
* @return array
*/
public function getOptions()
{
$options = array();
$options['classmap'] = $this->getClassmap();
$options['encoding'] = $this->getEncoding();
$options['soap_version'] = $this->getSoapVersion();
$options['wsdl'] = $this->getWsdl();
$options['uri'] = $this->getUri();
$options['location'] = $this->getLocation();
$options['style'] = $this->getStyle();
$options['use'] = $this->getEncodingMethod();
$options['login'] = $this->getHttpLogin();
$options['password'] = $this->getHttpPassword();
$options['proxy_host'] = $this->getProxyHost();
$options['proxy_port'] = $this->getProxyPort();
$options['proxy_login'] = $this->getProxyLogin();
$options['proxy_password'] = $this->getProxyPassword();
$options['local_cert'] = $this->getHttpsCertificate();
$options['passphrase'] = $this->getHttpsCertPassphrase();
$options['compression'] = $this->getCompressionOptions();
// $options['connection_timeout'] = $this->_connection_timeout;
foreach ($options as $key => $value) {
if ($value == null) {
unset($options[$key]);
}
}
return $options;
}
/**
* Set SOAP version
*
* @param int $version One of the SOAP_1_1 or SOAP_1_2 constants
* @return Zend_Soap_Client
* @throws Zend_Soap_Client_Exception with invalid soap version argument
*/
public function setSoapVersion($version)
{
if (!in_array($version, array(SOAP_1_1, SOAP_1_2))) {
throw new Zend_Soap_Client_Exception('Invalid soap version specified. Use SOAP_1_1 or SOAP_1_2 constants.');
}
$this->_soapVersion = $version;
$this->_soapClient = null;
return $this;
}
/**
* Get SOAP version
*
* @return int
*/
public function getSoapVersion()
{
return $this->_soapVersion;
}
/**
* Set classmap
*
* @param array $classmap
* @return Zend_Soap_Client
* @throws Zend_Soap_Client_Exception for any invalid class in the class map
*/
public function setClassmap(array $classmap)
{
foreach ($classmap as $type => $class) {
if (!class_exists($class)) {
throw new Zend_Soap_Client_Exception('Invalid class in class map');
}
}
$this->_classmap = $classmap;
$this->_soapClient = null;
return $this;
}
/**
* Retrieve classmap
*
* @return mixed
*/
public function getClassmap()
{
return $this->_classmap;
}
/**
* Set encoding
*
* @param string $encoding
* @return Zend_Soap_Client
* @throws Zend_Soap_Client_Exception with invalid encoding argument
*/
public function setEncoding($encoding)
{
if (!is_string($encoding)) {
throw new Zend_Soap_Client_Exception('Invalid encoding specified');
}
$this->_encoding = $encoding;
$this->_soapClient = null;
return $this;
}
/**
* Get encoding
*
* @return string
*/
public function getEncoding()
{
return $this->_encoding;
}
/**
* Check for valid URN
*
* @param string $urn
* @return true
* @throws Zend_Soap_Client_Exception on invalid URN
*/
public function validateUrn($urn)
{
$segs = parse_url($urn);
if (isset($segs['scheme'])) {
return true;
}
throw new Zend_Soap_Client_Exception('Invalid URN');
}
/**
* Set URI
*
* URI in Web Service the target namespace
*
* @param string $uri
* @return Zend_Soap_Client
* @throws Zend_Soap_Client_Exception with invalid uri argument
*/
public function setUri($uri)
{
$this->validateUrn($uri);
$this->_uri = $uri;
$this->_soapClient = null;
return $this;
}
/**
* Retrieve URI
*
* @return string
*/
public function getUri()
{
return $this->_uri;
}
/**
* Set Location
*
* URI in Web Service the target namespace
*
* @param string $location
* @return Zend_Soap_Client
* @throws Zend_Soap_Client_Exception with invalid uri argument
*/
public function setLocation($location)
{
$this->validateUrn($location);
$this->_location = $location;
$this->_soapClient = null;
return $this;
}
/**
* Retrieve URI
*
* @return string
*/
public function getLocation()
{
return $this->_location;
}
/**
* Set request style
*
* @param int $style One of the SOAP_RPC or SOAP_DOCUMENT constants
* @return Zend_Soap_Client
* @throws Zend_Soap_Client_Exception with invalid style argument
*/
public function setStyle($style)
{
if (!in_array($style, array(SOAP_RPC, SOAP_DOCUMENT))) {
throw new Zend_Soap_Client_Exception('Invalid request style specified. Use SOAP_RPC or SOAP_DOCUMENT constants.');
}
$this->_style = $style;
$this->_soapClient = null;
return $this;
}
/**
* Get request style
*
* @return int
*/
public function getStyle()
{
return $this->_style;
}
/**
* Set message encoding method
*
* @param int $use One of the SOAP_ENCODED or SOAP_LITERAL constants
* @return Zend_Soap_Client
* @throws Zend_Soap_Client_Exception with invalid message encoding method argument
*/
public function setEncodingMethod($use)
{
if (!in_array($use, array(SOAP_ENCODED, SOAP_LITERAL))) {
throw new Zend_Soap_Client_Exception('Invalid message encoding method. Use SOAP_ENCODED or SOAP_LITERAL constants.');
}
$this->_use = $use;
$this->_soapClient = null;
return $this;
}
/**
* Get message encoding method
*
* @return int
*/
public function getEncodingMethod()
{
return $this->_use;
}
/**
* Set HTTP login
*
* @param string $login
* @return Zend_Soap_Client
*/
public function setHttpLogin($login)
{
$this->_login = $login;
$this->_soapClient = null;
return $this;
}
/**
* Retrieve HTTP Login
*
* @return string
*/
public function getHttpLogin()
{
return $this->_login;
}
/**
* Set HTTP password
*
* @param string $password
* @return Zend_Soap_Client
*/
public function setHttpPassword($password)
{
$this->_password = $password;
$this->_soapClient = null;
return $this;
}
/**
* Retrieve HTTP Password
*
* @return string
*/
public function getHttpPassword()
{
return $this->_password;
}
/**
* Set proxy host
*
* @param string $proxyHost
* @return Zend_Soap_Client
*/
public function setProxyHost($proxyHost)
{
$this->_proxy_host = $proxyHost;
$this->_soapClient = null;
return $this;
}
/**
* Retrieve proxy host
*
* @return string
*/
public function getProxyHost()
{
return $this->_proxy_host;
}
/**
* Set proxy port
*
* @param int $proxyPort
* @return Zend_Soap_Client
*/
public function setProxyPort($proxyPort)
{
$this->_proxy_port = (int)$proxyPort;
$this->_soapClient = null;
return $this;
}
/**
* Retrieve proxy port
*
* @return int
*/
public function getProxyPort()
{
return $this->_proxy_port;
}
/**
* Set proxy login
*
* @param string $proxyLogin
* @return Zend_Soap_Client
*/
public function setProxyLogin($proxyLogin)
{
$this->_proxy_login = $proxyLogin;
$this->_soapClient = null;
return $this;
}
/**
* Retrieve proxy login
*
* @return string
*/
public function getProxyLogin()
{
return $this->_proxy_login;
}
/**
* Set proxy password
*
* @param string $proxyLogin
* @return Zend_Soap_Client
*/
public function setProxyPassword($proxyPassword)
{
$this->_proxy_password = $proxyPassword;
$this->_soapClient = null;
return $this;
}
/**
* Set HTTPS client certificate path
*
* @param string $localCert local certificate path
* @return Zend_Soap_Client
* @throws Zend_Soap_Client_Exception with invalid local certificate path argument
*/
public function setHttpsCertificate($localCert)
{
if (!is_readable($localCert)) {
throw new Zend_Soap_Client_Exception('Invalid HTTPS client certificate path.');
}
$this->_local_cert = $localCert;
$this->_soapClient = null;
return $this;
}
/**
* Get HTTPS client certificate path
*
* @return string
*/
public function getHttpsCertificate()
{
return $this->_local_cert;
}
/**
* Set HTTPS client certificate passphrase
*
* @param string $passphrase
* @return Zend_Soap_Client
*/
public function setHttpsCertPassphrase($passphrase)
{
$this->_passphrase = $passphrase;
$this->_soapClient = null;
return $this;
}
/**
* Get HTTPS client certificate passphrase
*
* @return string
*/
public function getHttpsCertPassphrase()
{
return $this->_passphrase;
}
/**
* Set compression options
*
* @param int $compressionOptions
* @return Zend_Soap_Client
*/
public function setCompressionOptions($compressionOptions)
{
$this->_compression = $compressionOptions;
$this->_soapClient = null;
return $this;
}
/**
* Get Compression options
*
* @return int
*/
public function getCompressionOptions()
{
return $this->_compression;
}
/**
* Retrieve proxy password
*
* @return string
*/
public function getProxyPassword()
{
return $this->_proxy_password;
}
/**
* Retrieve request XML
*
* @return string
*/
public function getLastRequest()
{
if ($this->_soapClient !== null) {
return $this->_soapClient->__getLastRequest();
}
return '';
}
/**
* Get response XML
*
* @return string
*/
public function getLastResponse()
{
if ($this->_soapClient !== null) {
return $this->_soapClient->__getLastResponse();
}
return '';
}
/**
* Retrieve request headers
*
* @return string
*/
public function getLastRequestHeaders()
{
if ($this->_soapClient !== null) {
return $this->_soapClient->__getLastRequestHeaders();
}
return '';
}
/**
* Retrieve response headers
*
* @return string
*/
public function getLastResponseHeaders()
{
if ($this->_soapClient !== null) {
return $this->_soapClient->__getLastResponseHeaders();
}
return '';
}
/**
* Retrieve last invoked method
*
* @return string
*/
public function getLastMethod()
{
return $this->_lastMethod;
}
/**
* Do request proxy method.
*
* May be overridden in subclasses
*
* @internal
* @param Zend_Soap_Client_Common $client
* @param string $request
* @param string $location
* @param string $action
* @param int $version
* @param int $one_way
* @return mixed
*/
public function _doRequest(Zend_Soap_Client_Common $client, $request, $location, $action, $version, $one_way = null)
{
// Perform request as is
if ($one_way == null) {
return call_user_func(array($client,'SoapClient::__doRequest'), $request, $location, $action, $version);
} else {
return call_user_func(array($client,'SoapClient::__doRequest'), $request, $location, $action, $version, $one_way);
}
}
/**
* Initialize SOAP Client object
*
* @throws Zend_Soap_Client_Exception
*/
protected function _initSoapClientObject()
{
$wsdl = $this->getWsdl();
$options = array_merge($this->getOptions(), array('trace' => true));
if ($wsdl == null) {
if (!isset($options['location'])) {
throw new Zend_Soap_Client_Exception('\'location\' parameter is required in non-WSDL mode.');
}
if (!isset($options['uri'])) {
throw new Zend_Soap_Client_Exception('\'uri\' parameter is required in non-WSDL mode.');
}
} else {
if (isset($options['use'])) {
throw new Zend_Soap_Client_Exception('\'use\' parameter only works in non-WSDL mode.');
}
if (isset($options['style'])) {
throw new Zend_Soap_Client_Exception('\'style\' parameter only works in non-WSDL mode.');
}
}
unset($options['wsdl']);
$this->_soapClient = new Zend_Soap_Client_Common(array($this, '_doRequest'), $wsdl, $options);
}
/**
* Perform arguments pre-processing
*
* My be overridden in descendant classes
*
* @param array $arguments
*/
protected function _preProcessArguments($arguments)
{
// Do nothing
return $arguments;
}
/**
* Perform result pre-processing
*
* My be overridden in descendant classes
*
* @param array $arguments
*/
protected function _preProcessResult($result)
{
// Do nothing
return $result;
}
/**
* Perform a SOAP call
*
* @param string $name
* @param array $arguments
* @return mixed
*/
public function __call($name, $arguments)
{
if ($this->_soapClient == null) {
$this->_initSoapClientObject();
}
$this->_lastMethod = $name;
$result = call_user_func_array(array($this->_soapClient, $name), $this->_preProcessArguments($arguments));
return $this->_preProcessResult($result);
}
/**
* Return a list of available functions
*
* @return array
* @throws Zend_Soap_Client_Exception
*/
public function getFunctions()
{
if ($this->getWsdl() == null) {
throw new Zend_Soap_Client_Exception('\'getFunctions\' method is available only in WSDL mode.');
}
if ($this->_soapClient == null) {
$this->_initSoapClientObject();
}
return $this->_soapClient->__getFunctions();
}
/**
* Get used types.
*
* @return array
*/
/**
* Return a list of SOAP types
*
* @return array
* @throws Zend_Soap_Client_Exception
*/
public function getTypes()
{
if ($this->getWsdl() == null) {
throw new Zend_Soap_Client_Exception('\'getTypes\' method is available only in WSDL mode.');
}
if ($this->_soapClient == null) {
$this->_initSoapClientObject();
}
return $this->_soapClient->__getTypes();
}
}
home/karenpetzb/library/Zend/Http/Client.php 0000604 00000113032 15071437065 0015057 0 ustar 00 <?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 12504 2008-11-10 16:28:46Z matthew $
* @copyright Copyright (c) 2005-2008 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_Response
*/
require_once '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';
/**
* 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';
/**
* 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
);
/**
* 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;
/**
* Fileinfo magic database resource
*
* This varaiable is populated the first time _detectFileMimeType is called
* and is then reused on every call to this method
*
* @var resource
*/
static protected $_fileInfoDb = null;
/**
* Contructor 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);
}
/**
* 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) {
/** @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.');
}
// 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
* @throws Zend_Http_Client_Exception
*/
public function setConfig($config = array())
{
if (! is_array($config)) {
/** @see Zend_Http_Client_Exception */
require_once '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;
// 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)
{
$regex = '/^[^\x00-\x1f\x7f-\xff\(\)<>@,;:\\\\"\/\[\]\?={}\s]+$/';
if (! preg_match($regex, $method)) {
/** @see Zend_Http_Client_Exception */
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 && $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
* @throws Zend_Http_Client_Exception
*/
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))) {
/** @see Zend_Http_Client_Exception */
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]);
// 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 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;
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;
// 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)
{
if (! class_exists('Zend_Http_CookieJar'))
require_once '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 {
/** @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)
{
if (! class_exists('Zend_Http_Cookie'))
require_once '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)) {
/** @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[$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[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()}");
}
$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);
}
/**
* Send the HTTP request and return an HTTP response object
*
* @param string $method
* @return Zend_Http_Response
* @throws Zend_Http_Client_Exception
*/
public function request($method = null)
{
if (! $this->uri instanceof Zend_Uri_Http) {
/** @see Zend_Http_Client_Exception */
require_once '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->_prepareBody();
$headers = $this->_prepareHeaders();
// 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) {
/** @see Zend_Http_Client_Exception */
require_once '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 _prepareHeaders()
{
$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[strtolower(self::CONTENT_TYPE)]) && isset($this->enctype))) {
$headers[] = self::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
* @throws Zend_Http_Client_Exception
*/
protected function _prepareBody()
{
// 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(self::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(self::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(self::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(self::CONTENT_TYPE, self::ENC_URLENCODED);
$body = http_build_query($this->paramsPost, '', '&');
break;
default:
/** @see Zend_Http_Client_Exception */
require_once '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;
}
}
// Set the Content-Length if we have a body or if request is POST/PUT
if ($body || $this->method == self::POST || $this->method == self::PUT) {
$this->setHeaders(self::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;
}
/**
* Attempt to detect the MIME type of a file using available extensions
*
* This method will try to detect the MIME type of a file. If the fileinfo
* extension is available, it will be used. If not, the mime_magic
* extension which is deprected but is still available in many PHP setups
* will be tried.
*
* If neither extension is available, the default application/octet-stream
* MIME type will be returned
*
* @param string $file File path
* @return string MIME type
*/
protected function _detectFileMimeType($file)
{
$type = null;
// First try with fileinfo functions
if (function_exists('finfo_open')) {
if (self::$_fileInfoDb === null) {
self::$_fileInfoDb = @finfo_open(FILEINFO_MIME);
}
if (self::$_fileInfoDb) {
$type = finfo_file(self::$_fileInfoDb, $file);
}
} elseif (function_exists('mime_content_type')) {
$type = mime_content_type($file);
}
// Fallback to the default application/octet-stream
if (! $type) {
$type = 'application/octet-stream';
}
return $type;
}
/**
* 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
* @throws Zend_Http_Client_Exception
*/
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) {
/** @see Zend_Http_Client_Exception */
require_once '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:
/** @see Zend_Http_Client_Exception */
require_once 'Zend/Http/Client/Exception.php';
throw new Zend_Http_Client_Exception("Not a supported HTTP authentication type: '$type'");
}
return $authHeader;
}
}
home/karenpetzb/library/Zend/Rest/Client.php 0000604 00000016336 15071473477 0015075 0 ustar 00 <?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_Rest
* @subpackage Client
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
/** Zend_Service_Abstract */
require_once 'Zend/Service/Abstract.php';
/** Zend_Rest_Client_Result */
require_once 'Zend/Rest/Client/Result.php';
/** Zend_Uri */
require_once 'Zend/Uri.php';
/**
* @category Zend
* @package Zend_Rest
* @subpackage Client
* @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_Rest_Client extends Zend_Service_Abstract
{
/**
* Data for the query
* @var array
*/
protected $_data = array();
/**
* Zend_Uri of this web service
* @var Zend_Uri_Http
*/
protected $_uri = null;
/**
* Constructor
*
* @param string|Zend_Uri_Http $uri URI for the web service
* @return void
*/
public function __construct($uri = null)
{
if (!empty($uri)) {
$this->setUri($uri);
}
}
/**
* Set the URI to use in the request
*
* @param string|Zend_Uri_Http $uri URI for the web service
* @return Zend_Rest_Client
*/
public function setUri($uri)
{
if ($uri instanceof Zend_Uri_Http) {
$this->_uri = $uri;
} else {
$this->_uri = Zend_Uri::factory($uri);
}
return $this;
}
/**
* Retrieve the current request URI object
*
* @return Zend_Uri_Http
*/
public function getUri()
{
return $this->_uri;
}
/**
* Call a remote REST web service URI and return the Zend_Http_Response object
*
* @param string $path The path to append to the URI
* @throws Zend_Rest_Client_Exception
* @return void
*/
final private function _prepareRest($path)
{
// Get the URI object and configure it
if (!$this->_uri instanceof Zend_Uri_Http) {
require_once 'Zend/Rest/Client/Exception.php';
throw new Zend_Rest_Client_Exception('URI object must be set before performing call');
}
$uri = $this->_uri->getUri();
if ($path[0] != '/' && $uri[strlen($uri)-1] != '/') {
$path = '/' . $path;
}
$this->_uri->setPath($path);
/**
* Get the HTTP client and configure it for the endpoint URI. Do this each time
* because the Zend_Http_Client instance is shared among all Zend_Service_Abstract subclasses.
*/
self::getHttpClient()->resetParameters()->setUri($this->_uri);
}
/**
* Performs an HTTP GET request to the $path.
*
* @param string $path
* @param array $query Array of GET parameters
* @return Zend_Http_Response
*/
final public function restGet($path, array $query = null)
{
$this->_prepareRest($path);
$client = self::getHttpClient();
$client->setParameterGet($query);
return $client->request('GET');
}
/**
* Perform a POST or PUT
*
* Performs a POST or PUT request. Any data provided is set in the HTTP
* client. String data is pushed in as raw POST data; array or object data
* is pushed in as POST parameters.
*
* @param mixed $method
* @param mixed $data
* @return Zend_Http_Response
*/
protected function _performPost($method, $data = null)
{
$client = self::getHttpClient();
if (is_string($data)) {
$client->setRawData($data);
} elseif (is_array($data) || is_object($data)) {
$client->setParameterPost((array) $data);
}
return $client->request($method);
}
/**
* Performs an HTTP POST request to $path.
*
* @param string $path
* @param mixed $data Raw data to send
* @return Zend_Http_Response
*/
final public function restPost($path, $data = null)
{
$this->_prepareRest($path);
return $this->_performPost('POST', $data);
}
/**
* Performs an HTTP PUT request to $path.
*
* @param string $path
* @param mixed $data Raw data to send in request
* @return Zend_Http_Response
*/
final public function restPut($path, $data = null)
{
$this->_prepareRest($path);
return $this->_performPost('PUT', $data);
}
/**
* Performs an HTTP DELETE request to $path.
*
* @param string $path
* @return Zend_Http_Response
*/
final public function restDelete($path)
{
$this->_prepareRest($path);
return self::getHttpClient()->request('DELETE');
}
/**
* Method call overload
*
* Allows calling REST actions as object methods; however, you must
* follow-up by chaining the request with a request to an HTTP request
* method (post, get, delete, put):
* <code>
* $response = $rest->sayHello('Foo', 'Manchu')->get();
* </code>
*
* Or use them together, but in sequential calls:
* <code>
* $rest->sayHello('Foo', 'Manchu');
* $response = $rest->get();
* </code>
*
* @param string $method Method name
* @param array $args Method args
* @return Zend_Rest_Client_Result|Zend_Rest_Client Zend_Rest_Client if using
* a remote method, Zend_Rest_Client_Result if using an HTTP request method
*/
public function __call($method, $args)
{
$methods = array('post', 'get', 'delete', 'put');
if (in_array(strtolower($method), $methods)) {
if (!isset($args[0])) {
$args[0] = $this->_uri->getPath();
}
$this->_data['rest'] = 1;
$data = array_slice($args, 1) + $this->_data;
$response = $this->{'rest' . $method}($args[0], $data);
$this->_data = array();//Initializes for next Rest method.
return new Zend_Rest_Client_Result($response->getBody());
} else {
// More than one arg means it's definitely a Zend_Rest_Server
if (sizeof($args) == 1) {
// Uses first called function name as method name
if (!isset($this->_data['method'])) {
$this->_data['method'] = $method;
$this->_data['arg1'] = $args[0];
}
$this->_data[$method] = $args[0];
} else {
$this->_data['method'] = $method;
if (sizeof($args) > 0) {
foreach ($args as $key => $arg) {
$key = 'arg' . $key;
$this->_data[$key] = $arg;
}
}
}
return $this;
}
}
}