/**

function request( $url, $args = array() ) {

global $wp_version;

$defaults = array(

'method' => 'GET',

'timeout' => apply_filters( 'http_request_timeout', 5),

'redirection' => apply_filters( 'http_request_redirection_count', 5),

'httpversion' => apply_filters( 'http_request_version', '1.0'),

'user-agent' => apply_filters( 'http_headers_useragent', 'WordPress/' . $wp_version . '; ' . get_bloginfo( 'url' ) ),

'reject_unsafe_urls' => apply_filters( 'http_request_reject_unsafe_urls', false ),

'blocking' => true,

'headers' => array(),

'cookies' => array(),

'body' => null,

'compress' => false,

'decompress' => true,

'sslverify' => true,

'sslcertificates' => ABSPATH . WPINC . '/certificates/ca-bundle.crt',

'stream' => false,

'filename' => null,

'limit_response_size' => null,

);

// Pre-parse for the HEAD checks.

$args = wp_parse_args( $args );

// By default, Head requests do not cause redirections.

if ( isset($args['method']) && 'HEAD' == $args['method'] )

$defaults['redirection'] = 0;

$r = wp_parse_args( $args, $defaults );

$r = apply_filters( 'http_request_args', $r, $url );

// The transports decrement this, store a copy of the original value for loop purposes.

if ( ! isset( $r['_redirection'] ) )

$r['_redirection'] = $r['redirection'];

// Allow plugins to short-circuit the request

$pre = apply_filters( 'pre_http_request', false, $r, $url );

if ( false !== $pre )

return $pre;

if ( function_exists( 'wp_kses_bad_protocol' ) ) {

if ( $r['reject_unsafe_urls'] )

$url = wp_http_validate_url( $url );

$url = wp_kses_bad_protocol( $url, array( 'http', 'https', 'ssl' ) );

}

$arrURL = @parse_url( $url );

if ( empty( $url ) || empty( $arrURL['scheme'] ) )

return new WP_Error('http_request_failed', __('A valid URL was not provided.'));

if ( $this->block_request( $url ) )

return new WP_Error( 'http_request_failed', __( 'User has blocked requests through HTTP.' ) );

// Determine if this is a https call and pass that on to the transport functions

// so that we can blacklist the transports that do not support ssl verification

$r['ssl'] = $arrURL['scheme'] == 'https' || $arrURL['scheme'] == 'ssl';

// Determine if this request is to OUR install of WordPress

$homeURL = parse_url( get_bloginfo( 'url' ) );

$r['local'] = $homeURL['host'] == $arrURL['host'] || 'localhost' == $arrURL['host'];

unset( $homeURL );

// If we are streaming to a file but no filename was given drop it in the WP temp dir

// and pick its name using the basename of the $url

if ( $r['stream'] && empty( $r['filename'] ) )

$r['filename'] = get_temp_dir() . basename( $url );

// Force some settings if we are streaming to a file and check for existence and perms of destination directory

if ( $r['stream'] ) {

$r['blocking'] = true;

if ( ! wp_is_writable( dirname( $r['filename'] ) ) )

return new WP_Error( 'http_request_failed', __( 'Destination directory for file streaming does not exist or is not writable.' ) );

}

if ( is_null( $r['headers'] ) )

$r['headers'] = array();

if ( ! is_array( $r['headers'] ) ) {

$processedHeaders = WP_Http::processHeaders( $r['headers'], $url );

$r['headers'] = $processedHeaders['headers'];

}

if ( isset( $r['headers']['User-Agent'] ) ) {

$r['user-agent'] = $r['headers']['User-Agent'];

unset( $r['headers']['User-Agent'] );

}

if ( isset( $r['headers']['user-agent'] ) ) {

$r['user-agent'] = $r['headers']['user-agent'];

unset( $r['headers']['user-agent'] );

}

if ( '1.1' == $r['httpversion'] && !isset( $r['headers']['connection'] ) ) {

$r['headers']['connection'] = 'close';

}

// Construct Cookie: header if any cookies are set

WP_Http::buildCookieHeader( $r );

// Avoid issues where mbstring.func_overload is enabled

mbstring_binary_safe_encoding();

if ( ! isset( $r['headers']['Accept-Encoding'] ) ) {

if ( $encoding = WP_Http_Encoding::accept_encoding( $url, $r ) )

$r['headers']['Accept-Encoding'] = $encoding;

}

if ( ( ! is_null( $r['body'] ) && '' != $r['body'] ) || 'POST' == $r['method'] || 'PUT' == $r['method'] ) {

if ( is_array( $r['body'] ) || is_object( $r['body'] ) ) {

$r['body'] = http_build_query( $r['body'], null, '&' );

if ( ! isset( $r['headers']['Content-Type'] ) )

$r['headers']['Content-Type'] = 'application/x-www-form-urlencoded; charset=' . get_option( 'blog_charset' );

}

if ( '' === $r['body'] )

$r['body'] = null;

if ( ! isset( $r['headers']['Content-Length'] ) && ! isset( $r['headers']['content-length'] ) )

$r['headers']['Content-Length'] = strlen( $r['body'] );

}

$response = $this->_dispatch_request( $url, $r );

reset_mbstring_encoding();

if ( is_wp_error( $response ) )

return $response;

// Append cookies that were used in this request to the response

if ( ! empty( $r['cookies'] ) ) {

$cookies_set = wp_list_pluck( $response['cookies'], 'name' );

foreach ( $r['cookies'] as $cookie ) {

if ( ! in_array( $cookie->name, $cookies_set ) && $cookie->test( $url ) ) {

$response['cookies'][] = $cookie;

}

}

}

return $response;

}

/**

public function _get_first_available_transport( $args, $url = null ) {

$request_order = apply_filters( 'http_api_transports', array( 'curl', 'streams' ), $args, $url );

// Loop over each transport on each HTTP request looking for one which will serve this request's needs

foreach ( $request_order as $transport ) {

$class = 'WP_HTTP_' . $transport;

// Check to see if this transport is a possibility, calls the transport statically

if ( !call_user_func( array( $class, 'test' ), $args, $url ) )

continue;

return $class;

}

return false;

}

/**

private function _dispatch_request( $url, $args ) {

static $transports = array();

$class = $this->_get_first_available_transport( $args, $url );

if ( !$class )

return new WP_Error( 'http_failure', __( 'There are no HTTP transports available which can complete the requested request.' ) );

// Transport claims to support request, instantiate it and give it a whirl.

if ( empty( $transports[$class] ) )

$transports[$class] = new $class;

$response = $transports[$class]->request( $url, $args );

do_action( 'http_api_debug', $response, 'response', $class, $args, $url );

if ( is_wp_error( $response ) )

return $response;

return apply_filters( 'http_response', $response, $args, $url );

}

/**

function post($url, $args = array()) {

$defaults = array('method' => 'POST');

$r = wp_parse_args( $args, $defaults );

return $this->request($url, $r);

}

/**

function get($url, $args = array()) {

$defaults = array('method' => 'GET');

$r = wp_parse_args( $args, $defaults );

return $this->request($url, $r);

}

/**

function head($url, $args = array()) {

$defaults = array('method' => 'HEAD');

$r = wp_parse_args( $args, $defaults );

return $this->request($url, $r);

}

/**

public static function processResponse($strResponse) {

$res = explode("\r\n\r\n", $strResponse, 2);

return array('headers' => $res[0], 'body' => isset($res[1]) ? $res[1] : '');

}

/**

public static function processHeaders( $headers, $url = '' ) {

// split headers, one per array element

if ( is_string($headers) ) {

// tolerate line terminator: CRLF = LF (RFC 2616 19.3)

$headers = str_replace("\r\n", "\n", $headers);

// unfold folded header fields. LWS = [CRLF] 1*( SP | HT ) <US-ASCII SP, space (32)>, <US-ASCII HT, horizontal-tab (9)> (RFC 2616 2.2)

$headers = preg_replace('/\n[ \t]/', ' ', $headers);

// create the headers array

$headers = explode("\n", $headers);

}

$response = array('code' => 0, 'message' => '');

// If a redirection has taken place, The headers for each page request may have been passed.

// In this case, determine the final HTTP header and parse from there.

for ( $i = count($headers)-1; $i >= 0; $i-- ) {

if ( !empty($headers[$i]) && false === strpos($headers[$i], ':') ) {

$headers = array_splice($headers, $i);

break;

}

}

$cookies = array();

$newheaders = array();

foreach ( (array) $headers as $tempheader ) {

if ( empty($tempheader) )

continue;

if ( false === strpos($tempheader, ':') ) {

$stack = explode(' ', $tempheader, 3);

$stack[] = '';

list( , $response['code'], $response['message']) = $stack;

continue;

}

list($key, $value) = explode(':', $tempheader, 2);

$key = strtolower( $key );

$value = trim( $value );

if ( isset( $newheaders[ $key ] ) ) {

if ( ! is_array( $newheaders[ $key ] ) )

$newheaders[$key] = array( $newheaders[ $key ] );

$newheaders[ $key ][] = $value;

} else {

$newheaders[ $key ] = $value;

}

if ( 'set-cookie' == $key )

$cookies[] = new WP_Http_Cookie( $value, $url );

}

return array('response' => $response, 'headers' => $newheaders, 'cookies' => $cookies);

}

/**

public static function buildCookieHeader( &$r ) {

if ( ! empty($r['cookies']) ) {

// Upgrade any name => value cookie pairs to WP_HTTP_Cookie instances

foreach ( $r['cookies'] as $name => $value ) {

if ( ! is_object( $value ) )

$r['cookies'][ $name ] = new WP_HTTP_Cookie( array( 'name' => $name, 'value' => $value ) );

}

$cookies_header = '';

foreach ( (array) $r['cookies'] as $cookie ) {

$cookies_header .= $cookie->getHeaderValue() . '; ';

}

$cookies_header = substr( $cookies_header, 0, -2 );

$r['headers']['cookie'] = $cookies_header;

}

}

/**

public static function chunkTransferDecode( $body ) {

// The body is not chunked encoded or is malformed.

if ( ! preg_match( '/^([0-9a-f]+)[^\r\n]*\r\n/i', trim( $body ) ) )

return $body;

$parsed_body = '';

$body_original = $body; // We'll be altering $body, so need a backup in case of error

while ( true ) {

$has_chunk = (bool) preg_match( '/^([0-9a-f]+)[^\r\n]*\r\n/i', $body, $match );

if ( ! $has_chunk || empty( $match[1] ) )

return $body_original;

$length = hexdec( $match[1] );

$chunk_length = strlen( $match[0] );

// Parse out the chunk of data

$parsed_body .= substr( $body, $chunk_length, $length );

// Remove the chunk from the raw data

$body = substr( $body, $length + $chunk_length );

// End of document

if ( '0' === trim( $body ) )

return $parsed_body;

}

}

/**

function block_request($uri) {

// We don't need to block requests, because nothing is blocked.

if ( ! defined( 'WP_HTTP_BLOCK_EXTERNAL' ) || ! WP_HTTP_BLOCK_EXTERNAL )

return false;

$check = parse_url($uri);

if ( ! $check )

return true;

$home = parse_url( get_option('siteurl') );

// Don't block requests back to ourselves by default

if ( $check['host'] == 'localhost' || $check['host'] == $home['host'] )

return apply_filters('block_local_requests', false);

if ( !defined('WP_ACCESSIBLE_HOSTS') )

return true;

static $accessible_hosts;

static $wildcard_regex = false;

if ( null == $accessible_hosts ) {

$accessible_hosts = preg_split('|,\s*|', WP_ACCESSIBLE_HOSTS);

if ( false !== strpos(WP_ACCESSIBLE_HOSTS, '*') ) {

$wildcard_regex = array();

foreach ( $accessible_hosts as $host )

$wildcard_regex[] = str_replace( '\*', '.+', preg_quote( $host, '/' ) );

$wildcard_regex = '/^(' . implode('|', $wildcard_regex) . ')$/i';

}

}

if ( !empty($wildcard_regex) )

return !preg_match($wildcard_regex, $check['host']);

else

return !in_array( $check['host'], $accessible_hosts ); //Inverse logic, If it's in the array, then we can't access it.

}

static function make_absolute_url( $maybe_relative_path, $url ) {

if ( empty( $url ) )

return $maybe_relative_path;

// Check for a scheme

if ( false !== strpos( $maybe_relative_path, '://' ) )

return $maybe_relative_path;

if ( ! $url_parts = @parse_url( $url ) )

return $maybe_relative_path;

if ( ! $relative_url_parts = @parse_url( $maybe_relative_path ) )

return $maybe_relative_path;

$absolute_path = $url_parts['scheme'] . '://' . $url_parts['host'];

if ( isset( $url_parts['port'] ) )

$absolute_path .= ':' . $url_parts['port'];

// Start off with the Absolute URL path

$path = ! empty( $url_parts['path'] ) ? $url_parts['path'] : '/';

// If it's a root-relative path, then great

if ( ! empty( $relative_url_parts['path'] ) && '/' == $relative_url_parts['path'][0] ) {

$path = $relative_url_parts['path'];

// Else it's a relative path

} elseif ( ! empty( $relative_url_parts['path'] ) ) {

// Strip off any file components from the absolute path

$path = substr( $path, 0, strrpos( $path, '/' ) + 1 );

// Build the new path

$path .= $relative_url_parts['path'];

// Strip all /path/../ out of the path

while ( strpos( $path, '../' ) > 1 ) {

$path = preg_replace( '![^/]+/\.\./!', '', $path );

}

// Strip any final leading ../ from the path

$path = preg_replace( '!^/(\.\./)+!', '', $path );

}

// Add the Query string

if ( ! empty( $relative_url_parts['query'] ) )

$path .= '?' . $relative_url_parts['query'];

return $absolute_path . '/' . ltrim( $path, '/' );

}

/**

static function handle_redirects( $url, $args, $response ) {

// If no redirects are present, or, redirects were not requested, perform no action.

if ( ! isset( $response['headers']['location'] ) || 0 === $args['_redirection'] )

return false;

// Only perform redirections on redirection http codes

if ( $response['response']['code'] > 399 || $response['response']['code'] < 300 )

return false;

// Don't redirect if we've run out of redirects

if ( $args['redirection']-- <= 0 )

return new WP_Error( 'http_request_failed', __('Too many redirects.') );

$redirect_location = $response['headers']['location'];

// If there were multiple Location headers, use the last header specified

if ( is_array( $redirect_location ) )

$redirect_location = array_pop( $redirect_location );

$redirect_location = WP_HTTP::make_absolute_url( $redirect_location, $url );

// POST requests should not POST to a redirected location

if ( 'POST' == $args['method'] ) {

if ( in_array( $response['response']['code'], array( 302, 303 ) ) )

$args['method'] = 'GET';

}

// Include valid cookies in the redirect process

if ( ! empty( $response['cookies'] ) ) {

foreach ( $response['cookies'] as $cookie ) {

if ( $cookie->test( $redirect_location ) )

$args['cookies'][] = $cookie;

}

}

return wp_remote_request( $redirect_location, $args );

}

/**

static function is_ip_address( $maybe_ip ) {

if ( preg_match( '/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/', $maybe_ip ) )

return 4;

if ( false !== strpos( $maybe_ip, ':' ) && preg_match( '/^(((?=.*(::))(?!.*\3.+\3))\3?|([\dA-F]{1,4}(\3|:\b|$)|\2))(?4){5}((?4){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})$/i', trim( $maybe_ip, ' []' ) ) )

return 6;

return false;

}

/**

function request($url, $args = array()) {

$defaults = array(

'method' => 'GET', 'timeout' => 5,

'redirection' => 5, 'httpversion' => '1.0',

'blocking' => true,

'headers' => array(), 'body' => null, 'cookies' => array()

);

$r = wp_parse_args( $args, $defaults );

if ( isset($r['headers']['User-Agent']) ) {

$r['user-agent'] = $r['headers']['User-Agent'];

unset($r['headers']['User-Agent']);

} else if ( isset($r['headers']['user-agent']) ) {

$r['user-agent'] = $r['headers']['user-agent'];

unset($r['headers']['user-agent']);

}

// Construct Cookie: header if any cookies are set

WP_Http::buildCookieHeader( $r );

$arrURL = parse_url($url);

$connect_host = $arrURL['host'];

$secure_transport = ( $arrURL['scheme'] == 'ssl' || $arrURL['scheme'] == 'https' );

if ( ! isset( $arrURL['port'] ) ) {

if ( $arrURL['scheme'] == 'ssl' || $arrURL['scheme'] == 'https' ) {

$arrURL['port'] = 443;

$secure_transport = true;

} else {

$arrURL['port'] = 80;

}

}

if ( isset( $r['headers']['Host'] ) || isset( $r['headers']['host'] ) ) {

if ( isset( $r['headers']['Host'] ) )

$arrURL['host'] = $r['headers']['Host'];

else

$arrURL['host'] = $r['headers']['host'];

unset( $r['headers']['Host'], $r['headers']['host'] );

}

// Certain versions of PHP have issues with 'localhost' and IPv6, It attempts to connect to ::1,

// which fails when the server is not set up for it. For compatibility, always connect to the IPv4 address.

if ( 'localhost' == strtolower( $connect_host ) )

$connect_host = '127.0.0.1';

$connect_host = $secure_transport ? 'ssl://' . $connect_host : 'tcp://' . $connect_host;

$is_local = isset( $r['local'] ) && $r['local'];

$ssl_verify = isset( $r['sslverify'] ) && $r['sslverify'];

if ( $is_local )

$ssl_verify = apply_filters( 'https_local_ssl_verify', $ssl_verify );

elseif ( ! $is_local )

$ssl_verify = apply_filters( 'https_ssl_verify', $ssl_verify );

$proxy = new WP_HTTP_Proxy();

$context = stream_context_create( array(

'ssl' => array(

'verify_peer' => $ssl_verify,

//'CN_match' => $arrURL['host'], // This is handled by self::verify_ssl_certificate()

'capture_peer_cert' => $ssl_verify,

'SNI_enabled' => true,

'cafile' => $r['sslcertificates'],

'allow_self_signed' => ! $ssl_verify,

)

) );

$timeout = (int) floor( $r['timeout'] );

$utimeout = $timeout == $r['timeout'] ? 0 : 1000000 * $r['timeout'] % 1000000;

$connect_timeout = max( $timeout, 1 );

$connection_error = null; // Store error number

$connection_error_str = null; // Store error string

if ( !WP_DEBUG ) {

// In the event that the SSL connection fails, silence the many PHP Warnings

if ( $secure_transport )

$error_reporting = error_reporting(0);

if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) )

$handle = @stream_socket_client( 'tcp://' . $proxy->host() . ':' . $proxy->port(), $connection_error, $connection_error_str, $connect_timeout, STREAM_CLIENT_CONNECT, $context );

else

$handle = @stream_socket_client( $connect_host . ':' . $arrURL['port'], $connection_error, $connection_error_str, $connect_timeout, STREAM_CLIENT_CONNECT, $context );

if ( $secure_transport )

error_reporting( $error_reporting );

} else {

if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) )

$handle = stream_socket_client( 'tcp://' . $proxy->host() . ':' . $proxy->port(), $connection_error, $connection_error_str, $connect_timeout, STREAM_CLIENT_CONNECT, $context );

else

$handle = stream_socket_client( $connect_host . ':' . $arrURL['port'], $connection_error, $connection_error_str, $connect_timeout, STREAM_CLIENT_CONNECT, $context );

}

if ( false === $handle ) {

// SSL connection failed due to expired/invalid cert, or, OpenSSL configuration is broken

if ( $secure_transport && 0 === $connection_error && '' === $connection_error_str )

return new WP_Error( 'http_request_failed', __( 'The SSL certificate for the host could not be verified.' ) );

return new WP_Error('http_request_failed', $connection_error . ': ' . $connection_error_str );

}

// Verify that the SSL certificate is valid for this request

if ( $secure_transport && $ssl_verify && ! $proxy->is_enabled() ) {

if ( ! self::verify_ssl_certificate( $handle, $arrURL['host'] ) )

return new WP_Error( 'http_request_failed', __( 'The SSL certificate for the host could not be verified.' ) );

}

stream_set_timeout( $handle, $timeout, $utimeout );

if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) //Some proxies require full URL in this field.

$requestPath = $url;

else

$requestPath = $arrURL['path'] . ( isset($arrURL['query']) ? '?' . $arrURL['query'] : '' );

if ( empty($requestPath) )

$requestPath .= '/';

$strHeaders = strtoupper($r['method']) . ' ' . $requestPath . ' HTTP/' . $r['httpversion'] . "\r\n";

if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) )

$strHeaders .= 'Host: ' . $arrURL['host'] . ':' . $arrURL['port'] . "\r\n";

else

$strHeaders .= 'Host: ' . $arrURL['host'] . "\r\n";

if ( isset($r['user-agent']) )

$strHeaders .= 'User-agent: ' . $r['user-agent'] . "\r\n";

if ( is_array($r['headers']) ) {

foreach ( (array) $r['headers'] as $header => $headerValue )

$strHeaders .= $header . ': ' . $headerValue . "\r\n";

} else {

$strHeaders .= $r['headers'];

}

if ( $proxy->use_authentication() )

$strHeaders .= $proxy->authentication_header() . "\r\n";

$strHeaders .= "\r\n";

if ( ! is_null($r['body']) )

$strHeaders .= $r['body'];

fwrite($handle, $strHeaders);

if ( ! $r['blocking'] ) {

stream_set_blocking( $handle, 0 );

fclose( $handle );

return array( 'headers' => array(), 'body' => '', 'response' => array('code' => false, 'message' => false), 'cookies' => array() );

}

$strResponse = '';

$bodyStarted = false;

$keep_reading = true;

$block_size = 4096;

if ( isset( $r['limit_response_size'] ) )

$block_size = min( $block_size, $r['limit_response_size'] );

// If streaming to a file setup the file handle

if ( $r['stream'] ) {

if ( ! WP_DEBUG )

$stream_handle = @fopen( $r['filename'], 'w+' );

else

$stream_handle = fopen( $r['filename'], 'w+' );

if ( ! $stream_handle )

return new WP_Error( 'http_request_failed', sprintf( __( 'Could not open handle for fopen() to %s' ), $r['filename'] ) );

$bytes_written = 0;

while ( ! feof($handle) && $keep_reading ) {

$block = fread( $handle, $block_size );

if ( ! $bodyStarted ) {

$strResponse .= $block;

if ( strpos( $strResponse, "\r\n\r\n" ) ) {

$process = WP_Http::processResponse( $strResponse );

$bodyStarted = true;

$block = $process['body'];

unset( $strResponse );

$process['body'] = '';

}

}

$this_block_size = strlen( $block );

if ( isset( $r['limit_response_size'] ) && ( $bytes_written + $this_block_size ) > $r['limit_response_size'] )

$block = substr( $block, 0, ( $r['limit_response_size'] - $bytes_written ) );

$bytes_written_to_file = fwrite( $stream_handle, $block );

if ( $bytes_written_to_file != $this_block_size ) {

fclose( $handle );

fclose( $stream_handle );

return new WP_Error( 'http_request_failed', __( 'Failed to write request to temporary file.' ) );

}

$bytes_written += $bytes_written_to_file;

$keep_reading = !isset( $r['limit_response_size'] ) || $bytes_written < $r['limit_response_size'];

}

fclose( $stream_handle );

} else {

$header_length = 0;

while ( ! feof( $handle ) && $keep_reading ) {

$block = fread( $handle, $block_size );

$strResponse .= $block;

if ( ! $bodyStarted && strpos( $strResponse, "\r\n\r\n" ) ) {

$header_length = strpos( $strResponse, "\r\n\r\n" ) + 4;

$bodyStarted = true;

}

$keep_reading = ( ! $bodyStarted || !isset( $r['limit_response_size'] ) || strlen( $strResponse ) < ( $header_length + $r['limit_response_size'] ) );

}

$process = WP_Http::processResponse( $strResponse );

unset( $strResponse );

}

fclose( $handle );

$arrHeaders = WP_Http::processHeaders( $process['headers'], $url );

$response = array(

'headers' => $arrHeaders['headers'],

'body' => null, // Not yet processed

'response' => $arrHeaders['response'],

'cookies' => $arrHeaders['cookies'],

'filename' => $r['filename']

);

// Handle redirects

if ( false !== ( $redirect_response = WP_HTTP::handle_redirects( $url, $r, $response ) ) )

return $redirect_response;

// If the body was chunk encoded, then decode it.

if ( ! empty( $process['body'] ) && isset( $arrHeaders['headers']['transfer-encoding'] ) && 'chunked' == $arrHeaders['headers']['transfer-encoding'] )

$process['body'] = WP_Http::chunkTransferDecode($process['body']);

if ( true === $r['decompress'] && true === WP_Http_Encoding::should_decode($arrHeaders['headers']) )

$process['body'] = WP_Http_Encoding::decompress( $process['body'] );

if ( isset( $r['limit_response_size'] ) && strlen( $process['body'] ) > $r['limit_response_size'] )

$process['body'] = substr( $process['body'], 0, $r['limit_response_size'] );

$response['body'] = $process['body'];

return $response;

}

/**

static function verify_ssl_certificate( $stream, $host ) {

$context_options = stream_context_get_options( $stream );

if ( empty( $context_options['ssl']['peer_certificate'] ) )

return false;

$cert = openssl_x509_parse( $context_options['ssl']['peer_certificate'] );

if ( ! $cert )

return false;

// If the request is being made to an IP address, we'll validate against IP fields in the cert (if they exist)

$host_type = ( WP_HTTP::is_ip_address( $host ) ? 'ip' : 'dns' );

$certificate_hostnames = array();

if ( ! empty( $cert['extensions']['subjectAltName'] ) ) {

$match_against = preg_split( '/,\s*/', $cert['extensions']['subjectAltName'] );

foreach ( $match_against as $match ) {

list( $match_type, $match_host ) = explode( ':', $match );

if ( $host_type == strtolower( trim( $match_type ) ) ) // IP: or DNS:

$certificate_hostnames[] = strtolower( trim( $match_host ) );

}

} elseif ( !empty( $cert['subject']['CN'] ) ) {

// Only use the CN when the certificate includes no subjectAltName extension

$certificate_hostnames[] = strtolower( $cert['subject']['CN'] );

}

// Exact hostname/IP matches

if ( in_array( strtolower( $host ), $certificate_hostnames ) )

return true;

// IP's can't be wildcards, Stop processing

if ( 'ip' == $host_type )

return false;

// Test to see if the domain is at least 2 deep for wildcard support

if ( substr_count( $host, '.' ) < 2 )

return false;

// Wildcard subdomains certs (*.example.com) are valid for a.example.com but not a.b.example.com