CC-2166: Packaging Improvements. Moved the Zend app into airtime_mvc. It is now installed to /var/www/airtime. Storage is now set to /srv/airtime/stor. Utils are now installed to /usr/lib/airtime/utils/. Added install/airtime-dircheck.php as a simple test to see if everything is install/uninstalled correctly.
This commit is contained in:
Paul Baranowski
parent
514777e8d2
commit
b11cbd8159
4546 changed files with 138 additions and 51 deletions
1459
airtime_mvc/library/Zend/Http/Client.php
Normal file
1459
airtime_mvc/library/Zend/Http/Client.php
Normal file
File diff suppressed because it is too large
Load diff
501
airtime_mvc/library/Zend/Http/Client/Adapter/Curl.php
Normal file
501
airtime_mvc/library/Zend/Http/Client/Adapter/Curl.php
Normal file
|
|
@ -0,0 +1,501 @@
|
|||
<?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_Adapter
|
||||
* @version $Id: Curl.php 20096 2010-01-06 02:05:09Z bkarwin $
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
|
||||
/**
|
||||
* @see Zend_Uri_Http
|
||||
*/
|
||||
require_once 'Zend/Uri/Http.php';
|
||||
|
||||
/**
|
||||
* @see Zend_Http_Client_Adapter_Interface
|
||||
*/
|
||||
require_once 'Zend/Http/Client/Adapter/Interface.php';
|
||||
/**
|
||||
* @see Zend_Http_Client_Adapter_Stream
|
||||
*/
|
||||
require_once 'Zend/Http/Client/Adapter/Stream.php';
|
||||
|
||||
/**
|
||||
* An adapter class for Zend_Http_Client based on the curl extension.
|
||||
* Curl requires libcurl. See for full requirements the PHP manual: http://php.net/curl
|
||||
*
|
||||
* @category Zend
|
||||
* @package Zend_Http
|
||||
* @subpackage Client_Adapter
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
class Zend_Http_Client_Adapter_Curl implements Zend_Http_Client_Adapter_Interface, Zend_Http_Client_Adapter_Stream
|
||||
{
|
||||
/**
|
||||
* Parameters array
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected $_config = array();
|
||||
|
||||
/**
|
||||
* What host/port are we connected to?
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected $_connected_to = array(null, null);
|
||||
|
||||
/**
|
||||
* The curl session handle
|
||||
*
|
||||
* @var resource|null
|
||||
*/
|
||||
protected $_curl = null;
|
||||
|
||||
/**
|
||||
* List of cURL options that should never be overwritten
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected $_invalidOverwritableCurlOptions = array(
|
||||
CURLOPT_HTTPGET,
|
||||
CURLOPT_POST,
|
||||
CURLOPT_PUT,
|
||||
CURLOPT_CUSTOMREQUEST,
|
||||
CURLOPT_HEADER,
|
||||
CURLOPT_RETURNTRANSFER,
|
||||
CURLOPT_HTTPHEADER,
|
||||
CURLOPT_POSTFIELDS,
|
||||
CURLOPT_INFILE,
|
||||
CURLOPT_INFILESIZE,
|
||||
CURLOPT_PORT,
|
||||
CURLOPT_MAXREDIRS,
|
||||
CURLOPT_CONNECTTIMEOUT,
|
||||
CURL_HTTP_VERSION_1_1,
|
||||
CURL_HTTP_VERSION_1_0,
|
||||
);
|
||||
|
||||
/**
|
||||
* Response gotten from server
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected $_response = null;
|
||||
|
||||
/**
|
||||
* Stream for storing output
|
||||
*
|
||||
* @var resource
|
||||
*/
|
||||
protected $out_stream;
|
||||
|
||||
/**
|
||||
* Adapter constructor
|
||||
*
|
||||
* Config is set using setConfig()
|
||||
*
|
||||
* @return void
|
||||
* @throws Zend_Http_Client_Adapter_Exception
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
if (!extension_loaded('curl')) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception('cURL extension has to be loaded to use this Zend_Http_Client adapter.');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the configuration array for the adapter
|
||||
*
|
||||
* @throws Zend_Http_Client_Adapter_Exception
|
||||
* @param Zend_Config | array $config
|
||||
* @return Zend_Http_Client_Adapter_Curl
|
||||
*/
|
||||
public function setConfig($config = array())
|
||||
{
|
||||
if ($config instanceof Zend_Config) {
|
||||
$config = $config->toArray();
|
||||
|
||||
} elseif (! is_array($config)) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception(
|
||||
'Array or Zend_Config object expected, got ' . gettype($config)
|
||||
);
|
||||
}
|
||||
|
||||
if(isset($config['proxy_user']) && isset($config['proxy_pass'])) {
|
||||
$this->setCurlOption(CURLOPT_PROXYUSERPWD, $config['proxy_user'].":".$config['proxy_pass']);
|
||||
unset($config['proxy_user'], $config['proxy_pass']);
|
||||
}
|
||||
|
||||
foreach ($config as $k => $v) {
|
||||
$option = strtolower($k);
|
||||
switch($option) {
|
||||
case 'proxy_host':
|
||||
$this->setCurlOption(CURLOPT_PROXY, $v);
|
||||
break;
|
||||
case 'proxy_port':
|
||||
$this->setCurlOption(CURLOPT_PROXYPORT, $v);
|
||||
break;
|
||||
default:
|
||||
$this->_config[$option] = $v;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve the array of all configuration options
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function getConfig()
|
||||
{
|
||||
return $this->_config;
|
||||
}
|
||||
|
||||
/**
|
||||
* Direct setter for cURL adapter related options.
|
||||
*
|
||||
* @param string|int $option
|
||||
* @param mixed $value
|
||||
* @return Zend_Http_Adapter_Curl
|
||||
*/
|
||||
public function setCurlOption($option, $value)
|
||||
{
|
||||
if (!isset($this->_config['curloptions'])) {
|
||||
$this->_config['curloptions'] = array();
|
||||
}
|
||||
$this->_config['curloptions'][$option] = $value;
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize curl
|
||||
*
|
||||
* @param string $host
|
||||
* @param int $port
|
||||
* @param boolean $secure
|
||||
* @return void
|
||||
* @throws Zend_Http_Client_Adapter_Exception if unable to connect
|
||||
*/
|
||||
public function connect($host, $port = 80, $secure = false)
|
||||
{
|
||||
// If we're already connected, disconnect first
|
||||
if ($this->_curl) {
|
||||
$this->close();
|
||||
}
|
||||
|
||||
// If we are connected to a different server or port, disconnect first
|
||||
if ($this->_curl
|
||||
&& is_array($this->_connected_to)
|
||||
&& ($this->_connected_to[0] != $host
|
||||
|| $this->_connected_to[1] != $port)
|
||||
) {
|
||||
$this->close();
|
||||
}
|
||||
|
||||
// Do the actual connection
|
||||
$this->_curl = curl_init();
|
||||
if ($port != 80) {
|
||||
curl_setopt($this->_curl, CURLOPT_PORT, intval($port));
|
||||
}
|
||||
|
||||
// Set timeout
|
||||
curl_setopt($this->_curl, CURLOPT_CONNECTTIMEOUT, $this->_config['timeout']);
|
||||
|
||||
// Set Max redirects
|
||||
curl_setopt($this->_curl, CURLOPT_MAXREDIRS, $this->_config['maxredirects']);
|
||||
|
||||
if (!$this->_curl) {
|
||||
$this->close();
|
||||
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception('Unable to Connect to ' . $host . ':' . $port);
|
||||
}
|
||||
|
||||
if ($secure !== false) {
|
||||
// Behave the same like Zend_Http_Adapter_Socket on SSL options.
|
||||
if (isset($this->_config['sslcert'])) {
|
||||
curl_setopt($this->_curl, CURLOPT_SSLCERT, $this->_config['sslcert']);
|
||||
}
|
||||
if (isset($this->_config['sslpassphrase'])) {
|
||||
curl_setopt($this->_curl, CURLOPT_SSLCERTPASSWD, $this->_config['sslpassphrase']);
|
||||
}
|
||||
}
|
||||
|
||||
// Update connected_to
|
||||
$this->_connected_to = array($host, $port);
|
||||
}
|
||||
|
||||
/**
|
||||
* Send request to the remote server
|
||||
*
|
||||
* @param string $method
|
||||
* @param Zend_Uri_Http $uri
|
||||
* @param float $http_ver
|
||||
* @param array $headers
|
||||
* @param string $body
|
||||
* @return string $request
|
||||
* @throws Zend_Http_Client_Adapter_Exception If connection fails, connected to wrong host, no PUT file defined, unsupported method, or unsupported cURL option
|
||||
*/
|
||||
public function write($method, $uri, $httpVersion = 1.1, $headers = array(), $body = '')
|
||||
{
|
||||
// Make sure we're properly connected
|
||||
if (!$this->_curl) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception("Trying to write but we are not connected");
|
||||
}
|
||||
|
||||
if ($this->_connected_to[0] != $uri->getHost() || $this->_connected_to[1] != $uri->getPort()) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception("Trying to write but we are connected to the wrong host");
|
||||
}
|
||||
|
||||
// set URL
|
||||
curl_setopt($this->_curl, CURLOPT_URL, $uri->__toString());
|
||||
|
||||
// ensure correct curl call
|
||||
$curlValue = true;
|
||||
switch ($method) {
|
||||
case Zend_Http_Client::GET:
|
||||
$curlMethod = CURLOPT_HTTPGET;
|
||||
break;
|
||||
|
||||
case Zend_Http_Client::POST:
|
||||
$curlMethod = CURLOPT_POST;
|
||||
break;
|
||||
|
||||
case Zend_Http_Client::PUT:
|
||||
// There are two different types of PUT request, either a Raw Data string has been set
|
||||
// or CURLOPT_INFILE and CURLOPT_INFILESIZE are used.
|
||||
if(is_resource($body)) {
|
||||
$this->_config['curloptions'][CURLOPT_INFILE] = $body;
|
||||
}
|
||||
if (isset($this->_config['curloptions'][CURLOPT_INFILE])) {
|
||||
// Now we will probably already have Content-Length set, so that we have to delete it
|
||||
// from $headers at this point:
|
||||
foreach ($headers AS $k => $header) {
|
||||
if (preg_match('/Content-Length:\s*(\d+)/i', $header, $m)) {
|
||||
if(is_resource($body)) {
|
||||
$this->_config['curloptions'][CURLOPT_INFILESIZE] = (int)$m[1];
|
||||
}
|
||||
unset($headers[$k]);
|
||||
}
|
||||
}
|
||||
|
||||
if (!isset($this->_config['curloptions'][CURLOPT_INFILESIZE])) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception("Cannot set a file-handle for cURL option CURLOPT_INFILE without also setting its size in CURLOPT_INFILESIZE.");
|
||||
}
|
||||
|
||||
if(is_resource($body)) {
|
||||
$body = '';
|
||||
}
|
||||
|
||||
$curlMethod = CURLOPT_PUT;
|
||||
} else {
|
||||
$curlMethod = CURLOPT_CUSTOMREQUEST;
|
||||
$curlValue = "PUT";
|
||||
}
|
||||
break;
|
||||
|
||||
case Zend_Http_Client::DELETE:
|
||||
$curlMethod = CURLOPT_CUSTOMREQUEST;
|
||||
$curlValue = "DELETE";
|
||||
break;
|
||||
|
||||
case Zend_Http_Client::OPTIONS:
|
||||
$curlMethod = CURLOPT_CUSTOMREQUEST;
|
||||
$curlValue = "OPTIONS";
|
||||
break;
|
||||
|
||||
case Zend_Http_Client::TRACE:
|
||||
$curlMethod = CURLOPT_CUSTOMREQUEST;
|
||||
$curlValue = "TRACE";
|
||||
break;
|
||||
|
||||
default:
|
||||
// For now, through an exception for unsupported request methods
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception("Method currently not supported");
|
||||
}
|
||||
|
||||
if(is_resource($body) && $curlMethod != CURLOPT_PUT) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception("Streaming requests are allowed only with PUT");
|
||||
}
|
||||
|
||||
// get http version to use
|
||||
$curlHttp = ($httpVersion == 1.1) ? CURL_HTTP_VERSION_1_1 : CURL_HTTP_VERSION_1_0;
|
||||
|
||||
// mark as HTTP request and set HTTP method
|
||||
curl_setopt($this->_curl, $curlHttp, true);
|
||||
curl_setopt($this->_curl, $curlMethod, $curlValue);
|
||||
|
||||
if($this->out_stream) {
|
||||
// headers will be read into the response
|
||||
curl_setopt($this->_curl, CURLOPT_HEADER, false);
|
||||
curl_setopt($this->_curl, CURLOPT_HEADERFUNCTION, array($this, "readHeader"));
|
||||
// and data will be written into the file
|
||||
curl_setopt($this->_curl, CURLOPT_FILE, $this->out_stream);
|
||||
} else {
|
||||
// ensure headers are also returned
|
||||
curl_setopt($this->_curl, CURLOPT_HEADER, true);
|
||||
|
||||
// ensure actual response is returned
|
||||
curl_setopt($this->_curl, CURLOPT_RETURNTRANSFER, true);
|
||||
}
|
||||
|
||||
// set additional headers
|
||||
$headers['Accept'] = '';
|
||||
curl_setopt($this->_curl, CURLOPT_HTTPHEADER, $headers);
|
||||
|
||||
/**
|
||||
* Make sure POSTFIELDS is set after $curlMethod is set:
|
||||
* @link http://de2.php.net/manual/en/function.curl-setopt.php#81161
|
||||
*/
|
||||
if ($method == Zend_Http_Client::POST) {
|
||||
curl_setopt($this->_curl, CURLOPT_POSTFIELDS, $body);
|
||||
} elseif ($curlMethod == CURLOPT_PUT) {
|
||||
// this covers a PUT by file-handle:
|
||||
// Make the setting of this options explicit (rather than setting it through the loop following a bit lower)
|
||||
// to group common functionality together.
|
||||
curl_setopt($this->_curl, CURLOPT_INFILE, $this->_config['curloptions'][CURLOPT_INFILE]);
|
||||
curl_setopt($this->_curl, CURLOPT_INFILESIZE, $this->_config['curloptions'][CURLOPT_INFILESIZE]);
|
||||
unset($this->_config['curloptions'][CURLOPT_INFILE]);
|
||||
unset($this->_config['curloptions'][CURLOPT_INFILESIZE]);
|
||||
} elseif ($method == Zend_Http_Client::PUT) {
|
||||
// This is a PUT by a setRawData string, not by file-handle
|
||||
curl_setopt($this->_curl, CURLOPT_POSTFIELDS, $body);
|
||||
}
|
||||
|
||||
// set additional curl options
|
||||
if (isset($this->_config['curloptions'])) {
|
||||
foreach ((array)$this->_config['curloptions'] as $k => $v) {
|
||||
if (!in_array($k, $this->_invalidOverwritableCurlOptions)) {
|
||||
if (curl_setopt($this->_curl, $k, $v) == false) {
|
||||
require_once 'Zend/Http/Client/Exception.php';
|
||||
throw new Zend_Http_Client_Exception(sprintf("Unknown or erroreous cURL option '%s' set", $k));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// send the request
|
||||
$response = curl_exec($this->_curl);
|
||||
|
||||
// if we used streaming, headers are already there
|
||||
if(!is_resource($this->out_stream)) {
|
||||
$this->_response = $response;
|
||||
}
|
||||
|
||||
$request = curl_getinfo($this->_curl, CURLINFO_HEADER_OUT);
|
||||
$request .= $body;
|
||||
|
||||
if (empty($this->_response)) {
|
||||
require_once 'Zend/Http/Client/Exception.php';
|
||||
throw new Zend_Http_Client_Exception("Error in cURL request: " . curl_error($this->_curl));
|
||||
}
|
||||
|
||||
// cURL automatically decodes chunked-messages, this means we have to disallow the Zend_Http_Response to do it again
|
||||
if (stripos($this->_response, "Transfer-Encoding: chunked\r\n")) {
|
||||
$this->_response = str_ireplace("Transfer-Encoding: chunked\r\n", '', $this->_response);
|
||||
}
|
||||
|
||||
// Eliminate multiple HTTP responses.
|
||||
do {
|
||||
$parts = preg_split('|(?:\r?\n){2}|m', $this->_response, 2);
|
||||
$again = false;
|
||||
|
||||
if (isset($parts[1]) && preg_match("|^HTTP/1\.[01](.*?)\r\n|mi", $parts[1])) {
|
||||
$this->_response = $parts[1];
|
||||
$again = true;
|
||||
}
|
||||
} while ($again);
|
||||
|
||||
// cURL automatically handles Proxy rewrites, remove the "HTTP/1.0 200 Connection established" string:
|
||||
if (stripos($this->_response, "HTTP/1.0 200 Connection established\r\n\r\n") !== false) {
|
||||
$this->_response = str_ireplace("HTTP/1.0 200 Connection established\r\n\r\n", '', $this->_response);
|
||||
}
|
||||
|
||||
return $request;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return read response from server
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function read()
|
||||
{
|
||||
return $this->_response;
|
||||
}
|
||||
|
||||
/**
|
||||
* Close the connection to the server
|
||||
*
|
||||
*/
|
||||
public function close()
|
||||
{
|
||||
if(is_resource($this->_curl)) {
|
||||
curl_close($this->_curl);
|
||||
}
|
||||
$this->_curl = null;
|
||||
$this->_connected_to = array(null, null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get cUrl Handle
|
||||
*
|
||||
* @return resource
|
||||
*/
|
||||
public function getHandle()
|
||||
{
|
||||
return $this->_curl;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set output stream for the response
|
||||
*
|
||||
* @param resource $stream
|
||||
* @return Zend_Http_Client_Adapter_Socket
|
||||
*/
|
||||
public function setOutputStream($stream)
|
||||
{
|
||||
$this->out_stream = $stream;
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Header reader function for CURL
|
||||
*
|
||||
* @param resource $curl
|
||||
* @param string $header
|
||||
* @return int
|
||||
*/
|
||||
public function readHeader($curl, $header)
|
||||
{
|
||||
$this->_response .= $header;
|
||||
return strlen($header);
|
||||
}
|
||||
}
|
||||
38
airtime_mvc/library/Zend/Http/Client/Adapter/Exception.php
Normal file
38
airtime_mvc/library/Zend/Http/Client/Adapter/Exception.php
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
<?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_Adapter_Exception
|
||||
* @version $Id: Exception.php 20096 2010-01-06 02:05:09Z bkarwin $
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
|
||||
/**
|
||||
* @see Zend_Http_Client_Exception
|
||||
*/
|
||||
require_once 'Zend/Http/Client/Exception.php';
|
||||
|
||||
/**
|
||||
* @category Zend
|
||||
* @package Zend_Http
|
||||
* @subpackage Client_Adapter
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
class Zend_Http_Client_Adapter_Exception extends Zend_Http_Client_Exception
|
||||
{
|
||||
const READ_TIMEOUT = 1000;
|
||||
}
|
||||
78
airtime_mvc/library/Zend/Http/Client/Adapter/Interface.php
Normal file
78
airtime_mvc/library/Zend/Http/Client/Adapter/Interface.php
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
<?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_Adapter
|
||||
* @version $Id: Interface.php 20096 2010-01-06 02:05:09Z bkarwin $
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
|
||||
/**
|
||||
* An interface description for Zend_Http_Client_Adapter classes.
|
||||
*
|
||||
* These classes are used as connectors for Zend_Http_Client, performing the
|
||||
* tasks of connecting, writing, reading and closing connection to the server.
|
||||
*
|
||||
* @category Zend
|
||||
* @package Zend_Http
|
||||
* @subpackage Client_Adapter
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
interface Zend_Http_Client_Adapter_Interface
|
||||
{
|
||||
/**
|
||||
* Set the configuration array for the adapter
|
||||
*
|
||||
* @param array $config
|
||||
*/
|
||||
public function setConfig($config = array());
|
||||
|
||||
/**
|
||||
* Connect to the remote server
|
||||
*
|
||||
* @param string $host
|
||||
* @param int $port
|
||||
* @param boolean $secure
|
||||
*/
|
||||
public function connect($host, $port = 80, $secure = false);
|
||||
|
||||
/**
|
||||
* Send request to the remote server
|
||||
*
|
||||
* @param string $method
|
||||
* @param Zend_Uri_Http $url
|
||||
* @param string $http_ver
|
||||
* @param array $headers
|
||||
* @param string $body
|
||||
* @return string Request as text
|
||||
*/
|
||||
public function write($method, $url, $http_ver = '1.1', $headers = array(), $body = '');
|
||||
|
||||
/**
|
||||
* Read response from server
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function read();
|
||||
|
||||
/**
|
||||
* Close the connection to the server
|
||||
*
|
||||
*/
|
||||
public function close();
|
||||
}
|
||||
272
airtime_mvc/library/Zend/Http/Client/Adapter/Proxy.php
Normal file
272
airtime_mvc/library/Zend/Http/Client/Adapter/Proxy.php
Normal file
|
|
@ -0,0 +1,272 @@
|
|||
<?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_Adapter
|
||||
* @version $Id: Proxy.php 20947 2010-02-06 17:09:07Z padraic $
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
|
||||
/**
|
||||
* @see Zend_Uri_Http
|
||||
*/
|
||||
require_once 'Zend/Uri/Http.php';
|
||||
/**
|
||||
* @see Zend_Http_Client
|
||||
*/
|
||||
require_once 'Zend/Http/Client.php';
|
||||
/**
|
||||
* @see Zend_Http_Client_Adapter_Socket
|
||||
*/
|
||||
require_once 'Zend/Http/Client/Adapter/Socket.php';
|
||||
|
||||
/**
|
||||
* HTTP Proxy-supporting Zend_Http_Client adapter class, based on the default
|
||||
* socket based adapter.
|
||||
*
|
||||
* Should be used if proxy HTTP access is required. If no proxy is set, will
|
||||
* fall back to Zend_Http_Client_Adapter_Socket behavior. Just like the
|
||||
* default Socket adapter, this adapter does not require any special extensions
|
||||
* installed.
|
||||
*
|
||||
* @category Zend
|
||||
* @package Zend_Http
|
||||
* @subpackage Client_Adapter
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
class Zend_Http_Client_Adapter_Proxy extends Zend_Http_Client_Adapter_Socket
|
||||
{
|
||||
/**
|
||||
* Parameters array
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected $config = array(
|
||||
'ssltransport' => 'ssl',
|
||||
'sslcert' => null,
|
||||
'sslpassphrase' => null,
|
||||
'proxy_host' => '',
|
||||
'proxy_port' => 8080,
|
||||
'proxy_user' => '',
|
||||
'proxy_pass' => '',
|
||||
'proxy_auth' => Zend_Http_Client::AUTH_BASIC,
|
||||
'persistent' => false
|
||||
);
|
||||
|
||||
/**
|
||||
* Whether HTTPS CONNECT was already negotiated with the proxy or not
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
protected $negotiated = false;
|
||||
|
||||
/**
|
||||
* Connect to the remote server
|
||||
*
|
||||
* Will try to connect to the proxy server. If no proxy was set, will
|
||||
* fall back to the target server (behave like regular Socket adapter)
|
||||
*
|
||||
* @param string $host
|
||||
* @param int $port
|
||||
* @param boolean $secure
|
||||
*/
|
||||
public function connect($host, $port = 80, $secure = false)
|
||||
{
|
||||
// If no proxy is set, fall back to Socket adapter
|
||||
if (! $this->config['proxy_host']) {
|
||||
return parent::connect($host, $port, $secure);
|
||||
}
|
||||
|
||||
/* Url might require stream context even if proxy connection doesn't */
|
||||
if ($secure) {
|
||||
$this->config['sslusecontext'] = true;
|
||||
}
|
||||
|
||||
// Connect (a non-secure connection) to the proxy server
|
||||
return parent::connect(
|
||||
$this->config['proxy_host'],
|
||||
$this->config['proxy_port'],
|
||||
false
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Send request to the proxy server
|
||||
*
|
||||
* @param string $method
|
||||
* @param Zend_Uri_Http $uri
|
||||
* @param string $http_ver
|
||||
* @param array $headers
|
||||
* @param string $body
|
||||
* @return string Request as string
|
||||
*/
|
||||
public function write($method, $uri, $http_ver = '1.1', $headers = array(), $body = '')
|
||||
{
|
||||
// If no proxy is set, fall back to default Socket adapter
|
||||
if (! $this->config['proxy_host']) return parent::write($method, $uri, $http_ver, $headers, $body);
|
||||
|
||||
// Make sure we're properly connected
|
||||
if (! $this->socket) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception("Trying to write but we are not connected");
|
||||
}
|
||||
|
||||
$host = $this->config['proxy_host'];
|
||||
$port = $this->config['proxy_port'];
|
||||
|
||||
if ($this->connected_to[0] != "tcp://$host" || $this->connected_to[1] != $port) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception("Trying to write but we are connected to the wrong proxy server");
|
||||
}
|
||||
|
||||
// Add Proxy-Authorization header
|
||||
if ($this->config['proxy_user'] && ! isset($headers['proxy-authorization'])) {
|
||||
$headers['proxy-authorization'] = Zend_Http_Client::encodeAuthHeader(
|
||||
$this->config['proxy_user'], $this->config['proxy_pass'], $this->config['proxy_auth']
|
||||
);
|
||||
}
|
||||
|
||||
// if we are proxying HTTPS, preform CONNECT handshake with the proxy
|
||||
if ($uri->getScheme() == 'https' && (! $this->negotiated)) {
|
||||
$this->connectHandshake($uri->getHost(), $uri->getPort(), $http_ver, $headers);
|
||||
$this->negotiated = true;
|
||||
}
|
||||
|
||||
// Save request method for later
|
||||
$this->method = $method;
|
||||
|
||||
// Build request headers
|
||||
if ($this->negotiated) {
|
||||
$path = $uri->getPath();
|
||||
if ($uri->getQuery()) {
|
||||
$path .= '?' . $uri->getQuery();
|
||||
}
|
||||
$request = "$method $path HTTP/$http_ver\r\n";
|
||||
} else {
|
||||
$request = "$method $uri HTTP/$http_ver\r\n";
|
||||
}
|
||||
|
||||
// Add all headers to the request string
|
||||
foreach ($headers as $k => $v) {
|
||||
if (is_string($k)) $v = "$k: $v";
|
||||
$request .= "$v\r\n";
|
||||
}
|
||||
|
||||
// Add the request body
|
||||
$request .= "\r\n" . $body;
|
||||
|
||||
// Send the request
|
||||
if (! @fwrite($this->socket, $request)) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception("Error writing request to proxy server");
|
||||
}
|
||||
|
||||
return $request;
|
||||
}
|
||||
|
||||
/**
|
||||
* Preform handshaking with HTTPS proxy using CONNECT method
|
||||
*
|
||||
* @param string $host
|
||||
* @param integer $port
|
||||
* @param string $http_ver
|
||||
* @param array $headers
|
||||
*/
|
||||
protected function connectHandshake($host, $port = 443, $http_ver = '1.1', array &$headers = array())
|
||||
{
|
||||
$request = "CONNECT $host:$port HTTP/$http_ver\r\n" .
|
||||
"Host: " . $this->config['proxy_host'] . "\r\n";
|
||||
|
||||
// Add the user-agent header
|
||||
if (isset($this->config['useragent'])) {
|
||||
$request .= "User-agent: " . $this->config['useragent'] . "\r\n";
|
||||
}
|
||||
|
||||
// If the proxy-authorization header is set, send it to proxy but remove
|
||||
// it from headers sent to target host
|
||||
if (isset($headers['proxy-authorization'])) {
|
||||
$request .= "Proxy-authorization: " . $headers['proxy-authorization'] . "\r\n";
|
||||
unset($headers['proxy-authorization']);
|
||||
}
|
||||
|
||||
$request .= "\r\n";
|
||||
|
||||
// Send the request
|
||||
if (! @fwrite($this->socket, $request)) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception("Error writing request to proxy server");
|
||||
}
|
||||
|
||||
// Read response headers only
|
||||
$response = '';
|
||||
$gotStatus = false;
|
||||
while ($line = @fgets($this->socket)) {
|
||||
$gotStatus = $gotStatus || (strpos($line, 'HTTP') !== false);
|
||||
if ($gotStatus) {
|
||||
$response .= $line;
|
||||
if (!chop($line)) break;
|
||||
}
|
||||
}
|
||||
|
||||
// Check that the response from the proxy is 200
|
||||
if (Zend_Http_Response::extractCode($response) != 200) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception("Unable to connect to HTTPS proxy. Server response: " . $response);
|
||||
}
|
||||
|
||||
// If all is good, switch socket to secure mode. We have to fall back
|
||||
// through the different modes
|
||||
$modes = array(
|
||||
STREAM_CRYPTO_METHOD_TLS_CLIENT,
|
||||
STREAM_CRYPTO_METHOD_SSLv3_CLIENT,
|
||||
STREAM_CRYPTO_METHOD_SSLv23_CLIENT,
|
||||
STREAM_CRYPTO_METHOD_SSLv2_CLIENT
|
||||
);
|
||||
|
||||
$success = false;
|
||||
foreach($modes as $mode) {
|
||||
$success = stream_socket_enable_crypto($this->socket, true, $mode);
|
||||
if ($success) break;
|
||||
}
|
||||
|
||||
if (! $success) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception("Unable to connect to" .
|
||||
" HTTPS server through proxy: could not negotiate secure connection.");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Close the connection to the server
|
||||
*
|
||||
*/
|
||||
public function close()
|
||||
{
|
||||
parent::close();
|
||||
$this->negotiated = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Destructor: make sure the socket is disconnected
|
||||
*
|
||||
*/
|
||||
public function __destruct()
|
||||
{
|
||||
if ($this->socket) $this->close();
|
||||
}
|
||||
}
|
||||
535
airtime_mvc/library/Zend/Http/Client/Adapter/Socket.php
Normal file
535
airtime_mvc/library/Zend/Http/Client/Adapter/Socket.php
Normal file
|
|
@ -0,0 +1,535 @@
|
|||
<?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_Adapter
|
||||
* @version $Id: Socket.php 20947 2010-02-06 17:09:07Z padraic $
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
|
||||
/**
|
||||
* @see Zend_Uri_Http
|
||||
*/
|
||||
require_once 'Zend/Uri/Http.php';
|
||||
/**
|
||||
* @see Zend_Http_Client_Adapter_Interface
|
||||
*/
|
||||
require_once 'Zend/Http/Client/Adapter/Interface.php';
|
||||
/**
|
||||
* @see Zend_Http_Client_Adapter_Stream
|
||||
*/
|
||||
require_once 'Zend/Http/Client/Adapter/Stream.php';
|
||||
|
||||
/**
|
||||
* A sockets based (stream_socket_client) adapter class for Zend_Http_Client. Can be used
|
||||
* on almost every PHP environment, and does not require any special extensions.
|
||||
*
|
||||
* @category Zend
|
||||
* @package Zend_Http
|
||||
* @subpackage Client_Adapter
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
class Zend_Http_Client_Adapter_Socket implements Zend_Http_Client_Adapter_Interface, Zend_Http_Client_Adapter_Stream
|
||||
{
|
||||
/**
|
||||
* The socket for server connection
|
||||
*
|
||||
* @var resource|null
|
||||
*/
|
||||
protected $socket = null;
|
||||
|
||||
/**
|
||||
* What host/port are we connected to?
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected $connected_to = array(null, null);
|
||||
|
||||
/**
|
||||
* Stream for storing output
|
||||
*
|
||||
* @var resource
|
||||
*/
|
||||
protected $out_stream = null;
|
||||
|
||||
/**
|
||||
* Parameters array
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected $config = array(
|
||||
'persistent' => false,
|
||||
'ssltransport' => 'ssl',
|
||||
'sslcert' => null,
|
||||
'sslpassphrase' => null,
|
||||
'sslusecontext' => false
|
||||
);
|
||||
|
||||
/**
|
||||
* Request method - will be set by write() and might be used by read()
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected $method = null;
|
||||
|
||||
/**
|
||||
* Stream context
|
||||
*
|
||||
* @var resource
|
||||
*/
|
||||
protected $_context = null;
|
||||
|
||||
/**
|
||||
* Adapter constructor, currently empty. Config is set using setConfig()
|
||||
*
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the configuration array for the adapter
|
||||
*
|
||||
* @param Zend_Config | array $config
|
||||
*/
|
||||
public function setConfig($config = array())
|
||||
{
|
||||
if ($config instanceof Zend_Config) {
|
||||
$config = $config->toArray();
|
||||
|
||||
} elseif (! is_array($config)) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception(
|
||||
'Array or Zend_Config object expected, got ' . gettype($config)
|
||||
);
|
||||
}
|
||||
|
||||
foreach ($config as $k => $v) {
|
||||
$this->config[strtolower($k)] = $v;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve the array of all configuration options
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function getConfig()
|
||||
{
|
||||
return $this->config;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the stream context for the TCP connection to the server
|
||||
*
|
||||
* Can accept either a pre-existing stream context resource, or an array
|
||||
* of stream options, similar to the options array passed to the
|
||||
* stream_context_create() PHP function. In such case a new stream context
|
||||
* will be created using the passed options.
|
||||
*
|
||||
* @since Zend Framework 1.9
|
||||
*
|
||||
* @param mixed $context Stream context or array of context options
|
||||
* @return Zend_Http_Client_Adapter_Socket
|
||||
*/
|
||||
public function setStreamContext($context)
|
||||
{
|
||||
if (is_resource($context) && get_resource_type($context) == 'stream-context') {
|
||||
$this->_context = $context;
|
||||
|
||||
} elseif (is_array($context)) {
|
||||
$this->_context = stream_context_create($context);
|
||||
|
||||
} else {
|
||||
// Invalid parameter
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception(
|
||||
"Expecting either a stream context resource or array, got " . gettype($context)
|
||||
);
|
||||
}
|
||||
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the stream context for the TCP connection to the server.
|
||||
*
|
||||
* If no stream context is set, will create a default one.
|
||||
*
|
||||
* @return resource
|
||||
*/
|
||||
public function getStreamContext()
|
||||
{
|
||||
if (! $this->_context) {
|
||||
$this->_context = stream_context_create();
|
||||
}
|
||||
|
||||
return $this->_context;
|
||||
}
|
||||
|
||||
/**
|
||||
* Connect to the remote server
|
||||
*
|
||||
* @param string $host
|
||||
* @param int $port
|
||||
* @param boolean $secure
|
||||
*/
|
||||
public function connect($host, $port = 80, $secure = false)
|
||||
{
|
||||
// If the URI should be accessed via SSL, prepend the Hostname with ssl://
|
||||
$host = ($secure ? $this->config['ssltransport'] : 'tcp') . '://' . $host;
|
||||
|
||||
// If we are connected to the wrong host, disconnect first
|
||||
if (($this->connected_to[0] != $host || $this->connected_to[1] != $port)) {
|
||||
if (is_resource($this->socket)) $this->close();
|
||||
}
|
||||
|
||||
// Now, if we are not connected, connect
|
||||
if (! is_resource($this->socket) || ! $this->config['keepalive']) {
|
||||
$context = $this->getStreamContext();
|
||||
if ($secure || $this->config['sslusecontext']) {
|
||||
if ($this->config['sslcert'] !== null) {
|
||||
if (! stream_context_set_option($context, 'ssl', 'local_cert',
|
||||
$this->config['sslcert'])) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception('Unable to set sslcert option');
|
||||
}
|
||||
}
|
||||
if ($this->config['sslpassphrase'] !== null) {
|
||||
if (! stream_context_set_option($context, 'ssl', 'passphrase',
|
||||
$this->config['sslpassphrase'])) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception('Unable to set sslpassphrase option');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
$flags = STREAM_CLIENT_CONNECT;
|
||||
if ($this->config['persistent']) $flags |= STREAM_CLIENT_PERSISTENT;
|
||||
|
||||
$this->socket = @stream_socket_client($host . ':' . $port,
|
||||
$errno,
|
||||
$errstr,
|
||||
(int) $this->config['timeout'],
|
||||
$flags,
|
||||
$context);
|
||||
|
||||
if (! $this->socket) {
|
||||
$this->close();
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception(
|
||||
'Unable to Connect to ' . $host . ':' . $port . '. Error #' . $errno . ': ' . $errstr);
|
||||
}
|
||||
|
||||
// Set the stream timeout
|
||||
if (! stream_set_timeout($this->socket, (int) $this->config['timeout'])) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception('Unable to set the connection timeout');
|
||||
}
|
||||
|
||||
// Update connected_to
|
||||
$this->connected_to = array($host, $port);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Send request to the remote server
|
||||
*
|
||||
* @param string $method
|
||||
* @param Zend_Uri_Http $uri
|
||||
* @param string $http_ver
|
||||
* @param array $headers
|
||||
* @param string $body
|
||||
* @return string Request as string
|
||||
*/
|
||||
public function write($method, $uri, $http_ver = '1.1', $headers = array(), $body = '')
|
||||
{
|
||||
// Make sure we're properly connected
|
||||
if (! $this->socket) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception('Trying to write but we are not connected');
|
||||
}
|
||||
|
||||
$host = $uri->getHost();
|
||||
$host = (strtolower($uri->getScheme()) == 'https' ? $this->config['ssltransport'] : 'tcp') . '://' . $host;
|
||||
if ($this->connected_to[0] != $host || $this->connected_to[1] != $uri->getPort()) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception('Trying to write but we are connected to the wrong host');
|
||||
}
|
||||
|
||||
// Save request method for later
|
||||
$this->method = $method;
|
||||
|
||||
// Build request headers
|
||||
$path = $uri->getPath();
|
||||
if ($uri->getQuery()) $path .= '?' . $uri->getQuery();
|
||||
$request = "{$method} {$path} HTTP/{$http_ver}\r\n";
|
||||
foreach ($headers as $k => $v) {
|
||||
if (is_string($k)) $v = ucfirst($k) . ": $v";
|
||||
$request .= "$v\r\n";
|
||||
}
|
||||
|
||||
if(is_resource($body)) {
|
||||
$request .= "\r\n";
|
||||
} else {
|
||||
// Add the request body
|
||||
$request .= "\r\n" . $body;
|
||||
}
|
||||
|
||||
// Send the request
|
||||
if (! @fwrite($this->socket, $request)) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception('Error writing request to server');
|
||||
}
|
||||
|
||||
if(is_resource($body)) {
|
||||
if(stream_copy_to_stream($body, $this->socket) == 0) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception('Error writing request to server');
|
||||
}
|
||||
}
|
||||
|
||||
return $request;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read response from server
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function read()
|
||||
{
|
||||
// First, read headers only
|
||||
$response = '';
|
||||
$gotStatus = false;
|
||||
$stream = !empty($this->config['stream']);
|
||||
|
||||
while (($line = @fgets($this->socket)) !== false) {
|
||||
$gotStatus = $gotStatus || (strpos($line, 'HTTP') !== false);
|
||||
if ($gotStatus) {
|
||||
$response .= $line;
|
||||
if (rtrim($line) === '') break;
|
||||
}
|
||||
}
|
||||
|
||||
$this->_checkSocketReadTimeout();
|
||||
|
||||
$statusCode = Zend_Http_Response::extractCode($response);
|
||||
|
||||
// Handle 100 and 101 responses internally by restarting the read again
|
||||
if ($statusCode == 100 || $statusCode == 101) return $this->read();
|
||||
|
||||
// Check headers to see what kind of connection / transfer encoding we have
|
||||
$headers = Zend_Http_Response::extractHeaders($response);
|
||||
|
||||
/**
|
||||
* Responses to HEAD requests and 204 or 304 responses are not expected
|
||||
* to have a body - stop reading here
|
||||
*/
|
||||
if ($statusCode == 304 || $statusCode == 204 ||
|
||||
$this->method == Zend_Http_Client::HEAD) {
|
||||
|
||||
// Close the connection if requested to do so by the server
|
||||
if (isset($headers['connection']) && $headers['connection'] == 'close') {
|
||||
$this->close();
|
||||
}
|
||||
return $response;
|
||||
}
|
||||
|
||||
// If we got a 'transfer-encoding: chunked' header
|
||||
if (isset($headers['transfer-encoding'])) {
|
||||
|
||||
if (strtolower($headers['transfer-encoding']) == 'chunked') {
|
||||
|
||||
do {
|
||||
$line = @fgets($this->socket);
|
||||
$this->_checkSocketReadTimeout();
|
||||
|
||||
$chunk = $line;
|
||||
|
||||
// Figure out the next chunk size
|
||||
$chunksize = trim($line);
|
||||
if (! ctype_xdigit($chunksize)) {
|
||||
$this->close();
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception('Invalid chunk size "' .
|
||||
$chunksize . '" unable to read chunked body');
|
||||
}
|
||||
|
||||
// Convert the hexadecimal value to plain integer
|
||||
$chunksize = hexdec($chunksize);
|
||||
|
||||
// Read next chunk
|
||||
$read_to = ftell($this->socket) + $chunksize;
|
||||
|
||||
do {
|
||||
$current_pos = ftell($this->socket);
|
||||
if ($current_pos >= $read_to) break;
|
||||
|
||||
if($this->out_stream) {
|
||||
if(stream_copy_to_stream($this->socket, $this->out_stream, $read_to - $current_pos) == 0) {
|
||||
$this->_checkSocketReadTimeout();
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
$line = @fread($this->socket, $read_to - $current_pos);
|
||||
if ($line === false || strlen($line) === 0) {
|
||||
$this->_checkSocketReadTimeout();
|
||||
break;
|
||||
}
|
||||
$chunk .= $line;
|
||||
}
|
||||
} while (! feof($this->socket));
|
||||
|
||||
$chunk .= @fgets($this->socket);
|
||||
$this->_checkSocketReadTimeout();
|
||||
|
||||
if(!$this->out_stream) {
|
||||
$response .= $chunk;
|
||||
}
|
||||
} while ($chunksize > 0);
|
||||
} else {
|
||||
$this->close();
|
||||
throw new Zend_Http_Client_Adapter_Exception('Cannot handle "' .
|
||||
$headers['transfer-encoding'] . '" transfer encoding');
|
||||
}
|
||||
|
||||
// We automatically decode chunked-messages when writing to a stream
|
||||
// this means we have to disallow the Zend_Http_Response to do it again
|
||||
if ($this->out_stream) {
|
||||
$response = str_ireplace("Transfer-Encoding: chunked\r\n", '', $response);
|
||||
}
|
||||
// Else, if we got the content-length header, read this number of bytes
|
||||
} elseif (isset($headers['content-length'])) {
|
||||
|
||||
$current_pos = ftell($this->socket);
|
||||
$chunk = '';
|
||||
|
||||
for ($read_to = $current_pos + $headers['content-length'];
|
||||
$read_to > $current_pos;
|
||||
$current_pos = ftell($this->socket)) {
|
||||
|
||||
if($this->out_stream) {
|
||||
if(@stream_copy_to_stream($this->socket, $this->out_stream, $read_to - $current_pos) == 0) {
|
||||
$this->_checkSocketReadTimeout();
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
$chunk = @fread($this->socket, $read_to - $current_pos);
|
||||
if ($chunk === false || strlen($chunk) === 0) {
|
||||
$this->_checkSocketReadTimeout();
|
||||
break;
|
||||
}
|
||||
|
||||
$response .= $chunk;
|
||||
}
|
||||
|
||||
// Break if the connection ended prematurely
|
||||
if (feof($this->socket)) break;
|
||||
}
|
||||
|
||||
// Fallback: just read the response until EOF
|
||||
} else {
|
||||
|
||||
do {
|
||||
if($this->out_stream) {
|
||||
if(@stream_copy_to_stream($this->socket, $this->out_stream) == 0) {
|
||||
$this->_checkSocketReadTimeout();
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
$buff = @fread($this->socket, 8192);
|
||||
if ($buff === false || strlen($buff) === 0) {
|
||||
$this->_checkSocketReadTimeout();
|
||||
break;
|
||||
} else {
|
||||
$response .= $buff;
|
||||
}
|
||||
}
|
||||
|
||||
} while (feof($this->socket) === false);
|
||||
|
||||
$this->close();
|
||||
}
|
||||
|
||||
// Close the connection if requested to do so by the server
|
||||
if (isset($headers['connection']) && $headers['connection'] == 'close') {
|
||||
$this->close();
|
||||
}
|
||||
|
||||
return $response;
|
||||
}
|
||||
|
||||
/**
|
||||
* Close the connection to the server
|
||||
*
|
||||
*/
|
||||
public function close()
|
||||
{
|
||||
if (is_resource($this->socket)) @fclose($this->socket);
|
||||
$this->socket = null;
|
||||
$this->connected_to = array(null, null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if the socket has timed out - if so close connection and throw
|
||||
* an exception
|
||||
*
|
||||
* @throws Zend_Http_Client_Adapter_Exception with READ_TIMEOUT code
|
||||
*/
|
||||
protected function _checkSocketReadTimeout()
|
||||
{
|
||||
if ($this->socket) {
|
||||
$info = stream_get_meta_data($this->socket);
|
||||
$timedout = $info['timed_out'];
|
||||
if ($timedout) {
|
||||
$this->close();
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception(
|
||||
"Read timed out after {$this->config['timeout']} seconds",
|
||||
Zend_Http_Client_Adapter_Exception::READ_TIMEOUT
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Set output stream for the response
|
||||
*
|
||||
* @param resource $stream
|
||||
* @return Zend_Http_Client_Adapter_Socket
|
||||
*/
|
||||
public function setOutputStream($stream)
|
||||
{
|
||||
$this->out_stream = $stream;
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Destructor: make sure the socket is disconnected
|
||||
*
|
||||
* If we are in persistent TCP mode, will not close the connection
|
||||
*
|
||||
*/
|
||||
public function __destruct()
|
||||
{
|
||||
if (! $this->config['persistent']) {
|
||||
if ($this->socket) $this->close();
|
||||
}
|
||||
}
|
||||
}
|
||||
46
airtime_mvc/library/Zend/Http/Client/Adapter/Stream.php
Normal file
46
airtime_mvc/library/Zend/Http/Client/Adapter/Stream.php
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
<?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_Adapter
|
||||
* @version $Id: Interface.php 16214 2009-06-21 19:34:03Z thomas $
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
|
||||
/**
|
||||
* An interface description for Zend_Http_Client_Adapter_Stream classes.
|
||||
*
|
||||
* This interface decribes Zend_Http_Client_Adapter which supports streaming.
|
||||
*
|
||||
* @category Zend
|
||||
* @package Zend_Http
|
||||
* @subpackage Client_Adapter
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
interface Zend_Http_Client_Adapter_Stream
|
||||
{
|
||||
/**
|
||||
* Set output stream
|
||||
*
|
||||
* This function sets output stream where the result will be stored.
|
||||
*
|
||||
* @param resource $stream Stream to write the output to
|
||||
*
|
||||
*/
|
||||
function setOutputStream($stream);
|
||||
}
|
||||
238
airtime_mvc/library/Zend/Http/Client/Adapter/Test.php
Normal file
238
airtime_mvc/library/Zend/Http/Client/Adapter/Test.php
Normal file
|
|
@ -0,0 +1,238 @@
|
|||
<?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_Adapter
|
||||
* @version $Id: Test.php 20096 2010-01-06 02:05:09Z bkarwin $
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
|
||||
/**
|
||||
* @see Zend_Uri_Http
|
||||
*/
|
||||
require_once 'Zend/Uri/Http.php';
|
||||
/**
|
||||
* @see Zend_Http_Response
|
||||
*/
|
||||
require_once 'Zend/Http/Response.php';
|
||||
/**
|
||||
* @see Zend_Http_Client_Adapter_Interface
|
||||
*/
|
||||
require_once 'Zend/Http/Client/Adapter/Interface.php';
|
||||
|
||||
/**
|
||||
* A testing-purposes adapter.
|
||||
*
|
||||
* Should be used to test all components that rely on Zend_Http_Client,
|
||||
* without actually performing an HTTP request. You should instantiate this
|
||||
* object manually, and then set it as the client's adapter. Then, you can
|
||||
* set the expected response using the setResponse() method.
|
||||
*
|
||||
* @category Zend
|
||||
* @package Zend_Http
|
||||
* @subpackage Client_Adapter
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
class Zend_Http_Client_Adapter_Test implements Zend_Http_Client_Adapter_Interface
|
||||
{
|
||||
/**
|
||||
* Parameters array
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected $config = array();
|
||||
|
||||
/**
|
||||
* Buffer of responses to be returned by the read() method. Can be
|
||||
* set using setResponse() and addResponse().
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected $responses = array("HTTP/1.1 400 Bad Request\r\n\r\n");
|
||||
|
||||
/**
|
||||
* Current position in the response buffer
|
||||
*
|
||||
* @var integer
|
||||
*/
|
||||
protected $responseIndex = 0;
|
||||
|
||||
/**
|
||||
* Wether or not the next request will fail with an exception
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
protected $_nextRequestWillFail = false;
|
||||
|
||||
/**
|
||||
* Adapter constructor, currently empty. Config is set using setConfig()
|
||||
*
|
||||
*/
|
||||
public function __construct()
|
||||
{ }
|
||||
|
||||
/**
|
||||
* Set the nextRequestWillFail flag
|
||||
*
|
||||
* @param boolean $flag
|
||||
* @return Zend_Http_Client_Adapter_Test
|
||||
*/
|
||||
public function setNextRequestWillFail($flag)
|
||||
{
|
||||
$this->_nextRequestWillFail = (bool) $flag;
|
||||
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the configuration array for the adapter
|
||||
*
|
||||
* @param Zend_Config | array $config
|
||||
*/
|
||||
public function setConfig($config = array())
|
||||
{
|
||||
if ($config instanceof Zend_Config) {
|
||||
$config = $config->toArray();
|
||||
|
||||
} elseif (! is_array($config)) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception(
|
||||
'Array or Zend_Config object expected, got ' . gettype($config)
|
||||
);
|
||||
}
|
||||
|
||||
foreach ($config as $k => $v) {
|
||||
$this->config[strtolower($k)] = $v;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Connect to the remote server
|
||||
*
|
||||
* @param string $host
|
||||
* @param int $port
|
||||
* @param boolean $secure
|
||||
* @param int $timeout
|
||||
* @throws Zend_Http_Client_Adapter_Exception
|
||||
*/
|
||||
public function connect($host, $port = 80, $secure = false)
|
||||
{
|
||||
if ($this->_nextRequestWillFail) {
|
||||
$this->_nextRequestWillFail = false;
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception('Request failed');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Send request to the remote server
|
||||
*
|
||||
* @param string $method
|
||||
* @param Zend_Uri_Http $uri
|
||||
* @param string $http_ver
|
||||
* @param array $headers
|
||||
* @param string $body
|
||||
* @return string Request as string
|
||||
*/
|
||||
public function write($method, $uri, $http_ver = '1.1', $headers = array(), $body = '')
|
||||
{
|
||||
$host = $uri->getHost();
|
||||
$host = (strtolower($uri->getScheme()) == 'https' ? 'sslv2://' . $host : $host);
|
||||
|
||||
// Build request headers
|
||||
$path = $uri->getPath();
|
||||
if ($uri->getQuery()) $path .= '?' . $uri->getQuery();
|
||||
$request = "{$method} {$path} HTTP/{$http_ver}\r\n";
|
||||
foreach ($headers as $k => $v) {
|
||||
if (is_string($k)) $v = ucfirst($k) . ": $v";
|
||||
$request .= "$v\r\n";
|
||||
}
|
||||
|
||||
// Add the request body
|
||||
$request .= "\r\n" . $body;
|
||||
|
||||
// Do nothing - just return the request as string
|
||||
|
||||
return $request;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the response set in $this->setResponse()
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function read()
|
||||
{
|
||||
if ($this->responseIndex >= count($this->responses)) {
|
||||
$this->responseIndex = 0;
|
||||
}
|
||||
return $this->responses[$this->responseIndex++];
|
||||
}
|
||||
|
||||
/**
|
||||
* Close the connection (dummy)
|
||||
*
|
||||
*/
|
||||
public function close()
|
||||
{ }
|
||||
|
||||
/**
|
||||
* Set the HTTP response(s) to be returned by this adapter
|
||||
*
|
||||
* @param Zend_Http_Response|array|string $response
|
||||
*/
|
||||
public function setResponse($response)
|
||||
{
|
||||
if ($response instanceof Zend_Http_Response) {
|
||||
$response = $response->asString("\r\n");
|
||||
}
|
||||
|
||||
$this->responses = (array)$response;
|
||||
$this->responseIndex = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add another response to the response buffer.
|
||||
*
|
||||
* @param string Zend_Http_Response|$response
|
||||
*/
|
||||
public function addResponse($response)
|
||||
{
|
||||
if ($response instanceof Zend_Http_Response) {
|
||||
$response = $response->asString("\r\n");
|
||||
}
|
||||
|
||||
$this->responses[] = $response;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the position of the response buffer. Selects which
|
||||
* response will be returned on the next call to read().
|
||||
*
|
||||
* @param integer $index
|
||||
*/
|
||||
public function setResponseIndex($index)
|
||||
{
|
||||
if ($index < 0 || $index >= count($this->responses)) {
|
||||
require_once 'Zend/Http/Client/Adapter/Exception.php';
|
||||
throw new Zend_Http_Client_Adapter_Exception(
|
||||
'Index out of range of response buffer size');
|
||||
}
|
||||
$this->responseIndex = $index;
|
||||
}
|
||||
}
|
||||
36
airtime_mvc/library/Zend/Http/Client/Exception.php
Normal file
36
airtime_mvc/library/Zend/Http/Client/Exception.php
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
<?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_Exception
|
||||
* @version $Id: Exception.php 20096 2010-01-06 02:05:09Z bkarwin $
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
|
||||
/**
|
||||
* @see Zend_Http_Exception
|
||||
*/
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
|
||||
/**
|
||||
* @category Zend
|
||||
* @package Zend_Http
|
||||
* @subpackage Client
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
class Zend_Http_Client_Exception extends Zend_Http_Exception
|
||||
{}
|
||||
424
airtime_mvc/library/Zend/Http/Cookie.php
Normal file
424
airtime_mvc/library/Zend/Http/Cookie.php
Normal file
|
|
@ -0,0 +1,424 @@
|
|||
<?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 Cookie
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @version $Id: Cookie.php 21020 2010-02-11 17:27:23Z shahar $
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
|
||||
/**
|
||||
* @see Zend_Uri_Http
|
||||
*/
|
||||
require_once 'Zend/Uri/Http.php';
|
||||
|
||||
|
||||
/**
|
||||
* Zend_Http_Cookie is a class describing an HTTP cookie and all it's parameters.
|
||||
*
|
||||
* Zend_Http_Cookie is a class describing an HTTP cookie and all it's parameters. The
|
||||
* class also enables validating whether the cookie should be sent to the server in
|
||||
* a specified scenario according to the request URI, the expiry time and whether
|
||||
* session cookies should be used or not. Generally speaking cookies should be
|
||||
* contained in a Cookiejar object, or instantiated manually and added to an HTTP
|
||||
* request.
|
||||
*
|
||||
* See http://wp.netscape.com/newsref/std/cookie_spec.html for some specs.
|
||||
*
|
||||
* @category Zend
|
||||
* @package Zend_Http
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
class Zend_Http_Cookie
|
||||
{
|
||||
/**
|
||||
* Cookie name
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected $name;
|
||||
|
||||
/**
|
||||
* Cookie value
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected $value;
|
||||
|
||||
/**
|
||||
* Cookie expiry date
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
protected $expires;
|
||||
|
||||
/**
|
||||
* Cookie domain
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected $domain;
|
||||
|
||||
/**
|
||||
* Cookie path
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected $path;
|
||||
|
||||
/**
|
||||
* Whether the cookie is secure or not
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
protected $secure;
|
||||
|
||||
/**
|
||||
* Whether the cookie value has been encoded/decoded
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
protected $encodeValue;
|
||||
|
||||
/**
|
||||
* Cookie object constructor
|
||||
*
|
||||
* @todo Add validation of each one of the parameters (legal domain, etc.)
|
||||
*
|
||||
* @param string $name
|
||||
* @param string $value
|
||||
* @param string $domain
|
||||
* @param int $expires
|
||||
* @param string $path
|
||||
* @param bool $secure
|
||||
*/
|
||||
public function __construct($name, $value, $domain, $expires = null, $path = null, $secure = false)
|
||||
{
|
||||
if (preg_match("/[=,; \t\r\n\013\014]/", $name)) {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception("Cookie name cannot contain these characters: =,; \\t\\r\\n\\013\\014 ({$name})");
|
||||
}
|
||||
|
||||
if (! $this->name = (string) $name) {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception('Cookies must have a name');
|
||||
}
|
||||
|
||||
if (! $this->domain = (string) $domain) {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception('Cookies must have a domain');
|
||||
}
|
||||
|
||||
$this->value = (string) $value;
|
||||
$this->expires = ($expires === null ? null : (int) $expires);
|
||||
$this->path = ($path ? $path : '/');
|
||||
$this->secure = $secure;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Cookie name
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getName()
|
||||
{
|
||||
return $this->name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get cookie value
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getValue()
|
||||
{
|
||||
return $this->value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get cookie domain
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getDomain()
|
||||
{
|
||||
return $this->domain;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the cookie path
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getPath()
|
||||
{
|
||||
return $this->path;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the expiry time of the cookie, or null if no expiry time is set
|
||||
*
|
||||
* @return int|null
|
||||
*/
|
||||
public function getExpiryTime()
|
||||
{
|
||||
return $this->expires;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether the cookie should only be sent over secure connections
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function isSecure()
|
||||
{
|
||||
return $this->secure;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether the cookie has expired
|
||||
*
|
||||
* Always returns false if the cookie is a session cookie (has no expiry time)
|
||||
*
|
||||
* @param int $now Timestamp to consider as "now"
|
||||
* @return boolean
|
||||
*/
|
||||
public function isExpired($now = null)
|
||||
{
|
||||
if ($now === null) $now = time();
|
||||
if (is_int($this->expires) && $this->expires < $now) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether the cookie is a session cookie (has no expiry time set)
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function isSessionCookie()
|
||||
{
|
||||
return ($this->expires === null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks whether the cookie should be sent or not in a specific scenario
|
||||
*
|
||||
* @param string|Zend_Uri_Http $uri URI to check against (secure, domain, path)
|
||||
* @param boolean $matchSessionCookies Whether to send session cookies
|
||||
* @param int $now Override the current time when checking for expiry time
|
||||
* @return boolean
|
||||
*/
|
||||
public function match($uri, $matchSessionCookies = true, $now = null)
|
||||
{
|
||||
if (is_string ($uri)) {
|
||||
$uri = Zend_Uri_Http::factory($uri);
|
||||
}
|
||||
|
||||
// Make sure we have a valid Zend_Uri_Http object
|
||||
if (! ($uri->valid() && ($uri->getScheme() == 'http' || $uri->getScheme() =='https'))) {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception('Passed URI is not a valid HTTP or HTTPS URI');
|
||||
}
|
||||
|
||||
// Check that the cookie is secure (if required) and not expired
|
||||
if ($this->secure && $uri->getScheme() != 'https') return false;
|
||||
if ($this->isExpired($now)) return false;
|
||||
if ($this->isSessionCookie() && ! $matchSessionCookies) return false;
|
||||
|
||||
// Check if the domain matches
|
||||
if (! self::matchCookieDomain($this->getDomain(), $uri->getHost())) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check that path matches using prefix match
|
||||
if (! self::matchCookiePath($this->getPath(), $uri->getPath())) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// If we didn't die until now, return true.
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the cookie as a string, suitable for sending as a "Cookie" header in an
|
||||
* HTTP request
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function __toString()
|
||||
{
|
||||
if ($this->encodeValue) {
|
||||
return $this->name . '=' . urlencode($this->value) . ';';
|
||||
}
|
||||
return $this->name . '=' . $this->value . ';';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a new Cookie object from a cookie string
|
||||
* (for example the value of the Set-Cookie HTTP header)
|
||||
*
|
||||
* @param string $cookieStr
|
||||
* @param Zend_Uri_Http|string $refUri Reference URI for default values (domain, path)
|
||||
* @param boolean $encodeValue Weither or not the cookie's value should be
|
||||
* passed through urlencode/urldecode
|
||||
* @return Zend_Http_Cookie A new Zend_Http_Cookie object or false on failure.
|
||||
*/
|
||||
public static function fromString($cookieStr, $refUri = null, $encodeValue = true)
|
||||
{
|
||||
// Set default values
|
||||
if (is_string($refUri)) {
|
||||
$refUri = Zend_Uri_Http::factory($refUri);
|
||||
}
|
||||
|
||||
$name = '';
|
||||
$value = '';
|
||||
$domain = '';
|
||||
$path = '';
|
||||
$expires = null;
|
||||
$secure = false;
|
||||
$parts = explode(';', $cookieStr);
|
||||
|
||||
// If first part does not include '=', fail
|
||||
if (strpos($parts[0], '=') === false) return false;
|
||||
|
||||
// Get the name and value of the cookie
|
||||
list($name, $value) = explode('=', trim(array_shift($parts)), 2);
|
||||
$name = trim($name);
|
||||
if ($encodeValue) {
|
||||
$value = urldecode(trim($value));
|
||||
}
|
||||
|
||||
// Set default domain and path
|
||||
if ($refUri instanceof Zend_Uri_Http) {
|
||||
$domain = $refUri->getHost();
|
||||
$path = $refUri->getPath();
|
||||
$path = substr($path, 0, strrpos($path, '/'));
|
||||
}
|
||||
|
||||
// Set other cookie parameters
|
||||
foreach ($parts as $part) {
|
||||
$part = trim($part);
|
||||
if (strtolower($part) == 'secure') {
|
||||
$secure = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
$keyValue = explode('=', $part, 2);
|
||||
if (count($keyValue) == 2) {
|
||||
list($k, $v) = $keyValue;
|
||||
switch (strtolower($k)) {
|
||||
case 'expires':
|
||||
if(($expires = strtotime($v)) === false) {
|
||||
/**
|
||||
* The expiration is past Tue, 19 Jan 2038 03:14:07 UTC
|
||||
* the maximum for 32-bit signed integer. Zend_Date
|
||||
* can get around that limit.
|
||||
*
|
||||
* @see Zend_Date
|
||||
*/
|
||||
require_once 'Zend/Date.php';
|
||||
|
||||
$expireDate = new Zend_Date($v);
|
||||
$expires = $expireDate->getTimestamp();
|
||||
}
|
||||
break;
|
||||
|
||||
case 'path':
|
||||
$path = $v;
|
||||
break;
|
||||
|
||||
case 'domain':
|
||||
$domain = $v;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ($name !== '') {
|
||||
$ret = new self($name, $value, $domain, $expires, $path, $secure);
|
||||
$ret->encodeValue = ($encodeValue) ? true : false;
|
||||
return $ret;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a cookie's domain matches a host name.
|
||||
*
|
||||
* Used by Zend_Http_Cookie and Zend_Http_CookieJar for cookie matching
|
||||
*
|
||||
* @param string $cookieDomain
|
||||
* @param string $host
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public static function matchCookieDomain($cookieDomain, $host)
|
||||
{
|
||||
if (! $cookieDomain) {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception("\$cookieDomain is expected to be a cookie domain");
|
||||
}
|
||||
|
||||
if (! $host) {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception("\$host is expected to be a host name");
|
||||
}
|
||||
|
||||
$cookieDomain = strtolower($cookieDomain);
|
||||
$host = strtolower($host);
|
||||
|
||||
if ($cookieDomain[0] == '.') {
|
||||
$cookieDomain = substr($cookieDomain, 1);
|
||||
}
|
||||
|
||||
// Check for either exact match or suffix match
|
||||
return ($cookieDomain == $host ||
|
||||
preg_match("/\.$cookieDomain$/", $host));
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a cookie's path matches a URL path
|
||||
*
|
||||
* Used by Zend_Http_Cookie and Zend_Http_CookieJar for cookie matching
|
||||
*
|
||||
* @param string $cookiePath
|
||||
* @param string $path
|
||||
* @return boolean
|
||||
*/
|
||||
public static function matchCookiePath($cookiePath, $path)
|
||||
{
|
||||
if (! $cookiePath) {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception("\$cookiePath is expected to be a cookie path");
|
||||
}
|
||||
|
||||
if (! $path) {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception("\$path is expected to be a host name");
|
||||
}
|
||||
|
||||
return (strpos($path, $cookiePath) === 0);
|
||||
}
|
||||
}
|
||||
403
airtime_mvc/library/Zend/Http/CookieJar.php
Normal file
403
airtime_mvc/library/Zend/Http/CookieJar.php
Normal file
|
|
@ -0,0 +1,403 @@
|
|||
<?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 CookieJar
|
||||
* @version $Id: CookieJar.php 20096 2010-01-06 02:05:09Z bkarwin $
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
|
||||
/**
|
||||
* @see Zend_Uri
|
||||
*/
|
||||
require_once "Zend/Uri.php";
|
||||
/**
|
||||
* @see Zend_Http_Cookie
|
||||
*/
|
||||
require_once "Zend/Http/Cookie.php";
|
||||
/**
|
||||
* @see Zend_Http_Response
|
||||
*/
|
||||
require_once "Zend/Http/Response.php";
|
||||
|
||||
/**
|
||||
* A Zend_Http_CookieJar object is designed to contain and maintain HTTP cookies, and should
|
||||
* be used along with Zend_Http_Client in order to manage cookies across HTTP requests and
|
||||
* responses.
|
||||
*
|
||||
* The class contains an array of Zend_Http_Cookie objects. Cookies can be added to the jar
|
||||
* automatically from a request or manually. Then, the jar can find and return the cookies
|
||||
* needed for a specific HTTP request.
|
||||
*
|
||||
* A special parameter can be passed to all methods of this class that return cookies: Cookies
|
||||
* can be returned either in their native form (as Zend_Http_Cookie objects) or as strings -
|
||||
* the later is suitable for sending as the value of the "Cookie" header in an HTTP request.
|
||||
* You can also choose, when returning more than one cookie, whether to get an array of strings
|
||||
* (by passing Zend_Http_CookieJar::COOKIE_STRING_ARRAY) or one unified string for all cookies
|
||||
* (by passing Zend_Http_CookieJar::COOKIE_STRING_CONCAT).
|
||||
*
|
||||
* @link http://wp.netscape.com/newsref/std/cookie_spec.html for some specs.
|
||||
*
|
||||
* @category Zend
|
||||
* @package Zend_Http
|
||||
* @subpackage CookieJar
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
class Zend_Http_CookieJar implements Countable, IteratorAggregate
|
||||
{
|
||||
/**
|
||||
* Return cookie(s) as a Zend_Http_Cookie object
|
||||
*
|
||||
*/
|
||||
const COOKIE_OBJECT = 0;
|
||||
|
||||
/**
|
||||
* Return cookie(s) as a string (suitable for sending in an HTTP request)
|
||||
*
|
||||
*/
|
||||
const COOKIE_STRING_ARRAY = 1;
|
||||
|
||||
/**
|
||||
* Return all cookies as one long string (suitable for sending in an HTTP request)
|
||||
*
|
||||
*/
|
||||
const COOKIE_STRING_CONCAT = 2;
|
||||
|
||||
/**
|
||||
* Array storing cookies
|
||||
*
|
||||
* Cookies are stored according to domain and path:
|
||||
* $cookies
|
||||
* + www.mydomain.com
|
||||
* + /
|
||||
* - cookie1
|
||||
* - cookie2
|
||||
* + /somepath
|
||||
* - othercookie
|
||||
* + www.otherdomain.net
|
||||
* + /
|
||||
* - alsocookie
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected $cookies = array();
|
||||
|
||||
/**
|
||||
* The Zend_Http_Cookie array
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected $_rawCookies = array();
|
||||
|
||||
/**
|
||||
* Construct a new CookieJar object
|
||||
*
|
||||
*/
|
||||
public function __construct()
|
||||
{ }
|
||||
|
||||
/**
|
||||
* Add a cookie to the jar. Cookie should be passed either as a Zend_Http_Cookie object
|
||||
* or as a string - in which case an object is created from the string.
|
||||
*
|
||||
* @param Zend_Http_Cookie|string $cookie
|
||||
* @param Zend_Uri_Http|string $ref_uri Optional reference URI (for domain, path, secure)
|
||||
*/
|
||||
public function addCookie($cookie, $ref_uri = null)
|
||||
{
|
||||
if (is_string($cookie)) {
|
||||
$cookie = Zend_Http_Cookie::fromString($cookie, $ref_uri);
|
||||
}
|
||||
|
||||
if ($cookie instanceof Zend_Http_Cookie) {
|
||||
$domain = $cookie->getDomain();
|
||||
$path = $cookie->getPath();
|
||||
if (! isset($this->cookies[$domain])) $this->cookies[$domain] = array();
|
||||
if (! isset($this->cookies[$domain][$path])) $this->cookies[$domain][$path] = array();
|
||||
$this->cookies[$domain][$path][$cookie->getName()] = $cookie;
|
||||
$this->_rawCookies[] = $cookie;
|
||||
} else {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception('Supplient argument is not a valid cookie string or object');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse an HTTP response, adding all the cookies set in that response
|
||||
* to the cookie jar.
|
||||
*
|
||||
* @param Zend_Http_Response $response
|
||||
* @param Zend_Uri_Http|string $ref_uri Requested URI
|
||||
*/
|
||||
public function addCookiesFromResponse($response, $ref_uri)
|
||||
{
|
||||
if (! $response instanceof Zend_Http_Response) {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception('$response is expected to be a Response object, ' .
|
||||
gettype($response) . ' was passed');
|
||||
}
|
||||
|
||||
$cookie_hdrs = $response->getHeader('Set-Cookie');
|
||||
|
||||
if (is_array($cookie_hdrs)) {
|
||||
foreach ($cookie_hdrs as $cookie) {
|
||||
$this->addCookie($cookie, $ref_uri);
|
||||
}
|
||||
} elseif (is_string($cookie_hdrs)) {
|
||||
$this->addCookie($cookie_hdrs, $ref_uri);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all cookies in the cookie jar as an array
|
||||
*
|
||||
* @param int $ret_as Whether to return cookies as objects of Zend_Http_Cookie or as strings
|
||||
* @return array|string
|
||||
*/
|
||||
public function getAllCookies($ret_as = self::COOKIE_OBJECT)
|
||||
{
|
||||
$cookies = $this->_flattenCookiesArray($this->cookies, $ret_as);
|
||||
return $cookies;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return an array of all cookies matching a specific request according to the request URI,
|
||||
* whether session cookies should be sent or not, and the time to consider as "now" when
|
||||
* checking cookie expiry time.
|
||||
*
|
||||
* @param string|Zend_Uri_Http $uri URI to check against (secure, domain, path)
|
||||
* @param boolean $matchSessionCookies Whether to send session cookies
|
||||
* @param int $ret_as Whether to return cookies as objects of Zend_Http_Cookie or as strings
|
||||
* @param int $now Override the current time when checking for expiry time
|
||||
* @return array|string
|
||||
*/
|
||||
public function getMatchingCookies($uri, $matchSessionCookies = true,
|
||||
$ret_as = self::COOKIE_OBJECT, $now = null)
|
||||
{
|
||||
if (is_string($uri)) $uri = Zend_Uri::factory($uri);
|
||||
if (! $uri instanceof Zend_Uri_Http) {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception("Invalid URI string or object passed");
|
||||
}
|
||||
|
||||
// First, reduce the array of cookies to only those matching domain and path
|
||||
$cookies = $this->_matchDomain($uri->getHost());
|
||||
$cookies = $this->_matchPath($cookies, $uri->getPath());
|
||||
$cookies = $this->_flattenCookiesArray($cookies, self::COOKIE_OBJECT);
|
||||
|
||||
// Next, run Cookie->match on all cookies to check secure, time and session mathcing
|
||||
$ret = array();
|
||||
foreach ($cookies as $cookie)
|
||||
if ($cookie->match($uri, $matchSessionCookies, $now))
|
||||
$ret[] = $cookie;
|
||||
|
||||
// Now, use self::_flattenCookiesArray again - only to convert to the return format ;)
|
||||
$ret = $this->_flattenCookiesArray($ret, $ret_as);
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a specific cookie according to a URI and name
|
||||
*
|
||||
* @param Zend_Uri_Http|string $uri The uri (domain and path) to match
|
||||
* @param string $cookie_name The cookie's name
|
||||
* @param int $ret_as Whether to return cookies as objects of Zend_Http_Cookie or as strings
|
||||
* @return Zend_Http_Cookie|string
|
||||
*/
|
||||
public function getCookie($uri, $cookie_name, $ret_as = self::COOKIE_OBJECT)
|
||||
{
|
||||
if (is_string($uri)) {
|
||||
$uri = Zend_Uri::factory($uri);
|
||||
}
|
||||
|
||||
if (! $uri instanceof Zend_Uri_Http) {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception('Invalid URI specified');
|
||||
}
|
||||
|
||||
// Get correct cookie path
|
||||
$path = $uri->getPath();
|
||||
$path = substr($path, 0, strrpos($path, '/'));
|
||||
if (! $path) $path = '/';
|
||||
|
||||
if (isset($this->cookies[$uri->getHost()][$path][$cookie_name])) {
|
||||
$cookie = $this->cookies[$uri->getHost()][$path][$cookie_name];
|
||||
|
||||
switch ($ret_as) {
|
||||
case self::COOKIE_OBJECT:
|
||||
return $cookie;
|
||||
break;
|
||||
|
||||
case self::COOKIE_STRING_ARRAY:
|
||||
case self::COOKIE_STRING_CONCAT:
|
||||
return $cookie->__toString();
|
||||
break;
|
||||
|
||||
default:
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception("Invalid value passed for \$ret_as: {$ret_as}");
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to recursivly flatten an array. Shoud be used when exporting the
|
||||
* cookies array (or parts of it)
|
||||
*
|
||||
* @param Zend_Http_Cookie|array $ptr
|
||||
* @param int $ret_as What value to return
|
||||
* @return array|string
|
||||
*/
|
||||
protected function _flattenCookiesArray($ptr, $ret_as = self::COOKIE_OBJECT) {
|
||||
if (is_array($ptr)) {
|
||||
$ret = ($ret_as == self::COOKIE_STRING_CONCAT ? '' : array());
|
||||
foreach ($ptr as $item) {
|
||||
if ($ret_as == self::COOKIE_STRING_CONCAT) {
|
||||
$ret .= $this->_flattenCookiesArray($item, $ret_as);
|
||||
} else {
|
||||
$ret = array_merge($ret, $this->_flattenCookiesArray($item, $ret_as));
|
||||
}
|
||||
}
|
||||
return $ret;
|
||||
} elseif ($ptr instanceof Zend_Http_Cookie) {
|
||||
switch ($ret_as) {
|
||||
case self::COOKIE_STRING_ARRAY:
|
||||
return array($ptr->__toString());
|
||||
break;
|
||||
|
||||
case self::COOKIE_STRING_CONCAT:
|
||||
return $ptr->__toString();
|
||||
break;
|
||||
|
||||
case self::COOKIE_OBJECT:
|
||||
default:
|
||||
return array($ptr);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a subset of the cookies array matching a specific domain
|
||||
*
|
||||
* @param string $domain
|
||||
* @return array
|
||||
*/
|
||||
protected function _matchDomain($domain)
|
||||
{
|
||||
$ret = array();
|
||||
|
||||
foreach (array_keys($this->cookies) as $cdom) {
|
||||
if (Zend_Http_Cookie::matchCookieDomain($cdom, $domain)) {
|
||||
$ret[$cdom] = $this->cookies[$cdom];
|
||||
}
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a subset of a domain-matching cookies that also match a specified path
|
||||
*
|
||||
* @param array $dom_array
|
||||
* @param string $path
|
||||
* @return array
|
||||
*/
|
||||
protected function _matchPath($domains, $path)
|
||||
{
|
||||
$ret = array();
|
||||
|
||||
foreach ($domains as $dom => $paths_array) {
|
||||
foreach (array_keys($paths_array) as $cpath) {
|
||||
if (Zend_Http_Cookie::matchCookiePath($cpath, $path)) {
|
||||
if (! isset($ret[$dom])) {
|
||||
$ret[$dom] = array();
|
||||
}
|
||||
|
||||
$ret[$dom][$cpath] = $paths_array[$cpath];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new CookieJar object and automatically load into it all the
|
||||
* cookies set in an Http_Response object. If $uri is set, it will be
|
||||
* considered as the requested URI for setting default domain and path
|
||||
* of the cookie.
|
||||
*
|
||||
* @param Zend_Http_Response $response HTTP Response object
|
||||
* @param Zend_Uri_Http|string $uri The requested URI
|
||||
* @return Zend_Http_CookieJar
|
||||
* @todo Add the $uri functionality.
|
||||
*/
|
||||
public static function fromResponse(Zend_Http_Response $response, $ref_uri)
|
||||
{
|
||||
$jar = new self();
|
||||
$jar->addCookiesFromResponse($response, $ref_uri);
|
||||
return $jar;
|
||||
}
|
||||
|
||||
/**
|
||||
* Required by Countable interface
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function count()
|
||||
{
|
||||
return count($this->_rawCookies);
|
||||
}
|
||||
|
||||
/**
|
||||
* Required by IteratorAggregate interface
|
||||
*
|
||||
* @return ArrayIterator
|
||||
*/
|
||||
public function getIterator()
|
||||
{
|
||||
return new ArrayIterator($this->_rawCookies);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tells if the jar is empty of any cookie
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function isEmpty()
|
||||
{
|
||||
return count($this) == 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Empties the cookieJar of any cookie
|
||||
*
|
||||
* @return Zend_Http_CookieJar
|
||||
*/
|
||||
public function reset()
|
||||
{
|
||||
$this->cookies = $this->_rawCookies = array();
|
||||
return $this;
|
||||
}
|
||||
}
|
||||
36
airtime_mvc/library/Zend/Http/Exception.php
Normal file
36
airtime_mvc/library/Zend/Http/Exception.php
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
<?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 Exception
|
||||
* @version $Id: Exception.php 20096 2010-01-06 02:05:09Z bkarwin $
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
|
||||
/**
|
||||
* @see Zend_Exception
|
||||
*/
|
||||
require_once 'Zend/Exception.php';
|
||||
|
||||
/**
|
||||
* @category Zend
|
||||
* @package Zend_Http
|
||||
* @subpackage Client
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
class Zend_Http_Exception extends Zend_Exception
|
||||
{}
|
||||
664
airtime_mvc/library/Zend/Http/Response.php
Normal file
664
airtime_mvc/library/Zend/Http/Response.php
Normal file
|
|
@ -0,0 +1,664 @@
|
|||
<?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 Response
|
||||
* @version $Id: Response.php 20096 2010-01-06 02:05:09Z bkarwin $
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
|
||||
/**
|
||||
* Zend_Http_Response represents an HTTP 1.0 / 1.1 response message. It
|
||||
* includes easy access to all the response's different elemts, as well as some
|
||||
* convenience methods for parsing and validating HTTP responses.
|
||||
*
|
||||
* @package Zend_Http
|
||||
* @subpackage Response
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
class Zend_Http_Response
|
||||
{
|
||||
/**
|
||||
* List of all known HTTP response codes - used by responseCodeAsText() to
|
||||
* translate numeric codes to messages.
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected static $messages = array(
|
||||
// Informational 1xx
|
||||
100 => 'Continue',
|
||||
101 => 'Switching Protocols',
|
||||
|
||||
// Success 2xx
|
||||
200 => 'OK',
|
||||
201 => 'Created',
|
||||
202 => 'Accepted',
|
||||
203 => 'Non-Authoritative Information',
|
||||
204 => 'No Content',
|
||||
205 => 'Reset Content',
|
||||
206 => 'Partial Content',
|
||||
|
||||
// Redirection 3xx
|
||||
300 => 'Multiple Choices',
|
||||
301 => 'Moved Permanently',
|
||||
302 => 'Found', // 1.1
|
||||
303 => 'See Other',
|
||||
304 => 'Not Modified',
|
||||
305 => 'Use Proxy',
|
||||
// 306 is deprecated but reserved
|
||||
307 => 'Temporary Redirect',
|
||||
|
||||
// Client Error 4xx
|
||||
400 => 'Bad Request',
|
||||
401 => 'Unauthorized',
|
||||
402 => 'Payment Required',
|
||||
403 => 'Forbidden',
|
||||
404 => 'Not Found',
|
||||
405 => 'Method Not Allowed',
|
||||
406 => 'Not Acceptable',
|
||||
407 => 'Proxy Authentication Required',
|
||||
408 => 'Request Timeout',
|
||||
409 => 'Conflict',
|
||||
410 => 'Gone',
|
||||
411 => 'Length Required',
|
||||
412 => 'Precondition Failed',
|
||||
413 => 'Request Entity Too Large',
|
||||
414 => 'Request-URI Too Long',
|
||||
415 => 'Unsupported Media Type',
|
||||
416 => 'Requested Range Not Satisfiable',
|
||||
417 => 'Expectation Failed',
|
||||
|
||||
// Server Error 5xx
|
||||
500 => 'Internal Server Error',
|
||||
501 => 'Not Implemented',
|
||||
502 => 'Bad Gateway',
|
||||
503 => 'Service Unavailable',
|
||||
504 => 'Gateway Timeout',
|
||||
505 => 'HTTP Version Not Supported',
|
||||
509 => 'Bandwidth Limit Exceeded'
|
||||
);
|
||||
|
||||
/**
|
||||
* The HTTP version (1.0, 1.1)
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected $version;
|
||||
|
||||
/**
|
||||
* The HTTP response code
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
protected $code;
|
||||
|
||||
/**
|
||||
* The HTTP response code as string
|
||||
* (e.g. 'Not Found' for 404 or 'Internal Server Error' for 500)
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected $message;
|
||||
|
||||
/**
|
||||
* The HTTP response headers array
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected $headers = array();
|
||||
|
||||
/**
|
||||
* The HTTP response body
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected $body;
|
||||
|
||||
/**
|
||||
* HTTP response constructor
|
||||
*
|
||||
* In most cases, you would use Zend_Http_Response::fromString to parse an HTTP
|
||||
* response string and create a new Zend_Http_Response object.
|
||||
*
|
||||
* NOTE: The constructor no longer accepts nulls or empty values for the code and
|
||||
* headers and will throw an exception if the passed values do not form a valid HTTP
|
||||
* responses.
|
||||
*
|
||||
* If no message is passed, the message will be guessed according to the response code.
|
||||
*
|
||||
* @param int $code Response code (200, 404, ...)
|
||||
* @param array $headers Headers array
|
||||
* @param string $body Response body
|
||||
* @param string $version HTTP version
|
||||
* @param string $message Response code as text
|
||||
* @throws Zend_Http_Exception
|
||||
*/
|
||||
public function __construct($code, $headers, $body = null, $version = '1.1', $message = null)
|
||||
{
|
||||
// Make sure the response code is valid and set it
|
||||
if (self::responseCodeAsText($code) === null) {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception("{$code} is not a valid HTTP response code");
|
||||
}
|
||||
|
||||
$this->code = $code;
|
||||
|
||||
// Make sure we got valid headers and set them
|
||||
if (! is_array($headers)) {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception('No valid headers were passed');
|
||||
}
|
||||
|
||||
foreach ($headers as $name => $value) {
|
||||
if (is_int($name))
|
||||
list($name, $value) = explode(": ", $value, 1);
|
||||
|
||||
$this->headers[ucwords(strtolower($name))] = $value;
|
||||
}
|
||||
|
||||
// Set the body
|
||||
$this->body = $body;
|
||||
|
||||
// Set the HTTP version
|
||||
if (! preg_match('|^\d\.\d$|', $version)) {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception("Invalid HTTP response version: $version");
|
||||
}
|
||||
|
||||
$this->version = $version;
|
||||
|
||||
// If we got the response message, set it. Else, set it according to
|
||||
// the response code
|
||||
if (is_string($message)) {
|
||||
$this->message = $message;
|
||||
} else {
|
||||
$this->message = self::responseCodeAsText($code);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether the response is an error
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function isError()
|
||||
{
|
||||
$restype = floor($this->code / 100);
|
||||
if ($restype == 4 || $restype == 5) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether the response in successful
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function isSuccessful()
|
||||
{
|
||||
$restype = floor($this->code / 100);
|
||||
if ($restype == 2 || $restype == 1) { // Shouldn't 3xx count as success as well ???
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether the response is a redirection
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function isRedirect()
|
||||
{
|
||||
$restype = floor($this->code / 100);
|
||||
if ($restype == 3) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the response body as string
|
||||
*
|
||||
* This method returns the body of the HTTP response (the content), as it
|
||||
* should be in it's readable version - that is, after decoding it (if it
|
||||
* was decoded), deflating it (if it was gzip compressed), etc.
|
||||
*
|
||||
* If you want to get the raw body (as transfered on wire) use
|
||||
* $this->getRawBody() instead.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getBody()
|
||||
{
|
||||
$body = '';
|
||||
|
||||
// Decode the body if it was transfer-encoded
|
||||
switch (strtolower($this->getHeader('transfer-encoding'))) {
|
||||
|
||||
// Handle chunked body
|
||||
case 'chunked':
|
||||
$body = self::decodeChunkedBody($this->body);
|
||||
break;
|
||||
|
||||
// No transfer encoding, or unknown encoding extension:
|
||||
// return body as is
|
||||
default:
|
||||
$body = $this->body;
|
||||
break;
|
||||
}
|
||||
|
||||
// Decode any content-encoding (gzip or deflate) if needed
|
||||
switch (strtolower($this->getHeader('content-encoding'))) {
|
||||
|
||||
// Handle gzip encoding
|
||||
case 'gzip':
|
||||
$body = self::decodeGzip($body);
|
||||
break;
|
||||
|
||||
// Handle deflate encoding
|
||||
case 'deflate':
|
||||
$body = self::decodeDeflate($body);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return $body;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the raw response body (as transfered "on wire") as string
|
||||
*
|
||||
* If the body is encoded (with Transfer-Encoding, not content-encoding -
|
||||
* IE "chunked" body), gzip compressed, etc. it will not be decoded.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getRawBody()
|
||||
{
|
||||
return $this->body;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the HTTP version of the response
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getVersion()
|
||||
{
|
||||
return $this->version;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the HTTP response status code
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function getStatus()
|
||||
{
|
||||
return $this->code;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a message describing the HTTP response code
|
||||
* (Eg. "OK", "Not Found", "Moved Permanently")
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getMessage()
|
||||
{
|
||||
return $this->message;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the response headers
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function getHeaders()
|
||||
{
|
||||
return $this->headers;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a specific header as string, or null if it is not set
|
||||
*
|
||||
* @param string$header
|
||||
* @return string|array|null
|
||||
*/
|
||||
public function getHeader($header)
|
||||
{
|
||||
$header = ucwords(strtolower($header));
|
||||
if (! is_string($header) || ! isset($this->headers[$header])) return null;
|
||||
|
||||
return $this->headers[$header];
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all headers as string
|
||||
*
|
||||
* @param boolean $status_line Whether to return the first status line (IE "HTTP 200 OK")
|
||||
* @param string $br Line breaks (eg. "\n", "\r\n", "<br />")
|
||||
* @return string
|
||||
*/
|
||||
public function getHeadersAsString($status_line = true, $br = "\n")
|
||||
{
|
||||
$str = '';
|
||||
|
||||
if ($status_line) {
|
||||
$str = "HTTP/{$this->version} {$this->code} {$this->message}{$br}";
|
||||
}
|
||||
|
||||
// Iterate over the headers and stringify them
|
||||
foreach ($this->headers as $name => $value)
|
||||
{
|
||||
if (is_string($value))
|
||||
$str .= "{$name}: {$value}{$br}";
|
||||
|
||||
elseif (is_array($value)) {
|
||||
foreach ($value as $subval) {
|
||||
$str .= "{$name}: {$subval}{$br}";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return $str;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the entire response as string
|
||||
*
|
||||
* @param string $br Line breaks (eg. "\n", "\r\n", "<br />")
|
||||
* @return string
|
||||
*/
|
||||
public function asString($br = "\n")
|
||||
{
|
||||
return $this->getHeadersAsString(true, $br) . $br . $this->getRawBody();
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements magic __toString()
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function __toString()
|
||||
{
|
||||
return $this->asString();
|
||||
}
|
||||
|
||||
/**
|
||||
* A convenience function that returns a text representation of
|
||||
* HTTP response codes. Returns 'Unknown' for unknown codes.
|
||||
* Returns array of all codes, if $code is not specified.
|
||||
*
|
||||
* Conforms to HTTP/1.1 as defined in RFC 2616 (except for 'Unknown')
|
||||
* See http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10 for reference
|
||||
*
|
||||
* @param int $code HTTP response code
|
||||
* @param boolean $http11 Use HTTP version 1.1
|
||||
* @return string
|
||||
*/
|
||||
public static function responseCodeAsText($code = null, $http11 = true)
|
||||
{
|
||||
$messages = self::$messages;
|
||||
if (! $http11) $messages[302] = 'Moved Temporarily';
|
||||
|
||||
if ($code === null) {
|
||||
return $messages;
|
||||
} elseif (isset($messages[$code])) {
|
||||
return $messages[$code];
|
||||
} else {
|
||||
return 'Unknown';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract the response code from a response string
|
||||
*
|
||||
* @param string $response_str
|
||||
* @return int
|
||||
*/
|
||||
public static function extractCode($response_str)
|
||||
{
|
||||
preg_match("|^HTTP/[\d\.x]+ (\d+)|", $response_str, $m);
|
||||
|
||||
if (isset($m[1])) {
|
||||
return (int) $m[1];
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract the HTTP message from a response
|
||||
*
|
||||
* @param string $response_str
|
||||
* @return string
|
||||
*/
|
||||
public static function extractMessage($response_str)
|
||||
{
|
||||
preg_match("|^HTTP/[\d\.x]+ \d+ ([^\r\n]+)|", $response_str, $m);
|
||||
|
||||
if (isset($m[1])) {
|
||||
return $m[1];
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract the HTTP version from a response
|
||||
*
|
||||
* @param string $response_str
|
||||
* @return string
|
||||
*/
|
||||
public static function extractVersion($response_str)
|
||||
{
|
||||
preg_match("|^HTTP/([\d\.x]+) \d+|", $response_str, $m);
|
||||
|
||||
if (isset($m[1])) {
|
||||
return $m[1];
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract the headers from a response string
|
||||
*
|
||||
* @param string $response_str
|
||||
* @return array
|
||||
*/
|
||||
public static function extractHeaders($response_str)
|
||||
{
|
||||
$headers = array();
|
||||
|
||||
// First, split body and headers
|
||||
$parts = preg_split('|(?:\r?\n){2}|m', $response_str, 2);
|
||||
if (! $parts[0]) return $headers;
|
||||
|
||||
// Split headers part to lines
|
||||
$lines = explode("\n", $parts[0]);
|
||||
unset($parts);
|
||||
$last_header = null;
|
||||
|
||||
foreach($lines as $line) {
|
||||
$line = trim($line, "\r\n");
|
||||
if ($line == "") break;
|
||||
|
||||
if (preg_match("|^([\w-]+):\s+(.+)|", $line, $m)) {
|
||||
unset($last_header);
|
||||
$h_name = strtolower($m[1]);
|
||||
$h_value = $m[2];
|
||||
|
||||
if (isset($headers[$h_name])) {
|
||||
if (! is_array($headers[$h_name])) {
|
||||
$headers[$h_name] = array($headers[$h_name]);
|
||||
}
|
||||
|
||||
$headers[$h_name][] = $h_value;
|
||||
} else {
|
||||
$headers[$h_name] = $h_value;
|
||||
}
|
||||
$last_header = $h_name;
|
||||
} elseif (preg_match("|^\s+(.+)$|", $line, $m) && $last_header !== null) {
|
||||
if (is_array($headers[$last_header])) {
|
||||
end($headers[$last_header]);
|
||||
$last_header_key = key($headers[$last_header]);
|
||||
$headers[$last_header][$last_header_key] .= $m[1];
|
||||
} else {
|
||||
$headers[$last_header] .= $m[1];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return $headers;
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract the body from a response string
|
||||
*
|
||||
* @param string $response_str
|
||||
* @return string
|
||||
*/
|
||||
public static function extractBody($response_str)
|
||||
{
|
||||
$parts = preg_split('|(?:\r?\n){2}|m', $response_str, 2);
|
||||
if (isset($parts[1])) {
|
||||
return $parts[1];
|
||||
}
|
||||
return '';
|
||||
}
|
||||
|
||||
/**
|
||||
* Decode a "chunked" transfer-encoded body and return the decoded text
|
||||
*
|
||||
* @param string $body
|
||||
* @return string
|
||||
*/
|
||||
public static function decodeChunkedBody($body)
|
||||
{
|
||||
$decBody = '';
|
||||
|
||||
// If mbstring overloads substr and strlen functions, we have to
|
||||
// override it's internal encoding
|
||||
if (function_exists('mb_internal_encoding') &&
|
||||
((int) ini_get('mbstring.func_overload')) & 2) {
|
||||
|
||||
$mbIntEnc = mb_internal_encoding();
|
||||
mb_internal_encoding('ASCII');
|
||||
}
|
||||
|
||||
while (trim($body)) {
|
||||
if (! preg_match("/^([\da-fA-F]+)[^\r\n]*\r\n/sm", $body, $m)) {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception("Error parsing body - doesn't seem to be a chunked message");
|
||||
}
|
||||
|
||||
$length = hexdec(trim($m[1]));
|
||||
$cut = strlen($m[0]);
|
||||
$decBody .= substr($body, $cut, $length);
|
||||
$body = substr($body, $cut + $length + 2);
|
||||
}
|
||||
|
||||
if (isset($mbIntEnc)) {
|
||||
mb_internal_encoding($mbIntEnc);
|
||||
}
|
||||
|
||||
return $decBody;
|
||||
}
|
||||
|
||||
/**
|
||||
* Decode a gzip encoded message (when Content-encoding = gzip)
|
||||
*
|
||||
* Currently requires PHP with zlib support
|
||||
*
|
||||
* @param string $body
|
||||
* @return string
|
||||
*/
|
||||
public static function decodeGzip($body)
|
||||
{
|
||||
if (! function_exists('gzinflate')) {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception(
|
||||
'zlib extension is required in order to decode "gzip" encoding'
|
||||
);
|
||||
}
|
||||
|
||||
return gzinflate(substr($body, 10));
|
||||
}
|
||||
|
||||
/**
|
||||
* Decode a zlib deflated message (when Content-encoding = deflate)
|
||||
*
|
||||
* Currently requires PHP with zlib support
|
||||
*
|
||||
* @param string $body
|
||||
* @return string
|
||||
*/
|
||||
public static function decodeDeflate($body)
|
||||
{
|
||||
if (! function_exists('gzuncompress')) {
|
||||
require_once 'Zend/Http/Exception.php';
|
||||
throw new Zend_Http_Exception(
|
||||
'zlib extension is required in order to decode "deflate" encoding'
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Some servers (IIS ?) send a broken deflate response, without the
|
||||
* RFC-required zlib header.
|
||||
*
|
||||
* We try to detect the zlib header, and if it does not exsit we
|
||||
* teat the body is plain DEFLATE content.
|
||||
*
|
||||
* This method was adapted from PEAR HTTP_Request2 by (c) Alexey Borzov
|
||||
*
|
||||
* @link http://framework.zend.com/issues/browse/ZF-6040
|
||||
*/
|
||||
$zlibHeader = unpack('n', substr($body, 0, 2));
|
||||
if ($zlibHeader[1] % 31 == 0) {
|
||||
return gzuncompress($body);
|
||||
} else {
|
||||
return gzinflate($body);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new Zend_Http_Response object from a string
|
||||
*
|
||||
* @param string $response_str
|
||||
* @return Zend_Http_Response
|
||||
*/
|
||||
public static function fromString($response_str)
|
||||
{
|
||||
$code = self::extractCode($response_str);
|
||||
$headers = self::extractHeaders($response_str);
|
||||
$body = self::extractBody($response_str);
|
||||
$version = self::extractVersion($response_str);
|
||||
$message = self::extractMessage($response_str);
|
||||
|
||||
return new Zend_Http_Response($code, $headers, $body, $version, $message);
|
||||
}
|
||||
}
|
||||
235
airtime_mvc/library/Zend/Http/Response/Stream.php
Normal file
235
airtime_mvc/library/Zend/Http/Response/Stream.php
Normal file
|
|
@ -0,0 +1,235 @@
|
|||
<?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 Response
|
||||
* @version $Id: Response.php 17131 2009-07-26 10:03:39Z shahar $
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
|
||||
/**
|
||||
* Zend_Http_Response represents an HTTP 1.0 / 1.1 response message. It
|
||||
* includes easy access to all the response's different elemts, as well as some
|
||||
* convenience methods for parsing and validating HTTP responses.
|
||||
*
|
||||
* @package Zend_Http
|
||||
* @subpackage Response
|
||||
* @copyright Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
*/
|
||||
class Zend_Http_Response_Stream extends Zend_Http_Response
|
||||
{
|
||||
/**
|
||||
* Response as stream
|
||||
*
|
||||
* @var resource
|
||||
*/
|
||||
protected $stream;
|
||||
|
||||
/**
|
||||
* The name of the file containing the stream
|
||||
*
|
||||
* Will be empty if stream is not file-based.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected $stream_name;
|
||||
|
||||
/**
|
||||
* Should we clean up the stream file when this response is closed?
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
protected $_cleanup;
|
||||
|
||||
/**
|
||||
* Get the response as stream
|
||||
*
|
||||
* @return resourse
|
||||
*/
|
||||
public function getStream()
|
||||
{
|
||||
return $this->stream;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the response stream
|
||||
*
|
||||
* @param resourse $stream
|
||||
* @return Zend_Http_Response_Stream
|
||||
*/
|
||||
public function setStream($stream)
|
||||
{
|
||||
$this->stream = $stream;
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the cleanup trigger
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function getCleanup() {
|
||||
return $this->_cleanup;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the cleanup trigger
|
||||
*
|
||||
* @param $cleanup Set cleanup trigger
|
||||
*/
|
||||
public function setCleanup($cleanup = true) {
|
||||
$this->_cleanup = $cleanup;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get file name associated with the stream
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getStreamName() {
|
||||
return $this->stream_name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set file name associated with the stream
|
||||
*
|
||||
* @param string $stream_name Name to set
|
||||
* @return Zend_Http_Response_Stream
|
||||
*/
|
||||
public function setStreamName($stream_name) {
|
||||
$this->stream_name = $stream_name;
|
||||
return $this;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* HTTP response constructor
|
||||
*
|
||||
* In most cases, you would use Zend_Http_Response::fromString to parse an HTTP
|
||||
* response string and create a new Zend_Http_Response object.
|
||||
*
|
||||
* NOTE: The constructor no longer accepts nulls or empty values for the code and
|
||||
* headers and will throw an exception if the passed values do not form a valid HTTP
|
||||
* responses.
|
||||
*
|
||||
* If no message is passed, the message will be guessed according to the response code.
|
||||
*
|
||||
* @param int $code Response code (200, 404, ...)
|
||||
* @param array $headers Headers array
|
||||
* @param string $body Response body
|
||||
* @param string $version HTTP version
|
||||
* @param string $message Response code as text
|
||||
* @throws Zend_Http_Exception
|
||||
*/
|
||||
public function __construct($code, $headers, $body = null, $version = '1.1', $message = null)
|
||||
{
|
||||
|
||||
if(is_resource($body)) {
|
||||
$this->setStream($body);
|
||||
$body = '';
|
||||
}
|
||||
parent::__construct($code, $headers, $body, $version, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new Zend_Http_Response_Stream object from a string
|
||||
*
|
||||
* @param string $response_str
|
||||
* @param resource $stream
|
||||
* @return Zend_Http_Response_Stream
|
||||
*/
|
||||
public static function fromStream($response_str, $stream)
|
||||
{
|
||||
$code = self::extractCode($response_str);
|
||||
$headers = self::extractHeaders($response_str);
|
||||
$version = self::extractVersion($response_str);
|
||||
$message = self::extractMessage($response_str);
|
||||
|
||||
return new self($code, $headers, $stream, $version, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the response body as string
|
||||
*
|
||||
* This method returns the body of the HTTP response (the content), as it
|
||||
* should be in it's readable version - that is, after decoding it (if it
|
||||
* was decoded), deflating it (if it was gzip compressed), etc.
|
||||
*
|
||||
* If you want to get the raw body (as transfered on wire) use
|
||||
* $this->getRawBody() instead.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getBody()
|
||||
{
|
||||
if($this->stream != null) {
|
||||
$this->readStream();
|
||||
}
|
||||
return parent::getBody();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the raw response body (as transfered "on wire") as string
|
||||
*
|
||||
* If the body is encoded (with Transfer-Encoding, not content-encoding -
|
||||
* IE "chunked" body), gzip compressed, etc. it will not be decoded.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getRawBody()
|
||||
{
|
||||
if($this->stream) {
|
||||
$this->readStream();
|
||||
}
|
||||
return $this->body;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read stream content and return it as string
|
||||
*
|
||||
* Function reads the remainder of the body from the stream and closes the stream.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
protected function readStream()
|
||||
{
|
||||
if(!is_resource($this->stream)) {
|
||||
return '';
|
||||
}
|
||||
|
||||
if(isset($headers['content-length'])) {
|
||||
$this->body = stream_get_contents($this->stream, $headers['content-length']);
|
||||
} else {
|
||||
$this->body = stream_get_contents($this->stream);
|
||||
}
|
||||
fclose($this->stream);
|
||||
$this->stream = null;
|
||||
}
|
||||
|
||||
public function __destruct()
|
||||
{
|
||||
if(is_resource($this->stream)) {
|
||||
fclose($this->stream);
|
||||
$this->stream = null;
|
||||
}
|
||||
if($this->_cleanup) {
|
||||
@unlink($this->stream_name);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue