enmi-conf.org: comparison wp/wp-includes/class-requests.php

equal deleted inserted replaced

-:34716fd837a4
+:be944660c56a
 	/**
 	 * Current version of Requests
 	 *
 	 * @var string
 	 */
-	const VERSION = '1.7-3470169';
+	const VERSION = '1.8.1';
 	/**
 	 * Registered transport classes
 	 *
 	 * @var array
 			return;
 		}
 		$file = str_replace('_', '/', $class);
 		if (file_exists(dirname(__FILE__) . '/' . $file . '.php')) {
-			require_once(dirname(__FILE__) . '/' . $file . '.php');
+			require_once dirname(__FILE__) . '/' . $file . '.php';
 		}
 	}
 	/**
 	 * Register the built-in autoloader
 	 *    certificate file as a string. (Using true uses the system-wide root
 	 *    certificate store instead, but this may have different behaviour
 	 *    across transports.)
 	 *    (string|boolean, default: library/Requests/Transport/cacert.pem)
 	 * - `verifyname`: Should we verify the common name in the SSL certificate?
-	 *    (boolean: default, true)
+	 *    (boolean, default: true)
 	 * - `data_format`: How should we send the `$data` parameter?
 	 *    (string, one of 'query' or 'body', default: 'query' for
 	 *    HEAD/GET/DELETE, 'body' for POST/PUT/OPTIONS/PATCH)
 	 *
 	 * @throws Requests_Exception On invalid URLs (`nonhttp`)
 			if (is_string($options['transport'])) {
 				$transport = new $transport();
 			}
 		}
 		else {
-			$need_ssl = (0 === stripos($url, 'https://'));
+			$need_ssl     = (stripos($url, 'https://') === 0);
 			$capabilities = array('ssl' => $need_ssl);
-			$transport = self::get_transport($capabilities);
+			$transport    = self::get_transport($capabilities);
 		}
 		$response = $transport->request($url, $headers, $data, $options);
 		$options['hooks']->dispatch('requests.before_parse', array(&$response, $url, $headers, $data, $type, $options));
 			}
 			if (!isset($request['type'])) {
 				$request['type'] = self::GET;
 			}
 			if (!isset($request['options'])) {
-				$request['options'] = $options;
+				$request['options']         = $options;
 				$request['options']['type'] = $request['type'];
 			}
 			else {
 				if (empty($request['options']['type'])) {
 					$request['options']['type'] = $request['type'];
 	 * @param boolean $multirequest Is this a multirequest?
 	 * @return array Default option values
 	 */
 	protected static function get_default_options($multirequest = false) {
 		$defaults = array(
-			'timeout' => 10,
+			'timeout'          => 10,
-			'connect_timeout' => 10,
+			'connect_timeout'  => 10,
-			'useragent' => 'php-requests/' . self::VERSION,
+			'useragent'        => 'php-requests/' . self::VERSION,
 			'protocol_version' => 1.1,
-			'redirected' => 0,
+			'redirected'       => 0,
-			'redirects' => 10,
+			'redirects'        => 10,
 			'follow_redirects' => true,
-			'blocking' => true,
+			'blocking'         => true,
-			'type' => self::GET,
+			'type'             => self::GET,
-			'filename' => false,
+			'filename'         => false,
-			'auth' => false,
+			'auth'             => false,
-			'proxy' => false,
+			'proxy'            => false,
-			'cookies' => false,
+			'cookies'          => false,
-			'max_bytes' => false,
+			'max_bytes'        => false,
-			'idn' => true,
+			'idn'              => true,
-			'hooks' => null,
+			'hooks'            => null,
-			'transport' => null,
+			'transport'        => null,
-			'verify' => Requests::get_certificate_path(),
+			'verify'           => self::get_certificate_path(),
-			'verifyname' => true,
+			'verifyname'       => true,
 		);
 		if ($multirequest !== false) {
 			$defaults['complete'] = null;
 		}
 		return $defaults;
 	 * Get default certificate path.
 	 *
 	 * @return string Default certificate path.
 	 */
 	public static function get_certificate_path() {
-		if ( ! empty( Requests::$certificate_path ) ) {
+		if (!empty(self::$certificate_path)) {
-			return Requests::$certificate_path;
+			return self::$certificate_path;
 		}
 		return dirname(__FILE__) . '/Requests/Transport/cacert.pem';
 	}
 	/**
 	 * Set default certificate path.
 	 *
 	 * @param string $path Certificate path, pointing to a PEM file.
 	 */
-	public static function set_certificate_path( $path ) {
+	public static function set_certificate_path($path) {
-		Requests::$certificate_path = $path;
+		self::$certificate_path = $path;
 	}
 	/**
 	 * Set the default values
 	 *
 		if ($options['cookies'] !== false) {
 			$options['cookies']->register($options['hooks']);
 		}
 		if ($options['idn'] !== false) {
-			$iri = new Requests_IRI($url);
+			$iri       = new Requests_IRI($url);
 			$iri->host = Requests_IDNAEncoder::encode($iri->ihost);
-			$url = $iri->uri;
+			$url       = $iri->uri;
 		}
 		// Massage the type to ensure we support it.
 		$type = strtoupper($type);
 		if (!isset($options['data_format'])) {
-			if (in_array($type, array(self::HEAD, self::GET, self::DELETE))) {
+			if (in_array($type, array(self::HEAD, self::GET, self::DELETE), true)) {
 				$options['data_format'] = 'query';
 			}
 			else {
 				$options['data_format'] = 'body';
 			}
 		$return = new Requests_Response();
 		if (!$options['blocking']) {
 			return $return;
 		}
-		$return->raw = $headers;
+		$return->raw  = $headers;
-		$return->url = $url;
+		$return->url  = (string) $url;
+		$return->body = '';
 		if (!$options['filename']) {
-			if (($pos = strpos($headers, "\r\n\r\n")) === false) {
+			$pos = strpos($headers, "\r\n\r\n");
+			if ($pos === false) {
 				// Crap!
 				throw new Requests_Exception('Missing header/body separator', 'requests.no_crlf_separator');
 			}
 			$headers = substr($return->raw, 0, $pos);
-			$return->body = substr($return->raw, $pos + strlen("\n\r\n\r"));
+			// Headers will always be separated from the body by two new lines - `\n\r\n\r`.
-		}
+			$body = substr($return->raw, $pos + 4);
-		else {
+			if (!empty($body)) {
-			$return->body = '';
+				$return->body = $body;
+			}
 		}
 		// Pretend CRLF = LF for compatibility (RFC 2616, section 19.3)
 		$headers = str_replace("\r\n", "\n", $headers);
 		// Unfold headers (replace [CRLF] 1*( SP | HT ) with SP) as per RFC 2616 (section 2.2)
 		$headers = preg_replace('/\n[ \t]/', ' ', $headers);
 		preg_match('#^HTTP/(1\.\d)[ \t]+(\d+)#i', array_shift($headers), $matches);
 		if (empty($matches)) {
 			throw new Requests_Exception('Response could not be parsed', 'noversion', $headers);
 		}
 		$return->protocol_version = (float) $matches[1];
-		$return->status_code = (int) $matches[2];
+		$return->status_code      = (int) $matches[2];
 		if ($return->status_code >= 200 && $return->status_code < 300) {
 			$return->success = true;
 		}
 		foreach ($headers as $header) {
 			list($key, $value) = explode(':', $header, 2);
-			$value = trim($value);
+			$value             = trim($value);
 			preg_replace('#(\s+)#i', ' ', $value);
 			$return->headers[$key] = $value;
 		}
 		if (isset($return->headers['transfer-encoding'])) {
 			$return->body = self::decode_chunked($return->body);
 				$hook_args = array(
 					&$location,
 					&$req_headers,
 					&$req_data,
 					&$options,
-					$return
+					$return,
 				);
 				$options['hooks']->dispatch('requests.before_redirect', $hook_args);
-				$redirected = self::request($location, $req_headers, $req_data, $options['type'], $options);
+				$redirected            = self::request($location, $req_headers, $req_data, $options['type'], $options);
 				$redirected->history[] = $return;
 				return $redirected;
 			}
 			elseif ($options['redirected'] >= $options['redirects']) {
 				throw new Requests_Exception('Too many redirects', 'toomanyredirects', $return);
 	 * @param array $request Request data as passed into {@see Requests::request_multiple()}
 	 * @return null `$response` is either set to a Requests_Response instance, or a Requests_Exception object
 	 */
 	public static function parse_multiple(&$response, $request) {
 		try {
-			$url = $request['url'];
+			$url      = $request['url'];
-			$headers = $request['headers'];
+			$headers  = $request['headers'];
-			$data = $request['data'];
+			$data     = $request['data'];
-			$options = $request['options'];
+			$options  = $request['options'];
 			$response = self::parse_response($response, $url, $headers, $data, $options);
 		}
 		catch (Requests_Exception $e) {
 			$response = $e;
 		}
 	 */
 	protected static function decode_chunked($data) {
 		if (!preg_match('/^([0-9a-f]+)(?:;(?:[\w-]*)(?:=(?:(?:[\w-]*)*|"(?:[^\r\n])*"))?)*\r\n/i', trim($data))) {
 			return $data;
 		}
 		$decoded = '';
 		$encoded = $data;
 		while (true) {
 				// Ignore trailer headers
 				return $decoded;
 			}
 			$chunk_length = strlen($matches[0]);
-			$decoded .= substr($encoded, $chunk_length, $length);
+			$decoded     .= substr($encoded, $chunk_length, $length);
-			$encoded = substr($encoded, $chunk_length + $length + 2);
+			$encoded      = substr($encoded, $chunk_length + $length + 2);
 			if (trim($encoded) === '0' || empty($encoded)) {
 				return $decoded;
 			}
 		}
 	/**
 	 * Convert a key => value array to a 'key: value' array for headers
 	 *
 	 * @param array $array Dictionary of header values
-	 * @return string[] List of headers
+	 * @return array List of headers
 	 */
 	public static function flatten($array) {
 		$return = array();
 		foreach ($array as $key => $value) {
 			$return[] = sprintf('%s: %s', $key, $value);
 	 * Convert a key => value array to a 'key: value' array for headers
 	 *
 	 * @codeCoverageIgnore
 	 * @deprecated Misspelling of {@see Requests::flatten}
 	 * @param array $array Dictionary of header values
-	 * @return string[] List of headers
+	 * @return array List of headers
 	 */
 	public static function flattern($array) {
 		return self::flatten($array);
 	}
 		if (substr($data, 0, 2) !== "\x1f\x8b" && substr($data, 0, 2) !== "\x78\x9c") {
 			// Not actually compressed. Probably cURL ruining this for us.
 			return $data;
 		}
-		if (function_exists('gzdecode') && ($decoded = @gzdecode($data)) !== false) {
+		if (function_exists('gzdecode')) {
+			// phpcs:ignore PHPCompatibility.FunctionUse.NewFunctions.gzdecodeFound -- Wrapped in function_exists() for PHP 5.2.
+			$decoded = @gzdecode($data);
+			if ($decoded !== false) {
+				return $decoded;
+			}
+		}
+		if (function_exists('gzinflate')) {
+			$decoded = @gzinflate($data);
+			if ($decoded !== false) {
+				return $decoded;
+			}
+		}
+		$decoded = self::compatible_gzinflate($data);
+		if ($decoded !== false) {
 			return $decoded;
 		}
-		elseif (function_exists('gzinflate') && ($decoded = @gzinflate($data)) !== false) {
-			return $decoded;
+		if (function_exists('gzuncompress')) {
-		}
+			$decoded = @gzuncompress($data);
-		elseif (($decoded = self::compatible_gzinflate($data)) !== false) {
+			if ($decoded !== false) {
-			return $decoded;
+				return $decoded;
-		}
+			}
-		elseif (function_exists('gzuncompress') && ($decoded = @gzuncompress($data)) !== false) {
-			return $decoded;
 		}
 		return $data;
 	}
 	 * @since 2.8.1
 	 * @link https://core.trac.wordpress.org/ticket/18273
 	 * @link https://secure.php.net/manual/en/function.gzinflate.php#70875
 	 * @link https://secure.php.net/manual/en/function.gzinflate.php#77336
 	 *
-	 * @param string $gzData String to decompress.
+	 * @param string $gz_data String to decompress.
 	 * @return string|bool False on failure.
 	 */
-	public static function compatible_gzinflate($gzData) {
+	public static function compatible_gzinflate($gz_data) {
 		// Compressed data might contain a full zlib header, if so strip it for
 		// gzinflate()
-		if (substr($gzData, 0, 3) == "\x1f\x8b\x08") {
+		if (substr($gz_data, 0, 3) === "\x1f\x8b\x08") {
-			$i = 10;
+			$i   = 10;
-			$flg = ord(substr($gzData, 3, 1));
+			$flg = ord(substr($gz_data, 3, 1));
 			if ($flg > 0) {
 				if ($flg & 4) {
-					list($xlen) = unpack('v', substr($gzData, $i, 2));
+					list($xlen) = unpack('v', substr($gz_data, $i, 2));
-					$i = $i + 2 + $xlen;
+					$i         += 2 + $xlen;
 				}
 				if ($flg & 8) {
-					$i = strpos($gzData, "\0", $i) + 1;
+					$i = strpos($gz_data, "\0", $i) + 1;
 				}
 				if ($flg & 16) {
-					$i = strpos($gzData, "\0", $i) + 1;
+					$i = strpos($gz_data, "\0", $i) + 1;
 				}
 				if ($flg & 2) {
-					$i = $i + 2;
+					$i += 2;
 				}
 			}
-			$decompressed = self::compatible_gzinflate(substr($gzData, $i));
+			$decompressed = self::compatible_gzinflate(substr($gz_data, $i));
-			if (false !== $decompressed) {
+			if ($decompressed !== false) {
 				return $decompressed;
 			}
 		}
 		// If the data is Huffman Encoded, we must first strip the leading 2
 		// See https://decompres.blogspot.com/ for a quick explanation of this
 		// data type
 		$huffman_encoded = false;
 		// low nibble of first byte should be 0x08
-		list(, $first_nibble)    = unpack('h', $gzData);
+		list(, $first_nibble) = unpack('h', $gz_data);
 		// First 2 bytes should be divisible by 0x1F
-		list(, $first_two_bytes) = unpack('n', $gzData);
+		list(, $first_two_bytes) = unpack('n', $gz_data);
-		if (0x08 == $first_nibble && 0 == ($first_two_bytes % 0x1F)) {
+		if ($first_nibble === 0x08 && ($first_two_bytes % 0x1F) === 0) {
 			$huffman_encoded = true;
 		}
 		if ($huffman_encoded) {
-			if (false !== ($decompressed = @gzinflate(substr($gzData, 2)))) {
+			$decompressed = @gzinflate(substr($gz_data, 2));
+			if ($decompressed !== false) {
 				return $decompressed;
 			}
 		}
-		if ("\x50\x4b\x03\x04" == substr($gzData, 0, 4)) {
+		if (substr($gz_data, 0, 4) === "\x50\x4b\x03\x04") {
 			// ZIP file format header
 			// Offset 6: 2 bytes, General-purpose field
 			// Offset 26: 2 bytes, filename length
 			// Offset 28: 2 bytes, optional field length
 			// Offset 30: Filename field, followed by optional field, followed
 			// immediately by data
-			list(, $general_purpose_flag) = unpack('v', substr($gzData, 6, 2));
+			list(, $general_purpose_flag) = unpack('v', substr($gz_data, 6, 2));
 			// If the file has been compressed on the fly, 0x08 bit is set of
 			// the general purpose field. We can use this to differentiate
 			// between a compressed document, and a ZIP file
-			$zip_compressed_on_the_fly = (0x08 == (0x08 & $general_purpose_flag));
+			$zip_compressed_on_the_fly = ((0x08 & $general_purpose_flag) === 0x08);
 			if (!$zip_compressed_on_the_fly) {
 				// Don't attempt to decode a compressed zip file
-				return $gzData;
+				return $gz_data;
 			}
 			// Determine the first byte of data, based on the above ZIP header
 			// offsets:
-			$first_file_start = array_sum(unpack('v2', substr($gzData, 26, 4)));
+			$first_file_start = array_sum(unpack('v2', substr($gz_data, 26, 4)));
-			if (false !== ($decompressed = @gzinflate(substr($gzData, 30 + $first_file_start)))) {
+			$decompressed     = @gzinflate(substr($gz_data, 30 + $first_file_start));
+			if ($decompressed !== false) {
 				return $decompressed;
 			}
 			return false;
 		}
 		// Finally fall back to straight gzinflate
-		if (false !== ($decompressed = @gzinflate($gzData))) {
+		$decompressed = @gzinflate($gz_data);
+		if ($decompressed !== false) {
 			return $decompressed;
 		}
 		// Fallback for all above failing, not expected, but included for
 		// debugging and preventing regressions and to track stats
-		if (false !== ($decompressed = @gzinflate(substr($gzData, 2)))) {
+		$decompressed = @gzinflate(substr($gz_data, 2));
+		if ($decompressed !== false) {
 			return $decompressed;
 		}
 		return false;
 	}

changeset 18	be944660c56a
parent 16	a86126ab1dd4
child 21	48c4eec2b7e6