Mercurial > hg > Members > shoshi > webvirt
diff cake/libs/http_socket.php @ 0:261e66bd5a0c
hg init
author | Shoshi TAMAKI <shoshi@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Sun, 24 Jul 2011 21:08:31 +0900 |
parents | |
children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/cake/libs/http_socket.php Sun Jul 24 21:08:31 2011 +0900 @@ -0,0 +1,1081 @@ +<?php +/** + * HTTP Socket connection class. + * + * PHP versions 4 and 5 + * + * CakePHP(tm) : Rapid Development Framework (http://cakephp.org) + * Copyright 2005-2010, Cake Software Foundation, Inc. (http://cakefoundation.org) + * + * Licensed under The MIT License + * Redistributions of files must retain the above copyright notice. + * + * @copyright Copyright 2005-2010, Cake Software Foundation, Inc. (http://cakefoundation.org) + * @link http://cakephp.org CakePHP(tm) Project + * @package cake + * @subpackage cake.cake.libs + * @since CakePHP(tm) v 1.2.0 + * @license MIT License (http://www.opensource.org/licenses/mit-license.php) + */ +App::import('Core', array('CakeSocket', 'Set', 'Router')); + +/** + * Cake network socket connection class. + * + * Core base class for HTTP network communication. HttpSocket can be used as an + * Object Oriented replacement for cURL in many places. + * + * @package cake + * @subpackage cake.cake.libs + */ +class HttpSocket extends CakeSocket { + +/** + * Object description + * + * @var string + * @access public + */ + var $description = 'HTTP-based DataSource Interface'; + +/** + * When one activates the $quirksMode by setting it to true, all checks meant to + * enforce RFC 2616 (HTTP/1.1 specs). + * will be disabled and additional measures to deal with non-standard responses will be enabled. + * + * @var boolean + * @access public + */ + var $quirksMode = false; + +/** + * The default values to use for a request + * + * @var array + * @access public + */ + var $request = array( + 'method' => 'GET', + 'uri' => array( + 'scheme' => 'http', + 'host' => null, + 'port' => 80, + 'user' => null, + 'pass' => null, + 'path' => null, + 'query' => null, + 'fragment' => null + ), + 'auth' => array( + 'method' => 'Basic', + 'user' => null, + 'pass' => null + ), + 'version' => '1.1', + 'body' => '', + 'line' => null, + 'header' => array( + 'Connection' => 'close', + 'User-Agent' => 'CakePHP' + ), + 'raw' => null, + 'cookies' => array() + ); + +/** +* The default structure for storing the response +* +* @var array +* @access public +*/ + var $response = array( + 'raw' => array( + 'status-line' => null, + 'header' => null, + 'body' => null, + 'response' => null + ), + 'status' => array( + 'http-version' => null, + 'code' => null, + 'reason-phrase' => null + ), + 'header' => array(), + 'body' => '', + 'cookies' => array() + ); + +/** + * Default configuration settings for the HttpSocket + * + * @var array + * @access public + */ + var $config = array( + 'persistent' => false, + 'host' => 'localhost', + 'protocol' => 'tcp', + 'port' => 80, + 'timeout' => 30, + 'request' => array( + 'uri' => array( + 'scheme' => 'http', + 'host' => 'localhost', + 'port' => 80 + ), + 'auth' => array( + 'method' => 'Basic', + 'user' => null, + 'pass' => null + ), + 'cookies' => array() + ) + ); + +/** + * String that represents a line break. + * + * @var string + * @access public + */ + var $lineBreak = "\r\n"; + +/** + * Build an HTTP Socket using the specified configuration. + * + * You can use a url string to set the url and use default configurations for + * all other options: + * + * `$http =& new HttpSocket('http://cakephp.org/');` + * + * Or use an array to configure multiple options: + * + * {{{ + * $http =& new HttpSocket(array( + * 'host' => 'cakephp.org', + * 'timeout' => 20 + * )); + * }}} + * + * See HttpSocket::$config for options that can be used. + * + * @param mixed $config Configuration information, either a string url or an array of options. + * @access public + */ + function __construct($config = array()) { + if (is_string($config)) { + $this->_configUri($config); + } elseif (is_array($config)) { + if (isset($config['request']['uri']) && is_string($config['request']['uri'])) { + $this->_configUri($config['request']['uri']); + unset($config['request']['uri']); + } + $this->config = Set::merge($this->config, $config); + } + parent::__construct($this->config); + } + +/** + * Issue the specified request. HttpSocket::get() and HttpSocket::post() wrap this + * method and provide a more granular interface. + * + * @param mixed $request Either an URI string, or an array defining host/uri + * @return mixed false on error, request body on success + * @access public + */ + function request($request = array()) { + $this->reset(false); + + if (is_string($request)) { + $request = array('uri' => $request); + } elseif (!is_array($request)) { + return false; + } + + if (!isset($request['uri'])) { + $request['uri'] = null; + } + $uri = $this->_parseUri($request['uri']); + $hadAuth = false; + if (is_array($uri) && array_key_exists('user', $uri)) { + $hadAuth = true; + } + if (!isset($uri['host'])) { + $host = $this->config['host']; + } + if (isset($request['host'])) { + $host = $request['host']; + unset($request['host']); + } + $request['uri'] = $this->url($request['uri']); + $request['uri'] = $this->_parseUri($request['uri'], true); + $this->request = Set::merge($this->request, $this->config['request'], $request); + + if (!$hadAuth && !empty($this->config['request']['auth']['user'])) { + $this->request['uri']['user'] = $this->config['request']['auth']['user']; + $this->request['uri']['pass'] = $this->config['request']['auth']['pass']; + } + $this->_configUri($this->request['uri']); + + if (isset($host)) { + $this->config['host'] = $host; + } + $cookies = null; + + if (is_array($this->request['header'])) { + $this->request['header'] = $this->_parseHeader($this->request['header']); + if (!empty($this->request['cookies'])) { + $cookies = $this->buildCookies($this->request['cookies']); + } + $Host = $this->request['uri']['host']; + $schema = ''; + $port = 0; + if (isset($this->request['uri']['schema'])) { + $schema = $this->request['uri']['schema']; + } + if (isset($this->request['uri']['port'])) { + $port = $this->request['uri']['port']; + } + if ( + ($schema === 'http' && $port != 80) || + ($schema === 'https' && $port != 443) || + ($port != 80 && $port != 443) + ) { + $Host .= ':' . $port; + } + $this->request['header'] = array_merge(compact('Host'), $this->request['header']); + } + + if (isset($this->request['auth']['user']) && isset($this->request['auth']['pass'])) { + $this->request['header']['Authorization'] = $this->request['auth']['method'] . " " . base64_encode($this->request['auth']['user'] . ":" . $this->request['auth']['pass']); + } + if (isset($this->request['uri']['user']) && isset($this->request['uri']['pass'])) { + $this->request['header']['Authorization'] = $this->request['auth']['method'] . " " . base64_encode($this->request['uri']['user'] . ":" . $this->request['uri']['pass']); + } + + if (is_array($this->request['body'])) { + $this->request['body'] = $this->_httpSerialize($this->request['body']); + } + + if (!empty($this->request['body']) && !isset($this->request['header']['Content-Type'])) { + $this->request['header']['Content-Type'] = 'application/x-www-form-urlencoded'; + } + + if (!empty($this->request['body']) && !isset($this->request['header']['Content-Length'])) { + $this->request['header']['Content-Length'] = strlen($this->request['body']); + } + + $connectionType = null; + if (isset($this->request['header']['Connection'])) { + $connectionType = $this->request['header']['Connection']; + } + $this->request['header'] = $this->_buildHeader($this->request['header']) . $cookies; + + if (empty($this->request['line'])) { + $this->request['line'] = $this->_buildRequestLine($this->request); + } + + if ($this->quirksMode === false && $this->request['line'] === false) { + return $this->response = false; + } + + if ($this->request['line'] !== false) { + $this->request['raw'] = $this->request['line']; + } + + if ($this->request['header'] !== false) { + $this->request['raw'] .= $this->request['header']; + } + + $this->request['raw'] .= "\r\n"; + $this->request['raw'] .= $this->request['body']; + $this->write($this->request['raw']); + + $response = null; + while ($data = $this->read()) { + $response .= $data; + } + + if ($connectionType == 'close') { + $this->disconnect(); + } + + $this->response = $this->_parseResponse($response); + if (!empty($this->response['cookies'])) { + $this->config['request']['cookies'] = array_merge($this->config['request']['cookies'], $this->response['cookies']); + } + + return $this->response['body']; + } + +/** + * Issues a GET request to the specified URI, query, and request. + * + * Using a string uri and an array of query string parameters: + * + * `$response = $http->get('http://google.com/search', array('q' => 'cakephp', 'client' => 'safari'));` + * + * Would do a GET request to `http://google.com/search?q=cakephp&client=safari` + * + * You could express the same thing using a uri array and query string parameters: + * + * {{{ + * $response = $http->get( + * array('host' => 'google.com', 'path' => '/search'), + * array('q' => 'cakephp', 'client' => 'safari') + * ); + * }}} + * + * @param mixed $uri URI to request. Either a string uri, or a uri array, see HttpSocket::_parseUri() + * @param array $query Querystring parameters to append to URI + * @param array $request An indexed array with indexes such as 'method' or uri + * @return mixed Result of request, either false on failure or the response to the request. + * @access public + */ + function get($uri = null, $query = array(), $request = array()) { + if (!empty($query)) { + $uri = $this->_parseUri($uri); + if (isset($uri['query'])) { + $uri['query'] = array_merge($uri['query'], $query); + } else { + $uri['query'] = $query; + } + $uri = $this->_buildUri($uri); + } + + $request = Set::merge(array('method' => 'GET', 'uri' => $uri), $request); + return $this->request($request); + } + +/** + * Issues a POST request to the specified URI, query, and request. + * + * `post()` can be used to post simple data arrays to a url: + * + * {{{ + * $response = $http->post('http://example.com', array( + * 'username' => 'batman', + * 'password' => 'bruce_w4yne' + * )); + * }}} + * + * @param mixed $uri URI to request. See HttpSocket::_parseUri() + * @param array $data Array of POST data keys and values. + * @param array $request An indexed array with indexes such as 'method' or uri + * @return mixed Result of request, either false on failure or the response to the request. + * @access public + */ + function post($uri = null, $data = array(), $request = array()) { + $request = Set::merge(array('method' => 'POST', 'uri' => $uri, 'body' => $data), $request); + return $this->request($request); + } + +/** + * Issues a PUT request to the specified URI, query, and request. + * + * @param mixed $uri URI to request, See HttpSocket::_parseUri() + * @param array $data Array of PUT data keys and values. + * @param array $request An indexed array with indexes such as 'method' or uri + * @return mixed Result of request + * @access public + */ + function put($uri = null, $data = array(), $request = array()) { + $request = Set::merge(array('method' => 'PUT', 'uri' => $uri, 'body' => $data), $request); + return $this->request($request); + } + +/** + * Issues a DELETE request to the specified URI, query, and request. + * + * @param mixed $uri URI to request (see {@link _parseUri()}) + * @param array $data Query to append to URI + * @param array $request An indexed array with indexes such as 'method' or uri + * @return mixed Result of request + * @access public + */ + function delete($uri = null, $data = array(), $request = array()) { + $request = Set::merge(array('method' => 'DELETE', 'uri' => $uri, 'body' => $data), $request); + return $this->request($request); + } + +/** + * Normalizes urls into a $uriTemplate. If no template is provided + * a default one will be used. Will generate the url using the + * current config information. + * + * ### Usage: + * + * After configuring part of the request parameters, you can use url() to generate + * urls. + * + * {{{ + * $http->configUri('http://www.cakephp.org'); + * $url = $http->url('/search?q=bar'); + * }}} + * + * Would return `http://www.cakephp.org/search?q=bar` + * + * url() can also be used with custom templates: + * + * `$url = $http->url('http://www.cakephp/search?q=socket', '/%path?%query');` + * + * Would return `/search?q=socket`. + * + * @param mixed $url Either a string or array of url options to create a url with. + * @param string $uriTemplate A template string to use for url formatting. + * @return mixed Either false on failure or a string containing the composed url. + * @access public + */ + function url($url = null, $uriTemplate = null) { + if (is_null($url)) { + $url = '/'; + } + if (is_string($url)) { + if ($url{0} == '/') { + $url = $this->config['request']['uri']['host'].':'.$this->config['request']['uri']['port'] . $url; + } + if (!preg_match('/^.+:\/\/|\*|^\//', $url)) { + $url = $this->config['request']['uri']['scheme'].'://'.$url; + } + } elseif (!is_array($url) && !empty($url)) { + return false; + } + + $base = array_merge($this->config['request']['uri'], array('scheme' => array('http', 'https'), 'port' => array(80, 443))); + $url = $this->_parseUri($url, $base); + + if (empty($url)) { + $url = $this->config['request']['uri']; + } + + if (!empty($uriTemplate)) { + return $this->_buildUri($url, $uriTemplate); + } + return $this->_buildUri($url); + } + +/** + * Parses the given message and breaks it down in parts. + * + * @param string $message Message to parse + * @return array Parsed message (with indexed elements such as raw, status, header, body) + * @access protected + */ + function _parseResponse($message) { + if (is_array($message)) { + return $message; + } elseif (!is_string($message)) { + return false; + } + + static $responseTemplate; + + if (empty($responseTemplate)) { + $classVars = get_class_vars(__CLASS__); + $responseTemplate = $classVars['response']; + } + + $response = $responseTemplate; + + if (!preg_match("/^(.+\r\n)(.*)(?<=\r\n)\r\n/Us", $message, $match)) { + return false; + } + + list($null, $response['raw']['status-line'], $response['raw']['header']) = $match; + $response['raw']['response'] = $message; + $response['raw']['body'] = substr($message, strlen($match[0])); + + if (preg_match("/(.+) ([0-9]{3}) (.+)\r\n/DU", $response['raw']['status-line'], $match)) { + $response['status']['http-version'] = $match[1]; + $response['status']['code'] = (int)$match[2]; + $response['status']['reason-phrase'] = $match[3]; + } + + $response['header'] = $this->_parseHeader($response['raw']['header']); + $transferEncoding = null; + if (isset($response['header']['Transfer-Encoding'])) { + $transferEncoding = $response['header']['Transfer-Encoding']; + } + $decoded = $this->_decodeBody($response['raw']['body'], $transferEncoding); + $response['body'] = $decoded['body']; + + if (!empty($decoded['header'])) { + $response['header'] = $this->_parseHeader($this->_buildHeader($response['header']).$this->_buildHeader($decoded['header'])); + } + + if (!empty($response['header'])) { + $response['cookies'] = $this->parseCookies($response['header']); + } + + foreach ($response['raw'] as $field => $val) { + if ($val === '') { + $response['raw'][$field] = null; + } + } + + return $response; + } + +/** + * Generic function to decode a $body with a given $encoding. Returns either an array with the keys + * 'body' and 'header' or false on failure. + * + * @param string $body A string continaing the body to decode. + * @param mixed $encoding Can be false in case no encoding is being used, or a string representing the encoding. + * @return mixed Array of response headers and body or false. + * @access protected + */ + function _decodeBody($body, $encoding = 'chunked') { + if (!is_string($body)) { + return false; + } + if (empty($encoding)) { + return array('body' => $body, 'header' => false); + } + $decodeMethod = '_decode'.Inflector::camelize(str_replace('-', '_', $encoding)).'Body'; + + if (!is_callable(array(&$this, $decodeMethod))) { + if (!$this->quirksMode) { + trigger_error(sprintf(__('HttpSocket::_decodeBody - Unknown encoding: %s. Activate quirks mode to surpress error.', true), h($encoding)), E_USER_WARNING); + } + return array('body' => $body, 'header' => false); + } + return $this->{$decodeMethod}($body); + } + +/** + * Decodes a chunked message $body and returns either an array with the keys 'body' and 'header' or false as + * a result. + * + * @param string $body A string continaing the chunked body to decode. + * @return mixed Array of response headers and body or false. + * @access protected + */ + function _decodeChunkedBody($body) { + if (!is_string($body)) { + return false; + } + + $decodedBody = null; + $chunkLength = null; + + while ($chunkLength !== 0) { + if (!preg_match("/^([0-9a-f]+) *(?:;(.+)=(.+))?\r\n/iU", $body, $match)) { + if (!$this->quirksMode) { + trigger_error(__('HttpSocket::_decodeChunkedBody - Could not parse malformed chunk. Activate quirks mode to do this.', true), E_USER_WARNING); + return false; + } + break; + } + + $chunkSize = 0; + $hexLength = 0; + $chunkExtensionName = ''; + $chunkExtensionValue = ''; + if (isset($match[0])) { + $chunkSize = $match[0]; + } + if (isset($match[1])) { + $hexLength = $match[1]; + } + if (isset($match[2])) { + $chunkExtensionName = $match[2]; + } + if (isset($match[3])) { + $chunkExtensionValue = $match[3]; + } + + $body = substr($body, strlen($chunkSize)); + $chunkLength = hexdec($hexLength); + $chunk = substr($body, 0, $chunkLength); + if (!empty($chunkExtensionName)) { + /** + * @todo See if there are popular chunk extensions we should implement + */ + } + $decodedBody .= $chunk; + if ($chunkLength !== 0) { + $body = substr($body, $chunkLength+strlen("\r\n")); + } + } + + $entityHeader = false; + if (!empty($body)) { + $entityHeader = $this->_parseHeader($body); + } + return array('body' => $decodedBody, 'header' => $entityHeader); + } + +/** + * Parses and sets the specified URI into current request configuration. + * + * @param mixed $uri URI, See HttpSocket::_parseUri() + * @return array Current configuration settings + * @access protected + */ + function _configUri($uri = null) { + if (empty($uri)) { + return false; + } + + if (is_array($uri)) { + $uri = $this->_parseUri($uri); + } else { + $uri = $this->_parseUri($uri, true); + } + + if (!isset($uri['host'])) { + return false; + } + $config = array( + 'request' => array( + 'uri' => array_intersect_key($uri, $this->config['request']['uri']), + 'auth' => array_intersect_key($uri, $this->config['request']['auth']) + ) + ); + $this->config = Set::merge($this->config, $config); + $this->config = Set::merge($this->config, array_intersect_key($this->config['request']['uri'], $this->config)); + return $this->config; + } + +/** + * Takes a $uri array and turns it into a fully qualified URL string + * + * @param mixed $uri Either A $uri array, or a request string. Will use $this->config if left empty. + * @param string $uriTemplate The Uri template/format to use. + * @return mixed A fully qualified URL formated according to $uriTemplate, or false on failure + * @access protected + */ + function _buildUri($uri = array(), $uriTemplate = '%scheme://%user:%pass@%host:%port/%path?%query#%fragment') { + if (is_string($uri)) { + $uri = array('host' => $uri); + } + $uri = $this->_parseUri($uri, true); + + if (!is_array($uri) || empty($uri)) { + return false; + } + + $uri['path'] = preg_replace('/^\//', null, $uri['path']); + $uri['query'] = $this->_httpSerialize($uri['query']); + $stripIfEmpty = array( + 'query' => '?%query', + 'fragment' => '#%fragment', + 'user' => '%user:%pass@', + 'host' => '%host:%port/' + ); + + foreach ($stripIfEmpty as $key => $strip) { + if (empty($uri[$key])) { + $uriTemplate = str_replace($strip, null, $uriTemplate); + } + } + + $defaultPorts = array('http' => 80, 'https' => 443); + if (array_key_exists($uri['scheme'], $defaultPorts) && $defaultPorts[$uri['scheme']] == $uri['port']) { + $uriTemplate = str_replace(':%port', null, $uriTemplate); + } + foreach ($uri as $property => $value) { + $uriTemplate = str_replace('%'.$property, $value, $uriTemplate); + } + + if ($uriTemplate === '/*') { + $uriTemplate = '*'; + } + return $uriTemplate; + } + +/** + * Parses the given URI and breaks it down into pieces as an indexed array with elements + * such as 'scheme', 'port', 'query'. + * + * @param string $uri URI to parse + * @param mixed $base If true use default URI config, otherwise indexed array to set 'scheme', 'host', 'port', etc. + * @return array Parsed URI + * @access protected + */ + function _parseUri($uri = null, $base = array()) { + $uriBase = array( + 'scheme' => array('http', 'https'), + 'host' => null, + 'port' => array(80, 443), + 'user' => null, + 'pass' => null, + 'path' => '/', + 'query' => null, + 'fragment' => null + ); + + if (is_string($uri)) { + $uri = parse_url($uri); + } + if (!is_array($uri) || empty($uri)) { + return false; + } + if ($base === true) { + $base = $uriBase; + } + + if (isset($base['port'], $base['scheme']) && is_array($base['port']) && is_array($base['scheme'])) { + if (isset($uri['scheme']) && !isset($uri['port'])) { + $base['port'] = $base['port'][array_search($uri['scheme'], $base['scheme'])]; + } elseif (isset($uri['port']) && !isset($uri['scheme'])) { + $base['scheme'] = $base['scheme'][array_search($uri['port'], $base['port'])]; + } + } + + if (is_array($base) && !empty($base)) { + $uri = array_merge($base, $uri); + } + + if (isset($uri['scheme']) && is_array($uri['scheme'])) { + $uri['scheme'] = array_shift($uri['scheme']); + } + if (isset($uri['port']) && is_array($uri['port'])) { + $uri['port'] = array_shift($uri['port']); + } + + if (array_key_exists('query', $uri)) { + $uri['query'] = $this->_parseQuery($uri['query']); + } + + if (!array_intersect_key($uriBase, $uri)) { + return false; + } + return $uri; + } + +/** + * This function can be thought of as a reverse to PHP5's http_build_query(). It takes a given query string and turns it into an array and + * supports nesting by using the php bracket syntax. So this menas you can parse queries like: + * + * - ?key[subKey]=value + * - ?key[]=value1&key[]=value2 + * + * A leading '?' mark in $query is optional and does not effect the outcome of this function. + * For the complete capabilities of this implementation take a look at HttpSocketTest::testparseQuery() + * + * @param mixed $query A query string to parse into an array or an array to return directly "as is" + * @return array The $query parsed into a possibly multi-level array. If an empty $query is + * given, an empty array is returned. + * @access protected + */ + function _parseQuery($query) { + if (is_array($query)) { + return $query; + } + $parsedQuery = array(); + + if (is_string($query) && !empty($query)) { + $query = preg_replace('/^\?/', '', $query); + $items = explode('&', $query); + + foreach ($items as $item) { + if (strpos($item, '=') !== false) { + list($key, $value) = explode('=', $item, 2); + } else { + $key = $item; + $value = null; + } + + $key = urldecode($key); + $value = urldecode($value); + + if (preg_match_all('/\[([^\[\]]*)\]/iUs', $key, $matches)) { + $subKeys = $matches[1]; + $rootKey = substr($key, 0, strpos($key, '[')); + if (!empty($rootKey)) { + array_unshift($subKeys, $rootKey); + } + $queryNode =& $parsedQuery; + + foreach ($subKeys as $subKey) { + if (!is_array($queryNode)) { + $queryNode = array(); + } + + if ($subKey === '') { + $queryNode[] = array(); + end($queryNode); + $subKey = key($queryNode); + } + $queryNode =& $queryNode[$subKey]; + } + $queryNode = $value; + } else { + $parsedQuery[$key] = $value; + } + } + } + return $parsedQuery; + } + +/** + * Builds a request line according to HTTP/1.1 specs. Activate quirks mode to work outside specs. + * + * @param array $request Needs to contain a 'uri' key. Should also contain a 'method' key, otherwise defaults to GET. + * @param string $versionToken The version token to use, defaults to HTTP/1.1 + * @return string Request line + * @access protected + */ + function _buildRequestLine($request = array(), $versionToken = 'HTTP/1.1') { + $asteriskMethods = array('OPTIONS'); + + if (is_string($request)) { + $isValid = preg_match("/(.+) (.+) (.+)\r\n/U", $request, $match); + if (!$this->quirksMode && (!$isValid || ($match[2] == '*' && !in_array($match[3], $asteriskMethods)))) { + trigger_error(__('HttpSocket::_buildRequestLine - Passed an invalid request line string. Activate quirks mode to do this.', true), E_USER_WARNING); + return false; + } + return $request; + } elseif (!is_array($request)) { + return false; + } elseif (!array_key_exists('uri', $request)) { + return false; + } + + $request['uri'] = $this->_parseUri($request['uri']); + $request = array_merge(array('method' => 'GET'), $request); + $request['uri'] = $this->_buildUri($request['uri'], '/%path?%query'); + + if (!$this->quirksMode && $request['uri'] === '*' && !in_array($request['method'], $asteriskMethods)) { + trigger_error(sprintf(__('HttpSocket::_buildRequestLine - The "*" asterisk character is only allowed for the following methods: %s. Activate quirks mode to work outside of HTTP/1.1 specs.', true), join(',', $asteriskMethods)), E_USER_WARNING); + return false; + } + return $request['method'].' '.$request['uri'].' '.$versionToken.$this->lineBreak; + } + +/** + * Serializes an array for transport. + * + * @param array $data Data to serialize + * @return string Serialized variable + * @access protected + */ + function _httpSerialize($data = array()) { + if (is_string($data)) { + return $data; + } + if (empty($data) || !is_array($data)) { + return false; + } + return substr(Router::queryString($data), 1); + } + +/** + * Builds the header. + * + * @param array $header Header to build + * @return string Header built from array + * @access protected + */ + function _buildHeader($header, $mode = 'standard') { + if (is_string($header)) { + return $header; + } elseif (!is_array($header)) { + return false; + } + + $returnHeader = ''; + foreach ($header as $field => $contents) { + if (is_array($contents) && $mode == 'standard') { + $contents = implode(',', $contents); + } + foreach ((array)$contents as $content) { + $contents = preg_replace("/\r\n(?![\t ])/", "\r\n ", $content); + $field = $this->_escapeToken($field); + + $returnHeader .= $field.': '.$contents.$this->lineBreak; + } + } + return $returnHeader; + } + +/** + * Parses an array based header. + * + * @param array $header Header as an indexed array (field => value) + * @return array Parsed header + * @access protected + */ + function _parseHeader($header) { + if (is_array($header)) { + foreach ($header as $field => $value) { + unset($header[$field]); + $field = strtolower($field); + preg_match_all('/(?:^|(?<=-))[a-z]/U', $field, $offsets, PREG_OFFSET_CAPTURE); + + foreach ($offsets[0] as $offset) { + $field = substr_replace($field, strtoupper($offset[0]), $offset[1], 1); + } + $header[$field] = $value; + } + return $header; + } elseif (!is_string($header)) { + return false; + } + + preg_match_all("/(.+):(.+)(?:(?<![\t ])" . $this->lineBreak . "|\$)/Uis", $header, $matches, PREG_SET_ORDER); + + $header = array(); + foreach ($matches as $match) { + list(, $field, $value) = $match; + + $value = trim($value); + $value = preg_replace("/[\t ]\r\n/", "\r\n", $value); + + $field = $this->_unescapeToken($field); + + $field = strtolower($field); + preg_match_all('/(?:^|(?<=-))[a-z]/U', $field, $offsets, PREG_OFFSET_CAPTURE); + foreach ($offsets[0] as $offset) { + $field = substr_replace($field, strtoupper($offset[0]), $offset[1], 1); + } + + if (!isset($header[$field])) { + $header[$field] = $value; + } else { + $header[$field] = array_merge((array)$header[$field], (array)$value); + } + } + return $header; + } + +/** + * Parses cookies in response headers. + * + * @param array $header Header array containing one ore more 'Set-Cookie' headers. + * @return mixed Either false on no cookies, or an array of cookies received. + * @access public + * @todo Make this 100% RFC 2965 confirm + */ + function parseCookies($header) { + if (!isset($header['Set-Cookie'])) { + return false; + } + + $cookies = array(); + foreach ((array)$header['Set-Cookie'] as $cookie) { + if (strpos($cookie, '";"') !== false) { + $cookie = str_replace('";"', "{__cookie_replace__}", $cookie); + $parts = str_replace("{__cookie_replace__}", '";"', explode(';', $cookie)); + } else { + $parts = preg_split('/\;[ \t]*/', $cookie); + } + + list($name, $value) = explode('=', array_shift($parts), 2); + $cookies[$name] = compact('value'); + + foreach ($parts as $part) { + if (strpos($part, '=') !== false) { + list($key, $value) = explode('=', $part); + } else { + $key = $part; + $value = true; + } + + $key = strtolower($key); + if (!isset($cookies[$name][$key])) { + $cookies[$name][$key] = $value; + } + } + } + return $cookies; + } + +/** + * Builds cookie headers for a request. + * + * @param array $cookies Array of cookies to send with the request. + * @return string Cookie header string to be sent with the request. + * @access public + * @todo Refactor token escape mechanism to be configurable + */ + function buildCookies($cookies) { + $header = array(); + foreach ($cookies as $name => $cookie) { + $header[] = $name.'='.$this->_escapeToken($cookie['value'], array(';')); + } + $header = $this->_buildHeader(array('Cookie' => implode('; ', $header)), 'pragmatic'); + return $header; + } + +/** + * Unescapes a given $token according to RFC 2616 (HTTP 1.1 specs) + * + * @param string $token Token to unescape + * @return string Unescaped token + * @access protected + * @todo Test $chars parameter + */ + function _unescapeToken($token, $chars = null) { + $regex = '/"(['.join('', $this->_tokenEscapeChars(true, $chars)).'])"/'; + $token = preg_replace($regex, '\\1', $token); + return $token; + } + +/** + * Escapes a given $token according to RFC 2616 (HTTP 1.1 specs) + * + * @param string $token Token to escape + * @return string Escaped token + * @access protected + * @todo Test $chars parameter + */ + function _escapeToken($token, $chars = null) { + $regex = '/(['.join('', $this->_tokenEscapeChars(true, $chars)).'])/'; + $token = preg_replace($regex, '"\\1"', $token); + return $token; + } + +/** + * Gets escape chars according to RFC 2616 (HTTP 1.1 specs). + * + * @param boolean $hex true to get them as HEX values, false otherwise + * @return array Escape chars + * @access protected + * @todo Test $chars parameter + */ + function _tokenEscapeChars($hex = true, $chars = null) { + if (!empty($chars)) { + $escape = $chars; + } else { + $escape = array('"', "(", ")", "<", ">", "@", ",", ";", ":", "\\", "/", "[", "]", "?", "=", "{", "}", " "); + for ($i = 0; $i <= 31; $i++) { + $escape[] = chr($i); + } + $escape[] = chr(127); + } + + if ($hex == false) { + return $escape; + } + $regexChars = ''; + foreach ($escape as $key => $char) { + $escape[$key] = '\\x'.str_pad(dechex(ord($char)), 2, '0', STR_PAD_LEFT); + } + return $escape; + } + +/** + * Resets the state of this HttpSocket instance to it's initial state (before Object::__construct got executed) or does + * the same thing partially for the request and the response property only. + * + * @param boolean $full If set to false only HttpSocket::response and HttpSocket::request are reseted + * @return boolean True on success + * @access public + */ + function reset($full = true) { + static $initalState = array(); + if (empty($initalState)) { + $initalState = get_class_vars(__CLASS__); + } + if ($full == false) { + $this->request = $initalState['request']; + $this->response = $initalState['response']; + return true; + } + parent::reset($initalState); + return true; + } +}