You are here

Home » API reference » Auth0 Single Sign On 8.2

functions.php in Auth0 Single Sign On 8.2

Same filename in this branch
  1. 8.2 vendor/guzzlehttp/psr7/src/functions.php
  2. 8.2 vendor/guzzlehttp/promises/src/functions.php
  3. 8.2 vendor/guzzlehttp/guzzle/src/functions.php

Namespace

GuzzleHttp\Psr7

File

vendor/guzzlehttp/psr7/src/functions.php
View source 
<?php

namespace GuzzleHttp\Psr7;

use Psr\Http\Message\MessageInterface;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\StreamInterface;
use Psr\Http\Message\UriInterface;

/**
 * Returns the string representation of an HTTP message.
 *
 * @param MessageInterface $message Message to convert to a string.
 *
 * @return string
 */
function str(MessageInterface $message) {
  if ($message instanceof RequestInterface) {
    $msg = trim($message
      ->getMethod() . ' ' . $message
      ->getRequestTarget()) . ' HTTP/' . $message
      ->getProtocolVersion();
    if (!$message
      ->hasHeader('host')) {
      $msg .= "\r\nHost: " . $message
        ->getUri()
        ->getHost();
    }
  }
  elseif ($message instanceof ResponseInterface) {
    $msg = 'HTTP/' . $message
      ->getProtocolVersion() . ' ' . $message
      ->getStatusCode() . ' ' . $message
      ->getReasonPhrase();
  }
  else {
    throw new \InvalidArgumentException('Unknown message type');
  }
  foreach ($message
    ->getHeaders() as $name => $values) {
    $msg .= "\r\n{$name}: " . implode(', ', $values);
  }
  return "{$msg}\r\n\r\n" . $message
    ->getBody();
}

/**
 * Returns a UriInterface for the given value.
 *
 * This function accepts a string or {@see Psr\Http\Message\UriInterface} and
 * returns a UriInterface for the given value. If the value is already a
 * `UriInterface`, it is returned as-is.
 *
 * @param string|UriInterface $uri
 *
 * @return UriInterface
 * @throws \InvalidArgumentException
 */
function uri_for($uri) {
  if ($uri instanceof UriInterface) {
    return $uri;
  }
  elseif (is_string($uri)) {
    return new Uri($uri);
  }
  throw new \InvalidArgumentException('URI must be a string or UriInterface');
}

/**
 * Create a new stream based on the input type.
 *
 * Options is an associative array that can contain the following keys:
 * - metadata: Array of custom metadata.
 * - size: Size of the stream.
 *
 * @param resource|string|null|int|float|bool|StreamInterface|callable|\Iterator $resource Entity body data
 * @param array                                                                  $options  Additional options
 *
 * @return StreamInterface
 * @throws \InvalidArgumentException if the $resource arg is not valid.
 */
function stream_for($resource = '', array $options = []) {
  if (is_scalar($resource)) {
    $stream = fopen('php://temp', 'r+');
    if ($resource !== '') {
      fwrite($stream, $resource);
      fseek($stream, 0);
    }
    return new Stream($stream, $options);
  }
  switch (gettype($resource)) {
    case 'resource':
      return new Stream($resource, $options);
    case 'object':
      if ($resource instanceof StreamInterface) {
        return $resource;
      }
      elseif ($resource instanceof \Iterator) {
        return new PumpStream(function () use ($resource) {
          if (!$resource
            ->valid()) {
            return false;
          }
          $result = $resource
            ->current();
          $resource
            ->next();
          return $result;
        }, $options);
      }
      elseif (method_exists($resource, '__toString')) {
        return stream_for((string) $resource, $options);
      }
      break;
    case 'NULL':
      return new Stream(fopen('php://temp', 'r+'), $options);
  }
  if (is_callable($resource)) {
    return new PumpStream($resource, $options);
  }
  throw new \InvalidArgumentException('Invalid resource type: ' . gettype($resource));
}

/**
 * Parse an array of header values containing ";" separated data into an
 * array of associative arrays representing the header key value pair
 * data of the header. When a parameter does not contain a value, but just
 * contains a key, this function will inject a key with a '' string value.
 *
 * @param string|array $header Header to parse into components.
 *
 * @return array Returns the parsed header values.
 */
