Your IP : 18.188.78.86
<?php
/**
* Bitrix Framework
* @package bitrix
* @subpackage main
* @copyright 2001-2023 Bitrix
*/
namespace Bitrix\Main\Web;
use Bitrix\Main\IO;
use Bitrix\Main\Config\Configuration;
use Bitrix\Main\ArgumentException;
use Psr\Log;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Client\ClientInterface;
use Psr\Http\Client\ClientExceptionInterface;
use Psr\Http\Client\NetworkExceptionInterface;
use Http\Promise\Promise as PromiseInterface;
class HttpClient implements Log\LoggerAwareInterface, ClientInterface, Http\DebugInterface
{
use Log\LoggerAwareTrait;
use Http\DebugInterfaceTrait;
const HTTP_1_0 = '1.0';
const HTTP_1_1 = '1.1';
const HTTP_GET = 'GET';
const HTTP_POST = 'POST';
const HTTP_PUT = 'PUT';
const HTTP_HEAD = 'HEAD';
const HTTP_PATCH = 'PATCH';
const HTTP_DELETE = 'DELETE';
const HTTP_OPTIONS = 'OPTIONS';
const DEFAULT_SOCKET_TIMEOUT = 30;
const DEFAULT_STREAM_TIMEOUT = 60;
const DEFAULT_STREAM_TIMEOUT_NO_WAIT = 1;
protected $proxyHost = '';
protected $proxyPort = 80;
protected $proxyUser = '';
protected $proxyPassword = '';
protected $socketTimeout = self::DEFAULT_SOCKET_TIMEOUT;
protected $streamTimeout = self::DEFAULT_STREAM_TIMEOUT;
protected $waitResponse = true;
protected $redirect = true;
protected $redirectMax = 5;
protected $redirectCount = 0;
protected $compress = false;
protected $version = self::HTTP_1_1;
protected $requestCharset = '';
protected $sslVerify = true;
protected $bodyLengthMax = 0;
protected $privateIp = true;
protected $contextOptions = [];
protected $outputStream = null;
protected $useCurl = false;
protected $curlLogFile = null;
protected $shouldFetchBody = null;
protected HttpHeaders $headers;
protected ?Http\Request $request = null;
protected ?Http\Response $response = null;
protected ?Http\Queue $queue = null;
protected ?IpAddress $effectiveIp = null;
protected $effectiveUrl;
protected $error = [];
/**
* @param array|null $options Optional array with options:
* "redirect" bool Follow redirects (default true).
* "redirectMax" int Maximum number of redirects (default 5).
* "waitResponse" bool Read the body or disconnect just after reading headers (default true).
* "socketTimeout" int Connection timeout in seconds (default 30).
* "streamTimeout" int Stream reading timeout in seconds (default 60 for waitResponse == true and 1 for waitResponse == false).
* "version" string HTTP version (HttpClient::HTTP_1_0, HttpClient::HTTP_1_1) (default "1.1").
* "proxyHost" string Proxy host name/address.
* "proxyPort" int Proxy port number.
* "proxyUser" string Proxy username.
* "proxyPassword" string Proxy password.
* "compress" bool Accept gzip encoding (default false).
* "charset" string Charset for body in POST and PUT.
* "disableSslVerification" bool Pass true to disable ssl check.
* "bodyLengthMax" int Maximum length of the body.
* "privateIp" bool Enable or disable requests to private IPs (default true).
* "debugLevel" int Debug level using HttpDebug::* constants.
* "cookies" array of cookies for HTTP request.
* "headers" array of headers for HTTP request.
* "useCurl" bool Enable CURL (default false).
* "curlLogFile" string Full path to CURL log file.
* Almost all options can be set separately with setters.
*/
public function __construct(array $options = null)
{
$this->headers = new HttpHeaders();
if ($options === null)
{
$options = [];
}
$defaultOptions = Configuration::getValue('http_client_options');
if ($defaultOptions !== null)
{
$options += $defaultOptions;
}
if (!empty($options))
{
if (isset($options['redirect']))
{
$this->setRedirect($options["redirect"], $options["redirectMax"] ?? null);
}
if (isset($options['waitResponse']))
{
$this->waitResponse($options['waitResponse']);
}
if (isset($options['socketTimeout']))
{
$this->setTimeout($options['socketTimeout']);
}
if (isset($options['streamTimeout']))
{
$this->setStreamTimeout($options['streamTimeout']);
}
if (isset($options['version']))
{
$this->setVersion($options['version']);
}
if (isset($options['proxyHost']))
{
$this->setProxy($options['proxyHost'], $options['proxyPort'] ?? null, $options['proxyUser'] ?? null, $options['proxyPassword'] ?? null);
}
if (isset($options['compress']))
{
$this->setCompress($options['compress']);
}
if (isset($options['charset']))
{
$this->setCharset($options['charset']);
}
if (isset($options['disableSslVerification']) && $options['disableSslVerification'] === true)
{
$this->disableSslVerification();
}
if (isset($options['bodyLengthMax']))
{
$this->setBodyLengthMax($options['bodyLengthMax']);
}
if (isset($options['privateIp']))
{
$this->setPrivateIp($options['privateIp']);
}
if (isset($options['debugLevel']))
{
$this->setDebugLevel((int)$options['debugLevel']);
}
if (isset($options['cookies']))
{
$this->setCookies($options['cookies']);
}
if (isset($options['headers']))
{
$this->setHeaders($options['headers']);
}
if (isset($options['useCurl']))
{
$this->useCurl = (bool)$options['useCurl'];
}
if (isset($options['curlLogFile']))
{
$this->curlLogFile = $options['curlLogFile'];
}
}
if ($this->useCurl && !function_exists('curl_init'))
{
$this->useCurl = false;
}
}
/**
* Performs GET request.
*
* @param string $url Absolute URI e.g. "http://user:pass @ host:port/path/?query".
* @return string|bool Response entity string or false on error. Note, it's empty string if outputStream is set.
*/
public function get($url)
{
if ($this->query(Http\Method::GET, $url))
{
return $this->getResult();
}
return false;
}
/**
* Performs HEAD request.
*
* @param string $url Absolute URI e.g. "http://user:pass @ host:port/path/?query"
* @return HttpHeaders|bool Response headers or false on error.
*/
public function head($url)
{
if ($this->query(Http\Method::HEAD, $url))
{
return $this->getHeaders();
}
return false;
}
/**
* Performs POST request.
*
* @param string $url Absolute URI e.g. "http://user:pass @ host:port/path/?query".
* @param array|string|resource $postData Entity of POST/PUT request. If it's resource handler then data will be read directly from the stream.
* @param boolean $multipart Whether to use multipart/form-data encoding. If true, method accepts file as a resource or as an array with keys 'resource' (or 'content') and optionally 'filename' and 'contentType'
* @return string|bool Response entity string or false on error. Note, it's empty string if outputStream is set.
*/
public function post($url, $postData = null, $multipart = false)
{
if ($multipart)
{
$postData = $this->prepareMultipart($postData);
if ($postData === false)
{
return false;
}
}
if ($this->query(Http\Method::POST, $url, $postData))
{
return $this->getResult();
}
return false;
}
/**
* Performs multipart/form-data encoding.
* Accepts file as a resource or as an array with keys 'resource' (or 'content') and optionally 'filename' and 'contentType'.
*
* @param array|string|resource $postData Entity of POST/PUT request
* @return Http\MultipartStream|bool False on error
*/
protected function prepareMultipart($postData)
{
if (is_array($postData))
{
try
{
$data = new Http\MultipartStream($postData);
$this->setHeader('Content-type', 'multipart/form-data; boundary=' . $data->getBoundary());
return $data;
}
catch (ArgumentException $e)
{
$this->addError('MULTIPART', $e->getMessage(), true);
return false;
}
}
return $postData;
}
/**
* Perfoms HTTP request.
*
* @param string $method HTTP method (GET, POST, etc.). Note, it must be in UPPERCASE.
* @param string $url Absolute URI e.g. "http://user:pass @ host:port/path/?query".
* @param array|string|resource|Http\Stream $entityBody Entity body of the request. If it's resource handler then data will be read directly from the stream.
* @return bool Query result (true or false). Response entity string can be got via getResult() method. Note, it's empty string if outputStream is set.
*/
public function query($method, $url, $entityBody = null)
{
$this->effectiveUrl = $url;
$this->effectiveIp = null;
$this->error = [];
if (is_array($entityBody))
{
$entityBody = new Http\FormStream($entityBody);
}
if ($entityBody instanceof Http\Stream)
{
$body = $entityBody;
}
elseif (is_resource($entityBody))
{
$body = new Http\Stream($entityBody);
}
else
{
$body = new Http\Stream('php://temp', 'r+');
$body->write($entityBody ?? '');
}
$this->redirectCount = 0;
while (true)
{
//Only absoluteURI is accepted
//Location response-header field must be absoluteURI either
$uri = new Uri($this->effectiveUrl);
// make a PSR-7 request
$request = new Http\Request($method, $uri, $this->headers->getHeaders(), $body, $this->version);
try
{
// PSR-18 magic is here
$this->sendRequest($request);
}
catch (ClientExceptionInterface $e)
{
// compatibility mode
if ($e instanceof NetworkExceptionInterface)
{
$this->addError('NETWORK', $e->getMessage());
}
return false;
}
if (!$this->waitResponse)
{
return true;
}
if ($this->redirect && ($location = $this->getHeaders()->get('Location')) !== null && $location != '')
{
if ($this->redirectCount < $this->redirectMax)
{
// there can be different host in Location
$this->headers->delete('Host');
$this->effectiveUrl = $location;
$status = $this->getStatus();
if ($status == 302 || $status == 303)
{
$method = Http\Method::GET;
}
$this->redirectCount++;
}
else
{
$this->addError('REDIRECT', "Maximum number of redirects ({$this->redirectMax}) has been reached at URL {$url}", true);
return false;
}
}
else
{
return true;
}
}
}
/**
* Sets an HTTP request header.
*
* @param string $name Name of the header field.
* @param string $value Value of the field.
* @param bool $replace Replace existing header field with the same name or add one more.
* @return $this
*/
public function setHeader($name, $value, $replace = true)
{
if ($replace || !$this->headers->has($name))
{
$this->headers->set($name, $value);
}
return $this;
}
/**
* Sets an array of headers for HTTP request.
*
* @param array $headers Array of header_name => value pairs.
* @return $this
*/
public function setHeaders(array $headers)
{
foreach ($headers as $name => $value)
{
$this->setHeader($name, $value);
}
return $this;
}
/**
* Returns HTTP request headers.
*
* @return HttpHeaders
*/
public function getRequestHeaders(): HttpHeaders
{
if ($this->request)
{
return $this->request->getHeadersCollection();
}
return $this->headers;
}
/**
* Clears all HTTP request header fields.
*/
public function clearHeaders()
{
$this->headers->clear();
}
/**
* Sets an array of cookies for HTTP request. Warning! Replaces 'Cookie' header.
*
* @param array $cookies Array of cookie_name => value pairs.
* @return $this
*/
public function setCookies(array $cookies)
{
if (!empty($cookies))
{
$this->setHeader('Cookie', (new HttpCookies($cookies))->implode());
}
return $this;
}
/**
* Sets Basic Authorization request header field.
*
* @param string $user Username.
* @param string $pass Password.
* @return $this
*/
public function setAuthorization($user, $pass)
{
$this->setHeader('Authorization', 'Basic ' . base64_encode($user . ':' . $pass));
return $this;
}
/**
* Sets redirect options.
*
* @param bool $value If true, do redirect (default true).
* @param null|int $max Maximum allowed redirect count.
* @return $this
*/
public function setRedirect($value, $max = null)
{
$this->redirect = (bool)$value;
if ($max !== null)
{
$this->redirectMax = intval($max);
}
return $this;
}
/**
* Sets response body waiting option.
*
* @param bool $value If true, wait for response body. If false, disconnect just after reading headers (default true).
* @return $this
*/
public function waitResponse($value)
{
$this->waitResponse = (bool)$value;
if (!$this->waitResponse)
{
$this->setStreamTimeout(self::DEFAULT_STREAM_TIMEOUT_NO_WAIT);
}
return $this;
}
/**
* Sets connection timeout.
*
* @param int $value Connection timeout in seconds (default 30).
* @return $this
*/
public function setTimeout($value)
{
$this->socketTimeout = intval($value);
return $this;
}
/**
* Sets socket stream reading timeout.
*
* @param int $value Stream reading timeout in seconds; "0" means no timeout (default 60).
* @return $this
*/
public function setStreamTimeout($value)
{
$this->streamTimeout = intval($value);
return $this;
}
/**
* Sets HTTP protocol version. In version 1.1 chunked response is possible.
*
* @param string $value Version "1.0" or "1.1" (default "1.0").
* @return $this
*/
public function setVersion($value)
{
$this->version = $value;
return $this;
}
/**
* Sets compression option.
* Consider not to use the "compress" option with the output stream if a content can be large.
* Note, that compressed response is processed anyway if Content-Encoding response header field is set
*
* @param bool $value If true, "Accept-Encoding: gzip" will be sent.
* @return $this
*/
public function setCompress($value)
{
$this->compress = (bool)$value;
return $this;
}
/**
* Sets charset for the entity-body (used in the Content-Type request header field for POST and PUT).
*
* @param string $value Charset.
* @return $this
*/
public function setCharset($value)
{
$this->requestCharset = $value;
return $this;
}
/**
* Disables ssl certificate verification.
*
* @return $this
*/
public function disableSslVerification()
{
$this->sslVerify = false;
return $this;
}
/**
* Enables or disables requests to private IPs.
*
* @param bool $value
* @return $this
*/
public function setPrivateIp($value)
{
$this->privateIp = (bool)$value;
return $this;
}
/**
* Sets HTTP proxy for request.
*
* @param string $proxyHost Proxy host name or address (without "http://").
* @param null|int $proxyPort Proxy port number.
* @param null|string $proxyUser Proxy username.
* @param null|string $proxyPassword Proxy password.
* @return $this
*/
public function setProxy($proxyHost, $proxyPort = null, $proxyUser = null, $proxyPassword = null)
{
$this->proxyHost = $proxyHost;
$proxyPort = (int)$proxyPort;
if ($proxyPort > 0)
{
$this->proxyPort = $proxyPort;
}
$this->proxyUser = $proxyUser ?? '';
$this->proxyPassword = $proxyPassword ?? '';
return $this;
}
/**
* Sets the response output to the stream instead of the string result. Useful for large responses.
* Note, the stream must be readable/writable to support a compressed response.
* Note, in this mode the result string is empty.
*
* @param resource $handler File or stream handler.
* @return $this
*/
public function setOutputStream($handler)
{
$this->outputStream = $handler;
return $this;
}
/**
* Sets the maximum body length that will be received in $this->readBody().
*
* @param int $bodyLengthMax
* @return $this
*/
public function setBodyLengthMax($bodyLengthMax)
{
$this->bodyLengthMax = intval($bodyLengthMax);
return $this;
}
/**
* Downloads and saves a file.
*
* @param string $url URI to download.
* @param string $filePath Absolute file path.
* @return bool
*/
public function download($url, $filePath)
{
$result = $this->query(Http\Method::GET, $url);
if ($result && ($status = $this->getStatus()) >= 200 && $status < 300)
{
$this->saveFile($filePath);
return true;
}
return false;
}
/**
* Saves a downloaded file.
*
* @param string $filePath Absolute file path.
*/
public function saveFile($filePath)
{
$dir = IO\Path::getDirectory($filePath);
IO\Directory::createDirectory($dir);
$file = new IO\File($filePath);
$handler = $file->open('w+');
$this->setOutputStream($handler);
$this->getResult();
$file->close();
}
/**
* Returns URL of the last redirect if request was redirected, or initial URL if request was not redirected.
*
* @return string
*/
public function getEffectiveUrl()
{
return $this->effectiveUrl;
}
/**
* Sets context options and parameters.
*
* @param array $options Context options and parameters
* @return $this
*/
public function setContextOptions(array $options)
{
$this->contextOptions = array_replace_recursive($this->contextOptions, $options);
return $this;
}
/**
* Returns parsed HTTP response headers.
*
* @return HttpHeaders
*/
public function getHeaders(): HttpHeaders
{
if ($this->response)
{
return $this->response->getHeadersCollection();
}
return new HttpHeaders();
}
/**
* Returns parsed HTTP response cookies.
*
* @return HttpCookies
*/
public function getCookies(): HttpCookies
{
return $this->getHeaders()->getCookies();
}
/**
* Returns HTTP response status code.
*
* @return int
*/
public function getStatus()
{
if ($this->response)
{
return $this->response->getStatusCode();
}
return 0;
}
/**
* Returns HTTP response entity string. Note, if outputStream is set, the result will be the empty string.
*
* @return string
*/
public function getResult()
{
$result = '';
if ($this->response)
{
$body = $this->response->getBody();
if ($this->outputStream === null)
{
$result = (string)$body;
}
else
{
$body->copyTo($this->outputStream);
}
}
return $result;
}
/**
* Returns PSR-7 response.
*
* @return Http\Response|null
*/
public function getResponse()
{
return $this->response;
}
/**
* Returns array of errors on failure.
*
* @return array Array with "error_code" => "error_message" pair
*/
public function getError()
{
return $this->error;
}
/**
* Returns response content type.
*
* @return string
*/
public function getContentType()
{
return $this->getHeaders()->getContentType();
}
/**
* Returns response content encoding.
*
* @return string
*/
public function getCharset()
{
return $this->getHeaders()->getCharset();
}
/**
* Returns remote peer ip address (only if privateIp = false).
*
* @return string|false
*/
public function getPeerAddress()
{
if ($this->effectiveIp)
{
return (string)$this->effectiveIp;
}
return false;
}
protected function addError($code, $message, $triggerWarning = false)
{
$this->error[$code] = $message;
if ($triggerWarning)
{
trigger_error($message, E_USER_WARNING);
}
}
protected function buildRequest(RequestInterface $request): RequestInterface
{
$method = $request->getMethod();
$uri = $request->getUri();
$body = $request->getBody();
$punyUri = new Uri('http://' . $uri->getHost());
if (($punyHost = $punyUri->convertToPunycode()) != $uri->getHost())
{
$uri = $uri->withHost($punyHost);
$request = $request->withUri($uri);
}
if (!$request->hasHeader('Host'))
{
$request = $request->withHeader('Host', $uri->getHost());
}
if (!$request->hasHeader('Connection'))
{
$request = $request->withHeader('Connection', 'close');
}
if (!$request->hasHeader('Accept'))
{
$request = $request->withHeader('Accept', '*/*');
}
if (!$request->hasHeader('Accept-Language'))
{
$request = $request->withHeader('Accept-Language', 'en');
}
if ($this->compress)
{
$request = $request->withHeader('Accept-Encoding', 'gzip');
}
if (($userInfo = $uri->getUserInfo()) != '')
{
$request = $request->withHeader('Authorization', 'Basic ' . base64_encode($userInfo));
}
if ($this->proxyHost != '' && $this->proxyUser != '')
{
$request = $request->withHeader('Proxy-Authorization', 'Basic ' . base64_encode($this->proxyUser . ':' . $this->proxyPassword));
}
// the client doesn't support "Expect-Continue", set empty value for cURL
if ($this->useCurl)
{
$request = $request->withHeader('Expect', '');
}
if ($method == Http\Method::POST)
{
//special processing for POST requests
if (!$request->hasHeader('Content-Type'))
{
$contentType = 'application/x-www-form-urlencoded';
if ($this->requestCharset != '')
{
$contentType .= '; charset=' . $this->requestCharset;
}
$request = $request->withHeader('Content-Type', $contentType);
}
}
$size = $body->getSize();
if ($size > 0 || $method == Http\Method::POST || $method == Http\Method::PUT)
{
// A valid Content-Length field value is required on all HTTP/1.0 request messages containing an entity body.
if (!$request->hasHeader('Content-Length'))
{
$request = $request->withHeader('Content-Length', $size ?? strlen((string)$body));
}
}
// Here's the chance to tune up the client and to rebuild the request.
$event = new Http\RequestEvent($this, $request, 'OnHttpClientBuildRequest');
$event->send();
foreach ($event->getResults() as $eventResult)
{
$request = $eventResult->getRequest();
}
return $request;
}
protected function checkRequest(RequestInterface $request): bool
{
$uri = $request->getUri();
$scheme = $uri->getScheme();
if ($scheme !== 'http' && $scheme !== 'https')
{
$this->addError('URI_SCHEME', 'Only http and https shemes are supported.');
return false;
}
if ($uri->getHost() == '')
{
$this->addError('URI_HOST', 'Incorrect host in URI.');
return false;
}
$punyUri = new Uri('http://' . $uri->getHost());
$error = $punyUri->convertToPunycode();
if ($error instanceof \Bitrix\Main\Error)
{
$this->addError('URI_PUNICODE', "Error converting hostname to punycode: {$error->getMessage()}");
return false;
}
if (!$this->privateIp)
{
$ip = IpAddress::createByUri($punyUri);
if ($ip->isPrivate())
{
$this->addError('PRIVATE_IP', "Resolved IP is incorrect or private: {$ip->get()}");
return false;
}
$this->effectiveIp = $ip;
}
return true;
}
/**
* @inheritdoc
*/
public function sendRequest(RequestInterface $request): ResponseInterface
{
if (!$this->checkRequest($request))
{
throw new Http\RequestException($request, reset($this->error));
}
$this->request = $this->buildRequest($request);
$queue = $this->createQueue(false);
$handler = $this->createHandler($this->request);
$promise = $this->createPromise($handler, $queue);
$queue->add($promise);
$this->response = $promise->wait();
return $this->response;
}
/**
* @param RequestInterface $request
* @return PromiseInterface
* @throws Http\ClientException
*/
public function sendAsyncRequest(RequestInterface $request): PromiseInterface
{
if (!$this->checkRequest($request))
{
throw new Http\RequestException($request, reset($this->error));
}
$this->request = $this->buildRequest($request);
if ($this->queue === null)
{
$this->queue = $this->createQueue();
}
$handler = $this->createHandler($this->request, true);
$promise = $this->createPromise($handler, $this->queue);
$this->queue->add($promise);
return $promise;
}
/**
* @param RequestInterface $request
* @param bool $async
* @return Http\Curl\Handler | Http\Socket\Handler
*/
protected function createHandler(RequestInterface $request, bool $async = false)
{
if ($this->sslVerify === false)
{
$this->contextOptions['ssl']['verify_peer_name'] = false;
$this->contextOptions['ssl']['verify_peer'] = false;
$this->contextOptions['ssl']['allow_self_signed'] = true;
}
$handlerOptions = [
'waitResponse' => $this->waitResponse,
'bodyLengthMax' => $this->bodyLengthMax,
'proxyHost' => $this->proxyHost,
'proxyPort' => $this->proxyPort,
'effectiveIp' => $this->effectiveIp,
'contextOptions' => $this->contextOptions,
'socketTimeout' => $this->socketTimeout,
'streamTimeout' => $this->streamTimeout,
'async' => $async,
'curlLogFile' => $this->curlLogFile,
];
$responseBuilder = new Http\ResponseBuilder();
if ($this->useCurl)
{
$handler = new Http\Curl\Handler($request, $responseBuilder, $handlerOptions);
}
else
{
$handler = new Http\Socket\Handler($request, $responseBuilder, $handlerOptions);
}
if ($this->logger !== null)
{
$handler->setLogger($this->logger);
$handler->setDebugLevel($this->debugLevel);
}
if ($this->shouldFetchBody !== null)
{
$handler->shouldFetchBody($this->shouldFetchBody);
}
return $handler;
}
/**
* @param Http\Curl\Handler | Http\Socket\Handler $handler
* @param Http\Queue $queue
* @return Http\Curl\Promise | Http\Socket\Promise
*/
protected function createPromise($handler, Http\Queue $queue)
{
if ($this->useCurl)
{
return new Http\Curl\Promise($handler, $queue);
}
return new Http\Socket\Promise($handler, $queue);
}
/**
* @param bool $backgroundJob
* @return Http\Curl\Queue | Http\Socket\Queue
*/
protected function createQueue(bool $backgroundJob = true)
{
if ($this->useCurl)
{
return new Http\Curl\Queue($backgroundJob);
}
return new Http\Socket\Queue($backgroundJob);
}
/**
* Waits for async promises and returns responses from processed promises.
*
* @return ResponseInterface[]
*/
public function wait(): array
{
$responses = [];
if ($this->queue)
{
foreach ($this->queue->wait() as $promise)
{
$responses[$promise->getId()] = $promise->wait();
}
}
return $responses;
}
/**
* Sets a callback called before fetching a message body.
*
* @param callable $callback
* @return $this
*/
public function shouldFetchBody(callable $callback)
{
$this->shouldFetchBody = $callback;
return $this;
}
}