src/Network/CurlResult.php

   1 <?php
   2 /**
   3  * @copyright Copyright (C) 2020, Friendica
   4  *
   5  * @license GNU AGPL version 3 or any later version
   6  *
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as
   9  * published by the Free Software Foundation, either version 3 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  19  *
  20  */
  21
  22 namespace Friendica\Network;
  23
  24 use Friendica\Core\Logger;
  25 use Friendica\Core\System;
  26 use Friendica\Network\HTTPException\InternalServerErrorException;
  27 use Friendica\Util\Network;
  28
  29 /**
  30  * A content class for Curl call results
  31  */
  32 class CurlResult
  33 {
  34         /**
  35          * @var int HTTP return code or 0 if timeout or failure
  36          */
  37         private $returnCode;
  38
  39         /**
  40          * @var string the content type of the Curl call
  41          */
  42         private $contentType;
  43
  44         /**
  45          * @var string the HTTP headers of the Curl call
  46          */
  47         private $header;
  48
  49         /**
  50          * @var array the HTTP headers of the Curl call
  51          */
  52         private $header_fields;
  53
  54         /**
  55          * @var boolean true (if HTTP 2xx result) or false
  56          */
  57         private $isSuccess;
  58
  59         /**
  60          * @var string the URL which was called
  61          */
  62         private $url;
  63
  64         /**
  65          * @var string in case of redirect, content was finally retrieved from this URL
  66          */
  67         private $redirectUrl;
  68
  69         /**
  70          * @var string fetched content
  71          */
  72         private $body;
  73
  74         /**
  75          * @var array some informations about the fetched data
  76          */
  77         private $info;
  78
  79         /**
  80          * @var boolean true if the URL has a redirect
  81          */
  82         private $isRedirectUrl;
  83
  84         /**
  85          * @var boolean true if the curl request timed out
  86          */
  87         private $isTimeout;
  88
  89         /**
  90          * @var int the error number or 0 (zero) if no error
  91          */
  92         private $errorNumber;
  93
  94         /**
  95          * @var string the error message or '' (the empty string) if no
  96          */
  97         private $error;
  98
  99         /**
 100          * Creates an errored CURL response
 101          *
 102          * @param string $url optional URL
 103          *
 104          * @return CurlResult a CURL with error response
 105          * @throws InternalServerErrorException
 106          */
 107         public static function createErrorCurl($url = '')
 108         {
 109                 return new CurlResult($url, '', ['http_code' => 0]);
 110         }
 111
 112         /**
 113          * Curl constructor.
 114          * @param string $url the URL which was called
 115          * @param string $result the result of the curl execution
 116          * @param array $info an additional info array
 117          * @param int $errorNumber the error number or 0 (zero) if no error
 118          * @param string $error the error message or '' (the empty string) if no
 119          *
 120          * @throws InternalServerErrorException when HTTP code of the CURL response is missing
 121          */
 122         public function __construct($url, $result, $info, $errorNumber = 0, $error = '')
 123         {
 124                 if (!array_key_exists('http_code', $info)) {
 125                         throw new InternalServerErrorException('CURL response doesn\'t contains a response HTTP code');
 126                 }
 127
 128                 $this->returnCode = $info['http_code'];
 129                 $this->url = $url;
 130                 $this->info = $info;
 131                 $this->errorNumber = $errorNumber;
 132                 $this->error = $error;
 133
 134                 Logger::debug('construct', ['url' => $url, 'returncode' => $this->returnCode, 'result' => $result]);
 135
 136                 $this->parseBodyHeader($result);
 137                 $this->checkSuccess();
 138                 $this->checkRedirect();
 139                 $this->checkInfo();
 140         }
 141
 142         private function parseBodyHeader($result)
 143         {
 144                 // Pull out multiple headers, e.g. proxy and continuation headers
 145                 // allow for HTTP/2.x without fixing code
 146
 147                 $header = '';
 148                 $base = $result;
 149                 while (preg_match('/^HTTP\/.+? \d+/', $base)) {
 150                         $chunk = substr($base, 0, strpos($base, "\r\n\r\n") + 4);
 151                         $header .= $chunk;
 152                         $base = substr($base, strlen($chunk));
 153                 }
 154
 155                 $this->body = substr($result, strlen($header));
 156                 $this->header = $header;
 157                 $this->header_fields = []; // Is filled on demand
 158         }
 159
 160         private function checkSuccess()
 161         {
 162                 $this->isSuccess = ($this->returnCode >= 200 && $this->returnCode <= 299) || $this->errorNumber == 0;
 163
 164                 // Everything higher or equal 400 is not a success
 165                 if ($this->returnCode >= 400) {
 166                         $this->isSuccess = false;
 167                 }
 168
 169                 if (!$this->isSuccess) {
 170                         Logger::notice('http error', ['url' => $this->url, 'code' => $this->returnCode, 'error'  => $this->error, 'callstack' => System::callstack(20)]);
 171                         Logger::debug('debug', ['info' => $this->info]);
 172                 }
 173
 174                 if (!$this->isSuccess && $this->errorNumber == CURLE_OPERATION_TIMEDOUT) {
 175                         $this->isTimeout = true;
 176                 } else {
 177                         $this->isTimeout = false;
 178                 }
 179         }
 180
 181         private function checkRedirect()
 182         {
 183                 if (!array_key_exists('url', $this->info)) {
 184                         $this->redirectUrl = '';
 185                 } else {
 186                         $this->redirectUrl = $this->info['url'];
 187                 }
 188
 189                 if ($this->returnCode == 301 || $this->returnCode == 302 || $this->returnCode == 303 || $this->returnCode== 307) {
 190                         $redirect_parts = parse_url($this->info['redirect_url'] ?? '');
 191                         if (empty($redirect_parts)) {
 192                                 $redirect_parts = [];
 193                         }
 194
 195                         if (preg_match('/(Location:|URI:)(.*?)\n/i', $this->header, $matches)) {
 196                                 $redirect_parts2 = parse_url(trim(array_pop($matches)));
 197                                 if (!empty($redirect_parts2)) {
 198                                         $redirect_parts = array_merge($redirect_parts, $redirect_parts2);
 199                                 }
 200                         }
 201
 202                         $parts = parse_url($this->info['url'] ?? '');
 203                         if (empty($parts)) {
 204                                 $parts = [];
 205                         }
 206
 207                         /// @todo Checking the corresponding RFC which parts of a redirect can be ommitted.
 208                         $components = ['scheme', 'host', 'path', 'query', 'fragment'];
 209                         foreach ($components as $component) {
 210                                 if (empty($redirect_parts[$component]) && !empty($parts[$component])) {
 211                                         $redirect_parts[$component] = $parts[$component];
 212                                 }
 213                         }
 214
 215                         $this->redirectUrl = Network::unparseURL($redirect_parts);
 216
 217                         $this->isRedirectUrl = true;
 218                 } else {
 219                         $this->isRedirectUrl = false;
 220                 }
 221         }
 222
 223         private function checkInfo()
 224         {
 225                 if (isset($this->info['content_type'])) {
 226                         $this->contentType = $this->info['content_type'];
 227                 } else {
 228                         $this->contentType = '';
 229                 }
 230         }
 231
 232         /**
 233          * Gets the Curl Code
 234          *
 235          * @return string The Curl Code
 236          */
 237         public function getReturnCode()
 238         {
 239                 return $this->returnCode;
 240         }
 241
 242         /**
 243          * Returns the Curl Content Type
 244          *
 245          * @return string the Curl Content Type
 246          */
 247         public function getContentType()
 248         {
 249                 return $this->contentType;
 250         }
 251
 252         /**
 253          * Returns the Curl headers
 254          *
 255          * @param string $field optional header field. Return all fields if empty
 256          *
 257          * @return string the Curl headers or the specified content of the header variable
 258          */
 259         public function getHeader(string $field = '')
 260         {
 261                 if (empty($field)) {
 262                         return $this->header;
 263                 }
 264
 265                 $field = strtolower(trim($field));
 266
 267                 $headers = $this->getHeaderArray();
 268
 269                 if (isset($headers[$field])) {
 270                         return $headers[$field];
 271                 }
 272
 273                 return '';
 274         }
 275
 276         /**
 277          * Check if a specified header exists
 278          *
 279          * @param string $field header field
 280          *
 281          * @return boolean "true" if header exists
 282          */
 283         public function inHeader(string $field)
 284         {
 285                 $field = strtolower(trim($field));
 286
 287                 $headers = $this->getHeaderArray();
 288
 289                 return array_key_exists($field, $headers);
 290         }
 291
 292         /**
 293          * Returns the Curl headers as an associated array
 294          *
 295          * @return array associated header array
 296          */
 297         public function getHeaderArray()
 298         {
 299                 if (!empty($this->header_fields)) {
 300                         return $this->header_fields;
 301                 }
 302
 303                 $this->header_fields = [];
 304
 305                 $lines = explode("\n", trim($this->header));
 306                 foreach ($lines as $line) {
 307                         $parts = explode(':', $line);
 308                         $headerfield = strtolower(trim(array_shift($parts)));
 309                         $headerdata = trim(implode(':', $parts));
 310                         $this->header_fields[$headerfield] = $headerdata;
 311                 }
 312
 313                 return $this->header_fields;
 314         }
 315
 316         /**
 317          * @return bool
 318          */
 319         public function isSuccess()
 320         {
 321                 return $this->isSuccess;
 322         }
 323
 324         /**
 325          * @return string
 326          */
 327         public function getUrl()
 328         {
 329                 return $this->url;
 330         }
 331
 332         /**
 333          * @return string
 334          */
 335         public function getRedirectUrl()
 336         {
 337                 return $this->redirectUrl;
 338         }
 339
 340         /**
 341          * @return string
 342          */
 343         public function getBody()
 344         {
 345                 return $this->body;
 346         }
 347
 348         /**
 349          * @return array
 350          */
 351         public function getInfo()
 352         {
 353                 return $this->info;
 354         }
 355
 356         /**
 357          * @return bool
 358          */
 359         public function isRedirectUrl()
 360         {
 361                 return $this->isRedirectUrl;
 362         }
 363
 364         /**
 365          * @return int
 366          */
 367         public function getErrorNumber()
 368         {
 369                 return $this->errorNumber;
 370         }
 371
 372         /**
 373          * @return string
 374          */
 375         public function getError()
 376         {
 377                 return $this->error;
 378         }
 379
 380         /**
 381          * @return bool
 382          */
 383         public function isTimeout()
 384         {
 385                 return $this->isTimeout;
 386         }
 387 }