function parse_header($header) {
  static $trimmed = "\"'  \n\t\r";
  $params = $matches = [];
  foreach (normalize_header($header) as $val) {
    $part = [];
    foreach (preg_split('/;(?=([^"]*"[^"]*")*[^"]*$)/', $val) as $kvp) {
      if (preg_match_all('/<[^>]+>|[^=]+/', $kvp, $matches)) {
        $m = $matches[0];
        if (isset($m[1])) {
          $part[trim($m[0], $trimmed)] = trim($m[1], $trimmed);
        }
        else {
          $part[] = trim($m[0], $trimmed);
        }
      }
    }
    if ($part) {
      $params[] = $part;
    }
  }
  return $params;
}

/**
 * Converts an array of header values that may contain comma separated
 * headers into an array of headers with no comma separated values.
 *
 * @param string|array $header Header to normalize.
 *
 * @return array Returns the normalized header field values.
 */
function normalize_header($header) {
  if (!is_array($header)) {
    return array_map('trim', explode(',', $header));
  }
  $result = [];
  foreach ($header as $value) {
    foreach ((array) $value as $v) {
      if (strpos($v, ',') === false) {
        $result[] = $v;
        continue;
      }
      foreach (preg_split('/,(?=([^"]*"[^"]*")*[^"]*$)/', $v) as $vv) {
        $result[] = trim($vv);
      }
    }
  }
  return $result;
}

/**
 * Clone and modify a request with the given changes.
 *
 * The changes can be one of:
 * - method: (string) Changes the HTTP method.
 * - set_headers: (array) Sets the given headers.
 * - remove_headers: (array) Remove the given headers.
 * - body: (mixed) Sets the given body.
 * - uri: (UriInterface) Set the URI.
 * - query: (string) Set the query string value of the URI.
 * - version: (string) Set the protocol version.
 *
 * @param RequestInterface $request Request to clone and modify.
 * @param array            $changes Changes to apply.
 *
 * @return RequestInterface
 */
function modify_request(RequestInterface $request, array $changes) {
  if (!$changes) {
    return $request;
  }
  $headers = $request
    ->getHeaders();
  if (!isset($changes['uri'])) {
    $uri = $request
      ->getUri();
  }
  else {

    // Remove the host header if one is on the URI
    if ($host = $changes['uri']
      ->getHost()) {
      $changes['set_headers']['Host'] = $host;
      if ($port = $changes['uri']
        ->getPort()) {
        $standardPorts = [
          'http' => 80,
          'https' => 443,
        ];
        $scheme = $changes['uri']
          ->getScheme();
        if (isset($standardPorts[$scheme]) && $port != $standardPorts[$scheme]) {
          $changes['set_headers']['Host'] .= ':' . $port;
        }
      }
    }
    $uri = $changes['uri'];
  }
  if (!empty($changes['remove_headers'])) {
    $headers = _caseless_remove($changes['remove_headers'], $headers);
  }
  if (!empty($changes['set_headers'])) {
    $headers = _caseless_remove(array_keys($changes['set_headers']), $headers);
    $headers = $changes['set_headers'] + $headers;
  }
  if (isset($changes['query'])) {
    $uri = $uri
      ->withQuery($changes['query']);
  }
  if ($request instanceof ServerRequestInterface) {
    return (new ServerRequest(isset($changes['method']) ? $changes['method'] : $request
      ->getMethod(), $uri, $headers, isset($changes['body']) ? $changes['body'] : $request
      ->getBody(), isset($changes['version']) ? $changes['version'] : $request
      ->getProtocolVersion(), $request
      ->getServerParams()))
      ->withParsedBody($request
      ->getParsedBody())
      ->withQueryParams($request
      ->getQueryParams())
      ->withCookieParams($request
      ->getCookieParams())
      ->withUploadedFiles($request
      ->getUploadedFiles());
  }
  return new Request(isset($changes['method']) ? $changes['method'] : $request
    ->getMethod(), $uri, $headers, isset($changes['body']) ? $changes['body'] : $request
    ->getBody(), isset($changes['version']) ? $changes['version'] : $request
    ->getProtocolVersion());
}

