]> git.mxchange.org Git - friendica.git/blob - src/Network/CurlResult.php
"print_r" in logging replaced / obsolete stuff removed
[friendica.git] / 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 }