[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  namespace dokuwiki\HTTP;
   4  
   5  define('HTTP_NL', "\r\n");
   6  
   7  
   8  /**
   9   * This class implements a basic HTTP client
  10   *
  11   * It supports POST and GET, Proxy usage, basic authentication,
  12   * handles cookies and referrers. It is based upon the httpclient
  13   * function from the VideoDB project.
  14   *
  15   * @link   https://www.splitbrain.org/projects/videodb
  16   * @author Andreas Goetz <cpuidle@gmx.de>
  17   * @author Andreas Gohr <andi@splitbrain.org>
  18   * @author Tobias Sarnowski <sarnowski@new-thoughts.org>
  19   */
  20  class HTTPClient
  21  {
  22      //set these if you like
  23      public $agent;         // User agent
  24      public $http = '1.0';          // HTTP version defaults to 1.0
  25      public $timeout = 15;       // read timeout (seconds)
  26      public $cookies = [];
  27      public $referer = '';
  28      public $max_redirect = 3;
  29      public $max_bodysize = 0;
  30      public $max_bodysize_abort = true;  // if set, abort if the response body is bigger than max_bodysize
  31      public $header_regexp = ''; // if set this RE must match against the headers, else abort
  32      public $headers = [];
  33      public $debug = false;
  34      public $start = 0.0; // for timings
  35      public $keep_alive = true; // keep alive rocks
  36  
  37      // don't set these, read on error
  38      public $error;
  39      public $redirect_count = 0;
  40  
  41      // read these after a successful request
  42      public $status = 0;
  43      public $resp_body;
  44      public $resp_headers;
  45  
  46      // set these to do basic authentication
  47      public $user;
  48      public $pass;
  49  
  50      // set these if you need to use a proxy
  51      public $proxy_host;
  52      public $proxy_port;
  53      public $proxy_user;
  54      public $proxy_pass;
  55      public $proxy_ssl; //boolean set to true if your proxy needs SSL
  56      public $proxy_except; // regexp of URLs to exclude from proxy
  57  
  58      // list of kept alive connections
  59      protected static $connections = [];
  60  
  61      // what we use as boundary on multipart/form-data posts
  62      protected $boundary = '---DokuWikiHTTPClient--4523452351';
  63  
  64      /**
  65       * Constructor.
  66       *
  67       * @author Andreas Gohr <andi@splitbrain.org>
  68       */
  69      public function __construct()
  70      {
  71          $this->agent = 'Mozilla/4.0 (compatible; DokuWiki HTTP Client; ' . PHP_OS . ')';
  72          if (extension_loaded('zlib')) $this->headers['Accept-encoding'] = 'gzip';
  73          $this->headers['Accept'] = 'text/xml,application/xml,application/xhtml+xml,' .
  74              'text/html,text/plain,image/png,image/jpeg,image/gif,*/*';
  75          $this->headers['Accept-Language'] = 'en-us';
  76      }
  77  
  78  
  79      /**
  80       * Simple function to do a GET request
  81       *
  82       * Returns the wanted page or false on an error;
  83       *
  84       * @param string $url The URL to fetch
  85       * @param bool $sloppy304 Return body on 304 not modified
  86       * @return false|string  response body, false on error
  87       *
  88       * @author Andreas Gohr <andi@splitbrain.org>
  89       */
  90      public function get($url, $sloppy304 = false)
  91      {
  92          if (!$this->sendRequest($url)) return false;
  93          if ($this->status == 304 && $sloppy304) return $this->resp_body;
  94          if ($this->status < 200 || $this->status > 206) return false;
  95          return $this->resp_body;
  96      }
  97  
  98      /**
  99       * Simple function to do a GET request with given parameters
 100       *
 101       * Returns the wanted page or false on an error.
 102       *
 103       * This is a convenience wrapper around get(). The given parameters
 104       * will be correctly encoded and added to the given base URL.
 105       *
 106       * @param string $url The URL to fetch
 107       * @param array $data Associative array of parameters
 108       * @param bool $sloppy304 Return body on 304 not modified
 109       * @return false|string  response body, false on error
 110       *
 111       * @author Andreas Gohr <andi@splitbrain.org>
 112       */
 113      public function dget($url, $data, $sloppy304 = false)
 114      {
 115          if (strpos($url, '?')) {
 116              $url .= '&';
 117          } else {
 118              $url .= '?';
 119          }
 120          $url .= $this->postEncode($data);
 121          return $this->get($url, $sloppy304);
 122      }
 123  
 124      /**
 125       * Simple function to do a POST request
 126       *
 127       * Returns the resulting page or false on an error;
 128       *
 129       * @param string $url The URL to fetch
 130       * @param array $data Associative array of parameters
 131       * @return false|string  response body, false on error
 132       * @author Andreas Gohr <andi@splitbrain.org>
 133       */
 134      public function post($url, $data)
 135      {
 136          if (!$this->sendRequest($url, $data, 'POST')) return false;
 137          if ($this->status < 200 || $this->status > 206) return false;
 138          return $this->resp_body;
 139      }
 140  
 141      /**
 142       * Send an HTTP request
 143       *
 144       * This method handles the whole HTTP communication. It respects set proxy settings,
 145       * builds the request headers, follows redirects and parses the response.
 146       *
 147       * Post data should be passed as associative array. When passed as string it will be
 148       * sent as is. You will need to setup your own Content-Type header then.
 149       *
 150       * @param string $url - the complete URL
 151       * @param mixed $data - the post data either as array or raw data
 152       * @param string $method - HTTP Method usually GET or POST.
 153       * @return bool - true on success
 154       *
 155       * @author Andreas Goetz <cpuidle@gmx.de>
 156       * @author Andreas Gohr <andi@splitbrain.org>
 157       */
 158      public function sendRequest($url, $data = '', $method = 'GET')
 159      {
 160          $this->start = microtime(true);
 161          $this->error = '';
 162          $this->status = 0;
 163          $this->resp_body = '';
 164          $this->resp_headers = [];
 165  
 166          // save unencoded data for recursive call
 167          $unencodedData = $data;
 168  
 169          // don't accept gzip if truncated bodies might occur
 170          if (
 171              $this->max_bodysize &&
 172              !$this->max_bodysize_abort &&
 173              isset($this->headers['Accept-encoding']) &&
 174              $this->headers['Accept-encoding'] == 'gzip'
 175          ) {
 176              unset($this->headers['Accept-encoding']);
 177          }
 178  
 179          // parse URL into bits
 180          $uri = parse_url($url);
 181          $server = $uri['host'];
 182          $path = empty($uri['path']) ? '/' : $uri['path'];
 183          $uriPort = empty($uri['port']) ? null : $uri['port'];
 184          if (!empty($uri['query'])) $path .= '?' . $uri['query'];
 185          if (isset($uri['user'])) $this->user = $uri['user'];
 186          if (isset($uri['pass'])) $this->pass = $uri['pass'];
 187  
 188          // proxy setup
 189          if ($this->useProxyForUrl($url)) {
 190              $request_url = $url;
 191              $server = $this->proxy_host;
 192              $port = $this->proxy_port;
 193              if (empty($port)) $port = 8080;
 194              $use_tls = $this->proxy_ssl;
 195          } else {
 196              $request_url = $path;
 197              $port = $uriPort ?: ($uri['scheme'] == 'https' ? 443 : 80);
 198              $use_tls = ($uri['scheme'] == 'https');
 199          }
 200  
 201          // add SSL stream prefix if needed - needs SSL support in PHP
 202          if ($use_tls) {
 203              if (!in_array('ssl', stream_get_transports())) {
 204                  $this->status = -200;
 205                  $this->error = 'This PHP version does not support SSL - cannot connect to server';
 206              }
 207              $server = 'ssl://' . $server;
 208          }
 209  
 210          // prepare headers
 211          $headers = $this->headers;
 212          $headers['Host'] = $uri['host']
 213              . ($uriPort ? ':' . $uriPort : '');
 214          $headers['User-Agent'] = $this->agent;
 215          $headers['Referer'] = $this->referer;
 216  
 217          if ($method == 'POST') {
 218              if (is_array($data)) {
 219                  if (empty($headers['Content-Type'])) {
 220                      $headers['Content-Type'] = null;
 221                  }
 222                  if ($headers['Content-Type'] == 'multipart/form-data') {
 223                      $headers['Content-Type'] = 'multipart/form-data; boundary=' . $this->boundary;
 224                      $data = $this->postMultipartEncode($data);
 225                  } else {
 226                      $headers['Content-Type'] = 'application/x-www-form-urlencoded';
 227                      $data = $this->postEncode($data);
 228                  }
 229              }
 230          } elseif ($method == 'GET') {
 231              $data = ''; //no data allowed on GET requests
 232          }
 233  
 234          $contentlength = strlen($data);
 235          if ($contentlength) {
 236              $headers['Content-Length'] = $contentlength;
 237          }
 238  
 239          if ($this->user) {
 240              $headers['Authorization'] = 'Basic ' . base64_encode($this->user . ':' . $this->pass);
 241          }
 242          if ($this->proxy_user) {
 243              $headers['Proxy-Authorization'] = 'Basic ' . base64_encode($this->proxy_user . ':' . $this->proxy_pass);
 244          }
 245  
 246          // already connected?
 247          $connectionId = $this->uniqueConnectionId($server, $port);
 248          $this->debug('connection pool', self::$connections);
 249          $socket = null;
 250          if (isset(self::$connections[$connectionId])) {
 251              $this->debug('reusing connection', $connectionId);
 252              $socket = self::$connections[$connectionId];
 253          }
 254          if (is_null($socket) || feof($socket)) {
 255              $this->debug('opening connection', $connectionId);
 256              // open socket
 257              $socket = @fsockopen($server, $port, $errno, $errstr, $this->timeout);
 258              if (!$socket) {
 259                  $this->status = -100;
 260                  $this->error = "Could not connect to $server:$port\n$errstr ($errno)";
 261                  return false;
 262              }
 263  
 264              // try to establish a CONNECT tunnel for SSL
 265              try {
 266                  if ($this->ssltunnel($socket, $request_url)) {
 267                      // no keep alive for tunnels
 268                      $this->keep_alive = false;
 269                      // tunnel is authed already
 270                      if (isset($headers['Proxy-Authentication'])) unset($headers['Proxy-Authentication']);
 271                  }
 272              } catch (HTTPClientException $e) {
 273                  $this->status = $e->getCode();
 274                  $this->error = $e->getMessage();
 275                  fclose($socket);
 276                  return false;
 277              }
 278  
 279              // keep alive?
 280              if ($this->keep_alive) {
 281                  self::$connections[$connectionId] = $socket;
 282              } else {
 283                  unset(self::$connections[$connectionId]);
 284              }
 285          }
 286  
 287          if ($this->keep_alive && !$this->useProxyForUrl($request_url)) {
 288              // RFC 2068, section 19.7.1: A client MUST NOT send the Keep-Alive
 289              // connection token to a proxy server. We still do keep the connection the
 290              // proxy alive (well except for CONNECT tunnels)
 291              $headers['Connection'] = 'Keep-Alive';
 292          } else {
 293              $headers['Connection'] = 'Close';
 294          }
 295  
 296          try {
 297              //set non-blocking
 298              stream_set_blocking($socket, 0);
 299  
 300              // build request
 301              $request = "$method $request_url HTTP/" . $this->http . HTTP_NL;
 302              $request .= $this->buildHeaders($headers);
 303              $request .= $this->getCookies();
 304              $request .= HTTP_NL;
 305              $request .= $data;
 306  
 307              $this->debug('request', $request);
 308              $this->sendData($socket, $request, 'request');
 309  
 310              // read headers from socket
 311              $r_headers = '';
 312              do {
 313                  $r_line = $this->readLine($socket, 'headers');
 314                  $r_headers .= $r_line;
 315              } while ($r_line != "\r\n" && $r_line != "\n");
 316  
 317              $this->debug('response headers', $r_headers);
 318  
 319              // check if expected body size exceeds allowance
 320              if ($this->max_bodysize && preg_match('/\r?\nContent-Length:\s*(\d+)\r?\n/i', $r_headers, $match)) {
 321                  if ($match[1] > $this->max_bodysize) {
 322                      if ($this->max_bodysize_abort)
 323                          throw new HTTPClientException('Reported content length exceeds allowed response size');
 324                      else $this->error = 'Reported content length exceeds allowed response size';
 325                  }
 326              }
 327  
 328              // get Status
 329              if (!preg_match('/^HTTP\/(\d\.\d)\s*(\d+).*?\n/s', $r_headers, $m))
 330                  throw new HTTPClientException('Server returned bad answer ' . $r_headers);
 331  
 332              $this->status = $m[2];
 333  
 334              // handle headers and cookies
 335              $this->resp_headers = $this->parseHeaders($r_headers);
 336              if (isset($this->resp_headers['set-cookie'])) {
 337                  foreach ((array)$this->resp_headers['set-cookie'] as $cookie) {
 338                      [$cookie] = sexplode(';', $cookie, 2, '');
 339                      [$key, $val] = sexplode('=', $cookie, 2, '');
 340                      $key = trim($key);
 341                      if ($val == 'deleted') {
 342                          if (isset($this->cookies[$key])) {
 343                              unset($this->cookies[$key]);
 344                          }
 345                      } elseif ($key) {
 346                          $this->cookies[$key] = $val;
 347                      }
 348                  }
 349              }
 350  
 351              $this->debug('Object headers', $this->resp_headers);
 352  
 353              // check server status code to follow redirect
 354              if (in_array($this->status, [301, 302, 303, 307, 308])) {
 355                  if (empty($this->resp_headers['location'])) {
 356                      throw new HTTPClientException('Redirect but no Location Header found');
 357                  } elseif ($this->redirect_count == $this->max_redirect) {
 358                      throw new HTTPClientException('Maximum number of redirects exceeded');
 359                  } else {
 360                      // close the connection because we don't handle content retrieval here
 361                      // that's the easiest way to clean up the connection
 362                      fclose($socket);
 363                      unset(self::$connections[$connectionId]);
 364  
 365                      $this->redirect_count++;
 366                      $this->referer = $url;
 367                      // handle non-RFC-compliant relative redirects
 368                      if (!preg_match('/^http/i', $this->resp_headers['location'])) {
 369                          if ($this->resp_headers['location'][0] != '/') {
 370                              $this->resp_headers['location'] = $uri['scheme'] . '://' . $uri['host'] . ':' . $uriPort .
 371                                  dirname($path) . '/' . $this->resp_headers['location'];
 372                          } else {
 373                              $this->resp_headers['location'] = $uri['scheme'] . '://' . $uri['host'] . ':' . $uriPort .
 374                                  $this->resp_headers['location'];
 375                          }
 376                      }
 377                      if ($this->status == 307 || $this->status == 308) {
 378                          // perform redirected request, same method as before (required by RFC)
 379                          return $this->sendRequest($this->resp_headers['location'], $unencodedData, $method);
 380                      } else {
 381                          // perform redirected request, always via GET (required by RFC)
 382                          return $this->sendRequest($this->resp_headers['location'], [], 'GET');
 383                      }
 384                  }
 385              }
 386  
 387              // check if headers are as expected
 388              if ($this->header_regexp && !preg_match($this->header_regexp, $r_headers))
 389                  throw new HTTPClientException('The received headers did not match the given regexp');
 390  
 391              //read body (with chunked encoding if needed)
 392              $r_body = '';
 393              if (
 394                  (
 395                      isset($this->resp_headers['transfer-encoding']) &&
 396                      $this->resp_headers['transfer-encoding'] == 'chunked'
 397                  ) || (
 398                      isset($this->resp_headers['transfer-coding']) &&
 399                      $this->resp_headers['transfer-coding'] == 'chunked'
 400                  )
 401              ) {
 402                  $abort = false;
 403                  do {
 404                      $chunk_size = '';
 405                      while (preg_match('/^[a-zA-Z0-9]?$/', $byte = $this->readData($socket, 1, 'chunk'))) {
 406                          // read chunksize until \r
 407                          $chunk_size .= $byte;
 408                          if (strlen($chunk_size) > 128) // set an abritrary limit on the size of chunks
 409                              throw new HTTPClientException('Allowed response size exceeded');
 410                      }
 411                      $this->readLine($socket, 'chunk');     // readtrailing \n
 412                      $chunk_size = hexdec($chunk_size);
 413  
 414                      if ($this->max_bodysize && $chunk_size + strlen($r_body) > $this->max_bodysize) {
 415                          if ($this->max_bodysize_abort)
 416                              throw new HTTPClientException('Allowed response size exceeded');
 417                          $this->error = 'Allowed response size exceeded';
 418                          $chunk_size = $this->max_bodysize - strlen($r_body);
 419                          $abort = true;
 420                      }
 421  
 422                      if ($chunk_size > 0) {
 423                          $r_body .= $this->readData($socket, $chunk_size, 'chunk');
 424                          $this->readData($socket, 2, 'chunk'); // read trailing \r\n
 425                      }
 426                  } while ($chunk_size && !$abort);
 427              } elseif (
 428                  isset($this->resp_headers['content-length']) &&
 429                  !isset($this->resp_headers['transfer-encoding'])
 430              ) {
 431                  /* RFC 2616
 432                   * If a message is received with both a Transfer-Encoding header field and a Content-Length
 433                   * header field, the latter MUST be ignored.
 434                   */
 435  
 436                  // read up to the content-length or max_bodysize
 437                  // for keep alive we need to read the whole message to clean up the socket for the next read
 438                  if (
 439                      !$this->keep_alive &&
 440                      $this->max_bodysize &&
 441                      $this->max_bodysize < $this->resp_headers['content-length']
 442                  ) {
 443                      $length = $this->max_bodysize + 1;
 444                  } else {
 445                      $length = $this->resp_headers['content-length'];
 446                  }
 447  
 448                  $r_body = $this->readData($socket, $length, 'response (content-length limited)', true);
 449              } elseif (!isset($this->resp_headers['transfer-encoding']) && $this->max_bodysize && !$this->keep_alive) {
 450                  $r_body = $this->readData($socket, $this->max_bodysize + 1, 'response (content-length limited)', true);
 451              } elseif ((int)$this->status === 204) {
 452                  // request has no content
 453              } else {
 454                  // read entire socket
 455                  while (!feof($socket)) {
 456                      $r_body .= $this->readData($socket, 4096, 'response (unlimited)', true);
 457                  }
 458              }
 459  
 460              // recheck body size, we might have read max_bodysize+1 or even the whole body, so we abort late here
 461              if ($this->max_bodysize) {
 462                  if (strlen($r_body) > $this->max_bodysize) {
 463                      if ($this->max_bodysize_abort) {
 464                          throw new HTTPClientException('Allowed response size exceeded');
 465                      } else {
 466                          $this->error = 'Allowed response size exceeded';
 467                      }
 468                  }
 469              }
 470          } catch (HTTPClientException $err) {
 471              $this->error = $err->getMessage();
 472              if ($err->getCode())
 473                  $this->status = $err->getCode();
 474              unset(self::$connections[$connectionId]);
 475              fclose($socket);
 476              return false;
 477          }
 478  
 479          if (
 480              !$this->keep_alive ||
 481              (isset($this->resp_headers['connection']) && $this->resp_headers['connection'] == 'Close')
 482          ) {
 483              // close socket
 484              fclose($socket);
 485              unset(self::$connections[$connectionId]);
 486          }
 487  
 488          // decode gzip if needed
 489          if (
 490              isset($this->resp_headers['content-encoding']) &&
 491              $this->resp_headers['content-encoding'] == 'gzip' &&
 492              strlen($r_body) > 10 && str_starts_with($r_body, "\x1f\x8b\x08")
 493          ) {
 494              $this->resp_body = @gzinflate(substr($r_body, 10));
 495              if ($this->resp_body === false) {
 496                  $this->error = 'Failed to decompress gzip encoded content';
 497                  $this->resp_body = $r_body;
 498              }
 499          } else {
 500              $this->resp_body = $r_body;
 501          }
 502  
 503          $this->debug('response body', $this->resp_body);
 504          $this->redirect_count = 0;
 505          return true;
 506      }
 507  
 508      /**
 509       * Tries to establish a CONNECT tunnel via Proxy
 510       *
 511       * Protocol, Servername and Port will be stripped from the request URL when a successful CONNECT happened
 512       *
 513       * @param resource &$socket
 514       * @param string   &$requesturl
 515       * @return bool true if a tunnel was established
 516       * @throws HTTPClientException when a tunnel is needed but could not be established
 517       */
 518      protected function ssltunnel(&$socket, &$requesturl)
 519      {
 520          if (!$this->useProxyForUrl($requesturl)) return false;
 521          $requestinfo = parse_url($requesturl);
 522          if ($requestinfo['scheme'] != 'https') return false;
 523          if (empty($requestinfo['port'])) $requestinfo['port'] = 443;
 524  
 525          // build request
 526          $request = "CONNECT {$requestinfo['host']}:{$requestinfo['port']} HTTP/1.0" . HTTP_NL;
 527          $request .= "Host: {$requestinfo['host']}" . HTTP_NL;
 528          if ($this->proxy_user) {
 529              $request .= 'Proxy-Authorization: Basic ' .
 530                  base64_encode($this->proxy_user . ':' . $this->proxy_pass) . HTTP_NL;
 531          }
 532          $request .= HTTP_NL;
 533  
 534          $this->debug('SSL Tunnel CONNECT', $request);
 535          $this->sendData($socket, $request, 'SSL Tunnel CONNECT');
 536  
 537          // read headers from socket
 538          $r_headers = '';
 539          do {
 540              $r_line = $this->readLine($socket, 'headers');
 541              $r_headers .= $r_line;
 542          } while ($r_line != "\r\n" && $r_line != "\n");
 543  
 544          $this->debug('SSL Tunnel Response', $r_headers);
 545          if (preg_match('/^HTTP\/1\.[01] 200/i', $r_headers)) {
 546              // set correct peer name for verification (enabled since PHP 5.6)
 547              stream_context_set_option($socket, 'ssl', 'peer_name', $requestinfo['host']);
 548  
 549              // SSLv3 is broken, use only TLS connections.
 550              // @link https://bugs.php.net/69195
 551              if (PHP_VERSION_ID >= 50600 && PHP_VERSION_ID <= 50606) {
 552                  $cryptoMethod = STREAM_CRYPTO_METHOD_TLS_CLIENT;
 553              } else {
 554                  // actually means neither SSLv2 nor SSLv3
 555                  $cryptoMethod = STREAM_CRYPTO_METHOD_SSLv23_CLIENT;
 556              }
 557  
 558              if (@stream_socket_enable_crypto($socket, true, $cryptoMethod)) {
 559                  $requesturl = ($requestinfo['path'] ?? '/') .
 560                      (empty($requestinfo['query']) ? '' : '?' . $requestinfo['query']);
 561                  return true;
 562              }
 563  
 564              throw new HTTPClientException(
 565                  'Failed to set up crypto for secure connection to ' . $requestinfo['host'],
 566                  -151
 567              );
 568          }
 569  
 570          throw new HTTPClientException('Failed to establish secure proxy connection', -150);
 571      }
 572  
 573      /**
 574       * Safely write data to a socket
 575       *
 576       * @param resource $socket An open socket handle
 577       * @param string $data The data to write
 578       * @param string $message Description of what is being read
 579       * @throws HTTPClientException
 580       *
 581       * @author Tom N Harris <tnharris@whoopdedo.org>
 582       */
 583      protected function sendData($socket, $data, $message)
 584      {
 585          // send request
 586          $towrite = strlen($data);
 587          $written = 0;
 588          while ($written < $towrite) {
 589              // check timeout
 590              $time_used = microtime(true) - $this->start;
 591              if ($time_used > $this->timeout)
 592                  throw new HTTPClientException(sprintf('Timeout while sending %s (%.3fs)', $message, $time_used), -100);
 593              if (feof($socket))
 594                  throw new HTTPClientException("Socket disconnected while writing $message");
 595  
 596              // select parameters
 597              $sel_r = null;
 598              $sel_w = [$socket];
 599              $sel_e = null;
 600              // wait for stream ready or timeout (1sec)
 601              if (@stream_select($sel_r, $sel_w, $sel_e, 1) === false) {
 602                  usleep(1000);
 603                  continue;
 604              }
 605  
 606              // write to stream
 607              $nbytes = fwrite($socket, substr($data, $written, 4096));
 608              if ($nbytes === false)
 609                  throw new HTTPClientException("Failed writing to socket while sending $message", -100);
 610              $written += $nbytes;
 611          }
 612      }
 613  
 614      /**
 615       * Safely read data from a socket
 616       *
 617       * Reads up to a given number of bytes or throws an exception if the
 618       * response times out or ends prematurely.
 619       *
 620       * @param resource $socket An open socket handle in non-blocking mode
 621       * @param int $nbytes Number of bytes to read
 622       * @param string $message Description of what is being read
 623       * @param bool $ignore_eof End-of-file is not an error if this is set
 624       * @return string
 625       *
 626       * @throws HTTPClientException
 627       * @author Tom N Harris <tnharris@whoopdedo.org>
 628       */
 629      protected function readData($socket, $nbytes, $message, $ignore_eof = false)
 630      {
 631          $r_data = '';
 632          // Does not return immediately so timeout and eof can be checked
 633          if ($nbytes < 0) $nbytes = 0;
 634          $to_read = $nbytes;
 635          do {
 636              $time_used = microtime(true) - $this->start;
 637              if ($time_used > $this->timeout)
 638                  throw new HTTPClientException(
 639                      sprintf(
 640                          'Timeout while reading %s after %d bytes (%.3fs)',
 641                          $message,
 642                          strlen($r_data),
 643                          $time_used
 644                      ),
 645                      -100
 646                  );
 647              if (feof($socket)) {
 648                  if (!$ignore_eof)
 649                      throw new HTTPClientException("Premature End of File (socket) while reading $message");
 650                  break;
 651              }
 652  
 653              if ($to_read > 0) {
 654                  // select parameters
 655                  $sel_r = [$socket];
 656                  $sel_w = null;
 657                  $sel_e = null;
 658                  // wait for stream ready or timeout (1sec)
 659                  if (@stream_select($sel_r, $sel_w, $sel_e, 1) === false) {
 660                      usleep(1000);
 661                      continue;
 662                  }
 663  
 664                  $bytes = fread($socket, $to_read);
 665                  if ($bytes === false)
 666                      throw new HTTPClientException("Failed reading from socket while reading $message", -100);
 667                  $r_data .= $bytes;
 668                  $to_read -= strlen($bytes);
 669              }
 670          } while ($to_read > 0 && strlen($r_data) < $nbytes);
 671          return $r_data;
 672      }
 673  
 674      /**
 675       * Safely read a \n-terminated line from a socket
 676       *
 677       * Always returns a complete line, including the terminating \n.
 678       *
 679       * @param resource $socket An open socket handle in non-blocking mode
 680       * @param string $message Description of what is being read
 681       * @return string
 682       *
 683       * @throws HTTPClientException
 684       * @author Tom N Harris <tnharris@whoopdedo.org>
 685       */
 686      protected function readLine($socket, $message)
 687      {
 688          $r_data = '';
 689          do {
 690              $time_used = microtime(true) - $this->start;
 691              if ($time_used > $this->timeout)
 692                  throw new HTTPClientException(
 693                      sprintf('Timeout while reading %s (%.3fs) >%s<', $message, $time_used, $r_data),
 694                      -100
 695                  );
 696              if (feof($socket))
 697                  throw new HTTPClientException("Premature End of File (socket) while reading $message");
 698  
 699              // select parameters
 700              $sel_r = [$socket];
 701              $sel_w = null;
 702              $sel_e = null;
 703              // wait for stream ready or timeout (1sec)
 704              if (@stream_select($sel_r, $sel_w, $sel_e, 1) === false) {
 705                  usleep(1000);
 706                  continue;
 707              }
 708  
 709              $r_data = fgets($socket, 1024);
 710          } while (!preg_match('/\n$/', $r_data));
 711          return $r_data;
 712      }
 713  
 714      /**
 715       * print debug info
 716       *
 717       * Uses _debug_text or _debug_html depending on the SAPI name
 718       *
 719       * @param string $info
 720       * @param mixed $var
 721       * @author Andreas Gohr <andi@splitbrain.org>
 722       *
 723       */
 724      protected function debug($info, $var = null)
 725      {
 726          if (!$this->debug) return;
 727          if (PHP_SAPI == 'cli') {
 728              $this->debugText($info, $var);
 729          } else {
 730              $this->debugHtml($info, $var);
 731          }
 732      }
 733  
 734      /**
 735       * print debug info as HTML
 736       *
 737       * @param string $info
 738       * @param mixed $var
 739       */
 740      protected function debugHtml($info, $var = null)
 741      {
 742          echo '<b>' . $info . '</b> ' . (microtime(true) - $this->start) . 's<br />';
 743          if (!is_null($var)) {
 744              ob_start();
 745              print_r($var);
 746              $content = htmlspecialchars(ob_get_contents());
 747              ob_end_clean();
 748              echo '<pre>' . $content . '</pre>';
 749          }
 750      }
 751  
 752      /**
 753       * prints debug info as plain text
 754       *
 755       * @param string $info
 756       * @param mixed $var
 757       */
 758      protected function debugText($info, $var = null)
 759      {
 760          echo '*' . $info . '* ' . (microtime(true) - $this->start) . "s\n";
 761          if (!is_null($var)) print_r($var);
 762          echo "\n-----------------------------------------------\n";
 763      }
 764  
 765      /**
 766       * convert given header string to Header array
 767       *
 768       * All Keys are lowercased.
 769       *
 770       * @param string $string
 771       * @return array
 772       * @author Andreas Gohr <andi@splitbrain.org>
 773       *
 774       */
 775      protected function parseHeaders($string)
 776      {
 777          $headers = [];
 778          $lines = explode("\n", $string);
 779          array_shift($lines); //skip first line (status)
 780          foreach ($lines as $line) {
 781              [$key, $val] = sexplode(':', $line, 2, '');
 782              $key = trim($key);
 783              $val = trim($val);
 784              $key = strtolower($key);
 785              if (!$key) continue;
 786              if (isset($headers[$key])) {
 787                  if (is_array($headers[$key])) {
 788                      $headers[$key][] = $val;
 789                  } else {
 790                      $headers[$key] = [$headers[$key], $val];
 791                  }
 792              } else {
 793                  $headers[$key] = $val;
 794              }
 795          }
 796          return $headers;
 797      }
 798  
 799      /**
 800       * convert given header array to header string
 801       *
 802       * @param array $headers
 803       * @return string
 804       * @author Andreas Gohr <andi@splitbrain.org>
 805       *
 806       */
 807      protected function buildHeaders($headers)
 808      {
 809          $string = '';
 810          foreach ($headers as $key => $value) {
 811              if ($value === '') continue;
 812              $string .= $key . ': ' . $value . HTTP_NL;
 813          }
 814          return $string;
 815      }
 816  
 817      /**
 818       * get cookies as http header string
 819       *
 820       * @return string
 821       * @author Andreas Goetz <cpuidle@gmx.de>
 822       *
 823       */
 824      protected function getCookies()
 825      {
 826          $headers = '';
 827          foreach ($this->cookies as $key => $val) {
 828              $headers .= "$key=$val; ";
 829          }
 830          $headers = substr($headers, 0, -2);
 831          if ($headers) $headers = "Cookie: $headers" . HTTP_NL;
 832          return $headers;
 833      }
 834  
 835      /**
 836       * Encode data for posting
 837       *
 838       * @param array $data
 839       * @return string
 840       * @author Andreas Gohr <andi@splitbrain.org>
 841       *
 842       */
 843      protected function postEncode($data)
 844      {
 845          return http_build_query($data, '', '&');
 846      }
 847  
 848      /**
 849       * Encode data for posting using multipart encoding
 850       *
 851       * @fixme use of urlencode might be wrong here
 852       * @param array $data
 853       * @return string
 854       * @author Andreas Gohr <andi@splitbrain.org>
 855       *
 856       */
 857      protected function postMultipartEncode($data)
 858      {
 859          $boundary = '--' . $this->boundary;
 860          $out = '';
 861          foreach ($data as $key => $val) {
 862              $out .= $boundary . HTTP_NL;
 863              if (!is_array($val)) {
 864                  $out .= 'Content-Disposition: form-data; name="' . urlencode($key) . '"' . HTTP_NL;
 865                  $out .= HTTP_NL; // end of headers
 866                  $out .= $val;
 867                  $out .= HTTP_NL;
 868              } else {
 869                  $out .= 'Content-Disposition: form-data; name="' . urlencode($key) . '"';
 870                  if ($val['filename']) $out .= '; filename="' . urlencode($val['filename']) . '"';
 871                  $out .= HTTP_NL;
 872                  if ($val['mimetype']) $out .= 'Content-Type: ' . $val['mimetype'] . HTTP_NL;
 873                  $out .= HTTP_NL; // end of headers
 874                  $out .= $val['body'];
 875                  $out .= HTTP_NL;
 876              }
 877          }
 878          $out .= "$boundary--" . HTTP_NL;
 879          return $out;
 880      }
 881  
 882      /**
 883       * Generates a unique identifier for a connection.
 884       *
 885       * @param string $server
 886       * @param string $port
 887       * @return string unique identifier
 888       */
 889      protected function uniqueConnectionId($server, $port)
 890      {
 891          return "$server:$port";
 892      }
 893  
 894      /**
 895       * Should the Proxy be used for the given URL?
 896       *
 897       * Checks the exceptions
 898       *
 899       * @param string $url
 900       * @return bool
 901       */
 902      protected function useProxyForUrl($url)
 903      {
 904          return $this->proxy_host && (!$this->proxy_except || !preg_match('/' . $this->proxy_except . '/i', $url));
 905      }
 906  }