/**
 * Attempts to rewind a message body and throws an exception on failure.
 *
 * The body of the message will only be rewound if a call to `tell()` returns a
 * value other than `0`.
 *
 * @param MessageInterface $message Message to rewind
 *
 * @throws \RuntimeException
 */
function rewind_body(MessageInterface $message) {
  $body = $message
    ->getBody();
  if ($body
    ->tell()) {
    $body
      ->rewind();
  }
}

/**
 * Safely opens a PHP stream resource using a filename.
 *
 * When fopen fails, PHP normally raises a warning. This function adds an
 * error handler that checks for errors and throws an exception instead.
 *
 * @param string $filename File to open
 * @param string $mode     Mode used to open the file
 *
 * @return resource
 * @throws \RuntimeException if the file cannot be opened
 */
function try_fopen($filename, $mode) {
  $ex = null;
  set_error_handler(function () use ($filename, $mode, &$ex) {
    $ex = new \RuntimeException(sprintf('Unable to open %s using mode %s: %s', $filename, $mode, func_get_args()[1]));
  });
  $handle = fopen($filename, $mode);
  restore_error_handler();
  if ($ex) {

    /** @var $ex \RuntimeException */
    throw $ex;
  }
  return $handle;
}

/**
 * Copy the contents of a stream into a string until the given number of
 * bytes have been read.
 *
 * @param StreamInterface $stream Stream to read
 * @param int             $maxLen Maximum number of bytes to read. Pass -1
 *                                to read the entire stream.
 * @return string
 * @throws \RuntimeException on error.
 */
function copy_to_string(StreamInterface $stream, $maxLen = -1) {
  $buffer = '';
  if ($maxLen === -1) {
    while (!$stream
      ->eof()) {
      $buf = $stream
        ->read(1048576);

      // Using a loose equality here to match on '' and false.
      if ($buf == null) {
        break;
      }
      $buffer .= $buf;
    }
    return $buffer;
  }
  $len = 0;
  while (!$stream
    ->eof() && $len < $maxLen) {
    $buf = $stream
      ->read($maxLen - $len);

    // Using a loose equality here to match on '' and false.
    if ($buf == null) {
      break;
    }
    $buffer .= $buf;
    $len = strlen($buffer);
  }
  return $buffer;
}

/**
 * Copy the contents of a stream into another stream until the given number
 * of bytes have been read.
 *
 * @param StreamInterface $source Stream to read from
 * @param StreamInterface $dest   Stream to write to
 * @param int             $maxLen Maximum number of bytes to read. Pass -1
 *                                to read the entire stream.
 *
 * @throws \RuntimeException on error.
 */
function copy_to_stream(StreamInterface $source, StreamInterface $dest, $maxLen = -1) {
  $bufferSize = 8192;
  if ($maxLen === -1) {
    while (!$source
      ->eof()) {
      if (!$dest
        ->write($source
        ->read($bufferSize))) {
        break;
      }
    }
  }
  else {
    $remaining = $maxLen;
    while ($remaining > 0 && !$source
      ->eof()) {
      $buf = $source
        ->read(min($bufferSize, $remaining));
      $len = strlen($buf);
      if (!$len) {
        break;
      }
      $remaining -= $len;
      $dest
        ->write($buf);
    }
  }
}

/**
 * Calculate a hash of a Stream
 *
 * @param StreamInterface $stream    Stream to calculate the hash for
 * @param string          $algo      Hash algorithm (e.g. md5, crc32, etc)
 * @param bool            $rawOutput Whether or not to use raw output
 *
 * @return string Returns the hash of the stream
 * @throws \RuntimeException on error.
 */
function hash(StreamInterface $stream, $algo, $rawOutput = false) {
  $pos = $stream
    ->tell();
  if ($pos > 0) {
    $stream
      ->rewind();
  }
  $ctx = hash_init($algo);
  while (!$stream
    ->eof()) {
    hash_update($ctx, $stream
      ->read(1048576));
  }
  $out = hash_final($ctx, (bool) $rawOutput);
  $stream
    ->seek($pos);
  return $out;
}

