Spade
Mini Shell
| Directory:~$ /home/lmsyaran/www/joomla5/libraries/src/Http/Transport/ |
| [Home] [System Details] [Kill Me] |
<?php
/**
* Joomla! Content Management System
*
* @copyright (C) 2011 Open Source Matters, Inc.
<https://www.joomla.org>
* @license GNU General Public License version 2 or later; see
LICENSE.txt
*/
namespace Joomla\CMS\Http\Transport;
use Composer\CaBundle\CaBundle;
use Joomla\CMS\Factory;
use Joomla\CMS\Http\Response;
use Joomla\CMS\Http\TransportInterface;
use Joomla\Http\AbstractTransport;
use Joomla\Http\Exception\InvalidResponseCodeException;
use Joomla\Uri\Uri;
use Joomla\Uri\UriInterface;
use Laminas\Diactoros\Stream as StreamResponse;
// phpcs:disable PSR1.Files.SideEffects
\defined('_JEXEC') or die;
// phpcs:enable PSR1.Files.SideEffects
/**
* HTTP transport class for using PHP streams.
*
* @since 1.7.3
*/
class StreamTransport extends AbstractTransport implements
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.7.3
* @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);
// Set any custom transport options
foreach ($this->getOption('transport.stream', []) as
$key => $value) {
$options[$key] = $value;
}
// Add the proxy configuration, if any.
$app = Factory::getApplication();
if ($app->get('proxy_enable')) {
$options['proxy'] =
$app->get('proxy_host') . ':' .
$app->get('proxy_port');
$options['request_fulluri'] = true;
// Put any required authorization into the headers array to be
handled later
// @todo: do we need to support any auth type other than Basic?
if ($user = $app->get('proxy_user')) {
$auth = base64_encode($app->get('proxy_user')
. ':' . $app->get('proxy_pass'));
$headers['Proxy-Authorization'] = 'Basic
' . $auth;
}
}
// Build the headers string for the request.
$headerEntries = [];
if (isset($headers)) {
foreach ($headers as $key => $value) {
$headerEntries[] = $key . ': ' . $value;
}
// Add the headers string into the stream context options
array.
$options['header'] = implode("\r\n",
$headerEntries);
}
// Get the current context options.
$contextOptions =
stream_context_get_options(stream_context_get_default());
// Add our options to the current ones, if any.
$contextOptions['http'] =
isset($contextOptions['http']) ?
array_merge($contextOptions['http'], $options) : $options;
// Create the stream context for the request.
$context = stream_context_create(
[
'http' => $options,
'ssl' => [
'verify_peer' => true,
'cafile' =>
$this->getOption('stream.certpath',
CaBundle::getBundledCaBundlePath()),
'verify_depth' => 5,
'verify_peer_name' => true,
],
]
);
// Authentication, if needed
if ($uri instanceof Uri &&
$this->getOption('userauth') &&
$this->getOption('passwordauth')) {
$uri->setUser($this->getOption('userauth'));
$uri->setPass($this->getOption('passwordauth'));
}
// Capture PHP errors
// PHP sends a warning if the uri does not exist; we silence it and
throw an exception instead.
set_error_handler(static function ($errno, $err) {
throw new \Exception($err);
}, \E_WARNING);
try {
// Open the stream for reading.
$stream = fopen((string) $uri, 'r', false, $context);
if (!$stream) {
// Error but nothing from php? Create our own
throw new \Exception(sprintf('Could not connect to
resource: %s', $uri));
}
} catch (\Exception $e) {
throw new \RuntimeException($e->getMessage());
} finally {
restore_error_handler();
}
// 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);
if
(isset($metadata['wrapper_data']['headers'])) {
$headers =
$metadata['wrapper_data']['headers'];
} elseif (isset($metadata['wrapper_data'])) {
$headers = $metadata['wrapper_data'];
} else {
$headers = [];
}
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.7.3
* @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 3.0.0
*/
public static function isSupported()
{
return \function_exists('fopen') &&
\is_callable('fopen') &&
\ini_get('allow_url_fopen');
}
}