Context Navigation

← Previous Change
Next Change →

Fsockopen.php

Timestamp:

11/25/2021 01:10:30 AM (5 years ago)

Author:

SergeyBiryukov

Message:

External Libraries: Update the Requests library to version 2.0.0.

This is a major release and contains breaking changes.

Most important changes to be aware of for this release:

All code is now namespaced. Though there is a full backward compatibility layer available and the old class names are still supported, using them will generate a deprecation notice (which can be silenced by plugins if they'd need to support multiple WP versions). See the upgrade guide for more details.
A lot of classes have been marked final. This should generally not affect userland code as care has been taken to not apply the final keyword to classes which are known to be extended in userland code.
Extensive input validation has been added to Requests. When Requests is used as documented though, this will be unnoticable.
A new WpOrg\Requests\Requests::has_capabilities() method has been introduced which can be used to address #37708.
A new WpOrg\Requests\Response::decode_body() method has been introduced which may be usable to simplify some of the WP native wrapper code.
Remaining PHP 8.0 compatibility fixed (support for named parameters).
PHP 8.1 compatibility.

Release notes: https://github.com/WordPress/Requests/releases/tag/v2.0.0

For a full list of changes in this update, see the Requests GitHub:
https://github.com/WordPress/Requests/compare/v1.8.1...v2.0.0

Follow-up to [50842], [51078].

Props jrf, schlessera, datagutten, wojsmol, dd32, dustinrue, soulseekah, costdev, szepeviktor.
Fixes #54504.

File:

: 1 moved

trunk/src/wp-includes/Requests/Transport/Fsockopen.php (moved) (moved from trunk/src/wp-includes/Requests/Transport/fsockopen.php ) (23 diffs)

Legend:

: Unmodified
: Added
: Removed

trunk/src/wp-includes/Requests/Transport/Fsockopen.php

-              r52243
+              r52244
  * fsockopen HTTP transport
+ *
+ * @package Requests
+ * @subpackage Transport
+ * @package Requests\Transport
  */
+namespace WpOrg\Requests\Transport;
+use WpOrg\Requests\Capability;
+use WpOrg\Requests\Exception;
+use WpOrg\Requests\Exception\InvalidArgument;
+use WpOrg\Requests\Port;
+use WpOrg\Requests\Requests;
+use WpOrg\Requests\Ssl;
+use WpOrg\Requests\Transport;
+use WpOrg\Requests\Utility\CaseInsensitiveDictionary;
+use WpOrg\Requests\Utility\InputValidator;
 /**
  * fsockopen HTTP transport
+ *
+ * @package Requests
+ * @subpackage Transport
+ * @package Requests\Transport
  */
 class Requests_Transport_fsockopen implements Requests_Transport {
+final class Fsockopen implements Transport {
         /**
          * Second to microsecond conversion
 …
          * Stream metadata
+         *
          * @var array Associative array of properties, see {@see https://secure.php.net/stream_get_meta_data}
+         * @var array Associative array of properties, see {@link https://www.php.net/stream_get_meta_data}
          */
         public $info;
 …
          * @var int|bool Byte count, or false if no limit.
          */
         protected $max_bytes = false;
         protected $connect_error = '';
+        private $max_bytes = false;
+        private $connect_error = '';
         /**
          * Perform a request
+         *
+         * @throws Requests_Exception On failure to connect to socket (`fsockopenerror`)
+         * @throws Requests_Exception On socket timeout (`timeout`)
+         *
+         * @param string $url URL to request
+         * @param string|Stringable $url URL to request
          * @param array $headers Associative array of request headers
          * @param string|array $data Data to send either as the POST body, or as parameters in the URL for a GET/HEAD
          * @param array $options Request options, see {@see Requests::response()} for documentation
+         * @param array $options Request options, see {@see \WpOrg\Requests\Requests::response()} for documentation
          * @return string Raw HTTP result
+         */
+        public function request($url, $headers = array(), $data = array(), $options = array()) {
+         *
+         * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $url argument is not a string or Stringable.
+         * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $headers argument is not an array.
+         * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $data parameter is not an array or string.
+         * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $options argument is not an array.
+         * @throws \WpOrg\Requests\Exception       On failure to connect to socket (`fsockopenerror`)
+         * @throws \WpOrg\Requests\Exception       On socket timeout (`timeout`)
+         */
+        public function request($url, $headers = [], $data = [], $options = []) {
+                if (InputValidator::is_string_or_stringable($url) === false) {
+                        throw InvalidArgument::create(1, '$url', 'string|Stringable', gettype($url));
+                }
+                if (is_array($headers) === false) {
+                        throw InvalidArgument::create(2, '$headers', 'array', gettype($headers));
+                }
+                if (!is_array($data) && !is_string($data)) {
+                        if ($data === null) {
+                                $data = '';
+                        } else {
+                                throw InvalidArgument::create(3, '$data', 'array|string', gettype($data));
+                        }
+                }
+                if (is_array($options) === false) {
+                        throw InvalidArgument::create(4, '$options', 'array', gettype($options));
+                }
                 $options['hooks']->dispatch('fsockopen.before_request');
                 $url_parts = parse_url($url);
                 if (empty($url_parts)) {
                         throw new Requests_Exception('Invalid URL.', 'invalidurl', $url);
+                        throw new Exception('Invalid URL.', 'invalidurl', $url);
+                }
                 $host                     = $url_parts['host'];
                 $context                  = stream_context_create();
                 $verifyname               = false;
                 $case_insensitive_headers = new Requests_Utility_CaseInsensitiveDictionary($headers);
+                $case_insensitive_headers = new CaseInsensitiveDictionary($headers);
                 // HTTPS support
 …
                         $remote_socket = 'ssl://' . $host;
                         if (!isset($url_parts['port'])) {
                                 $url_parts['port'] = 443;
+                        }
                         $context_options = array(
+                                $url_parts['port'] = Port::HTTPS;
+                        }
+                        $context_options = [
                                 'verify_peer'       => true,
                                 'capture_peer_cert' => true,
                         );
+                        ];
                         $verifyname      = true;
 …
+                        }
                         stream_context_set_option($context, array('ssl' => $context_options));
+                        stream_context_set_option($context, ['ssl' => $context_options]);
+                }
                 else {
 …
                 if (!isset($url_parts['port'])) {
                         $url_parts['port'] = 80;
+                        $url_parts['port'] = Port::HTTP;
+                }
                 $remote_socket .= ':' . $url_parts['port'];
                 // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_set_error_handler
                 set_error_handler(array($this, 'connect_error_handler'), E_WARNING | E_NOTICE);
                 $options['hooks']->dispatch('fsockopen.remote_socket', array(&$remote_socket));
+                set_error_handler([$this, 'connect_error_handler'], E_WARNING | E_NOTICE);
+                $options['hooks']->dispatch('fsockopen.remote_socket', [&$remote_socket]);
                 $socket = stream_socket_client($remote_socket, $errno, $errstr, ceil($options['connect_timeout']), STREAM_CLIENT_CONNECT, $context);
 …
                 if ($verifyname && !$this->verify_certificate_from_context($host, $context)) {
                         throw new Requests_Exception('SSL certificate did not match the requested domain name', 'ssl.no_match');
+                        throw new Exception('SSL certificate did not match the requested domain name', 'ssl.no_match');
+                }
 …
                         if ($errno === 0) {
                                 // Connection issue
                                 throw new Requests_Exception(rtrim($this->connect_error), 'fsockopen.connect_error');
+                        }
                         throw new Requests_Exception($errstr, 'fsockopenerror', null, $errno);
+                                throw new Exception(rtrim($this->connect_error), 'fsockopen.connect_error');
+                        }
+                        throw new Exception($errstr, 'fsockopenerror', null, $errno);
+                }
 …
+                }
                 else {
                         $path = self::format_get($url_parts, array());
+                }
                 $options['hooks']->dispatch('fsockopen.remote_host_path', array(&$path, $url));