/**
 * Read a line from the stream up to the maximum allowed buffer length
 *
 * @param StreamInterface $stream    Stream to read from
 * @param int             $maxLength Maximum buffer length
 *
 * @return string
 */
function readline(StreamInterface $stream, $maxLength = null) {
  $buffer = '';
  $size = 0;
  while (!$stream
    ->eof()) {

    // Using a loose equality here to match on '' and false.
    if (null == ($byte = $stream
      ->read(1))) {
      return $buffer;
    }
    $buffer .= $byte;

    // Break when a new line is found or the max length - 1 is reached
    if ($byte === "\n" || ++$size === $maxLength - 1) {
      break;
    }
  }
  return $buffer;
}

/**
 * Parses a request message string into a request object.
 *
 * @param string $message Request message string.
 *
 * @return Request
 */
function parse_request($message) {
  $data = _parse_message($message);
  $matches = [];
  if (!preg_match('/^[\\S]+\\s+([a-zA-Z]+:\\/\\/|\\/).*/', $data['start-line'], $matches)) {
    throw new \InvalidArgumentException('Invalid request string');
  }
  $parts = explode(' ', $data['start-line'], 3);
  $version = isset($parts[2]) ? explode('/', $parts[2])[1] : '1.1';
  $request = new Request($parts[0], $matches[1] === '/' ? _parse_request_uri($parts[1], $data['headers']) : $parts[1], $data['headers'], $data['body'], $version);
  return $matches[1] === '/' ? $request : $request
    ->withRequestTarget($parts[1]);
}

/**
 * Parses a response message string into a response object.
 *
 * @param string $message Response message string.
 *
 * @return Response
 */
function parse_response($message) {
  $data = _parse_message($message);

  // According to https://tools.ietf.org/html/rfc7230#section-3.1.2 the space
  // between status-code and reason-phrase is required. But browsers accept
  // responses without space and reason as well.
  if (!preg_match('/^HTTP\\/.* [0-9]{3}( .*|$)/', $data['start-line'])) {
    throw new \InvalidArgumentException('Invalid response string: ' . $data['start-line']);
  }
  $parts = explode(' ', $data['start-line'], 3);
  return new Response($parts[1], $data['headers'], $data['body'], explode('/', $parts[0])[1], isset($parts[2]) ? $parts[2] : null);
}

/**
 * Parse a query string into an associative array.
 *
 * If multiple values are found for the same key, the value of that key
 * value pair will become an array. This function does not parse nested
 * PHP style arrays into an associative array (e.g., foo[a]=1&foo[b]=2 will
 * be parsed into ['foo[a]' => '1', 'foo[b]' => '2']).
 *
 * @param string   $str         Query string to parse
 * @param int|bool $urlEncoding How the query string is encoded
 *
 * @return array
 */
function parse_query($str, $urlEncoding = true) {
  $result = [];
  if ($str === '') {
    return $result;
  }
  if ($urlEncoding === true) {
    $decoder = function ($value) {
      return rawurldecode(str_replace('+', ' ', $value));
    };
  }
  elseif ($urlEncoding === PHP_QUERY_RFC3986) {
    $decoder = 'rawurldecode';
  }
  elseif ($urlEncoding === PHP_QUERY_RFC1738) {
    $decoder = 'urldecode';
  }
  else {
    $decoder = function ($str) {
      return $str;
    };
  }
  foreach (explode('&', $str) as $kvp) {
    $parts = explode('=', $kvp, 2);
    $key = $decoder($parts[0]);
    $value = isset($parts[1]) ? $decoder($parts[1]) : null;
    if (!isset($result[$key])) {
      $result[$key] = $value;
    }
    else {
      if (!is_array($result[$key])) {
        $result[$key] = [
          $result[$key],
        ];
      }
      $result[$key][] = $value;
    }
  }
  return $result;
}

