/** * @return string */ public function getRequestId() { if ($this->request->hasHeader($this->headerName)) { return $this->request->getHeader($this->headerName); } return $this->fallback->getRequestId(); }
/** * {@inheritdoc} */ public function getHeader($header) { if (!$this->request->hasHeader($header)) { if (strtolower($header) === 'host' && ($this->request->getUri() && $this->request->getUri()->getHost())) { return array($this->getHostFromUri()); } return array(); } return $this->request->getHeader($header); }
/** * @Then the sent request should contain an :header header */ public function theSentRequestShouldContainAnHeader($header) { if (null === $this->request) { throw new \RuntimeException('No request found, maybe no registered hook, right?'); } else { if (!$this->request->hasHeader($header)) { throw new \RuntimeException('Header not found in request'); } } }
private function addExpectHeader(RequestInterface $request, array $options, array &$modify) { // Determine if the Expect header should be used if ($request->hasHeader('Expect')) { return; } $expect = isset($options['expect']) ? $options['expect'] : null; // Return if disabled or if you're not using HTTP/1.1 or HTTP/2.0 if ($expect === false || $request->getProtocolVersion() < 1.1) { return; } // The expect header is unconditionally enabled if ($expect === true) { $modify['set_headers']['Expect'] = '100-Continue'; return; } // By default, send the expect header when the payload is > 1mb if ($expect === null) { $expect = 1048576; } // Always add if the body cannot be rewound, the size cannot be // determined, or the size is greater than the cutoff threshold $body = $request->getBody(); $size = $body->getSize(); if ($size === null || $size >= (int) $expect || !$body->isSeekable()) { $modify['set_headers']['Expect'] = '100-Continue'; } }
/** * @param RequestInterface $request * @return MatchResultInterface */ public function match(RequestInterface $request) { if ($request->hasHeader('X-GitHub-Event')) { return new MatchResult(true, $this->getNotificationEvent($request)); } return new UnmatchedResult(); }
/** * Always add a x-amz-content-sha-256 for data integrity. */ public function presign(RequestInterface $request, CredentialsInterface $credentials, $expires) { if (!$request->hasHeader('x-amz-content-sha256')) { $request = $request->withHeader('X-Amz-Content-Sha256', $this->getPresignedPayload($request)); } return parent::presign($request, $credentials, $expires); }
/** * @param RequestInterface $request * @return MatchResultInterface */ public function match(RequestInterface $request) { if ($request->hasHeader('x-amz-sns-message-type')) { return new MatchResult(true, $this->getNotificationEvent($request)); } return new UnmatchedResult(); }
/** * {@inheritdoc} */ public function handleRequest(RequestInterface $request, callable $next, callable $first) { foreach ($this->headers as $header) { if ($request->hasHeader($header)) { $request = $request->withoutHeader($header); } } return $next($request); }
public function __invoke(CommandInterface $command, RequestInterface $request) { $name = $command->getName(); $body = $request->getBody(); if (!$request->hasHeader('Content-MD5') && $body->getSize() && in_array($name, self::$requireMd5)) { $request = $request->withHeader('Content-MD5', base64_encode(Psr7\hash($body, 'md5', true))); } $next = $this->nextHandler; return $next($command, $request); }
/** * Normalizes the custom headers for signing. * * @return string[] * An array of normalized headers. */ protected function normalizeCustomHeaders() { $headers = []; // The spec requires that headers are sorted by header name. sort($this->headers); foreach ($this->headers as $header) { if ($this->request->hasHeader($header)) { $headers[] = strtolower($header) . ':' . $this->request->getHeaderLine($header); } } return $headers; }
/** * Signs the request, adds the HMAC hash to the authorization header. * * @param \Psr\Http\Message\RequestInterface $request * * @return \Psr\Http\Message\RequestInterface */ public function signRequest(RequestInterface $request) { if (!$request->hasHeader('Date')) { $time = new \DateTime(); $time->setTimezone(new \DateTimeZone('GMT')); $request = $request->withHeader('Date', $time->format('D, d M Y H:i:s \\G\\M\\T')); } if (!$request->hasHeader('Content-Type')) { $request = $request->withHeader('Content-Type', $this->defaultContentType); } $authorization = $this->requestSigner->getAuthorization(new RequestWrapper($request), $this->id, $this->secretKey); return $request->withHeader('Authorization', $authorization); }
/** * Take a request and update the $_SERVER global to match * * @param RequestInterface $request */ private function forgeServerGlobal(RequestInterface $request) { $_SERVER['REQUEST_URI'] = $request->getUri()->getPath(); $_SERVER['REQUEST_METHOD'] = $request->getMethod(); $_SERVER['QUERY_STRING'] = $request->getUri()->getQuery(); if ($request->hasHeader('Content-Type')) { $_SERVER['CONTENT_TYPE'] = $request->getHeaderLine('Content-Type'); } if ($request->hasHeader('Referer')) { $_SERVER['HTTP_REFERER'] = $request->getHeaderLine('Referer'); } if ($request->hasHeader('X-Requested-with')) { $_SERVER['HTTP_X_REQUESTED_WITH'] = $request->getHeaderLine('X-Requested-With'); } if ($request->hasHeader('User-Agent')) { $_SERVER['HTTP_USER_AGENT'] = $request->getHeaderLine('User-Agent'); } if ($request->hasHeader('X-Forwarded-For')) { $_SERVER['HTTP_X_FORWARDED_FOR'] = $request->getHeaderLine('X-Forwarded-For'); } return $this; }
/** * {@inheritdoc} */ public function handleRequest(RequestInterface $request, callable $next, callable $first) { if (!$request->hasHeader('Content-Length')) { $stream = $request->getBody(); // Cannot determine the size so we use a chunk stream if (null === $stream->getSize()) { $stream = new ChunkStream($stream); $request = $request->withBody($stream); } else { $request = $request->withHeader('Content-Length', $stream->getSize()); } } return $next($request); }
public function __invoke(CommandInterface $command, RequestInterface $request) { $next = $this->nextHandler; $name = $command->getName(); $body = $request->getBody(); if (in_array($name, self::$md5) && !$request->hasHeader('Content-MD5')) { // Set the content MD5 header for operations that require it. $request = $request->withHeader('Content-MD5', base64_encode(Psr7\hash($body, 'md5', true))); } elseif (in_array($name, self::$sha256) && $command['ContentSHA256']) { // Set the content hash header if provided in the parameters. $request = $request->withHeader('X-Amz-Content-Sha256', $command['ContentSHA256']); } return $next($command, $request); }
protected function getPayload(RequestInterface $request) { // Calculate the request signature payload if ($request->hasHeader('X-Amz-Content-Sha256')) { // Handle streaming operations (e.g. Glacier.UploadArchive) return $request->getHeaderLine('X-Amz-Content-Sha256'); } if (!$request->getBody()->isSeekable()) { throw new CouldNotCreateChecksumException('sha256'); } try { return Psr7\hash($request->getBody(), 'sha256'); } catch (\Exception $e) { throw new CouldNotCreateChecksumException('sha256', $e); } }
/** * {@inheritDoc} */ public static function createFromRequest(RequestInterface $request) { if (!$request->hasHeader('Authorization')) { throw new MalformedRequestException('Authorization header is required.', null, 0, $request); } $header = $request->getHeaderLine('Authorization'); $id_match = preg_match('/.*id="(.*?)"/', $header, $id_matches); $realm_match = preg_match('/.*realm="(.*?)"/', $header, $realm_matches); $nonce_match = preg_match('/.*nonce="(.*?)"/', $header, $nonce_matches); $version_match = preg_match('/.*version="(.*?)"/', $header, $version_matches); $signature_match = preg_match('/.*signature="(.*?)"/', $header, $signature_matches); $headers_match = preg_match('/.*headers="(.*?)"/', $header, $headers_matches); if (!$id_match || !$realm_match || !$nonce_match || !$version_match || !$signature_match) { throw new MalformedRequestException('Authorization header requires a realm, id, version, nonce and a signature.', null, 0, $request); } $customHeaders = !empty($headers_matches[1]) ? explode('%3B', $headers_matches[1]) : []; return new static(rawurldecode($realm_matches[1]), $id_matches[1], $nonce_matches[1], $version_matches[1], $customHeaders, $signature_matches[1]); }
/** * @param RequestInterface $request * @param array $options * * @return PromiseInterface */ public function __invoke(RequestInterface $request, array $options) { $nextHandler = $this->nextHandler; if ($request->hasHeader('Authorization')) { return $nextHandler($request, $options); } $request = $request->withHeader('Authorization', sprintf('Bearer %s', $this->session->getToken())); return $nextHandler($request, $options)->then(function (ResponseInterface $response) use($request, $options) { $code = $response->getStatusCode(); if ($code < 400) { return $response; } if ($response->hasHeader("WWW-Authenticate")) { throw BearerErrorResponseException::create($request, $response); } throw RequestException::create($request, $response); }); }
/** * {@inheritDoc} * * @throws \InvalidArgumentException */ protected function compareTimestamp(RequestInterface $request, $expiry) { if (!$request->hasHeader('X-Authorization-Timestamp')) { throw new MalformedRequestException('Request is missing X-Authorization-Timestamp.', null, 0, $request); } $timestamp = (int) $request->getHeaderLine('X-Authorization-Timestamp'); $current = $this->getCurrentTimestamp(); // Is the request too old? $lowerLimit = $this->getExpiry($expiry, $timestamp); if ($current > $lowerLimit) { return -1; } // Is the request too far in the future? $upperLimit = $this->getExpiry($expiry, $current); if ($timestamp > $upperLimit) { return 1; } // Timestamp is within the expected range. return 0; }
private function getDefaultContext(RequestInterface $request) { $headers = ''; foreach ($request->getHeaders() as $name => $value) { foreach ($value as $val) { $headers .= "{$name}: {$val}\r\n"; } } $context = ['http' => ['method' => $request->getMethod(), 'header' => $headers, 'protocol_version' => $request->getProtocolVersion(), 'ignore_errors' => true, 'follow_location' => 0]]; $body = (string) $request->getBody(); if (!empty($body)) { $context['http']['content'] = $body; // Prevent the HTTP handler from adding a Content-Type header. if (!$request->hasHeader('Content-Type')) { $context['http']['header'] .= "Content-Type:\r\n"; } } $context['http']['header'] = rtrim($context['http']['header']); return $context; }
/** * @param RequestInterface $request * * @return ParsedUrlInterface|null */ protected function getOrigin(RequestInterface $request) { $origin = null; if ($request->hasHeader(CorsRequestHeaders::ORIGIN) === true) { $headerValue = $request->getHeader(CorsRequestHeaders::ORIGIN); empty($headerValue) === false ? $origin = $this->factory->createParsedUrl($headerValue[0]) : null; } return $origin; }
/** * Return remote socket from the request. * * @param RequestInterface $request * * @throws InvalidRequestException When no remote can be determined from the request * * @return string */ private function determineRemoteFromRequest(RequestInterface $request) { if (!$request->hasHeader('Host') && $request->getUri()->getHost() === '') { throw new InvalidRequestException('Remote is not defined and we cannot determine a connection endpoint for this request (no Host header)', $request); } $host = $request->getUri()->getHost(); $port = $request->getUri()->getPort() ?: ($request->getUri()->getScheme() === 'https' ? 443 : 80); $endpoint = sprintf('%s:%s', $host, $port); // If use the host header if present for the endpoint if (empty($host) && $request->hasHeader('Host')) { $endpoint = $request->getHeaderLine('Host'); } return sprintf('tcp://%s', $endpoint); }
/** * @param RequestInterface $request * @return bool */ public function isVaryEquals(RequestInterface $request) { if ($this->response->hasHeader('Vary')) { if ($this->request === null) { return false; } $varyHeaders = new KeyValueHttpHeader($this->response->getHeader('Vary')); foreach ($varyHeaders as $key => $value) { if (!$this->request->hasHeader($key) && !$request->hasHeader($key)) { // Absent from both continue; } elseif ($this->request->getHeaderLine($key) == $request->getHeaderLine($key)) { // Same content continue; } return false; } } return true; }
/** * {@inheritDoc} */ public function getAuthorizedRequest(RequestInterface $request, array $customHeaders = []) { if ($request->hasHeader('Authorization')) { $authHeader = AuthorizationHeader::createFromRequest($request); } else { $authHeader = $this->buildAuthorizationHeader($request, $customHeaders); } /** @var RequestInterface $request */ $request = $request->withHeader('Authorization', (string) $authHeader); return $request; }
/** * Return a CacheEntry or null if no cache. * * @param RequestInterface $request * * @return CacheEntry|null */ public function fetch(RequestInterface $request) { /** @var int|null $maxAge */ $maxAge = null; if ($request->hasHeader('Cache-Control')) { $reqCacheControl = new KeyValueHttpHeader($request->getHeader('Cache-Control')); if ($reqCacheControl->has('no-cache')) { // Can't return cache return null; } $maxAge = $reqCacheControl->get('max-age', null); } elseif ($request->hasHeader('Pragma')) { $pragma = new KeyValueHttpHeader($request->getHeader('Pragma')); if ($pragma->has('no-cache')) { // Can't return cache return null; } } $cache = $this->storage->fetch($this->getCacheKey($request)); if ($cache !== null) { if ((string) $cache->getOriginalRequest()->getUri() !== (string) $request->getUri()) { return null; } if ($maxAge !== null) { if ($cache->getAge() > $maxAge) { // Cache entry is too old for the request requirements! return null; } } if (!$cache->isVaryEquals($request)) { return null; } } return $cache; }
/** * Return remote socket from the request * * @param RequestInterface $request * * @throws NetworkException When no remote can be determined from the request * * @return string */ private function determineRemoteFromRequest(RequestInterface $request) { if ($request->getUri()->getHost() == "" && !$request->hasHeader('Host')) { throw new NetworkException("Cannot find connection endpoint for this request", $request); } $host = $request->getUri()->getHost(); $port = $request->getUri()->getPort() ?: ($request->getUri()->getScheme() == "https" ? 443 : 80); $endpoint = sprintf("%s:%s", $host, $port); // If use the host header if present for the endpoint if (empty($host) && $request->hasHeader('Host')) { $endpoint = $request->getHeaderLine('Host'); } return sprintf('tcp://%s', $endpoint); }
private function applyBody(RequestInterface $request, array $options, array &$conf) { $size = $request->hasHeader('Content-Length') ? (int) $request->getHeaderLine('Content-Length') : null; // Send the body as a string if the size is less than 1MB OR if the // [curl][body_as_string] request value is set. if ($size !== null && $size < 1000000 || !empty($options['_body_as_string'])) { $conf[CURLOPT_POSTFIELDS] = (string) $request->getBody(); // Don't duplicate the Content-Length header $this->removeHeader('Content-Length', $conf); $this->removeHeader('Transfer-Encoding', $conf); } else { $conf[CURLOPT_UPLOAD] = true; if ($size !== null) { $conf[CURLOPT_INFILESIZE] = $size; $this->removeHeader('Content-Length', $conf); } $body = $request->getBody(); $conf[CURLOPT_READFUNCTION] = function ($ch, $fd, $length) use($body) { return $body->read($length); }; } // If the Expect header is not present, prevent curl from adding it if (!$request->hasHeader('Expect')) { $conf[CURLOPT_HTTPHEADER][] = 'Expect:'; } // cURL sometimes adds a content-type by default. Prevent this. if (!$request->hasHeader('Content-Type')) { $conf[CURLOPT_HTTPHEADER][] = 'Content-Type:'; } }
/** * Generates cURL options * * @param RequestInterface $request * * @throws UnexpectedValueException if unsupported HTTP version requested * * @return array */ private function createCurlOptions(RequestInterface $request) { $options = array_key_exists('curl_options', $this->options) ? $this->options['curl_options'] : []; $options[CURLOPT_HEADER] = true; $options[CURLOPT_RETURNTRANSFER] = true; $options[CURLOPT_HTTP_VERSION] = $this->getProtocolVersion($request->getProtocolVersion()); $options[CURLOPT_URL] = (string) $request->getUri(); $options[CURLOPT_CONNECTTIMEOUT] = $this->options['connection_timeout']; $options[CURLOPT_FOLLOWLOCATION] = $this->options['follow_redirects']; $options[CURLOPT_MAXREDIRS] = $this->options['max_redirects']; $options[CURLOPT_SSL_VERIFYPEER] = $this->options['ssl_verify_peer']; $options[CURLOPT_TIMEOUT] = $this->options['timeout']; if ($this->options['decode_content'] && $request->hasHeader('accept-encoding')) { $options[CURLOPT_ENCODING] = $request->getHeaderLine('accept-encoding'); } if ($this->options['use_cookies'] && $request->hasHeader('cookie')) { $options[CURLOPT_COOKIE] = implode('; ', $request->getHeader('cookie')); } switch ($request->getMethod()) { case 'GET': $options[CURLOPT_HTTPGET] = true; break; case 'HEAD': $options[CURLOPT_NOBODY] = true; break; case 'POST': case 'CONNECT': case 'DELETE': case 'PATCH': case 'PUT': case 'TRACE': $options[CURLOPT_CUSTOMREQUEST] = $request->getMethod(); break; } $headers = array_keys($request->getHeaders()); foreach ($headers as $name) { $values = $request->getHeader($name); foreach ($values as $value) { $options[CURLOPT_HTTPHEADER][] = $name . ': ' . $value; } } if ($request->getUri()->getUserInfo()) { $options[CURLOPT_USERPWD] = $request->getUri()->getUserInfo(); } return $options; }
public function sendAsync(RequestInterface $request, array $options = []) { // Merge the base URI into the request URI if needed. $options = $this->prepareDefaults($options); return $this->transfer($request->withUri($this->buildUri($request->getUri(), $options), $request->hasHeader('Host')), $options); }
/** * @param RequestInterface $request * * @return bool */ private function isRequestValid(RequestInterface $request) { $uri = $request->getUri(); $queryParams = \GuzzleHttp\Psr7\parse_query($uri->getQuery()); return $request->hasHeader('Authorization') || $request->hasHeader('Authentication') || array_key_exists('jwt', $queryParams) || !empty($queryParams['jwt']); }
/** * @param string $header * @return bool */ public function hasHeader($header) { return $this->request->hasHeader($header); }