primo commit

libraries/vendor/joomla/http/src/AbstractTransport.php

@@ -0,0 +1,92 @@
+<?php
+
+/**
+ * Part of the Joomla Framework Http Package
+ *
+ * @copyright  Copyright (C) 2005 - 2021 Open Source Matters, Inc. All rights reserved.
+ * @license    GNU General Public License version 2 or later; see LICENSE
+ */
+
+namespace Joomla\Http;
+
+/**
+ * Abstract transport class.
+ *
+ * @since  2.0.0
+ */
+abstract class AbstractTransport implements TransportInterface
+{
+    /**
+     * The client options.
+     *
+     * @var    array|\ArrayAccess
+     * @since  2.0.0
+     */
+    protected $options;
+
+    /**
+     * Constructor.
+     *
+     * @param   array|\ArrayAccess  $options  Client options array.
+     *
+     * @since   2.0.0
+     * @throws  \RuntimeException
+     */
+    public function __construct($options = [])
+    {
+        if (!static::isSupported()) {
+            throw new \RuntimeException(sprintf('The %s transport is not supported in this environment.', \get_class($this)));
+        }
+
+        if (!\is_array($options) && !($options instanceof \ArrayAccess)) {
+            throw new \InvalidArgumentException(
+                'The options param must be an array or implement the ArrayAccess interface.'
+            );
+        }
+
+        $this->options = $options;
+    }
+
+    /**
+     * Get an option from the HTTP transport.
+     *
+     * @param   string  $key      The name of the option to get.
+     * @param   mixed   $default  The default value if the option is not set.
+     *
+     * @return  mixed  The option value.
+     *
+     * @since   2.0.0
+     */
+    protected function getOption(string $key, $default = null)
+    {
+        return $this->options[$key] ?? $default;
+    }
+
+    /**
+     * Processes the headers from a transport's response data.
+     *
+     * @param   array  $headers  The headers to process.
+     *
+     * @return  array
+     *
+     * @since   2.0.0
+     */
+    protected function processHeaders(array $headers): array
+    {
+        $verifiedHeaders = [];
+
+        // Add the response headers to the response object.
+        foreach ($headers as $header) {
+            $pos     = strpos($header, ':');
+            $keyName = trim(substr($header, 0, $pos));
+
+            if (!isset($verifiedHeaders[$keyName])) {
+                $verifiedHeaders[$keyName] = [];
+            }
+
+            $verifiedHeaders[$keyName][] = trim(substr($header, ($pos + 1)));
+        }
+
+        return $verifiedHeaders;
+    }
+}

libraries/vendor/joomla/http/src/Exception/InvalidResponseCodeException.php

@@ -0,0 +1,21 @@
+<?php
+
+/**
+ * Part of the Joomla Framework Http Package
+ *
+ * @copyright  Copyright (C) 2005 - 2021 Open Source Matters, Inc. All rights reserved.
+ * @license    GNU General Public License version 2 or later; see LICENSE
+ */
+
+namespace Joomla\Http\Exception;
+
+use Psr\Http\Client\ClientExceptionInterface;
+
+/**
+ * Exception representing an invalid or undefined HTTP response code
+ *
+ * @since  1.2.0
+ */
+class InvalidResponseCodeException extends \UnexpectedValueException implements ClientExceptionInterface
+{
+}

libraries/vendor/joomla/http/src/Exception/UnexpectedResponseException.php

@@ -0,0 +1,58 @@
+<?php
+
+/**
+ * Part of the Joomla Framework Http Package
+ *
+ * @copyright  Copyright (C) 2005 - 2021 Open Source Matters, Inc. All rights reserved.
+ * @license    GNU General Public License version 2 or later; see LICENSE
+ */
+
+namespace Joomla\Http\Exception;
+
+use Joomla\Http\Response;
+use Psr\Http\Client\ClientExceptionInterface;
+
+/**
+ * Exception representing an unexpected response
+ *
+ * @since  1.2.0
+ */
+class UnexpectedResponseException extends \DomainException implements ClientExceptionInterface
+{
+    /**
+     * The Response object.
+     *
+     * @var    Response
+     * @since  1.2.0
+     */
+    private $response;
+
+    /**
+     * Constructor
+     *
+     * @param   Response     $response  The Response object.
+     * @param   string       $message   The Exception message to throw.
+     * @param   integer      $code      The Exception code.
+     * @param   ?\Exception  $previous  The previous exception used for the exception chaining.
+     *
+     * @since   1.2.0
+     */
+    public function __construct(Response $response, $message = '', $code = 0, \Exception $previous = null)
+    {
+        parent::__construct($message, $code, $previous);
+
+        $this->response = $response;
+    }
+
+    /**
+     * Get the Response object.
+     *
+     * @return  Response
+     *
+     * @since   1.2.0
+     */
+    public function getResponse()
+    {
+        return $this->response;
+    }
+}

libraries/vendor/joomla/http/src/Http.php