/**
 * Build a query string from an array of key value pairs.
 *
 * This function can use the return value of parse_query() to build a query
 * string. This function does not modify the provided keys when an array is
 * encountered (like http_build_query would).
 *
 * @param array     $params   Query string parameters.
 * @param int|false $encoding Set to false to not encode, PHP_QUERY_RFC3986
 *                            to encode using RFC3986, or PHP_QUERY_RFC1738
 *                            to encode using RFC1738.
 * @return string
 */
function build_query(array $params, $encoding = PHP_QUERY_RFC3986) {
  if (!$params) {
    return '';
  }
  if ($encoding === false) {
    $encoder = function ($str) {
      return $str;
    };
  }
  elseif ($encoding === PHP_QUERY_RFC3986) {
    $encoder = 'rawurlencode';
  }
  elseif ($encoding === PHP_QUERY_RFC1738) {
    $encoder = 'urlencode';
  }
  else {
    throw new \InvalidArgumentException('Invalid type');
  }
  $qs = '';
  foreach ($params as $k => $v) {
    $k = $encoder($k);
    if (!is_array($v)) {
      $qs .= $k;
      if ($v !== null) {
        $qs .= '=' . $encoder($v);
      }
      $qs .= '&';
    }
    else {
      foreach ($v as $vv) {
        $qs .= $k;
        if ($vv !== null) {
          $qs .= '=' . $encoder($vv);
        }
        $qs .= '&';
      }
    }
  }
  return $qs ? (string) substr($qs, 0, -1) : '';
}

/**
 * Determines the mimetype of a file by looking at its extension.
 *
 * @param $filename
 *
 * @return null|string
 */
function mimetype_from_filename($filename) {
  return mimetype_from_extension(pathinfo($filename, PATHINFO_EXTENSION));
}

/**
 * Maps a file extensions to a mimetype.
 *
 * @param $extension string The file extension.
 *
 * @return string|null
 * @link http://svn.apache.org/repos/asf/httpd/httpd/branches/1.3.x/conf/mime.types
 */
