1
|
|
|
<?php |
2
|
|
|
namespace GuzzleHttp\Psr7; |
3
|
|
|
|
4
|
|
|
use Psr\Http\Message\MessageInterface; |
5
|
|
|
use Psr\Http\Message\RequestInterface; |
6
|
|
|
use Psr\Http\Message\ResponseInterface; |
7
|
|
|
use Psr\Http\Message\ServerRequestInterface; |
8
|
|
|
use Psr\Http\Message\StreamInterface; |
9
|
|
|
use Psr\Http\Message\UriInterface; |
10
|
|
|
|
11
|
|
|
/** |
12
|
|
|
* Returns the string representation of an HTTP message. |
13
|
|
|
* |
14
|
|
|
* @param MessageInterface $message Message to convert to a string. |
15
|
|
|
* |
16
|
|
|
* @return string |
17
|
|
|
*/ |
18
|
|
|
function str(MessageInterface $message) |
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
|
|
|
|
42
|
|
|
/** |
43
|
|
|
* Returns a UriInterface for the given value. |
44
|
|
|
* |
45
|
|
|
* This function accepts a string or {@see Psr\Http\Message\UriInterface} and |
46
|
|
|
* returns a UriInterface for the given value. If the value is already a |
47
|
|
|
* `UriInterface`, it is returned as-is. |
48
|
|
|
* |
49
|
|
|
* @param string|UriInterface $uri |
50
|
|
|
* |
51
|
|
|
* @return UriInterface |
52
|
|
|
* @throws \InvalidArgumentException |
53
|
|
|
*/ |
54
|
|
|
function 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
|
|
|
|
65
|
|
|
/** |
66
|
|
|
* Create a new stream based on the input type. |
67
|
|
|
* |
68
|
|
|
* Options is an associative array that can contain the following keys: |
69
|
|
|
* - metadata: Array of custom metadata. |
70
|
|
|
* - size: Size of the stream. |
71
|
|
|
* |
72
|
|
|
* @param resource|string|null|int|float|bool|StreamInterface|callable $resource Entity body data |
73
|
|
|
* @param array $options Additional options |
74
|
|
|
* |
75
|
|
|
* @return Stream |
76
|
|
|
* @throws \InvalidArgumentException if the $resource arg is not valid. |
77
|
|
|
*/ |
78
|
|
|
function 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
|
|
|
|
119
|
|
|
/** |
120
|
|
|
* Parse an array of header values containing ";" separated data into an |
121
|
|
|
* array of associative arrays representing the header key value pair |
122
|
|
|
* data of the header. When a parameter does not contain a value, but just |
123
|
|
|
* contains a key, this function will inject a key with a '' string value. |
124
|
|
|
* |
125
|
|
|
* @param string|array $header Header to parse into components. |
126
|
|
|
* |
127
|
|
|
* @return array Returns the parsed header values. |
128
|
|
|
*/ |
129
|
|
|
function parse_header($header) |
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
|
|
|
|
154
|
|
|
/** |
155
|
|
|
* Converts an array of header values that may contain comma separated |
156
|
|
|
* headers into an array of headers with no comma separated values. |
157
|
|
|
* |
158
|
|
|
* @param string|array $header Header to normalize. |
159
|
|
|
* |
160
|
|
|
* @return array Returns the normalized header field values. |
161
|
|
|
*/ |
162
|
|
|
function normalize_header($header) |
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
|
|
|
|
184
|
|
|
/** |
185
|
|
|
* Clone and modify a request with the given changes. |
186
|
|
|
* |
187
|
|
|
* The changes can be one of: |
188
|
|
|
* - method: (string) Changes the HTTP method. |
189
|
|
|
* - set_headers: (array) Sets the given headers. |
190
|
|
|
* - remove_headers: (array) Remove the given headers. |
191
|
|
|
* - body: (mixed) Sets the given body. |
192
|
|
|
* - uri: (UriInterface) Set the URI. |
193
|
|
|
* - query: (string) Set the query string value of the URI. |
194
|
|
|
* - version: (string) Set the protocol version. |
195
|
|
|
* |
196
|
|
|
* @param RequestInterface $request Request to clone and modify. |
197
|
|
|
* @param array $changes Changes to apply. |
198
|
|
|
* |
199
|
|
|
* @return RequestInterface |
200
|
|
|
*/ |
201
|
|
|
function 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
|
|
|
|
264
|
|
|
/** |
265
|
|
|
* Attempts to rewind a message body and throws an exception on failure. |
266
|
|
|
* |
267
|
|
|
* The body of the message will only be rewound if a call to `tell()` returns a |
268
|
|
|
* value other than `0`. |
269
|
|
|
* |
270
|
|
|
* @param MessageInterface $message Message to rewind |
271
|
|
|
* |
272
|
|
|
* @throws \RuntimeException |
273
|
|
|
*/ |
274
|
|
|
function rewind_body(MessageInterface $message) |
275
|
|
|
{ |
276
|
|
|
$body = $message->getBody(); |
277
|
|
|
|
278
|
|
|
if ($body->tell()) { |
279
|
|
|
$body->rewind(); |
280
|
|
|
} |
281
|
|
|
} |
282
|
|
|
|
283
|
|
|
/** |
284
|
|
|
* Safely opens a PHP stream resource using a filename. |
285
|
|
|
* |
286
|
|
|
* When fopen fails, PHP normally raises a warning. This function adds an |
287
|
|
|
* error handler that checks for errors and throws an exception instead. |
288
|
|
|
* |
289
|
|
|
* @param string $filename File to open |
290
|
|
|
* @param string $mode Mode used to open the file |
291
|
|
|
* |
292
|
|
|
* @return resource |
293
|
|
|
* @throws \RuntimeException if the file cannot be opened |
294
|
|
|
*/ |
295
|
|
|
function 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) { |
311
|
|
|
/** @var $ex \RuntimeException */ |
312
|
|
|
throw $ex; |
313
|
|
|
} |
314
|
|
|
|
315
|
|
|
return $handle; |
316
|
|
|
} |
317
|
|
|
|
318
|
|
|
/** |
319
|
|
|
* Copy the contents of a stream into a string until the given number of |
320
|
|
|
* bytes have been read. |
321
|
|
|
* |
322
|
|
|
* @param StreamInterface $stream Stream to read |
323
|
|
|
* @param int $maxLen Maximum number of bytes to read. Pass -1 |
324
|
|
|
* to read the entire stream. |
325
|
|
|
* @return string |
326
|
|
|
* @throws \RuntimeException on error. |
327
|
|
|
*/ |
328
|
|
|
function copy_to_string(StreamInterface $stream, $maxLen = -1) |
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
|
|
|
|
358
|
|
|
/** |
359
|
|
|
* Copy the contents of a stream into another stream until the given number |
360
|
|
|
* of bytes have been read. |
361
|
|
|
* |
362
|
|
|
* @param StreamInterface $source Stream to read from |
363
|
|
|
* @param StreamInterface $dest Stream to write to |
364
|
|
|
* @param int $maxLen Maximum number of bytes to read. Pass -1 |
365
|
|
|
* to read the entire stream. |
366
|
|
|
* |
367
|
|
|
* @throws \RuntimeException on error. |
368
|
|
|
*/ |
369
|
|
|
function copy_to_stream( |
370
|
|
|
StreamInterface $source, |
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
|
|
|
|
396
|
|
|
/** |
397
|
|
|
* Calculate a hash of a Stream |
398
|
|
|
* |
399
|
|
|
* @param StreamInterface $stream Stream to calculate the hash for |
400
|
|
|
* @param string $algo Hash algorithm (e.g. md5, crc32, etc) |
401
|
|
|
* @param bool $rawOutput Whether or not to use raw output |
402
|
|
|
* |
403
|
|
|
* @return string Returns the hash of the stream |
404
|
|
|
* @throws \RuntimeException on error. |
405
|
|
|
*/ |
406
|
|
|
function hash( |
407
|
|
|
StreamInterface $stream, |
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
|
|
|
|
428
|
|
|
/** |
429
|
|
|
* Read a line from the stream up to the maximum allowed buffer length |
430
|
|
|
* |
431
|
|
|
* @param StreamInterface $stream Stream to read from |
432
|
|
|
* @param int $maxLength Maximum buffer length |
433
|
|
|
* |
434
|
|
|
* @return string |
435
|
|
|
*/ |
436
|
|
|
function 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
|
|
|
|
456
|
|
|
/** |
457
|
|
|
* Parses a request message string into a request object. |
458
|
|
|
* |
459
|
|
|
* @param string $message Request message string. |
460
|
|
|
* |
461
|
|
|
* @return Request |
462
|
|
|
*/ |
463
|
|
|
function parse_request($message) |
464
|
|
|
{ |
465
|
|
|
$data = _parse_message($message); |
|
|
|
|
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'], |
478
|
|
|
$version |
479
|
|
|
); |
480
|
|
|
|
481
|
|
|
return $matches[1] === '/' ? $request : $request->withRequestTarget($parts[1]); |
482
|
|
|
} |
483
|
|
|
|
484
|
|
|
/** |
485
|
|
|
* Parses a response message string into a response object. |
486
|
|
|
* |
487
|
|
|
* @param string $message Response message string. |
488
|
|
|
* |
489
|
|
|
* @return Response |
490
|
|
|
*/ |
491
|
|
|
function parse_response($message) |
492
|
|
|
{ |
493
|
|
|
$data = _parse_message($message); |
|
|
|
|
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: ' . $data['start-line']); |
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
|
|
|
|
511
|
|
|
/** |
512
|
|
|
* Parse a query string into an associative array. |
513
|
|
|
* |
514
|
|
|
* If multiple values are found for the same key, the value of that key |
515
|
|
|
* value pair will become an array. This function does not parse nested |
516
|
|
|
* PHP style arrays into an associative array (e.g., foo[a]=1&foo[b]=2 will |
517
|
|
|
* be parsed into ['foo[a]' => '1', 'foo[b]' => '2']). |
518
|
|
|
* |
519
|
|
|
* @param string $str Query string to parse |
520
|
|
|
* @param bool|string $urlEncoding How the query string is encoded |
521
|
|
|
* |
522
|
|
|
* @return array |
523
|
|
|
*/ |
524
|
|
|
function 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
|
|
|
|
561
|
|
|
/** |
562
|
|
|
* Build a query string from an array of key value pairs. |
563
|
|
|
* |
564
|
|
|
* This function can use the return value of parse_query() to build a query |
565
|
|
|
* string. This function does not modify the provided keys when an array is |
566
|
|
|
* encountered (like http_build_query would). |
567
|
|
|
* |
568
|
|
|
* @param array $params Query string parameters. |
569
|
|
|
* @param int|false $encoding Set to false to not encode, PHP_QUERY_RFC3986 |
570
|
|
|
* to encode using RFC3986, or PHP_QUERY_RFC1738 |
571
|
|
|
* to encode using RFC1738. |
572
|
|
|
* @return string |
573
|
|
|
*/ |
574
|
|
|
function 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
|
|
|
|
613
|
|
|
/** |
614
|
|
|
* Determines the mimetype of a file by looking at its extension. |
615
|
|
|
* |
616
|
|
|
* @param $filename |
617
|
|
|
* |
618
|
|
|
* @return null|string |
619
|
|
|
*/ |
620
|
|
|
function mimetype_from_filename($filename) |
621
|
|
|
{ |
622
|
|
|
return mimetype_from_extension(pathinfo($filename, PATHINFO_EXTENSION)); |
|
|
|
|
623
|
|
|
} |
624
|
|
|
|
625
|
|
|
/** |
626
|
|
|
* Maps a file extensions to a mimetype. |
627
|
|
|
* |
628
|
|
|
* @param $extension string The file extension. |
629
|
|
|
* |
630
|
|
|
* @return string|null |
631
|
|
|
* @link http://svn.apache.org/repos/asf/httpd/httpd/branches/1.3.x/conf/mime.types |
632
|
|
|
*/ |
633
|
|
|
function 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
|
|
|
|
743
|
|
|
/** |
744
|
|
|
* Parses an HTTP message into an associative array. |
745
|
|
|
* |
746
|
|
|
* The array contains the "start-line" key containing the start line of |
747
|
|
|
* the message, "headers" key containing an associative array of header |
748
|
|
|
* array values, and a "body" key containing the body of the message. |
749
|
|
|
* |
750
|
|
|
* @param string $message HTTP request or response to parse. |
751
|
|
|
* |
752
|
|
|
* @return array |
753
|
|
|
* @internal |
754
|
|
|
*/ |
755
|
|
|
function _parse_message($message) |
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
|
|
|
|
786
|
|
|
/** |
787
|
|
|
* Constructs a URI for an HTTP request message. |
788
|
|
|
* |
789
|
|
|
* @param string $path Path from the start-line |
790
|
|
|
* @param array $headers Array of headers (each value an array). |
791
|
|
|
* |
792
|
|
|
* @return string |
793
|
|
|
* @internal |
794
|
|
|
*/ |
795
|
|
|
function _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
|
|
|
|
812
|
|
|
/** @internal */ |
813
|
|
|
function _caseless_remove($keys, array $data) |
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
|
|
|
} |
829
|
|
|
|