/** * Transform a PSR7 request into a CakePHP one. * * @param \Psr\Http\Message\ServerRequestInterface $request The PSR7 request. * @return \Cake\Network\Request The transformed request. */ public static function toCake(PsrRequest $request) { $post = $request->getParsedBody(); $server = $request->getServerParams(); $files = static::getFiles($request); if (!empty($files)) { $post = Hash::merge($post, $files); } return new CakeRequest(['query' => $request->getQueryParams(), 'post' => $post, 'cookies' => $request->getCookieParams(), 'environment' => $server, 'params' => static::getParams($request), 'url' => $request->getUri()->getPath(), 'base' => $request->getAttribute('base', ''), 'webroot' => $request->getAttribute('webroot', '/')]); }
/** * Server data (e.g. $_SERVER) * @return \PHPixie\HTTP\Data\Server */ public function server() { if ($this->server === null) { $data = $this->serverRequest->getServerParams(); $this->server = $this->builder->serverData($data); } return $this->server; }
/** * {@inheritdoc} */ public function getData() { $headers = []; foreach ($this->request->getHeaders() as $name => $values) { $headers[$name] = implode(', ', $values); } $data = ['SERVER' => $this->request->getServerParams(), 'QUERY' => $this->request->getQueryParams(), 'COOKIES' => $this->request->getCookieParams(), 'HEADERS' => $headers, 'ATTRIBUTES' => $this->request->getAttributes()]; return $data; }
/** * Convert a PSR-7 ServerRequest to a Zend\Http server-side request. * * @param ServerRequestInterface $psr7Request * @param bool $shallow Whether or not to convert without body/file * parameters; defaults to false, meaning a fully populated request * is returned. * @return Zend\Request */ public static function toZend(ServerRequestInterface $psr7Request, $shallow = false) { if ($shallow) { return new Zend\Request($psr7Request->getMethod(), $psr7Request->getUri(), $psr7Request->getHeaders(), $psr7Request->getCookieParams(), $psr7Request->getQueryParams(), [], [], $psr7Request->getServerParams()); } $zendRequest = new Zend\Request($psr7Request->getMethod(), $psr7Request->getUri(), $psr7Request->getHeaders(), $psr7Request->getCookieParams(), $psr7Request->getQueryParams(), $psr7Request->getParsedBody() ?: [], self::convertUploadedFiles($psr7Request->getUploadedFiles()), $psr7Request->getServerParams()); $zendRequest->setContent($psr7Request->getBody()); return $zendRequest; }
/** * Constructor * * @param Request $request * @param Response $response */ public function __construct(RequestInterface $request, ResponseInterface $response) { $this->request = $request; $this->response = $response; $this->server = $this->request->getServerParams(); $request = $request->withAttribute('base_path', $this->getBasePath()); $request = $request->withAttribute('base_uri', $this->getBaseUri()); $request = $request->withAttribute('host_url', $this->getHostUrl()); //$x = $request->getAttribute('base_path', 'default'); }
private function _extractDataPSR7(ServerRequestInterface $request = null, $name = '') { $method = $request->getMethod(); $queryParams = $request->getQueryParams(); if ('GET' === $method) { if ('' === $name) { return $queryParams; } // Don't submit GET requests if the form's name does not exist // in the request if (!isset($queryParams[$name])) { return; } return $queryParams[$name]; } $serverParams = $request->getServerParams(); $uploadedFiles = $request->getUploadedFiles(); if ('' === $name) { return $this->mergeParamsAndUploadedFiles($serverParams, $uploadedFiles); } if (isset($serverParams[$name]) || isset($uploadedFiles[$name])) { $default = null; $params = isset($serverParams[$name]) ? $serverParams[$name] : null; $files = isset($uploadedFiles[$name]) ? $uploadedFiles[$name] : null; return $this->mergeParamsAndUploadedFiles($params, $files); } // Don't submit the form if it is not present in the request return; }
/** * @param \Psr\Http\Message\ServerRequestInterface $request * * @throws \OAuth2\Exception\BadRequestExceptionInterface */ private function checkRequestIsSecured(ServerRequestInterface $request) { $server_params = $request->getServerParams(); if (empty($server_params['HTTPS']) || 'on' !== mb_strtolower($server_params['HTTPS'], '8bit')) { throw $this->getExceptionManager()->getBadRequestException(ExceptionManagerInterface::ERROR_INVALID_REQUEST, 'The request must be secured.'); } }
/** * Find out the client's IP address from the headers available to us * * @param ServerRequestInterface $request PSR-7 Request * @return string */ protected function determineClientIpAddress($request) { $ipAddress = null; $serverParams = $request->getServerParams(); if (isset($serverParams['REMOTE_ADDR']) && $this->isValidIpAddress($serverParams['REMOTE_ADDR'])) { $ipAddress = $serverParams['REMOTE_ADDR']; } $checkProxyHeaders = $this->checkProxyHeaders; if ($checkProxyHeaders && !empty($this->trustedProxies)) { if (!in_array($ipAddress, $this->trustedProxies)) { $checkProxyHeaders = false; } } if ($checkProxyHeaders) { foreach ($this->headersToInspect as $header) { if ($request->hasHeader($header)) { $ip = trim(current(explode(',', $request->getHeaderLine($header)))); if ($this->isValidIpAddress($ip)) { $ipAddress = $ip; break; } } } } return $ipAddress; }
/** * @param string $name * @param array $options * * @return bool */ public function isValid($name, array $options = []) { $options += ['referer' => null, 'token' => null]; if (null === $options['token']) { $params = $this->request->getParsedBody(); if (!isset($params[$name])) { $this->invalidate(); return false; } else { $options['token'] = $params[$name]; } } $error = false; $name .= $options['token']; $config = array_get([self::TOKEN_KEY, $name], $this->storage, []); $time = isset($config['expire']) ? $config['expire'] : 0; if (time() > $time) { $error = true; } if (!$error && null !== $options['referer']) { $params = $this->request->getServerParams(); if (!isset($params['HTTP_REFERER']) || $params['HTTP_REFERER'] !== $options['referer']) { $error = true; } } $regenerate = array_key_exists('regenerate', $config) ? $config['regenerate'] : false; if ($error || !$regenerate) { array_remove([self::TOKEN_KEY, $name], $this->storage); } elseif ($regenerate) { $config['expire'] = time() + $config['time']; array_set([self::TOKEN_KEY, $name], $config, $this->storage); } $this->invalidate(); return !$error; }
/** * Handle authentication * * @param \Psr\Http\Message\ServerRequestInterface $request PSR7 request * @param \Psr\Http\Message\ResponseInterface $response PSR7 response * @param callable $next Next middleware * * @return \Psr\Http\Message\ResponseInterface */ public function __invoke(Request $request, Response $response, $next) { $path = $request->getUri()->getPath(); if ($path && $path != 'login') { $serverParams = $request->getServerParams(); $authHeader = isset($serverParams['HTTP_X_AUTHORIZATION']) ? $serverParams['HTTP_X_AUTHORIZATION'] : null; list($jwt) = sscanf($authHeader, 'Bearer %s'); if (!$jwt) { return $response->withStatus(401)->write(json_encode(['message' => '401 Unauthorized'])); } try { $settings = $this->app->getContainer()->get('settings'); $secretKey = base64_decode($settings->get('jwt')['key']); $token = JWT::decode($jwt, $secretKey, [$settings->get('jwt')['algorithm']]); // Get the user info and add to the container $this->app->getContainer()['currentUser'] = function ($c) use($token) { return $token->data; // user attributes }; } catch (\Exception $e) { return $response->withStatus(401)->write(json_encode(['message' => $e->getMessage()])); } } $response = $next($request, $response); return $response; }
/** * @param ServerRequestInterface $request * @return BaseResponse|Response */ public static function back(ServerRequestInterface $request) { $serverParams = $request->getServerParams(); if (isset($serverParams['HTTP_REFERER'])) { return static::redirect($serverParams['HTTP_REFERER']); } return static::factory(200, "<script>window.history.back()</script>"); }
/** * {@inheritdoc} */ public function createRequest(ServerRequestInterface $psrRequest) { $parsedBody = $psrRequest->getParsedBody(); $parsedBody = is_array($parsedBody) ? $parsedBody : array(); $request = new Request($psrRequest->getQueryParams(), $parsedBody, $psrRequest->getAttributes(), $psrRequest->getCookieParams(), $this->getFiles($psrRequest->getUploadedFiles()), $psrRequest->getServerParams(), $psrRequest->getBody()->__toString()); $request->headers->replace($psrRequest->getHeaders()); return $request; }
/** * Returns the client IP address * * @param \Psr\Http\Message\ServerRequestInterface $request * @return string|null IPv4 or IPv6 address or null if invalid */ protected function getIPAddress(\Psr\Http\Message\ServerRequestInterface $request) { $server = $request->getServerParams(); $flags = FILTER_FLAG_IPV4 | FILTER_FLAG_IPV6; if (isset($server['REMOTE_ADDR']) && ($ip = filter_var($server['REMOTE_ADDR'], FILTER_VALIDATE_IP, $flags)) !== false) { return $ip; } }
/** * Converts a PSR-7 request into an OAuth2 request. * * @param ServerRequestInterface $psrRequest * @return Request */ public static function convertRequestFromPsr7(ServerRequestInterface $psrRequest) { $headers = []; foreach ($psrRequest->getHeaders() as $header => $value) { $headers[$header] = implode(';', $value); } return new Request($psrRequest->getQueryParams(), is_array($psrRequest->getParsedBody()) ? $psrRequest->getParsedBody() : [], $psrRequest->getAttributes(), $psrRequest->getCookieParams(), self::getFiles($psrRequest->getUploadedFiles()), $psrRequest->getServerParams(), $psrRequest->getBody()->__toString(), $headers); }
/** * @param ServerRequestInterface $request * @param ResponseInterface $response * @param callable $next * @return ResponseInterface */ public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next = null) { $server = $request->getServerParams(); $response = $next ? $next($request, $response) : $response; $ms = (microtime(true) - $server['REQUEST_TIME_FLOAT']) * 1000; $time = sprintf('%2.' . $this->config['digits'] . 'f%s', $ms, $this->config['suffix'] ? 'ms' : ''); return $response->withHeader($this->config['header'], $time); }
public function __invoke(ServerRequestInterface $requestInterface, ResponseInterface $responseInterface, callable $next) { $valid = $this->verify($requestInterface->getParam('g-recaptcha-response'), $requestInterface->getServerParams()['REMOTE_ADDR']); if ($valid) { return $next($requestInterface, $responseInterface); } else { throw new \Exception("Captcha Failed"); } }
/** * Execute the middleware. * * @param ServerRequestInterface $request * @param ResponseInterface $response * @param callable $next * * @return ResponseInterface */ public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next) { $server = $request->getServerParams(); if (!isset($server['REQUEST_TIME_FLOAT'])) { $server['REQUEST_TIME_FLOAT'] = microtime(true); } $response = $next($request, $response); $time = (microtime(true) - $server['REQUEST_TIME_FLOAT']) * 1000; return $response->withHeader(self::HEADER, sprintf('%2.3fms', $time)); }
/** * @param ServerRequestInterface $request * @param ResponseInterface $response * @param callable|null $out * @return ResponseInterface */ public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $out = null) : ResponseInterface { $serverParams = $request->getServerParams(); $remoteAddr = $serverParams['REMOTE_ADDR'] ?? 'unknown IP address'; // If request is not originating from localhost or from Docker local IP, we throw an RuntimeException if (!in_array($remoteAddr, $this->localhost) && !fnmatch('172.17.*', $remoteAddr)) { throw new RuntimeException(sprintf('Worker requests must come from localhost, request originated from %s given', $remoteAddr)); } return $out($request, $response); }
public function __construct(ServerRequestInterface $serverRequest) { $this->serverRequest = $serverRequest; // Parse the URL path $serverParams = $serverRequest->getServerParams(); if (isset($serverParams["PATH_INFO"])) { $path = $serverRequest->getServerParams()["PATH_INFO"]; $this->pathParts = explode('/', trim($path, '/')); } // Support old index.php?page=foo&id=3 if (empty($this->pathParts) && $this->hasRequestValue("p")) { $pageName = $this->getRequestString("p"); if ($this->hasRequestValue("id")) { $pageId = $this->getRequestInt("id"); $this->pathParts = [$pageName, (string) $pageId]; } else { $this->pathParts = [$pageName]; } } }
/** * Guesses the base URI of the application. * * @param Psr\Http\Message\ServerRequestInterface $request * @return Psr\Http\Message\ServerRequestInterface */ public static function guess(\Psr\Http\Message\ServerRequestInterface $request) { $server = $request->getServerParams(); $basename = basename($server['SCRIPT_FILENAME']); $position = strpos($server['SCRIPT_NAME'], $basename) - 1; $rootUri = substr($server['SCRIPT_NAME'], 0, $position); $oldPath = $request->getUri()->getPath(); $newPath = str_replace($rootUri, '', $oldPath); $uri = $request->getUri()->withPath($newPath); return $request->withUri($uri); }
public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next) { $uri = $request->getUri(); $uriPath = $uri->getPath(); $baseUrl = $this->baseUrlFinder->findBaseUrl($request->getServerParams(), $uriPath); $basePath = $this->detectBasePath($request->getServerParams(), $baseUrl); $request = $request->withAttribute(self::BASE_URL, $baseUrl); $request = $request->withAttribute(self::BASE_PATH, $basePath); if (!empty($baseUrl) && strpos($uriPath, $baseUrl) === 0) { $path = substr($uriPath, strlen($baseUrl)); $path = '/' . ltrim($path, '/'); $request = $request->withUri($uri->withPath($path)); } if ($this->urlHelper) { $this->urlHelper->setBasePath($baseUrl); } if ($this->basePathHelper) { $this->basePathHelper->setBasePath($basePath); } return $next($request, $response); }
/** * Set the "$attributeName" attribute to the client's IP address as determined from * the proxy header (X-Forwarded-For or from $_SERVER['REMOTE_ADDR'] * * @param ServerRequestInterface $request PSR7 request * @param ResponseInterface $response PSR7 response * @param callable $next Next middleware * * @return ResponseInterface */ public function __invoke(ServerRequestInterface $request, ResponseInterface $response, $next) { if (!$next) { return $response; } if (!empty($this->trustedProxies)) { // get IP address from REMOTE_ADDR or from the Request attribute $ipAddress = null; $serverParams = $request->getServerParams(); if (isset($serverParams['REMOTE_ADDR']) && $this->isValidIpAddress($serverParams['REMOTE_ADDR'])) { $ipAddress = $serverParams['REMOTE_ADDR']; } $ip = $request->getAttribute($this->ipAddressAttributeName); if ($this->isValidIpAddress($ip)) { $ipAddress = $ip; } if (!in_array($ipAddress, $this->trustedProxies)) { return $response = $next($request, $response); } } $uri = $request->getUri(); // scheme if ($request->hasHeader('X-Forwarded-Proto')) { $scheme = $request->getHeaderLine('X-Forwarded-Proto'); if (in_array($scheme, ['http', 'https'])) { $uri = $uri->withScheme($scheme); } } // host (& maybe port too) if ($request->hasHeader('X-Forwarded-Host')) { $host = trim(current(explode(',', $request->getHeaderLine('X-Forwarded-Host')))); $port = null; if (preg_match('/^(\\[[a-fA-F0-9:.]+\\])(:\\d+)?\\z/', $host, $matches)) { $host = $matches[1]; if ($matches[2]) { $port = (int) substr($matches[2], 1); } } else { $pos = strpos($host, ':'); if ($pos !== false) { $port = (int) substr($host, $pos + 1); $host = strstr($host, ':', true); } } $uri = $uri->withHost($host); if ($port) { $uri = $uri->withPort($port); } } $request = $request->withUri($uri); return $response = $next($request, $response); }
/** * @param \Psr\Http\Message\ServerRequestInterface $requestInterface * @param \Psr\Http\Message\ResponseInterface $responseInterface * @param callable $next * @return \Psr\Http\Message\ResponseInterface * @throws \Exception */ public function __invoke(ServerRequestInterface $requestInterface, ResponseInterface $responseInterface, callable $next) { if (is_array($requestInterface->getAttribute($this->permissionKey))) { $uri = $requestInterface->getServerParams()['REQUEST_URI']; if (in_array($uri, $requestInterface->getAttribute($this->permissionKey))) { return $next($requestInterface, $responseInterface); } else { throw new \Exception("User does not have permission to view this resource"); } } else { throw new \Exception("Permissions Not Loaded"); } }
/** * Match a request against the known routes. * * Implementations will aggregate required information from the provided * request instance, and pass them to the underlying router implementation; * when done, they will then marshal a `RouteResult` instance indicating * the results of the matching operation and return it to the caller. * * @param Request $request * @return RouteResult */ public function match(Request $request) { $this->_forbidRouteAdd = true; $params = $request->getServerParams(); $path = $params['PATH_INFO']; // get the matched route $matchedRoute = $this->_matchPathToRoutePath($path); // check if route exists if ($matchedRoute instanceof Route) { return RouteResult::fromRouteMatch($matchedRoute->getName(), $matchedRoute->getMiddleware(), $params); } return RouteResult::fromRouteFailure(); }
/** * @inheritDoc */ public function match(Request $request) { // Must inject routes prior to matching. $this->injectRoutes(); $path = $request->getUri()->getPath(); $method = $request->getMethod(); $params = $request->getServerParams(); $params['REQUEST_METHOD'] = $method; $route = $this->router->match($path, $params); if (false === $route) { return $this->marshalFailedRoute($request); } return $this->marshalMatchedRoute($route); }
/** * @param \Psr\Http\Message\ServerRequestInterface $request * * @return null|\HttpDigest\DigestDataInterface */ public function findAuthorizationHeader(ServerRequestInterface $request) { $server_params = $request->getServerParams(); if (array_key_exists('PHP_AUTH_DIGEST', $server_params)) { $data = new DigestData($server_params['PHP_AUTH_DIGEST']); $this->validateData($data); return $data; } $header = $request->getHeader('Authorization'); if (0 < count($header) && strtolower(substr($header[0], 0, 7)) === 'digest ') { $data = new DigestData(substr($header[0], 7, strlen($header[0]) - 7)); $this->validateData($data); return $data; } }
/** * {@inheritdoc} */ protected function data(ServerRequestInterface $request, Document $document) { $actor = $request->getAttribute('actor'); $ipAddress = array_get($request->getServerParams(), 'REMOTE_ADDR', '127.0.0.1'); if (!$request->getAttribute('bypassFloodgate')) { $this->floodgate->assertNotFlooding($actor); } $discussion = $this->bus->dispatch(new StartDiscussion($actor, array_get($request->getParsedBody(), 'data', []), $ipAddress)); // After creating the discussion, we assume that the user has seen all // of the posts in the discussion; thus, we will mark the discussion // as read if they are logged in. if ($actor->exists) { $this->bus->dispatch(new ReadDiscussion($discussion->id, $actor, 1)); } return $discussion; }
/** * @return array */ private function parseIncomingParams() { $parameters = []; $server = $this->request->getServerParams(); $body = $this->request->getBody(); $content_type = false; if (isset($server['CONTENT_TYPE'])) { $content_type = $server['CONTENT_TYPE']; } switch ($content_type) { case "application/json": $body_params = json_decode($body, true); if ($body_params) { foreach ($body_params as $param_name => $param_value) { $parameters[$param_name] = $param_value; } } break; case "application/x-www-form-urlencoded": parse_str($body, $postvars); foreach ($postvars as $field => $value) { $parameters[$field] = $value; } break; } return $parameters; }
/** * @param ServerRequestInterface $request * @return string */ protected function findOutRemoteAddr(ServerRequestInterface $request) { $forwardedFor = $request->getHeaderLine('X-Forwarded-For'); if (empty($forwardedFor)) { $serverParams = $request->getServerParams(); return isset($serverParams['REMOTE_ADDR']) ? $serverParams['REMOTE_ADDR'] : null; } $ips = explode(',', $forwardedFor); return $ips[0]; }
/** * @return Cookie\CookiePool */ public function getCookies() { if (!isset($this->cookies)) { $server = $this->request->getServerParams(); $secure = isset($server['HTTPS']) && $server['HTTPS'] != 'off'; $this->cookies = new Cookie\CookiePool($this->path, $this->domain, true, $secure); foreach ($this->request->getCookieParams() as $name => $value) { $this->cookies->add(new Cookie\RequestCookie($name, $value)); } } return $this->cookies; }