function mimetype_from_extension($extension) {
  static $mimetypes = [
    '3gp' => 'video/3gpp',
    '7z' => 'application/x-7z-compressed',
    'aac' => 'audio/x-aac',
    'ai' => 'application/postscript',
    'aif' => 'audio/x-aiff',
    'asc' => 'text/plain',
    'asf' => 'video/x-ms-asf',
    'atom' => 'application/atom+xml',
    'avi' => 'video/x-msvideo',
    'bmp' => 'image/bmp',
    'bz2' => 'application/x-bzip2',
    'cer' => 'application/pkix-cert',
    'crl' => 'application/pkix-crl',
    'crt' => 'application/x-x509-ca-cert',
    'css' => 'text/css',
    'csv' => 'text/csv',
    'cu' => 'application/cu-seeme',
    'deb' => 'application/x-debian-package',
    'doc' => 'application/msword',
    'docx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
    'dvi' => 'application/x-dvi',
    'eot' => 'application/vnd.ms-fontobject',
    'eps' => 'application/postscript',
    'epub' => 'application/epub+zip',
    'etx' => 'text/x-setext',
    'flac' => 'audio/flac',
    'flv' => 'video/x-flv',
    'gif' => 'image/gif',
    'gz' => 'application/gzip',
    'htm' => 'text/html',
    'html' => 'text/html',
    'ico' => 'image/x-icon',
    'ics' => 'text/calendar',
    'ini' => 'text/plain',
    'iso' => 'application/x-iso9660-image',
    'jar' => 'application/java-archive',
    'jpe' => 'image/jpeg',
    'jpeg' => 'image/jpeg',
    'jpg' => 'image/jpeg',
    'js' => 'text/javascript',
    'json' => 'application/json',
    'latex' => 'application/x-latex',
    'log' => 'text/plain',
    'm4a' => 'audio/mp4',
    'm4v' => 'video/mp4',
    'mid' => 'audio/midi',
    'midi' => 'audio/midi',
    'mov' => 'video/quicktime',
    'mkv' => 'video/x-matroska',
    'mp3' => 'audio/mpeg',
    'mp4' => 'video/mp4',
    'mp4a' => 'audio/mp4',
    'mp4v' => 'video/mp4',
    'mpe' => 'video/mpeg',
    'mpeg' => 'video/mpeg',
    'mpg' => 'video/mpeg',
    'mpg4' => 'video/mp4',
    'oga' => 'audio/ogg',
    'ogg' => 'audio/ogg',
    'ogv' => 'video/ogg',
    'ogx' => 'application/ogg',
    'pbm' => 'image/x-portable-bitmap',
    'pdf' => 'application/pdf',
    'pgm' => 'image/x-portable-graymap',
    'png' => 'image/png',
    'pnm' => 'image/x-portable-anymap',
    'ppm' => 'image/x-portable-pixmap',
    'ppt' => 'application/vnd.ms-powerpoint',
    'pptx' => 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
    'ps' => 'application/postscript',
    'qt' => 'video/quicktime',
    'rar' => 'application/x-rar-compressed',
    'ras' => 'image/x-cmu-raster',
    'rss' => 'application/rss+xml',
    'rtf' => 'application/rtf',
    'sgm' => 'text/sgml',
    'sgml' => 'text/sgml',
    'svg' => 'image/svg+xml',
    'swf' => 'application/x-shockwave-flash',
    'tar' => 'application/x-tar',
    'tif' => 'image/tiff',
    'tiff' => 'image/tiff',
    'torrent' => 'application/x-bittorrent',
    'ttf' => 'application/x-font-ttf',
    'txt' => 'text/plain',
    'wav' => 'audio/x-wav',
    'webm' => 'video/webm',
    'webp' => 'image/webp',
    'wma' => 'audio/x-ms-wma',
    'wmv' => 'video/x-ms-wmv',
    'woff' => 'application/x-font-woff',
    'wsdl' => 'application/wsdl+xml',
    'xbm' => 'image/x-xbitmap',
    'xls' => 'application/vnd.ms-excel',
    'xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
    'xml' => 'application/xml',
    'xpm' => 'image/x-xpixmap',
    'xwd' => 'image/x-xwindowdump',
    'yaml' => 'text/yaml',
    'yml' => 'text/yaml',
    'zip' => 'application/zip',
  ];
  $extension = strtolower($extension);
  return isset($mimetypes[$extension]) ? $mimetypes[$extension] : null;
}

/**
 * Parses an HTTP message into an associative array.
 *
 * The array contains the "start-line" key containing the start line of
 * the message, "headers" key containing an associative array of header
 * array values, and a "body" key containing the body of the message.
 *
 * @param string $message HTTP request or response to parse.
 *
 * @return array
 * @internal
 */
function _parse_message($message) {
  if (!$message) {
    throw new \InvalidArgumentException('Invalid message');
  }
  $message = ltrim($message, "\r\n");
  $messageParts = preg_split("/\r?\n\r?\n/", $message, 2);
  if ($messageParts === false || count($messageParts) !== 2) {
    throw new \InvalidArgumentException('Invalid message: Missing header delimiter');
  }
  list($rawHeaders, $body) = $messageParts;
  $rawHeaders .= "\r\n";

  // Put back the delimiter we split previously
  $headerParts = preg_split("/\r?\n/", $rawHeaders, 2);
  if ($headerParts === false || count($headerParts) !== 2) {
    throw new \InvalidArgumentException('Invalid message: Missing status line');
  }
  list($startLine, $rawHeaders) = $headerParts;
  if (preg_match("/(?:^HTTP\\/|^[A-Z]+ \\S+ HTTP\\/)(\\d+(?:\\.\\d+)?)/i", $startLine, $matches) && $matches[1] === '1.0') {

    // Header folding is deprecated for HTTP/1.1, but allowed in HTTP/1.0
    $rawHeaders = preg_replace(Rfc7230::HEADER_FOLD_REGEX, ' ', $rawHeaders);
  }

  /** @var array[] $headerLines */
  $count = preg_match_all(Rfc7230::HEADER_REGEX, $rawHeaders, $headerLines, PREG_SET_ORDER);

  // If these aren't the same, then one line didn't match and there's an invalid header.
  if ($count !== substr_count($rawHeaders, "\n")) {

    // Folding is deprecated, see https://tools.ietf.org/html/rfc7230#section-3.2.4
    if (preg_match(Rfc7230::HEADER_FOLD_REGEX, $rawHeaders)) {
      throw new \InvalidArgumentException('Invalid header syntax: Obsolete line folding');
    }
    throw new \InvalidArgumentException('Invalid header syntax');
  }
  $headers = [];
  foreach ($headerLines as $headerLine) {
    $headers[$headerLine[1]][] = $headerLine[2];
  }
  return [
    'start-line' => $startLine,
    'headers' => $headers,
    'body' => $body,
  ];
}