+                        $path = self::format_get($url_parts, []);
+                }
+                $options['hooks']->dispatch('fsockopen.remote_host_path', [&$path, $url]);
                 $request_body = '';
 …
                 if (!isset($case_insensitive_headers['Host'])) {
+                        $out .= sprintf('Host: %s', $url_parts['host']);
+                        if ((strtolower($url_parts['scheme']) === 'http' && $url_parts['port'] !== 80) || (strtolower($url_parts['scheme']) === 'https' && $url_parts['port'] !== 443)) {
+                        $out         .= sprintf('Host: %s', $url_parts['host']);
+                        $scheme_lower = strtolower($url_parts['scheme']);
+                        if (($scheme_lower === 'http' && $url_parts['port'] !== Port::HTTP) || ($scheme_lower === 'https' && $url_parts['port'] !== Port::HTTPS)) {
                                 $out .= ':' . $url_parts['port'];
+                        }
 …
+                }
                 $options['hooks']->dispatch('fsockopen.after_headers', array(&$out));
+                $options['hooks']->dispatch('fsockopen.after_headers', [&$out]);
                 if (substr($out, -2) !== "\r\n") {
 …
                 $out .= "\r\n" . $request_body;
                 $options['hooks']->dispatch('fsockopen.before_send', array(&$out));
+                $options['hooks']->dispatch('fsockopen.before_send', [&$out]);
                 fwrite($socket, $out);
                 $options['hooks']->dispatch('fsockopen.after_send', array($out));
+                $options['hooks']->dispatch('fsockopen.after_send', [$out]);
                 if (!$options['blocking']) {
                         fclose($socket);
                         $fake_headers = '';
                         $options['hooks']->dispatch('fsockopen.after_request', array(&$fake_headers));
+                        $options['hooks']->dispatch('fsockopen.after_request', [&$fake_headers]);
                         return '';
+                }
 …
                 $download   = false;
                 if ($options['filename']) {
+                        $download = fopen($options['filename'], 'wb');
+                        // phpcs:ignore WordPress.PHP.NoSilencedErrors -- Silenced the PHP native warning in favour of throwing an exception.
+                        $download = @fopen($options['filename'], 'wb');
+                        if ($download === false) {
+                                $error = error_get_last();
+                                throw new Exception($error['message'], 'fopen');
+                        }
+                }
 …
                         $this->info = stream_get_meta_data($socket);
                         if ($this->info['timed_out']) {
                                 throw new Requests_Exception('fsocket timed out', 'timeout');
+                                throw new Exception('fsocket timed out', 'timeout');
+                        }
 …
                         // Are we in body mode now?
                         if ($doingbody) {
                                 $options['hooks']->dispatch('request.progress', array($block, $size, $this->max_bytes));
+                                $options['hooks']->dispatch('request.progress', [$block, $size, $this->max_bytes]);
                                 $data_length = strlen($block);
                                 if ($this->max_bytes) {
 …
                 fclose($socket);
                 $options['hooks']->dispatch('fsockopen.after_request', array(&$this->headers, &$this->info));
+                $options['hooks']->dispatch('fsockopen.after_request', [&$this->headers, &$this->info]);
                 return $this->headers;
+        }
 …
          * Send multiple requests simultaneously
+         *
+         * @param array $requests Request data (array of 'url', 'headers', 'data', 'options') as per {@see Requests_Transport::request}
+         * @param array $options Global options, see {@see Requests::response()} for documentation
+         * @return array Array of Requests_Response objects (may contain Requests_Exception or string responses as well)
+         * @param array $requests Request data (array of 'url', 'headers', 'data', 'options') as per {@see \WpOrg\Requests\Transport::request()}
+         * @param array $options Global options, see {@see \WpOrg\Requests\Requests::response()} for documentation
+         * @return array Array of \WpOrg\Requests\Response objects (may contain \WpOrg\Requests\Exception or string responses as well)
+         *
+         * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $requests argument is not an array or iterable object with array access.
+         * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $options argument is not an array.
          */
         public function request_multiple($requests, $options) {
+                $responses = array();
+                // If you're not requesting, we can't get any responses ¯\_(ツ)_/¯
+                if (empty($requests)) {
+                        return [];
+                }
+                if (InputValidator::has_array_access($requests) === false || InputValidator::is_iterable($requests) === false) {
+                        throw InvalidArgument::create(1, '$requests', 'array|ArrayAccess&Traversable', gettype($requests));
+                }
+                if (is_array($options) === false) {
+                        throw InvalidArgument::create(2, '$options', 'array', gettype($options));
+                }
+                $responses = [];
                 $class     = get_class($this);
                 foreach ($requests as $id => $request) {
 …
                                 $responses[$id] = $handler->request($request['url'], $request['headers'], $request['data'], $request['options']);
                                 $request['options']['hooks']->dispatch('transport.internal.parse_response', array(&$responses[$id], $request));
+                        }
                         catch (Requests_Exception $e) {
+                                $request['options']['hooks']->dispatch('transport.internal.parse_response', [&$responses[$id], $request]);
+                        }
+                        catch (Exception $e) {
                                 $responses[$id] = $e;
+                        }
                         if (!is_string($responses[$id])) {
                                 $request['options']['hooks']->dispatch('multiple.request.complete', array(&$responses[$id], $id));
+                                $request['options']['hooks']->dispatch('multiple.request.complete', [&$responses[$id], $id]);
+                        }
+                }
 …
          * @return string Accept-Encoding header value
          */
         protected static function accept_encoding() {
                 $type = array();
+        private static function accept_encoding() {
+                $type = [];
                 if (function_exists('gzinflate')) {
                         $type[] = 'deflate;q=1.0';
 …
+         *
          * @param array $url_parts
          * @param array|object $data Data to build query using, see {@see https://secure.php.net/http_build_query}
+         * @param array|object $data Data to build query using, see {@link https://www.php.net/http_build_query}
          * @return string URL with data
          */
         protected static function format_get($url_parts, $data) {
+        private static function format_get($url_parts, $data) {
                 if (!empty($data)) {
                         if (empty($url_parts['query'])) {
 …
          * Instead
+         *
+         * @see https://tools.ietf.org/html/rfc2818#section-3.1 RFC2818, Section 3.1
+         *
+         * @throws Requests_Exception On failure to connect via TLS (`fsockopen.ssl.connect_error`)
+         * @throws Requests_Exception On not obtaining a match for the host (`fsockopen.ssl.no_match`)
+         * @link https://tools.ietf.org/html/rfc2818#section-3.1 RFC2818, Section 3.1
+         *
          * @param string $host Host name to verify against
          * @param resource $context Stream context
          * @return bool
+         *
+         * @throws \WpOrg\Requests\Exception On failure to connect via TLS (`fsockopen.ssl.connect_error`)
+         * @throws \WpOrg\Requests\Exception On not obtaining a match for the host (`fsockopen.ssl.no_match`)
          */
         public function verify_certificate_from_context($host, $context) {
 …
                 // all
                 if (empty($meta) || empty($meta['ssl']) || empty($meta['ssl']['peer_certificate'])) {
                         throw new Requests_Exception(rtrim($this->connect_error), 'ssl.connect_error');
+                        throw new Exception(rtrim($this->connect_error), 'ssl.connect_error');
+                }
                 $cert = openssl_x509_parse($meta['ssl']['peer_certificate']);
+                return Requests_SSL::verify_certificate($host, $cert);
+        }
+        /**
+         * Whether this transport is valid
+                return Ssl::verify_certificate($host, $cert);
+        }
+        /**
+         * Self-test whether the transport can be used.
+         *
+         * The available capabilities to test for can be found in {@see \WpOrg\Requests\Capability}.
+         *
          * @codeCoverageIgnore
+         * @return boolean True if the transport is valid, false otherwise.
+         */
+        public static function test($capabilities = array()) {
+         * @param array<string, bool> $capabilities Optional. Associative array of capabilities to test against, i.e. `['<capability>' => true]`.
+         * @return bool Whether the transport can be used.
+         */
+        public static function test($capabilities = []) {
                 if (!function_exists('fsockopen')) {
                         return false;
 …
                 // If needed, check that streams support SSL
                 if (isset($capabilities['ssl']) && $capabilities['ssl']) {
+                if (isset($capabilities[Capability::SSL]) && $capabilities[Capability::SSL]) {
                         if (!extension_loaded('openssl') || !function_exists('openssl_x509_parse')) {
                                 return false;
+                        }
-                        // Currently broken, thanks to https://github.com/facebook/hhvm/issues/2156
-                        if (defined('HHVM_VERSION')) {
-                                return false;
+                        }
+                }

Note: See TracChangeset for help on using the changeset viewer.

Make WordPress Core

Context Navigation

Changeset 52244 for trunk/src/wp-includes/Requests/Transport/Fsockopen.php

Legend:

trunk/src/wp-includes/Requests/Transport/Fsockopen.php

Download in other formats: