ILIAS  release_5-3 Revision v5.3.23-19-g915713cf615
functions.php
Go to the documentation of this file.
1<?php
2namespace GuzzleHttp\Psr7;
3
10
19{
20 if ($message instanceof RequestInterface) {
21 $msg = trim($message->getMethod() . ' '
22 . $message->getRequestTarget())
23 . ' HTTP/' . $message->getProtocolVersion();
24 if (!$message->hasHeader('host')) {
25 $msg .= "\r\nHost: " . $message->getUri()->getHost();
26 }
27 } elseif ($message instanceof ResponseInterface) {
28 $msg = 'HTTP/' . $message->getProtocolVersion() . ' '
29 . $message->getStatusCode() . ' '
30 . $message->getReasonPhrase();
31 } else {
32 throw new \InvalidArgumentException('Unknown message type');
33 }
34
35 foreach ($message->getHeaders() as $name => $values) {
36 $msg .= "\r\n{$name}: " . implode(', ', $values);
37 }
38
39 return "{$msg}\r\n\r\n" . $message->getBody();
40}
41
54function uri_for($uri)
55{
56 if ($uri instanceof UriInterface) {
57 return $uri;
58 } elseif (is_string($uri)) {
59 return new Uri($uri);
60 }
61
62 throw new \InvalidArgumentException('URI must be a string or UriInterface');
63}
64
78function stream_for($resource = '', array $options = [])
79{
80 if (is_scalar($resource)) {
81 $stream = fopen('php://temp', 'r+');
82 if ($resource !== '') {
83 fwrite($stream, $resource);
84 fseek($stream, 0);
85 }
86 return new Stream($stream, $options);
87 }
88
89 switch (gettype($resource)) {
90 case 'resource':
91 return new Stream($resource, $options);
92 case 'object':
93 if ($resource instanceof StreamInterface) {
94 return $resource;
95 } elseif ($resource instanceof \Iterator) {
96 return new PumpStream(function () use ($resource) {
97 if (!$resource->valid()) {
98 return false;
99 }
100 $result = $resource->current();
101 $resource->next();
102 return $result;
103 }, $options);
104 } elseif (method_exists($resource, '__toString')) {
105 return stream_for((string) $resource, $options);
106 }
107 break;
108 case 'NULL':
109 return new Stream(fopen('php://temp', 'r+'), $options);
110 }
111
112 if (is_callable($resource)) {
113 return new PumpStream($resource, $options);
114 }
115
116 throw new \InvalidArgumentException('Invalid resource type: ' . gettype($resource));
117}
118
130{
131 static $trimmed = "\"' \n\t\r";
132 $params = $matches = [];
133
134 foreach (normalize_header($header) as $val) {
135 $part = [];
136 foreach (preg_split('/;(?=([^"]*"[^"]*")*[^"]*$)/', $val) as $kvp) {
137 if (preg_match_all('/<[^>]+>|[^=]+/', $kvp, $matches)) {
138 $m = $matches[0];
139 if (isset($m[1])) {
140 $part[trim($m[0], $trimmed)] = trim($m[1], $trimmed);
141 } else {
142 $part[] = trim($m[0], $trimmed);
143 }
144 }
145 }
146 if ($part) {
147 $params[] = $part;
148 }
149 }
150
151 return $params;
152}
153
163{
164 if (!is_array($header)) {
165 return array_map('trim', explode(',', $header));
166 }
167
168 $result = [];
169 foreach ($header as $value) {
170 foreach ((array) $value as $v) {
171 if (strpos($v, ',') === false) {
172 $result[] = $v;
173 continue;
174 }
175 foreach (preg_split('/,(?=([^"]*"[^"]*")*[^"]*$)/', $v) as $vv) {
176 $result[] = trim($vv);
177 }
178 }
179 }
180
181 return $result;
182}
183
201function modify_request(RequestInterface $request, array $changes)
202{
203 if (!$changes) {
204 return $request;
205 }
206
207 $headers = $request->getHeaders();
208
209 if (!isset($changes['uri'])) {
210 $uri = $request->getUri();
211 } else {
212 // Remove the host header if one is on the URI
213 if ($host = $changes['uri']->getHost()) {
214 $changes['set_headers']['Host'] = $host;
215
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;
221 }
222 }
223 }
224 $uri = $changes['uri'];
225 }
226
227 if (!empty($changes['remove_headers'])) {
228 $headers = _caseless_remove($changes['remove_headers'], $headers);
229 }
230
231 if (!empty($changes['set_headers'])) {
232 $headers = _caseless_remove(array_keys($changes['set_headers']), $headers);
233 $headers = $changes['set_headers'] + $headers;
234 }
235
236 if (isset($changes['query'])) {
237 $uri = $uri->withQuery($changes['query']);
238 }
239
240 if ($request instanceof ServerRequestInterface) {
241 return new ServerRequest(
242 isset($changes['method']) ? $changes['method'] : $request->getMethod(),
243 $uri,
244 $headers,
245 isset($changes['body']) ? $changes['body'] : $request->getBody(),
246 isset($changes['version'])
247 ? $changes['version']
248 : $request->getProtocolVersion(),
249 $request->getServerParams()
250 );
251 }
252
253 return new Request(
254 isset($changes['method']) ? $changes['method'] : $request->getMethod(),
255 $uri,
256 $headers,
257 isset($changes['body']) ? $changes['body'] : $request->getBody(),
258 isset($changes['version'])
259 ? $changes['version']
260 : $request->getProtocolVersion()
261 );
262}
263
275{
276 $body = $message->getBody();
277
278 if ($body->tell()) {
279 $body->rewind();
280 }
281}
282
295function try_fopen($filename, $mode)
296{
297 $ex = null;
298 set_error_handler(function () use ($filename, $mode, &$ex) {
299 $ex = new \RuntimeException(sprintf(
300 'Unable to open %s using mode %s: %s',
301 $filename,
302 $mode,
303 func_get_args()[1]
304 ));
305 });
306
307 $handle = fopen($filename, $mode);
308 restore_error_handler();
309
310 if ($ex) {
312 throw $ex;
313 }
314
315 return $handle;
316}
317
329{
330 $buffer = '';
331
332 if ($maxLen === -1) {
333 while (!$stream->eof()) {
334 $buf = $stream->read(1048576);
335 // Using a loose equality here to match on '' and false.
336 if ($buf == null) {
337 break;
338 }
339 $buffer .= $buf;
340 }
341 return $buffer;
342 }
343
344 $len = 0;
345 while (!$stream->eof() && $len < $maxLen) {
346 $buf = $stream->read($maxLen - $len);
347 // Using a loose equality here to match on '' and false.
348 if ($buf == null) {
349 break;
350 }
351 $buffer .= $buf;
352 $len = strlen($buffer);
353 }
354
355 return $buffer;
356}
357
371 StreamInterface $dest,
372 $maxLen = -1
373) {
374 $bufferSize = 8192;
375
376 if ($maxLen === -1) {
377 while (!$source->eof()) {
378 if (!$dest->write($source->read($bufferSize))) {
379 break;
380 }
381 }
382 } else {
383 $remaining = $maxLen;
384 while ($remaining > 0 && !$source->eof()) {
385 $buf = $source->read(min($bufferSize, $remaining));
386 $len = strlen($buf);
387 if (!$len) {
388 break;
389 }
390 $remaining -= $len;
391 $dest->write($buf);
392 }
393 }
394}
395
406function hash(
408 $algo,
409 $rawOutput = false
410) {
411 $pos = $stream->tell();
412
413 if ($pos > 0) {
414 $stream->rewind();
415 }
416
417 $ctx = hash_init($algo);
418 while (!$stream->eof()) {
419 hash_update($ctx, $stream->read(1048576));
420 }
421
422 $out = hash_final($ctx, (bool) $rawOutput);
423 $stream->seek($pos);
424
425 return $out;
426}
427
436function readline(StreamInterface $stream, $maxLength = null)
437{
438 $buffer = '';
439 $size = 0;
440
441 while (!$stream->eof()) {
442 // Using a loose equality here to match on '' and false.
443 if (null == ($byte = $stream->read(1))) {
444 return $buffer;
445 }
446 $buffer .= $byte;
447 // Break when a new line is found or the max length - 1 is reached
448 if ($byte === "\n" || ++$size === $maxLength - 1) {
449 break;
450 }
451 }
452
453 return $buffer;
454}
455
464{
466 $matches = [];
467 if (!preg_match('/^[\S]+\s+([a-zA-Z]+:\/\/|\/).*/', $data['start-line'], $matches)) {
468 throw new \InvalidArgumentException('Invalid request string');
469 }
470 $parts = explode(' ', $data['start-line'], 3);
471 $version = isset($parts[2]) ? explode('/', $parts[2])[1] : '1.1';
472
473 $request = new Request(
474 $parts[0],
475 $matches[1] === '/' ? _parse_request_uri($parts[1], $data['headers']) : $parts[1],
476 $data['headers'],
477 $data['body'],
479 );
480
481 return $matches[1] === '/' ? $request : $request->withRequestTarget($parts[1]);
482}
483
492{
494 // According to https://tools.ietf.org/html/rfc7230#section-3.1.2 the space
495 // between status-code and reason-phrase is required. But browsers accept
496 // responses without space and reason as well.
497 if (!preg_match('/^HTTP\/.* [0-9]{3}( .*|$)/', $data['start-line'])) {
498 throw new \InvalidArgumentException('Invalid response string');
499 }
500 $parts = explode(' ', $data['start-line'], 3);
501
502 return new Response(
503 $parts[1],
504 $data['headers'],
505 $data['body'],
506 explode('/', $parts[0])[1],
507 isset($parts[2]) ? $parts[2] : null
508 );
509}
510
524function parse_query($str, $urlEncoding = true)
525{
526 $result = [];
527
528 if ($str === '') {
529 return $result;
530 }
531
532 if ($urlEncoding === true) {
533 $decoder = function ($value) {
534 return rawurldecode(str_replace('+', ' ', $value));
535 };
536 } elseif ($urlEncoding == PHP_QUERY_RFC3986) {
537 $decoder = 'rawurldecode';
538 } elseif ($urlEncoding == PHP_QUERY_RFC1738) {
539 $decoder = 'urldecode';
540 } else {
541 $decoder = function ($str) { return $str; };
542 }
543
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;
548 if (!isset($result[$key])) {
549 $result[$key] = $value;
550 } else {
551 if (!is_array($result[$key])) {
552 $result[$key] = [$result[$key]];
553 }
554 $result[$key][] = $value;
555 }
556 }
557
558 return $result;
559}
560
574function build_query(array $params, $encoding = PHP_QUERY_RFC3986)
575{
576 if (!$params) {
577 return '';
578 }
579
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';
586 } else {
587 throw new \InvalidArgumentException('Invalid type');
588 }
589
590 $qs = '';
591 foreach ($params as $k => $v) {
592 $k = $encoder($k);
593 if (!is_array($v)) {
594 $qs .= $k;
595 if ($v !== null) {
596 $qs .= '=' . $encoder($v);
597 }
598 $qs .= '&';
599 } else {
600 foreach ($v as $vv) {
601 $qs .= $k;
602 if ($vv !== null) {
603 $qs .= '=' . $encoder($vv);
604 }
605 $qs .= '&';
606 }
607 }
608 }
609
610 return $qs ? (string) substr($qs, 0, -1) : '';
611}
612
621{
622 return mimetype_from_extension(pathinfo($filename, PATHINFO_EXTENSION));
623}
624
633function mimetype_from_extension($extension)
634{
635 static $mimetypes = [
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',
649 'css' => 'text/css',
650 'csv' => 'text/csv',
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',
734 ];
735
736 $extension = strtolower($extension);
737
738 return isset($mimetypes[$extension])
739 ? $mimetypes[$extension]
740 : null;
741}
742
756{
757 if (!$message) {
758 throw new \InvalidArgumentException('Invalid message');
759 }
760
761 // Iterate over each line in the message, accounting for line endings
762 $lines = preg_split('/(\\r?\\n)/', $message, -1, PREG_SPLIT_DELIM_CAPTURE);
763 $result = ['start-line' => array_shift($lines), 'headers' => [], 'body' => ''];
764 array_shift($lines);
765
766 for ($i = 0, $totalLines = count($lines); $i < $totalLines; $i += 2) {
767 $line = $lines[$i];
768 // If two line breaks were encountered, then this is the end of body
769 if (empty($line)) {
770 if ($i < $totalLines - 1) {
771 $result['body'] = implode('', array_slice($lines, $i + 2));
772 }
773 break;
774 }
775 if (strpos($line, ':')) {
776 $parts = explode(':', $line, 2);
777 $key = trim($parts[0]);
778 $value = isset($parts[1]) ? trim($parts[1]) : '';
779 $result['headers'][$key][] = $value;
780 }
781 }
782
783 return $result;
784}
785
795function _parse_request_uri($path, array $headers)
796{
797 $hostKey = array_filter(array_keys($headers), function ($k) {
798 return strtolower($k) === 'host';
799 });
800
801 // If no host is found, then a full URI cannot be constructed.
802 if (!$hostKey) {
803 return $path;
804 }
805
806 $host = $headers[reset($hostKey)][0];
807 $scheme = substr($host, -4) === ':443' ? 'https' : 'http';
808
809 return $scheme . '://' . $host . '/' . ltrim($path, '/');
810}
811
814{
815 $result = [];
816
817 foreach ($keys as &$key) {
818 $key = strtolower($key);
819 }
820
821 foreach ($data as $k => $v) {
822 if (!in_array(strtolower($k), $keys)) {
823 $result[$k] = $v;
824 }
825 }
826
827 return $result;
828}
sprintf('%.4f', $callTime)
$result
$size
Definition: RandomTest.php:84
if(!isset( $_REQUEST[ 'ReturnTo'])) if(!isset($_REQUEST['AuthId'])) $options
Definition: as_login.php:20
$source
Definition: linkback.php:22
An exception for terminatinating execution or to throw for unit testing.
Provides a read only stream that pumps data from a PHP callable.
Definition: PumpStream.php:17
PSR-7 request implementation.
Definition: Request.php:13
PSR-7 response implementation.
Definition: Response.php:11
Server-side HTTP request.
PSR-7 URI implementation.
Definition: Uri.php:14
$key
Definition: croninfo.php:18
$i
Definition: disco.tpl.php:19
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.
Describes a data stream.
write($string)
Write data to the stream.
Value object representing a URI.
if($format !==null) $name
Definition: metadata.php:146
catch(Exception $e) $message
$keys
$mimetypes
Definition: mimemap.php:5
readline(StreamInterface $stream, $maxLength=null)
Read a line from the stream up to the maximum allowed buffer length.
Definition: functions.php:436
normalize_header($header)
Converts an array of header values that may contain comma separated headers into an array of headers ...
Definition: functions.php:162
$stream
PHP stream implementation.
stream_for($resource='', array $options=[])
Create a new stream based on the input type.
Definition: functions.php:78
mimetype_from_extension($extension)
Maps a file extensions to a mimetype.
Definition: functions.php:633
parse_response($message)
Parses a response message string into a response object.
Definition: functions.php:491
rewind_body(MessageInterface $message)
Attempts to rewind a message body and throws an exception on failure.
Definition: functions.php:274
parse_request($message)
Parses a request message string into a request object.
Definition: functions.php:463
build_query(array $params, $encoding=PHP_QUERY_RFC3986)
Build a query string from an array of key value pairs.
Definition: functions.php:574
hash(StreamInterface $stream, $algo, $rawOutput=false)
Calculate a hash of a Stream.
Definition: functions.php:406
_parse_message($message)
Parses an HTTP message into an associative array.
Definition: functions.php:755
modify_request(RequestInterface $request, array $changes)
Clone and modify a request with the given changes.
Definition: functions.php:201
parse_query($str, $urlEncoding=true)
Parse a query string into an associative array.
Definition: functions.php:524
str(MessageInterface $message)
Returns the string representation of an HTTP message.
Definition: functions.php:18
mimetype_from_filename($filename)
Determines the mimetype of a file by looking at its extension.
Definition: functions.php:620
uri_for($uri)
Returns a UriInterface for the given value.
Definition: functions.php:54
_caseless_remove($keys, array $data)
Definition: functions.php:813
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.
Definition: functions.php:369
parse_header($header)
Parse an array of header values containing ";" separated data into an array of associative arrays rep...
Definition: functions.php:129
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.
Definition: functions.php:328
_parse_request_uri($path, array $headers)
Constructs a URI for an HTTP request message.
Definition: functions.php:795
$algo
Definition: pwgen.php:34
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
$params
Definition: disable.php:11
if($state['core:TerminatedAssocId'] !==null) $remaining