diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-17 07:56:49 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-17 07:56:49 +0000 |
commit | a415c29efee45520ae252d2aa28f1083a521cd7b (patch) | |
tree | f4ade4b6668ecc0765de7e1424f7c1427ad433ff /wp-includes/Requests | |
parent | Initial commit. (diff) | |
download | wordpress-a415c29efee45520ae252d2aa28f1083a521cd7b.tar.xz wordpress-a415c29efee45520ae252d2aa28f1083a521cd7b.zip |
Adding upstream version 6.4.3+dfsg1.upstream/6.4.3+dfsg1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
65 files changed, 8031 insertions, 0 deletions
diff --git a/wp-includes/Requests/library/Requests.php b/wp-includes/Requests/library/Requests.php new file mode 100644 index 0000000..9e42db5 --- /dev/null +++ b/wp-includes/Requests/library/Requests.php @@ -0,0 +1,12 @@ +<?php +/** + * Loads the old Requests class file when the autoloader + * references the original PSR-0 Requests class. + * + * @deprecated 6.2.0 + * @package WordPress + * @subpackage Requests + * @since 6.2.0 + */ + +include_once ABSPATH . WPINC . '/class-requests.php'; diff --git a/wp-includes/Requests/src/Auth.php b/wp-includes/Requests/src/Auth.php new file mode 100644 index 0000000..63ebb08 --- /dev/null +++ b/wp-includes/Requests/src/Auth.php @@ -0,0 +1,36 @@ +<?php +/** + * Authentication provider interface + * + * @package Requests\Authentication + */ + +namespace WpOrg\Requests; + +use WpOrg\Requests\Hooks; + +/** + * Authentication provider interface + * + * Implement this interface to act as an authentication provider. + * + * Parameters should be passed via the constructor where possible, as this + * makes it much easier for users to use your provider. + * + * @see \WpOrg\Requests\Hooks + * + * @package Requests\Authentication + */ +interface Auth { + /** + * Register hooks as needed + * + * This method is called in {@see \WpOrg\Requests\Requests::request()} when the user + * has set an instance as the 'auth' option. Use this callback to register all the + * hooks you'll need. + * + * @see \WpOrg\Requests\Hooks::register() + * @param \WpOrg\Requests\Hooks $hooks Hook system + */ + public function register(Hooks $hooks); +} diff --git a/wp-includes/Requests/src/Auth/Basic.php b/wp-includes/Requests/src/Auth/Basic.php new file mode 100644 index 0000000..8ea0eb5 --- /dev/null +++ b/wp-includes/Requests/src/Auth/Basic.php @@ -0,0 +1,103 @@ +<?php +/** + * Basic Authentication provider + * + * @package Requests\Authentication + */ + +namespace WpOrg\Requests\Auth; + +use WpOrg\Requests\Auth; +use WpOrg\Requests\Exception\ArgumentCount; +use WpOrg\Requests\Exception\InvalidArgument; +use WpOrg\Requests\Hooks; + +/** + * Basic Authentication provider + * + * Provides a handler for Basic HTTP authentication via the Authorization + * header. + * + * @package Requests\Authentication + */ +class Basic implements Auth { + /** + * Username + * + * @var string + */ + public $user; + + /** + * Password + * + * @var string + */ + public $pass; + + /** + * Constructor + * + * @since 2.0 Throws an `InvalidArgument` exception. + * @since 2.0 Throws an `ArgumentCount` exception instead of the Requests base `Exception. + * + * @param array|null $args Array of user and password. Must have exactly two elements + * + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed argument is not an array or null. + * @throws \WpOrg\Requests\Exception\ArgumentCount On incorrect number of array elements (`authbasicbadargs`). + */ + public function __construct($args = null) { + if (is_array($args)) { + if (count($args) !== 2) { + throw ArgumentCount::create('an array with exactly two elements', count($args), 'authbasicbadargs'); + } + + list($this->user, $this->pass) = $args; + return; + } + + if ($args !== null) { + throw InvalidArgument::create(1, '$args', 'array|null', gettype($args)); + } + } + + /** + * Register the necessary callbacks + * + * @see \WpOrg\Requests\Auth\Basic::curl_before_send() + * @see \WpOrg\Requests\Auth\Basic::fsockopen_header() + * @param \WpOrg\Requests\Hooks $hooks Hook system + */ + public function register(Hooks $hooks) { + $hooks->register('curl.before_send', [$this, 'curl_before_send']); + $hooks->register('fsockopen.after_headers', [$this, 'fsockopen_header']); + } + + /** + * Set cURL parameters before the data is sent + * + * @param resource|\CurlHandle $handle cURL handle + */ + public function curl_before_send(&$handle) { + curl_setopt($handle, CURLOPT_HTTPAUTH, CURLAUTH_BASIC); + curl_setopt($handle, CURLOPT_USERPWD, $this->getAuthString()); + } + + /** + * Add extra headers to the request before sending + * + * @param string $out HTTP header string + */ + public function fsockopen_header(&$out) { + $out .= sprintf("Authorization: Basic %s\r\n", base64_encode($this->getAuthString())); + } + + /** + * Get the authentication string (user:pass) + * + * @return string + */ + public function getAuthString() { + return $this->user . ':' . $this->pass; + } +} diff --git a/wp-includes/Requests/src/Autoload.php b/wp-includes/Requests/src/Autoload.php new file mode 100644 index 0000000..669ddec --- /dev/null +++ b/wp-includes/Requests/src/Autoload.php @@ -0,0 +1,187 @@ +<?php +/** + * Autoloader for Requests for PHP. + * + * Include this file if you'd like to avoid having to create your own autoloader. + * + * @package Requests + * @since 2.0.0 + * + * @codeCoverageIgnore + */ + +namespace WpOrg\Requests; + +/* + * Ensure the autoloader is only declared once. + * This safeguard is in place as this is the typical entry point for this library + * and this file being required unconditionally could easily cause + * fatal "Class already declared" errors. + */ +if (class_exists('WpOrg\Requests\Autoload') === false) { + + /** + * Autoloader for Requests for PHP. + * + * This autoloader supports the PSR-4 based Requests 2.0.0 classes in a case-sensitive manner + * as the most common server OS-es are case-sensitive and the file names are in mixed case. + * + * For the PSR-0 Requests 1.x BC-layer, requested classes will be treated case-insensitively. + * + * @package Requests + */ + final class Autoload { + + /** + * List of the old PSR-0 class names in lowercase as keys with their PSR-4 case-sensitive name as a value. + * + * @var array + */ + private static $deprecated_classes = [ + // Interfaces. + 'requests_auth' => '\WpOrg\Requests\Auth', + 'requests_hooker' => '\WpOrg\Requests\HookManager', + 'requests_proxy' => '\WpOrg\Requests\Proxy', + 'requests_transport' => '\WpOrg\Requests\Transport', + + // Classes. + 'requests_cookie' => '\WpOrg\Requests\Cookie', + 'requests_exception' => '\WpOrg\Requests\Exception', + 'requests_hooks' => '\WpOrg\Requests\Hooks', + 'requests_idnaencoder' => '\WpOrg\Requests\IdnaEncoder', + 'requests_ipv6' => '\WpOrg\Requests\Ipv6', + 'requests_iri' => '\WpOrg\Requests\Iri', + 'requests_response' => '\WpOrg\Requests\Response', + 'requests_session' => '\WpOrg\Requests\Session', + 'requests_ssl' => '\WpOrg\Requests\Ssl', + 'requests_auth_basic' => '\WpOrg\Requests\Auth\Basic', + 'requests_cookie_jar' => '\WpOrg\Requests\Cookie\Jar', + 'requests_proxy_http' => '\WpOrg\Requests\Proxy\Http', + 'requests_response_headers' => '\WpOrg\Requests\Response\Headers', + 'requests_transport_curl' => '\WpOrg\Requests\Transport\Curl', + 'requests_transport_fsockopen' => '\WpOrg\Requests\Transport\Fsockopen', + 'requests_utility_caseinsensitivedictionary' => '\WpOrg\Requests\Utility\CaseInsensitiveDictionary', + 'requests_utility_filterediterator' => '\WpOrg\Requests\Utility\FilteredIterator', + 'requests_exception_http' => '\WpOrg\Requests\Exception\Http', + 'requests_exception_transport' => '\WpOrg\Requests\Exception\Transport', + 'requests_exception_transport_curl' => '\WpOrg\Requests\Exception\Transport\Curl', + 'requests_exception_http_304' => '\WpOrg\Requests\Exception\Http\Status304', + 'requests_exception_http_305' => '\WpOrg\Requests\Exception\Http\Status305', + 'requests_exception_http_306' => '\WpOrg\Requests\Exception\Http\Status306', + 'requests_exception_http_400' => '\WpOrg\Requests\Exception\Http\Status400', + 'requests_exception_http_401' => '\WpOrg\Requests\Exception\Http\Status401', + 'requests_exception_http_402' => '\WpOrg\Requests\Exception\Http\Status402', + 'requests_exception_http_403' => '\WpOrg\Requests\Exception\Http\Status403', + 'requests_exception_http_404' => '\WpOrg\Requests\Exception\Http\Status404', + 'requests_exception_http_405' => '\WpOrg\Requests\Exception\Http\Status405', + 'requests_exception_http_406' => '\WpOrg\Requests\Exception\Http\Status406', + 'requests_exception_http_407' => '\WpOrg\Requests\Exception\Http\Status407', + 'requests_exception_http_408' => '\WpOrg\Requests\Exception\Http\Status408', + 'requests_exception_http_409' => '\WpOrg\Requests\Exception\Http\Status409', + 'requests_exception_http_410' => '\WpOrg\Requests\Exception\Http\Status410', + 'requests_exception_http_411' => '\WpOrg\Requests\Exception\Http\Status411', + 'requests_exception_http_412' => '\WpOrg\Requests\Exception\Http\Status412', + 'requests_exception_http_413' => '\WpOrg\Requests\Exception\Http\Status413', + 'requests_exception_http_414' => '\WpOrg\Requests\Exception\Http\Status414', + 'requests_exception_http_415' => '\WpOrg\Requests\Exception\Http\Status415', + 'requests_exception_http_416' => '\WpOrg\Requests\Exception\Http\Status416', + 'requests_exception_http_417' => '\WpOrg\Requests\Exception\Http\Status417', + 'requests_exception_http_418' => '\WpOrg\Requests\Exception\Http\Status418', + 'requests_exception_http_428' => '\WpOrg\Requests\Exception\Http\Status428', + 'requests_exception_http_429' => '\WpOrg\Requests\Exception\Http\Status429', + 'requests_exception_http_431' => '\WpOrg\Requests\Exception\Http\Status431', + 'requests_exception_http_500' => '\WpOrg\Requests\Exception\Http\Status500', + 'requests_exception_http_501' => '\WpOrg\Requests\Exception\Http\Status501', + 'requests_exception_http_502' => '\WpOrg\Requests\Exception\Http\Status502', + 'requests_exception_http_503' => '\WpOrg\Requests\Exception\Http\Status503', + 'requests_exception_http_504' => '\WpOrg\Requests\Exception\Http\Status504', + 'requests_exception_http_505' => '\WpOrg\Requests\Exception\Http\Status505', + 'requests_exception_http_511' => '\WpOrg\Requests\Exception\Http\Status511', + 'requests_exception_http_unknown' => '\WpOrg\Requests\Exception\Http\StatusUnknown', + ]; + + /** + * Register the autoloader. + * + * Note: the autoloader is *prepended* in the autoload queue. + * This is done to ensure that the Requests 2.0 autoloader takes precedence + * over a potentially (dependency-registered) Requests 1.x autoloader. + * + * @internal This method contains a safeguard against the autoloader being + * registered multiple times. This safeguard uses a global constant to + * (hopefully/in most cases) still function correctly, even if the + * class would be renamed. + * + * @return void + */ + public static function register() { + if (defined('REQUESTS_AUTOLOAD_REGISTERED') === false) { + spl_autoload_register([self::class, 'load'], true); + define('REQUESTS_AUTOLOAD_REGISTERED', true); + } + } + + /** + * Autoloader. + * + * @param string $class_name Name of the class name to load. + * + * @return bool Whether a class was loaded or not. + */ + public static function load($class_name) { + // Check that the class starts with "Requests" (PSR-0) or "WpOrg\Requests" (PSR-4). + $psr_4_prefix_pos = strpos($class_name, 'WpOrg\\Requests\\'); + + if (stripos($class_name, 'Requests') !== 0 && $psr_4_prefix_pos !== 0) { + return false; + } + + $class_lower = strtolower($class_name); + + if ($class_lower === 'requests') { + // Reference to the original PSR-0 Requests class. + $file = dirname(__DIR__) . '/library/Requests.php'; + } elseif ($psr_4_prefix_pos === 0) { + // PSR-4 classname. + $file = __DIR__ . '/' . strtr(substr($class_name, 15), '\\', '/') . '.php'; + } + + if (isset($file) && file_exists($file)) { + include $file; + return true; + } + + /* + * Okay, so the class starts with "Requests", but we couldn't find the file. + * If this is one of the deprecated/renamed PSR-0 classes being requested, + * let's alias it to the new name and throw a deprecation notice. + */ + if (isset(self::$deprecated_classes[$class_lower])) { + /* + * Integrators who cannot yet upgrade to the PSR-4 class names can silence deprecations + * by defining a `REQUESTS_SILENCE_PSR0_DEPRECATIONS` constant and setting it to `true`. + * The constant needs to be defined before the first deprecated class is requested + * via this autoloader. + */ + if (!defined('REQUESTS_SILENCE_PSR0_DEPRECATIONS') || REQUESTS_SILENCE_PSR0_DEPRECATIONS !== true) { + // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_trigger_error + trigger_error( + 'The PSR-0 `Requests_...` class names in the Requests library are deprecated.' + . ' Switch to the PSR-4 `WpOrg\Requests\...` class names at your earliest convenience.', + E_USER_DEPRECATED + ); + + // Prevent the deprecation notice from being thrown twice. + if (!defined('REQUESTS_SILENCE_PSR0_DEPRECATIONS')) { + define('REQUESTS_SILENCE_PSR0_DEPRECATIONS', true); + } + } + + // Create an alias and let the autoloader recursively kick in to load the PSR-4 class. + return class_alias(self::$deprecated_classes[$class_lower], $class_name, true); + } + + return false; + } + } +} diff --git a/wp-includes/Requests/src/Capability.php b/wp-includes/Requests/src/Capability.php new file mode 100644 index 0000000..30572ba --- /dev/null +++ b/wp-includes/Requests/src/Capability.php @@ -0,0 +1,36 @@ +<?php +/** + * Capability interface declaring the known capabilities. + * + * @package Requests\Utilities + */ + +namespace WpOrg\Requests; + +/** + * Capability interface declaring the known capabilities. + * + * This is used as the authoritative source for which capabilities can be queried. + * + * @package Requests\Utilities + */ +interface Capability { + + /** + * Support for SSL. + * + * @var string + */ + const SSL = 'ssl'; + + /** + * Collection of all capabilities supported in Requests. + * + * Note: this does not automatically mean that the capability will be supported for your chosen transport! + * + * @var string[] + */ + const ALL = [ + self::SSL, + ]; +} diff --git a/wp-includes/Requests/src/Cookie.php b/wp-includes/Requests/src/Cookie.php new file mode 100644 index 0000000..6f971d6 --- /dev/null +++ b/wp-includes/Requests/src/Cookie.php @@ -0,0 +1,527 @@ +<?php +/** + * Cookie storage object + * + * @package Requests\Cookies + */ + +namespace WpOrg\Requests; + +use WpOrg\Requests\Exception\InvalidArgument; +use WpOrg\Requests\Iri; +use WpOrg\Requests\Response\Headers; +use WpOrg\Requests\Utility\CaseInsensitiveDictionary; +use WpOrg\Requests\Utility\InputValidator; + +/** + * Cookie storage object + * + * @package Requests\Cookies + */ +class Cookie { + /** + * Cookie name. + * + * @var string + */ + public $name; + + /** + * Cookie value. + * + * @var string + */ + public $value; + + /** + * Cookie attributes + * + * Valid keys are `'path'`, `'domain'`, `'expires'`, `'max-age'`, `'secure'` and + * `'httponly'`. + * + * @var \WpOrg\Requests\Utility\CaseInsensitiveDictionary|array Array-like object + */ + public $attributes = []; + + /** + * Cookie flags + * + * Valid keys are `'creation'`, `'last-access'`, `'persistent'` and `'host-only'`. + * + * @var array + */ + public $flags = []; + + /** + * Reference time for relative calculations + * + * This is used in place of `time()` when calculating Max-Age expiration and + * checking time validity. + * + * @var int + */ + public $reference_time = 0; + + /** + * Create a new cookie object + * + * @param string $name The name of the cookie. + * @param string $value The value for the cookie. + * @param array|\WpOrg\Requests\Utility\CaseInsensitiveDictionary $attributes Associative array of attribute data + * @param array $flags The flags for the cookie. + * Valid keys are `'creation'`, `'last-access'`, + * `'persistent'` and `'host-only'`. + * @param int|null $reference_time Reference time for relative calculations. + * + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $name argument is not a string. + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $value argument is not a string. + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $attributes argument is not an array or iterable object with array access. + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $flags argument is not an array. + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $reference_time argument is not an integer or null. + */ + public function __construct($name, $value, $attributes = [], $flags = [], $reference_time = null) { + if (is_string($name) === false) { + throw InvalidArgument::create(1, '$name', 'string', gettype($name)); + } + + if (is_string($value) === false) { + throw InvalidArgument::create(2, '$value', 'string', gettype($value)); + } + + if (InputValidator::has_array_access($attributes) === false || InputValidator::is_iterable($attributes) === false) { + throw InvalidArgument::create(3, '$attributes', 'array|ArrayAccess&Traversable', gettype($attributes)); + } + + if (is_array($flags) === false) { + throw InvalidArgument::create(4, '$flags', 'array', gettype($flags)); + } + + if ($reference_time !== null && is_int($reference_time) === false) { + throw InvalidArgument::create(5, '$reference_time', 'integer|null', gettype($reference_time)); + } + + $this->name = $name; + $this->value = $value; + $this->attributes = $attributes; + $default_flags = [ + 'creation' => time(), + 'last-access' => time(), + 'persistent' => false, + 'host-only' => true, + ]; + $this->flags = array_merge($default_flags, $flags); + + $this->reference_time = time(); + if ($reference_time !== null) { + $this->reference_time = $reference_time; + } + + $this->normalize(); + } + + /** + * Get the cookie value + * + * Attributes and other data can be accessed via methods. + */ + public function __toString() { + return $this->value; + } + + /** + * Check if a cookie is expired. + * + * Checks the age against $this->reference_time to determine if the cookie + * is expired. + * + * @return boolean True if expired, false if time is valid. + */ + public function is_expired() { + // RFC6265, s. 4.1.2.2: + // If a cookie has both the Max-Age and the Expires attribute, the Max- + // Age attribute has precedence and controls the expiration date of the + // cookie. + if (isset($this->attributes['max-age'])) { + $max_age = $this->attributes['max-age']; + return $max_age < $this->reference_time; + } + + if (isset($this->attributes['expires'])) { + $expires = $this->attributes['expires']; + return $expires < $this->reference_time; + } + + return false; + } + + /** + * Check if a cookie is valid for a given URI + * + * @param \WpOrg\Requests\Iri $uri URI to check + * @return boolean Whether the cookie is valid for the given URI + */ + public function uri_matches(Iri $uri) { + if (!$this->domain_matches($uri->host)) { + return false; + } + + if (!$this->path_matches($uri->path)) { + return false; + } + + return empty($this->attributes['secure']) || $uri->scheme === 'https'; + } + + /** + * Check if a cookie is valid for a given domain + * + * @param string $domain Domain to check + * @return boolean Whether the cookie is valid for the given domain + */ + public function domain_matches($domain) { + if (is_string($domain) === false) { + return false; + } + + if (!isset($this->attributes['domain'])) { + // Cookies created manually; cookies created by Requests will set + // the domain to the requested domain + return true; + } + + $cookie_domain = $this->attributes['domain']; + if ($cookie_domain === $domain) { + // The cookie domain and the passed domain are identical. + return true; + } + + // If the cookie is marked as host-only and we don't have an exact + // match, reject the cookie + if ($this->flags['host-only'] === true) { + return false; + } + + if (strlen($domain) <= strlen($cookie_domain)) { + // For obvious reasons, the cookie domain cannot be a suffix if the passed domain + // is shorter than the cookie domain + return false; + } + + if (substr($domain, -1 * strlen($cookie_domain)) !== $cookie_domain) { + // The cookie domain should be a suffix of the passed domain. + return false; + } + + $prefix = substr($domain, 0, strlen($domain) - strlen($cookie_domain)); + if (substr($prefix, -1) !== '.') { + // The last character of the passed domain that is not included in the + // domain string should be a %x2E (".") character. + return false; + } + + // The passed domain should be a host name (i.e., not an IP address). + return !preg_match('#^(.+\.)\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$#', $domain); + } + + /** + * Check if a cookie is valid for a given path + * + * From the path-match check in RFC 6265 section 5.1.4 + * + * @param string $request_path Path to check + * @return boolean Whether the cookie is valid for the given path + */ + public function path_matches($request_path) { + if (empty($request_path)) { + // Normalize empty path to root + $request_path = '/'; + } + + if (!isset($this->attributes['path'])) { + // Cookies created manually; cookies created by Requests will set + // the path to the requested path + return true; + } + + if (is_scalar($request_path) === false) { + return false; + } + + $cookie_path = $this->attributes['path']; + + if ($cookie_path === $request_path) { + // The cookie-path and the request-path are identical. + return true; + } + + if (strlen($request_path) > strlen($cookie_path) && substr($request_path, 0, strlen($cookie_path)) === $cookie_path) { + if (substr($cookie_path, -1) === '/') { + // The cookie-path is a prefix of the request-path, and the last + // character of the cookie-path is %x2F ("/"). + return true; + } + + if (substr($request_path, strlen($cookie_path), 1) === '/') { + // The cookie-path is a prefix of the request-path, and the + // first character of the request-path that is not included in + // the cookie-path is a %x2F ("/") character. + return true; + } + } + + return false; + } + + /** + * Normalize cookie and attributes + * + * @return boolean Whether the cookie was successfully normalized + */ + public function normalize() { + foreach ($this->attributes as $key => $value) { + $orig_value = $value; + + if (is_string($key)) { + $value = $this->normalize_attribute($key, $value); + } + + if ($value === null) { + unset($this->attributes[$key]); + continue; + } + + if ($value !== $orig_value) { + $this->attributes[$key] = $value; + } + } + + return true; + } + + /** + * Parse an individual cookie attribute + * + * Handles parsing individual attributes from the cookie values. + * + * @param string $name Attribute name + * @param string|int|bool $value Attribute value (string/integer value, or true if empty/flag) + * @return mixed Value if available, or null if the attribute value is invalid (and should be skipped) + */ + protected function normalize_attribute($name, $value) { + switch (strtolower($name)) { + case 'expires': + // Expiration parsing, as per RFC 6265 section 5.2.1 + if (is_int($value)) { + return $value; + } + + $expiry_time = strtotime($value); + if ($expiry_time === false) { + return null; + } + + return $expiry_time; + + case 'max-age': + // Expiration parsing, as per RFC 6265 section 5.2.2 + if (is_int($value)) { + return $value; + } + + // Check that we have a valid age + if (!preg_match('/^-?\d+$/', $value)) { + return null; + } + + $delta_seconds = (int) $value; + if ($delta_seconds <= 0) { + $expiry_time = 0; + } else { + $expiry_time = $this->reference_time + $delta_seconds; + } + + return $expiry_time; + + case 'domain': + // Domains are not required as per RFC 6265 section 5.2.3 + if (empty($value)) { + return null; + } + + // Domain normalization, as per RFC 6265 section 5.2.3 + if ($value[0] === '.') { + $value = substr($value, 1); + } + + return $value; + + default: + return $value; + } + } + + /** + * Format a cookie for a Cookie header + * + * This is used when sending cookies to a server. + * + * @return string Cookie formatted for Cookie header + */ + public function format_for_header() { + return sprintf('%s=%s', $this->name, $this->value); + } + + /** + * Format a cookie for a Set-Cookie header + * + * This is used when sending cookies to clients. This isn't really + * applicable to client-side usage, but might be handy for debugging. + * + * @return string Cookie formatted for Set-Cookie header + */ + public function format_for_set_cookie() { + $header_value = $this->format_for_header(); + if (!empty($this->attributes)) { + $parts = []; + foreach ($this->attributes as $key => $value) { + // Ignore non-associative attributes + if (is_numeric($key)) { + $parts[] = $value; + } else { + $parts[] = sprintf('%s=%s', $key, $value); + } + } + + $header_value .= '; ' . implode('; ', $parts); + } + + return $header_value; + } + + /** + * Parse a cookie string into a cookie object + * + * Based on Mozilla's parsing code in Firefox and related projects, which + * is an intentional deviation from RFC 2109 and RFC 2616. RFC 6265 + * specifies some of this handling, but not in a thorough manner. + * + * @param string $cookie_header Cookie header value (from a Set-Cookie header) + * @param string $name + * @param int|null $reference_time + * @return \WpOrg\Requests\Cookie Parsed cookie object + * + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $cookie_header argument is not a string. + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $name argument is not a string. + */ + public static function parse($cookie_header, $name = '', $reference_time = null) { + if (is_string($cookie_header) === false) { + throw InvalidArgument::create(1, '$cookie_header', 'string', gettype($cookie_header)); + } + + if (is_string($name) === false) { + throw InvalidArgument::create(2, '$name', 'string', gettype($name)); + } + + $parts = explode(';', $cookie_header); + $kvparts = array_shift($parts); + + if (!empty($name)) { + $value = $cookie_header; + } elseif (strpos($kvparts, '=') === false) { + // Some sites might only have a value without the equals separator. + // Deviate from RFC 6265 and pretend it was actually a blank name + // (`=foo`) + // + // https://bugzilla.mozilla.org/show_bug.cgi?id=169091 + $name = ''; + $value = $kvparts; + } else { + list($name, $value) = explode('=', $kvparts, 2); + } + + $name = trim($name); + $value = trim($value); + + // Attribute keys are handled case-insensitively + $attributes = new CaseInsensitiveDictionary(); + + if (!empty($parts)) { + foreach ($parts as $part) { + if (strpos($part, '=') === false) { + $part_key = $part; + $part_value = true; + } else { + list($part_key, $part_value) = explode('=', $part, 2); + $part_value = trim($part_value); + } + + $part_key = trim($part_key); + $attributes[$part_key] = $part_value; + } + } + + return new static($name, $value, $attributes, [], $reference_time); + } + + /** + * Parse all Set-Cookie headers from request headers + * + * @param \WpOrg\Requests\Response\Headers $headers Headers to parse from + * @param \WpOrg\Requests\Iri|null $origin URI for comparing cookie origins + * @param int|null $time Reference time for expiration calculation + * @return array + */ + public static function parse_from_headers(Headers $headers, Iri $origin = null, $time = null) { + $cookie_headers = $headers->getValues('Set-Cookie'); + if (empty($cookie_headers)) { + return []; + } + + $cookies = []; + foreach ($cookie_headers as $header) { + $parsed = self::parse($header, '', $time); + + // Default domain/path attributes + if (empty($parsed->attributes['domain']) && !empty($origin)) { + $parsed->attributes['domain'] = $origin->host; + $parsed->flags['host-only'] = true; + } else { + $parsed->flags['host-only'] = false; + } + + $path_is_valid = (!empty($parsed->attributes['path']) && $parsed->attributes['path'][0] === '/'); + if (!$path_is_valid && !empty($origin)) { + $path = $origin->path; + + // Default path normalization as per RFC 6265 section 5.1.4 + if (substr($path, 0, 1) !== '/') { + // If the uri-path is empty or if the first character of + // the uri-path is not a %x2F ("/") character, output + // %x2F ("/") and skip the remaining steps. + $path = '/'; + } elseif (substr_count($path, '/') === 1) { + // If the uri-path contains no more than one %x2F ("/") + // character, output %x2F ("/") and skip the remaining + // step. + $path = '/'; + } else { + // Output the characters of the uri-path from the first + // character up to, but not including, the right-most + // %x2F ("/"). + $path = substr($path, 0, strrpos($path, '/')); + } + + $parsed->attributes['path'] = $path; + } + + // Reject invalid cookie domains + if (!empty($origin) && !$parsed->domain_matches($origin->host)) { + continue; + } + + $cookies[$parsed->name] = $parsed; + } + + return $cookies; + } +} diff --git a/wp-includes/Requests/src/Cookie/Jar.php b/wp-includes/Requests/src/Cookie/Jar.php new file mode 100644 index 0000000..7633786 --- /dev/null +++ b/wp-includes/Requests/src/Cookie/Jar.php @@ -0,0 +1,187 @@ +<?php +/** + * Cookie holder object + * + * @package Requests\Cookies + */ + +namespace WpOrg\Requests\Cookie; + +use ArrayAccess; +use ArrayIterator; +use IteratorAggregate; +use ReturnTypeWillChange; +use WpOrg\Requests\Cookie; +use WpOrg\Requests\Exception; +use WpOrg\Requests\Exception\InvalidArgument; +use WpOrg\Requests\HookManager; +use WpOrg\Requests\Iri; +use WpOrg\Requests\Response; + +/** + * Cookie holder object + * + * @package Requests\Cookies + */ +class Jar implements ArrayAccess, IteratorAggregate { + /** + * Actual item data + * + * @var array + */ + protected $cookies = []; + + /** + * Create a new jar + * + * @param array $cookies Existing cookie values + * + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed argument is not an array. + */ + public function __construct($cookies = []) { + if (is_array($cookies) === false) { + throw InvalidArgument::create(1, '$cookies', 'array', gettype($cookies)); + } + + $this->cookies = $cookies; + } + + /** + * Normalise cookie data into a \WpOrg\Requests\Cookie + * + * @param string|\WpOrg\Requests\Cookie $cookie Cookie header value, possibly pre-parsed (object). + * @param string $key Optional. The name for this cookie. + * @return \WpOrg\Requests\Cookie + */ + public function normalize_cookie($cookie, $key = '') { + if ($cookie instanceof Cookie) { + return $cookie; + } + + return Cookie::parse($cookie, $key); + } + + /** + * Check if the given item exists + * + * @param string $offset Item key + * @return boolean Does the item exist? + */ + #[ReturnTypeWillChange] + public function offsetExists($offset) { + return isset($this->cookies[$offset]); + } + + /** + * Get the value for the item + * + * @param string $offset Item key + * @return string|null Item value (null if offsetExists is false) + */ + #[ReturnTypeWillChange] + public function offsetGet($offset) { + if (!isset($this->cookies[$offset])) { + return null; + } + + return $this->cookies[$offset]; + } + + /** + * Set the given item + * + * @param string $offset Item name + * @param string $value Item value + * + * @throws \WpOrg\Requests\Exception On attempting to use dictionary as list (`invalidset`) + */ + #[ReturnTypeWillChange] + public function offsetSet($offset, $value) { + if ($offset === null) { + throw new Exception('Object is a dictionary, not a list', 'invalidset'); + } + + $this->cookies[$offset] = $value; + } + + /** + * Unset the given header + * + * @param string $offset The key for the item to unset. + */ + #[ReturnTypeWillChange] + public function offsetUnset($offset) { + unset($this->cookies[$offset]); + } + + /** + * Get an iterator for the data + * + * @return \ArrayIterator + */ + #[ReturnTypeWillChange] + public function getIterator() { + return new ArrayIterator($this->cookies); + } + + /** + * Register the cookie handler with the request's hooking system + * + * @param \WpOrg\Requests\HookManager $hooks Hooking system + */ + public function register(HookManager $hooks) { + $hooks->register('requests.before_request', [$this, 'before_request']); + $hooks->register('requests.before_redirect_check', [$this, 'before_redirect_check']); + } + + /** + * Add Cookie header to a request if we have any + * + * As per RFC 6265, cookies are separated by '; ' + * + * @param string $url + * @param array $headers + * @param array $data + * @param string $type + * @param array $options + */ + public function before_request($url, &$headers, &$data, &$type, &$options) { + if (!$url instanceof Iri) { + $url = new Iri($url); + } + + if (!empty($this->cookies)) { + $cookies = []; + foreach ($this->cookies as $key => $cookie) { + $cookie = $this->normalize_cookie($cookie, $key); + + // Skip expired cookies + if ($cookie->is_expired()) { + continue; + } + + if ($cookie->domain_matches($url->host)) { + $cookies[] = $cookie->format_for_header(); + } + } + + $headers['Cookie'] = implode('; ', $cookies); + } + } + + /** + * Parse all cookies from a response and attach them to the response + * + * @param \WpOrg\Requests\Response $response Response as received. + */ + public function before_redirect_check(Response $response) { + $url = $response->url; + if (!$url instanceof Iri) { + $url = new Iri($url); + } + + $cookies = Cookie::parse_from_headers($response->headers, $url); + $this->cookies = array_merge($this->cookies, $cookies); + $response->cookies = $this; + } +} diff --git a/wp-includes/Requests/src/Exception.php b/wp-includes/Requests/src/Exception.php new file mode 100644 index 0000000..b67d1b1 --- /dev/null +++ b/wp-includes/Requests/src/Exception.php @@ -0,0 +1,66 @@ +<?php +/** + * Exception for HTTP requests + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests; + +use Exception as PHPException; + +/** + * Exception for HTTP requests + * + * @package Requests\Exceptions + */ +class Exception extends PHPException { + /** + * Type of exception + * + * @var string + */ + protected $type; + + /** + * Data associated with the exception + * + * @var mixed + */ + protected $data; + + /** + * Create a new exception + * + * @param string $message Exception message + * @param string $type Exception type + * @param mixed $data Associated data + * @param integer $code Exception numerical code, if applicable + */ + public function __construct($message, $type, $data = null, $code = 0) { + parent::__construct($message, $code); + + $this->type = $type; + $this->data = $data; + } + + /** + * Like {@see \Exception::getCode()}, but a string code. + * + * @codeCoverageIgnore + * @return string + */ + public function getType() { + return $this->type; + } + + /** + * Gives any relevant data + * + * @codeCoverageIgnore + * @return mixed + */ + public function getData() { + return $this->data; + } +} diff --git a/wp-includes/Requests/src/Exception/ArgumentCount.php b/wp-includes/Requests/src/Exception/ArgumentCount.php new file mode 100644 index 0000000..b5773dd --- /dev/null +++ b/wp-includes/Requests/src/Exception/ArgumentCount.php @@ -0,0 +1,47 @@ +<?php + +namespace WpOrg\Requests\Exception; + +use WpOrg\Requests\Exception; + +/** + * Exception for when an incorrect number of arguments are passed to a method. + * + * Typically, this exception is used when all arguments for a method are optional, + * but certain arguments need to be passed together, i.e. a method which can be called + * with no arguments or with two arguments, but not with one argument. + * + * Along the same lines, this exception is also used if a method expects an array + * with a certain number of elements and the provided number of elements does not comply. + * + * @package Requests\Exceptions + * @since 2.0.0 + */ +final class ArgumentCount extends Exception { + + /** + * Create a new argument count exception with a standardized text. + * + * @param string $expected The argument count expected as a phrase. + * For example: `at least 2 arguments` or `exactly 1 argument`. + * @param int $received The actual argument count received. + * @param string $type Exception type. + * + * @return \WpOrg\Requests\Exception\ArgumentCount + */ + public static function create($expected, $received, $type) { + // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_debug_backtrace + $stack = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2); + + return new self( + sprintf( + '%s::%s() expects %s, %d given', + $stack[1]['class'], + $stack[1]['function'], + $expected, + $received + ), + $type + ); + } +} diff --git a/wp-includes/Requests/src/Exception/Http.php b/wp-includes/Requests/src/Exception/Http.php new file mode 100644 index 0000000..7efbc93 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http.php @@ -0,0 +1,78 @@ +<?php +/** + * Exception based on HTTP response + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception; + +use WpOrg\Requests\Exception; +use WpOrg\Requests\Exception\Http\StatusUnknown; + +/** + * Exception based on HTTP response + * + * @package Requests\Exceptions + */ +class Http extends Exception { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 0; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Unknown'; + + /** + * Create a new exception + * + * There is no mechanism to pass in the status code, as this is set by the + * subclass used. Reason phrases can vary, however. + * + * @param string|null $reason Reason phrase + * @param mixed $data Associated data + */ + public function __construct($reason = null, $data = null) { + if ($reason !== null) { + $this->reason = $reason; + } + + $message = sprintf('%d %s', $this->code, $this->reason); + parent::__construct($message, 'httpresponse', $data, $this->code); + } + + /** + * Get the status message. + * + * @return string + */ + public function getReason() { + return $this->reason; + } + + /** + * Get the correct exception class for a given error code + * + * @param int|bool $code HTTP status code, or false if unavailable + * @return string Exception class name to use + */ + public static function get_class($code) { + if (!$code) { + return StatusUnknown::class; + } + + $class = sprintf('\WpOrg\Requests\Exception\Http\Status%d', $code); + if (class_exists($class)) { + return $class; + } + + return StatusUnknown::class; + } +} diff --git a/wp-includes/Requests/src/Exception/Http/Status304.php b/wp-includes/Requests/src/Exception/Http/Status304.php new file mode 100644 index 0000000..d510ae7 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status304.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 304 Not Modified responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 304 Not Modified responses + * + * @package Requests\Exceptions + */ +final class Status304 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 304; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Not Modified'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status305.php b/wp-includes/Requests/src/Exception/Http/Status305.php new file mode 100644 index 0000000..8be63c3 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status305.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 305 Use Proxy responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 305 Use Proxy responses + * + * @package Requests\Exceptions + */ +final class Status305 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 305; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Use Proxy'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status306.php b/wp-includes/Requests/src/Exception/Http/Status306.php new file mode 100644 index 0000000..2f3534a --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status306.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 306 Switch Proxy responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 306 Switch Proxy responses + * + * @package Requests\Exceptions + */ +final class Status306 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 306; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Switch Proxy'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status400.php b/wp-includes/Requests/src/Exception/Http/Status400.php new file mode 100644 index 0000000..4e39623 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status400.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 400 Bad Request responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 400 Bad Request responses + * + * @package Requests\Exceptions + */ +final class Status400 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 400; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Bad Request'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status401.php b/wp-includes/Requests/src/Exception/Http/Status401.php new file mode 100644 index 0000000..2a76429 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status401.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 401 Unauthorized responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 401 Unauthorized responses + * + * @package Requests\Exceptions + */ +final class Status401 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 401; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Unauthorized'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status402.php b/wp-includes/Requests/src/Exception/Http/Status402.php new file mode 100644 index 0000000..09d4287 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status402.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 402 Payment Required responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 402 Payment Required responses + * + * @package Requests\Exceptions + */ +final class Status402 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 402; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Payment Required'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status403.php b/wp-includes/Requests/src/Exception/Http/Status403.php new file mode 100644 index 0000000..0b1fc39 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status403.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 403 Forbidden responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 403 Forbidden responses + * + * @package Requests\Exceptions + */ +final class Status403 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 403; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Forbidden'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status404.php b/wp-includes/Requests/src/Exception/Http/Status404.php new file mode 100644 index 0000000..ef39a85 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status404.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 404 Not Found responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 404 Not Found responses + * + * @package Requests\Exceptions + */ +final class Status404 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 404; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Not Found'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status405.php b/wp-includes/Requests/src/Exception/Http/Status405.php new file mode 100644 index 0000000..666fbfe --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status405.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 405 Method Not Allowed responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 405 Method Not Allowed responses + * + * @package Requests\Exceptions + */ +final class Status405 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 405; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Method Not Allowed'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status406.php b/wp-includes/Requests/src/Exception/Http/Status406.php new file mode 100644 index 0000000..37952f8 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status406.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 406 Not Acceptable responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 406 Not Acceptable responses + * + * @package Requests\Exceptions + */ +final class Status406 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 406; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Not Acceptable'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status407.php b/wp-includes/Requests/src/Exception/Http/Status407.php new file mode 100644 index 0000000..d8796f9 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status407.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 407 Proxy Authentication Required responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 407 Proxy Authentication Required responses + * + * @package Requests\Exceptions + */ +final class Status407 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 407; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Proxy Authentication Required'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status408.php b/wp-includes/Requests/src/Exception/Http/Status408.php new file mode 100644 index 0000000..6718d06 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status408.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 408 Request Timeout responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 408 Request Timeout responses + * + * @package Requests\Exceptions + */ +final class Status408 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 408; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Request Timeout'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status409.php b/wp-includes/Requests/src/Exception/Http/Status409.php new file mode 100644 index 0000000..711a5c4 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status409.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 409 Conflict responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 409 Conflict responses + * + * @package Requests\Exceptions + */ +final class Status409 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 409; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Conflict'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status410.php b/wp-includes/Requests/src/Exception/Http/Status410.php new file mode 100644 index 0000000..127443b --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status410.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 410 Gone responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 410 Gone responses + * + * @package Requests\Exceptions + */ +final class Status410 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 410; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Gone'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status411.php b/wp-includes/Requests/src/Exception/Http/Status411.php new file mode 100644 index 0000000..e70e63c --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status411.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 411 Length Required responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 411 Length Required responses + * + * @package Requests\Exceptions + */ +final class Status411 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 411; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Length Required'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status412.php b/wp-includes/Requests/src/Exception/Http/Status412.php new file mode 100644 index 0000000..4a8b918 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status412.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 412 Precondition Failed responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 412 Precondition Failed responses + * + * @package Requests\Exceptions + */ +final class Status412 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 412; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Precondition Failed'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status413.php b/wp-includes/Requests/src/Exception/Http/Status413.php new file mode 100644 index 0000000..96a96fb --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status413.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 413 Request Entity Too Large responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 413 Request Entity Too Large responses + * + * @package Requests\Exceptions + */ +final class Status413 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 413; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Request Entity Too Large'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status414.php b/wp-includes/Requests/src/Exception/Http/Status414.php new file mode 100644 index 0000000..b65ec93 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status414.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 414 Request-URI Too Large responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 414 Request-URI Too Large responses + * + * @package Requests\Exceptions + */ +final class Status414 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 414; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Request-URI Too Large'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status415.php b/wp-includes/Requests/src/Exception/Http/Status415.php new file mode 100644 index 0000000..cb45655 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status415.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 415 Unsupported Media Type responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 415 Unsupported Media Type responses + * + * @package Requests\Exceptions + */ +final class Status415 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 415; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Unsupported Media Type'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status416.php b/wp-includes/Requests/src/Exception/Http/Status416.php new file mode 100644 index 0000000..c3661a1 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status416.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 416 Requested Range Not Satisfiable responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 416 Requested Range Not Satisfiable responses + * + * @package Requests\Exceptions + */ +final class Status416 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 416; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Requested Range Not Satisfiable'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status417.php b/wp-includes/Requests/src/Exception/Http/Status417.php new file mode 100644 index 0000000..4adba9a --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status417.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 417 Expectation Failed responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 417 Expectation Failed responses + * + * @package Requests\Exceptions + */ +final class Status417 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 417; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Expectation Failed'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status418.php b/wp-includes/Requests/src/Exception/Http/Status418.php new file mode 100644 index 0000000..5bcb2b8 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status418.php @@ -0,0 +1,35 @@ +<?php +/** + * Exception for 418 I'm A Teapot responses + * + * @link https://tools.ietf.org/html/rfc2324 + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 418 I'm A Teapot responses + * + * @link https://tools.ietf.org/html/rfc2324 + * + * @package Requests\Exceptions + */ +final class Status418 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 418; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = "I'm A Teapot"; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status428.php b/wp-includes/Requests/src/Exception/Http/Status428.php new file mode 100644 index 0000000..4d7ea51 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status428.php @@ -0,0 +1,35 @@ +<?php +/** + * Exception for 428 Precondition Required responses + * + * @link https://tools.ietf.org/html/rfc6585 + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 428 Precondition Required responses + * + * @link https://tools.ietf.org/html/rfc6585 + * + * @package Requests\Exceptions + */ +final class Status428 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 428; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Precondition Required'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status429.php b/wp-includes/Requests/src/Exception/Http/Status429.php new file mode 100644 index 0000000..2018196 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status429.php @@ -0,0 +1,35 @@ +<?php +/** + * Exception for 429 Too Many Requests responses + * + * @link https://tools.ietf.org/html/draft-nottingham-http-new-status-04 + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 429 Too Many Requests responses + * + * @link https://tools.ietf.org/html/draft-nottingham-http-new-status-04 + * + * @package Requests\Exceptions + */ +final class Status429 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 429; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Too Many Requests'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status431.php b/wp-includes/Requests/src/Exception/Http/Status431.php new file mode 100644 index 0000000..50bba43 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status431.php @@ -0,0 +1,35 @@ +<?php +/** + * Exception for 431 Request Header Fields Too Large responses + * + * @link https://tools.ietf.org/html/rfc6585 + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 431 Request Header Fields Too Large responses + * + * @link https://tools.ietf.org/html/rfc6585 + * + * @package Requests\Exceptions + */ +final class Status431 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 431; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Request Header Fields Too Large'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status500.php b/wp-includes/Requests/src/Exception/Http/Status500.php new file mode 100644 index 0000000..42089ff --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status500.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 500 Internal Server Error responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 500 Internal Server Error responses + * + * @package Requests\Exceptions + */ +final class Status500 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 500; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Internal Server Error'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status501.php b/wp-includes/Requests/src/Exception/Http/Status501.php new file mode 100644 index 0000000..2b92430 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status501.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 501 Not Implemented responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 501 Not Implemented responses + * + * @package Requests\Exceptions + */ +final class Status501 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 501; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Not Implemented'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status502.php b/wp-includes/Requests/src/Exception/Http/Status502.php new file mode 100644 index 0000000..7ce2b0f --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status502.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 502 Bad Gateway responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 502 Bad Gateway responses + * + * @package Requests\Exceptions + */ +final class Status502 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 502; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Bad Gateway'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status503.php b/wp-includes/Requests/src/Exception/Http/Status503.php new file mode 100644 index 0000000..2e70dd9 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status503.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 503 Service Unavailable responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 503 Service Unavailable responses + * + * @package Requests\Exceptions + */ +final class Status503 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 503; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Service Unavailable'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status504.php b/wp-includes/Requests/src/Exception/Http/Status504.php new file mode 100644 index 0000000..efa100a --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status504.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 504 Gateway Timeout responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 504 Gateway Timeout responses + * + * @package Requests\Exceptions + */ +final class Status504 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 504; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Gateway Timeout'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status505.php b/wp-includes/Requests/src/Exception/Http/Status505.php new file mode 100644 index 0000000..71ba463 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status505.php @@ -0,0 +1,31 @@ +<?php +/** + * Exception for 505 HTTP Version Not Supported responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 505 HTTP Version Not Supported responses + * + * @package Requests\Exceptions + */ +final class Status505 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 505; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'HTTP Version Not Supported'; +} diff --git a/wp-includes/Requests/src/Exception/Http/Status511.php b/wp-includes/Requests/src/Exception/Http/Status511.php new file mode 100644 index 0000000..8d6fee7 --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/Status511.php @@ -0,0 +1,35 @@ +<?php +/** + * Exception for 511 Network Authentication Required responses + * + * @link https://tools.ietf.org/html/rfc6585 + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; + +/** + * Exception for 511 Network Authentication Required responses + * + * @link https://tools.ietf.org/html/rfc6585 + * + * @package Requests\Exceptions + */ +final class Status511 extends Http { + /** + * HTTP status code + * + * @var integer + */ + protected $code = 511; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Network Authentication Required'; +} diff --git a/wp-includes/Requests/src/Exception/Http/StatusUnknown.php b/wp-includes/Requests/src/Exception/Http/StatusUnknown.php new file mode 100644 index 0000000..802793f --- /dev/null +++ b/wp-includes/Requests/src/Exception/Http/StatusUnknown.php @@ -0,0 +1,49 @@ +<?php +/** + * Exception for unknown status responses + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Http; + +use WpOrg\Requests\Exception\Http; +use WpOrg\Requests\Response; + +/** + * Exception for unknown status responses + * + * @package Requests\Exceptions + */ +final class StatusUnknown extends Http { + /** + * HTTP status code + * + * @var integer|bool Code if available, false if an error occurred + */ + protected $code = 0; + + /** + * Reason phrase + * + * @var string + */ + protected $reason = 'Unknown'; + + /** + * Create a new exception + * + * If `$data` is an instance of {@see \WpOrg\Requests\Response}, uses the status + * code from it. Otherwise, sets as 0 + * + * @param string|null $reason Reason phrase + * @param mixed $data Associated data + */ + public function __construct($reason = null, $data = null) { + if ($data instanceof Response) { + $this->code = (int) $data->status_code; + } + + parent::__construct($reason, $data); + } +} diff --git a/wp-includes/Requests/src/Exception/InvalidArgument.php b/wp-includes/Requests/src/Exception/InvalidArgument.php new file mode 100644 index 0000000..0ab7332 --- /dev/null +++ b/wp-includes/Requests/src/Exception/InvalidArgument.php @@ -0,0 +1,41 @@ +<?php + +namespace WpOrg\Requests\Exception; + +use InvalidArgumentException; + +/** + * Exception for an invalid argument passed. + * + * @package Requests\Exceptions + * @since 2.0.0 + */ +final class InvalidArgument extends InvalidArgumentException { + + /** + * Create a new invalid argument exception with a standardized text. + * + * @param int $position The argument position in the function signature. 1-based. + * @param string $name The argument name in the function signature. + * @param string $expected The argument type expected as a string. + * @param string $received The actual argument type received. + * + * @return \WpOrg\Requests\Exception\InvalidArgument + */ + public static function create($position, $name, $expected, $received) { + // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_debug_backtrace + $stack = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2); + + return new self( + sprintf( + '%s::%s(): Argument #%d (%s) must be of type %s, %s given', + $stack[1]['class'], + $stack[1]['function'], + $position, + $name, + $expected, + $received + ) + ); + } +} diff --git a/wp-includes/Requests/src/Exception/Transport.php b/wp-includes/Requests/src/Exception/Transport.php new file mode 100644 index 0000000..c76e92e --- /dev/null +++ b/wp-includes/Requests/src/Exception/Transport.php @@ -0,0 +1,17 @@ +<?php +/** + * Transport Exception + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception; + +use WpOrg\Requests\Exception; + +/** + * Transport Exception + * + * @package Requests\Exceptions + */ +class Transport extends Exception {} diff --git a/wp-includes/Requests/src/Exception/Transport/Curl.php b/wp-includes/Requests/src/Exception/Transport/Curl.php new file mode 100644 index 0000000..4c0294d --- /dev/null +++ b/wp-includes/Requests/src/Exception/Transport/Curl.php @@ -0,0 +1,80 @@ +<?php +/** + * CURL Transport Exception. + * + * @package Requests\Exceptions + */ + +namespace WpOrg\Requests\Exception\Transport; + +use WpOrg\Requests\Exception\Transport; + +/** + * CURL Transport Exception. + * + * @package Requests\Exceptions + */ +final class Curl extends Transport { + + const EASY = 'cURLEasy'; + const MULTI = 'cURLMulti'; + const SHARE = 'cURLShare'; + + /** + * cURL error code + * + * @var integer + */ + protected $code = -1; + + /** + * Which type of cURL error + * + * EASY|MULTI|SHARE + * + * @var string + */ + protected $type = 'Unknown'; + + /** + * Clear text error message + * + * @var string + */ + protected $reason = 'Unknown'; + + /** + * Create a new exception. + * + * @param string $message Exception message. + * @param string $type Exception type. + * @param mixed $data Associated data, if applicable. + * @param int $code Exception numerical code, if applicable. + */ + public function __construct($message, $type, $data = null, $code = 0) { + if ($type !== null) { + $this->type = $type; + } + + if ($code !== null) { + $this->code = (int) $code; + } + + if ($message !== null) { + $this->reason = $message; + } + + $message = sprintf('%d %s', $this->code, $this->reason); + parent::__construct($message, $this->type, $data, $this->code); + } + + /** + * Get the error message. + * + * @return string + */ + public function getReason() { + return $this->reason; + } + +} diff --git a/wp-includes/Requests/src/HookManager.php b/wp-includes/Requests/src/HookManager.php new file mode 100644 index 0000000..f292017 --- /dev/null +++ b/wp-includes/Requests/src/HookManager.php @@ -0,0 +1,33 @@ +<?php +/** + * Event dispatcher + * + * @package Requests\EventDispatcher + */ + +namespace WpOrg\Requests; + +/** + * Event dispatcher + * + * @package Requests\EventDispatcher + */ +interface HookManager { + /** + * Register a callback for a hook + * + * @param string $hook Hook name + * @param callable $callback Function/method to call on event + * @param int $priority Priority number. <0 is executed earlier, >0 is executed later + */ + public function register($hook, $callback, $priority = 0); + + /** + * Dispatch a message + * + * @param string $hook Hook name + * @param array $parameters Parameters to pass to callbacks + * @return boolean Successfulness + */ + public function dispatch($hook, $parameters = []); +} diff --git a/wp-includes/Requests/src/Hooks.php b/wp-includes/Requests/src/Hooks.php new file mode 100644 index 0000000..d8023ed --- /dev/null +++ b/wp-includes/Requests/src/Hooks.php @@ -0,0 +1,103 @@ +<?php +/** + * Handles adding and dispatching events + * + * @package Requests\EventDispatcher + */ + +namespace WpOrg\Requests; + +use WpOrg\Requests\Exception\InvalidArgument; +use WpOrg\Requests\HookManager; +use WpOrg\Requests\Utility\InputValidator; + +/** + * Handles adding and dispatching events + * + * @package Requests\EventDispatcher + */ +class Hooks implements HookManager { + /** + * Registered callbacks for each hook + * + * @var array + */ + protected $hooks = []; + + /** + * Register a callback for a hook + * + * @param string $hook Hook name + * @param callable $callback Function/method to call on event + * @param int $priority Priority number. <0 is executed earlier, >0 is executed later + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $hook argument is not a string. + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $callback argument is not callable. + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $priority argument is not an integer. + */ + public function register($hook, $callback, $priority = 0) { + if (is_string($hook) === false) { + throw InvalidArgument::create(1, '$hook', 'string', gettype($hook)); + } + + if (is_callable($callback) === false) { + throw InvalidArgument::create(2, '$callback', 'callable', gettype($callback)); + } + + if (InputValidator::is_numeric_array_key($priority) === false) { + throw InvalidArgument::create(3, '$priority', 'integer', gettype($priority)); + } + + if (!isset($this->hooks[$hook])) { + $this->hooks[$hook] = [ + $priority => [], + ]; + } elseif (!isset($this->hooks[$hook][$priority])) { + $this->hooks[$hook][$priority] = []; + } + + $this->hooks[$hook][$priority][] = $callback; + } + + /** + * Dispatch a message + * + * @param string $hook Hook name + * @param array $parameters Parameters to pass to callbacks + * @return boolean Successfulness + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $hook argument is not a string. + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $parameters argument is not an array. + */ + public function dispatch($hook, $parameters = []) { + if (is_string($hook) === false) { + throw InvalidArgument::create(1, '$hook', 'string', gettype($hook)); + } + + // Check strictly against array, as Array* objects don't work in combination with `call_user_func_array()`. + if (is_array($parameters) === false) { + throw InvalidArgument::create(2, '$parameters', 'array', gettype($parameters)); + } + + if (empty($this->hooks[$hook])) { + return false; + } + + if (!empty($parameters)) { + // Strip potential keys from the array to prevent them being interpreted as parameter names in PHP 8.0. + $parameters = array_values($parameters); + } + + ksort($this->hooks[$hook]); + + foreach ($this->hooks[$hook] as $priority => $hooked) { + foreach ($hooked as $callback) { + $callback(...$parameters); + } + } + + return true; + } + + public function __wakeup() { + throw new \LogicException( __CLASS__ . ' should never be unserialized' ); + } +} diff --git a/wp-includes/Requests/src/IdnaEncoder.php b/wp-includes/Requests/src/IdnaEncoder.php new file mode 100644 index 0000000..4257a1a --- /dev/null +++ b/wp-includes/Requests/src/IdnaEncoder.php @@ -0,0 +1,412 @@ +<?php + +namespace WpOrg\Requests; + +use WpOrg\Requests\Exception; +use WpOrg\Requests\Exception\InvalidArgument; +use WpOrg\Requests\Utility\InputValidator; + +/** + * IDNA URL encoder + * + * Note: Not fully compliant, as nameprep does nothing yet. + * + * @package Requests\Utilities + * + * @link https://tools.ietf.org/html/rfc3490 IDNA specification + * @link https://tools.ietf.org/html/rfc3492 Punycode/Bootstrap specification + */ +class IdnaEncoder { + /** + * ACE prefix used for IDNA + * + * @link https://tools.ietf.org/html/rfc3490#section-5 + * @var string + */ + const ACE_PREFIX = 'xn--'; + + /** + * Maximum length of a IDNA URL in ASCII. + * + * @see \WpOrg\Requests\IdnaEncoder::to_ascii() + * + * @since 2.0.0 + * + * @var int + */ + const MAX_LENGTH = 64; + + /**#@+ + * Bootstrap constant for Punycode + * + * @link https://tools.ietf.org/html/rfc3492#section-5 + * @var int + */ + const BOOTSTRAP_BASE = 36; + const BOOTSTRAP_TMIN = 1; + const BOOTSTRAP_TMAX = 26; + const BOOTSTRAP_SKEW = 38; + const BOOTSTRAP_DAMP = 700; + const BOOTSTRAP_INITIAL_BIAS = 72; + const BOOTSTRAP_INITIAL_N = 128; + /**#@-*/ + + /** + * Encode a hostname using Punycode + * + * @param string|Stringable $hostname Hostname + * @return string Punycode-encoded hostname + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed argument is not a string or a stringable object. + */ + public static function encode($hostname) { + if (InputValidator::is_string_or_stringable($hostname) === false) { + throw InvalidArgument::create(1, '$hostname', 'string|Stringable', gettype($hostname)); + } + + $parts = explode('.', $hostname); + foreach ($parts as &$part) { + $part = self::to_ascii($part); + } + + return implode('.', $parts); + } + + /** + * Convert a UTF-8 text string to an ASCII string using Punycode + * + * @param string $text ASCII or UTF-8 string (max length 64 characters) + * @return string ASCII string + * + * @throws \WpOrg\Requests\Exception Provided string longer than 64 ASCII characters (`idna.provided_too_long`) + * @throws \WpOrg\Requests\Exception Prepared string longer than 64 ASCII characters (`idna.prepared_too_long`) + * @throws \WpOrg\Requests\Exception Provided string already begins with xn-- (`idna.provided_is_prefixed`) + * @throws \WpOrg\Requests\Exception Encoded string longer than 64 ASCII characters (`idna.encoded_too_long`) + */ + public static function to_ascii($text) { + // Step 1: Check if the text is already ASCII + if (self::is_ascii($text)) { + // Skip to step 7 + if (strlen($text) < self::MAX_LENGTH) { + return $text; + } + + throw new Exception('Provided string is too long', 'idna.provided_too_long', $text); + } + + // Step 2: nameprep + $text = self::nameprep($text); + + // Step 3: UseSTD3ASCIIRules is false, continue + // Step 4: Check if it's ASCII now + if (self::is_ascii($text)) { + // Skip to step 7 + /* + * As the `nameprep()` method returns the original string, this code will never be reached until + * that method is properly implemented. + */ + // @codeCoverageIgnoreStart + if (strlen($text) < self::MAX_LENGTH) { + return $text; + } + + throw new Exception('Prepared string is too long', 'idna.prepared_too_long', $text); + // @codeCoverageIgnoreEnd + } + + // Step 5: Check ACE prefix + if (strpos($text, self::ACE_PREFIX) === 0) { + throw new Exception('Provided string begins with ACE prefix', 'idna.provided_is_prefixed', $text); + } + + // Step 6: Encode with Punycode + $text = self::punycode_encode($text); + + // Step 7: Prepend ACE prefix + $text = self::ACE_PREFIX . $text; + + // Step 8: Check size + if (strlen($text) < self::MAX_LENGTH) { + return $text; + } + + throw new Exception('Encoded string is too long', 'idna.encoded_too_long', $text); + } + + /** + * Check whether a given text string contains only ASCII characters + * + * @internal (Testing found regex was the fastest implementation) + * + * @param string $text Text to examine. + * @return bool Is the text string ASCII-only? + */ + protected static function is_ascii($text) { + return (preg_match('/(?:[^\x00-\x7F])/', $text) !== 1); + } + + /** + * Prepare a text string for use as an IDNA name + * + * @todo Implement this based on RFC 3491 and the newer 5891 + * @param string $text Text to prepare. + * @return string Prepared string + */ + protected static function nameprep($text) { + return $text; + } + + /** + * Convert a UTF-8 string to a UCS-4 codepoint array + * + * Based on \WpOrg\Requests\Iri::replace_invalid_with_pct_encoding() + * + * @param string $input Text to convert. + * @return array Unicode code points + * + * @throws \WpOrg\Requests\Exception Invalid UTF-8 codepoint (`idna.invalidcodepoint`) + */ + protected static function utf8_to_codepoints($input) { + $codepoints = []; + + // Get number of bytes + $strlen = strlen($input); + + // phpcs:ignore Generic.CodeAnalysis.JumbledIncrementer -- This is a deliberate choice. + for ($position = 0; $position < $strlen; $position++) { + $value = ord($input[$position]); + + if ((~$value & 0x80) === 0x80) { // One byte sequence: + $character = $value; + $length = 1; + $remaining = 0; + } elseif (($value & 0xE0) === 0xC0) { // Two byte sequence: + $character = ($value & 0x1F) << 6; + $length = 2; + $remaining = 1; + } elseif (($value & 0xF0) === 0xE0) { // Three byte sequence: + $character = ($value & 0x0F) << 12; + $length = 3; + $remaining = 2; + } elseif (($value & 0xF8) === 0xF0) { // Four byte sequence: + $character = ($value & 0x07) << 18; + $length = 4; + $remaining = 3; + } else { // Invalid byte: + throw new Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $value); + } + + if ($remaining > 0) { + if ($position + $length > $strlen) { + throw new Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $character); + } + + for ($position++; $remaining > 0; $position++) { + $value = ord($input[$position]); + + // If it is invalid, count the sequence as invalid and reprocess the current byte: + if (($value & 0xC0) !== 0x80) { + throw new Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $character); + } + + --$remaining; + $character |= ($value & 0x3F) << ($remaining * 6); + } + + $position--; + } + + if (// Non-shortest form sequences are invalid + $length > 1 && $character <= 0x7F + || $length > 2 && $character <= 0x7FF + || $length > 3 && $character <= 0xFFFF + // Outside of range of ucschar codepoints + // Noncharacters + || ($character & 0xFFFE) === 0xFFFE + || $character >= 0xFDD0 && $character <= 0xFDEF + || ( + // Everything else not in ucschar + $character > 0xD7FF && $character < 0xF900 + || $character < 0x20 + || $character > 0x7E && $character < 0xA0 + || $character > 0xEFFFD + ) + ) { + throw new Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $character); + } + + $codepoints[] = $character; + } + + return $codepoints; + } + + /** + * RFC3492-compliant encoder + * + * @internal Pseudo-code from Section 6.3 is commented with "#" next to relevant code + * + * @param string $input UTF-8 encoded string to encode + * @return string Punycode-encoded string + * + * @throws \WpOrg\Requests\Exception On character outside of the domain (never happens with Punycode) (`idna.character_outside_domain`) + */ + public static function punycode_encode($input) { + $output = ''; + // let n = initial_n + $n = self::BOOTSTRAP_INITIAL_N; + // let delta = 0 + $delta = 0; + // let bias = initial_bias + $bias = self::BOOTSTRAP_INITIAL_BIAS; + // let h = b = the number of basic code points in the input + $h = 0; + $b = 0; // see loop + // copy them to the output in order + $codepoints = self::utf8_to_codepoints($input); + $extended = []; + + foreach ($codepoints as $char) { + if ($char < 128) { + // Character is valid ASCII + // TODO: this should also check if it's valid for a URL + $output .= chr($char); + $h++; + + // Check if the character is non-ASCII, but below initial n + // This never occurs for Punycode, so ignore in coverage + // @codeCoverageIgnoreStart + } elseif ($char < $n) { + throw new Exception('Invalid character', 'idna.character_outside_domain', $char); + // @codeCoverageIgnoreEnd + } else { + $extended[$char] = true; + } + } + + $extended = array_keys($extended); + sort($extended); + $b = $h; + // [copy them] followed by a delimiter if b > 0 + if (strlen($output) > 0) { + $output .= '-'; + } + + // {if the input contains a non-basic code point < n then fail} + // while h < length(input) do begin + $codepointcount = count($codepoints); + while ($h < $codepointcount) { + // let m = the minimum code point >= n in the input + $m = array_shift($extended); + //printf('next code point to insert is %s' . PHP_EOL, dechex($m)); + // let delta = delta + (m - n) * (h + 1), fail on overflow + $delta += ($m - $n) * ($h + 1); + // let n = m + $n = $m; + // for each code point c in the input (in order) do begin + for ($num = 0; $num < $codepointcount; $num++) { + $c = $codepoints[$num]; + // if c < n then increment delta, fail on overflow + if ($c < $n) { + $delta++; + } elseif ($c === $n) { // if c == n then begin + // let q = delta + $q = $delta; + // for k = base to infinity in steps of base do begin + for ($k = self::BOOTSTRAP_BASE; ; $k += self::BOOTSTRAP_BASE) { + // let t = tmin if k <= bias {+ tmin}, or + // tmax if k >= bias + tmax, or k - bias otherwise + if ($k <= ($bias + self::BOOTSTRAP_TMIN)) { + $t = self::BOOTSTRAP_TMIN; + } elseif ($k >= ($bias + self::BOOTSTRAP_TMAX)) { + $t = self::BOOTSTRAP_TMAX; + } else { + $t = $k - $bias; + } + + // if q < t then break + if ($q < $t) { + break; + } + + // output the code point for digit t + ((q - t) mod (base - t)) + $digit = (int) ($t + (($q - $t) % (self::BOOTSTRAP_BASE - $t))); + $output .= self::digit_to_char($digit); + // let q = (q - t) div (base - t) + $q = (int) floor(($q - $t) / (self::BOOTSTRAP_BASE - $t)); + } // end + // output the code point for digit q + $output .= self::digit_to_char($q); + // let bias = adapt(delta, h + 1, test h equals b?) + $bias = self::adapt($delta, $h + 1, $h === $b); + // let delta = 0 + $delta = 0; + // increment h + $h++; + } // end + } // end + // increment delta and n + $delta++; + $n++; + } // end + + return $output; + } + + /** + * Convert a digit to its respective character + * + * @link https://tools.ietf.org/html/rfc3492#section-5 + * + * @param int $digit Digit in the range 0-35 + * @return string Single character corresponding to digit + * + * @throws \WpOrg\Requests\Exception On invalid digit (`idna.invalid_digit`) + */ + protected static function digit_to_char($digit) { + // @codeCoverageIgnoreStart + // As far as I know, this never happens, but still good to be sure. + if ($digit < 0 || $digit > 35) { + throw new Exception(sprintf('Invalid digit %d', $digit), 'idna.invalid_digit', $digit); + } + + // @codeCoverageIgnoreEnd + $digits = 'abcdefghijklmnopqrstuvwxyz0123456789'; + return substr($digits, $digit, 1); + } + + /** + * Adapt the bias + * + * @link https://tools.ietf.org/html/rfc3492#section-6.1 + * @param int $delta + * @param int $numpoints + * @param bool $firsttime + * @return int|float New bias + * + * function adapt(delta,numpoints,firsttime): + */ + protected static function adapt($delta, $numpoints, $firsttime) { + // if firsttime then let delta = delta div damp + if ($firsttime) { + $delta = floor($delta / self::BOOTSTRAP_DAMP); + } else { + // else let delta = delta div 2 + $delta = floor($delta / 2); + } + + // let delta = delta + (delta div numpoints) + $delta += floor($delta / $numpoints); + // let k = 0 + $k = 0; + // while delta > ((base - tmin) * tmax) div 2 do begin + $max = floor(((self::BOOTSTRAP_BASE - self::BOOTSTRAP_TMIN) * self::BOOTSTRAP_TMAX) / 2); + while ($delta > $max) { + // let delta = delta div (base - tmin) + $delta = floor($delta / (self::BOOTSTRAP_BASE - self::BOOTSTRAP_TMIN)); + // let k = k + base + $k += self::BOOTSTRAP_BASE; + } // end + // return k + (((base - tmin + 1) * delta) div (delta + skew)) + return $k + floor(((self::BOOTSTRAP_BASE - self::BOOTSTRAP_TMIN + 1) * $delta) / ($delta + self::BOOTSTRAP_SKEW)); + } +} diff --git a/wp-includes/Requests/src/Ipv6.php b/wp-includes/Requests/src/Ipv6.php new file mode 100644 index 0000000..a90ab8a --- /dev/null +++ b/wp-includes/Requests/src/Ipv6.php @@ -0,0 +1,203 @@ +<?php +/** + * Class to validate and to work with IPv6 addresses + * + * @package Requests\Utilities + */ + +namespace WpOrg\Requests; + +use WpOrg\Requests\Exception\InvalidArgument; +use WpOrg\Requests\Utility\InputValidator; + +/** + * Class to validate and to work with IPv6 addresses + * + * This was originally based on the PEAR class of the same name, but has been + * entirely rewritten. + * + * @package Requests\Utilities + */ +final class Ipv6 { + /** + * Uncompresses an IPv6 address + * + * RFC 4291 allows you to compress consecutive zero pieces in an address to + * '::'. This method expects a valid IPv6 address and expands the '::' to + * the required number of zero pieces. + * + * Example: FF01::101 -> FF01:0:0:0:0:0:0:101 + * ::1 -> 0:0:0:0:0:0:0:1 + * + * @author Alexander Merz <alexander.merz@web.de> + * @author elfrink at introweb dot nl + * @author Josh Peck <jmp at joshpeck dot org> + * @copyright 2003-2005 The PHP Group + * @license https://opensource.org/licenses/bsd-license.php + * + * @param string|Stringable $ip An IPv6 address + * @return string The uncompressed IPv6 address + * + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed argument is not a string or a stringable object. + */ + public static function uncompress($ip) { + if (InputValidator::is_string_or_stringable($ip) === false) { + throw InvalidArgument::create(1, '$ip', 'string|Stringable', gettype($ip)); + } + + $ip = (string) $ip; + + if (substr_count($ip, '::') !== 1) { + return $ip; + } + + list($ip1, $ip2) = explode('::', $ip); + $c1 = ($ip1 === '') ? -1 : substr_count($ip1, ':'); + $c2 = ($ip2 === '') ? -1 : substr_count($ip2, ':'); + + if (strpos($ip2, '.') !== false) { + $c2++; + } + + if ($c1 === -1 && $c2 === -1) { + // :: + $ip = '0:0:0:0:0:0:0:0'; + } elseif ($c1 === -1) { + // ::xxx + $fill = str_repeat('0:', 7 - $c2); + $ip = str_replace('::', $fill, $ip); + } elseif ($c2 === -1) { + // xxx:: + $fill = str_repeat(':0', 7 - $c1); + $ip = str_replace('::', $fill, $ip); + } else { + // xxx::xxx + $fill = ':' . str_repeat('0:', 6 - $c2 - $c1); + $ip = str_replace('::', $fill, $ip); + } + + return $ip; + } + + /** + * Compresses an IPv6 address + * + * RFC 4291 allows you to compress consecutive zero pieces in an address to + * '::'. This method expects a valid IPv6 address and compresses consecutive + * zero pieces to '::'. + * + * Example: FF01:0:0:0:0:0:0:101 -> FF01::101 + * 0:0:0:0:0:0:0:1 -> ::1 + * + * @see \WpOrg\Requests\Ipv6::uncompress() + * + * @param string $ip An IPv6 address + * @return string The compressed IPv6 address + */ + public static function compress($ip) { + // Prepare the IP to be compressed. + // Note: Input validation is handled in the `uncompress()` method, which is the first call made in this method. + $ip = self::uncompress($ip); + $ip_parts = self::split_v6_v4($ip); + + // Replace all leading zeros + $ip_parts[0] = preg_replace('/(^|:)0+([0-9])/', '\1\2', $ip_parts[0]); + + // Find bunches of zeros + if (preg_match_all('/(?:^|:)(?:0(?::|$))+/', $ip_parts[0], $matches, PREG_OFFSET_CAPTURE)) { + $max = 0; + $pos = null; + foreach ($matches[0] as $match) { + if (strlen($match[0]) > $max) { + $max = strlen($match[0]); + $pos = $match[1]; + } + } + + $ip_parts[0] = substr_replace($ip_parts[0], '::', $pos, $max); + } + + if ($ip_parts[1] !== '') { + return implode(':', $ip_parts); + } else { + return $ip_parts[0]; + } + } + + /** + * Splits an IPv6 address into the IPv6 and IPv4 representation parts + * + * RFC 4291 allows you to represent the last two parts of an IPv6 address + * using the standard IPv4 representation + * + * Example: 0:0:0:0:0:0:13.1.68.3 + * 0:0:0:0:0:FFFF:129.144.52.38 + * + * @param string $ip An IPv6 address + * @return string[] [0] contains the IPv6 represented part, and [1] the IPv4 represented part + */ + private static function split_v6_v4($ip) { + if (strpos($ip, '.') !== false) { + $pos = strrpos($ip, ':'); + $ipv6_part = substr($ip, 0, $pos); + $ipv4_part = substr($ip, $pos + 1); + return [$ipv6_part, $ipv4_part]; + } else { + return [$ip, '']; + } + } + + /** + * Checks an IPv6 address + * + * Checks if the given IP is a valid IPv6 address + * + * @param string $ip An IPv6 address + * @return bool true if $ip is a valid IPv6 address + */ + public static function check_ipv6($ip) { + // Note: Input validation is handled in the `uncompress()` method, which is the first call made in this method. + $ip = self::uncompress($ip); + list($ipv6, $ipv4) = self::split_v6_v4($ip); + $ipv6 = explode(':', $ipv6); + $ipv4 = explode('.', $ipv4); + if (count($ipv6) === 8 && count($ipv4) === 1 || count($ipv6) === 6 && count($ipv4) === 4) { + foreach ($ipv6 as $ipv6_part) { + // The section can't be empty + if ($ipv6_part === '') { + return false; + } + + // Nor can it be over four characters + if (strlen($ipv6_part) > 4) { + return false; + } + + // Remove leading zeros (this is safe because of the above) + $ipv6_part = ltrim($ipv6_part, '0'); + if ($ipv6_part === '') { + $ipv6_part = '0'; + } + + // Check the value is valid + $value = hexdec($ipv6_part); + if (dechex($value) !== strtolower($ipv6_part) || $value < 0 || $value > 0xFFFF) { + return false; + } + } + + if (count($ipv4) === 4) { + foreach ($ipv4 as $ipv4_part) { + $value = (int) $ipv4_part; + if ((string) $value !== $ipv4_part || $value < 0 || $value > 0xFF) { + return false; + } + } + } + + return true; + } else { + return false; + } + } +} diff --git a/wp-includes/Requests/src/Iri.php b/wp-includes/Requests/src/Iri.php new file mode 100644 index 0000000..41ea7a8 --- /dev/null +++ b/wp-includes/Requests/src/Iri.php @@ -0,0 +1,1116 @@ +<?php +/** + * IRI parser/serialiser/normaliser + * + * @package Requests\Utilities + */ + +namespace WpOrg\Requests; + +use WpOrg\Requests\Exception; +use WpOrg\Requests\Exception\InvalidArgument; +use WpOrg\Requests\Ipv6; +use WpOrg\Requests\Port; +use WpOrg\Requests\Utility\InputValidator; + +/** + * IRI parser/serialiser/normaliser + * + * Copyright (c) 2007-2010, Geoffrey Sneddon and Steve Minutillo. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of the SimplePie Team nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * @package Requests\Utilities + * @author Geoffrey Sneddon + * @author Steve Minutillo + * @copyright 2007-2009 Geoffrey Sneddon and Steve Minutillo + * @license https://opensource.org/licenses/bsd-license.php + * @link http://hg.gsnedders.com/iri/ + * + * @property string $iri IRI we're working with + * @property-read string $uri IRI in URI form, {@see \WpOrg\Requests\Iri::to_uri()} + * @property string $scheme Scheme part of the IRI + * @property string $authority Authority part, formatted for a URI (userinfo + host + port) + * @property string $iauthority Authority part of the IRI (userinfo + host + port) + * @property string $userinfo Userinfo part, formatted for a URI (after '://' and before '@') + * @property string $iuserinfo Userinfo part of the IRI (after '://' and before '@') + * @property string $host Host part, formatted for a URI + * @property string $ihost Host part of the IRI + * @property string $port Port part of the IRI (after ':') + * @property string $path Path part, formatted for a URI (after first '/') + * @property string $ipath Path part of the IRI (after first '/') + * @property string $query Query part, formatted for a URI (after '?') + * @property string $iquery Query part of the IRI (after '?') + * @property string $fragment Fragment, formatted for a URI (after '#') + * @property string $ifragment Fragment part of the IRI (after '#') + */ +class Iri { + /** + * Scheme + * + * @var string|null + */ + protected $scheme = null; + + /** + * User Information + * + * @var string|null + */ + protected $iuserinfo = null; + + /** + * ihost + * + * @var string|null + */ + protected $ihost = null; + + /** + * Port + * + * @var string|null + */ + protected $port = null; + + /** + * ipath + * + * @var string + */ + protected $ipath = ''; + + /** + * iquery + * + * @var string|null + */ + protected $iquery = null; + + /** + * ifragment|null + * + * @var string + */ + protected $ifragment = null; + + /** + * Normalization database + * + * Each key is the scheme, each value is an array with each key as the IRI + * part and value as the default value for that part. + * + * @var array + */ + protected $normalization = array( + 'acap' => array( + 'port' => Port::ACAP, + ), + 'dict' => array( + 'port' => Port::DICT, + ), + 'file' => array( + 'ihost' => 'localhost', + ), + 'http' => array( + 'port' => Port::HTTP, + ), + 'https' => array( + 'port' => Port::HTTPS, + ), + ); + + /** + * Return the entire IRI when you try and read the object as a string + * + * @return string + */ + public function __toString() { + return $this->get_iri(); + } + + /** + * Overload __set() to provide access via properties + * + * @param string $name Property name + * @param mixed $value Property value + */ + public function __set($name, $value) { + if (method_exists($this, 'set_' . $name)) { + call_user_func(array($this, 'set_' . $name), $value); + } + elseif ( + $name === 'iauthority' + || $name === 'iuserinfo' + || $name === 'ihost' + || $name === 'ipath' + || $name === 'iquery' + || $name === 'ifragment' + ) { + call_user_func(array($this, 'set_' . substr($name, 1)), $value); + } + } + + /** + * Overload __get() to provide access via properties + * + * @param string $name Property name + * @return mixed + */ + public function __get($name) { + // isset() returns false for null, we don't want to do that + // Also why we use array_key_exists below instead of isset() + $props = get_object_vars($this); + + if ( + $name === 'iri' || + $name === 'uri' || + $name === 'iauthority' || + $name === 'authority' + ) { + $method = 'get_' . $name; + $return = $this->$method(); + } + elseif (array_key_exists($name, $props)) { + $return = $this->$name; + } + // host -> ihost + elseif (($prop = 'i' . $name) && array_key_exists($prop, $props)) { + $name = $prop; + $return = $this->$prop; + } + // ischeme -> scheme + elseif (($prop = substr($name, 1)) && array_key_exists($prop, $props)) { + $name = $prop; + $return = $this->$prop; + } + else { + trigger_error('Undefined property: ' . get_class($this) . '::' . $name, E_USER_NOTICE); + $return = null; + } + + if ($return === null && isset($this->normalization[$this->scheme][$name])) { + return $this->normalization[$this->scheme][$name]; + } + else { + return $return; + } + } + + /** + * Overload __isset() to provide access via properties + * + * @param string $name Property name + * @return bool + */ + public function __isset($name) { + return (method_exists($this, 'get_' . $name) || isset($this->$name)); + } + + /** + * Overload __unset() to provide access via properties + * + * @param string $name Property name + */ + public function __unset($name) { + if (method_exists($this, 'set_' . $name)) { + call_user_func(array($this, 'set_' . $name), ''); + } + } + + /** + * Create a new IRI object, from a specified string + * + * @param string|Stringable|null $iri + * + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $iri argument is not a string, Stringable or null. + */ + public function __construct($iri = null) { + if ($iri !== null && InputValidator::is_string_or_stringable($iri) === false) { + throw InvalidArgument::create(1, '$iri', 'string|Stringable|null', gettype($iri)); + } + + $this->set_iri($iri); + } + + /** + * Create a new IRI object by resolving a relative IRI + * + * Returns false if $base is not absolute, otherwise an IRI. + * + * @param \WpOrg\Requests\Iri|string $base (Absolute) Base IRI + * @param \WpOrg\Requests\Iri|string $relative Relative IRI + * @return \WpOrg\Requests\Iri|false + */ + public static function absolutize($base, $relative) { + if (!($relative instanceof self)) { + $relative = new self($relative); + } + if (!$relative->is_valid()) { + return false; + } + elseif ($relative->scheme !== null) { + return clone $relative; + } + + if (!($base instanceof self)) { + $base = new self($base); + } + if ($base->scheme === null || !$base->is_valid()) { + return false; + } + + if ($relative->get_iri() !== '') { + if ($relative->iuserinfo !== null || $relative->ihost !== null || $relative->port !== null) { + $target = clone $relative; + $target->scheme = $base->scheme; + } + else { + $target = new self; + $target->scheme = $base->scheme; + $target->iuserinfo = $base->iuserinfo; + $target->ihost = $base->ihost; + $target->port = $base->port; + if ($relative->ipath !== '') { + if ($relative->ipath[0] === '/') { + $target->ipath = $relative->ipath; + } + elseif (($base->iuserinfo !== null || $base->ihost !== null || $base->port !== null) && $base->ipath === '') { + $target->ipath = '/' . $relative->ipath; + } + elseif (($last_segment = strrpos($base->ipath, '/')) !== false) { + $target->ipath = substr($base->ipath, 0, $last_segment + 1) . $relative->ipath; + } + else { + $target->ipath = $relative->ipath; + } + $target->ipath = $target->remove_dot_segments($target->ipath); + $target->iquery = $relative->iquery; + } + else { + $target->ipath = $base->ipath; + if ($relative->iquery !== null) { + $target->iquery = $relative->iquery; + } + elseif ($base->iquery !== null) { + $target->iquery = $base->iquery; + } + } + $target->ifragment = $relative->ifragment; + } + } + else { + $target = clone $base; + $target->ifragment = null; + } + $target->scheme_normalization(); + return $target; + } + + /** + * Parse an IRI into scheme/authority/path/query/fragment segments + * + * @param string $iri + * @return array + */ + protected function parse_iri($iri) { + $iri = trim($iri, "\x20\x09\x0A\x0C\x0D"); + $has_match = preg_match('/^((?P<scheme>[^:\/?#]+):)?(\/\/(?P<authority>[^\/?#]*))?(?P<path>[^?#]*)(\?(?P<query>[^#]*))?(#(?P<fragment>.*))?$/', $iri, $match); + if (!$has_match) { + throw new Exception('Cannot parse supplied IRI', 'iri.cannot_parse', $iri); + } + + if ($match[1] === '') { + $match['scheme'] = null; + } + if (!isset($match[3]) || $match[3] === '') { + $match['authority'] = null; + } + if (!isset($match[5])) { + $match['path'] = ''; + } + if (!isset($match[6]) || $match[6] === '') { + $match['query'] = null; + } + if (!isset($match[8]) || $match[8] === '') { + $match['fragment'] = null; + } + return $match; + } + + /** + * Remove dot segments from a path + * + * @param string $input + * @return string + */ + protected function remove_dot_segments($input) { + $output = ''; + while (strpos($input, './') !== false || strpos($input, '/.') !== false || $input === '.' || $input === '..') { + // A: If the input buffer begins with a prefix of "../" or "./", + // then remove that prefix from the input buffer; otherwise, + if (strpos($input, '../') === 0) { + $input = substr($input, 3); + } + elseif (strpos($input, './') === 0) { + $input = substr($input, 2); + } + // B: if the input buffer begins with a prefix of "/./" or "/.", + // where "." is a complete path segment, then replace that prefix + // with "/" in the input buffer; otherwise, + elseif (strpos($input, '/./') === 0) { + $input = substr($input, 2); + } + elseif ($input === '/.') { + $input = '/'; + } + // C: if the input buffer begins with a prefix of "/../" or "/..", + // where ".." is a complete path segment, then replace that prefix + // with "/" in the input buffer and remove the last segment and its + // preceding "/" (if any) from the output buffer; otherwise, + elseif (strpos($input, '/../') === 0) { + $input = substr($input, 3); + $output = substr_replace($output, '', (strrpos($output, '/') ?: 0)); + } + elseif ($input === '/..') { + $input = '/'; + $output = substr_replace($output, '', (strrpos($output, '/') ?: 0)); + } + // D: if the input buffer consists only of "." or "..", then remove + // that from the input buffer; otherwise, + elseif ($input === '.' || $input === '..') { + $input = ''; + } + // E: move the first path segment in the input buffer to the end of + // the output buffer, including the initial "/" character (if any) + // and any subsequent characters up to, but not including, the next + // "/" character or the end of the input buffer + elseif (($pos = strpos($input, '/', 1)) !== false) { + $output .= substr($input, 0, $pos); + $input = substr_replace($input, '', 0, $pos); + } + else { + $output .= $input; + $input = ''; + } + } + return $output . $input; + } + + /** + * Replace invalid character with percent encoding + * + * @param string $text Input string + * @param string $extra_chars Valid characters not in iunreserved or + * iprivate (this is ASCII-only) + * @param bool $iprivate Allow iprivate + * @return string + */ + protected function replace_invalid_with_pct_encoding($text, $extra_chars, $iprivate = false) { + // Normalize as many pct-encoded sections as possible + $text = preg_replace_callback('/(?:%[A-Fa-f0-9]{2})+/', array($this, 'remove_iunreserved_percent_encoded'), $text); + + // Replace invalid percent characters + $text = preg_replace('/%(?![A-Fa-f0-9]{2})/', '%25', $text); + + // Add unreserved and % to $extra_chars (the latter is safe because all + // pct-encoded sections are now valid). + $extra_chars .= 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~%'; + + // Now replace any bytes that aren't allowed with their pct-encoded versions + $position = 0; + $strlen = strlen($text); + while (($position += strspn($text, $extra_chars, $position)) < $strlen) { + $value = ord($text[$position]); + + // Start position + $start = $position; + + // By default we are valid + $valid = true; + + // No one byte sequences are valid due to the while. + // Two byte sequence: + if (($value & 0xE0) === 0xC0) { + $character = ($value & 0x1F) << 6; + $length = 2; + $remaining = 1; + } + // Three byte sequence: + elseif (($value & 0xF0) === 0xE0) { + $character = ($value & 0x0F) << 12; + $length = 3; + $remaining = 2; + } + // Four byte sequence: + elseif (($value & 0xF8) === 0xF0) { + $character = ($value & 0x07) << 18; + $length = 4; + $remaining = 3; + } + // Invalid byte: + else { + $valid = false; + $length = 1; + $remaining = 0; + } + + if ($remaining) { + if ($position + $length <= $strlen) { + for ($position++; $remaining; $position++) { + $value = ord($text[$position]); + + // Check that the byte is valid, then add it to the character: + if (($value & 0xC0) === 0x80) { + $character |= ($value & 0x3F) << (--$remaining * 6); + } + // If it is invalid, count the sequence as invalid and reprocess the current byte: + else { + $valid = false; + $position--; + break; + } + } + } + else { + $position = $strlen - 1; + $valid = false; + } + } + + // Percent encode anything invalid or not in ucschar + if ( + // Invalid sequences + !$valid + // Non-shortest form sequences are invalid + || $length > 1 && $character <= 0x7F + || $length > 2 && $character <= 0x7FF + || $length > 3 && $character <= 0xFFFF + // Outside of range of ucschar codepoints + // Noncharacters + || ($character & 0xFFFE) === 0xFFFE + || $character >= 0xFDD0 && $character <= 0xFDEF + || ( + // Everything else not in ucschar + $character > 0xD7FF && $character < 0xF900 + || $character < 0xA0 + || $character > 0xEFFFD + ) + && ( + // Everything not in iprivate, if it applies + !$iprivate + || $character < 0xE000 + || $character > 0x10FFFD + ) + ) { + // If we were a character, pretend we weren't, but rather an error. + if ($valid) { + $position--; + } + + for ($j = $start; $j <= $position; $j++) { + $text = substr_replace($text, sprintf('%%%02X', ord($text[$j])), $j, 1); + $j += 2; + $position += 2; + $strlen += 2; + } + } + } + + return $text; + } + + /** + * Callback function for preg_replace_callback. + * + * Removes sequences of percent encoded bytes that represent UTF-8 + * encoded characters in iunreserved + * + * @param array $regex_match PCRE match + * @return string Replacement + */ + protected function remove_iunreserved_percent_encoded($regex_match) { + // As we just have valid percent encoded sequences we can just explode + // and ignore the first member of the returned array (an empty string). + $bytes = explode('%', $regex_match[0]); + + // Initialize the new string (this is what will be returned) and that + // there are no bytes remaining in the current sequence (unsurprising + // at the first byte!). + $string = ''; + $remaining = 0; + + // Loop over each and every byte, and set $value to its value + for ($i = 1, $len = count($bytes); $i < $len; $i++) { + $value = hexdec($bytes[$i]); + + // If we're the first byte of sequence: + if (!$remaining) { + // Start position + $start = $i; + + // By default we are valid + $valid = true; + + // One byte sequence: + if ($value <= 0x7F) { + $character = $value; + $length = 1; + } + // Two byte sequence: + elseif (($value & 0xE0) === 0xC0) { + $character = ($value & 0x1F) << 6; + $length = 2; + $remaining = 1; + } + // Three byte sequence: + elseif (($value & 0xF0) === 0xE0) { + $character = ($value & 0x0F) << 12; + $length = 3; + $remaining = 2; + } + // Four byte sequence: + elseif (($value & 0xF8) === 0xF0) { + $character = ($value & 0x07) << 18; + $length = 4; + $remaining = 3; + } + // Invalid byte: + else { + $valid = false; + $remaining = 0; + } + } + // Continuation byte: + else { + // Check that the byte is valid, then add it to the character: + if (($value & 0xC0) === 0x80) { + $remaining--; + $character |= ($value & 0x3F) << ($remaining * 6); + } + // If it is invalid, count the sequence as invalid and reprocess the current byte as the start of a sequence: + else { + $valid = false; + $remaining = 0; + $i--; + } + } + + // If we've reached the end of the current byte sequence, append it to Unicode::$data + if (!$remaining) { + // Percent encode anything invalid or not in iunreserved + if ( + // Invalid sequences + !$valid + // Non-shortest form sequences are invalid + || $length > 1 && $character <= 0x7F + || $length > 2 && $character <= 0x7FF + || $length > 3 && $character <= 0xFFFF + // Outside of range of iunreserved codepoints + || $character < 0x2D + || $character > 0xEFFFD + // Noncharacters + || ($character & 0xFFFE) === 0xFFFE + || $character >= 0xFDD0 && $character <= 0xFDEF + // Everything else not in iunreserved (this is all BMP) + || $character === 0x2F + || $character > 0x39 && $character < 0x41 + || $character > 0x5A && $character < 0x61 + || $character > 0x7A && $character < 0x7E + || $character > 0x7E && $character < 0xA0 + || $character > 0xD7FF && $character < 0xF900 + ) { + for ($j = $start; $j <= $i; $j++) { + $string .= '%' . strtoupper($bytes[$j]); + } + } + else { + for ($j = $start; $j <= $i; $j++) { + $string .= chr(hexdec($bytes[$j])); + } + } + } + } + + // If we have any bytes left over they are invalid (i.e., we are + // mid-way through a multi-byte sequence) + if ($remaining) { + for ($j = $start; $j < $len; $j++) { + $string .= '%' . strtoupper($bytes[$j]); + } + } + + return $string; + } + + protected function scheme_normalization() { + if (isset($this->normalization[$this->scheme]['iuserinfo']) && $this->iuserinfo === $this->normalization[$this->scheme]['iuserinfo']) { + $this->iuserinfo = null; + } + if (isset($this->normalization[$this->scheme]['ihost']) && $this->ihost === $this->normalization[$this->scheme]['ihost']) { + $this->ihost = null; + } + if (isset($this->normalization[$this->scheme]['port']) && $this->port === $this->normalization[$this->scheme]['port']) { + $this->port = null; + } + if (isset($this->normalization[$this->scheme]['ipath']) && $this->ipath === $this->normalization[$this->scheme]['ipath']) { + $this->ipath = ''; + } + if (isset($this->ihost) && empty($this->ipath)) { + $this->ipath = '/'; + } + if (isset($this->normalization[$this->scheme]['iquery']) && $this->iquery === $this->normalization[$this->scheme]['iquery']) { + $this->iquery = null; + } + if (isset($this->normalization[$this->scheme]['ifragment']) && $this->ifragment === $this->normalization[$this->scheme]['ifragment']) { + $this->ifragment = null; + } + } + + /** + * Check if the object represents a valid IRI. This needs to be done on each + * call as some things change depending on another part of the IRI. + * + * @return bool + */ + public function is_valid() { + $isauthority = $this->iuserinfo !== null || $this->ihost !== null || $this->port !== null; + if ($this->ipath !== '' && + ( + $isauthority && $this->ipath[0] !== '/' || + ( + $this->scheme === null && + !$isauthority && + strpos($this->ipath, ':') !== false && + (strpos($this->ipath, '/') === false ? true : strpos($this->ipath, ':') < strpos($this->ipath, '/')) + ) + ) + ) { + return false; + } + + return true; + } + + public function __wakeup() { + $class_props = get_class_vars( __CLASS__ ); + $string_props = array( 'scheme', 'iuserinfo', 'ihost', 'port', 'ipath', 'iquery', 'ifragment' ); + $array_props = array( 'normalization' ); + foreach ( $class_props as $prop => $default_value ) { + if ( in_array( $prop, $string_props, true ) && ! is_string( $this->$prop ) ) { + throw new UnexpectedValueException(); + } elseif ( in_array( $prop, $array_props, true ) && ! is_array( $this->$prop ) ) { + throw new UnexpectedValueException(); + } + $this->$prop = null; + } + } + + /** + * Set the entire IRI. Returns true on success, false on failure (if there + * are any invalid characters). + * + * @param string $iri + * @return bool + */ + protected function set_iri($iri) { + static $cache; + if (!$cache) { + $cache = array(); + } + + if ($iri === null) { + return true; + } + + $iri = (string) $iri; + + if (isset($cache[$iri])) { + list($this->scheme, + $this->iuserinfo, + $this->ihost, + $this->port, + $this->ipath, + $this->iquery, + $this->ifragment, + $return) = $cache[$iri]; + return $return; + } + + $parsed = $this->parse_iri($iri); + + $return = $this->set_scheme($parsed['scheme']) + && $this->set_authority($parsed['authority']) + && $this->set_path($parsed['path']) + && $this->set_query($parsed['query']) + && $this->set_fragment($parsed['fragment']); + + $cache[$iri] = array($this->scheme, + $this->iuserinfo, + $this->ihost, + $this->port, + $this->ipath, + $this->iquery, + $this->ifragment, + $return); + return $return; + } + + /** + * Set the scheme. Returns true on success, false on failure (if there are + * any invalid characters). + * + * @param string $scheme + * @return bool + */ + protected function set_scheme($scheme) { + if ($scheme === null) { + $this->scheme = null; + } + elseif (!preg_match('/^[A-Za-z][0-9A-Za-z+\-.]*$/', $scheme)) { + $this->scheme = null; + return false; + } + else { + $this->scheme = strtolower($scheme); + } + return true; + } + + /** + * Set the authority. Returns true on success, false on failure (if there are + * any invalid characters). + * + * @param string $authority + * @return bool + */ + protected function set_authority($authority) { + static $cache; + if (!$cache) { + $cache = array(); + } + + if ($authority === null) { + $this->iuserinfo = null; + $this->ihost = null; + $this->port = null; + return true; + } + if (isset($cache[$authority])) { + list($this->iuserinfo, + $this->ihost, + $this->port, + $return) = $cache[$authority]; + + return $return; + } + + $remaining = $authority; + if (($iuserinfo_end = strrpos($remaining, '@')) !== false) { + $iuserinfo = substr($remaining, 0, $iuserinfo_end); + $remaining = substr($remaining, $iuserinfo_end + 1); + } + else { + $iuserinfo = null; + } + + if (($port_start = strpos($remaining, ':', (strpos($remaining, ']') ?: 0))) !== false) { + $port = substr($remaining, $port_start + 1); + if ($port === false || $port === '') { + $port = null; + } + $remaining = substr($remaining, 0, $port_start); + } + else { + $port = null; + } + + $return = $this->set_userinfo($iuserinfo) && + $this->set_host($remaining) && + $this->set_port($port); + + $cache[$authority] = array($this->iuserinfo, + $this->ihost, + $this->port, + $return); + + return $return; + } + + /** + * Set the iuserinfo. + * + * @param string $iuserinfo + * @return bool + */ + protected function set_userinfo($iuserinfo) { + if ($iuserinfo === null) { + $this->iuserinfo = null; + } + else { + $this->iuserinfo = $this->replace_invalid_with_pct_encoding($iuserinfo, '!$&\'()*+,;=:'); + $this->scheme_normalization(); + } + + return true; + } + + /** + * Set the ihost. Returns true on success, false on failure (if there are + * any invalid characters). + * + * @param string $ihost + * @return bool + */ + protected function set_host($ihost) { + if ($ihost === null) { + $this->ihost = null; + return true; + } + if (substr($ihost, 0, 1) === '[' && substr($ihost, -1) === ']') { + if (Ipv6::check_ipv6(substr($ihost, 1, -1))) { + $this->ihost = '[' . Ipv6::compress(substr($ihost, 1, -1)) . ']'; + } + else { + $this->ihost = null; + return false; + } + } + else { + $ihost = $this->replace_invalid_with_pct_encoding($ihost, '!$&\'()*+,;='); + + // Lowercase, but ignore pct-encoded sections (as they should + // remain uppercase). This must be done after the previous step + // as that can add unescaped characters. + $position = 0; + $strlen = strlen($ihost); + while (($position += strcspn($ihost, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ%', $position)) < $strlen) { + if ($ihost[$position] === '%') { + $position += 3; + } + else { + $ihost[$position] = strtolower($ihost[$position]); + $position++; + } + } + + $this->ihost = $ihost; + } + + $this->scheme_normalization(); + + return true; + } + + /** + * Set the port. Returns true on success, false on failure (if there are + * any invalid characters). + * + * @param string $port + * @return bool + */ + protected function set_port($port) { + if ($port === null) { + $this->port = null; + return true; + } + + if (strspn($port, '0123456789') === strlen($port)) { + $this->port = (int) $port; + $this->scheme_normalization(); + return true; + } + + $this->port = null; + return false; + } + + /** + * Set the ipath. + * + * @param string $ipath + * @return bool + */ + protected function set_path($ipath) { + static $cache; + if (!$cache) { + $cache = array(); + } + + $ipath = (string) $ipath; + + if (isset($cache[$ipath])) { + $this->ipath = $cache[$ipath][(int) ($this->scheme !== null)]; + } + else { + $valid = $this->replace_invalid_with_pct_encoding($ipath, '!$&\'()*+,;=@:/'); + $removed = $this->remove_dot_segments($valid); + + $cache[$ipath] = array($valid, $removed); + $this->ipath = ($this->scheme !== null) ? $removed : $valid; + } + $this->scheme_normalization(); + return true; + } + + /** + * Set the iquery. + * + * @param string $iquery + * @return bool + */ + protected function set_query($iquery) { + if ($iquery === null) { + $this->iquery = null; + } + else { + $this->iquery = $this->replace_invalid_with_pct_encoding($iquery, '!$&\'()*+,;=:@/?', true); + $this->scheme_normalization(); + } + return true; + } + + /** + * Set the ifragment. + * + * @param string $ifragment + * @return bool + */ + protected function set_fragment($ifragment) { + if ($ifragment === null) { + $this->ifragment = null; + } + else { + $this->ifragment = $this->replace_invalid_with_pct_encoding($ifragment, '!$&\'()*+,;=:@/?'); + $this->scheme_normalization(); + } + return true; + } + + /** + * Convert an IRI to a URI (or parts thereof) + * + * @param string|bool $iri IRI to convert (or false from {@see \WpOrg\Requests\Iri::get_iri()}) + * @return string|false URI if IRI is valid, false otherwise. + */ + protected function to_uri($iri) { + if (!is_string($iri)) { + return false; + } + + static $non_ascii; + if (!$non_ascii) { + $non_ascii = implode('', range("\x80", "\xFF")); + } + + $position = 0; + $strlen = strlen($iri); + while (($position += strcspn($iri, $non_ascii, $position)) < $strlen) { + $iri = substr_replace($iri, sprintf('%%%02X', ord($iri[$position])), $position, 1); + $position += 3; + $strlen += 2; + } + + return $iri; + } + + /** + * Get the complete IRI + * + * @return string|false + */ + protected function get_iri() { + if (!$this->is_valid()) { + return false; + } + + $iri = ''; + if ($this->scheme !== null) { + $iri .= $this->scheme . ':'; + } + if (($iauthority = $this->get_iauthority()) !== null) { + $iri .= '//' . $iauthority; + } + $iri .= $this->ipath; + if ($this->iquery !== null) { + $iri .= '?' . $this->iquery; + } + if ($this->ifragment !== null) { + $iri .= '#' . $this->ifragment; + } + + return $iri; + } + + /** + * Get the complete URI + * + * @return string + */ + protected function get_uri() { + return $this->to_uri($this->get_iri()); + } + + /** + * Get the complete iauthority + * + * @return string|null + */ + protected function get_iauthority() { + if ($this->iuserinfo === null && $this->ihost === null && $this->port === null) { + return null; + } + + $iauthority = ''; + if ($this->iuserinfo !== null) { + $iauthority .= $this->iuserinfo . '@'; + } + if ($this->ihost !== null) { + $iauthority .= $this->ihost; + } + if ($this->port !== null) { + $iauthority .= ':' . $this->port; + } + return $iauthority; + } + + /** + * Get the complete authority + * + * @return string + */ + protected function get_authority() { + $iauthority = $this->get_iauthority(); + if (is_string($iauthority)) { + return $this->to_uri($iauthority); + } + else { + return $iauthority; + } + } +} diff --git a/wp-includes/Requests/src/Port.php b/wp-includes/Requests/src/Port.php new file mode 100644 index 0000000..5545409 --- /dev/null +++ b/wp-includes/Requests/src/Port.php @@ -0,0 +1,75 @@ +<?php +/** + * Port utilities for Requests + * + * @package Requests\Utilities + * @since 2.0.0 + */ + +namespace WpOrg\Requests; + +use WpOrg\Requests\Exception; +use WpOrg\Requests\Exception\InvalidArgument; + +/** + * Find the correct port depending on the Request type. + * + * @package Requests\Utilities + * @since 2.0.0 + */ +final class Port { + + /** + * Port to use with Acap requests. + * + * @var int + */ + const ACAP = 674; + + /** + * Port to use with Dictionary requests. + * + * @var int + */ + const DICT = 2628; + + /** + * Port to use with HTTP requests. + * + * @var int + */ + const HTTP = 80; + + /** + * Port to use with HTTP over SSL requests. + * + * @var int + */ + const HTTPS = 443; + + /** + * Retrieve the port number to use. + * + * @param string $type Request type. + * The following requests types are supported: + * 'acap', 'dict', 'http' and 'https'. + * + * @return int + * + * @throws \WpOrg\Requests\Exception\InvalidArgument When a non-string input has been passed. + * @throws \WpOrg\Requests\Exception When a non-supported port is requested ('portnotsupported'). + */ + public static function get($type) { + if (!is_string($type)) { + throw InvalidArgument::create(1, '$type', 'string', gettype($type)); + } + + $type = strtoupper($type); + if (!defined("self::{$type}")) { + $message = sprintf('Invalid port type (%s) passed', $type); + throw new Exception($message, 'portnotsupported'); + } + + return constant("self::{$type}"); + } +} diff --git a/wp-includes/Requests/src/Proxy.php b/wp-includes/Requests/src/Proxy.php new file mode 100644 index 0000000..18797a2 --- /dev/null +++ b/wp-includes/Requests/src/Proxy.php @@ -0,0 +1,38 @@ +<?php +/** + * Proxy connection interface + * + * @package Requests\Proxy + * @since 1.6 + */ + +namespace WpOrg\Requests; + +use WpOrg\Requests\Hooks; + +/** + * Proxy connection interface + * + * Implement this interface to handle proxy settings and authentication + * + * Parameters should be passed via the constructor where possible, as this + * makes it much easier for users to use your provider. + * + * @see \WpOrg\Requests\Hooks + * + * @package Requests\Proxy + * @since 1.6 + */ +interface Proxy { + /** + * Register hooks as needed + * + * This method is called in {@see \WpOrg\Requests\Requests::request()} when the user + * has set an instance as the 'auth' option. Use this callback to register all the + * hooks you'll need. + * + * @see \WpOrg\Requests\Hooks::register() + * @param \WpOrg\Requests\Hooks $hooks Hook system + */ + public function register(Hooks $hooks); +} diff --git a/wp-includes/Requests/src/Proxy/Http.php b/wp-includes/Requests/src/Proxy/Http.php new file mode 100644 index 0000000..e553c9c --- /dev/null +++ b/wp-includes/Requests/src/Proxy/Http.php @@ -0,0 +1,164 @@ +<?php +/** + * HTTP Proxy connection interface + * + * @package Requests\Proxy + * @since 1.6 + */ + +namespace WpOrg\Requests\Proxy; + +use WpOrg\Requests\Exception\ArgumentCount; +use WpOrg\Requests\Exception\InvalidArgument; +use WpOrg\Requests\Hooks; +use WpOrg\Requests\Proxy; + +/** + * HTTP Proxy connection interface + * + * Provides a handler for connection via an HTTP proxy + * + * @package Requests\Proxy + * @since 1.6 + */ +final class Http implements Proxy { + /** + * Proxy host and port + * + * Notation: "host:port" (eg 127.0.0.1:8080 or someproxy.com:3128) + * + * @var string + */ + public $proxy; + + /** + * Username + * + * @var string + */ + public $user; + + /** + * Password + * + * @var string + */ + public $pass; + + /** + * Do we need to authenticate? (ie username & password have been provided) + * + * @var boolean + */ + public $use_authentication; + + /** + * Constructor + * + * @since 1.6 + * + * @param array|string|null $args Proxy as a string or an array of proxy, user and password. + * When passed as an array, must have exactly one (proxy) + * or three elements (proxy, user, password). + * + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed argument is not an array, a string or null. + * @throws \WpOrg\Requests\Exception\ArgumentCount On incorrect number of arguments (`proxyhttpbadargs`) + */ + public function __construct($args = null) { + if (is_string($args)) { + $this->proxy = $args; + } elseif (is_array($args)) { + if (count($args) === 1) { + list($this->proxy) = $args; + } elseif (count($args) === 3) { + list($this->proxy, $this->user, $this->pass) = $args; + $this->use_authentication = true; + } else { + throw ArgumentCount::create( + 'an array with exactly one element or exactly three elements', + count($args), + 'proxyhttpbadargs' + ); + } + } elseif ($args !== null) { + throw InvalidArgument::create(1, '$args', 'array|string|null', gettype($args)); + } + } + + /** + * Register the necessary callbacks + * + * @since 1.6 + * @see \WpOrg\Requests\Proxy\Http::curl_before_send() + * @see \WpOrg\Requests\Proxy\Http::fsockopen_remote_socket() + * @see \WpOrg\Requests\Proxy\Http::fsockopen_remote_host_path() + * @see \WpOrg\Requests\Proxy\Http::fsockopen_header() + * @param \WpOrg\Requests\Hooks $hooks Hook system + */ + public function register(Hooks $hooks) { + $hooks->register('curl.before_send', [$this, 'curl_before_send']); + + $hooks->register('fsockopen.remote_socket', [$this, 'fsockopen_remote_socket']); + $hooks->register('fsockopen.remote_host_path', [$this, 'fsockopen_remote_host_path']); + if ($this->use_authentication) { + $hooks->register('fsockopen.after_headers', [$this, 'fsockopen_header']); + } + } + + /** + * Set cURL parameters before the data is sent + * + * @since 1.6 + * @param resource|\CurlHandle $handle cURL handle + */ + public function curl_before_send(&$handle) { + curl_setopt($handle, CURLOPT_PROXYTYPE, CURLPROXY_HTTP); + curl_setopt($handle, CURLOPT_PROXY, $this->proxy); + + if ($this->use_authentication) { + curl_setopt($handle, CURLOPT_PROXYAUTH, CURLAUTH_ANY); + curl_setopt($handle, CURLOPT_PROXYUSERPWD, $this->get_auth_string()); + } + } + + /** + * Alter remote socket information before opening socket connection + * + * @since 1.6 + * @param string $remote_socket Socket connection string + */ + public function fsockopen_remote_socket(&$remote_socket) { + $remote_socket = $this->proxy; + } + + /** + * Alter remote path before getting stream data + * + * @since 1.6 + * @param string $path Path to send in HTTP request string ("GET ...") + * @param string $url Full URL we're requesting + */ + public function fsockopen_remote_host_path(&$path, $url) { + $path = $url; + } + + /** + * Add extra headers to the request before sending + * + * @since 1.6 + * @param string $out HTTP header string + */ + public function fsockopen_header(&$out) { + $out .= sprintf("Proxy-Authorization: Basic %s\r\n", base64_encode($this->get_auth_string())); + } + + /** + * Get the authentication string (user:pass) + * + * @since 1.6 + * @return string + */ + public function get_auth_string() { + return $this->user . ':' . $this->pass; + } +} diff --git a/wp-includes/Requests/src/Requests.php b/wp-includes/Requests/src/Requests.php new file mode 100644 index 0000000..bb5292a --- /dev/null +++ b/wp-includes/Requests/src/Requests.php @@ -0,0 +1,1099 @@ +<?php +/** + * Requests for PHP + * + * Inspired by Requests for Python. + * + * Based on concepts from SimplePie_File, RequestCore and WP_Http. + * + * @package Requests + */ + +namespace WpOrg\Requests; + +use WpOrg\Requests\Auth\Basic; +use WpOrg\Requests\Capability; +use WpOrg\Requests\Cookie\Jar; +use WpOrg\Requests\Exception; +use WpOrg\Requests\Exception\InvalidArgument; +use WpOrg\Requests\Hooks; +use WpOrg\Requests\IdnaEncoder; +use WpOrg\Requests\Iri; +use WpOrg\Requests\Proxy\Http; +use WpOrg\Requests\Response; +use WpOrg\Requests\Transport\Curl; +use WpOrg\Requests\Transport\Fsockopen; +use WpOrg\Requests\Utility\InputValidator; + +/** + * Requests for PHP + * + * Inspired by Requests for Python. + * + * Based on concepts from SimplePie_File, RequestCore and WP_Http. + * + * @package Requests + */ +class Requests { + /** + * POST method + * + * @var string + */ + const POST = 'POST'; + + /** + * PUT method + * + * @var string + */ + const PUT = 'PUT'; + + /** + * GET method + * + * @var string + */ + const GET = 'GET'; + + /** + * HEAD method + * + * @var string + */ + const HEAD = 'HEAD'; + + /** + * DELETE method + * + * @var string + */ + const DELETE = 'DELETE'; + + /** + * OPTIONS method + * + * @var string + */ + const OPTIONS = 'OPTIONS'; + + /** + * TRACE method + * + * @var string + */ + const TRACE = 'TRACE'; + + /** + * PATCH method + * + * @link https://tools.ietf.org/html/rfc5789 + * @var string + */ + const PATCH = 'PATCH'; + + /** + * Default size of buffer size to read streams + * + * @var integer + */ + const BUFFER_SIZE = 1160; + + /** + * Option defaults. + * + * @see \WpOrg\Requests\Requests::get_default_options() + * @see \WpOrg\Requests\Requests::request() for values returned by this method + * + * @since 2.0.0 + * + * @var array + */ + const OPTION_DEFAULTS = [ + 'timeout' => 10, + 'connect_timeout' => 10, + 'useragent' => 'php-requests/' . self::VERSION, + 'protocol_version' => 1.1, + 'redirected' => 0, + 'redirects' => 10, + 'follow_redirects' => true, + 'blocking' => true, + 'type' => self::GET, + 'filename' => false, + 'auth' => false, + 'proxy' => false, + 'cookies' => false, + 'max_bytes' => false, + 'idn' => true, + 'hooks' => null, + 'transport' => null, + 'verify' => null, + 'verifyname' => true, + ]; + + /** + * Default supported Transport classes. + * + * @since 2.0.0 + * + * @var array + */ + const DEFAULT_TRANSPORTS = [ + Curl::class => Curl::class, + Fsockopen::class => Fsockopen::class, + ]; + + /** + * Current version of Requests + * + * @var string + */ + const VERSION = '2.0.9'; + + /** + * Selected transport name + * + * Use {@see \WpOrg\Requests\Requests::get_transport()} instead + * + * @var array + */ + public static $transport = []; + + /** + * Registered transport classes + * + * @var array + */ + protected static $transports = []; + + /** + * Default certificate path. + * + * @see \WpOrg\Requests\Requests::get_certificate_path() + * @see \WpOrg\Requests\Requests::set_certificate_path() + * + * @var string + */ + protected static $certificate_path = __DIR__ . '/../certificates/cacert.pem'; + + /** + * All (known) valid deflate, gzip header magic markers. + * + * These markers relate to different compression levels. + * + * @link https://stackoverflow.com/a/43170354/482864 Marker source. + * + * @since 2.0.0 + * + * @var array + */ + private static $magic_compression_headers = [ + "\x1f\x8b" => true, // Gzip marker. + "\x78\x01" => true, // Zlib marker - level 1. + "\x78\x5e" => true, // Zlib marker - level 2 to 5. + "\x78\x9c" => true, // Zlib marker - level 6. + "\x78\xda" => true, // Zlib marker - level 7 to 9. + ]; + + /** + * This is a static class, do not instantiate it + * + * @codeCoverageIgnore + */ + private function __construct() {} + + /** + * Register a transport + * + * @param string $transport Transport class to add, must support the \WpOrg\Requests\Transport interface + */ + public static function add_transport($transport) { + if (empty(self::$transports)) { + self::$transports = self::DEFAULT_TRANSPORTS; + } + + self::$transports[$transport] = $transport; + } + + /** + * Get the fully qualified class name (FQCN) for a working transport. + * + * @param array<string, bool> $capabilities Optional. Associative array of capabilities to test against, i.e. `['<capability>' => true]`. + * @return string FQCN of the transport to use, or an empty string if no transport was + * found which provided the requested capabilities. + */ + protected static function get_transport_class(array $capabilities = []) { + // Caching code, don't bother testing coverage. + // @codeCoverageIgnoreStart + // Array of capabilities as a string to be used as an array key. + ksort($capabilities); + $cap_string = serialize($capabilities); + + // Don't search for a transport if it's already been done for these $capabilities. + if (isset(self::$transport[$cap_string])) { + return self::$transport[$cap_string]; + } + + // Ensure we will not run this same check again later on. + self::$transport[$cap_string] = ''; + // @codeCoverageIgnoreEnd + + if (empty(self::$transports)) { + self::$transports = self::DEFAULT_TRANSPORTS; + } + + // Find us a working transport. + foreach (self::$transports as $class) { + if (!class_exists($class)) { + continue; + } + + $result = $class::test($capabilities); + if ($result === true) { + self::$transport[$cap_string] = $class; + break; + } + } + + return self::$transport[$cap_string]; + } + + /** + * Get a working transport. + * + * @param array<string, bool> $capabilities Optional. Associative array of capabilities to test against, i.e. `['<capability>' => true]`. + * @return \WpOrg\Requests\Transport + * @throws \WpOrg\Requests\Exception If no valid transport is found (`notransport`). + */ + protected static function get_transport(array $capabilities = []) { + $class = self::get_transport_class($capabilities); + + if ($class === '') { + throw new Exception('No working transports found', 'notransport', self::$transports); + } + + return new $class(); + } + + /** + * Checks to see if we have a transport for the capabilities requested. + * + * Supported capabilities can be found in the {@see \WpOrg\Requests\Capability} + * interface as constants. + * + * Example usage: + * `Requests::has_capabilities([Capability::SSL => true])`. + * + * @param array<string, bool> $capabilities Optional. Associative array of capabilities to test against, i.e. `['<capability>' => true]`. + * @return bool Whether the transport has the requested capabilities. + */ + public static function has_capabilities(array $capabilities = []) { + return self::get_transport_class($capabilities) !== ''; + } + + /**#@+ + * @see \WpOrg\Requests\Requests::request() + * @param string $url + * @param array $headers + * @param array $options + * @return \WpOrg\Requests\Response + */ + /** + * Send a GET request + */ + public static function get($url, $headers = [], $options = []) { + return self::request($url, $headers, null, self::GET, $options); + } + + /** + * Send a HEAD request + */ + public static function head($url, $headers = [], $options = []) { + return self::request($url, $headers, null, self::HEAD, $options); + } + + /** + * Send a DELETE request + */ + public static function delete($url, $headers = [], $options = []) { + return self::request($url, $headers, null, self::DELETE, $options); + } + + /** + * Send a TRACE request + */ + public static function trace($url, $headers = [], $options = []) { + return self::request($url, $headers, null, self::TRACE, $options); + } + /**#@-*/ + + /**#@+ + * @see \WpOrg\Requests\Requests::request() + * @param string $url + * @param array $headers + * @param array $data + * @param array $options + * @return \WpOrg\Requests\Response + */ + /** + * Send a POST request + */ + public static function post($url, $headers = [], $data = [], $options = []) { + return self::request($url, $headers, $data, self::POST, $options); + } + /** + * Send a PUT request + */ + public static function put($url, $headers = [], $data = [], $options = []) { + return self::request($url, $headers, $data, self::PUT, $options); + } + + /** + * Send an OPTIONS request + */ + public static function options($url, $headers = [], $data = [], $options = []) { + return self::request($url, $headers, $data, self::OPTIONS, $options); + } + + /** + * Send a PATCH request + * + * Note: Unlike {@see \WpOrg\Requests\Requests::post()} and {@see \WpOrg\Requests\Requests::put()}, + * `$headers` is required, as the specification recommends that should send an ETag + * + * @link https://tools.ietf.org/html/rfc5789 + */ + public static function patch($url, $headers, $data = [], $options = []) { + return self::request($url, $headers, $data, self::PATCH, $options); + } + /**#@-*/ + + /** + * Main interface for HTTP requests + * + * This method initiates a request and sends it via a transport before + * parsing. + * + * The `$options` parameter takes an associative array with the following + * options: + * + * - `timeout`: How long should we wait for a response? + * Note: for cURL, a minimum of 1 second applies, as DNS resolution + * operates at second-resolution only. + * (float, seconds with a millisecond precision, default: 10, example: 0.01) + * - `connect_timeout`: How long should we wait while trying to connect? + * (float, seconds with a millisecond precision, default: 10, example: 0.01) + * - `useragent`: Useragent to send to the server + * (string, default: php-requests/$version) + * - `follow_redirects`: Should we follow 3xx redirects? + * (boolean, default: true) + * - `redirects`: How many times should we redirect before erroring? + * (integer, default: 10) + * - `blocking`: Should we block processing on this request? + * (boolean, default: true) + * - `filename`: File to stream the body to instead. + * (string|boolean, default: false) + * - `auth`: Authentication handler or array of user/password details to use + * for Basic authentication + * (\WpOrg\Requests\Auth|array|boolean, default: false) + * - `proxy`: Proxy details to use for proxy by-passing and authentication + * (\WpOrg\Requests\Proxy|array|string|boolean, default: false) + * - `max_bytes`: Limit for the response body size. + * (integer|boolean, default: false) + * - `idn`: Enable IDN parsing + * (boolean, default: true) + * - `transport`: Custom transport. Either a class name, or a + * transport object. Defaults to the first working transport from + * {@see \WpOrg\Requests\Requests::getTransport()} + * (string|\WpOrg\Requests\Transport, default: {@see \WpOrg\Requests\Requests::getTransport()}) + * - `hooks`: Hooks handler. + * (\WpOrg\Requests\HookManager, default: new WpOrg\Requests\Hooks()) + * - `verify`: Should we verify SSL certificates? Allows passing in a custom + * 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: certificates/cacert.pem) + * - `verifyname`: Should we verify the common name in the SSL certificate? + * (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) + * + * @param string|Stringable $url URL to request + * @param array $headers Extra headers to send with the request + * @param array|null $data Data to send either as a query string for GET/HEAD requests, or in the body for POST requests + * @param string $type HTTP request type (use Requests constants) + * @param array $options Options for the request (see description for more information) + * @return \WpOrg\Requests\Response + * + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $url argument is not a string or Stringable. + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $type argument is not a string. + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $options argument is not an array. + * @throws \WpOrg\Requests\Exception On invalid URLs (`nonhttp`) + */ + public static function request($url, $headers = [], $data = [], $type = self::GET, $options = []) { + if (InputValidator::is_string_or_stringable($url) === false) { + throw InvalidArgument::create(1, '$url', 'string|Stringable', gettype($url)); + } + + if (is_string($type) === false) { + throw InvalidArgument::create(4, '$type', 'string', gettype($type)); + } + + if (is_array($options) === false) { + throw InvalidArgument::create(5, '$options', 'array', gettype($options)); + } + + if (empty($options['type'])) { + $options['type'] = $type; + } + + $options = array_merge(self::get_default_options(), $options); + + self::set_defaults($url, $headers, $data, $type, $options); + + $options['hooks']->dispatch('requests.before_request', [&$url, &$headers, &$data, &$type, &$options]); + + if (!empty($options['transport'])) { + $transport = $options['transport']; + + if (is_string($options['transport'])) { + $transport = new $transport(); + } + } else { + $need_ssl = (stripos($url, 'https://') === 0); + $capabilities = [Capability::SSL => $need_ssl]; + $transport = self::get_transport($capabilities); + } + + $response = $transport->request($url, $headers, $data, $options); + + $options['hooks']->dispatch('requests.before_parse', [&$response, $url, $headers, $data, $type, $options]); + + return self::parse_response($response, $url, $headers, $data, $options); + } + + /** + * Send multiple HTTP requests simultaneously + * + * The `$requests` parameter takes an associative or indexed array of + * request fields. The key of each request can be used to match up the + * request with the returned data, or with the request passed into your + * `multiple.request.complete` callback. + * + * The request fields value is an associative array with the following keys: + * + * - `url`: Request URL Same as the `$url` parameter to + * {@see \WpOrg\Requests\Requests::request()} + * (string, required) + * - `headers`: Associative array of header fields. Same as the `$headers` + * parameter to {@see \WpOrg\Requests\Requests::request()} + * (array, default: `array()`) + * - `data`: Associative array of data fields or a string. Same as the + * `$data` parameter to {@see \WpOrg\Requests\Requests::request()} + * (array|string, default: `array()`) + * - `type`: HTTP request type (use \WpOrg\Requests\Requests constants). Same as the `$type` + * parameter to {@see \WpOrg\Requests\Requests::request()} + * (string, default: `\WpOrg\Requests\Requests::GET`) + * - `cookies`: Associative array of cookie name to value, or cookie jar. + * (array|\WpOrg\Requests\Cookie\Jar) + * + * If the `$options` parameter is specified, individual requests will + * inherit options from it. This can be used to use a single hooking system, + * or set all the types to `\WpOrg\Requests\Requests::POST`, for example. + * + * In addition, the `$options` parameter takes the following global options: + * + * - `complete`: A callback for when a request is complete. Takes two + * parameters, a \WpOrg\Requests\Response/\WpOrg\Requests\Exception reference, and the + * ID from the request array (Note: this can also be overridden on a + * per-request basis, although that's a little silly) + * (callback) + * + * @param array $requests Requests data (see description for more information) + * @param array $options Global and default options (see {@see \WpOrg\Requests\Requests::request()}) + * @return array Responses (either \WpOrg\Requests\Response or a \WpOrg\Requests\Exception object) + * + * @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 static function request_multiple($requests, $options = []) { + 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)); + } + + $options = array_merge(self::get_default_options(true), $options); + + if (!empty($options['hooks'])) { + $options['hooks']->register('transport.internal.parse_response', [static::class, 'parse_multiple']); + if (!empty($options['complete'])) { + $options['hooks']->register('multiple.request.complete', $options['complete']); + } + } + + foreach ($requests as $id => &$request) { + if (!isset($request['headers'])) { + $request['headers'] = []; + } + + if (!isset($request['data'])) { + $request['data'] = []; + } + + if (!isset($request['type'])) { + $request['type'] = self::GET; + } + + if (!isset($request['options'])) { + $request['options'] = $options; + $request['options']['type'] = $request['type']; + } else { + if (empty($request['options']['type'])) { + $request['options']['type'] = $request['type']; + } + + $request['options'] = array_merge($options, $request['options']); + } + + self::set_defaults($request['url'], $request['headers'], $request['data'], $request['type'], $request['options']); + + // Ensure we only hook in once + if ($request['options']['hooks'] !== $options['hooks']) { + $request['options']['hooks']->register('transport.internal.parse_response', [static::class, 'parse_multiple']); + if (!empty($request['options']['complete'])) { + $request['options']['hooks']->register('multiple.request.complete', $request['options']['complete']); + } + } + } + + unset($request); + + if (!empty($options['transport'])) { + $transport = $options['transport']; + + if (is_string($options['transport'])) { + $transport = new $transport(); + } + } else { + $transport = self::get_transport(); + } + + $responses = $transport->request_multiple($requests, $options); + + foreach ($responses as $id => &$response) { + // If our hook got messed with somehow, ensure we end up with the + // correct response + if (is_string($response)) { + $request = $requests[$id]; + self::parse_multiple($response, $request); + $request['options']['hooks']->dispatch('multiple.request.complete', [&$response, $id]); + } + } + + return $responses; + } + + /** + * Get the default options + * + * @see \WpOrg\Requests\Requests::request() for values returned by this method + * @param boolean $multirequest Is this a multirequest? + * @return array Default option values + */ + protected static function get_default_options($multirequest = false) { + $defaults = static::OPTION_DEFAULTS; + $defaults['verify'] = self::$certificate_path; + + if ($multirequest !== false) { + $defaults['complete'] = null; + } + + return $defaults; + } + + /** + * Get default certificate path. + * + * @return string Default certificate path. + */ + public static function get_certificate_path() { + return self::$certificate_path; + } + + /** + * Set default certificate path. + * + * @param string|Stringable|bool $path Certificate path, pointing to a PEM file. + * + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $url argument is not a string, Stringable or boolean. + */ + public static function set_certificate_path($path) { + if (InputValidator::is_string_or_stringable($path) === false && is_bool($path) === false) { + throw InvalidArgument::create(1, '$path', 'string|Stringable|bool', gettype($path)); + } + + self::$certificate_path = $path; + } + + /** + * Set the default values + * + * The $options parameter is updated with the results. + * + * @param string $url URL to request + * @param array $headers Extra headers to send with the request + * @param array|null $data Data to send either as a query string for GET/HEAD requests, or in the body for POST requests + * @param string $type HTTP request type + * @param array $options Options for the request + * @return void + * + * @throws \WpOrg\Requests\Exception When the $url is not an http(s) URL. + */ + protected static function set_defaults(&$url, &$headers, &$data, &$type, &$options) { + if (!preg_match('/^http(s)?:\/\//i', $url, $matches)) { + throw new Exception('Only HTTP(S) requests are handled.', 'nonhttp', $url); + } + + if (empty($options['hooks'])) { + $options['hooks'] = new Hooks(); + } + + if (is_array($options['auth'])) { + $options['auth'] = new Basic($options['auth']); + } + + if ($options['auth'] !== false) { + $options['auth']->register($options['hooks']); + } + + if (is_string($options['proxy']) || is_array($options['proxy'])) { + $options['proxy'] = new Http($options['proxy']); + } + + if ($options['proxy'] !== false) { + $options['proxy']->register($options['hooks']); + } + + if (is_array($options['cookies'])) { + $options['cookies'] = new Jar($options['cookies']); + } elseif (empty($options['cookies'])) { + $options['cookies'] = new Jar(); + } + + if ($options['cookies'] !== false) { + $options['cookies']->register($options['hooks']); + } + + if ($options['idn'] !== false) { + $iri = new Iri($url); + $iri->host = IdnaEncoder::encode($iri->ihost); + $url = $iri->uri; + } + + // Massage the type to ensure we support it. + $type = strtoupper($type); + + if (!isset($options['data_format'])) { + if (in_array($type, [self::HEAD, self::GET, self::DELETE], true)) { + $options['data_format'] = 'query'; + } else { + $options['data_format'] = 'body'; + } + } + } + + /** + * HTTP response parser + * + * @param string $headers Full response text including headers and body + * @param string $url Original request URL + * @param array $req_headers Original $headers array passed to {@link request()}, in case we need to follow redirects + * @param array $req_data Original $data array passed to {@link request()}, in case we need to follow redirects + * @param array $options Original $options array passed to {@link request()}, in case we need to follow redirects + * @return \WpOrg\Requests\Response + * + * @throws \WpOrg\Requests\Exception On missing head/body separator (`requests.no_crlf_separator`) + * @throws \WpOrg\Requests\Exception On missing head/body separator (`noversion`) + * @throws \WpOrg\Requests\Exception On missing head/body separator (`toomanyredirects`) + */ + protected static function parse_response($headers, $url, $req_headers, $req_data, $options) { + $return = new Response(); + if (!$options['blocking']) { + return $return; + } + + $return->raw = $headers; + $return->url = (string) $url; + $return->body = ''; + + if (!$options['filename']) { + $pos = strpos($headers, "\r\n\r\n"); + if ($pos === false) { + // Crap! + throw new Exception('Missing header/body separator', 'requests.no_crlf_separator'); + } + + $headers = substr($return->raw, 0, $pos); + // Headers will always be separated from the body by two new lines - `\n\r\n\r`. + $body = substr($return->raw, $pos + 4); + if (!empty($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); + $headers = explode("\n", $headers); + preg_match('#^HTTP/(1\.\d)[ \t]+(\d+)#i', array_shift($headers), $matches); + if (empty($matches)) { + throw new Exception('Response could not be parsed', 'noversion', $headers); + } + + $return->protocol_version = (float) $matches[1]; + $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); + preg_replace('#(\s+)#i', ' ', $value); + $return->headers[$key] = $value; + } + + if (isset($return->headers['transfer-encoding'])) { + $return->body = self::decode_chunked($return->body); + unset($return->headers['transfer-encoding']); + } + + if (isset($return->headers['content-encoding'])) { + $return->body = self::decompress($return->body); + } + + //fsockopen and cURL compatibility + if (isset($return->headers['connection'])) { + unset($return->headers['connection']); + } + + $options['hooks']->dispatch('requests.before_redirect_check', [&$return, $req_headers, $req_data, $options]); + + if ($return->is_redirect() && $options['follow_redirects'] === true) { + if (isset($return->headers['location']) && $options['redirected'] < $options['redirects']) { + if ($return->status_code === 303) { + $options['type'] = self::GET; + } + + $options['redirected']++; + $location = $return->headers['location']; + if (strpos($location, 'http://') !== 0 && strpos($location, 'https://') !== 0) { + // relative redirect, for compatibility make it absolute + $location = Iri::absolutize($url, $location); + $location = $location->uri; + } + + $hook_args = [ + &$location, + &$req_headers, + &$req_data, + &$options, + $return, + ]; + $options['hooks']->dispatch('requests.before_redirect', $hook_args); + $redirected = self::request($location, $req_headers, $req_data, $options['type'], $options); + $redirected->history[] = $return; + return $redirected; + } elseif ($options['redirected'] >= $options['redirects']) { + throw new Exception('Too many redirects', 'toomanyredirects', $return); + } + } + + $return->redirects = $options['redirected']; + + $options['hooks']->dispatch('requests.after_request', [&$return, $req_headers, $req_data, $options]); + return $return; + } + + /** + * Callback for `transport.internal.parse_response` + * + * Internal use only. Converts a raw HTTP response to a \WpOrg\Requests\Response + * while still executing a multiple request. + * + * `$response` is either set to a \WpOrg\Requests\Response instance, or a \WpOrg\Requests\Exception object + * + * @param string $response Full response text including headers and body (will be overwritten with Response instance) + * @param array $request Request data as passed into {@see \WpOrg\Requests\Requests::request_multiple()} + * @return void + */ + public static function parse_multiple(&$response, $request) { + try { + $url = $request['url']; + $headers = $request['headers']; + $data = $request['data']; + $options = $request['options']; + $response = self::parse_response($response, $url, $headers, $data, $options); + } catch (Exception $e) { + $response = $e; + } + } + + /** + * Decoded a chunked body as per RFC 2616 + * + * @link https://tools.ietf.org/html/rfc2616#section-3.6.1 + * @param string $data Chunked body + * @return string Decoded body + */ + 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) { + $is_chunked = (bool) preg_match('/^([0-9a-f]+)(?:;(?:[\w-]*)(?:=(?:(?:[\w-]*)*|"(?:[^\r\n])*"))?)*\r\n/i', $encoded, $matches); + if (!$is_chunked) { + // Looks like it's not chunked after all + return $data; + } + + $length = hexdec(trim($matches[1])); + if ($length === 0) { + // Ignore trailer headers + return $decoded; + } + + $chunk_length = strlen($matches[0]); + $decoded .= substr($encoded, $chunk_length, $length); + $encoded = substr($encoded, $chunk_length + $length + 2); + + if (trim($encoded) === '0' || empty($encoded)) { + return $decoded; + } + } + + // We'll never actually get down here + // @codeCoverageIgnoreStart + } + // @codeCoverageIgnoreEnd + + /** + * Convert a key => value array to a 'key: value' array for headers + * + * @param iterable $dictionary Dictionary of header values + * @return array List of headers + * + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed argument is not iterable. + */ + public static function flatten($dictionary) { + if (InputValidator::is_iterable($dictionary) === false) { + throw InvalidArgument::create(1, '$dictionary', 'iterable', gettype($dictionary)); + } + + $return = []; + foreach ($dictionary as $key => $value) { + $return[] = sprintf('%s: %s', $key, $value); + } + + return $return; + } + + /** + * Decompress an encoded body + * + * Implements gzip, compress and deflate. Guesses which it is by attempting + * to decode. + * + * @param string $data Compressed data in one of the above formats + * @return string Decompressed string + * + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed argument is not a string. + */ + public static function decompress($data) { + if (is_string($data) === false) { + throw InvalidArgument::create(1, '$data', 'string', gettype($data)); + } + + if (trim($data) === '') { + // Empty body does not need further processing. + return $data; + } + + $marker = substr($data, 0, 2); + if (!isset(self::$magic_compression_headers[$marker])) { + // Not actually compressed. Probably cURL ruining this for us. + return $data; + } + + if (function_exists('gzdecode')) { + $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; + } + + if (function_exists('gzuncompress')) { + $decoded = @gzuncompress($data); + if ($decoded !== false) { + return $decoded; + } + } + + return $data; + } + + /** + * Decompression of deflated string while staying compatible with the majority of servers. + * + * Certain Servers will return deflated data with headers which PHP's gzinflate() + * function cannot handle out of the box. The following function has been created from + * various snippets on the gzinflate() PHP documentation. + * + * Warning: Magic numbers within. Due to the potential different formats that the compressed + * data may be returned in, some "magic offsets" are needed to ensure proper decompression + * takes place. For a simple progmatic way to determine the magic offset in use, see: + * https://core.trac.wordpress.org/ticket/18273 + * + * @since 1.6.0 + * @link https://core.trac.wordpress.org/ticket/18273 + * @link https://www.php.net/gzinflate#70875 + * @link https://www.php.net/gzinflate#77336 + * + * @param string $gz_data String to decompress. + * @return string|bool False on failure. + * + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed argument is not a string. + */ + public static function compatible_gzinflate($gz_data) { + if (is_string($gz_data) === false) { + throw InvalidArgument::create(1, '$gz_data', 'string', gettype($gz_data)); + } + + if (trim($gz_data) === '') { + return false; + } + + // Compressed data might contain a full zlib header, if so strip it for + // gzinflate() + if (substr($gz_data, 0, 3) === "\x1f\x8b\x08") { + $i = 10; + $flg = ord(substr($gz_data, 3, 1)); + if ($flg > 0) { + if ($flg & 4) { + list($xlen) = unpack('v', substr($gz_data, $i, 2)); + $i += 2 + $xlen; + } + + if ($flg & 8) { + $i = strpos($gz_data, "\0", $i) + 1; + } + + if ($flg & 16) { + $i = strpos($gz_data, "\0", $i) + 1; + } + + if ($flg & 2) { + $i += 2; + } + } + + $decompressed = self::compatible_gzinflate(substr($gz_data, $i)); + if ($decompressed !== false) { + return $decompressed; + } + } + + // If the data is Huffman Encoded, we must first strip the leading 2 + // byte Huffman marker for gzinflate() + // The response is Huffman coded by many compressors such as + // java.util.zip.Deflater, Ruby's Zlib::Deflate, and .NET's + // System.IO.Compression.DeflateStream. + // + // 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', $gz_data); + + // First 2 bytes should be divisible by 0x1F + list(, $first_two_bytes) = unpack('n', $gz_data); + + if ($first_nibble === 0x08 && ($first_two_bytes % 0x1F) === 0) { + $huffman_encoded = true; + } + + if ($huffman_encoded) { + $decompressed = @gzinflate(substr($gz_data, 2)); + if ($decompressed !== false) { + return $decompressed; + } + } + + 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($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 & $general_purpose_flag) === 0x08); + + if (!$zip_compressed_on_the_fly) { + // Don't attempt to decode a compressed zip file + return $gz_data; + } + + // Determine the first byte of data, based on the above ZIP header + // offsets: + $first_file_start = array_sum(unpack('v2', substr($gz_data, 26, 4))); + $decompressed = @gzinflate(substr($gz_data, 30 + $first_file_start)); + if ($decompressed !== false) { + return $decompressed; + } + + return false; + } + + // Finally fall back to straight gzinflate + $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 + $decompressed = @gzinflate(substr($gz_data, 2)); + if ($decompressed !== false) { + return $decompressed; + } + + return false; + } +} diff --git a/wp-includes/Requests/src/Response.php b/wp-includes/Requests/src/Response.php new file mode 100644 index 0000000..86a0438 --- /dev/null +++ b/wp-includes/Requests/src/Response.php @@ -0,0 +1,165 @@ +<?php +/** + * HTTP response class + * + * Contains a response from \WpOrg\Requests\Requests::request() + * + * @package Requests + */ + +namespace WpOrg\Requests; + +use WpOrg\Requests\Cookie\Jar; +use WpOrg\Requests\Exception; +use WpOrg\Requests\Exception\Http; +use WpOrg\Requests\Response\Headers; + +/** + * HTTP response class + * + * Contains a response from \WpOrg\Requests\Requests::request() + * + * @package Requests + */ +class Response { + + /** + * Response body + * + * @var string + */ + public $body = ''; + + /** + * Raw HTTP data from the transport + * + * @var string + */ + public $raw = ''; + + /** + * Headers, as an associative array + * + * @var \WpOrg\Requests\Response\Headers Array-like object representing headers + */ + public $headers = []; + + /** + * Status code, false if non-blocking + * + * @var integer|boolean + */ + public $status_code = false; + + /** + * Protocol version, false if non-blocking + * + * @var float|boolean + */ + public $protocol_version = false; + + /** + * Whether the request succeeded or not + * + * @var boolean + */ + public $success = false; + + /** + * Number of redirects the request used + * + * @var integer + */ + public $redirects = 0; + + /** + * URL requested + * + * @var string + */ + public $url = ''; + + /** + * Previous requests (from redirects) + * + * @var array Array of \WpOrg\Requests\Response objects + */ + public $history = []; + + /** + * Cookies from the request + * + * @var \WpOrg\Requests\Cookie\Jar Array-like object representing a cookie jar + */ + public $cookies = []; + + /** + * Constructor + */ + public function __construct() { + $this->headers = new Headers(); + $this->cookies = new Jar(); + } + + /** + * Is the response a redirect? + * + * @return boolean True if redirect (3xx status), false if not. + */ + public function is_redirect() { + $code = $this->status_code; + return in_array($code, [300, 301, 302, 303, 307], true) || $code > 307 && $code < 400; + } + + /** + * Throws an exception if the request was not successful + * + * @param boolean $allow_redirects Set to false to throw on a 3xx as well + * + * @throws \WpOrg\Requests\Exception If `$allow_redirects` is false, and code is 3xx (`response.no_redirects`) + * @throws \WpOrg\Requests\Exception\Http On non-successful status code. Exception class corresponds to "Status" + code (e.g. {@see \WpOrg\Requests\Exception\Http\Status404}) + */ + public function throw_for_status($allow_redirects = true) { + if ($this->is_redirect()) { + if ($allow_redirects !== true) { + throw new Exception('Redirection not allowed', 'response.no_redirects', $this); + } + } elseif (!$this->success) { + $exception = Http::get_class($this->status_code); + throw new $exception(null, $this); + } + } + + /** + * JSON decode the response body. + * + * The method parameters are the same as those for the PHP native `json_decode()` function. + * + * @link https://php.net/json-decode + * + * @param bool|null $associative Optional. When `true`, JSON objects will be returned as associative arrays; + * When `false`, JSON objects will be returned as objects. + * When `null`, JSON objects will be returned as associative arrays + * or objects depending on whether `JSON_OBJECT_AS_ARRAY` is set in the flags. + * Defaults to `true` (in contrast to the PHP native default of `null`). + * @param int $depth Optional. Maximum nesting depth of the structure being decoded. + * Defaults to `512`. + * @param int $options Optional. Bitmask of JSON_BIGINT_AS_STRING, JSON_INVALID_UTF8_IGNORE, + * JSON_INVALID_UTF8_SUBSTITUTE, JSON_OBJECT_AS_ARRAY, JSON_THROW_ON_ERROR. + * Defaults to `0` (no options set). + * + * @return array + * + * @throws \WpOrg\Requests\Exception If `$this->body` is not valid json. + */ + public function decode_body($associative = true, $depth = 512, $options = 0) { + $data = json_decode($this->body, $associative, $depth, $options); + + if (json_last_error() !== JSON_ERROR_NONE) { + $last_error = json_last_error_msg(); + throw new Exception('Unable to parse JSON data: ' . $last_error, 'response.invalid', $this); + } + + return $data; + } +} diff --git a/wp-includes/Requests/src/Response/Headers.php b/wp-includes/Requests/src/Response/Headers.php new file mode 100644 index 0000000..b4d0fcf --- /dev/null +++ b/wp-includes/Requests/src/Response/Headers.php @@ -0,0 +1,127 @@ +<?php +/** + * Case-insensitive dictionary, suitable for HTTP headers + * + * @package Requests + */ + +namespace WpOrg\Requests\Response; + +use WpOrg\Requests\Exception; +use WpOrg\Requests\Exception\InvalidArgument; +use WpOrg\Requests\Utility\CaseInsensitiveDictionary; +use WpOrg\Requests\Utility\FilteredIterator; + +/** + * Case-insensitive dictionary, suitable for HTTP headers + * + * @package Requests + */ +class Headers extends CaseInsensitiveDictionary { + /** + * Get the given header + * + * Unlike {@see \WpOrg\Requests\Response\Headers::getValues()}, this returns a string. If there are + * multiple values, it concatenates them with a comma as per RFC2616. + * + * Avoid using this where commas may be used unquoted in values, such as + * Set-Cookie headers. + * + * @param string $offset Name of the header to retrieve. + * @return string|null Header value + */ + public function offsetGet($offset) { + if (is_string($offset)) { + $offset = strtolower($offset); + } + + if (!isset($this->data[$offset])) { + return null; + } + + return $this->flatten($this->data[$offset]); + } + + /** + * Set the given item + * + * @param string $offset Item name + * @param string $value Item value + * + * @throws \WpOrg\Requests\Exception On attempting to use dictionary as list (`invalidset`) + */ + public function offsetSet($offset, $value) { + if ($offset === null) { + throw new Exception('Object is a dictionary, not a list', 'invalidset'); + } + + if (is_string($offset)) { + $offset = strtolower($offset); + } + + if (!isset($this->data[$offset])) { + $this->data[$offset] = []; + } + + $this->data[$offset][] = $value; + } + + /** + * Get all values for a given header + * + * @param string $offset Name of the header to retrieve. + * @return array|null Header values + * + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed argument is not valid as an array key. + */ + public function getValues($offset) { + if (!is_string($offset) && !is_int($offset)) { + throw InvalidArgument::create(1, '$offset', 'string|int', gettype($offset)); + } + + if (is_string($offset)) { + $offset = strtolower($offset); + } + + if (!isset($this->data[$offset])) { + return null; + } + + return $this->data[$offset]; + } + + /** + * Flattens a value into a string + * + * Converts an array into a string by imploding values with a comma, as per + * RFC2616's rules for folding headers. + * + * @param string|array $value Value to flatten + * @return string Flattened value + * + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed argument is not a string or an array. + */ + public function flatten($value) { + if (is_string($value)) { + return $value; + } + + if (is_array($value)) { + return implode(',', $value); + } + + throw InvalidArgument::create(1, '$value', 'string|array', gettype($value)); + } + + /** + * Get an iterator for the data + * + * Converts the internally stored values to a comma-separated string if there is more + * than one value for a key. + * + * @return \ArrayIterator + */ + public function getIterator() { + return new FilteredIterator($this->data, [$this, 'flatten']); + } +} diff --git a/wp-includes/Requests/src/Session.php b/wp-includes/Requests/src/Session.php new file mode 100644 index 0000000..0a63279 --- /dev/null +++ b/wp-includes/Requests/src/Session.php @@ -0,0 +1,308 @@ +<?php +/** + * Session handler for persistent requests and default parameters + * + * @package Requests\SessionHandler + */ + +namespace WpOrg\Requests; + +use WpOrg\Requests\Cookie\Jar; +use WpOrg\Requests\Exception\InvalidArgument; +use WpOrg\Requests\Iri; +use WpOrg\Requests\Requests; +use WpOrg\Requests\Utility\InputValidator; + +/** + * Session handler for persistent requests and default parameters + * + * Allows various options to be set as default values, and merges both the + * options and URL properties together. A base URL can be set for all requests, + * with all subrequests resolved from this. Base options can be set (including + * a shared cookie jar), then overridden for individual requests. + * + * @package Requests\SessionHandler + */ +class Session { + /** + * Base URL for requests + * + * URLs will be made absolute using this as the base + * + * @var string|null + */ + public $url = null; + + /** + * Base headers for requests + * + * @var array + */ + public $headers = []; + + /** + * Base data for requests + * + * If both the base data and the per-request data are arrays, the data will + * be merged before sending the request. + * + * @var array + */ + public $data = []; + + /** + * Base options for requests + * + * The base options are merged with the per-request data for each request. + * The only default option is a shared cookie jar between requests. + * + * Values here can also be set directly via properties on the Session + * object, e.g. `$session->useragent = 'X';` + * + * @var array + */ + public $options = []; + + /** + * Create a new session + * + * @param string|Stringable|null $url Base URL for requests + * @param array $headers Default headers for requests + * @param array $data Default data for requests + * @param array $options Default options for requests + * + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $url argument is not a string, Stringable or null. + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $headers argument is not an array. + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $data argument is not an array. + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $options argument is not an array. + */ + public function __construct($url = null, $headers = [], $data = [], $options = []) { + if ($url !== null && InputValidator::is_string_or_stringable($url) === false) { + throw InvalidArgument::create(1, '$url', 'string|Stringable|null', gettype($url)); + } + + if (is_array($headers) === false) { + throw InvalidArgument::create(2, '$headers', 'array', gettype($headers)); + } + + if (is_array($data) === false) { + throw InvalidArgument::create(3, '$data', 'array', gettype($data)); + } + + if (is_array($options) === false) { + throw InvalidArgument::create(4, '$options', 'array', gettype($options)); + } + + $this->url = $url; + $this->headers = $headers; + $this->data = $data; + $this->options = $options; + + if (empty($this->options['cookies'])) { + $this->options['cookies'] = new Jar(); + } + } + + /** + * Get a property's value + * + * @param string $name Property name. + * @return mixed|null Property value, null if none found + */ + public function __get($name) { + if (isset($this->options[$name])) { + return $this->options[$name]; + } + + return null; + } + + /** + * Set a property's value + * + * @param string $name Property name. + * @param mixed $value Property value + */ + public function __set($name, $value) { + $this->options[$name] = $value; + } + + /** + * Remove a property's value + * + * @param string $name Property name. + */ + public function __isset($name) { + return isset($this->options[$name]); + } + + /** + * Remove a property's value + * + * @param string $name Property name. + */ + public function __unset($name) { + unset($this->options[$name]); + } + + /**#@+ + * @see \WpOrg\Requests\Session::request() + * @param string $url + * @param array $headers + * @param array $options + * @return \WpOrg\Requests\Response + */ + /** + * Send a GET request + */ + public function get($url, $headers = [], $options = []) { + return $this->request($url, $headers, null, Requests::GET, $options); + } + + /** + * Send a HEAD request + */ + public function head($url, $headers = [], $options = []) { + return $this->request($url, $headers, null, Requests::HEAD, $options); + } + + /** + * Send a DELETE request + */ + public function delete($url, $headers = [], $options = []) { + return $this->request($url, $headers, null, Requests::DELETE, $options); + } + /**#@-*/ + + /**#@+ + * @see \WpOrg\Requests\Session::request() + * @param string $url + * @param array $headers + * @param array $data + * @param array $options + * @return \WpOrg\Requests\Response + */ + /** + * Send a POST request + */ + public function post($url, $headers = [], $data = [], $options = []) { + return $this->request($url, $headers, $data, Requests::POST, $options); + } + + /** + * Send a PUT request + */ + public function put($url, $headers = [], $data = [], $options = []) { + return $this->request($url, $headers, $data, Requests::PUT, $options); + } + + /** + * Send a PATCH request + * + * Note: Unlike {@see \WpOrg\Requests\Session::post()} and {@see \WpOrg\Requests\Session::put()}, + * `$headers` is required, as the specification recommends that should send an ETag + * + * @link https://tools.ietf.org/html/rfc5789 + */ + public function patch($url, $headers, $data = [], $options = []) { + return $this->request($url, $headers, $data, Requests::PATCH, $options); + } + /**#@-*/ + + /** + * Main interface for HTTP requests + * + * This method initiates a request and sends it via a transport before + * parsing. + * + * @see \WpOrg\Requests\Requests::request() + * + * @param string $url URL to request + * @param array $headers Extra headers to send with the request + * @param array|null $data Data to send either as a query string for GET/HEAD requests, or in the body for POST requests + * @param string $type HTTP request type (use \WpOrg\Requests\Requests constants) + * @param array $options Options for the request (see {@see \WpOrg\Requests\Requests::request()}) + * @return \WpOrg\Requests\Response + * + * @throws \WpOrg\Requests\Exception On invalid URLs (`nonhttp`) + */ + public function request($url, $headers = [], $data = [], $type = Requests::GET, $options = []) { + $request = $this->merge_request(compact('url', 'headers', 'data', 'options')); + + return Requests::request($request['url'], $request['headers'], $request['data'], $type, $request['options']); + } + + /** + * Send multiple HTTP requests simultaneously + * + * @see \WpOrg\Requests\Requests::request_multiple() + * + * @param array $requests Requests data (see {@see \WpOrg\Requests\Requests::request_multiple()}) + * @param array $options Global and default options (see {@see \WpOrg\Requests\Requests::request()}) + * @return array Responses (either \WpOrg\Requests\Response or a \WpOrg\Requests\Exception object) + * + * @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 = []) { + 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)); + } + + foreach ($requests as $key => $request) { + $requests[$key] = $this->merge_request($request, false); + } + + $options = array_merge($this->options, $options); + + // Disallow forcing the type, as that's a per request setting + unset($options['type']); + + return Requests::request_multiple($requests, $options); + } + + public function __wakeup() { + throw new \LogicException( __CLASS__ . ' should never be unserialized' ); + } + + /** + * Merge a request's data with the default data + * + * @param array $request Request data (same form as {@see \WpOrg\Requests\Session::request_multiple()}) + * @param boolean $merge_options Should we merge options as well? + * @return array Request data + */ + protected function merge_request($request, $merge_options = true) { + if ($this->url !== null) { + $request['url'] = Iri::absolutize($this->url, $request['url']); + $request['url'] = $request['url']->uri; + } + + if (empty($request['headers'])) { + $request['headers'] = []; + } + + $request['headers'] = array_merge($this->headers, $request['headers']); + + if (empty($request['data'])) { + if (is_array($this->data)) { + $request['data'] = $this->data; + } + } elseif (is_array($request['data']) && is_array($this->data)) { + $request['data'] = array_merge($this->data, $request['data']); + } + + if ($merge_options === true) { + $request['options'] = array_merge($this->options, $request['options']); + + // Disallow forcing the type, as that's a per request setting + unset($request['options']['type']); + } + + return $request; + } +} diff --git a/wp-includes/Requests/src/Ssl.php b/wp-includes/Requests/src/Ssl.php new file mode 100644 index 0000000..99da11d --- /dev/null +++ b/wp-includes/Requests/src/Ssl.php @@ -0,0 +1,182 @@ +<?php +/** + * SSL utilities for Requests + * + * @package Requests\Utilities + */ + +namespace WpOrg\Requests; + +use WpOrg\Requests\Exception\InvalidArgument; +use WpOrg\Requests\Utility\InputValidator; + +/** + * SSL utilities for Requests + * + * Collection of utilities for working with and verifying SSL certificates. + * + * @package Requests\Utilities + */ +final class Ssl { + /** + * Verify the certificate against common name and subject alternative names + * + * Unfortunately, PHP doesn't check the certificate against the alternative + * names, leading things like 'https://www.github.com/' to be invalid. + * + * @link https://tools.ietf.org/html/rfc2818#section-3.1 RFC2818, Section 3.1 + * + * @param string|Stringable $host Host name to verify against + * @param array $cert Certificate data from openssl_x509_parse() + * @return bool + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $host argument is not a string or a stringable object. + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $cert argument is not an array or array accessible. + */ + public static function verify_certificate($host, $cert) { + if (InputValidator::is_string_or_stringable($host) === false) { + throw InvalidArgument::create(1, '$host', 'string|Stringable', gettype($host)); + } + + if (InputValidator::has_array_access($cert) === false) { + throw InvalidArgument::create(2, '$cert', 'array|ArrayAccess', gettype($cert)); + } + + $has_dns_alt = false; + + // Check the subjectAltName + if (!empty($cert['extensions']['subjectAltName'])) { + $altnames = explode(',', $cert['extensions']['subjectAltName']); + foreach ($altnames as $altname) { + $altname = trim($altname); + if (strpos($altname, 'DNS:') !== 0) { + continue; + } + + $has_dns_alt = true; + + // Strip the 'DNS:' prefix and trim whitespace + $altname = trim(substr($altname, 4)); + + // Check for a match + if (self::match_domain($host, $altname) === true) { + return true; + } + } + + if ($has_dns_alt === true) { + return false; + } + } + + // Fall back to checking the common name if we didn't get any dNSName + // alt names, as per RFC2818 + if (!empty($cert['subject']['CN'])) { + // Check for a match + return (self::match_domain($host, $cert['subject']['CN']) === true); + } + + return false; + } + + /** + * Verify that a reference name is valid + * + * Verifies a dNSName for HTTPS usage, (almost) as per Firefox's rules: + * - Wildcards can only occur in a name with more than 3 components + * - Wildcards can only occur as the last character in the first + * component + * - Wildcards may be preceded by additional characters + * + * We modify these rules to be a bit stricter and only allow the wildcard + * character to be the full first component; that is, with the exclusion of + * the third rule. + * + * @param string|Stringable $reference Reference dNSName + * @return boolean Is the name valid? + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed argument is not a string or a stringable object. + */ + public static function verify_reference_name($reference) { + if (InputValidator::is_string_or_stringable($reference) === false) { + throw InvalidArgument::create(1, '$reference', 'string|Stringable', gettype($reference)); + } + + if ($reference === '') { + return false; + } + + if (preg_match('`\s`', $reference) > 0) { + // Whitespace detected. This can never be a dNSName. + return false; + } + + $parts = explode('.', $reference); + if ($parts !== array_filter($parts)) { + // DNSName cannot contain two dots next to each other. + return false; + } + + // Check the first part of the name + $first = array_shift($parts); + + if (strpos($first, '*') !== false) { + // Check that the wildcard is the full part + if ($first !== '*') { + return false; + } + + // Check that we have at least 3 components (including first) + if (count($parts) < 2) { + return false; + } + } + + // Check the remaining parts + foreach ($parts as $part) { + if (strpos($part, '*') !== false) { + return false; + } + } + + // Nothing found, verified! + return true; + } + + /** + * Match a hostname against a dNSName reference + * + * @param string|Stringable $host Requested host + * @param string|Stringable $reference dNSName to match against + * @return boolean Does the domain match? + * @throws \WpOrg\Requests\Exception\InvalidArgument When either of the passed arguments is not a string or a stringable object. + */ + public static function match_domain($host, $reference) { + if (InputValidator::is_string_or_stringable($host) === false) { + throw InvalidArgument::create(1, '$host', 'string|Stringable', gettype($host)); + } + + // Check if the reference is blocklisted first + if (self::verify_reference_name($reference) !== true) { + return false; + } + + // Check for a direct match + if ((string) $host === (string) $reference) { + return true; + } + + // Calculate the valid wildcard match if the host is not an IP address + // Also validates that the host has 3 parts or more, as per Firefox's ruleset, + // as a wildcard reference is only allowed with 3 parts or more, so the + // comparison will never match if host doesn't contain 3 parts or more as well. + if (ip2long($host) === false) { + $parts = explode('.', $host); + $parts[0] = '*'; + $wildcard = implode('.', $parts); + if ($wildcard === (string) $reference) { + return true; + } + } + + return false; + } +} diff --git a/wp-includes/Requests/src/Transport.php b/wp-includes/Requests/src/Transport.php new file mode 100644 index 0000000..f2e1c6e --- /dev/null +++ b/wp-includes/Requests/src/Transport.php @@ -0,0 +1,45 @@ +<?php +/** + * Base HTTP transport + * + * @package Requests\Transport + */ + +namespace WpOrg\Requests; + +/** + * Base HTTP transport + * + * @package Requests\Transport + */ +interface Transport { + /** + * Perform a request + * + * @param string $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 \WpOrg\Requests\Requests::response()} for documentation + * @return string Raw HTTP result + */ + public function request($url, $headers = [], $data = [], $options = []); + + /** + * Send multiple requests simultaneously + * + * @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) + */ + public function request_multiple($requests, $options); + + /** + * Self-test whether the transport can be used. + * + * The available capabilities to test for can be found in {@see \WpOrg\Requests\Capability}. + * + * @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 = []); +} diff --git a/wp-includes/Requests/src/Transport/Curl.php b/wp-includes/Requests/src/Transport/Curl.php new file mode 100644 index 0000000..7316987 --- /dev/null +++ b/wp-includes/Requests/src/Transport/Curl.php @@ -0,0 +1,640 @@ +<?php +/** + * cURL HTTP transport + * + * @package Requests\Transport + */ + +namespace WpOrg\Requests\Transport; + +use RecursiveArrayIterator; +use RecursiveIteratorIterator; +use WpOrg\Requests\Capability; +use WpOrg\Requests\Exception; +use WpOrg\Requests\Exception\InvalidArgument; +use WpOrg\Requests\Exception\Transport\Curl as CurlException; +use WpOrg\Requests\Requests; +use WpOrg\Requests\Transport; +use WpOrg\Requests\Utility\InputValidator; + +/** + * cURL HTTP transport + * + * @package Requests\Transport + */ +final class Curl implements Transport { + const CURL_7_10_5 = 0x070A05; + const CURL_7_16_2 = 0x071002; + + /** + * Raw HTTP data + * + * @var string + */ + public $headers = ''; + + /** + * Raw body data + * + * @var string + */ + public $response_data = ''; + + /** + * Information on the current request + * + * @var array cURL information array, see {@link https://www.php.net/curl_getinfo} + */ + public $info; + + /** + * cURL version number + * + * @var int + */ + public $version; + + /** + * cURL handle + * + * @var resource|\CurlHandle Resource in PHP < 8.0, Instance of CurlHandle in PHP >= 8.0. + */ + private $handle; + + /** + * Hook dispatcher instance + * + * @var \WpOrg\Requests\Hooks + */ + private $hooks; + + /** + * Have we finished the headers yet? + * + * @var boolean + */ + private $done_headers = false; + + /** + * If streaming to a file, keep the file pointer + * + * @var resource + */ + private $stream_handle; + + /** + * How many bytes are in the response body? + * + * @var int + */ + private $response_bytes; + + /** + * What's the maximum number of bytes we should keep? + * + * @var int|bool Byte count, or false if no limit. + */ + private $response_byte_limit; + + /** + * Constructor + */ + public function __construct() { + $curl = curl_version(); + $this->version = $curl['version_number']; + $this->handle = curl_init(); + + curl_setopt($this->handle, CURLOPT_HEADER, false); + curl_setopt($this->handle, CURLOPT_RETURNTRANSFER, 1); + if ($this->version >= self::CURL_7_10_5) { + curl_setopt($this->handle, CURLOPT_ENCODING, ''); + } + + if (defined('CURLOPT_PROTOCOLS')) { + // phpcs:ignore PHPCompatibility.Constants.NewConstants.curlopt_protocolsFound + curl_setopt($this->handle, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS); + } + + if (defined('CURLOPT_REDIR_PROTOCOLS')) { + // phpcs:ignore PHPCompatibility.Constants.NewConstants.curlopt_redir_protocolsFound + curl_setopt($this->handle, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS); + } + } + + /** + * Destructor + */ + public function __destruct() { + if (is_resource($this->handle)) { + curl_close($this->handle); + } + } + + /** + * Perform a 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 \WpOrg\Requests\Requests::response()} for documentation + * @return string Raw HTTP result + * + * @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 a cURL error (`curlerror`) + */ + 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)); + } + + $this->hooks = $options['hooks']; + + $this->setup_handle($url, $headers, $data, $options); + + $options['hooks']->dispatch('curl.before_send', [&$this->handle]); + + if ($options['filename'] !== false) { + // phpcs:ignore WordPress.PHP.NoSilencedErrors -- Silenced the PHP native warning in favour of throwing an exception. + $this->stream_handle = @fopen($options['filename'], 'wb'); + if ($this->stream_handle === false) { + $error = error_get_last(); + throw new Exception($error['message'], 'fopen'); + } + } + + $this->response_data = ''; + $this->response_bytes = 0; + $this->response_byte_limit = false; + if ($options['max_bytes'] !== false) { + $this->response_byte_limit = $options['max_bytes']; + } + + if (isset($options['verify'])) { + if ($options['verify'] === false) { + curl_setopt($this->handle, CURLOPT_SSL_VERIFYHOST, 0); + curl_setopt($this->handle, CURLOPT_SSL_VERIFYPEER, 0); + } elseif (is_string($options['verify'])) { + curl_setopt($this->handle, CURLOPT_CAINFO, $options['verify']); + } + } + + if (isset($options['verifyname']) && $options['verifyname'] === false) { + curl_setopt($this->handle, CURLOPT_SSL_VERIFYHOST, 0); + } + + curl_exec($this->handle); + $response = $this->response_data; + + $options['hooks']->dispatch('curl.after_send', []); + + if (curl_errno($this->handle) === CURLE_WRITE_ERROR || curl_errno($this->handle) === CURLE_BAD_CONTENT_ENCODING) { + // Reset encoding and try again + curl_setopt($this->handle, CURLOPT_ENCODING, 'none'); + + $this->response_data = ''; + $this->response_bytes = 0; + curl_exec($this->handle); + $response = $this->response_data; + } + + $this->process_response($response, $options); + + // Need to remove the $this reference from the curl handle. + // Otherwise \WpOrg\Requests\Transport\Curl won't be garbage collected and the curl_close() will never be called. + curl_setopt($this->handle, CURLOPT_HEADERFUNCTION, null); + curl_setopt($this->handle, CURLOPT_WRITEFUNCTION, null); + + return $this->headers; + } + + /** + * Send multiple requests simultaneously + * + * @param array $requests Request data + * @param array $options Global options + * @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) { + // 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)); + } + + $multihandle = curl_multi_init(); + $subrequests = []; + $subhandles = []; + + $class = get_class($this); + foreach ($requests as $id => $request) { + $subrequests[$id] = new $class(); + $subhandles[$id] = $subrequests[$id]->get_subrequest_handle($request['url'], $request['headers'], $request['data'], $request['options']); + $request['options']['hooks']->dispatch('curl.before_multi_add', [&$subhandles[$id]]); + curl_multi_add_handle($multihandle, $subhandles[$id]); + } + + $completed = 0; + $responses = []; + $subrequestcount = count($subrequests); + + $request['options']['hooks']->dispatch('curl.before_multi_exec', [&$multihandle]); + + do { + $active = 0; + + do { + $status = curl_multi_exec($multihandle, $active); + } while ($status === CURLM_CALL_MULTI_PERFORM); + + $to_process = []; + + // Read the information as needed + while ($done = curl_multi_info_read($multihandle)) { + $key = array_search($done['handle'], $subhandles, true); + if (!isset($to_process[$key])) { + $to_process[$key] = $done; + } + } + + // Parse the finished requests before we start getting the new ones + foreach ($to_process as $key => $done) { + $options = $requests[$key]['options']; + if ($done['result'] !== CURLE_OK) { + //get error string for handle. + $reason = curl_error($done['handle']); + $exception = new CurlException( + $reason, + CurlException::EASY, + $done['handle'], + $done['result'] + ); + $responses[$key] = $exception; + $options['hooks']->dispatch('transport.internal.parse_error', [&$responses[$key], $requests[$key]]); + } else { + $responses[$key] = $subrequests[$key]->process_response($subrequests[$key]->response_data, $options); + + $options['hooks']->dispatch('transport.internal.parse_response', [&$responses[$key], $requests[$key]]); + } + + curl_multi_remove_handle($multihandle, $done['handle']); + curl_close($done['handle']); + + if (!is_string($responses[$key])) { + $options['hooks']->dispatch('multiple.request.complete', [&$responses[$key], $key]); + } + + $completed++; + } + } while ($active || $completed < $subrequestcount); + + $request['options']['hooks']->dispatch('curl.after_multi_exec', [&$multihandle]); + + curl_multi_close($multihandle); + + return $responses; + } + + /** + * Get the cURL handle for use in a multi-request + * + * @param string $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 \WpOrg\Requests\Requests::response()} for documentation + * @return resource|\CurlHandle Subrequest's cURL handle + */ + public function &get_subrequest_handle($url, $headers, $data, $options) { + $this->setup_handle($url, $headers, $data, $options); + + if ($options['filename'] !== false) { + $this->stream_handle = fopen($options['filename'], 'wb'); + } + + $this->response_data = ''; + $this->response_bytes = 0; + $this->response_byte_limit = false; + if ($options['max_bytes'] !== false) { + $this->response_byte_limit = $options['max_bytes']; + } + + $this->hooks = $options['hooks']; + + return $this->handle; + } + + /** + * Setup the cURL handle for the given data + * + * @param string $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 \WpOrg\Requests\Requests::response()} for documentation + */ + private function setup_handle($url, $headers, $data, $options) { + $options['hooks']->dispatch('curl.before_request', [&$this->handle]); + + // Force closing the connection for old versions of cURL (<7.22). + if (!isset($headers['Connection'])) { + $headers['Connection'] = 'close'; + } + + /** + * Add "Expect" header. + * + * By default, cURL adds a "Expect: 100-Continue" to most requests. This header can + * add as much as a second to the time it takes for cURL to perform a request. To + * prevent this, we need to set an empty "Expect" header. To match the behaviour of + * Guzzle, we'll add the empty header to requests that are smaller than 1 MB and use + * HTTP/1.1. + * + * https://curl.se/mail/lib-2017-07/0013.html + */ + if (!isset($headers['Expect']) && $options['protocol_version'] === 1.1) { + $headers['Expect'] = $this->get_expect_header($data); + } + + $headers = Requests::flatten($headers); + + if (!empty($data)) { + $data_format = $options['data_format']; + + if ($data_format === 'query') { + $url = self::format_get($url, $data); + $data = ''; + } elseif (!is_string($data)) { + $data = http_build_query($data, '', '&'); + } + } + + switch ($options['type']) { + case Requests::POST: + curl_setopt($this->handle, CURLOPT_POST, true); + curl_setopt($this->handle, CURLOPT_POSTFIELDS, $data); + break; + case Requests::HEAD: + curl_setopt($this->handle, CURLOPT_CUSTOMREQUEST, $options['type']); + curl_setopt($this->handle, CURLOPT_NOBODY, true); + break; + case Requests::TRACE: + curl_setopt($this->handle, CURLOPT_CUSTOMREQUEST, $options['type']); + break; + case Requests::PATCH: + case Requests::PUT: + case Requests::DELETE: + case Requests::OPTIONS: + default: + curl_setopt($this->handle, CURLOPT_CUSTOMREQUEST, $options['type']); + if (!empty($data)) { + curl_setopt($this->handle, CURLOPT_POSTFIELDS, $data); + } + } + + // cURL requires a minimum timeout of 1 second when using the system + // DNS resolver, as it uses `alarm()`, which is second resolution only. + // There's no way to detect which DNS resolver is being used from our + // end, so we need to round up regardless of the supplied timeout. + // + // https://github.com/curl/curl/blob/4f45240bc84a9aa648c8f7243be7b79e9f9323a5/lib/hostip.c#L606-L609 + $timeout = max($options['timeout'], 1); + + if (is_int($timeout) || $this->version < self::CURL_7_16_2) { + curl_setopt($this->handle, CURLOPT_TIMEOUT, ceil($timeout)); + } else { + // phpcs:ignore PHPCompatibility.Constants.NewConstants.curlopt_timeout_msFound + curl_setopt($this->handle, CURLOPT_TIMEOUT_MS, round($timeout * 1000)); + } + + if (is_int($options['connect_timeout']) || $this->version < self::CURL_7_16_2) { + curl_setopt($this->handle, CURLOPT_CONNECTTIMEOUT, ceil($options['connect_timeout'])); + } else { + // phpcs:ignore PHPCompatibility.Constants.NewConstants.curlopt_connecttimeout_msFound + curl_setopt($this->handle, CURLOPT_CONNECTTIMEOUT_MS, round($options['connect_timeout'] * 1000)); + } + + curl_setopt($this->handle, CURLOPT_URL, $url); + curl_setopt($this->handle, CURLOPT_USERAGENT, $options['useragent']); + if (!empty($headers)) { + curl_setopt($this->handle, CURLOPT_HTTPHEADER, $headers); + } + + if ($options['protocol_version'] === 1.1) { + curl_setopt($this->handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1); + } else { + curl_setopt($this->handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0); + } + + if ($options['blocking'] === true) { + curl_setopt($this->handle, CURLOPT_HEADERFUNCTION, [$this, 'stream_headers']); + curl_setopt($this->handle, CURLOPT_WRITEFUNCTION, [$this, 'stream_body']); + curl_setopt($this->handle, CURLOPT_BUFFERSIZE, Requests::BUFFER_SIZE); + } + } + + /** + * Process a response + * + * @param string $response Response data from the body + * @param array $options Request options + * @return string|false HTTP response data including headers. False if non-blocking. + * @throws \WpOrg\Requests\Exception If the request resulted in a cURL error. + */ + public function process_response($response, $options) { + if ($options['blocking'] === false) { + $fake_headers = ''; + $options['hooks']->dispatch('curl.after_request', [&$fake_headers]); + return false; + } + + if ($options['filename'] !== false && $this->stream_handle) { + fclose($this->stream_handle); + $this->headers = trim($this->headers); + } else { + $this->headers .= $response; + } + + if (curl_errno($this->handle)) { + $error = sprintf( + 'cURL error %s: %s', + curl_errno($this->handle), + curl_error($this->handle) + ); + throw new Exception($error, 'curlerror', $this->handle); + } + + $this->info = curl_getinfo($this->handle); + + $options['hooks']->dispatch('curl.after_request', [&$this->headers, &$this->info]); + return $this->headers; + } + + /** + * Collect the headers as they are received + * + * @param resource|\CurlHandle $handle cURL handle + * @param string $headers Header string + * @return integer Length of provided header + */ + public function stream_headers($handle, $headers) { + // Why do we do this? cURL will send both the final response and any + // interim responses, such as a 100 Continue. We don't need that. + // (We may want to keep this somewhere just in case) + if ($this->done_headers) { + $this->headers = ''; + $this->done_headers = false; + } + + $this->headers .= $headers; + + if ($headers === "\r\n") { + $this->done_headers = true; + } + + return strlen($headers); + } + + /** + * Collect data as it's received + * + * @since 1.6.1 + * + * @param resource|\CurlHandle $handle cURL handle + * @param string $data Body data + * @return integer Length of provided data + */ + public function stream_body($handle, $data) { + $this->hooks->dispatch('request.progress', [$data, $this->response_bytes, $this->response_byte_limit]); + $data_length = strlen($data); + + // Are we limiting the response size? + if ($this->response_byte_limit) { + if ($this->response_bytes === $this->response_byte_limit) { + // Already at maximum, move on + return $data_length; + } + + if (($this->response_bytes + $data_length) > $this->response_byte_limit) { + // Limit the length + $limited_length = ($this->response_byte_limit - $this->response_bytes); + $data = substr($data, 0, $limited_length); + } + } + + if ($this->stream_handle) { + fwrite($this->stream_handle, $data); + } else { + $this->response_data .= $data; + } + + $this->response_bytes += strlen($data); + return $data_length; + } + + /** + * Format a URL given GET data + * + * @param string $url Original URL. + * @param array|object $data Data to build query using, see {@link https://www.php.net/http_build_query} + * @return string URL with data + */ + private static function format_get($url, $data) { + if (!empty($data)) { + $query = ''; + $url_parts = parse_url($url); + if (empty($url_parts['query'])) { + $url_parts['query'] = ''; + } else { + $query = $url_parts['query']; + } + + $query .= '&' . http_build_query($data, '', '&'); + $query = trim($query, '&'); + + if (empty($url_parts['query'])) { + $url .= '?' . $query; + } else { + $url = str_replace($url_parts['query'], $query, $url); + } + } + + return $url; + } + + /** + * Self-test whether the transport can be used. + * + * The available capabilities to test for can be found in {@see \WpOrg\Requests\Capability}. + * + * @codeCoverageIgnore + * @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('curl_init') || !function_exists('curl_exec')) { + return false; + } + + // If needed, check that our installed curl version supports SSL + if (isset($capabilities[Capability::SSL]) && $capabilities[Capability::SSL]) { + $curl_version = curl_version(); + if (!(CURL_VERSION_SSL & $curl_version['features'])) { + return false; + } + } + + return true; + } + + /** + * Get the correct "Expect" header for the given request data. + * + * @param string|array $data Data to send either as the POST body, or as parameters in the URL for a GET/HEAD. + * @return string The "Expect" header. + */ + private function get_expect_header($data) { + if (!is_array($data)) { + return strlen((string) $data) >= 1048576 ? '100-Continue' : ''; + } + + $bytesize = 0; + $iterator = new RecursiveIteratorIterator(new RecursiveArrayIterator($data)); + + foreach ($iterator as $datum) { + $bytesize += strlen((string) $datum); + + if ($bytesize >= 1048576) { + return '100-Continue'; + } + } + + return ''; + } +} diff --git a/wp-includes/Requests/src/Transport/Fsockopen.php b/wp-includes/Requests/src/Transport/Fsockopen.php new file mode 100644 index 0000000..2b53d0c --- /dev/null +++ b/wp-includes/Requests/src/Transport/Fsockopen.php @@ -0,0 +1,510 @@ +<?php +/** + * fsockopen HTTP 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\Transport + */ +final class Fsockopen implements Transport { + /** + * Second to microsecond conversion + * + * @var integer + */ + const SECOND_IN_MICROSECONDS = 1000000; + + /** + * Raw HTTP data + * + * @var string + */ + public $headers = ''; + + /** + * Stream metadata + * + * @var array Associative array of properties, see {@link https://www.php.net/stream_get_meta_data} + */ + public $info; + + /** + * What's the maximum number of bytes we should keep? + * + * @var int|bool Byte count, or false if no limit. + */ + private $max_bytes = false; + + /** + * Cache for received connection errors. + * + * @var string + */ + private $connect_error = ''; + + /** + * Perform a 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 \WpOrg\Requests\Requests::response()} for documentation + * @return string Raw HTTP result + * + * @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 Exception('Invalid URL.', 'invalidurl', $url); + } + + $host = $url_parts['host']; + $context = stream_context_create(); + $verifyname = false; + $case_insensitive_headers = new CaseInsensitiveDictionary($headers); + + // HTTPS support + if (isset($url_parts['scheme']) && strtolower($url_parts['scheme']) === 'https') { + $remote_socket = 'ssl://' . $host; + if (!isset($url_parts['port'])) { + $url_parts['port'] = Port::HTTPS; + } + + $context_options = [ + 'verify_peer' => true, + 'capture_peer_cert' => true, + ]; + $verifyname = true; + + // SNI, if enabled (OpenSSL >=0.9.8j) + // phpcs:ignore PHPCompatibility.Constants.NewConstants.openssl_tlsext_server_nameFound + if (defined('OPENSSL_TLSEXT_SERVER_NAME') && OPENSSL_TLSEXT_SERVER_NAME) { + $context_options['SNI_enabled'] = true; + if (isset($options['verifyname']) && $options['verifyname'] === false) { + $context_options['SNI_enabled'] = false; + } + } + + if (isset($options['verify'])) { + if ($options['verify'] === false) { + $context_options['verify_peer'] = false; + $context_options['verify_peer_name'] = false; + $verifyname = false; + } elseif (is_string($options['verify'])) { + $context_options['cafile'] = $options['verify']; + } + } + + if (isset($options['verifyname']) && $options['verifyname'] === false) { + $context_options['verify_peer_name'] = false; + $verifyname = false; + } + + stream_context_set_option($context, ['ssl' => $context_options]); + } else { + $remote_socket = 'tcp://' . $host; + } + + $this->max_bytes = $options['max_bytes']; + + if (!isset($url_parts['port'])) { + $url_parts['port'] = Port::HTTP; + } + + $remote_socket .= ':' . $url_parts['port']; + + // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_set_error_handler + 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); + + restore_error_handler(); + + if ($verifyname && !$this->verify_certificate_from_context($host, $context)) { + throw new Exception('SSL certificate did not match the requested domain name', 'ssl.no_match'); + } + + if (!$socket) { + if ($errno === 0) { + // Connection issue + throw new Exception(rtrim($this->connect_error), 'fsockopen.connect_error'); + } + + throw new Exception($errstr, 'fsockopenerror', null, $errno); + } + + $data_format = $options['data_format']; + + if ($data_format === 'query') { + $path = self::format_get($url_parts, $data); + $data = ''; + } else { + $path = self::format_get($url_parts, []); + } + + $options['hooks']->dispatch('fsockopen.remote_host_path', [&$path, $url]); + + $request_body = ''; + $out = sprintf("%s %s HTTP/%.1F\r\n", $options['type'], $path, $options['protocol_version']); + + if ($options['type'] !== Requests::TRACE) { + if (is_array($data)) { + $request_body = http_build_query($data, '', '&'); + } else { + $request_body = $data; + } + + // Always include Content-length on POST requests to prevent + // 411 errors from some servers when the body is empty. + if (!empty($data) || $options['type'] === Requests::POST) { + if (!isset($case_insensitive_headers['Content-Length'])) { + $headers['Content-Length'] = strlen($request_body); + } + + if (!isset($case_insensitive_headers['Content-Type'])) { + $headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8'; + } + } + } + + if (!isset($case_insensitive_headers['Host'])) { + $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']; + } + + $out .= "\r\n"; + } + + if (!isset($case_insensitive_headers['User-Agent'])) { + $out .= sprintf("User-Agent: %s\r\n", $options['useragent']); + } + + $accept_encoding = $this->accept_encoding(); + if (!isset($case_insensitive_headers['Accept-Encoding']) && !empty($accept_encoding)) { + $out .= sprintf("Accept-Encoding: %s\r\n", $accept_encoding); + } + + $headers = Requests::flatten($headers); + + if (!empty($headers)) { + $out .= implode("\r\n", $headers) . "\r\n"; + } + + $options['hooks']->dispatch('fsockopen.after_headers', [&$out]); + + if (substr($out, -2) !== "\r\n") { + $out .= "\r\n"; + } + + if (!isset($case_insensitive_headers['Connection'])) { + $out .= "Connection: Close\r\n"; + } + + $out .= "\r\n" . $request_body; + + $options['hooks']->dispatch('fsockopen.before_send', [&$out]); + + fwrite($socket, $out); + $options['hooks']->dispatch('fsockopen.after_send', [$out]); + + if (!$options['blocking']) { + fclose($socket); + $fake_headers = ''; + $options['hooks']->dispatch('fsockopen.after_request', [&$fake_headers]); + return ''; + } + + $timeout_sec = (int) floor($options['timeout']); + if ($timeout_sec === $options['timeout']) { + $timeout_msec = 0; + } else { + $timeout_msec = self::SECOND_IN_MICROSECONDS * $options['timeout'] % self::SECOND_IN_MICROSECONDS; + } + + stream_set_timeout($socket, $timeout_sec, $timeout_msec); + + $response = ''; + $body = ''; + $headers = ''; + $this->info = stream_get_meta_data($socket); + $size = 0; + $doingbody = false; + $download = false; + if ($options['filename']) { + // 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'); + } + } + + while (!feof($socket)) { + $this->info = stream_get_meta_data($socket); + if ($this->info['timed_out']) { + throw new Exception('fsocket timed out', 'timeout'); + } + + $block = fread($socket, Requests::BUFFER_SIZE); + if (!$doingbody) { + $response .= $block; + if (strpos($response, "\r\n\r\n")) { + list($headers, $block) = explode("\r\n\r\n", $response, 2); + $doingbody = true; + } + } + + // Are we in body mode now? + if ($doingbody) { + $options['hooks']->dispatch('request.progress', [$block, $size, $this->max_bytes]); + $data_length = strlen($block); + if ($this->max_bytes) { + // Have we already hit a limit? + if ($size === $this->max_bytes) { + continue; + } + + if (($size + $data_length) > $this->max_bytes) { + // Limit the length + $limited_length = ($this->max_bytes - $size); + $block = substr($block, 0, $limited_length); + } + } + + $size += strlen($block); + if ($download) { + fwrite($download, $block); + } else { + $body .= $block; + } + } + } + + $this->headers = $headers; + + if ($download) { + fclose($download); + } else { + $this->headers .= "\r\n\r\n" . $body; + } + + fclose($socket); + + $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 \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) { + // 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) { + try { + $handler = new $class(); + $responses[$id] = $handler->request($request['url'], $request['headers'], $request['data'], $request['options']); + + $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', [&$responses[$id], $id]); + } + } + + return $responses; + } + + /** + * Retrieve the encodings we can accept + * + * @return string Accept-Encoding header value + */ + private static function accept_encoding() { + $type = []; + if (function_exists('gzinflate')) { + $type[] = 'deflate;q=1.0'; + } + + if (function_exists('gzuncompress')) { + $type[] = 'compress;q=0.5'; + } + + $type[] = 'gzip;q=0.5'; + + return implode(', ', $type); + } + + /** + * Format a URL given GET data + * + * @param array $url_parts Array of URL parts as received from {@link https://www.php.net/parse_url} + * @param array|object $data Data to build query using, see {@link https://www.php.net/http_build_query} + * @return string URL with data + */ + private static function format_get($url_parts, $data) { + if (!empty($data)) { + if (empty($url_parts['query'])) { + $url_parts['query'] = ''; + } + + $url_parts['query'] .= '&' . http_build_query($data, '', '&'); + $url_parts['query'] = trim($url_parts['query'], '&'); + } + + if (isset($url_parts['path'])) { + if (isset($url_parts['query'])) { + $get = $url_parts['path'] . '?' . $url_parts['query']; + } else { + $get = $url_parts['path']; + } + } else { + $get = '/'; + } + + return $get; + } + + /** + * Error handler for stream_socket_client() + * + * @param int $errno Error number (e.g. E_WARNING) + * @param string $errstr Error message + */ + public function connect_error_handler($errno, $errstr) { + // Double-check we can handle it + if (($errno & E_WARNING) === 0 && ($errno & E_NOTICE) === 0) { + // Return false to indicate the default error handler should engage + return false; + } + + $this->connect_error .= $errstr . "\n"; + return true; + } + + /** + * Verify the certificate against common name and subject alternative names + * + * Unfortunately, PHP doesn't check the certificate against the alternative + * names, leading things like 'https://www.github.com/' to be invalid. + * Instead + * + * @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) { + $meta = stream_context_get_options($context); + + // If we don't have SSL options, then we couldn't make the connection at + // all + if (empty($meta) || empty($meta['ssl']) || empty($meta['ssl']['peer_certificate'])) { + throw new Exception(rtrim($this->connect_error), 'ssl.connect_error'); + } + + $cert = openssl_x509_parse($meta['ssl']['peer_certificate']); + + 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 + * @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[Capability::SSL]) && $capabilities[Capability::SSL]) { + if (!extension_loaded('openssl') || !function_exists('openssl_x509_parse')) { + return false; + } + } + + return true; + } +} diff --git a/wp-includes/Requests/src/Utility/CaseInsensitiveDictionary.php b/wp-includes/Requests/src/Utility/CaseInsensitiveDictionary.php new file mode 100644 index 0000000..0e1a914 --- /dev/null +++ b/wp-includes/Requests/src/Utility/CaseInsensitiveDictionary.php @@ -0,0 +1,127 @@ +<?php +/** + * Case-insensitive dictionary, suitable for HTTP headers + * + * @package Requests\Utilities + */ + +namespace WpOrg\Requests\Utility; + +use ArrayAccess; +use ArrayIterator; +use IteratorAggregate; +use ReturnTypeWillChange; +use WpOrg\Requests\Exception; + +/** + * Case-insensitive dictionary, suitable for HTTP headers + * + * @package Requests\Utilities + */ +class CaseInsensitiveDictionary implements ArrayAccess, IteratorAggregate { + /** + * Actual item data + * + * @var array + */ + protected $data = []; + + /** + * Creates a case insensitive dictionary. + * + * @param array $data Dictionary/map to convert to case-insensitive + */ + public function __construct(array $data = []) { + foreach ($data as $offset => $value) { + $this->offsetSet($offset, $value); + } + } + + /** + * Check if the given item exists + * + * @param string $offset Item key + * @return boolean Does the item exist? + */ + #[ReturnTypeWillChange] + public function offsetExists($offset) { + if (is_string($offset)) { + $offset = strtolower($offset); + } + + return isset($this->data[$offset]); + } + + /** + * Get the value for the item + * + * @param string $offset Item key + * @return string|null Item value (null if the item key doesn't exist) + */ + #[ReturnTypeWillChange] + public function offsetGet($offset) { + if (is_string($offset)) { + $offset = strtolower($offset); + } + + if (!isset($this->data[$offset])) { + return null; + } + + return $this->data[$offset]; + } + + /** + * Set the given item + * + * @param string $offset Item name + * @param string $value Item value + * + * @throws \WpOrg\Requests\Exception On attempting to use dictionary as list (`invalidset`) + */ + #[ReturnTypeWillChange] + public function offsetSet($offset, $value) { + if ($offset === null) { + throw new Exception('Object is a dictionary, not a list', 'invalidset'); + } + + if (is_string($offset)) { + $offset = strtolower($offset); + } + + $this->data[$offset] = $value; + } + + /** + * Unset the given header + * + * @param string $offset The key for the item to unset. + */ + #[ReturnTypeWillChange] + public function offsetUnset($offset) { + if (is_string($offset)) { + $offset = strtolower($offset); + } + + unset($this->data[$offset]); + } + + /** + * Get an iterator for the data + * + * @return \ArrayIterator + */ + #[ReturnTypeWillChange] + public function getIterator() { + return new ArrayIterator($this->data); + } + + /** + * Get the headers as an array + * + * @return array Header data + */ + public function getAll() { + return $this->data; + } +} diff --git a/wp-includes/Requests/src/Utility/FilteredIterator.php b/wp-includes/Requests/src/Utility/FilteredIterator.php new file mode 100644 index 0000000..4865966 --- /dev/null +++ b/wp-includes/Requests/src/Utility/FilteredIterator.php @@ -0,0 +1,97 @@ +<?php +/** + * Iterator for arrays requiring filtered values + * + * @package Requests\Utilities + */ + +namespace WpOrg\Requests\Utility; + +use ArrayIterator; +use ReturnTypeWillChange; +use WpOrg\Requests\Exception\InvalidArgument; +use WpOrg\Requests\Utility\InputValidator; + +/** + * Iterator for arrays requiring filtered values + * + * @package Requests\Utilities + */ +final class FilteredIterator extends ArrayIterator { + /** + * Callback to run as a filter + * + * @var callable + */ + private $callback; + + /** + * Create a new iterator + * + * @param array $data The array or object to be iterated on. + * @param callable $callback Callback to be called on each value + * + * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $data argument is not iterable. + */ + public function __construct($data, $callback) { + if (InputValidator::is_iterable($data) === false) { + throw InvalidArgument::create(1, '$data', 'iterable', gettype($data)); + } + + parent::__construct($data); + + if (is_callable($callback)) { + $this->callback = $callback; + } + } + + /** + * Prevent unserialization of the object for security reasons. + * + * @phpcs:disable PHPCompatibility.FunctionNameRestrictions.NewMagicMethods.__unserializeFound + * + * @param array $data Restored array of data originally serialized. + * + * @return void + */ + #[ReturnTypeWillChange] + public function __unserialize($data) {} + // phpcs:enable + + /** + * Perform reinitialization tasks. + * + * Prevents a callback from being injected during unserialization of an object. + * + * @return void + */ + public function __wakeup() { + unset($this->callback); + } + + /** + * Get the current item's value after filtering + * + * @return string + */ + #[ReturnTypeWillChange] + public function current() { + $value = parent::current(); + + if (is_callable($this->callback)) { + $value = call_user_func($this->callback, $value); + } + + return $value; + } + + /** + * Prevent creating a PHP value from a stored representation of the object for security reasons. + * + * @param string $data The serialized string. + * + * @return void + */ + #[ReturnTypeWillChange] + public function unserialize($data) {} +} diff --git a/wp-includes/Requests/src/Utility/InputValidator.php b/wp-includes/Requests/src/Utility/InputValidator.php new file mode 100644 index 0000000..7c10d61 --- /dev/null +++ b/wp-includes/Requests/src/Utility/InputValidator.php @@ -0,0 +1,109 @@ +<?php +/** + * Input validation utilities. + * + * @package Requests\Utilities + */ + +namespace WpOrg\Requests\Utility; + +use ArrayAccess; +use CurlHandle; +use Traversable; + +/** + * Input validation utilities. + * + * @package Requests\Utilities + */ +final class InputValidator { + + /** + * Verify that a received input parameter is of type string or is "stringable". + * + * @param mixed $input Input parameter to verify. + * + * @return bool + */ + public static function is_string_or_stringable($input) { + return is_string($input) || self::is_stringable_object($input); + } + + /** + * Verify whether a received input parameter is usable as an integer array key. + * + * @param mixed $input Input parameter to verify. + * + * @return bool + */ + public static function is_numeric_array_key($input) { + if (is_int($input)) { + return true; + } + + if (!is_string($input)) { + return false; + } + + return (bool) preg_match('`^-?[0-9]+$`', $input); + } + + /** + * Verify whether a received input parameter is "stringable". + * + * @param mixed $input Input parameter to verify. + * + * @return bool + */ + public static function is_stringable_object($input) { + return is_object($input) && method_exists($input, '__toString'); + } + + /** + * Verify whether a received input parameter is _accessible as if it were an array_. + * + * @param mixed $input Input parameter to verify. + * + * @return bool + */ + public static function has_array_access($input) { + return is_array($input) || $input instanceof ArrayAccess; + } + + /** + * Verify whether a received input parameter is "iterable". + * + * @internal The PHP native `is_iterable()` function was only introduced in PHP 7.1 + * and this library still supports PHP 5.6. + * + * @param mixed $input Input parameter to verify. + * + * @return bool + */ + public static function is_iterable($input) { + return is_array($input) || $input instanceof Traversable; + } + + /** + * Verify whether a received input parameter is a Curl handle. + * + * The PHP Curl extension worked with resources prior to PHP 8.0 and with + * an instance of the `CurlHandle` class since PHP 8.0. + * {@link https://www.php.net/manual/en/migration80.incompatible.php#migration80.incompatible.resource2object} + * + * @param mixed $input Input parameter to verify. + * + * @return bool + */ + public static function is_curl_handle($input) { + if (is_resource($input)) { + return get_resource_type($input) === 'curl'; + } + + if (is_object($input)) { + return $input instanceof CurlHandle; + } + + return false; + } +} |