/**
 * Constructs a URI for an HTTP request message.
 *
 * @param string $path    Path from the start-line
 * @param array  $headers Array of headers (each value an array).
 *
 * @return string
 * @internal
 */
function _parse_request_uri($path, array $headers) {
  $hostKey = array_filter(array_keys($headers), function ($k) {
    return strtolower($k) === 'host';
  });

  // If no host is found, then a full URI cannot be constructed.
  if (!$hostKey) {
    return $path;
  }
  $host = $headers[reset($hostKey)][0];
  $scheme = substr($host, -4) === ':443' ? 'https' : 'http';
  return $scheme . '://' . $host . '/' . ltrim($path, '/');
}

/**
 * Get a short summary of the message body
 *
 * Will return `null` if the response is not printable.
 *
 * @param MessageInterface $message    The message to get the body summary
 * @param int              $truncateAt The maximum allowed size of the summary
 *
 * @return null|string
 */
function get_message_body_summary(MessageInterface $message, $truncateAt = 120) {
  $body = $message
    ->getBody();
  if (!$body
    ->isSeekable() || !$body
    ->isReadable()) {
    return null;
  }
  $size = $body
    ->getSize();
  if ($size === 0) {
    return null;
  }
  $summary = $body
    ->read($truncateAt);
  $body
    ->rewind();
  if ($size > $truncateAt) {
    $summary .= ' (truncated...)';
  }

  // Matches any printable character, including unicode characters:
  // letters, marks, numbers, punctuation, spacing, and separators.
  if (preg_match('/[^\\pL\\pM\\pN\\pP\\pS\\pZ\\n\\r\\t]/', $summary)) {
    return null;
  }
  return $summary;
}

/** @internal */
function _caseless_remove($keys, array $data) {
  $result = [];
  foreach ($keys as &$key) {
    $key = strtolower($key);
  }
  foreach ($data as $k => $v) {
    if (!in_array(strtolower($k), $keys)) {
      $result[$k] = $v;
    }
  }
  return $result;
}

Functions

Namesort descending Description
build_query Build a query string from an array of key value pairs.
copy_to_stream Copy the contents of a stream into another stream until the given number of bytes have been read.
copy_to_string Copy the contents of a stream into a string until the given number of bytes have been read.
get_message_body_summary Get a short summary of the message body
hash Calculate a hash of a Stream
mimetype_from_extension Maps a file extensions to a mimetype.
mimetype_from_filename Determines the mimetype of a file by looking at its extension.
modify_request Clone and modify a request with the given changes.
normalize_header Converts an array of header values that may contain comma separated headers into an array of headers with no comma separated values.
parse_header Parse an array of header values containing ";" separated data into an array of associative arrays representing the header key value pair data of the header. When a parameter does not contain a value, but just contains a key, this function…
parse_query Parse a query string into an associative array.
parse_request Parses a request message string into a request object.
parse_response Parses a response message string into a response object.
readline Read a line from the stream up to the maximum allowed buffer length
rewind_body Attempts to rewind a message body and throws an exception on failure.
str Returns the string representation of an HTTP message.
stream_for Create a new stream based on the input type.
try_fopen Safely opens a PHP stream resource using a filename.
uri_for Returns a UriInterface for the given value.
_caseless_remove @internal
_parse_message Parses an HTTP message into an associative array.
_parse_request_uri Constructs a URI for an HTTP request message.