21        $msg = trim(
$message->getMethod() . 
' ' 
   23            . 
' HTTP/' . 
$message->getProtocolVersion();
 
   25            $msg .= 
"\r\nHost: " . 
$message->getUri()->getHost();
 
   28        $msg = 
'HTTP/' . 
$message->getProtocolVersion() . 
' ' 
   32        throw new \InvalidArgumentException(
'Unknown message type');
 
   36        $msg .= 
"\r\n{$name}: " . implode(
', ', $values);
 
   39    return "{$msg}\r\n\r\n" . 
$message->getBody();
 
   58    } elseif (is_string($uri)) {
 
   62    throw new \InvalidArgumentException(
'URI must be a string or UriInterface');
 
   80    if (is_scalar($resource)) {
 
   81        $stream = fopen(
'php://temp', 
'r+');
 
   82        if ($resource !== 
'') {
 
   89    switch (gettype($resource)) {
 
   95            } elseif ($resource instanceof \
Iterator) {
 
   96                return new PumpStream(
function () use ($resource) {
 
   97                    if (!$resource->valid()) {
 
  100                    $result = $resource->current();
 
  104            } elseif (method_exists($resource, 
'__toString')) {
 
  112    if (is_callable($resource)) {
 
  116    throw new \InvalidArgumentException(
'Invalid resource type: ' . gettype($resource));
 
  131    static $trimmed = 
"\"'  \n\t\r";
 
  136        foreach (preg_split(
'/;(?=([^"]*"[^"]*")*[^"]*$)/', $val) as $kvp) {
 
  137            if (preg_match_all(
'/<[^>]+>|[^=]+/', $kvp, $matches)) {
 
  140                    $part[trim(
$m[0], $trimmed)] = trim(
$m[1], $trimmed);
 
  142                    $part[] = trim(
$m[0], $trimmed);
 
  165        return array_map(
'trim', explode(
',', 
$header));
 
  170        foreach ((array) $value as $v) {
 
  171            if (strpos($v, 
',') === 
false) {
 
  175            foreach (preg_split(
'/,(?=([^"]*"[^"]*")*[^"]*$)/', $v) as $vv) {
 
  209    if (!isset($changes[
'uri'])) {
 
  210        $uri = $request->
getUri();
 
  213        if ($host = $changes[
'uri']->getHost()) {
 
  214            $changes[
'set_headers'][
'Host'] = $host;
 
  216            if ($port = $changes[
'uri']->getPort()) {
 
  217                $standardPorts = [
'http' => 80, 
'https' => 443];
 
  218                $scheme = $changes[
'uri']->getScheme();
 
  219                if (isset($standardPorts[$scheme]) && $port != $standardPorts[$scheme]) {
 
  220                    $changes[
'set_headers'][
'Host'] .= 
':'.$port;
 
  224        $uri = $changes[
'uri'];
 
  227    if (!empty($changes[
'remove_headers'])) {
 
  231    if (!empty($changes[
'set_headers'])) {
 
  233        $headers = $changes[
'set_headers'] + $headers;
 
  236    if (isset($changes[
'query'])) {
 
  237        $uri = $uri->withQuery($changes[
'query']);
 
  242            isset($changes[
'method']) ? $changes[
'method'] : $request->
getMethod(),
 
  245            isset($changes[
'body']) ? $changes[
'body'] : $request->
getBody(),
 
  246            isset($changes[
'version'])
 
  247                ? $changes[
'version']
 
  249            $request->getServerParams()
 
  254        isset($changes[
'method']) ? $changes[
'method'] : $request->
getMethod(),
 
  257        isset($changes[
'body']) ? $changes[
'body'] : $request->
getBody(),
 
  258        isset($changes[
'version'])
 
  259            ? $changes[
'version']
 
  298    set_error_handler(
function () use (
$filename, $mode, &$ex) {
 
  299        $ex = new \RuntimeException(
sprintf(
 
  300            'Unable to open %s using mode %s: %s',
 
  308    restore_error_handler();
 
  332    if ($maxLen === -1) {
 
  345    while (!
$stream->eof() && $len < $maxLen) {
 
  346        $buf = 
$stream->read($maxLen - $len);
 
  352        $len = strlen($buffer);
 
  376    if ($maxLen === -1) {
 
  417    $ctx = hash_init(
$algo);
 
  419        hash_update($ctx, 
$stream->read(1048576));
 
  422    $out = hash_final($ctx, (
bool) $rawOutput);
 
  443        if (
null == ($byte = 
$stream->read(1))) {
 
  448        if ($byte === 
"\n" || ++
$size === $maxLength - 1) {
 
  467    if (!preg_match(
'/^[\S]+\s+([a-zA-Z]+:\/\/|\/).*/', 
$data[
'start-line'], $matches)) {
 
  468        throw new \InvalidArgumentException(
'Invalid request string');
 
  470    $parts = explode(
' ', 
$data[
'start-line'], 3);
 
  471    $version = isset($parts[2]) ? explode(
'/', $parts[2])[1] : 
'1.1';
 
  481    return $matches[1] === 
'/' ? $request : $request->withRequestTarget($parts[1]);
 
  497    if (!preg_match(
'/^HTTP\/.* [0-9]{3}( .*|$)/', 
$data[
'start-line'])) {
 
  498        throw new \InvalidArgumentException(
'Invalid response string');
 
  500    $parts = explode(
' ', 
$data[
'start-line'], 3);
 
  506        explode(
'/', $parts[0])[1],
 
  507        isset($parts[2]) ? $parts[2] : 
null 
  532    if ($urlEncoding === 
true) {
 
  533        $decoder = 
function ($value) {
 
  534            return rawurldecode(str_replace(
'+', 
' ', $value));
 
  536    } elseif ($urlEncoding == PHP_QUERY_RFC3986) {
 
  537        $decoder = 
'rawurldecode';
 
  538    } elseif ($urlEncoding == PHP_QUERY_RFC1738) {
 
  539        $decoder = 
'urldecode';
 
  541        $decoder = 
function ($str) { 
return $str; };
 
  544    foreach (explode(
'&', $str) as $kvp) {
 
  545        $parts = explode(
'=', $kvp, 2);
 
  546        $key = $decoder($parts[0]);
 
  547        $value = isset($parts[1]) ? $decoder($parts[1]) : 
null;
 
  580    if ($encoding === 
false) {
 
  581        $encoder = 
function ($str) { 
return $str; };
 
  582    } elseif ($encoding === PHP_QUERY_RFC3986) {
 
  583        $encoder = 
'rawurlencode';
 
  584    } elseif ($encoding === PHP_QUERY_RFC1738) {
 
  585        $encoder = 
'urlencode';
 
  587        throw new \InvalidArgumentException(
'Invalid type');
 
  591    foreach (
$params as $k => $v) {
 
  596                $qs .= 
'=' . $encoder($v);
 
  600            foreach ($v as $vv) {
 
  603                    $qs .= 
'=' . $encoder($vv);
 
  610    return $qs ? (string) substr($qs, 0, -1) : 
'';
 
  636        '7z' => 
'application/x-7z-compressed',
 
  637        'aac' => 
'audio/x-aac',
 
  638        'ai' => 
'application/postscript',
 
  639        'aif' => 
'audio/x-aiff',
 
  640        'asc' => 
'text/plain',
 
  641        'asf' => 
'video/x-ms-asf',
 
  642        'atom' => 
'application/atom+xml',
 
  643        'avi' => 
'video/x-msvideo',
 
  644        'bmp' => 
'image/bmp',
 
  645        'bz2' => 
'application/x-bzip2',
 
  646        'cer' => 
'application/pkix-cert',
 
  647        'crl' => 
'application/pkix-crl',
 
  648        'crt' => 
'application/x-x509-ca-cert',
 
  651        'cu' => 
'application/cu-seeme',
 
  652        'deb' => 
'application/x-debian-package',
 
  653        'doc' => 
'application/msword',
 
  654        'docx' => 
'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
 
  655        'dvi' => 
'application/x-dvi',
 
  656        'eot' => 
'application/vnd.ms-fontobject',
 
  657        'eps' => 
'application/postscript',
 
  658        'epub' => 
'application/epub+zip',
 
  659        'etx' => 
'text/x-setext',
 
  660        'flac' => 
'audio/flac',
 
  661        'flv' => 
'video/x-flv',
 
  662        'gif' => 
'image/gif',
 
  663        'gz' => 
'application/gzip',
 
  664        'htm' => 
'text/html',
 
  665        'html' => 
'text/html',
 
  666        'ico' => 
'image/x-icon',
 
  667        'ics' => 
'text/calendar',
 
  668        'ini' => 
'text/plain',
 
  669        'iso' => 
'application/x-iso9660-image',
 
  670        'jar' => 
'application/java-archive',
 
  671        'jpe' => 
'image/jpeg',
 
  672        'jpeg' => 
'image/jpeg',
 
  673        'jpg' => 
'image/jpeg',
 
  674        'js' => 
'text/javascript',
 
  675        'json' => 
'application/json',
 
  676        'latex' => 
'application/x-latex',
 
  677        'log' => 
'text/plain',
 
  678        'm4a' => 
'audio/mp4',
 
  679        'm4v' => 
'video/mp4',
 
  680        'mid' => 
'audio/midi',
 
  681        'midi' => 
'audio/midi',
 
  682        'mov' => 
'video/quicktime',
 
  683        'mp3' => 
'audio/mpeg',
 
  684        'mp4' => 
'video/mp4',
 
  685        'mp4a' => 
'audio/mp4',
 
  686        'mp4v' => 
'video/mp4',
 
  687        'mpe' => 
'video/mpeg',
 
  688        'mpeg' => 
'video/mpeg',
 
  689        'mpg' => 
'video/mpeg',
 
  690        'mpg4' => 
'video/mp4',
 
  691        'oga' => 
'audio/ogg',
 
  692        'ogg' => 
'audio/ogg',
 
  693        'ogv' => 
'video/ogg',
 
  694        'ogx' => 
'application/ogg',
 
  695        'pbm' => 
'image/x-portable-bitmap',
 
  696        'pdf' => 
'application/pdf',
 
  697        'pgm' => 
'image/x-portable-graymap',
 
  698        'png' => 
'image/png',
 
  699        'pnm' => 
'image/x-portable-anymap',
 
  700        'ppm' => 
'image/x-portable-pixmap',
 
  701        'ppt' => 
'application/vnd.ms-powerpoint',
 
  702        'pptx' => 
'application/vnd.openxmlformats-officedocument.presentationml.presentation',
 
  703        'ps' => 
'application/postscript',
 
  704        'qt' => 
'video/quicktime',
 
  705        'rar' => 
'application/x-rar-compressed',
 
  706        'ras' => 
'image/x-cmu-raster',
 
  707        'rss' => 
'application/rss+xml',
 
  708        'rtf' => 
'application/rtf',
 
  709        'sgm' => 
'text/sgml',
 
  710        'sgml' => 
'text/sgml',
 
  711        'svg' => 
'image/svg+xml',
 
  712        'swf' => 
'application/x-shockwave-flash',
 
  713        'tar' => 
'application/x-tar',
 
  714        'tif' => 
'image/tiff',
 
  715        'tiff' => 
'image/tiff',
 
  716        'torrent' => 
'application/x-bittorrent',
 
  717        'ttf' => 
'application/x-font-ttf',
 
  718        'txt' => 
'text/plain',
 
  719        'wav' => 
'audio/x-wav',
 
  720        'webm' => 
'video/webm',
 
  721        'wma' => 
'audio/x-ms-wma',
 
  722        'wmv' => 
'video/x-ms-wmv',
 
  723        'woff' => 
'application/x-font-woff',
 
  724        'wsdl' => 
'application/wsdl+xml',
 
  725        'xbm' => 
'image/x-xbitmap',
 
  726        'xls' => 
'application/vnd.ms-excel',
 
  727        'xlsx' => 
'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
 
  728        'xml' => 
'application/xml',
 
  729        'xpm' => 
'image/x-xpixmap',
 
  730        'xwd' => 
'image/x-xwindowdump',
 
  731        'yaml' => 
'text/yaml',
 
  732        'yml' => 
'text/yaml',
 
  733        'zip' => 
'application/zip',
 
  736    $extension = strtolower($extension);
 
  758        throw new \InvalidArgumentException(
'Invalid message');
 
  763    $result = [
'start-line' => array_shift($lines), 
'headers' => [], 
'body' => 
''];
 
  766    for (
$i = 0, $totalLines = count($lines); 
$i < $totalLines; 
$i += 2) {
 
  770            if (
$i < $totalLines - 1) {
 
  771                $result[
'body'] = implode(
'', array_slice($lines, 
$i + 2));
 
  775        if (strpos($line, 
':')) {
 
  776            $parts = explode(
':', $line, 2);
 
  777            $key = trim($parts[0]);
 
  778            $value = isset($parts[1]) ? trim($parts[1]) : 
'';
 
  797    $hostKey = array_filter(array_keys($headers), 
function ($k) {
 
  798        return strtolower($k) === 
'host';
 
  806    $host = $headers[reset($hostKey)][0];
 
  807    $scheme = substr($host, -4) === 
':443' ? 
'https' : 
'http';
 
  809    return $scheme . 
'://' . $host . 
'/' . ltrim(
$path, 
'/');
 
  821    foreach (
$data as $k => $v) {
 
  822        if (!in_array(strtolower($k), 
$keys)) {
 
sprintf('%.4f', $callTime)
if(!isset( $_REQUEST[ 'ReturnTo'])) if(!isset($_REQUEST['AuthId'])) $options
An exception for terminatinating execution or to throw for unit testing.
Provides a read only stream that pumps data from a PHP callable.
PSR-7 request implementation.
PSR-7 response implementation.
Server-side HTTP request.
PSR-7 URI implementation.
HTTP messages consist of requests from a client to a server and responses from a server to a client.
getHeaders()
Retrieves all message header values.
getBody()
Gets the body of the message.
getProtocolVersion()
Retrieves the HTTP protocol version as a string.
Representation of an outgoing, client-side request.
getUri()
Retrieves the URI instance.
getMethod()
Retrieves the HTTP method of the request.
Representation of an outgoing, server-side response.
Representation of an incoming, server-side HTTP request.
write($string)
Write data to the stream.
Value object representing a URI.
catch(Exception $e) $message
readline(StreamInterface $stream, $maxLength=null)
Read a line from the stream up to the maximum allowed buffer length.
normalize_header($header)
Converts an array of header values that may contain comma separated headers into an array of headers ...
$stream
PHP stream implementation.
stream_for($resource='', array $options=[])
Create a new stream based on the input type.
mimetype_from_extension($extension)
Maps a file extensions to a mimetype.
parse_response($message)
Parses a response message string into a response object.
rewind_body(MessageInterface $message)
Attempts to rewind a message body and throws an exception on failure.
parse_request($message)
Parses a request message string into a request object.
build_query(array $params, $encoding=PHP_QUERY_RFC3986)
Build a query string from an array of key value pairs.
hash(StreamInterface $stream, $algo, $rawOutput=false)
Calculate a hash of a Stream.
_parse_message($message)
Parses an HTTP message into an associative array.
modify_request(RequestInterface $request, array $changes)
Clone and modify a request with the given changes.
parse_query($str, $urlEncoding=true)
Parse a query string into an associative array.
str(MessageInterface $message)
Returns the string representation of an HTTP message.
mimetype_from_filename($filename)
Determines the mimetype of a file by looking at its extension.
uri_for($uri)
Returns a UriInterface for the given value.
_caseless_remove($keys, array $data)
copy_to_stream(StreamInterface $source, StreamInterface $dest, $maxLen=-1)
Copy the contents of a stream into another stream until the given number of bytes have been read.
parse_header($header)
Parse an array of header values containing ";" separated data into an array of associative arrays rep...
copy_to_string(StreamInterface $stream, $maxLen=-1)
Copy the contents of a stream into a string until the given number of bytes have been read.
_parse_request_uri($path, array $headers)
Constructs a URI for an HTTP request message.
echo;exit;}function LogoutNotification($SessionID){ global $ilDB;$q="SELECT session_id, data FROM usr_session WHERE expires > (\w+)\|/" PREG_SPLIT_NO_EMPTY PREG_SPLIT_DELIM_CAPTURE
if($state['core:TerminatedAssocId'] !==null) $remaining