@@ -0,0 +1,307 @@
+<?php
+
+/**
+ * Part of the Joomla Framework Http Package
+ *
+ * @copyright  Copyright (C) 2005 - 2021 Open Source Matters, Inc. All rights reserved.
+ * @license    GNU General Public License version 2 or later; see LICENSE
+ */
+
+namespace Joomla\Http;
+
+use Joomla\Uri\Uri;
+use Joomla\Uri\UriInterface;
+use Psr\Http\Client\ClientInterface;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * HTTP client class.
+ *
+ * @since  1.0
+ */
+class Http implements ClientInterface
+{
+    /**
+     * Options for the HTTP client.
+     *
+     * @var    array|\ArrayAccess
+     * @since  1.0
+     */
+    protected $options;
+
+    /**
+     * The HTTP transport object to use in sending HTTP requests.
+     *
+     * @var    TransportInterface
+     * @since  1.0
+     */
+    protected $transport;
+
+    /**
+     * Constructor.
+     *
+     * @param   array|\ArrayAccess   $options    Client options array. If the registry contains any headers.* elements,
+     *                                           these will be added to the request headers.
+     * @param   ?TransportInterface  $transport  The HTTP transport object.
+     *
+     * @since   1.0
+     * @throws  \InvalidArgumentException
+     */
+    public function __construct($options = [], TransportInterface $transport = null)
+    {
+        if (!\is_array($options) && !($options instanceof \ArrayAccess)) {
+            throw new \InvalidArgumentException(
+                'The options param must be an array or implement the ArrayAccess interface.'
+            );
+        }
+
+        $this->options = $options;
+
+        if (!$transport) {
+            $transport = (new HttpFactory())->getAvailableDriver($this->options);
+
+            // Ensure the transport is a TransportInterface instance or bail out
+            if (!($transport instanceof TransportInterface)) {
+                throw new \InvalidArgumentException(sprintf('A valid %s object was not set.', TransportInterface::class));
+            }
+        }
+
+        $this->transport = $transport;
+    }
+
+    /**
+     * Get an option from the HTTP client.
+     *
+     * @param   string  $key      The name of the option to get.
+     * @param   mixed   $default  The default value if the option is not set.
+     *
+     * @return  mixed  The option value.
+     *
+     * @since   1.0
+     */
+    public function getOption($key, $default = null)
+    {
+        return $this->options[$key] ?? $default;
+    }
+
+    /**
+     * Set an option for the HTTP client.
+     *
+     * @param   string  $key    The name of the option to set.
+     * @param   mixed   $value  The option value to set.
+     *
+     * @return  $this
+     *
+     * @since   1.0
+     */
+    public function setOption($key, $value)
+    {
+        $this->options[$key] = $value;
+
+        return $this;
+    }
+
+    /**
+     * Method to send the OPTIONS command to the server.
+     *
+     * @param   string|UriInterface  $url      The URI to the resource to request.
+     * @param   array                $headers  An array of request headers to send with the request.
+     * @param   integer              $timeout  Read timeout in seconds.
+     *
+     * @return  Response
+     *
+     * @since   1.0
+     */
+    public function options($url, array $headers = [], $timeout = null)
+    {
+        return $this->makeTransportRequest('OPTIONS', $url, null, $headers, $timeout);
+    }
+
+    /**
+     * Method to send the HEAD command to the server.
+     *
+     * @param   string|UriInterface  $url      The URI to the resource to request.
+     * @param   array                $headers  An array of request headers to send with the request.
+     * @param   integer              $timeout  Read timeout in seconds.
+     *
+     * @return  Response
+     *
+     * @since   1.0
+     */
+    public function head($url, array $headers = [], $timeout = null)
+    {
+        return $this->makeTransportRequest('HEAD', $url, null, $headers, $timeout);
+    }
+
+    /**
+     * Method to send the GET command to the server.
+     *
+     * @param   string|UriInterface  $url      The URI to the resource to request.
+     * @param   array                $headers  An array of request headers to send with the request.
+     * @param   integer              $timeout  Read timeout in seconds.
+     *
+     * @return  Response
+     *
+     * @since   1.0
+     */
+    public function get($url, array $headers = [], $timeout = null)
+    {
+        return $this->makeTransportRequest('GET', $url, null, $headers, $timeout);
+    }
+
+    /**
+     * Method to send the POST command to the server.
+     *
+     * @param   string|UriInterface  $url      The URI to the resource to request.
+     * @param   mixed                $data     Either an associative array or a string to be sent with the request.
+     * @param   array                $headers  An array of request headers to send with the request.
+     * @param   integer              $timeout  Read timeout in seconds.
+     *
+     * @return  Response
+     *
+     * @since   1.0
+     */
+    public function post($url, $data, array $headers = [], $timeout = null)
+    {
+        return $this->makeTransportRequest('POST', $url, $data, $headers, $timeout);
+    }
+
+    /**
+     * Method to send the PUT command to the server.
+     *
+     * @param   string|UriInterface  $url      The URI to the resource to request.
+     * @param   mixed                $data     Either an associative array or a string to be sent with the request.
+     * @param   array                $headers  An array of request headers to send with the request.
+     * @param   integer              $timeout  Read timeout in seconds.
+     *
+     * @return  Response
+     *
+     * @since   1.0
+     */
+    public function put($url, $data, array $headers = [], $timeout = null)
+    {
+        return $this->makeTransportRequest('PUT', $url, $data, $headers, $timeout);
+    }
+
+    /**
+     * Method to send the DELETE command to the server.
+     *
+     * @param   string|UriInterface  $url      The URI to the resource to request.
+     * @param   array                $headers  An array of request headers to send with the request.
+     * @param   integer              $timeout  Read timeout in seconds.
+     * @param   mixed                $data     Either an associative array or a string to be sent with the request.
+     *
+     * @return  Response
+     *
+     * @since   1.0
+     */
+    public function delete($url, array $headers = [], $timeout = null, $data = null)
+    {
+        return $this->makeTransportRequest('DELETE', $url, $data, $headers, $timeout);
+    }
+
+    /**
+     * Method to send the TRACE command to the server.
+     *
+     * @param   string|UriInterface  $url      The URI to the resource to request.
+     * @param   array                $headers  An array of request headers to send with the request.
+     * @param   integer              $timeout  Read timeout in seconds.
+     *
+     * @return  Response
+     *
+     * @since   1.0
+     */
+    public function trace($url, array $headers = [], $timeout = null)
+    {
+        return $this->makeTransportRequest('TRACE', $url, null, $headers, $timeout);
+    }
+
+    /**
+     * Method to send the PATCH command to the server.
+     *
+     * @param   string|UriInterface  $url      The URI to the resource to request.
+     * @param   mixed                $data     Either an associative array or a string to be sent with the request.
+     * @param   array                $headers  An array of request headers to send with the request.
+     * @param   integer              $timeout  Read timeout in seconds.
+     *
+     * @return  Response
+     *
+     * @since   1.0
+     */
+    public function patch($url, $data, array $headers = [], $timeout = null)
+    {
+        return $this->makeTransportRequest('PATCH', $url, $data, $headers, $timeout);
+    }
+
+    /**
+     * Sends a PSR-7 request and returns a PSR-7 response.
+     *
+     * @param   RequestInterface  $request  The PSR-7 request object.
+     *
+     * @return  ResponseInterface|Response
+     *
+     * @since   2.0.0
+     */
+    public function sendRequest(RequestInterface $request): ResponseInterface
+    {
+        $data = $request->getBody()->getContents();
+
+        return $this->makeTransportRequest(
+            $request->getMethod(),
+            new Uri((string) $request->getUri()),
+            empty($data) ? null : $data,
+            $request->getHeaders()
+        );
+    }
+
+    /**
+     * Send a request to the server and return a Response object with the response.
+     *
+     * @param   string               $method   The HTTP method for sending the request.
+     * @param   string|UriInterface  $url      The URI to the resource to request.
+     * @param   mixed                $data     Either an associative array or a string to be sent with the request.
+     * @param   array                $headers  An array of request headers to send with the request.
+     * @param   integer              $timeout  Read timeout in seconds.
+     *
+     * @return  Response
+     *
+     * @since   1.0
+     * @throws  \InvalidArgumentException
+     */
+    protected function makeTransportRequest($method, $url, $data = null, array $headers = [], $timeout = null)
+    {
+        // Look for headers set in the options.
+        if (isset($this->options['headers'])) {
+            $temp = (array) $this->options['headers'];
+
+            foreach ($temp as $key => $val) {
+                if (!isset($headers[$key])) {
+                    $headers[$key] = $val;
+                }
+            }
+        }
+
+        // Look for timeout set in the options.
+        if ($timeout === null && isset($this->options['timeout'])) {
+            $timeout = $this->options['timeout'];
+        }
+
+        $userAgent = isset($this->options['userAgent']) ? $this->options['userAgent'] : null;
+
+        // Convert to a Uri object if we were given a string
+        if (\is_string($url)) {
+            $url = new Uri($url);
+        } elseif (!($url instanceof UriInterface)) {
+            throw new \InvalidArgumentException(
+                sprintf(
+                    'A string or %s object must be provided, a "%s" was provided.',
+                    UriInterface::class,
+                    \gettype($url)
+                )
+            );
+        }
+
+        return $this->transport->request($method, $url, $data, $headers, $timeout, $userAgent);
+    }
+}

