]> git.mxchange.org Git - friendica.git/blob - src/Util/Network.php
add self for unfollowed contact
[friendica.git] / src / Util / Network.php
1 <?php
2 /**
3  * @copyright Copyright (C) 2010-2023, the Friendica project
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\Util;
23
24 use Friendica\Core\Hook;
25 use Friendica\Core\Logger;
26 use Friendica\DI;
27 use Friendica\Model\Contact;
28 use Friendica\Network\HTTPClient\Client\HttpClientAccept;
29 use Friendica\Network\HTTPClient\Client\HttpClientOptions;
30 use Friendica\Network\HTTPException\NotModifiedException;
31 use GuzzleHttp\Psr7\Uri;
32 use Psr\Http\Message\UriInterface;
33
34 class Network
35 {
36
37         /**
38          * Return raw post data from a post request
39          *
40          * @return string post data
41          */
42         public static function postdata()
43         {
44                 return file_get_contents('php://input');
45         }
46
47         /**
48          * Check URL to see if it's real
49          *
50          * Take a URL from the wild, prepend http:// if necessary
51          * and check DNS to see if it's real (or check if is a valid IP address)
52          *
53          * @param string $url The URL to be validated
54          *
55          * @return string|boolean The actual working URL, false else
56          * @throws \Friendica\Network\HTTPException\InternalServerErrorException
57          */
58         public static function isUrlValid(string $url)
59         {
60                 if (DI::config()->get('system', 'disable_url_validation')) {
61                         return $url;
62                 }
63
64                 // no naked subdomains (allow localhost for tests)
65                 if (strpos($url, '.') === false && strpos($url, '/localhost/') === false) {
66                         return false;
67                 }
68
69                 if (substr($url, 0, 4) != 'http') {
70                         $url = 'http://' . $url;
71                 }
72
73                 $xrd_timeout = DI::config()->get('system', 'xrd_timeout');
74                 $host = parse_url($url, PHP_URL_HOST);
75
76                 if (empty($host) || !(filter_var($host, FILTER_VALIDATE_IP) || @dns_get_record($host . '.', DNS_A + DNS_AAAA))) {
77                         return false;
78                 }
79
80                 if (in_array(parse_url($url, PHP_URL_SCHEME), ['https', 'http'])) {
81                         $options = [HttpClientOptions::VERIFY => true, HttpClientOptions::TIMEOUT => $xrd_timeout];
82                         try {
83                                 $curlResult = DI::httpClient()->head($url, $options);
84                         } catch (\Exception $e) {
85                                 return false;
86                         }
87
88                         // Workaround for systems that can't handle a HEAD request. Don't retry on timeouts.
89                         if (!$curlResult->isSuccess() && ($curlResult->getReturnCode() >= 400) && !in_array($curlResult->getReturnCode(), [408, 504])) {
90                                 try {
91                                         $curlResult = DI::httpClient()->get($url, HttpClientAccept::DEFAULT, $options);
92                                 } catch (\Exception $e) {
93                                         return false;
94                                 }
95                         }
96
97                         if (!$curlResult->isSuccess()) {
98                                 Logger::notice('Url not reachable', ['host' => $host, 'url' => $url]);
99                                 return false;
100                         } elseif ($curlResult->isRedirectUrl()) {
101                                 $url = $curlResult->getRedirectUrl();
102                         }
103                 }
104
105                 return $url;
106         }
107
108         /**
109          * Checks that email is an actual resolvable internet address
110          *
111          * @param string $addr The email address
112          * @return boolean True if it's a valid email address, false if it's not
113          */
114         public static function isEmailDomainValid(string $addr): bool
115         {
116                 if (DI::config()->get('system', 'disable_email_validation')) {
117                         return true;
118                 }
119
120                 if (! strpos($addr, '@')) {
121                         return false;
122                 }
123
124                 $h = substr($addr, strpos($addr, '@') + 1);
125
126                 // Concerning the @ see here: https://stackoverflow.com/questions/36280957/dns-get-record-a-temporary-server-error-occurred
127                 if ($h && (@dns_get_record($h, DNS_A + DNS_AAAA + DNS_MX) || filter_var($h, FILTER_VALIDATE_IP))) {
128                         return true;
129                 }
130                 if ($h && @dns_get_record($h, DNS_CNAME + DNS_MX)) {
131                         return true;
132                 }
133                 return false;
134         }
135
136         /**
137          * Check if URL is allowed
138          *
139          * Check $url against our list of allowed sites,
140          * wildcards allowed. If allowed_sites is unset return true;
141          *
142          * @param string $url URL which get tested
143          * @return boolean True if url is allowed otherwise return false
144          */
145         public static function isUrlAllowed(string $url): bool
146         {
147                 $h = @parse_url($url);
148
149                 if (! $h) {
150                         return false;
151                 }
152
153                 $str_allowed = DI::config()->get('system', 'allowed_sites');
154                 if (! $str_allowed) {
155                         return true;
156                 }
157
158                 $found = false;
159
160                 $host = strtolower($h['host']);
161
162                 // always allow our own site
163                 if ($host == strtolower($_SERVER['SERVER_NAME'])) {
164                         return true;
165                 }
166
167                 $fnmatch = function_exists('fnmatch');
168                 $allowed = explode(',', $str_allowed);
169
170                 if (count($allowed)) {
171                         foreach ($allowed as $a) {
172                                 $pat = strtolower(trim($a));
173                                 if (($fnmatch && fnmatch($pat, $host)) || ($pat == $host)) {
174                                         $found = true;
175                                         break;
176                                 }
177                         }
178                 }
179                 return $found;
180         }
181
182         /**
183          * Checks if the provided url domain is on the domain blocklist.
184          * Returns true if it is or malformed URL, false if not.
185          *
186          * @param string $url The url to check the domain from
187          *
188          * @return boolean
189          *
190          * @deprecated since 2023.03 Use isUriBlocked instead
191          */
192         public static function isUrlBlocked(string $url): bool
193         {
194                 try {
195                         return self::isUriBlocked(new Uri($url));
196                 } catch (\Throwable $e) {
197                         Logger::warning('Invalid URL', ['url' => $url]);
198                         return false;
199                 }
200         }
201
202         /**
203          * Checks if the provided URI domain is on the domain blocklist.
204          *
205          * @param UriInterface $uri
206          * @return boolean
207          */
208         public static function isUriBlocked(UriInterface $uri): bool
209         {
210                 if (!$uri->getHost()) {
211                         return false;
212                 }
213
214                 $domain_blocklist = DI::config()->get('system', 'blocklist', []);
215                 if (!$domain_blocklist) {
216                         return false;
217                 }
218
219                 foreach ($domain_blocklist as $domain_block) {
220                         if (fnmatch(strtolower($domain_block['domain']), strtolower($uri->getHost()))) {
221                                 return true;
222                         }
223                 }
224
225                 return false;
226         }
227
228         /**
229          * Checks if the provided url is on the list of domains where redirects are blocked.
230          * Returns true if it is or malformed URL, false if not.
231          *
232          * @param string $url The url to check the domain from
233          *
234          * @return boolean
235          */
236         public static function isRedirectBlocked(string $url): bool
237         {
238                 $host = @parse_url($url, PHP_URL_HOST);
239                 if (!$host) {
240                         return false;
241                 }
242
243                 $no_redirect_list = DI::config()->get('system', 'no_redirect_list', []);
244                 if (!$no_redirect_list) {
245                         return false;
246                 }
247
248                 foreach ($no_redirect_list as $no_redirect) {
249                         if (fnmatch(strtolower($no_redirect), strtolower($host))) {
250                                 return true;
251                         }
252                 }
253
254                 return false;
255         }
256
257         /**
258          * Check if email address is allowed to register here.
259          *
260          * Compare against our list (wildcards allowed).
261          *
262          * @param  string $email email address
263          * @return boolean False if not allowed, true if allowed
264          *                       or if allowed list is not configured
265          * @throws \Friendica\Network\HTTPException\InternalServerErrorException
266          */
267         public static function isEmailDomainAllowed(string $email): bool
268         {
269                 $domain = strtolower(substr($email, strpos($email, '@') + 1));
270                 if (!$domain) {
271                         return false;
272                 }
273
274                 $str_allowed = DI::config()->get('system', 'allowed_email', '');
275                 if (empty($str_allowed)) {
276                         return true;
277                 }
278
279                 $allowed = explode(',', $str_allowed);
280
281                 return self::isDomainAllowed($domain, $allowed);
282         }
283
284         /**
285          * Checks for the existence of a domain in a domain list
286          *
287          * @param string $domain
288          * @param array  $domain_list
289          *
290          * @return boolean
291          */
292         public static function isDomainAllowed(string $domain, array $domain_list): bool
293         {
294                 $found = false;
295
296                 foreach ($domain_list as $item) {
297                         $pat = strtolower(trim($item));
298                         if (fnmatch($pat, $domain) || ($pat == $domain)) {
299                                 $found = true;
300                                 break;
301                         }
302                 }
303
304                 return $found;
305         }
306
307         public static function lookupAvatarByEmail(string $email): string
308         {
309                 $avatar['size'] = 300;
310                 $avatar['email'] = $email;
311                 $avatar['url'] = '';
312                 $avatar['success'] = false;
313
314                 Hook::callAll('avatar_lookup', $avatar);
315
316                 if (! $avatar['success']) {
317                         $avatar['url'] = DI::baseUrl() . Contact::DEFAULT_AVATAR_PHOTO;
318                 }
319
320                 Logger::info('Avatar: ' . $avatar['email'] . ' ' . $avatar['url']);
321                 return $avatar['url'];
322         }
323
324         /**
325          * Remove Google Analytics and other tracking platforms params from URL
326          *
327          * @param string $url Any user-submitted URL that may contain tracking params
328          *
329          * @return string The same URL stripped of tracking parameters
330          */
331         public static function stripTrackingQueryParams(string $url): string
332         {
333                 $urldata = parse_url($url);
334
335                 if (!empty($urldata['query'])) {
336                         $query = $urldata['query'];
337                         parse_str($query, $querydata);
338
339                         if (is_array($querydata)) {
340                                 foreach ($querydata as $param => $value) {
341                                         if (in_array(
342                                                 $param,
343                                                 [
344                                                         'utm_source', 'utm_medium', 'utm_term', 'utm_content', 'utm_campaign',
345                                                         // As seen from Purism
346                                                         'mtm_source', 'mtm_medium', 'mtm_term', 'mtm_content', 'mtm_campaign',
347                                                         'wt_mc', 'pk_campaign', 'pk_kwd', 'mc_cid', 'mc_eid',
348                                                         'fb_action_ids', 'fb_action_types', 'fb_ref',
349                                                         'awesm', 'wtrid',
350                                                         'woo_campaign', 'woo_source', 'woo_medium', 'woo_content', 'woo_term']
351                                                 )
352                                         ) {
353                                                 $pair = $param . '=' . urlencode($value);
354                                                 $url = str_replace($pair, '', $url);
355
356                                                 // Second try: if the url isn't encoded completely
357                                                 $pair = $param . '=' . str_replace(' ', '+', $value);
358                                                 $url = str_replace($pair, '', $url);
359
360                                                 // Third try: Maybe the url isn't encoded at all
361                                                 $pair = $param . '=' . $value;
362                                                 $url = str_replace($pair, '', $url);
363
364                                                 $url = str_replace(['?&', '&&'], ['?', ''], $url);
365                                         }
366                                 }
367                         }
368
369                         if (substr($url, -1, 1) == '?') {
370                                 $url = substr($url, 0, -1);
371                         }
372                 }
373
374                 return $url;
375         }
376
377         /**
378          * Add a missing base path (scheme and host) to a given url
379          *
380          * @param string $url
381          * @param string $basepath
382          *
383          * @return string url
384          */
385         public static function addBasePath(string $url, string $basepath): string
386         {
387                 $url = trim($url);
388                 if (!empty(parse_url($url, PHP_URL_SCHEME)) || empty(parse_url($basepath, PHP_URL_SCHEME)) || empty($url) || empty(parse_url($url))) {
389                         return $url;
390                 }
391
392                 $base = [
393                         'scheme' => parse_url($basepath, PHP_URL_SCHEME),
394                         'host' => parse_url($basepath, PHP_URL_HOST),
395                 ];
396
397                 $parts = array_merge($base, parse_url('/' . ltrim($url, '/')));
398                 return self::unparseURL($parts);
399         }
400
401         /**
402          * Find the matching part between two url
403          *
404          * @param string $url1
405          * @param string $url2
406          *
407          * @return string The matching part or empty string on error
408          */
409         public static function getUrlMatch(string $url1, string $url2): string
410         {
411                 if (($url1 == '') || ($url2 == '')) {
412                         return '';
413                 }
414
415                 $url1 = Strings::normaliseLink($url1);
416                 $url2 = Strings::normaliseLink($url2);
417
418                 $parts1 = parse_url($url1);
419                 $parts2 = parse_url($url2);
420
421                 if (!isset($parts1['host']) || !isset($parts2['host'])) {
422                         return '';
423                 }
424
425                 if (empty($parts1['scheme'])) {
426                         $parts1['scheme'] = '';
427                 }
428                 if (empty($parts2['scheme'])) {
429                         $parts2['scheme'] = '';
430                 }
431
432                 if ($parts1['scheme'] != $parts2['scheme']) {
433                         return '';
434                 }
435
436                 if (empty($parts1['host'])) {
437                         $parts1['host'] = '';
438                 }
439                 if (empty($parts2['host'])) {
440                         $parts2['host'] = '';
441                 }
442
443                 if ($parts1['host'] != $parts2['host']) {
444                         return '';
445                 }
446
447                 if (empty($parts1['port'])) {
448                         $parts1['port'] = '';
449                 }
450                 if (empty($parts2['port'])) {
451                         $parts2['port'] = '';
452                 }
453
454                 if ($parts1['port'] != $parts2['port']) {
455                         return '';
456                 }
457
458                 $match = $parts1['scheme'] . '://' . $parts1['host'];
459
460                 if ($parts1['port']) {
461                         $match .= ':' . $parts1['port'];
462                 }
463
464                 if (empty($parts1['path'])) {
465                         $parts1['path'] = '';
466                 }
467                 if (empty($parts2['path'])) {
468                         $parts2['path'] = '';
469                 }
470
471                 $pathparts1 = explode('/', $parts1['path']);
472                 $pathparts2 = explode('/', $parts2['path']);
473
474                 $i = 0;
475                 $path = '';
476                 do {
477                         $path1 = $pathparts1[$i] ?? '';
478                         $path2 = $pathparts2[$i] ?? '';
479
480                         if ($path1 == $path2) {
481                                 $path .= $path1 . '/';
482                         }
483                 } while (($path1 == $path2) && ($i++ <= count($pathparts1)));
484
485                 $match .= $path;
486
487                 return Strings::normaliseLink($match);
488         }
489
490         /**
491          * Glue url parts together
492          *
493          * @param array $parsed URL parts
494          *
495          * @return string|null The glued URL or null on error
496          * @deprecated since version 2021.12, use GuzzleHttp\Psr7\Uri::fromParts($parts) instead
497          */
498         public static function unparseURL(array $parsed): string
499         {
500                 $get = function ($key) use ($parsed) {
501                         return isset($parsed[$key]) ? $parsed[$key] : null;
502                 };
503
504                 $pass      = $get('pass');
505                 $user      = $get('user');
506                 $userinfo  = $pass !== null ? "$user:$pass" : $user;
507                 $port      = $get('port');
508                 $scheme    = $get('scheme');
509                 $query     = $get('query');
510                 $fragment  = $get('fragment');
511                 $authority = ($userinfo !== null ? $userinfo . '@' : '') .
512                                                 $get('host') .
513                                                 ($port ? ":$port" : '');
514
515                 return  (!empty($scheme) ? $scheme . ':' : '') .
516                         (!empty($authority) ? '//' . $authority : '') .
517                         $get('path') .
518                         (!empty($query) ? '?' . $query : '') .
519                         (!empty($fragment) ? '#' . $fragment : '');
520         }
521
522         /**
523          * Convert an URI to an IDN compatible URI
524          *
525          * @param string $uri
526          *
527          * @return string
528          */
529         public static function convertToIdn(string $uri): string
530         {
531                 $parts = parse_url($uri);
532                 if (!empty($parts['scheme']) && !empty($parts['host'])) {
533                         $parts['host'] = idn_to_ascii($parts['host']);
534                         $uri = (string)Uri::fromParts($parts);
535                 } else {
536                         $parts = explode('@', $uri);
537                         if (count($parts) == 2) {
538                                 $uri = $parts[0] . '@' . idn_to_ascii($parts[1]);
539                         } else {
540                                 $uri = idn_to_ascii($uri);
541                         }
542                 }
543
544                 return $uri;
545         }
546
547         /**
548          * Switch the scheme of an url between http and https
549          *
550          * @param string $url
551          *
552          * @return string Switched URL
553          */
554         public static function switchScheme(string $url): string
555         {
556                 $scheme = parse_url($url, PHP_URL_SCHEME);
557                 if (empty($scheme)) {
558                         return $url;
559                 }
560
561                 if ($scheme === 'http') {
562                         $url = str_replace('http://', 'https://', $url);
563                 } elseif ($scheme === 'https') {
564                         $url = str_replace('https://', 'http://', $url);
565                 }
566
567                 return $url;
568         }
569
570         /**
571          * Adds query string parameters to the provided URI. Replace the value of existing keys.
572          *
573          * @param string $path
574          * @param array  $additionalParams Associative array of parameters
575          *
576          * @return string
577          */
578         public static function appendQueryParam(string $path, array $additionalParams): string
579         {
580                 $parsed = parse_url($path);
581
582                 $params = [];
583                 if (!empty($parsed['query'])) {
584                         parse_str($parsed['query'], $params);
585                 }
586
587                 $params = array_merge($params, $additionalParams);
588
589                 $parsed['query'] = http_build_query($params);
590
591                 return self::unparseURL($parsed);
592         }
593
594         /**
595          * Generates ETag and Last-Modified response headers and checks them against
596          * If-None-Match and If-Modified-Since request headers if present.
597          *
598          * Blocking function, sends 304 headers and exits if check passes.
599          *
600          * @param string $etag          The page etag
601          * @param string $last_modified The page last modification UTC date
602          *
603          * @return void
604          * @throws \Exception
605          */
606         public static function checkEtagModified(string $etag, string $last_modified)
607         {
608                 $last_modified = DateTimeFormat::utc($last_modified, 'D, d M Y H:i:s') . ' GMT';
609
610                 /**
611                  * @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.26
612                  */
613                 $if_none_match     = filter_input(INPUT_SERVER, 'HTTP_IF_NONE_MATCH');
614                 $if_modified_since = filter_input(INPUT_SERVER, 'HTTP_IF_MODIFIED_SINCE');
615                 $flag_not_modified = null;
616                 if ($if_none_match) {
617                         $result = [];
618                         preg_match('/^(?:W\/")?([^"]+)"?$/i', $etag, $result);
619                         $etagTrimmed = $result[1];
620                         // Lazy exact ETag match, could check weak/strong ETags
621                         $flag_not_modified = $if_none_match == '*' || strpos($if_none_match, $etagTrimmed) !== false;
622                 }
623
624                 if ($if_modified_since && (!$if_none_match || $flag_not_modified)) {
625                         // Lazy exact Last-Modified match, could check If-Modified-Since validity
626                         $flag_not_modified = $if_modified_since == $last_modified;
627                 }
628
629                 header('Etag: ' . $etag);
630                 header('Last-Modified: ' . $last_modified);
631
632                 if ($flag_not_modified) {
633                         throw new NotModifiedException();
634                 }
635         }
636
637         /**
638          * Check if the given URL is a local link
639          *
640          * @param string $url
641          *
642          * @return bool
643          * @deprecated since 2023.09, please use BaseUrl->isLocalUrl or BaseUrl->isLocalUri instead.
644          */
645         public static function isLocalLink(string $url): bool
646         {
647                 return DI::baseUrl()->isLocalUrl($url);
648         }
649
650         /**
651          * Check if the given URL is a valid HTTP/HTTPS URL
652          *
653          * @param string $url
654          * @return bool
655          */
656         public static function isValidHttpUrl(string $url): bool
657         {
658                 $scheme = parse_url($url, PHP_URL_SCHEME);
659                 return !empty($scheme) && in_array($scheme, ['http', 'https']) && parse_url($url, PHP_URL_HOST);
660         }
661 }