Requests.php
1002 lines
| 1 | <?php |
| 2 | /** |
| 3 | * Requests for PHP |
| 4 | * |
| 5 | * Inspired by Requests for Python. |
| 6 | * |
| 7 | * Based on concepts from SimplePie_File, RequestCore and WP_Http. |
| 8 | * |
| 9 | * @package Requests |
| 10 | */ |
| 11 | |
| 12 | /** |
| 13 | * Requests for PHP |
| 14 | * |
| 15 | * Inspired by Requests for Python. |
| 16 | * |
| 17 | * Based on concepts from SimplePie_File, RequestCore and WP_Http. |
| 18 | * |
| 19 | * @package Requests |
| 20 | */ |
| 21 | class Requests { |
| 22 | /** |
| 23 | * POST method |
| 24 | * |
| 25 | * @var string |
| 26 | */ |
| 27 | const POST = 'POST'; |
| 28 | |
| 29 | /** |
| 30 | * PUT method |
| 31 | * |
| 32 | * @var string |
| 33 | */ |
| 34 | const PUT = 'PUT'; |
| 35 | |
| 36 | /** |
| 37 | * GET method |
| 38 | * |
| 39 | * @var string |
| 40 | */ |
| 41 | const GET = 'GET'; |
| 42 | |
| 43 | /** |
| 44 | * HEAD method |
| 45 | * |
| 46 | * @var string |
| 47 | */ |
| 48 | const HEAD = 'HEAD'; |
| 49 | |
| 50 | /** |
| 51 | * DELETE method |
| 52 | * |
| 53 | * @var string |
| 54 | */ |
| 55 | const DELETE = 'DELETE'; |
| 56 | |
| 57 | /** |
| 58 | * OPTIONS method |
| 59 | * |
| 60 | * @var string |
| 61 | */ |
| 62 | const OPTIONS = 'OPTIONS'; |
| 63 | |
| 64 | /** |
| 65 | * TRACE method |
| 66 | * |
| 67 | * @var string |
| 68 | */ |
| 69 | const TRACE = 'TRACE'; |
| 70 | |
| 71 | /** |
| 72 | * PATCH method |
| 73 | * |
| 74 | * @link https://tools.ietf.org/html/rfc5789 |
| 75 | * @var string |
| 76 | */ |
| 77 | const PATCH = 'PATCH'; |
| 78 | |
| 79 | /** |
| 80 | * Default size of buffer size to read streams |
| 81 | * |
| 82 | * @var integer |
| 83 | */ |
| 84 | const BUFFER_SIZE = 1160; |
| 85 | |
| 86 | /** |
| 87 | * Current version of Requests |
| 88 | * |
| 89 | * @var string |
| 90 | */ |
| 91 | const VERSION = '1.7'; |
| 92 | |
| 93 | /** |
| 94 | * Registered transport classes |
| 95 | * |
| 96 | * @var array |
| 97 | */ |
| 98 | protected static $transports = array(); |
| 99 | |
| 100 | /** |
| 101 | * Selected transport name |
| 102 | * |
| 103 | * Use {@see get_transport()} instead |
| 104 | * |
| 105 | * @var array |
| 106 | */ |
| 107 | public static $transport = array(); |
| 108 | |
| 109 | /** |
| 110 | * Default certificate path. |
| 111 | * |
| 112 | * @see Requests::get_certificate_path() |
| 113 | * @see Requests::set_certificate_path() |
| 114 | * |
| 115 | * @var string |
| 116 | */ |
| 117 | protected static $certificate_path; |
| 118 | |
| 119 | /** |
| 120 | * This is a static class, do not instantiate it |
| 121 | * |
| 122 | * @codeCoverageIgnore |
| 123 | */ |
| 124 | private function __construct() {} |
| 125 | |
| 126 | /** |
| 127 | * Autoloader for Requests |
| 128 | * |
| 129 | * Register this with {@see register_autoloader()} if you'd like to avoid |
| 130 | * having to create your own. |
| 131 | * |
| 132 | * (You can also use `spl_autoload_register` directly if you'd prefer.) |
| 133 | * |
| 134 | * @codeCoverageIgnore |
| 135 | * |
| 136 | * @param string $class Class name to load |
| 137 | */ |
| 138 | public static function autoloader($class) { |
| 139 | // Check that the class starts with "Requests" |
| 140 | if (strpos($class, 'Requests') !== 0) { |
| 141 | return; |
| 142 | } |
| 143 | |
| 144 | $file = str_replace('_', '/', $class); |
| 145 | if (file_exists(dirname(__FILE__) . '/' . $file . '.php')) { |
| 146 | require_once dirname(__FILE__) . '/' . $file . '.php'; |
| 147 | } |
| 148 | } |
| 149 | |
| 150 | /** |
| 151 | * Register the built-in autoloader |
| 152 | * |
| 153 | * @codeCoverageIgnore |
| 154 | */ |
| 155 | public static function register_autoloader() { |
| 156 | spl_autoload_register(array('Requests', 'autoloader')); |
| 157 | } |
| 158 | |
| 159 | /** |
| 160 | * Register a transport |
| 161 | * |
| 162 | * @param string $transport Transport class to add, must support the Requests_Transport interface |
| 163 | */ |
| 164 | public static function add_transport($transport) { |
| 165 | if (empty(self::$transports)) { |
| 166 | self::$transports = array( |
| 167 | 'Requests_Transport_cURL', |
| 168 | 'Requests_Transport_fsockopen', |
| 169 | ); |
| 170 | } |
| 171 | |
| 172 | self::$transports = array_merge(self::$transports, array($transport)); |
| 173 | } |
| 174 | |
| 175 | /** |
| 176 | * Get a working transport |
| 177 | * |
| 178 | * @throws Requests_Exception If no valid transport is found (`notransport`) |
| 179 | * @return Requests_Transport |
| 180 | */ |
| 181 | protected static function get_transport($capabilities = array()) { |
| 182 | // Caching code, don't bother testing coverage |
| 183 | // @codeCoverageIgnoreStart |
| 184 | // array of capabilities as a string to be used as an array key |
| 185 | ksort($capabilities); |
| 186 | $cap_string = serialize($capabilities); |
| 187 | |
| 188 | // Don't search for a transport if it's already been done for these $capabilities |
| 189 | if (isset(self::$transport[$cap_string]) && self::$transport[$cap_string] !== null) { |
| 190 | $class = self::$transport[$cap_string]; |
| 191 | return new $class(); |
| 192 | } |
| 193 | // @codeCoverageIgnoreEnd |
| 194 | |
| 195 | if (empty(self::$transports)) { |
| 196 | self::$transports = array( |
| 197 | 'Requests_Transport_cURL', |
| 198 | 'Requests_Transport_fsockopen', |
| 199 | ); |
| 200 | } |
| 201 | |
| 202 | // Find us a working transport |
| 203 | foreach (self::$transports as $class) { |
| 204 | if (!class_exists($class)) { |
| 205 | continue; |
| 206 | } |
| 207 | |
| 208 | $result = call_user_func(array($class, 'test'), $capabilities); |
| 209 | if ($result) { |
| 210 | self::$transport[$cap_string] = $class; |
| 211 | break; |
| 212 | } |
| 213 | } |
| 214 | if (self::$transport[$cap_string] === null) { |
| 215 | throw new Requests_Exception('No working transports found', 'notransport', self::$transports); |
| 216 | } |
| 217 | |
| 218 | $class = self::$transport[$cap_string]; |
| 219 | return new $class(); |
| 220 | } |
| 221 | |
| 222 | /**#@+ |
| 223 | * @see request() |
| 224 | * @param string $url |
| 225 | * @param array $headers |
| 226 | * @param array $options |
| 227 | * @return Requests_Response |
| 228 | */ |
| 229 | /** |
| 230 | * Send a GET request |
| 231 | */ |
| 232 | public static function get($url, $headers = array(), $options = array()) { |
| 233 | return self::request($url, $headers, null, self::GET, $options); |
| 234 | } |
| 235 | |
| 236 | /** |
| 237 | * Send a HEAD request |
| 238 | */ |
| 239 | public static function head($url, $headers = array(), $options = array()) { |
| 240 | return self::request($url, $headers, null, self::HEAD, $options); |
| 241 | } |
| 242 | |
| 243 | /** |
| 244 | * Send a DELETE request |
| 245 | */ |
| 246 | public static function delete($url, $headers = array(), $options = array()) { |
| 247 | return self::request($url, $headers, null, self::DELETE, $options); |
| 248 | } |
| 249 | |
| 250 | /** |
| 251 | * Send a TRACE request |
| 252 | */ |
| 253 | public static function trace($url, $headers = array(), $options = array()) { |
| 254 | return self::request($url, $headers, null, self::TRACE, $options); |
| 255 | } |
| 256 | /**#@-*/ |
| 257 | |
| 258 | /**#@+ |
| 259 | * @see request() |
| 260 | * @param string $url |
| 261 | * @param array $headers |
| 262 | * @param array $data |
| 263 | * @param array $options |
| 264 | * @return Requests_Response |
| 265 | */ |
| 266 | /** |
| 267 | * Send a POST request |
| 268 | */ |
| 269 | public static function post($url, $headers = array(), $data = array(), $options = array()) { |
| 270 | return self::request($url, $headers, $data, self::POST, $options); |
| 271 | } |
| 272 | /** |
| 273 | * Send a PUT request |
| 274 | */ |
| 275 | public static function put($url, $headers = array(), $data = array(), $options = array()) { |
| 276 | return self::request($url, $headers, $data, self::PUT, $options); |
| 277 | } |
| 278 | |
| 279 | /** |
| 280 | * Send an OPTIONS request |
| 281 | */ |
| 282 | public static function options($url, $headers = array(), $data = array(), $options = array()) { |
| 283 | return self::request($url, $headers, $data, self::OPTIONS, $options); |
| 284 | } |
| 285 | |
| 286 | /** |
| 287 | * Send a PATCH request |
| 288 | * |
| 289 | * Note: Unlike {@see post} and {@see put}, `$headers` is required, as the |
| 290 | * specification recommends that should send an ETag |
| 291 | * |
| 292 | * @link https://tools.ietf.org/html/rfc5789 |
| 293 | */ |
| 294 | public static function patch($url, $headers, $data = array(), $options = array()) { |
| 295 | return self::request($url, $headers, $data, self::PATCH, $options); |
| 296 | } |
| 297 | /**#@-*/ |
| 298 | |
| 299 | /** |
| 300 | * Main interface for HTTP requests |
| 301 | * |
| 302 | * This method initiates a request and sends it via a transport before |
| 303 | * parsing. |
| 304 | * |
| 305 | * The `$options` parameter takes an associative array with the following |
| 306 | * options: |
| 307 | * |
| 308 | * - `timeout`: How long should we wait for a response? |
| 309 | * Note: for cURL, a minimum of 1 second applies, as DNS resolution |
| 310 | * operates at second-resolution only. |
| 311 | * (float, seconds with a millisecond precision, default: 10, example: 0.01) |
| 312 | * - `connect_timeout`: How long should we wait while trying to connect? |
| 313 | * (float, seconds with a millisecond precision, default: 10, example: 0.01) |
| 314 | * - `useragent`: Useragent to send to the server |
| 315 | * (string, default: php-requests/$version) |
| 316 | * - `follow_redirects`: Should we follow 3xx redirects? |
| 317 | * (boolean, default: true) |
| 318 | * - `redirects`: How many times should we redirect before erroring? |
| 319 | * (integer, default: 10) |
| 320 | * - `blocking`: Should we block processing on this request? |
| 321 | * (boolean, default: true) |
| 322 | * - `filename`: File to stream the body to instead. |
| 323 | * (string|boolean, default: false) |
| 324 | * - `auth`: Authentication handler or array of user/password details to use |
| 325 | * for Basic authentication |
| 326 | * (Requests_Auth|array|boolean, default: false) |
| 327 | * - `proxy`: Proxy details to use for proxy by-passing and authentication |
| 328 | * (Requests_Proxy|array|string|boolean, default: false) |
| 329 | * - `max_bytes`: Limit for the response body size. |
| 330 | * (integer|boolean, default: false) |
| 331 | * - `idn`: Enable IDN parsing |
| 332 | * (boolean, default: true) |
| 333 | * - `transport`: Custom transport. Either a class name, or a |
| 334 | * transport object. Defaults to the first working transport from |
| 335 | * {@see getTransport()} |
| 336 | * (string|Requests_Transport, default: {@see getTransport()}) |
| 337 | * - `hooks`: Hooks handler. |
| 338 | * (Requests_Hooker, default: new Requests_Hooks()) |
| 339 | * - `verify`: Should we verify SSL certificates? Allows passing in a custom |
| 340 | * certificate file as a string. (Using true uses the system-wide root |
| 341 | * certificate store instead, but this may have different behaviour |
| 342 | * across transports.) |
| 343 | * (string|boolean, default: library/Requests/Transport/cacert.pem) |
| 344 | * - `verifyname`: Should we verify the common name in the SSL certificate? |
| 345 | * (boolean, default: true) |
| 346 | * - `data_format`: How should we send the `$data` parameter? |
| 347 | * (string, one of 'query' or 'body', default: 'query' for |
| 348 | * HEAD/GET/DELETE, 'body' for POST/PUT/OPTIONS/PATCH) |
| 349 | * |
| 350 | * @throws Requests_Exception On invalid URLs (`nonhttp`) |
| 351 | * |
| 352 | * @param string $url URL to request |
| 353 | * @param array $headers Extra headers to send with the request |
| 354 | * @param array|null $data Data to send either as a query string for GET/HEAD requests, or in the body for POST requests |
| 355 | * @param string $type HTTP request type (use Requests constants) |
| 356 | * @param array $options Options for the request (see description for more information) |
| 357 | * @return Requests_Response |
| 358 | */ |
| 359 | public static function request($url, $headers = array(), $data = array(), $type = self::GET, $options = array()) { |
| 360 | if (empty($options['type'])) { |
| 361 | $options['type'] = $type; |
| 362 | } |
| 363 | $options = array_merge(self::get_default_options(), $options); |
| 364 | |
| 365 | self::set_defaults($url, $headers, $data, $type, $options); |
| 366 | |
| 367 | $options['hooks']->dispatch('requests.before_request', array(&$url, &$headers, &$data, &$type, &$options)); |
| 368 | |
| 369 | if (!empty($options['transport'])) { |
| 370 | $transport = $options['transport']; |
| 371 | |
| 372 | if (is_string($options['transport'])) { |
| 373 | $transport = new $transport(); |
| 374 | } |
| 375 | } |
| 376 | else { |
| 377 | $need_ssl = (stripos($url, 'https://') === 0); |
| 378 | $capabilities = array('ssl' => $need_ssl); |
| 379 | $transport = self::get_transport($capabilities); |
| 380 | } |
| 381 | $response = $transport->request($url, $headers, $data, $options); |
| 382 | |
| 383 | $options['hooks']->dispatch('requests.before_parse', array(&$response, $url, $headers, $data, $type, $options)); |
| 384 | |
| 385 | return self::parse_response($response, $url, $headers, $data, $options); |
| 386 | } |
| 387 | |
| 388 | /** |
| 389 | * Send multiple HTTP requests simultaneously |
| 390 | * |
| 391 | * The `$requests` parameter takes an associative or indexed array of |
| 392 | * request fields. The key of each request can be used to match up the |
| 393 | * request with the returned data, or with the request passed into your |
| 394 | * `multiple.request.complete` callback. |
| 395 | * |
| 396 | * The request fields value is an associative array with the following keys: |
| 397 | * |
| 398 | * - `url`: Request URL Same as the `$url` parameter to |
| 399 | * {@see Requests::request} |
| 400 | * (string, required) |
| 401 | * - `headers`: Associative array of header fields. Same as the `$headers` |
| 402 | * parameter to {@see Requests::request} |
| 403 | * (array, default: `array()`) |
| 404 | * - `data`: Associative array of data fields or a string. Same as the |
| 405 | * `$data` parameter to {@see Requests::request} |
| 406 | * (array|string, default: `array()`) |
| 407 | * - `type`: HTTP request type (use Requests constants). Same as the `$type` |
| 408 | * parameter to {@see Requests::request} |
| 409 | * (string, default: `Requests::GET`) |
| 410 | * - `cookies`: Associative array of cookie name to value, or cookie jar. |
| 411 | * (array|Requests_Cookie_Jar) |
| 412 | * |
| 413 | * If the `$options` parameter is specified, individual requests will |
| 414 | * inherit options from it. This can be used to use a single hooking system, |
| 415 | * or set all the types to `Requests::POST`, for example. |
| 416 | * |
| 417 | * In addition, the `$options` parameter takes the following global options: |
| 418 | * |
| 419 | * - `complete`: A callback for when a request is complete. Takes two |
| 420 | * parameters, a Requests_Response/Requests_Exception reference, and the |
| 421 | * ID from the request array (Note: this can also be overridden on a |
| 422 | * per-request basis, although that's a little silly) |
| 423 | * (callback) |
| 424 | * |
| 425 | * @param array $requests Requests data (see description for more information) |
| 426 | * @param array $options Global and default options (see {@see Requests::request}) |
| 427 | * @return array Responses (either Requests_Response or a Requests_Exception object) |
| 428 | */ |
| 429 | public static function request_multiple($requests, $options = array()) { |
| 430 | $options = array_merge(self::get_default_options(true), $options); |
| 431 | |
| 432 | if (!empty($options['hooks'])) { |
| 433 | $options['hooks']->register('transport.internal.parse_response', array('Requests', 'parse_multiple')); |
| 434 | if (!empty($options['complete'])) { |
| 435 | $options['hooks']->register('multiple.request.complete', $options['complete']); |
| 436 | } |
| 437 | } |
| 438 | |
| 439 | foreach ($requests as $id => &$request) { |
| 440 | if (!isset($request['headers'])) { |
| 441 | $request['headers'] = array(); |
| 442 | } |
| 443 | if (!isset($request['data'])) { |
| 444 | $request['data'] = array(); |
| 445 | } |
| 446 | if (!isset($request['type'])) { |
| 447 | $request['type'] = self::GET; |
| 448 | } |
| 449 | if (!isset($request['options'])) { |
| 450 | $request['options'] = $options; |
| 451 | $request['options']['type'] = $request['type']; |
| 452 | } |
| 453 | else { |
| 454 | if (empty($request['options']['type'])) { |
| 455 | $request['options']['type'] = $request['type']; |
| 456 | } |
| 457 | $request['options'] = array_merge($options, $request['options']); |
| 458 | } |
| 459 | |
| 460 | self::set_defaults($request['url'], $request['headers'], $request['data'], $request['type'], $request['options']); |
| 461 | |
| 462 | // Ensure we only hook in once |
| 463 | if ($request['options']['hooks'] !== $options['hooks']) { |
| 464 | $request['options']['hooks']->register('transport.internal.parse_response', array('Requests', 'parse_multiple')); |
| 465 | if (!empty($request['options']['complete'])) { |
| 466 | $request['options']['hooks']->register('multiple.request.complete', $request['options']['complete']); |
| 467 | } |
| 468 | } |
| 469 | } |
| 470 | unset($request); |
| 471 | |
| 472 | if (!empty($options['transport'])) { |
| 473 | $transport = $options['transport']; |
| 474 | |
| 475 | if (is_string($options['transport'])) { |
| 476 | $transport = new $transport(); |
| 477 | } |
| 478 | } |
| 479 | else { |
| 480 | $transport = self::get_transport(); |
| 481 | } |
| 482 | $responses = $transport->request_multiple($requests, $options); |
| 483 | |
| 484 | foreach ($responses as $id => &$response) { |
| 485 | // If our hook got messed with somehow, ensure we end up with the |
| 486 | // correct response |
| 487 | if (is_string($response)) { |
| 488 | $request = $requests[$id]; |
| 489 | self::parse_multiple($response, $request); |
| 490 | $request['options']['hooks']->dispatch('multiple.request.complete', array(&$response, $id)); |
| 491 | } |
| 492 | } |
| 493 | |
| 494 | return $responses; |
| 495 | } |
| 496 | |
| 497 | /** |
| 498 | * Get the default options |
| 499 | * |
| 500 | * @see Requests::request() for values returned by this method |
| 501 | * @param boolean $multirequest Is this a multirequest? |
| 502 | * @return array Default option values |
| 503 | */ |
| 504 | protected static function get_default_options($multirequest = false) { |
| 505 | $defaults = array( |
| 506 | 'timeout' => 10, |
| 507 | 'connect_timeout' => 10, |
| 508 | 'useragent' => 'php-requests/' . self::VERSION, |
| 509 | 'protocol_version' => 1.1, |
| 510 | 'redirected' => 0, |
| 511 | 'redirects' => 10, |
| 512 | 'follow_redirects' => true, |
| 513 | 'blocking' => true, |
| 514 | 'type' => self::GET, |
| 515 | 'filename' => false, |
| 516 | 'auth' => false, |
| 517 | 'proxy' => false, |
| 518 | 'cookies' => false, |
| 519 | 'max_bytes' => false, |
| 520 | 'idn' => true, |
| 521 | 'hooks' => null, |
| 522 | 'transport' => null, |
| 523 | 'verify' => self::get_certificate_path(), |
| 524 | 'verifyname' => true, |
| 525 | ); |
| 526 | if ($multirequest !== false) { |
| 527 | $defaults['complete'] = null; |
| 528 | } |
| 529 | return $defaults; |
| 530 | } |
| 531 | |
| 532 | /** |
| 533 | * Get default certificate path. |
| 534 | * |
| 535 | * @return string Default certificate path. |
| 536 | */ |
| 537 | public static function get_certificate_path() { |
| 538 | if (!empty(self::$certificate_path)) { |
| 539 | return self::$certificate_path; |
| 540 | } |
| 541 | |
| 542 | return dirname(__FILE__) . '/Requests/Transport/cacert.pem'; |
| 543 | } |
| 544 | |
| 545 | /** |
| 546 | * Set default certificate path. |
| 547 | * |
| 548 | * @param string $path Certificate path, pointing to a PEM file. |
| 549 | */ |
| 550 | public static function set_certificate_path($path) { |
| 551 | self::$certificate_path = $path; |
| 552 | } |
| 553 | |
| 554 | /** |
| 555 | * Set the default values |
| 556 | * |
| 557 | * @param string $url URL to request |
| 558 | * @param array $headers Extra headers to send with the request |
| 559 | * @param array|null $data Data to send either as a query string for GET/HEAD requests, or in the body for POST requests |
| 560 | * @param string $type HTTP request type |
| 561 | * @param array $options Options for the request |
| 562 | * @return array $options |
| 563 | */ |
| 564 | protected static function set_defaults(&$url, &$headers, &$data, &$type, &$options) { |
| 565 | if (!preg_match('/^http(s)?:\/\//i', $url, $matches)) { |
| 566 | throw new Requests_Exception('Only HTTP(S) requests are handled.', 'nonhttp', $url); |
| 567 | } |
| 568 | |
| 569 | if (empty($options['hooks'])) { |
| 570 | $options['hooks'] = new Requests_Hooks(); |
| 571 | } |
| 572 | |
| 573 | if (is_array($options['auth'])) { |
| 574 | $options['auth'] = new Requests_Auth_Basic($options['auth']); |
| 575 | } |
| 576 | if ($options['auth'] !== false) { |
| 577 | $options['auth']->register($options['hooks']); |
| 578 | } |
| 579 | |
| 580 | if (is_string($options['proxy']) || is_array($options['proxy'])) { |
| 581 | $options['proxy'] = new Requests_Proxy_HTTP($options['proxy']); |
| 582 | } |
| 583 | if ($options['proxy'] !== false) { |
| 584 | $options['proxy']->register($options['hooks']); |
| 585 | } |
| 586 | |
| 587 | if (is_array($options['cookies'])) { |
| 588 | $options['cookies'] = new Requests_Cookie_Jar($options['cookies']); |
| 589 | } |
| 590 | elseif (empty($options['cookies'])) { |
| 591 | $options['cookies'] = new Requests_Cookie_Jar(); |
| 592 | } |
| 593 | if ($options['cookies'] !== false) { |
| 594 | $options['cookies']->register($options['hooks']); |
| 595 | } |
| 596 | |
| 597 | if ($options['idn'] !== false) { |
| 598 | $iri = new Requests_IRI($url); |
| 599 | $iri->host = Requests_IDNAEncoder::encode($iri->ihost); |
| 600 | $url = $iri->uri; |
| 601 | } |
| 602 | |
| 603 | // Massage the type to ensure we support it. |
| 604 | $type = strtoupper($type); |
| 605 | |
| 606 | if (!isset($options['data_format'])) { |
| 607 | if (in_array($type, array(self::HEAD, self::GET, self::DELETE), true)) { |
| 608 | $options['data_format'] = 'query'; |
| 609 | } |
| 610 | else { |
| 611 | $options['data_format'] = 'body'; |
| 612 | } |
| 613 | } |
| 614 | } |
| 615 | |
| 616 | /** |
| 617 | * HTTP response parser |
| 618 | * |
| 619 | * @throws Requests_Exception On missing head/body separator (`requests.no_crlf_separator`) |
| 620 | * @throws Requests_Exception On missing head/body separator (`noversion`) |
| 621 | * @throws Requests_Exception On missing head/body separator (`toomanyredirects`) |
| 622 | * |
| 623 | * @param string $headers Full response text including headers and body |
| 624 | * @param string $url Original request URL |
| 625 | * @param array $req_headers Original $headers array passed to {@link request()}, in case we need to follow redirects |
| 626 | * @param array $req_data Original $data array passed to {@link request()}, in case we need to follow redirects |
| 627 | * @param array $options Original $options array passed to {@link request()}, in case we need to follow redirects |
| 628 | * @return Requests_Response |
| 629 | */ |
| 630 | protected static function parse_response($headers, $url, $req_headers, $req_data, $options) { |
| 631 | $return = new Requests_Response(); |
| 632 | if (!$options['blocking']) { |
| 633 | return $return; |
| 634 | } |
| 635 | |
| 636 | $return->raw = $headers; |
| 637 | $return->url = (string) $url; |
| 638 | $return->body = ''; |
| 639 | |
| 640 | if (!$options['filename']) { |
| 641 | $pos = strpos($headers, "\r\n\r\n"); |
| 642 | if ($pos === false) { |
| 643 | // Crap! |
| 644 | throw new Requests_Exception('Missing header/body separator', 'requests.no_crlf_separator'); |
| 645 | } |
| 646 | |
| 647 | $headers = substr($return->raw, 0, $pos); |
| 648 | // Headers will always be separated from the body by two new lines - `\n\r\n\r`. |
| 649 | $body = substr($return->raw, $pos + 4); |
| 650 | if (!empty($body)) { |
| 651 | $return->body = $body; |
| 652 | } |
| 653 | } |
| 654 | // Pretend CRLF = LF for compatibility (RFC 2616, section 19.3) |
| 655 | $headers = str_replace("\r\n", "\n", $headers); |
| 656 | // Unfold headers (replace [CRLF] 1*( SP | HT ) with SP) as per RFC 2616 (section 2.2) |
| 657 | $headers = preg_replace('/\n[ \t]/', ' ', $headers); |
| 658 | $headers = explode("\n", $headers); |
| 659 | preg_match('#^HTTP/(1\.\d)[ \t]+(\d+)#i', array_shift($headers), $matches); |
| 660 | if (empty($matches)) { |
| 661 | throw new Requests_Exception('Response could not be parsed', 'noversion', $headers); |
| 662 | } |
| 663 | $return->protocol_version = (float) $matches[1]; |
| 664 | $return->status_code = (int) $matches[2]; |
| 665 | if ($return->status_code >= 200 && $return->status_code < 300) { |
| 666 | $return->success = true; |
| 667 | } |
| 668 | |
| 669 | foreach ($headers as $header) { |
| 670 | list($key, $value) = explode(':', $header, 2); |
| 671 | $value = trim($value); |
| 672 | preg_replace('#(\s+)#i', ' ', $value); |
| 673 | $return->headers[$key] = $value; |
| 674 | } |
| 675 | if (isset($return->headers['transfer-encoding'])) { |
| 676 | $return->body = self::decode_chunked($return->body); |
| 677 | unset($return->headers['transfer-encoding']); |
| 678 | } |
| 679 | if (isset($return->headers['content-encoding'])) { |
| 680 | $return->body = self::decompress($return->body); |
| 681 | } |
| 682 | |
| 683 | //fsockopen and cURL compatibility |
| 684 | if (isset($return->headers['connection'])) { |
| 685 | unset($return->headers['connection']); |
| 686 | } |
| 687 | |
| 688 | $options['hooks']->dispatch('requests.before_redirect_check', array(&$return, $req_headers, $req_data, $options)); |
| 689 | |
| 690 | if ($return->is_redirect() && $options['follow_redirects'] === true) { |
| 691 | if (isset($return->headers['location']) && $options['redirected'] < $options['redirects']) { |
| 692 | if ($return->status_code === 303) { |
| 693 | $options['type'] = self::GET; |
| 694 | } |
| 695 | $options['redirected']++; |
| 696 | $location = $return->headers['location']; |
| 697 | if (strpos($location, 'http://') !== 0 && strpos($location, 'https://') !== 0) { |
| 698 | // relative redirect, for compatibility make it absolute |
| 699 | $location = Requests_IRI::absolutize($url, $location); |
| 700 | $location = $location->uri; |
| 701 | } |
| 702 | |
| 703 | $hook_args = array( |
| 704 | &$location, |
| 705 | &$req_headers, |
| 706 | &$req_data, |
| 707 | &$options, |
| 708 | $return, |
| 709 | ); |
| 710 | $options['hooks']->dispatch('requests.before_redirect', $hook_args); |
| 711 | $redirected = self::request($location, $req_headers, $req_data, $options['type'], $options); |
| 712 | $redirected->history[] = $return; |
| 713 | return $redirected; |
| 714 | } |
| 715 | elseif ($options['redirected'] >= $options['redirects']) { |
| 716 | throw new Requests_Exception('Too many redirects', 'toomanyredirects', $return); |
| 717 | } |
| 718 | } |
| 719 | |
| 720 | $return->redirects = $options['redirected']; |
| 721 | |
| 722 | $options['hooks']->dispatch('requests.after_request', array(&$return, $req_headers, $req_data, $options)); |
| 723 | return $return; |
| 724 | } |
| 725 | |
| 726 | /** |
| 727 | * Callback for `transport.internal.parse_response` |
| 728 | * |
| 729 | * Internal use only. Converts a raw HTTP response to a Requests_Response |
| 730 | * while still executing a multiple request. |
| 731 | * |
| 732 | * @param string $response Full response text including headers and body (will be overwritten with Response instance) |
| 733 | * @param array $request Request data as passed into {@see Requests::request_multiple()} |
| 734 | * @return null `$response` is either set to a Requests_Response instance, or a Requests_Exception object |
| 735 | */ |
| 736 | public static function parse_multiple(&$response, $request) { |
| 737 | try { |
| 738 | $url = $request['url']; |
| 739 | $headers = $request['headers']; |
| 740 | $data = $request['data']; |
| 741 | $options = $request['options']; |
| 742 | $response = self::parse_response($response, $url, $headers, $data, $options); |
| 743 | } |
| 744 | catch (Requests_Exception $e) { |
| 745 | $response = $e; |
| 746 | } |
| 747 | } |
| 748 | |
| 749 | /** |
| 750 | * Decoded a chunked body as per RFC 2616 |
| 751 | * |
| 752 | * @see https://tools.ietf.org/html/rfc2616#section-3.6.1 |
| 753 | * @param string $data Chunked body |
| 754 | * @return string Decoded body |
| 755 | */ |
| 756 | protected static function decode_chunked($data) { |
| 757 | if (!preg_match('/^([0-9a-f]+)(?:;(?:[\w-]*)(?:=(?:(?:[\w-]*)*|"(?:[^\r\n])*"))?)*\r\n/i', trim($data))) { |
| 758 | return $data; |
| 759 | } |
| 760 | |
| 761 | $decoded = ''; |
| 762 | $encoded = $data; |
| 763 | |
| 764 | while (true) { |
| 765 | $is_chunked = (bool) preg_match('/^([0-9a-f]+)(?:;(?:[\w-]*)(?:=(?:(?:[\w-]*)*|"(?:[^\r\n])*"))?)*\r\n/i', $encoded, $matches); |
| 766 | if (!$is_chunked) { |
| 767 | // Looks like it's not chunked after all |
| 768 | return $data; |
| 769 | } |
| 770 | |
| 771 | $length = hexdec(trim($matches[1])); |
| 772 | if ($length === 0) { |
| 773 | // Ignore trailer headers |
| 774 | return $decoded; |
| 775 | } |
| 776 | |
| 777 | $chunk_length = strlen($matches[0]); |
| 778 | $decoded .= substr($encoded, $chunk_length, $length); |
| 779 | $encoded = substr($encoded, $chunk_length + $length + 2); |
| 780 | |
| 781 | if (trim($encoded) === '0' || empty($encoded)) { |
| 782 | return $decoded; |
| 783 | } |
| 784 | } |
| 785 | |
| 786 | // We'll never actually get down here |
| 787 | // @codeCoverageIgnoreStart |
| 788 | } |
| 789 | // @codeCoverageIgnoreEnd |
| 790 | |
| 791 | /** |
| 792 | * Convert a key => value array to a 'key: value' array for headers |
| 793 | * |
| 794 | * @param array $array Dictionary of header values |
| 795 | * @return array List of headers |
| 796 | */ |
| 797 | public static function flatten($array) { |
| 798 | $return = array(); |
| 799 | foreach ($array as $key => $value) { |
| 800 | $return[] = sprintf('%s: %s', $key, $value); |
| 801 | } |
| 802 | return $return; |
| 803 | } |
| 804 | |
| 805 | /** |
| 806 | * Convert a key => value array to a 'key: value' array for headers |
| 807 | * |
| 808 | * @codeCoverageIgnore |
| 809 | * @deprecated Misspelling of {@see Requests::flatten} |
| 810 | * @param array $array Dictionary of header values |
| 811 | * @return array List of headers |
| 812 | */ |
| 813 | public static function flattern($array) { |
| 814 | return self::flatten($array); |
| 815 | } |
| 816 | |
| 817 | /** |
| 818 | * Decompress an encoded body |
| 819 | * |
| 820 | * Implements gzip, compress and deflate. Guesses which it is by attempting |
| 821 | * to decode. |
| 822 | * |
| 823 | * @param string $data Compressed data in one of the above formats |
| 824 | * @return string Decompressed string |
| 825 | */ |
| 826 | public static function decompress($data) { |
| 827 | if (substr($data, 0, 2) !== "\x1f\x8b" && substr($data, 0, 2) !== "\x78\x9c") { |
| 828 | // Not actually compressed. Probably cURL ruining this for us. |
| 829 | return $data; |
| 830 | } |
| 831 | |
| 832 | if (function_exists('gzdecode')) { |
| 833 | // phpcs:ignore PHPCompatibility.FunctionUse.NewFunctions.gzdecodeFound -- Wrapped in function_exists() for PHP 5.2. |
| 834 | $decoded = @gzdecode($data); |
| 835 | if ($decoded !== false) { |
| 836 | return $decoded; |
| 837 | } |
| 838 | } |
| 839 | |
| 840 | if (function_exists('gzinflate')) { |
| 841 | $decoded = @gzinflate($data); |
| 842 | if ($decoded !== false) { |
| 843 | return $decoded; |
| 844 | } |
| 845 | } |
| 846 | |
| 847 | $decoded = self::compatible_gzinflate($data); |
| 848 | if ($decoded !== false) { |
| 849 | return $decoded; |
| 850 | } |
| 851 | |
| 852 | if (function_exists('gzuncompress')) { |
| 853 | $decoded = @gzuncompress($data); |
| 854 | if ($decoded !== false) { |
| 855 | return $decoded; |
| 856 | } |
| 857 | } |
| 858 | |
| 859 | return $data; |
| 860 | } |
| 861 | |
| 862 | /** |
| 863 | * Decompression of deflated string while staying compatible with the majority of servers. |
| 864 | * |
| 865 | * Certain Servers will return deflated data with headers which PHP's gzinflate() |
| 866 | * function cannot handle out of the box. The following function has been created from |
| 867 | * various snippets on the gzinflate() PHP documentation. |
| 868 | * |
| 869 | * Warning: Magic numbers within. Due to the potential different formats that the compressed |
| 870 | * data may be returned in, some "magic offsets" are needed to ensure proper decompression |
| 871 | * takes place. For a simple progmatic way to determine the magic offset in use, see: |
| 872 | * https://core.trac.wordpress.org/ticket/18273 |
| 873 | * |
| 874 | * @since 2.8.1 |
| 875 | * @link https://core.trac.wordpress.org/ticket/18273 |
| 876 | * @link https://secure.php.net/manual/en/function.gzinflate.php#70875 |
| 877 | * @link https://secure.php.net/manual/en/function.gzinflate.php#77336 |
| 878 | * |
| 879 | * @param string $gz_data String to decompress. |
| 880 | * @return string|bool False on failure. |
| 881 | */ |
| 882 | public static function compatible_gzinflate($gz_data) { |
| 883 | // Compressed data might contain a full zlib header, if so strip it for |
| 884 | // gzinflate() |
| 885 | if (substr($gz_data, 0, 3) === "\x1f\x8b\x08") { |
| 886 | $i = 10; |
| 887 | $flg = ord(substr($gz_data, 3, 1)); |
| 888 | if ($flg > 0) { |
| 889 | if ($flg & 4) { |
| 890 | list($xlen) = unpack('v', substr($gz_data, $i, 2)); |
| 891 | $i += 2 + $xlen; |
| 892 | } |
| 893 | if ($flg & 8) { |
| 894 | $i = strpos($gz_data, "\0", $i) + 1; |
| 895 | } |
| 896 | if ($flg & 16) { |
| 897 | $i = strpos($gz_data, "\0", $i) + 1; |
| 898 | } |
| 899 | if ($flg & 2) { |
| 900 | $i += 2; |
| 901 | } |
| 902 | } |
| 903 | $decompressed = self::compatible_gzinflate(substr($gz_data, $i)); |
| 904 | if ($decompressed !== false) { |
| 905 | return $decompressed; |
| 906 | } |
| 907 | } |
| 908 | |
| 909 | // If the data is Huffman Encoded, we must first strip the leading 2 |
| 910 | // byte Huffman marker for gzinflate() |
| 911 | // The response is Huffman coded by many compressors such as |
| 912 | // java.util.zip.Deflater, Ruby’s Zlib::Deflate, and .NET's |
| 913 | // System.IO.Compression.DeflateStream. |
| 914 | // |
| 915 | // See https://decompres.blogspot.com/ for a quick explanation of this |
| 916 | // data type |
| 917 | $huffman_encoded = false; |
| 918 | |
| 919 | // low nibble of first byte should be 0x08 |
| 920 | list(, $first_nibble) = unpack('h', $gz_data); |
| 921 | |
| 922 | // First 2 bytes should be divisible by 0x1F |
| 923 | list(, $first_two_bytes) = unpack('n', $gz_data); |
| 924 | |
| 925 | if ($first_nibble === 0x08 && ($first_two_bytes % 0x1F) === 0) { |
| 926 | $huffman_encoded = true; |
| 927 | } |
| 928 | |
| 929 | if ($huffman_encoded) { |
| 930 | $decompressed = @gzinflate(substr($gz_data, 2)); |
| 931 | if ($decompressed !== false) { |
| 932 | return $decompressed; |
| 933 | } |
| 934 | } |
| 935 | |
| 936 | if (substr($gz_data, 0, 4) === "\x50\x4b\x03\x04") { |
| 937 | // ZIP file format header |
| 938 | // Offset 6: 2 bytes, General-purpose field |
| 939 | // Offset 26: 2 bytes, filename length |
| 940 | // Offset 28: 2 bytes, optional field length |
| 941 | // Offset 30: Filename field, followed by optional field, followed |
| 942 | // immediately by data |
| 943 | list(, $general_purpose_flag) = unpack('v', substr($gz_data, 6, 2)); |
| 944 | |
| 945 | // If the file has been compressed on the fly, 0x08 bit is set of |
| 946 | // the general purpose field. We can use this to differentiate |
| 947 | // between a compressed document, and a ZIP file |
| 948 | $zip_compressed_on_the_fly = ((0x08 & $general_purpose_flag) === 0x08); |
| 949 | |
| 950 | if (!$zip_compressed_on_the_fly) { |
| 951 | // Don't attempt to decode a compressed zip file |
| 952 | return $gz_data; |
| 953 | } |
| 954 | |
| 955 | // Determine the first byte of data, based on the above ZIP header |
| 956 | // offsets: |
| 957 | $first_file_start = array_sum(unpack('v2', substr($gz_data, 26, 4))); |
| 958 | $decompressed = @gzinflate(substr($gz_data, 30 + $first_file_start)); |
| 959 | if ($decompressed !== false) { |
| 960 | return $decompressed; |
| 961 | } |
| 962 | return false; |
| 963 | } |
| 964 | |
| 965 | // Finally fall back to straight gzinflate |
| 966 | $decompressed = @gzinflate($gz_data); |
| 967 | if ($decompressed !== false) { |
| 968 | return $decompressed; |
| 969 | } |
| 970 | |
| 971 | // Fallback for all above failing, not expected, but included for |
| 972 | // debugging and preventing regressions and to track stats |
| 973 | $decompressed = @gzinflate(substr($gz_data, 2)); |
| 974 | if ($decompressed !== false) { |
| 975 | return $decompressed; |
| 976 | } |
| 977 | |
| 978 | return false; |
| 979 | } |
| 980 | |
| 981 | public static function match_domain($host, $reference) { |
| 982 | // Check for a direct match |
| 983 | if ($host === $reference) { |
| 984 | return true; |
| 985 | } |
| 986 | |
| 987 | // Calculate the valid wildcard match if the host is not an IP address |
| 988 | // Also validates that the host has 3 parts or more, as per Firefox's |
| 989 | // ruleset. |
| 990 | $parts = explode('.', $host); |
| 991 | if (ip2long($host) === false && count($parts) >= 3) { |
| 992 | $parts[0] = '*'; |
| 993 | $wildcard = implode('.', $parts); |
| 994 | if ($wildcard === $reference) { |
| 995 | return true; |
| 996 | } |
| 997 | } |
| 998 | |
| 999 | return false; |
| 1000 | } |
| 1001 | } |
| 1002 |