/** * Check the current url for oauth paths * * @param RequestInterface $request PSR7 request object * @param ResponseInterface $response PSR7 response object * * @return ResponseInterface|false PSR7 response object */ private function checkForOAuthPaths(RequestInterface $request, ResponseInterface $response) { $path = $request->getUri()->getPath(); if (!is_string($path)) { return false; } // this matches the request to authenticate for an oauth provider if (1 === preg_match($this->getAuthRouteRegex(), $path, $matches)) { // validate we have an allowed oAuthServiceType if (!in_array($matches['oAuthServiceType'], $this->oAuthProviders)) { throw new Exception("Unknown oAuthServiceType"); } // validate the return url parse_str($_SERVER['QUERY_STRING'], $query); if (!array_key_exists('return', $query) || filter_var($query['return'], FILTER_VALIDATE_URL) === false) { throw new Exception("Invalid return url"); } $_SESSION['oauth_return_url'] = $query['return']; $url = $this->oAuthFactory->getOrCreateByType($matches['oAuthServiceType'])->getAuthorizationUri(); return $response->withStatus(302)->withHeader('Location', $url); } elseif (1 === preg_match($this->getCallbackRouteRegex(), $path, $matches)) { // this matches the request to post-authentication for an oauth provider if (!in_array($matches['oAuthServiceType'], $this->oAuthProviders)) { throw new Exception("Unknown oAuthServiceType"); } $service = $this->oAuthFactory->getOrCreateByType($matches['oAuthServiceType']); // turn our code into a token that's stored internally $service->requestAccessToken($request->getParam('code')); // validates and creates the user entry in the db if not already exists $user = $this->userService->createUser($service); // set our token in the header and then redirect to the client's chosen url return $response->withStatus(200)->withHeader('Authorization', 'token ' . $user->token)->withHeader('Location', $_SESSION['oauth_return_url']); } return false; }
/** * @param \Psr\Http\Message\RequestInterface $request * @param \Psr\Http\Message\ResponseInterface $response * * @return string */ protected function describe(RequestInterface $request, ResponseInterface $response = null) { if (!$response) { return sprintf('%s %s failed', $request->getMethod(), $request->getUri()); } return sprintf('%s %s returned %s %s', $request->getMethod(), $request->getUri(), $response->getStatusCode(), $response->getReasonPhrase()); }
/** * Starts the profiling. * @param RequestInterface $request */ public function enter(RequestInterface $request = null) { $this->starts = ['wt' => microtime(true), 'mu' => memory_get_usage(), 'pmu' => memory_get_peak_usage()]; if ($request) { $this->request = ['method' => $request->getMethod(), 'url' => (string) $request->getUri(), 'body' => (string) $request->getBody()]; } }
/** * Send a request to the server and return a Response object with the response. * * @param RequestInterface $request The request object to send. * * @return ResponseInterface * * @since 2.1 */ public function request(RequestInterface $request) { $uri = $request->getUri()->withPath(null)->withQuery(null)->withFragment(null); $uri = $uri . $request->getRequestTarget(); $request = $request->withRequestTarget($uri); return $this->doRequest($request); }
/** * @return string */ public function getUri() { if (!$this->request) { return null; } return (string) $this->request->getUri(); }
/** * @param ServerRequestInterface $request PSR7 Request. * @param ResponseInterface $response PSR7 Response. * @return ResponseInterface */ public function run(RequestInterface $request, ResponseInterface $response) { $widgetType = $request->getParam('widget_type'); $widgetOptions = $request->getParam('widget_options'); if (!$widgetType) { $this->setSuccess(false); return $response->withStatus(400); } try { $widget = $this->widgetFactory->create($widgetType); $widget->setView($this->widgetView); if (is_array($widgetOptions)) { $widget->setData($widgetOptions); } $widgetHtml = $widget->renderTemplate($widgetType); $widgetId = $widget->widgetId(); $this->setWidgetHtml($widgetHtml); $this->setWidgetId($widgetId); $this->setSuccess(true); return $response; } catch (Exception $e) { $this->addFeedback('error', sprintf('An error occured reloading the widget: "%s"', $e->getMessage())); $this->addFeedback('error', $e->getMessage()); $this->setSuccess(false); return $response->withStatus(500); } }
/** * @param RequestInterface $request * @param string $name * @return string */ public function getAttribute(RequestInterface $request, $name) { if (!$request instanceof ServerRequestInterface) { throw new \InvalidArgumentException('Request is not of type ' . ServerRequestInterface::class); } return $request->getAttribute($name); }
/** * Note that the lost-password action should never change status code and always return 200. * * @param RequestInterface $request A PSR-7 compatible Request instance. * @param ResponseInterface $response A PSR-7 compatible Response instance. * @return ResponseInterface * @todo This should be done via an Authenticator object. */ public function run(RequestInterface $request, ResponseInterface $response) { $username = $request->getParam('username'); if (!$username) { $this->addFeedback('error', 'Missing username.'); $this->setSuccess(false); return $response->withStatus(404); } $recaptchaValue = $request->getParam('g-recaptcha-response'); if (!$recaptchaValue) { $this->addFeedback('error', 'Missing captcha.'); $this->setSuccess(false); return $response->withStatus(404); } if (!$this->validateCaptcha($recaptchaValue)) { $this->addFeedback('error', 'Invalid captcha.'); $this->setSuccess(false); return $response->withStatus(404); } $user = $this->loadUser($username); if (!$user) { // Fail silently. $this->logger->error('Lost password request: can not find user in database.'); return $response; } $token = $this->generateLostPasswordToken($user); $this->sendLostPasswordEmail($user, $token); return $response; }
/** * @param \Psr\Http\Message\RequestInterface $request * * @return \Psr\Http\Message\RequestInterface */ public function sign(RequestInterface $request) { $timestamp = (new \DateTime('now', new \DateTimeZone('UTC')))->getTimestamp(); $data = implode('|', [$request->getMethod(), rtrim((string) $request->getUri(), '/'), $timestamp]); $signature = $this->signer->sign($data); return $request->withHeader(self::TIMESTAMP_HEADER, $timestamp)->withHeader(self::SIGNATURE_HEADER, $signature); }
/** * Invoke this state. States are invoked until they return something * non-invokable. * * @param array $arguments All matched URL parameters. * @param Psr\Http\Message\RequestInterface $request The current request. * @return mixed Whatever the state eventually resolves to. */ public function __invoke(array $arguments, RequestInterface $request) { $method = $request->getMethod(); if (!isset($this->actions[$method])) { return new EmptyResponse(405); } $call = $this->actions[$method]; $this->request = $request; do { $args = $this->parseArguments($call, $arguments); foreach ($args as &$value) { if (is_string($value) && $this->isHttpAction(substr($value, 1))) { $key = substr($value, 1); if ($key == $method) { throw new EndlessStateLoopException(); } if (isset($this->actions[$key])) { $value = $this->actions[$key]; } else { $value = new EmptyResponse(405); } } } $call = call_user_func_array($call, $args); } while (is_callable($call)); return $call; }
function it_returns_body_with_headers(RequestInterface $request, Stream $stream) { $request->getHeaders()->shouldBeCalled()->willReturn(['content-type' => 'application/json']); $request->getBody()->shouldBeCalled()->willReturn($stream); $stream->getContents()->shouldBeCalled()->willReturn('{"data": {}}'); $this->getBodyWithHeaders($request)->shouldReturn('content-type: application/json' . PHP_EOL . PHP_EOL . '{"data": {}}'); }
/** * {@inheritdoc} */ public function send(RequestInterface $request, array $options = array()) { $options += Client::$defaultOptions; $curlOptions = $options['curl'] + array(CURLOPT_URL => (string) $request->getUri(), CURLOPT_CUSTOMREQUEST => $request->getMethod(), CURLOPT_RETURNTRANSFER => true, CURLOPT_HEADER => true, CURLOPT_SSL_VERIFYPEER => false, CURLOPT_HTTPHEADER => \EasyRequest\get_headers($request), CURLOPT_ENCODING => $request->getHeaderLine('Accept-Encoding'), CURLOPT_NOBODY => $options['nobody'], CURLOPT_CONNECTTIMEOUT => $options['timeout'], CURLOPT_HTTP_VERSION => $request->getProtocolVersion() == '1.0' ? CURL_HTTP_VERSION_1_0 : CURL_HTTP_VERSION_1_1); if ($options['upload']) { $body = $request->getBody(); $curlOptions += array(CURLOPT_UPLOAD => true, CURLOPT_READFUNCTION => function ($ch, $fp, $length) use($body) { return $body->read($length); }); } elseif ($options['body']) { $curlOptions[CURLOPT_POSTFIELDS] = (string) $request->getBody(); } if ($options['proxy']) { $curlOptions += array(CURLOPT_PROXY => $options['proxy'], CURLOPT_PROXYTYPE => $options['proxy_type']); if ($options['proxy_userpwd']) { $curlOptions[CURLOPT_PROXYUSERPWD] = $options['proxy_userpwd']; } } if ($options['bindto']) { $curlOptions[CURLOPT_INTERFACE] = $options['bindto']; } $header = $body = ''; $curlOptions[CURLOPT_HEADERFUNCTION] = $this->handleResponseHeader($header); $ch = curl_init(); curl_setopt_array($ch, $curlOptions); $result = curl_exec($ch); curl_close($ch); if ($result === false) { throw new Exception(sprintf('%d - %s', curl_errno($ch), curl_error($ch))); } $body = substr($result, strlen($header)); return Response::parse($header, $body); }
/** * 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); }
public function __invoke(RequestInterface $request, ResponseInterface $response, callable $next) { $path = $request->getUri()->getPath(); if (!isset($this->commands[$path])) { return $next($request, $response); } if ($request->getMethod() !== 'POST') { return $response->withStatus(405); } try { $payload = json_decode($request->getBody(), true); if ($payload === null) { $payload = []; } $command = $this->commands[$path]; if (!is_callable($command)) { throw new \RuntimeException("Command associated with the path {$path} is not callable"); } $command = call_user_func_array($command, [$payload]); $this->commandBus->dispatch($command); return $response->withStatus(202); } catch (CommandDispatchException $dispatchException) { $e = $dispatchException->getFailedCommandDispatch()->getException(); return $this->populateError($response, $e); } catch (\Exception $e) { return $this->populateError($response, $e); } }
/** * Factory method to create a new exception with a normalized error message * * @param RequestInterface $request Request * @param ResponseInterface $response Response received * @param \Exception $previous Previous exception * @param array $ctx Optional handler context. * * @return self */ public static function create(RequestInterface $request, ResponseInterface $response = null, \Exception $previous = null, array $ctx = []) { if (!$response) { return new self('Error completing request', $request, null, $previous, $ctx); } $level = (int) floor($response->getStatusCode() / 100); if ($level === 4) { $label = 'Client error'; $className = __NAMESPACE__ . '\\ClientException'; } elseif ($level === 5) { $label = 'Server error'; $className = __NAMESPACE__ . '\\ServerException'; } else { $label = 'Unsuccessful request'; $className = __CLASS__; } $uri = $request->getUri(); $uri = static::obfuscateUri($uri); // Server Error: `GET /` resulted in a `404 Not Found` response: // <html> ... (truncated) $message = sprintf('%s: `%s` resulted in a `%s` response', $label, $request->getMethod() . ' ' . $uri, $response->getStatusCode() . ' ' . $response->getReasonPhrase()); $summary = static::getResponseBodySummary($response); if ($summary !== null) { $message .= ":\n{$summary}\n"; } return new $className($message, $request, $response, $previous, $ctx); }
/** * @return string|null */ public function getLastRequestPath() { if (is_null($this->lastRequest)) { return null; } return $this->lastRequest->getUri(); }
/** * @param Request $request * * @return Response */ public function __invoke(Request $request) { $options = []; // Headers $headerLines = []; foreach ($request->getHeaders() as $name => $values) { $headerLines[] = sprintf('%s: %s', $name, implode(', ', $values)); } $options[CURLOPT_HTTPHEADER] = $headerLines; // Url $options[CURLOPT_URL] = (string) $request->getUri(); switch ($request->getMethod()) { case 'HEAD': $options[CURLOPT_NOBODY] = true; break; case 'GET': $options[CURLOPT_HTTPGET] = true; break; case 'POST': $options[CURLOPT_POST] = true; $options[CURLOPT_POSTFIELDS] = (string) $request->getBody(); // Don't duplicate the Content-Length header $request = $request->withoutHeader('Content-Length'); $request = $request->withoutHeader('Transfer-Encoding'); break; case 'PUT': // Write to memory/temp $file = fopen('php://temp/' . spl_object_hash($request), 'w+'); $bytes = fwrite($file, (string) $request->getBody()); rewind($file); $options[CURLOPT_PUT] = true; $options[CURLOPT_INFILE] = $file; $options[CURLOPT_INFILESIZE] = $bytes; $request = $request->withoutHeader('Content-Length'); break; default: $options[CURLOPT_CUSTOMREQUEST] = $request->getMethod(); } // If the Expect header is not present, prevent curl from adding it if (!$request->hasHeader('Expect')) { $options[CURLOPT_HTTPHEADER][] = 'Expect:'; } // cURL sometimes adds a content-type by default. Prevent this. if (!$request->hasHeader('Content-Type')) { $options[CURLOPT_HTTPHEADER][] = 'Content-Type:'; } list($body, $headerLines) = $this->execute($options); $headerLines = preg_split("#\r\n#", $headerLines, -1, PREG_SPLIT_NO_EMPTY); $headers = []; // Extract the version and status from the first header preg_match('#HTTP/(\\d\\.\\d)\\s(\\d\\d\\d)\\s(.*)#', array_shift($headerLines), $matches); array_shift($matches); list($protocolVersion, $statusCode, $reasonPhrase) = $matches; foreach ($headerLines as $line) { list($name, $values) = preg_split('#\\s*:\\s*#', $line, 2, PREG_SPLIT_NO_EMPTY); $headers[$name] = preg_split('#\\s*,\\s*#', $values, -1, PREG_SPLIT_NO_EMPTY); } $response = new \GuzzleHttp\Psr7\Response($statusCode, $headers, $body, $protocolVersion, $reasonPhrase); return $response; }
/** * @return string */ public function getRequestId() { if ($this->request->hasHeader($this->headerName)) { return $this->request->getHeader($this->headerName); } return $this->fallback->getRequestId(); }
/** * Forward the request to the target url and return the response. * * @param string $target * @throws UnexpectedValueException * @return Response */ public function to($target) { if (is_null($this->request)) { throw new UnexpectedValueException('Missing request instance.'); } $target = new Uri($target); // Overwrite target scheme and host. $uri = $this->request->getUri()->withScheme($target->getScheme())->withHost($target->getHost()); // Check for custom port. if ($port = $target->getPort()) { $uri = $uri->withPort($port); } // Check for subdirectory. if ($path = $target->getPath()) { $uri = $uri->withPath(rtrim($path, '/') . '/' . ltrim($uri->getPath(), '/')); } $request = $this->request->withUri($uri); $stack = $this->filters; $stack[] = function (RequestInterface $request, ResponseInterface $response, callable $next) { $response = $this->adapter->send($request); return $next($request, $response); }; $relay = (new RelayBuilder())->newInstance($stack); return $relay($request, new Response()); }
/** * @param RequestInterface $request * @return Message */ public function convertRequestToMessage(RequestInterface $request) { parse_str($request->getBody(), $body); $message = new Message($body['Message-Id']); $message->setSubject($body['Subject']); if (!empty($body['Reply-To'])) { $message->setReplyTo($body['Reply-To']); } elseif (!empty($body['Reply-to'])) { $message->setReplyTo($body['Reply-to']); } elseif (!empty($body['reply-to'])) { $message->setReplyTo($body['reply-to']); } if (!empty($body['From'])) { $message->setFrom($body['From']); } else { $message->setFrom($body['from']); } if (isset($body['To'])) { $message->setTo($body['To']); } if (!empty($body['body-html'])) { $message->setBodyHtml($body['body-html']); } if (!empty($body['stripped-html'])) { $body['stripped-html'] = html_entity_decode($body['stripped-html']); if (strpos($body['stripped-html'], 'å') !== false && stripos($body['stripped-html'], 'charset=iso-8859-2')) { $body['stripped-html'] = iconv('UTF-8', 'ISO-8859-2//TRANSLIT', $body['stripped-html']); } elseif (strpos($body['stripped-html'], 'á') !== false && stripos($body['stripped-html'], 'charset=windows-1250')) { $body['stripped-html'] = iconv('UTF-8', 'CP1250//TRANSLIT', $body['stripped-html']); } $message->setStrippedHtml($body['stripped-html']); } if (!empty($body['body-plain'])) { if (isset($body['stripped-html'])) { if (strpos($body['body-plain'], 'å') !== false && stripos($body['stripped-html'], 'charset=iso-8859-2')) { $body['body-plain'] = iconv('UTF-8', 'ISO-8859-2//TRANSLIT', $body['body-plain']); } elseif (strpos($body['body-plain'], 'á') !== false && stripos($body['stripped-html'], 'charset=windows-1250')) { $body['body-plain'] = iconv('UTF-8', 'CP1250//TRANSLIT', $body['body-plain']); } } $message->setBodyPlain($body['body-plain']); } if (!empty($body['References'])) { $message->setReferences($body['References']); } $message->setDate((new \DateTime())->setTimestamp($body['timestamp'])); $message->setSpam(isset($body['X-Mailgun-Sflag']) && $body['X-Mailgun-Sflag'] === 'yes'); $message->setSpamScore(isset($body['X-Mailgun-Sscore']) ? (double) $body['X-Mailgun-Sscore'] : 0); if (isset($body['attachments'])) { foreach (json_decode($body['attachments']) as $at) { if ($at->name == 'smime.p7s') { continue; } $attachment = new Attachment(); $attachment->setName($at->name)->setUrl(str_replace('https://', 'https://*****:*****@', $at->url)); $message->addAttachment($attachment); } } return $message; }
/** * @param RequestInterface $request * @return ResponseInterface */ public function send($request) { /** * var \GuzzleHttp\Message\Response $response */ $headers = $request->getHeaders(); if (!empty($this->append_headers)) { $headers = array_merge($headers, $this->append_headers); } $opt = []; if (!empty($this->basicAuth)) { $opt['auth'] = $this->basicAuth; } if (!empty($headers)) { $opt['headers'] = $headers; } $body = $request->getBody(); if ($body !== null) { $opt['body'] = $body; } $g4request = $this->getClient()->createRequest($request->getMethod(), $request->getUri(), $opt); try { $response = $this->getClient()->send($g4request); return new Response($response->getStatusCode(), $response->getHeaders(), $response->getBody()); } catch (\GuzzleHttp\Exception\RequestException $ex) { $ex_request = $ex->getRequest(); $ex_response = $ex->getResponse(); throw new RequestException($ex->getMessage(), $ex_request ? new Request($ex_request->getMethod(), $ex_request->getUrl(), $ex_request->getHeaders(), $ex_request->getBody()) : null, $ex_response ? new Response($ex_response->getStatusCode(), $ex_response->getHeaders(), $ex_response->getBody()) : null, $ex); } }
/** * Execute the middleware. * * @param RequestInterface $request * @param ResponseInterface $response * @param callable $next * * @return ResponseInterface */ public function __invoke(RequestInterface $request, ResponseInterface $response, callable $next) { $uri = $request->getUri(); $path = $this->getBasePath($uri->getPath()); $request = $request->withUri($uri->withPath($path)); return $next($request, $response); }
/** * @param RequestInterface $request A PSR-7 compatible Request instance. * @param ResponseInterface $response A PSR-7 compatible Response instance. * @return ResponseInterface */ public function run(RequestInterface $request, ResponseInterface $response) { try { $objType = $request->getParam('obj_type'); $objId = $request->getParam('obj_id'); if (!$objType) { $this->setSuccess(false); return $response->withStatus(404); } if (!$objId) { $this->setSuccess(false); return $response->withStatus(404); } $this->logger->debug(sprintf('Admin Deleting object "%s" ID %s', $objType, $objId)); $obj = $this->modelFactory()->create($objType); $obj->load($objId); if (!$obj->id()) { $this->setSuccess(false); return $response->withStatus(404); } $res = $obj->delete(); if ($res) { $this->setSuccess(true); return $response; } } catch (Exception $e) { $this->setSuccess(false); return $response->withStatus(500); } }
/** * Execute the middleware. * * @param RequestInterface $request * @param ResponseInterface $response * @param callable $next * * @return ResponseInterface */ public function __invoke(RequestInterface $request, ResponseInterface $response, callable $next) { $uri = $request->getUri(); $path = $uri->getPath(); //Test basePath if (!$this->testBasePath($path)) { return $next($request, $response); } //Add/remove slash if ($this->addSlash) { if (strlen($path) > 1 && substr($path, -1) !== '/' && !pathinfo($path, PATHINFO_EXTENSION)) { $path .= '/'; } } else { if (strlen($path) > 1 && substr($path, -1) === '/') { $path = substr($path, 0, -1); } } //Ensure the path has one "/" if (empty($path) || $path === $this->basePath) { $path .= '/'; } //redirect if (is_int($this->redirectStatus) && $uri->getPath() !== $path) { return self::getRedirectResponse($this->redirectStatus, $uri->withPath($path), $response); } return $next($request->withUri($uri->withPath($path)), $response); }
/** * Retrieves the HTTP protocol version as a string. * * The string MUST contain only the HTTP version number (e.g., "1.1", "1.0"). * * @return string HTTP protocol version. */ public function getProtocolVersion() { if ($this->overRidingProtocol !== null) { return $this->overRidingProtocol; } return $this->request->getProtocolVersion(); }
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'; } }
/** * {@inheritdoc} */ public function request(RequestInterface $request) { $url = (string) $request->getUri(); $body = $request->getBody(); $body->seek(0); $headers = $request->getHeaders(); $headers['Accept'] = 'application/json'; $headers['Content-Type'] = 'application/json'; $req = $this->guzzle->createRequest($request->getMethod(), $url); $req->setHeaders($headers); $req->setBody(GStream::factory($body->getContents())); try { $res = $this->guzzle->send($req); } catch (RequestException $e) { // Guzzle will throw exceptions for 4xx and 5xx responses, so we catch // them here and quietly get the response object. $res = $e->getResponse(); if (!$res) { throw $e; } } $response = (new Response(new Stream('php://memory', 'w')))->withStatus($res->getStatusCode(), $res->getReasonPhrase()); $response->getBody()->write((string) $res->getBody()); return $response; }
/** * 通过提供的凭证,对特定请求进行签名,并添加对应的 HTTP 头至请求中。 * * @param RequestInterface $request 要签名的请求。 * @param CredentialsInterface $credential 使用的凭证。 * * @return RequestInterface 修改(签名)过的请求。 */ public function signRequest(RequestInterface $request, CredentialsInterface $credential) { $content = base64_encode($credential['key'] . ':' . $credential['secret']); $basicSignature = "Basic {$content}"; // 先清除之前可能存在的 HTTP 头。 return $request->withoutHeader('Authorization')->withHeader('Authorization', $basicSignature); }
public function render(RequestInterface $request, ResponseInterface $response, $data) { $mediaType = $this->determineMediaType($request->getHeaderLine('Accept')); $output = $this->renderOutput($mediaType, $data); $response = $this->writeBody($response, $output); $response = $response->withHeader('Content-type', $mediaType); return $response; }
/** * {@inheritdoc} */ public function authenticate(RequestInterface $request) { // TODO: add error handling // TODO: support other grant types? $accessToken = $this->provider->getAccessToken('client_credentials'); return $request->withHeader('Authorization', 'Bearer ' . $accessToken); }