libraries/vendor/joomla/http/src/HttpFactory.php

@@ -0,0 +1,125 @@
+<?php
+
+/**
+ * Part of the Joomla Framework Http Package
+ *
+ * @copyright  Copyright (C) 2005 - 2021 Open Source Matters, Inc. All rights reserved.
+ * @license    GNU General Public License version 2 or later; see LICENSE
+ */
+
+namespace Joomla\Http;
+
+/**
+ * HTTP factory class.
+ *
+ * @since  1.0
+ */
+class HttpFactory
+{
+    /**
+     * Method to create an Http instance.
+     *
+     * @param   array|\ArrayAccess  $options   Client options array.
+     * @param   array|string        $adapters  Adapter (string) or queue of adapters (array) to use for communication.
+     *
+     * @return  Http
+     *
+     * @since   1.0
+     * @throws  \InvalidArgumentException
+     * @throws  \RuntimeException
+     */
+    public function getHttp($options = [], $adapters = null)
+    {
+        if (!\is_array($options) && !($options instanceof \ArrayAccess)) {
+            throw new \InvalidArgumentException(
+                'The options param must be an array or implement the ArrayAccess interface.'
+            );
+        }
+
+        if (!$driver = $this->getAvailableDriver($options, $adapters)) {
+            throw new \RuntimeException('No transport driver available.');
+        }
+
+        return new Http($options, $driver);
+    }
+
+    /**
+     * Finds an available TransportInterface object for communication
+     *
+     * @param   array|\ArrayAccess  $options  Options for creating TransportInterface object
+     * @param   array|string        $default  Adapter (string) or queue of adapters (array) to use
+     *
+     * @return  TransportInterface|boolean  Interface sub-class or boolean false if no adapters are available
+     *
+     * @since   1.0
+     * @throws  \InvalidArgumentException
+     */
+    public function getAvailableDriver($options = [], $default = null)
+    {
+        if (!\is_array($options) && !($options instanceof \ArrayAccess)) {
+            throw new \InvalidArgumentException(
+                'The options param must be an array or implement the ArrayAccess interface.'
+            );
+        }
+
+        if ($default === null) {
+            $availableAdapters = $this->getHttpTransports();
+        } else {
+            settype($default, 'array');
+            $availableAdapters = $default;
+        }
+
+        // Check if there is at least one available http transport adapter
+        if (!\count($availableAdapters)) {
+            return false;
+        }
+
+        foreach ($availableAdapters as $adapter) {
+            $class = __NAMESPACE__ . '\\Transport\\' . ucfirst($adapter);
+
+            if (class_exists($class)) {
+                if ($class::isSupported()) {
+                    return new $class($options);
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Get the HTTP transport handlers
+     *
+     * @return  string[]  An array of available transport handler types
+     *
+     * @since   1.0
+     */
+    public function getHttpTransports()
+    {
+        $names    = [];
+        $iterator = new \DirectoryIterator(__DIR__ . '/Transport');
+
+        /** @var \DirectoryIterator $file */
+        foreach ($iterator as $file) {
+            $fileName = $file->getFilename();
+
+            // Only load for php files.
+            if ($file->isFile() && $file->getExtension() == 'php') {
+                $names[] = substr($fileName, 0, strrpos($fileName, '.'));
+            }
+        }
+
+        // Keep alphabetical order across all environments
+        sort($names);
+
+        // If curl is available set it to the first position
+        $key = array_search('Curl', $names);
+
+        if ($key) {
+            unset($names[$key]);
+            array_unshift($names, 'Curl');
+        }
+
+        return $names;
+    }
+}

libraries/vendor/joomla/http/src/Response.php

@@ -0,0 +1,63 @@
+<?php
+
+/**
+ * Part of the Joomla Framework Http Package
+ *
+ * @copyright  Copyright (C) 2005 - 2021 Open Source Matters, Inc. All rights reserved.
+ * @license    GNU General Public License version 2 or later; see LICENSE
+ */
+
+namespace Joomla\Http;
+
+use Laminas\Diactoros\Response as PsrResponse;
+
+/**
+ * HTTP response data object class.
+ *
+ * @property-read  string   $body     The response body as a string
+ * @property-read  integer  $code     The status code of the response
+ * @property-read  array    $headers  The headers as an array
+ *
+ * @since  1.0
+ */
+class Response extends PsrResponse
+{
+    /**
+     * Magic getter for backward compatibility with the 1.x API
+     *
+     * @param   string  $name  The variable to return
+     *
+     * @return  mixed
+     *
+     * @since   2.0.0
+     * @deprecated  3.0  Access data via the PSR-7 ResponseInterface instead
+     */
+    public function __get($name)
+    {
+        switch (strtolower($name)) {
+            case 'body':
+                return (string) $this->getBody();
+
+            case 'code':
+                return $this->getStatusCode();
+
+            case 'headers':
+                return $this->getHeaders();
+
+            default:
+                $trace = debug_backtrace();
+
+                trigger_error(
+                    sprintf(
+                        'Undefined property via __get(): %s in %s on line %s',
+                        $name,
+                        $trace[0]['file'],
+                        $trace[0]['line']
+                    ),
+                    E_USER_NOTICE
+                );
+
+                break;
+        }
+    }
+}

libraries/vendor/joomla/http/src/Transport/Curl.php

@@ -0,0 +1,332 @@
+<?php
+
+/**
+ * Part of the Joomla Framework Http Package
+ *
+ * @copyright  Copyright (C) 2005 - 2021 Open Source Matters, Inc. All rights reserved.
+ * @license    GNU General Public License version 2 or later; see LICENSE
+ */
+
+namespace Joomla\Http\Transport;
+
+use Composer\CaBundle\CaBundle;
+use Joomla\Http\AbstractTransport;
+use Joomla\Http\Exception\InvalidResponseCodeException;
+use Joomla\Http\Response;
+use Joomla\Uri\UriInterface;
+use Laminas\Diactoros\Stream as StreamResponse;
+
+/**
+ * HTTP transport class for using cURL.
+ *
+ * @since  1.0
+ */
+class Curl extends AbstractTransport
+{
+    /**
+     * Send a request to the server and return a Response object with the response.
+     *
+     * @param   string        $method     The HTTP method for sending the request.
+     * @param   UriInterface  $uri        The URI to the resource to request.
+     * @param   mixed         $data       Either an associative array or a string to be sent with the request.
+     * @param   array         $headers    An array of request headers to send with the request.
+     * @param   integer       $timeout    Read timeout in seconds.
+     * @param   string        $userAgent  The optional user agent string to send with the request.
+     *
+     * @return  Response
+     *
+     * @since   1.0
+     * @throws  \RuntimeException
+     */
+    public function request($method, UriInterface $uri, $data = null, array $headers = [], $timeout = null, $userAgent = null)
+    {
+        // Setup the cURL handle.
+        $ch = curl_init();
+
+        // Initialize the certificate store
+        $this->setCAOptionAndValue($ch);
+
+        $options = [];
+
+        // Set the request method.
+        switch (strtoupper($method)) {
+            case 'GET':
+                $options[\CURLOPT_HTTPGET] = true;
+
+                break;
+
+            case 'POST':
+                $options[\CURLOPT_POST] = true;
+
+                break;
+
+            default:
+                $options[\CURLOPT_CUSTOMREQUEST] = strtoupper($method);
+
+                break;
+        }
+
+        // Don't wait for body when $method is HEAD
+        $options[\CURLOPT_NOBODY] = ($method === 'HEAD');
+
+        // Initialize the certificate store
+        $options[CURLOPT_CAINFO] = $this->getOption('curl.certpath', CaBundle::getSystemCaRootBundlePath());
+
+        // If data exists let's encode it and make sure our Content-type header is set.
+        if (isset($data)) {
+            // If the data is a scalar value simply add it to the cURL post fields.
+            if (is_scalar($data) || (isset($headers['Content-Type']) && strpos($headers['Content-Type'], 'multipart/form-data') === 0)) {
+                $options[\CURLOPT_POSTFIELDS] = $data;
+            } else {
+                // Otherwise we need to encode the value first.
+                $options[\CURLOPT_POSTFIELDS] = http_build_query($data);
+            }
+
+            if (!isset($headers['Content-Type'])) {
+                $headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=utf-8';
+            }
+
+            // Add the relevant headers.
+            if (is_scalar($options[\CURLOPT_POSTFIELDS])) {
+                $headers['Content-Length'] = \strlen($options[\CURLOPT_POSTFIELDS]);
+            }
+        }
+
+        // Build the headers string for the request.
+        $headerArray = [];
+
+        if (!empty($headers)) {
+            foreach ($headers as $key => $value) {
+                if (\is_array($value)) {
+                    foreach ($value as $header) {
+                        $headerArray[] = "$key: $header";
+                    }
+                } else {
+                    $headerArray[] = "$key: $value";
+                }
+            }
+
+            // Add the headers string into the stream context options array.
+            $options[\CURLOPT_HTTPHEADER] = $headerArray;
+        }
+
+        // Curl needs the accepted encoding header as option
+        if (isset($headers['Accept-Encoding'])) {
+            $options[\CURLOPT_ENCODING] = $headers['Accept-Encoding'];
+        }
+
+        // If an explicit timeout is given use it.
+        if (isset($timeout)) {
+            $options[\CURLOPT_TIMEOUT]        = (int) $timeout;
+            $options[\CURLOPT_CONNECTTIMEOUT] = (int) $timeout;
+        }
+
+        // If an explicit user agent is given use it.
+        if (isset($userAgent)) {
+            $options[\CURLOPT_USERAGENT] = $userAgent;
+        }
+
+        // Set the request URL.
+        $options[\CURLOPT_URL] = (string) $uri;
+
+        // We want our headers. :-)
+        $options[\CURLOPT_HEADER] = true;
+
+        // Return it... echoing it would be tacky.
+        $options[\CURLOPT_RETURNTRANSFER] = true;
+
+        // Override the Expect header to prevent cURL from confusing itself in its own stupidity.
+        // Link: http://the-stickman.com/web-development/php-and-curl-disabling-100-continue-header/
+        $options[\CURLOPT_HTTPHEADER][] = 'Expect:';
+
+        // Follow redirects if server config allows
+        if ($this->redirectsAllowed()) {
+            $options[\CURLOPT_FOLLOWLOCATION] = (bool) $this->getOption('follow_location', true);
+        }
+
+        // Authentication, if needed
+        if ($this->getOption('userauth') && $this->getOption('passwordauth')) {
+            $options[\CURLOPT_USERPWD]  = $this->getOption('userauth') . ':' . $this->getOption('passwordauth');
+            $options[\CURLOPT_HTTPAUTH] = CURLAUTH_BASIC;
+        }
+
+        // Configure protocol version
+        if ($protocolVersion = $this->getOption('protocolVersion')) {
+            $options[\CURLOPT_HTTP_VERSION] = $this->mapProtocolVersion($protocolVersion);
+        }
+
+        // Set any custom transport options
+        foreach ($this->getOption('transport.curl', []) as $key => $value) {
+            $options[$key] = $value;
+        }
+
+        // Set the cURL options.
+        curl_setopt_array($ch, $options);
+
+        // Execute the request and close the connection.
+        $content = curl_exec($ch);
+
+        // Check if the content is a string. If it is not, it must be an error.
+        if (!\is_string($content)) {
+            $message = curl_error($ch);
+
+            if (empty($message)) {
+                // Error but nothing from cURL? Create our own
+                $message = 'No HTTP response received';
+            }
+
+            throw new \RuntimeException($message);
+        }
+
+        // Get the request information.
+        $info = curl_getinfo($ch);
+
+        // Close the connection.
+        curl_close($ch);
+
+        return $this->getResponse($content, $info);
+    }
+
+    /**
+     * Configure the cURL resources with the appropriate root certificates.
+     *
+     * @param   \CurlHandle  $ch  The cURL resource you want to configure the certificates on.
+     *
+     * @return  void
+     *
+     * @since   1.3.2
+     */
+    protected function setCAOptionAndValue($ch)
+    {
+        if ($certpath = $this->getOption('curl.certpath')) {
+            // Option is passed to a .PEM file.
+            curl_setopt($ch, \CURLOPT_CAINFO, $certpath);
+
+            return;
+        }
+
+        $caPathOrFile = CaBundle::getSystemCaRootBundlePath();
+
+        if (is_dir($caPathOrFile) || (is_link($caPathOrFile) && is_dir(readlink($caPathOrFile)))) {
+            curl_setopt($ch, \CURLOPT_CAPATH, $caPathOrFile);
+
+            return;
+        }
+
+        curl_setopt($ch, \CURLOPT_CAINFO, $caPathOrFile);
+    }
+
+    /**
+     * Method to get a response object from a server response.
+     *
+     * @param   string  $content  The complete server response, including headers
+     *                            as a string if the response has no errors.
+     * @param   array   $info     The cURL request information.
+     *
+     * @return  Response
+     *
+     * @since   1.0
+     * @throws  InvalidResponseCodeException
+     */
+    protected function getResponse($content, $info)
+    {
+        // Try to get header size
+        if (isset($info['header_size'])) {
+            $headerString = trim(substr($content, 0, $info['header_size']));
+            $headerArray  = explode("\r\n\r\n", $headerString);
+
+            // Get the last set of response headers as an array.
+            $headers = explode("\r\n", array_pop($headerArray));
+
+            // Set the body for the response.
+            $body = substr($content, $info['header_size']);
+        } else {
+            // Fallback and try to guess header count by redirect count
+            // Get the number of redirects that occurred.
+            $redirects = $info['redirect_count'] ?? 0;
+
+            /*
+             * Split the response into headers and body. If cURL encountered redirects, the headers for the redirected requests will
+             * also be included. So we split the response into header + body + the number of redirects and only use the last two
+             * sections which should be the last set of headers and the actual body.
+             */
+            $response = explode("\r\n\r\n", $content, 2 + $redirects);
+
+            // Set the body for the response.
+            $body = array_pop($response);
+
+            // Get the last set of response headers as an array.
+            $headers = explode("\r\n", array_pop($response));
+        }
+
+        // Get the response code from the first offset of the response headers.
+        preg_match('/[0-9]{3}/', array_shift($headers), $matches);
+
+        $code = \count($matches) ? $matches[0] : null;
+
+        if (!is_numeric($code)) {
+            // No valid response code was detected.
+            throw new InvalidResponseCodeException('No HTTP response code found.');
+        }
+
+        $statusCode      = (int) $code;
+        $verifiedHeaders = $this->processHeaders($headers);
+
+        $streamInterface = new StreamResponse('php://memory', 'rw');
+        $streamInterface->write($body);
+
+        return new Response($streamInterface, $statusCode, $verifiedHeaders);
+    }
+
+    /**
+     * Method to check if HTTP transport cURL is available for use
+     *
+     * @return  boolean  True if available, else false
+     *
+     * @since   1.0
+     */
+    public static function isSupported()
+    {
+        return \function_exists('curl_version') && curl_version();
+    }
+
+    /**
+     * Get the cURL constant for a HTTP protocol version
+     *
+     * @param   string  $version  The HTTP protocol version to use
+     *
+     * @return  integer
+     *
+     * @since   1.3.1
+     */
+    private function mapProtocolVersion(string $version): int
+    {
+        switch ($version) {
+            case '1.0':
+                return \CURL_HTTP_VERSION_1_0;
+
+            case '1.1':
+                return \CURL_HTTP_VERSION_1_1;
+
+            case '2.0':
+            case '2':
+                if (\defined('CURL_HTTP_VERSION_2')) {
+                    return \CURL_HTTP_VERSION_2;
+                }
+        }
+
+        return \CURL_HTTP_VERSION_NONE;
+    }
+
+    /**
+     * Check if redirects are allowed
+     *
+     * @return  boolean
+     *
+     * @since   1.2.1
+     */
+    private function redirectsAllowed(): bool
+    {
+        return true;
+    }
+}

libraries/vendor/joomla/http/src/Transport/Socket.php

@@ -0,0 +1,286 @@
+<?php
+
+/**
+ * Part of the Joomla Framework Http Package
+ *
+ * @copyright  Copyright (C) 2005 - 2021 Open Source Matters, Inc. All rights reserved.
+ * @license    GNU General Public License version 2 or later; see LICENSE
+ */
+
+namespace Joomla\Http\Transport;
+
+use Joomla\Http\AbstractTransport;
+use Joomla\Http\Exception\InvalidResponseCodeException;
+use Joomla\Http\Response;
+use Joomla\Uri\Uri;
+use Joomla\Uri\UriInterface;
+use Laminas\Diactoros\Stream as StreamResponse;
+
+/**
+ * HTTP transport class for using sockets directly.
+ *
+ * @since  1.0
+ */
+class Socket extends AbstractTransport
+{
+    /**
+     * Reusable socket connections.
+     *
+     * @var    array
+     * @since  1.0
+     */
+    protected $connections;
+
+    /**
+     * Send a request to the server and return a Response object with the response.
+     *
+     * @param   string        $method     The HTTP method for sending the request.
+     * @param   UriInterface  $uri        The URI to the resource to request.
+     * @param   mixed         $data       Either an associative array or a string to be sent with the request.
+     * @param   array         $headers    An array of request headers to send with the request.
+     * @param   integer       $timeout    Read timeout in seconds.
+     * @param   string        $userAgent  The optional user agent string to send with the request.
+     *
+     * @return  Response
+     *
+     * @since   1.0
+     * @throws  \RuntimeException
+     */
+    public function request($method, UriInterface $uri, $data = null, array $headers = [], $timeout = null, $userAgent = null)
+    {
+        $connection = $this->connect($uri, $timeout);
+
+        // Make sure the connection is alive and valid.
+        if (!\is_resource($connection)) {
+            throw new \RuntimeException('Not connected to server.');
+        }
+
+        // Make sure the connection has not timed out.
+        $meta = stream_get_meta_data($connection);
+
+        if ($meta['timed_out']) {
+            throw new \RuntimeException('Server connection timed out.');
+        }
+
+        // Get the request path from the URI object.
+        $path = $uri->toString(['path', 'query']);
+
+        // If we have data to send make sure our request is setup for it.
+        if (!empty($data)) {
+            // If the data is not a scalar value encode it to be sent with the request.
+            if (!is_scalar($data)) {
+                $data = http_build_query($data);
+            }
+
+            if (!isset($headers['Content-Type'])) {
+                $headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=utf-8';
+            }
+
+            // Add the relevant headers.
+            $headers['Content-Length'] = \strlen($data);
+        }
+
+        // Configure protocol version, use transport's default if not set otherwise.
+        $protocolVersion = $this->getOption('protocolVersion', '1.0');
+
+        // Build the request payload.
+        $request   = [];
+        $request[] = strtoupper($method) . ' ' . ((empty($path)) ? '/' : $path) . ' HTTP/' . $protocolVersion;
+
+        if (!isset($headers['Host'])) {
+            $request[] = 'Host: ' . $uri->getHost();
+        }
+
+        // If an explicit user agent is given use it.
+        if (isset($userAgent)) {
+            $headers['User-Agent'] = $userAgent;
+        }
+
+        // If we have a username then we include basic authentication credentials.
+        if ($uri->getUser()) {
+            $authString               = $uri->getUser() . ':' . $uri->getPass();
+            $headers['Authorization'] = 'Basic ' . base64_encode($authString);
+        }
+
+        // If there are custom headers to send add them to the request payload.
+        if (!empty($headers)) {
+            foreach ($headers as $key => $value) {
+                if (\is_array($value)) {
+                    foreach ($value as $header) {
+                        $request[] = "$key: $header";
+                    }
+                } else {
+                    $request[] = "$key: $value";
+                }
+            }
+        }
+
+        // Authentication, if needed
+        if ($this->getOption('userauth') && $this->getOption('passwordauth')) {
+            $request[] = 'Authorization: Basic ' . base64_encode($this->getOption('userauth') . ':' . $this->getOption('passwordauth'));
+        }
+
+        // Set any custom transport options
+        foreach ($this->getOption('transport.socket', []) as $value) {
+            $request[] = $value;
+        }
+
+        // If we have data to send add it to the request payload.
+        if (!empty($data)) {
+            $request[] = null;
+            $request[] = $data;
+        }
+
+        // Send the request to the server.
+        fwrite($connection, implode("\r\n", $request) . "\r\n\r\n");
+
+        // Get the response data from the server.
+        $content = '';
+
+        while (!feof($connection)) {
+            $content .= fgets($connection, 4096);
+        }
+
+        $content = $this->getResponse($content);
+
+        // Follow Http redirects
+        if ($content->getStatusCode() >= 301 && $content->getStatusCode() < 400 && $content->hasHeader('Location')) {
+            return $this->request($method, new Uri($content->getHeaderLine('Location')), $data, $headers, $timeout, $userAgent);
+        }
+
+        return $content;
+    }
+
+    /**
+     * Method to get a response object from a server response.
+     *
+     * @param   string  $content  The complete server response, including headers.
+     *
+     * @return  Response
+     *
+     * @since   1.0
+     * @throws  \UnexpectedValueException
+     * @throws  InvalidResponseCodeException
+     */
+    protected function getResponse($content)
+    {
+        if (empty($content)) {
+            throw new \UnexpectedValueException('No content in response.');
+        }
+
+        // Split the response into headers and body.
+        $response = explode("\r\n\r\n", $content, 2);
+
+        // Get the response headers as an array.
+        $headers = explode("\r\n", $response[0]);
+
+        // Set the body for the response.
+        $body = empty($response[1]) ? '' : $response[1];
+
+        // Get the response code from the first offset of the response headers.
+        preg_match('/[0-9]{3}/', array_shift($headers), $matches);
+        $code = $matches[0];
+
+        if (!is_numeric($code)) {
+            // No valid response code was detected.
+            throw new InvalidResponseCodeException('No HTTP response code found.');
+        }
+
+        $statusCode      = (int) $code;
+        $verifiedHeaders = $this->processHeaders($headers);
+
+        $streamInterface = new StreamResponse('php://memory', 'rw');
+        $streamInterface->write($body);
+
+        return new Response($streamInterface, $statusCode, $verifiedHeaders);
+    }
+
+    /**
+     * Method to connect to a server and get the resource.
+     *
+     * @param   UriInterface  $uri      The URI to connect with.
+     * @param   integer       $timeout  Read timeout in seconds.
+     *
+     * @return  resource  Socket connection resource.
+     *
+     * @since   1.0
+     * @throws  \RuntimeException
+     */
+    protected function connect(UriInterface $uri, $timeout = null)
+    {
+        $errno = null;
+        $err   = null;
+
+        // Get the host from the uri.
+        $host = ($uri->isSsl()) ? 'ssl://' . $uri->getHost() : $uri->getHost();
+
+        // If the port is not explicitly set in the URI detect it.
+        if (!$uri->getPort()) {
+            $port = ($uri->getScheme() == 'https') ? 443 : 80;
+        } else {
+            // Use the set port.
+            $port = $uri->getPort();
+        }
+
+        // Build the connection key for resource memory caching.
+        $key = md5($host . $port);
+
+        // If the connection already exists, use it.
+        if (!empty($this->connections[$key]) && \is_resource($this->connections[$key])) {
+            // Connection reached EOF, cannot be used anymore
+            $meta = stream_get_meta_data($this->connections[$key]);
+
+            if ($meta['eof']) {
+                if (!fclose($this->connections[$key])) {
+                    throw new \RuntimeException('Cannot close connection');
+                }
+            } elseif (!$meta['timed_out']) {
+                // Make sure the connection has not timed out.
+                return $this->connections[$key];
+            }
+        }
+
+        if (!is_numeric($timeout)) {
+            $timeout = ini_get('default_socket_timeout');
+        }
+
+        // Capture PHP errors
+        error_clear_last();
+
+        // PHP sends a warning if the uri does not exists; we silence it and throw an exception instead.
+        // Attempt to connect to the server
+        $connection = @fsockopen($host, $port, $errno, $err, $timeout);
+
+        if (!$connection) {
+            $error = error_get_last();
+
+            if ($error === null || $error['message'] === '') {
+                // Error but nothing from php? Create our own
+                $error = [
+                    'message' => sprintf('Could not connect to resource %s: %s (%d)', $uri, $err, $errno),
+                ];
+            }
+
+            throw new \RuntimeException($error['message']);
+        }
+
+        // Since the connection was successful let's store it in case we need to use it later.
+        $this->connections[$key] = $connection;
+
+        stream_set_timeout($this->connections[$key], (int) $timeout);
+
+        return $this->connections[$key];
+    }
+
+    /**
+     * Method to check if http transport socket available for use
+     *
+     * @return  boolean   True if available else false
+     *
+     * @since   1.0
+     */
+    public static function isSupported()
+    {
+        return \function_exists('fsockopen') && \is_callable('fsockopen');
+    }
+}

libraries/vendor/joomla/http/src/Transport/Stream.php

@@ -0,0 +1,235 @@
+<?php
+
+/**
+ * Part of the Joomla Framework Http Package
+ *
+ * @copyright  Copyright (C) 2005 - 2021 Open Source Matters, Inc. All rights reserved.
+ * @license    GNU General Public License version 2 or later; see LICENSE
+ */
+
+namespace Joomla\Http\Transport;
+
+use Composer\CaBundle\CaBundle;
+use Joomla\Http\AbstractTransport;
+use Joomla\Http\Exception\InvalidResponseCodeException;
+use Joomla\Http\Response;
+use Joomla\Uri\Uri;
+use Joomla\Uri\UriInterface;
+use Laminas\Diactoros\Stream as StreamResponse;
+
+/**
+ * HTTP transport class for using PHP streams.
+ *
+ * @since  1.0
+ */
+class Stream extends AbstractTransport
+{
+    /**
+     * Send a request to the server and return a Response object with the response.
+     *
+     * @param   string        $method     The HTTP method for sending the request.
+     * @param   UriInterface  $uri        The URI to the resource to request.
+     * @param   mixed         $data       Either an associative array or a string to be sent with the request.
+     * @param   array         $headers    An array of request headers to send with the request.
+     * @param   integer       $timeout    Read timeout in seconds.
+     * @param   string        $userAgent  The optional user agent string to send with the request.
+     *
+     * @return  Response
+     *
+     * @since   1.0
+     * @throws  \RuntimeException
+     */
+    public function request($method, UriInterface $uri, $data = null, array $headers = [], $timeout = null, $userAgent = null)
+    {
+        // Create the stream context options array with the required method offset.
+        $options = ['method' => strtoupper($method)];
+
+        // If data exists let's encode it and make sure our Content-Type header is set.
+        if (isset($data)) {
+            // If the data is a scalar value simply add it to the stream context options.
+            if (is_scalar($data)) {
+                $options['content'] = $data;
+            } else {
+                // Otherwise we need to encode the value first.
+                $options['content'] = http_build_query($data);
+            }
+
+            if (!isset($headers['Content-Type'])) {
+                $headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=utf-8';
+            }
+
+            // Add the relevant headers.
+            $headers['Content-Length'] = \strlen($options['content']);
+        }
+
+        // If an explicit timeout is given user it.
+        if (isset($timeout)) {
+            $options['timeout'] = (int) $timeout;
+        }
+
+        // If an explicit user agent is given use it.
+        if (isset($userAgent)) {
+            $options['user_agent'] = $userAgent;
+        }
+
+        // Ignore HTTP errors so that we can capture them.
+        $options['ignore_errors'] = 1;
+
+        // Follow redirects.
+        $options['follow_location'] = (int) $this->getOption('follow_location', 1);
+
+        // Configure protocol version, use transport's default if not set otherwise.
+        $options['follow_location'] = $this->getOption('protocolVersion', '1.0');
+
+        // Add the proxy configuration if enabled
+        if ($this->getOption('proxy.enabled', false)) {
+            $options['request_fulluri'] = true;
+
+            if ($this->getOption('proxy.host') && $this->getOption('proxy.port')) {
+                $options['proxy'] = $this->getOption('proxy.host') . ':' . (int) $this->getOption('proxy.port');
+            }
+
+            // If authentication details are provided, add those as well
+            if ($this->getOption('proxy.user') && $this->getOption('proxy.password')) {
+                $headers['Proxy-Authorization'] = 'Basic ' . base64_encode($this->getOption('proxy.user') . ':' . $this->getOption('proxy.password'));
+            }
+        }
+
+        // Build the headers string for the request.
+        if (!empty($headers)) {
+            $headerString = '';
+
+            foreach ($headers as $key => $value) {
+                if (\is_array($value)) {
+                    foreach ($value as $header) {
+                        $headerString .= "$key: $header\r\n";
+                    }
+                } else {
+                    $headerString .= "$key: $value\r\n";
+                }
+            }
+
+            // Add the headers string into the stream context options array.
+            $options['header'] = trim($headerString, "\r\n");
+        }
+
+        // Authentication, if needed
+        if ($uri instanceof Uri && $this->getOption('userauth') && $this->getOption('passwordauth')) {
+            $uri->setUser($this->getOption('userauth'));
+            $uri->setPass($this->getOption('passwordauth'));
+        }
+
+        // Set any custom transport options
+        foreach ($this->getOption('transport.stream', []) as $key => $value) {
+            $options[$key] = $value;
+        }
+
+        // Get the current context options.
+        $contextOptions = stream_context_get_options(stream_context_get_default());
+
+        // Add our options to the currently defined options, if any.
+        $contextOptions['http'] = isset($contextOptions['http']) ? array_merge($contextOptions['http'], $options) : $options;
+
+        // Create the stream context for the request.
+        $streamOptions = [
+            'http' => $options,
+            'ssl'  => [
+                'verify_peer'      => true,
+                'verify_depth'     => 5,
+                'verify_peer_name' => true,
+            ],
+        ];
+
+        // The cacert may be a file or path
+        $certpath = $this->getOption('stream.certpath', CaBundle::getSystemCaRootBundlePath());
+
+        if (is_dir($certpath)) {
+            $streamOptions['ssl']['capath'] = $certpath;
+        } else {
+            $streamOptions['ssl']['cafile'] = $certpath;
+        }
+
+        $context = stream_context_create($streamOptions);
+
+        // Capture PHP errors
+        error_clear_last();
+
+        // Open the stream for reading.
+        $stream = @fopen((string) $uri, 'r', false, $context);
+
+        if (!$stream) {
+            $error = error_get_last();
+
+            if ($error === null || $error['message'] === '') {
+                // Error but nothing from php? Create our own
+                $error = [
+                    'message' => sprintf('Could not connect to resource %s', $uri),
+                ];
+            }
+
+            throw new \RuntimeException($error['message']);
+        }
+
+        // Get the metadata for the stream, including response headers.
+        $metadata = stream_get_meta_data($stream);
+
+        // Get the contents from the stream.
+        $content = stream_get_contents($stream);
+
+        // Close the stream.
+        fclose($stream);
+
+        $headers = [];
+
+        if (isset($metadata['wrapper_data']['headers'])) {
+            $headers = $metadata['wrapper_data']['headers'];
+        } elseif (isset($metadata['wrapper_data'])) {
+            $headers = $metadata['wrapper_data'];
+        }
+
+        return $this->getResponse($headers, $content);
+    }
+
+    /**
+     * Method to get a response object from a server response.
+     *
+     * @param   array   $headers  The response headers as an array.
+     * @param   string  $body     The response body as a string.
+     *
+     * @return  Response
+     *
+     * @since   1.0
+     * @throws  InvalidResponseCodeException
+     */
+    protected function getResponse(array $headers, $body)
+    {
+        // Get the response code from the first offset of the response headers.
+        preg_match('/[0-9]{3}/', array_shift($headers), $matches);
+        $code = $matches[0];
+
+        if (!is_numeric($code)) {
+            // No valid response code was detected.
+            throw new InvalidResponseCodeException('No HTTP response code found.');
+        }
+
+        $statusCode      = (int) $code;
+        $verifiedHeaders = $this->processHeaders($headers);
+
+        $streamInterface = new StreamResponse('php://memory', 'rw');
+        $streamInterface->write($body);
+
+        return new Response($streamInterface, $statusCode, $verifiedHeaders);
+    }
+
+    /**
+     * Method to check if http transport stream available for use
+     *
+     * @return  boolean  True if available else false
+     *
+     * @since   1.0
+     */
+    public static function isSupported()
+    {
+        return \function_exists('fopen') && \is_callable('fopen') && ini_get('allow_url_fopen');
+    }
+}

libraries/vendor/joomla/http/src/TransportInterface.php

@@ -0,0 +1,45 @@
+<?php
+
+/**
+ * Part of the Joomla Framework Http Package
+ *
+ * @copyright  Copyright (C) 2005 - 2021 Open Source Matters, Inc. All rights reserved.
+ * @license    GNU General Public License version 2 or later; see LICENSE
+ */
+
+namespace Joomla\Http;
+
+use Joomla\Uri\UriInterface;
+
+/**
+ * HTTP transport class interface.
+ *
+ * @since  1.0
+ */
+interface TransportInterface
+{
+    /**
+     * Send a request to the server and return a Response object with the response.
+     *
+     * @param   string        $method     The HTTP method for sending the request.
+     * @param   UriInterface  $uri        The URI to the resource to request.
+     * @param   mixed         $data       Either an associative array or a string to be sent with the request.
+     * @param   array         $headers    An array of request headers to send with the request.
+     * @param   integer       $timeout    Read timeout in seconds.
+     * @param   string        $userAgent  The optional user agent string to send with the request.
+     *
+     * @return  Response
+     *
+     * @since   1.0
+     */
+    public function request($method, UriInterface $uri, $data = null, array $headers = [], $timeout = null, $userAgent = null);
+
+    /**
+     * Method to check if HTTP transport layer available for using
+     *
+     * @return  boolean  True if available else false
+     *
+     * @since   1.0
+     */
+    public static function isSupported();
+}