/**
* Constructor
*
* @param Request $request
* @param Response $response
* @param Dispatcher $dispatcher
*/
public function __construct(Request $request, Response $response, Dispatcher $dispatcher)
{
$this->request = $request;
$this->response = $response;
$this->dispatcher = $dispatcher;
if (isset($this->request->getHeaders()['Content-Length'])) {
$this->contentLength = intval($this->request->getHeaders()['Content-Length']);
}
}
/**
* @param Request $request
* @param array $parameters
* @return SymfonyRequest
*/
private function buildSfRequest(Request $request, array $parameters)
{
$sfRequest = SymfonyRequest::create($request->getPath(), $request->getMethod());
$requestHeaders = $request->getHeaders();
if (isset($requestHeaders['Cookie'])) {
$sfRequest->cookies->replace($this->deserializeCookiesHeader($requestHeaders['Cookie']));
}
$sfRequest->request->replace($parameters);
$sfRequest->query->replace($request->getQuery());
$sfRequest->server->set('REQUEST_URI', $request->getPath());
$sfRequest->server->set('SERVER_NAME', rtrim($requestHeaders['Host'], ':0..9'));
$sfRequest->headers->replace($request->getHeaders());
return $sfRequest;
}
/**
* HttpRequest constructor.
* @param Request $request
*/
public function __construct(Request $request, $jsonData)
{
$this->request = $request;
$this->parameters = $request->getQuery();
$this->parameters = array_merge($this->parameters, $request->getHeaders());
$this->parameters = array_merge($this->parameters, (array) $jsonData);
}
public function parseBody($content)
{
$headers = $this->request->getHeaders();
if (array_key_exists('Content-Type', $headers)) {
if (strpos($headers['Content-Type'], 'multipart/') === 0) {
//TODO :: parse the content while it is streaming
preg_match("/boundary=\"?(.*)\"?\$/", $headers['Content-Type'], $matches);
$boundary = $matches[1];
$parser = new MultipartParser($content, $boundary);
$parser->parse();
$this->request->setPost($parser->getPost());
$this->request->setFiles($parser->getFiles());
return;
}
if (strtolower($headers['Content-Type']) == 'application/x-www-form-urlencoded') {
parse_str($content, $result);
$this->request->setPost($result);
return;
}
if (strtolower($headers['Content-Type']) == 'application/json') {
$result = json_decode($content);
$this->request->setBody($result);
return;
}
}
$this->request->setBody($content);
}
/**
* Set value of ReactRequest
*
* @param \React\Http\Request $reactRequest
*/
public function setReactRequest($reactRequest)
{
$this->reactRequest = $reactRequest;
$this->setUri($reactRequest->getPath());
$this->getHeaders()->addHeaders($reactRequest->getHeaders());
$this->setMethod($reactRequest->getMethod());
$this->setQuery(new Parameters($reactRequest->getQuery()));
}
protected function handleSse(Request $request, Response $response)
{
$headers = $request->getHeaders();
$id = isset($headers['Last-Event-ID']) ? $headers['Last-Event-ID'] : null;
$response->writeHead(200, array('Content-Type' => 'text/event-stream'));
$this->channel->connect($response, $id);
$response->on('close', function () use($response) {
$this->channel->disconnect($response);
});
}
function __construct(Request $request)
{
$this->request = $request;
$headers = $request->getHeaders();
if (isset($headers['Content-Length']) && is_numeric($contentLength = $headers['Content-Length'])) {
$this->contentLength = $contentLength;
}
$request->on('data', [$this, 'handleData']);
$request->on('close', [$this, 'handleClose']);
$request->on('error', [$this, 'handleError']);
}
/**
* Extract the server parameters ($_SERVER).
*
* @param ReactRequest $request
*
* @return array
*/
private function extractServer(ReactRequest $request)
{
$server = ['SERVER_PROTOCOL' => 'HTTP/' . $request->getHttpVersion(), 'REQUEST_METHOD' => $request->getMethod(), 'REQUEST_URI' => $request->getPath(), 'REQUEST_TIME' => time()];
// headers
foreach ($request->getHeaders() as $key => $value) {
$name = mb_strtoupper($key, 'UTF-8');
$name = str_replace('-', '_', $name);
$server[$name] = $value;
}
return $server;
}
protected function fixHeaderNames(Request $request)
{
$headers = $request->getHeaders();
foreach ($headers as $name => $v) {
$newName = str_replace(' ', '-', ucwords(strtolower(str_replace('-', ' ', $name))));
$headers[$newName] = $headers[$name];
}
if (isset($headers['Content-Type'])) {
$headers['Content-Type'] = explode(';', $headers['Content-Type'])[0];
}
$request->__construct($request->getMethod(), $request->getUrl(), $request->getQuery(), $request->getHttpVersion(), $headers, $request->getBody());
}
/**
* @param Request $request
* @param string $postData
* @return SymfonyRequest
*/
private function buildSfRequest(Request $request, $postData = null)
{
if ($postData !== null) {
parse_str($postData, $postDataArray);
$parameters = empty($postDataArray) ? [] : $postDataArray;
$content = empty($postDataArray) ? [] : $postData;
// TODO Maybe check Content-Type too?
$sfRequest = SymfonyRequest::create($request->getPath(), $request->getMethod(), $parameters, [], [], [], $content);
} else {
$sfRequest = SymfonyRequest::create($request->getPath(), $request->getMethod());
}
$requestHeaders = $request->getHeaders();
if (isset($requestHeaders['Cookie'])) {
$sfRequest->cookies->replace($this->deserializeCookiesHeader($requestHeaders['Cookie']));
}
// $sfRequest->request->replace($parameters);
$sfRequest->query->replace($request->getQuery());
$sfRequest->server->set('REQUEST_URI', $request->getPath());
$sfRequest->server->set('SERVER_NAME', rtrim($requestHeaders['Host'], ':0..9'));
$sfRequest->headers->replace($request->getHeaders());
return $sfRequest;
}
/**
* Constructor
*
* @param React\HttpClient\Client $client
* @param Irto\OAuth2Proxy\Server $server
* @param React\Http\Request $request original request
*
* @return Irto\OAuth2Proxy\ProxyRequest
*/
public function __construct(HttpClient $client, Server $server, Request $request)
{
$headers = $request->getHeaders();
$headers = array_combine(array_map('strtolower', array_keys($headers)), $headers);
$headers = Arr::except($headers, $this->headersNotAllowed);
$this->original = $request;
$this->client = $client;
$this->server = $server;
$this->query = new Collection();
$headers = new Collection($headers);
$headers->put('cookie', new Collection((new \Guzzle\Parser\Cookie\CookieParser())->parseCookie($headers->get('cookie'))));
$this->headers = $headers;
$request->on('data', array($this, 'write'));
}
/**
* @inheritdoc
*/
public function handle(Request $request)
{
$headers = $request->getHeaders();
if (array_key_exists('Authorization', $headers)) {
$authorization = $headers['Authorization'];
if (substr($authorization, 0, strlen('Basic ')) !== 'Basic ') {
return false;
}
$authentication = base64_decode(substr($authorization, strlen('Basic ')));
$parts = explode(':', $authentication);
if (count($parts) !== 2) {
return false;
}
return call_user_func($this->implementation, $parts[0], $parts[1]);
}
return false;
}
public function handle(Request $request, Response $response)
{
$headers = array_change_key_case($request->getHeaders(), CASE_LOWER);
// Only enable when the X-Blackfire-Query header is present
if (!isset($headers['x-blackfire-query'])) {
return array();
}
$probe = new \BlackfireProbe($headers['x-blackfire-query']);
// Stop if it failed
if (!$probe->enable()) {
return array();
}
// Stop profiling once the request ends
$response->on('end', array($probe, 'close'));
// Return the header
$header = explode(':', $probe->getResponseLine(), 2);
return array('x-' . $header[0] => $header[1]);
}
/**
* Creates a new request object from the data of a reactPHP request object
*
* @param \React\Http\Request $request ReactPHP native request object
*
* @return \Slim\Http\Request
*/
public static function createFromReactRequest(\React\Http\Request $request)
{
$slimHeads = new Headers();
foreach ($request->getHeaders() as $reactHeadKey => $reactHead) {
$slimHeads->add($reactHeadKey, $reactHead);
if ($reactHeadKey === 'Host') {
$host = explode(':', $reactHead);
if (count($host) === 1) {
$host[1] = '80';
}
}
}
$slimUri = new Uri('http', $host[0], (int) $host[1], $request->getPath(), $request->getQuery());
$cookies = [];
$serverParams = $_SERVER;
$serverParams['SERVER_PROTOCOL'] = 'HTTP/' . $request->getHttpVersion();
$slimBody = new RequestBody();
return new self($request->getMethod(), $slimUri, $slimHeads, $cookies, $serverParams, $slimBody);
}
/**
* Creates a new request object from the data of a reactPHP request object
*
* @param \React\Http\Request $request ReactPHP native request object
* @param string $body Content of received call
*
* @return \Slim\Http\Request
*/
public static function createFromReactRequest(\React\Http\Request $request, $body = '')
{
$slimHeads = new Headers();
$cookies = [];
$host = ['', 80];
foreach ($request->getHeaders() as $reactHeadKey => $reactHead) {
$slimHeads->add($reactHeadKey, $reactHead);
switch ($reactHeadKey) {
case 'Host':
$host = static::getHost($reactHead);
break;
case 'Cookie':
$cookies = Cookies::parseHeader($reactHead);
break;
}
}
$slimUri = new Uri('http', $host[0], (int) $host[1], $request->getPath(), $request->getQuery());
$serverParams = $_SERVER;
$serverParams['SERVER_PROTOCOL'] = 'HTTP/' . $request->getHttpVersion();
$slimBody = static::getBody($body);
return new Request($request->getMethod(), $slimUri, $slimHeads, $cookies, $serverParams, $slimBody);
}
/**
* {@inheritdoc}
*/
protected static function mapRequest(ReactRequest $reactRequest, $content)
{
$method = strtoupper($reactRequest->getMethod());
$headers = $reactRequest->getHeaders();
$query = $reactRequest->getQuery();
$post = array();
$requestIsPostType = in_array($method, array('POST', 'PUT', 'DELETE', 'PATCH'));
// Parse body?
if (isset($headers['Content-Type']) && 0 === strpos($headers['Content-Type'], 'application/x-www-form-urlencoded') && $requestIsPostType) {
parse_str($content, $post);
}
$cookies = array();
if (isset($headers['Cookie'])) {
$headersCookie = explode(';', $headers['Cookie']);
foreach ($headersCookie as $cookie) {
list($name, $value) = explode('=', trim($cookie));
$cookies[$name] = $value;
}
}
// Add any query string to URI so SymfonyRequest::create() can access it.
$uri = $reactRequest->getPath() . (empty($query) ? '' : '?' . http_build_query($query));
// SymfonyRequest::create() expects $parameters to contain either
// $_GET or $_POST.
$parameters = $requestIsPostType ? $post : $query;
$syRequest = SymfonyRequest::create($uri, $method, $parameters, $cookies, array(), array(), $content);
$syRequest->headers->replace($headers);
// Set CGI/1.1 (RFC 3875) server vars.
if (empty($_ENV)) {
// In some cases with cli, $_ENV isn't set, so get with getenv().
// @see http://stackoverflow.com/questions/8798294/getenv-vs-env-in-php/21473853#21473853
// @todo: Make this more efficient to eliminate running per request.
// Static variable?
$_ENV['DOCUMENT_ROOT'] = getenv('DOCUMENT_ROOT');
$_ENV['SCRIPT_NAME'] = getenv('SCRIPT_NAME');
}
$serverVars = array_merge($syRequest->server->all(), array('DOCUMENT_ROOT' => $_ENV['DOCUMENT_ROOT'], 'GATEWAY_INTERFACE' => 'CGI/1.1', 'SCRIPT_NAME' => $_ENV['SCRIPT_NAME'], 'SCRIPT_FILENAME' => $_ENV['DOCUMENT_ROOT'] . $_ENV['SCRIPT_NAME']));
$syRequest->server->replace($serverVars);
return $syRequest;
}
public function transformFromReact(ReactRequest $request)
{
$this->baseUrl = '';
$this->requestUri = $request->getPath();
$this->content = $request->getBody();
// Request Headers
$this->headers = new HeaderBag($request->getHeaders());
// Server informations ($_SERVER)
$this->server = new ServerBag($this->buildServerBag($request));
// Request body parameters ($_POST).
if (0 === strpos($this->headers->get('CONTENT_TYPE'), 'application/x-www-form-urlencoded') && in_array(strtoupper($this->server->get('REQUEST_METHOD', 'GET')), ['POST', 'PUT', 'DELETE', 'PATCH'])) {
$this->request = new ParameterBag($request->getPost());
}
// Query string parameters ($_GET).
$this->query = new ParameterBag($request->getQuery());
// Request attributes
$this->attributes = new ParameterBag([]);
// Cookies
$this->cookies = new ParameterBag($this->buildCookieBag());
// Files uploads
$this->files = new FileBag($this->buildFileBag($request));
}
/**
* main push request/ websocket response loop
*/
function onRequest(Request $request, Response $response)
{
$content = '';
$headers = $request->getHeaders();
$contentLength = isset($headers['Content-Length']) ? (int) $headers['Content-Length'] : null;
// length required, chunked encoding not supported
if (null === $contentLength) {
$response->writeHead(411);
$response->end();
return;
}
$request->on('data', function ($data) use($request, $response, &$content, $contentLength) {
// read data (may be empty for GET request)
$content .= $data;
// handle request after receive
if (strlen($content) >= $contentLength) {
$headers = array('Content-Type' => 'application/json');
try {
$data = $this->hub->handlePushMessage($content);
$headers['Content-Length'] = strlen($data);
if (null === $data) {
$response->writeHead(400, $headers);
$response->end();
} else {
$response->writeHead(200, $headers);
$response->end($data);
}
} catch (\Exception $exception) {
$data = $this->getExceptionAsJson($exception, true);
$headers['Content-Length'] = strlen($data);
$response->writeHead(500, $headers);
// internal server error
$response->end($data);
}
}
});
}
public static function fromHttpRequest(HttpRequest $request)
{
return new RequestHeaders($request->getMethod(), $request->getPath(), $request->getQuery(), $request->getHttpVersion(), $request->getHeaders());
}
/**
* @param \React\Http\Request $request
*/
public function setServerGlobals($request)
{
$headers = $request->getHeaders();
if (isset($headers['Authorization']) && $headers['Authorization']) {
$_SERVER['HTTP_AUTHENTICATION'] = $headers['Authorization'];
}
}
/**
* Manages a request, made to the Http server.
*
* @param \React\Http\Request $request
* @param \React\Http\Response $response
*/
public function manageRequest($request, $response)
{
$requestData = [$request->getHeaders()['Host'] . $request->getPath(), $request->getMethod(), array_merge($request->getQuery(), $request->getPost()), [], $request->getFiles(), []];
$contentType = isset($request->getHeaders()['Content-Type']) ? $request->getHeaders()['Content-Type'] : 'application/x-www-form-urlencoded';
if (strtolower($contentType) == 'application/x-www-form-urlencoded') {
$requestData[] = http_build_query($request->getPost());
} else {
$requestData[] = $request->getBody();
}
//Creates the Symfony Request from the React Request.
$sRequest = Request::create(...$requestData);
/** @var Response $sResponse */
$sResponse = $this->kernel->handle($sRequest);
$response->writeHead($sResponse->getStatusCode());
$response->end($sResponse->getContent());
}
/**
* @param ReactRequest $reactRequest
*
* @return array
*/
private function transformCookies(ReactRequest $reactRequest)
{
$cookies = array();
$headers = $reactRequest->getHeaders();
if (isset($headers['Cookie'])) {
foreach (explode(';', $headers['Cookie']) as $rawCookie) {
$segment = explode('=', $rawCookie, 2);
$cookies[trim($segment[0])] = isset($segment[1]) ? $segment[1] : null;
}
}
return $cookies;
}
protected function handleRequest(\React\Http\Request $request, \React\Http\Response $response)
{
$request_headers = $request->getHeaders();
$requestUri = $this->getRequestUri($request_headers, $request->getPath());
$laravel_request = \Request::create($this->getRequestUri($request_headers, $request->getPath()), $request->getMethod(), array_merge($request->getQuery(), $this->post_params), $this->getCookies($request_headers), [], [], $this->request_body);
$laravel_request->headers->add($request_headers);
$laravel_response = \App::handle($laravel_request);
$headers = array_merge($laravel_response->headers->allPreserveCase(), $this->buildCookies($laravel_response->headers->getCookies()));
$response->writeHead($laravel_response->getStatusCode(), $headers);
$response->end($laravel_response->getContent());
echo $requestUri . "\n";
}
/**
* Convert React\Http\Request to Symfony\Component\HttpFoundation\Request
*
* @param ReactRequest $reactRequest
* @return SymfonyRequest $syRequest
*/
protected static function mapRequest(ReactRequest $reactRequest, $content)
{
$method = $reactRequest->getMethod();
$headers = $reactRequest->getHeaders();
$query = $reactRequest->getQuery();
$post = array();
// parse body?
if (isset($headers['Content-Type']) && 0 === strpos($headers['Content-Type'], 'application/x-www-form-urlencoded') && in_array(strtoupper($method), array('POST', 'PUT', 'DELETE', 'PATCH'))) {
parse_str($content, $post);
}
$syRequest = new SymfonyRequest($query, $post, array(), array(), array(), array(), $content);
$syRequest->setMethod($method);
$syRequest->headers->replace($headers);
$syRequest->server->set('REQUEST_URI', $reactRequest->getPath());
$syRequest->server->set('SERVER_NAME', explode(':', $headers['Host'])[0]);
return $syRequest;
}
/**
* @param React\Http\Request $reactRequest
* @return Nette\Http\Request
*/
private function createNetteHttpRequest(React\Http\Request $reactRequest)
{
$url = new Nette\Http\UrlScript('http://' . $reactRequest->getHeaders()['Host'] . $reactRequest->getPath());
$url->setQuery($reactRequest->getQuery());
return new Nette\Http\Request($url, NULL, NULL, NULL, NULL, $reactRequest->getHeaders(), $reactRequest->getMethod(), $reactRequest->remoteAddress, NULL, NULL);
}
protected function setupResponseLogging(\React\Http\Request $request, HttpResponse $response)
{
$timeLocal = date('d/M/Y:H:i:s O');
$response->on('end', function () use($request, $response, $timeLocal) {
$requestString = $request->getMethod() . ' ' . $request->getPath() . ' HTTP/' . $request->getHttpVersion();
$statusCode = $response->getStatusCode();
if ($response->getStatusCode() < 400) {
$requestString = "<info>{$requestString}</info>";
$statusCode = "<info>{$statusCode}</info>";
}
$message = str_replace(['$remote_addr', '$remote_user', '$time_local', '$request', '$status', '$bytes_sent', '$http_referer', '$http_user_agent'], [$_SERVER['REMOTE_ADDR'], '-', $timeLocal, $requestString, $statusCode, $response->getBytesSent(), isset($request->getHeaders()['Referer']) ? $request->getHeaders()['Referer'] : '-', isset($request->getHeaders()['User-Agent']) ? $request->getHeaders()['User-Agent'] : '-'], $this->logFormat);
if ($response->getStatusCode() >= 400) {
$message = "<error>{$message}</error>";
}
$this->sendMessage($this->controller, 'log', ['message' => $message]);
});
}
/**
* @param \React\Http\Request $request
*
* @return \Symfony\Component\HttpFoundation\Request
*/
private function convertRequest($request)
{
// Convert the React Request to a Symfony Request
$symReq = new \Symfony\Component\HttpFoundation\Request();
// Set Method
$symReq->setMethod($request->getMethod());
// Add path
$symReq->server->set('REQUEST_URI', $request->getPath());
// TODO: consider appending http_build_query($request->getQuery())
// Add GET variables
$symReq->query->add($request->getQuery());
// Add POST variables
$symReq->request->add($request->getPost());
// Add headers
$symReq->headers->add($request->getHeaders());
return $symReq;
}
/**
* Returns the content length for the given request
*
* @param Request $request
* @return int
*/
protected function getContentLengthFromRequest($request)
{
$headers = $request->getHeaders();
$headerNamesToCheck = array('Content-Length', 'Content-length', 'content-length');
foreach ($headerNamesToCheck as $headerName) {
if (isset($headers[$headerName])) {
return $headers[$headerName];
}
}
throw new MissingLengthHeaderException('Could not detect the Content-Length', 1413473195);
}
protected function handleRequest(\React\Http\Request $request, \React\Http\Response $response)
{
$kernel = \App::make('Illuminate\\Contracts\\Http\\Kernel');
$laravel_request = \Request::create($this->getRequestUri($request->getHeaders(), $request->getPath()), $request->getMethod(), array_merge($request->getQuery(), $this->post_params), $this->getCookies($request->getHeaders()), [], [], $this->request_body);
$laravel_response = $kernel->handle($laravel_request);
$headers = array_merge($laravel_response->headers->allPreserveCase(), $this->buildCookies($laravel_response->headers->getCookies()));
$response->writeHead($laravel_response->getStatusCode(), $headers);
$response->end($laravel_response->getContent());
$kernel->terminate($laravel_request, $laravel_response);
}
public function prepare(reactRequest $request, reactResponse $response, $output)
{
static $serverSoftware, $settings;
if ($serverSoftware === null) {
$serverSoftware = 'MPCMF Async PHP ' . phpversion();
$settings = ['document_root' => APP_ROOT . '/htdocs'];
}
$_SERVER = [];
$now = microtime(true);
$_SERVER['REQUEST_TIME'] = (int) $now;
$_SERVER['REQUEST_TIME_FLOAT'] = $now;
$GLOBALS['MPCMF_START_TIME'] = $now;
/** @var Uri $requestUrl */
$requestUrl = $request->getUrl();
$path = $requestUrl->getPath();
if ($path === '/favicon.ico') {
$response->writeHead(404);
$response->end('FAVICON NOT FOUND! :)');
//MPCMF_DEBUG && $output->writeln("<info>[CHILD:{$this->port}]</info> Connection closed by favicon catch");
return false;
}
$realpath = realpath($settings['document_root'] . $path);
if ($realpath !== false && strpos($realpath, $settings['document_root']) !== false && (file_exists($realpath) && !is_dir($realpath))) {
$response->writeHead(200, ['Content-type' => \GuzzleHttp\Psr7\mimetype_from_filename($realpath), 'Content-length' => filesize($realpath)]);
$response->end(file_get_contents($realpath));
//MPCMF_DEBUG && $output->writeln("<info>[CHILD:{$this->port}]</info> Connection closed by static");
return false;
}
$_FILES = [];
foreach ($request->getFiles() as $filename => $fileData) {
$tmpname = tempnam('/tmp/mpcmf/', 'upl');
file_put_contents($tmpname, stream_get_contents($fileData['stream']));
$_FILES[$filename] = ['name' => $filename, 'type' => $fileData['type'], 'tmp_name' => $tmpname, 'error' => $fileData['error'], 'size' => $fileData['size']];
}
$_SERVER['DOCUMENT_ROOT'] = $settings['document_root'];
$_SERVER['REMOTE_ADDR'] = $request->getRemoteAddress();
$_SERVER['REMOTE_PORT'] = 0;
$_SERVER['SERVER_SOFTWARE'] = $serverSoftware;
$_SERVER['SERVER_PROTOCOL'] = "HTTP/{$request->getHttpVersion()}";
$_SERVER['SERVER_NAME'] = $this->childHost;
$_SERVER['SERVER_PORT'] = $this->port;
$path = $requestUrl->getPath();
$queryString = $requestUrl->getQuery();
$_SERVER['REQUEST_URI'] = $path . (!empty($queryString) ? "?{$queryString}" : '');
$_SERVER['REQUEST_METHOD'] = mb_strtoupper($request->getMethod());
$_SERVER['SCRIPT_NAME'] = '/';
$_SERVER['SCRIPT_FILENAME'] = __FILE__;
$_SERVER['PATH_INFO'] = $path;
$_SERVER['PHP_SELF'] = $path;
$headers = $request->getHeaders();
foreach ($headers as $headerKey => $headerValue) {
$_SERVER['HTTP_' . strtoupper(preg_replace('/[\\-\\s]/', '_', $headerKey))] = $headerValue;
}
if (isset($_SERVER['HTTP_X_REAL_IP'])) {
$_SERVER['REMOTE_ADDR'] = $_SERVER['HTTP_X_REAL_IP'];
}
$_SERVER['QUERY_STRING'] = $queryString;
//@todo remove on pull request merge https://github.com/reactphp/http/pull/34
$_GET = $request->getQuery();
$_POST = $request->getPost();
parse_str($queryString, $parsedGET);
parse_str($request->getBody(), $parsedPOST);
$_GET = array_replace($_GET, $parsedGET);
$_POST = array_replace($_POST, $parsedPOST);
if (isset($_SERVER['HTTP_COOKIE'])) {
parse_str($_SERVER['HTTP_COOKIE'], $_COOKIE);
} else {
$_COOKIE = [];
}
$_REQUEST = array_merge($_GET, $_POST);
return true;
}
