]> git.mxchange.org Git - friendica.git/blob - include/network.php
Merge pull request #4243 from MrPetovan/task/switch-to-array-new-style
[friendica.git] / include / network.php
1 <?php
2 /**
3  * @file include/network.php
4  */
5 use Friendica\App;
6 use Friendica\Core\System;
7 use Friendica\Core\Config;
8 use Friendica\Network\Probe;
9 use Friendica\Object\Image;
10 use Friendica\Util\XML;
11
12 /**
13  * @brief Curl wrapper
14  *
15  * If binary flag is true, return binary results.
16  * Set the cookiejar argument to a string (e.g. "/tmp/friendica-cookies.txt")
17  * to preserve cookies from one request to the next.
18  *
19  * @param string  $url            URL to fetch
20  * @param boolean $binary         default false
21  *                                TRUE if asked to return binary results (file download)
22  * @param integer $redirects      The recursion counter for internal use - default 0
23  * @param integer $timeout        Timeout in seconds, default system config value or 60 seconds
24  * @param string  $accept_content supply Accept: header with 'accept_content' as the value
25  * @param string  $cookiejar      Path to cookie jar file
26  *
27  * @return string The fetched content
28  */
29 function fetch_url($url, $binary = false, &$redirects = 0, $timeout = 0, $accept_content = null, $cookiejar = 0)
30 {
31         $ret = z_fetch_url(
32                 $url,
33                 $binary,
34                 $redirects,
35                 ['timeout'=>$timeout,
36                 'accept_content'=>$accept_content,
37                 'cookiejar'=>$cookiejar
38                 ]
39         );
40
41         return($ret['body']);
42 }
43
44 /**
45  * @brief fetches an URL.
46  *
47  * @param string  $url       URL to fetch
48  * @param boolean $binary    default false
49  *                           TRUE if asked to return binary results (file download)
50  * @param int     $redirects The recursion counter for internal use - default 0
51  * @param array   $opts      (optional parameters) assoziative array with:
52  *                           'accept_content' => supply Accept: header with 'accept_content' as the value
53  *                           'timeout' => int Timeout in seconds, default system config value or 60 seconds
54  *                           'http_auth' => username:password
55  *                           'novalidate' => do not validate SSL certs, default is to validate using our CA list
56  *                           'nobody' => only return the header
57  *                           'cookiejar' => path to cookie jar file
58  *
59  * @return array an assoziative array with:
60  *    int 'return_code' => HTTP return code or 0 if timeout or failure
61  *    boolean 'success' => boolean true (if HTTP 2xx result) or false
62  *    string 'redirect_url' => in case of redirect, content was finally retrieved from this URL
63  *    string 'header' => HTTP headers
64  *    string 'body' => fetched content
65  */
66 function z_fetch_url($url, $binary = false, &$redirects = 0, $opts = [])
67 {
68         $ret = ['return_code' => 0, 'success' => false, 'header' => '', 'info' => '', 'body' => ''];
69
70         $stamp1 = microtime(true);
71
72         $a = get_app();
73
74         if (blocked_url($url)) {
75                 logger('z_fetch_url: domain of ' . $url . ' is blocked', LOGGER_DATA);
76                 return $ret;
77         }
78
79         $ch = @curl_init($url);
80
81         if (($redirects > 8) || (!$ch)) {
82                 return $ret;
83         }
84
85         @curl_setopt($ch, CURLOPT_HEADER, true);
86
87         if (x($opts, "cookiejar")) {
88                 curl_setopt($ch, CURLOPT_COOKIEJAR, $opts["cookiejar"]);
89                 curl_setopt($ch, CURLOPT_COOKIEFILE, $opts["cookiejar"]);
90         }
91
92         // These settings aren't needed. We're following the location already.
93         //      @curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
94         //      @curl_setopt($ch, CURLOPT_MAXREDIRS, 5);
95
96         if (x($opts, 'accept_content')) {
97                 curl_setopt(
98                         $ch,
99                         CURLOPT_HTTPHEADER,
100                         ['Accept: ' . $opts['accept_content']]
101                 );
102         }
103
104         @curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
105         @curl_setopt($ch, CURLOPT_USERAGENT, $a->get_useragent());
106
107         $range = intval(Config::get('system', 'curl_range_bytes', 0));
108
109         if ($range > 0) {
110                 @curl_setopt($ch, CURLOPT_RANGE, '0-' . $range);
111         }
112
113         // Without this setting it seems as if some webservers send compressed content
114         // This seems to confuse curl so that it shows this uncompressed.
115         /// @todo  We could possibly set this value to "gzip" or something similar
116         curl_setopt($ch, CURLOPT_ENCODING, '');
117
118         if (x($opts, 'headers')) {
119                 @curl_setopt($ch, CURLOPT_HTTPHEADER, $opts['headers']);
120         }
121
122         if (x($opts, 'nobody')) {
123                 @curl_setopt($ch, CURLOPT_NOBODY, $opts['nobody']);
124         }
125
126         if (x($opts, 'timeout')) {
127                 @curl_setopt($ch, CURLOPT_TIMEOUT, $opts['timeout']);
128         } else {
129                 $curl_time = Config::get('system', 'curl_timeout', 60);
130                 @curl_setopt($ch, CURLOPT_TIMEOUT, intval($curl_time));
131         }
132
133         // by default we will allow self-signed certs
134         // but you can override this
135
136         $check_cert = Config::get('system', 'verifyssl');
137         @curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, (($check_cert) ? true : false));
138
139         if ($check_cert) {
140                 @curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2);
141         }
142
143         $proxy = Config::get('system', 'proxy');
144
145         if (strlen($proxy)) {
146                 @curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, 1);
147                 @curl_setopt($ch, CURLOPT_PROXY, $proxy);
148                 $proxyuser = @Config::get('system', 'proxyuser');
149
150                 if (strlen($proxyuser)) {
151                         @curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxyuser);
152                 }
153         }
154
155         if (Config::get('system', 'ipv4_resolve', false)) {
156                 curl_setopt($ch, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
157         }
158
159         if ($binary) {
160                 @curl_setopt($ch, CURLOPT_BINARYTRANSFER, 1);
161         }
162
163         $a->set_curl_code(0);
164
165         // don't let curl abort the entire application
166         // if it throws any errors.
167
168         $s = @curl_exec($ch);
169         $curl_info = @curl_getinfo($ch);
170
171         // Special treatment for HTTP Code 416
172         // See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/416
173         if (($curl_info['http_code'] == 416) && ($range > 0)) {
174                 @curl_setopt($ch, CURLOPT_RANGE, '');
175                 $s = @curl_exec($ch);
176                 $curl_info = @curl_getinfo($ch);
177         }
178
179         if (curl_errno($ch) !== CURLE_OK) {
180                 logger('fetch_url error fetching ' . $url . ': ' . curl_error($ch), LOGGER_NORMAL);
181         }
182
183         $ret['errno'] = curl_errno($ch);
184
185         $base = $s;
186         $ret['info'] = $curl_info;
187
188         $http_code = $curl_info['http_code'];
189
190         logger('fetch_url ' . $url . ': ' . $http_code . " " . $s, LOGGER_DATA);
191         $header = '';
192
193         // Pull out multiple headers, e.g. proxy and continuation headers
194         // allow for HTTP/2.x without fixing code
195
196         while (preg_match('/^HTTP\/[1-2].+? [1-5][0-9][0-9]/', $base)) {
197                 $chunk = substr($base, 0, strpos($base, "\r\n\r\n") + 4);
198                 $header .= $chunk;
199                 $base = substr($base, strlen($chunk));
200         }
201
202         $a->set_curl_code($http_code);
203         $a->set_curl_content_type($curl_info['content_type']);
204         $a->set_curl_headers($header);
205
206         if ($http_code == 301 || $http_code == 302 || $http_code == 303 || $http_code == 307) {
207                 $new_location_info = @parse_url($curl_info['redirect_url']);
208                 $old_location_info = @parse_url($curl_info['url']);
209
210                 $newurl = $curl_info['redirect_url'];
211
212                 if (($new_location_info['path'] == '') && ( $new_location_info['host'] != '')) {
213                         $newurl = $new_location_info['scheme'] . '://' . $new_location_info['host'] . $old_location_info['path'];
214                 }
215
216                 $matches = [];
217
218                 if (preg_match('/(Location:|URI:)(.*?)\n/i', $header, $matches)) {
219                         $newurl = trim(array_pop($matches));
220                 }
221                 if (strpos($newurl, '/') === 0) {
222                         $newurl = $old_location_info["scheme"]."://".$old_location_info["host"].$newurl;
223                 }
224
225                 if (filter_var($newurl, FILTER_VALIDATE_URL)) {
226                         $redirects++;
227                         @curl_close($ch);
228                         return z_fetch_url($newurl, $binary, $redirects, $opts);
229                 }
230         }
231
232         $a->set_curl_code($http_code);
233         $a->set_curl_content_type($curl_info['content_type']);
234
235         $rc = intval($http_code);
236         $ret['return_code'] = $rc;
237         $ret['success'] = (($rc >= 200 && $rc <= 299) ? true : false);
238         $ret['redirect_url'] = $url;
239
240         if (!$ret['success']) {
241                 $ret['error'] = curl_error($ch);
242                 $ret['debug'] = $curl_info;
243                 logger('z_fetch_url: error: '.$url.': '.$ret['return_code'].' - '.$ret['error'], LOGGER_DEBUG);
244                 logger('z_fetch_url: debug: '.print_r($curl_info, true), LOGGER_DATA);
245         }
246
247         $ret['body'] = substr($s, strlen($header));
248         $ret['header'] = $header;
249
250         if (x($opts, 'debug')) {
251                 $ret['debug'] = $curl_info;
252         }
253
254         @curl_close($ch);
255
256         $a->save_timestamp($stamp1, 'network');
257
258         return($ret);
259 }
260
261 /**
262  * @brief Send POST request to $url
263  *
264  * @param string  $url       URL to post
265  * @param mixed   $params    array of POST variables
266  * @param string  $headers   HTTP headers
267  * @param integer $redirects Recursion counter for internal use - default = 0
268  * @param integer $timeout   The timeout in seconds, default system config value or 60 seconds
269  *
270  * @return string The content
271  */
272 function post_url($url, $params, $headers = null, &$redirects = 0, $timeout = 0)
273 {
274         $stamp1 = microtime(true);
275
276         if (blocked_url($url)) {
277                 logger('post_url: domain of ' . $url . ' is blocked', LOGGER_DATA);
278                 return false;
279         }
280
281         $a = get_app();
282         $ch = curl_init($url);
283
284         if (($redirects > 8) || (!$ch)) {
285                 return false;
286         }
287
288         logger('post_url: start ' . $url, LOGGER_DATA);
289
290         curl_setopt($ch, CURLOPT_HEADER, true);
291         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
292         curl_setopt($ch, CURLOPT_POST, 1);
293         curl_setopt($ch, CURLOPT_POSTFIELDS, $params);
294         curl_setopt($ch, CURLOPT_USERAGENT, $a->get_useragent());
295
296         if (Config::get('system', 'ipv4_resolve', false)) {
297                 curl_setopt($ch, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
298         }
299
300         if (intval($timeout)) {
301                 curl_setopt($ch, CURLOPT_TIMEOUT, $timeout);
302         } else {
303                 $curl_time = Config::get('system', 'curl_timeout', 60);
304                 curl_setopt($ch, CURLOPT_TIMEOUT, intval($curl_time));
305         }
306
307         if (defined('LIGHTTPD')) {
308                 if (!is_array($headers)) {
309                         $headers = ['Expect:'];
310                 } else {
311                         if (!in_array('Expect:', $headers)) {
312                                 array_push($headers, 'Expect:');
313                         }
314                 }
315         }
316
317         if ($headers) {
318                 curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
319         }
320
321         $check_cert = Config::get('system', 'verifyssl');
322         curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, (($check_cert) ? true : false));
323
324         if ($check_cert) {
325                 @curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2);
326         }
327
328         $proxy = Config::get('system', 'proxy');
329
330         if (strlen($proxy)) {
331                 curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, 1);
332                 curl_setopt($ch, CURLOPT_PROXY, $proxy);
333                 $proxyuser = Config::get('system', 'proxyuser');
334                 if (strlen($proxyuser)) {
335                         curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxyuser);
336                 }
337         }
338
339         $a->set_curl_code(0);
340
341         // don't let curl abort the entire application
342         // if it throws any errors.
343
344         $s = @curl_exec($ch);
345
346         $base = $s;
347         $curl_info = curl_getinfo($ch);
348         $http_code = $curl_info['http_code'];
349
350         logger('post_url: result ' . $http_code . ' - ' . $url, LOGGER_DATA);
351
352         $header = '';
353
354         // Pull out multiple headers, e.g. proxy and continuation headers
355         // allow for HTTP/2.x without fixing code
356
357         while (preg_match('/^HTTP\/[1-2].+? [1-5][0-9][0-9]/', $base)) {
358                 $chunk = substr($base, 0, strpos($base, "\r\n\r\n") + 4);
359                 $header .= $chunk;
360                 $base = substr($base, strlen($chunk));
361         }
362
363         if ($http_code == 301 || $http_code == 302 || $http_code == 303 || $http_code == 307) {
364                 $matches = [];
365                 preg_match('/(Location:|URI:)(.*?)\n/', $header, $matches);
366                 $newurl = trim(array_pop($matches));
367
368                 if (strpos($newurl, '/') === 0) {
369                         $newurl = $old_location_info["scheme"] . "://" . $old_location_info["host"] . $newurl;
370                 }
371
372                 if (filter_var($newurl, FILTER_VALIDATE_URL)) {
373                         $redirects++;
374                         logger('post_url: redirect ' . $url . ' to ' . $newurl);
375                         return post_url($newurl, $params, $headers, $redirects, $timeout);
376                 }
377         }
378
379         $a->set_curl_code($http_code);
380
381         $body = substr($s, strlen($header));
382
383         $a->set_curl_headers($header);
384
385         curl_close($ch);
386
387         $a->save_timestamp($stamp1, 'network');
388
389         logger('post_url: end ' . $url, LOGGER_DATA);
390
391         return $body;
392 }
393
394 // Generic XML return
395 // Outputs a basic dfrn XML status structure to STDOUT, with a <status> variable
396 // of $st and an optional text <message> of $message and terminates the current process.
397
398 function xml_status($st, $message = '')
399 {
400         $result = ['status' => $st];
401
402         if ($message != '') {
403                 $result['message'] = $message;
404         }
405
406         if ($st) {
407                 logger('xml_status returning non_zero: ' . $st . " message=" . $message);
408         }
409
410         header("Content-type: text/xml");
411
412         $xmldata = ["result" => $result];
413
414         echo XML::fromArray($xmldata, $xml);
415
416         killme();
417 }
418
419 /**
420  * @brief Send HTTP status header and exit.
421  *
422  * @param integer $val HTTP status result value
423  * @param array $description optional message
424  *    'title' => header title
425  *    'description' => optional message
426  */
427
428 /**
429  * @brief Send HTTP status header and exit.
430  *
431  * @param integer $val         HTTP status result value
432  * @param array   $description optional message
433  *                             'title' => header title
434  *                             'description' => optional message
435  */
436 function http_status_exit($val, $description = [])
437 {
438         $err = '';
439         if ($val >= 400) {
440                 $err = 'Error';
441                 if (!isset($description["title"])) {
442                         $description["title"] = $err." ".$val;
443                 }
444         }
445         if ($val >= 200 && $val < 300)
446                 $err = 'OK';
447
448         logger('http_status_exit ' . $val);
449         header($_SERVER["SERVER_PROTOCOL"] . ' ' . $val . ' ' . $err);
450
451         if (isset($description["title"])) {
452                 $tpl = get_markup_template('http_status.tpl');
453                 echo replace_macros(
454                         $tpl,
455                         [
456                                 '$title' => $description["title"],
457                                 '$description' => $description["description"]]
458                 );
459         }
460
461         killme();
462 }
463
464 /**
465  * @brief Check URL to se if ts's real
466  *
467  * Take a URL from the wild, prepend http:// if necessary
468  * and check DNS to see if it's real (or check if is a valid IP address)
469  *
470  * @param string $url The URL to be validated
471  * @return string|boolean The actual working URL, false else
472  */
473 function validate_url($url)
474 {
475         if (Config::get('system', 'disable_url_validation')) {
476                 return $url;
477         }
478
479         // no naked subdomains (allow localhost for tests)
480         if (strpos($url, '.') === false && strpos($url, '/localhost/') === false) {
481                 return false;
482         }
483
484         if (substr($url, 0, 4) != 'http') {
485                 $url = 'http://' . $url;
486         }
487
488         /// @TODO Really suppress function outcomes? Why not find them + debug them?
489         $h = @parse_url($url);
490
491         if ((is_array($h)) && (dns_get_record($h['host'], DNS_A + DNS_CNAME + DNS_PTR) || filter_var($h['host'], FILTER_VALIDATE_IP) )) {
492                 return $url;
493         }
494
495         return false;
496 }
497
498 /**
499  * @brief Checks that email is an actual resolvable internet address
500  *
501  * @param string $addr The email address
502  * @return boolean True if it's a valid email address, false if it's not
503  */
504 function validate_email($addr)
505 {
506         if (Config::get('system', 'disable_email_validation')) {
507                 return true;
508         }
509
510         if (! strpos($addr, '@')) {
511                 return false;
512         }
513
514         $h = substr($addr, strpos($addr, '@') + 1);
515
516         if (($h) && (dns_get_record($h, DNS_A + DNS_CNAME + DNS_PTR + DNS_MX) || filter_var($h, FILTER_VALIDATE_IP) )) {
517                 return true;
518         }
519         return false;
520 }
521
522 /**
523  * @brief Check if URL is allowed
524  *
525  * Check $url against our list of allowed sites,
526  * wildcards allowed. If allowed_sites is unset return true;
527  *
528  * @param string $url URL which get tested
529  * @return boolean True if url is allowed otherwise return false
530  */
531 function allowed_url($url)
532 {
533         $h = @parse_url($url);
534
535         if (! $h) {
536                 return false;
537         }
538
539         $str_allowed = Config::get('system', 'allowed_sites');
540         if (! $str_allowed) {
541                 return true;
542         }
543
544         $found = false;
545
546         $host = strtolower($h['host']);
547
548         // always allow our own site
549         if ($host == strtolower($_SERVER['SERVER_NAME'])) {
550                 return true;
551         }
552
553         $fnmatch = function_exists('fnmatch');
554         $allowed = explode(',', $str_allowed);
555
556         if (count($allowed)) {
557                 foreach ($allowed as $a) {
558                         $pat = strtolower(trim($a));
559                         if (($fnmatch && fnmatch($pat, $host)) || ($pat == $host)) {
560                                 $found = true;
561                                 break;
562                         }
563                 }
564         }
565         return $found;
566 }
567
568 /**
569  * Checks if the provided url domain is on the domain blocklist.
570  * Returns true if it is or malformed URL, false if not.
571  *
572  * @param string $url The url to check the domain from
573  *
574  * @return boolean
575  */
576 function blocked_url($url)
577 {
578         $h = @parse_url($url);
579
580         if (! $h) {
581                 return true;
582         }
583
584         $domain_blocklist = Config::get('system', 'blocklist', []);
585         if (! $domain_blocklist) {
586                 return false;
587         }
588
589         $host = strtolower($h['host']);
590
591         foreach ($domain_blocklist as $domain_block) {
592                 if (strtolower($domain_block['domain']) == $host) {
593                         return true;
594                 }
595         }
596
597         return false;
598 }
599
600 /**
601  * @brief Check if email address is allowed to register here.
602  *
603  * Compare against our list (wildcards allowed).
604  *
605  * @param  string $email email address
606  * @return boolean False if not allowed, true if allowed
607  *    or if allowed list is not configured
608  */
609 function allowed_email($email)
610 {
611         $domain = strtolower(substr($email, strpos($email, '@') + 1));
612         if (!$domain) {
613                 return false;
614         }
615
616         $str_allowed = Config::get('system', 'allowed_email', '');
617         if (!x($str_allowed)) {
618                 return true;
619         }
620
621         $allowed = explode(',', $str_allowed);
622
623         return allowed_domain($domain, $allowed);
624 }
625
626 /**
627  * Checks for the existence of a domain in a domain list
628  *
629  * @brief Checks for the existence of a domain in a domain list
630  * @param string $domain
631  * @param array  $domain_list
632  * @return boolean
633  */
634 function allowed_domain($domain, array $domain_list)
635 {
636         $found = false;
637
638         foreach ($domain_list as $item) {
639                 $pat = strtolower(trim($item));
640                 if (fnmatch($pat, $domain) || ($pat == $domain)) {
641                         $found = true;
642                         break;
643                 }
644         }
645
646         return $found;
647 }
648
649 function avatar_img($email)
650 {
651         $avatar['size'] = 175;
652         $avatar['email'] = $email;
653         $avatar['url'] = '';
654         $avatar['success'] = false;
655
656         call_hooks('avatar_lookup', $avatar);
657
658         if (! $avatar['success']) {
659                 $avatar['url'] = System::baseUrl() . '/images/person-175.jpg';
660         }
661
662         logger('Avatar: ' . $avatar['email'] . ' ' . $avatar['url'], LOGGER_DEBUG);
663         return $avatar['url'];
664 }
665
666
667 function parse_xml_string($s, $strict = true)
668 {
669         // the "strict" parameter is deactivated
670
671         /// @todo Move this function to the xml class
672         libxml_use_internal_errors(true);
673
674         $x = @simplexml_load_string($s);
675         if (!$x) {
676                 logger('libxml: parse: error: ' . $s, LOGGER_DATA);
677                 foreach (libxml_get_errors() as $err) {
678                         logger('libxml: parse: ' . $err->code." at ".$err->line.":".$err->column." : ".$err->message, LOGGER_DATA);
679                 }
680                 libxml_clear_errors();
681         }
682         return $x;
683 }
684
685 function scale_external_images($srctext, $include_link = true, $scale_replace = false)
686 {
687         // Suppress "view full size"
688         if (intval(Config::get('system', 'no_view_full_size'))) {
689                 $include_link = false;
690         }
691
692         // Picture addresses can contain special characters
693         $s = htmlspecialchars_decode($srctext);
694
695         $matches = null;
696         $c = preg_match_all('/\[img.*?\](.*?)\[\/img\]/ism', $s, $matches, PREG_SET_ORDER);
697         if ($c) {
698                 foreach ($matches as $mtch) {
699                         logger('scale_external_image: ' . $mtch[1]);
700
701                         $hostname = str_replace('www.', '', substr(System::baseUrl(), strpos(System::baseUrl(), '://') + 3));
702                         if (stristr($mtch[1], $hostname)) {
703                                 continue;
704                         }
705
706                         // $scale_replace, if passed, is an array of two elements. The
707                         // first is the name of the full-size image. The second is the
708                         // name of a remote, scaled-down version of the full size image.
709                         // This allows Friendica to display the smaller remote image if
710                         // one exists, while still linking to the full-size image
711                         if ($scale_replace) {
712                                 $scaled = str_replace($scale_replace[0], $scale_replace[1], $mtch[1]);
713                         } else {
714                                 $scaled = $mtch[1];
715                         }
716                         $i = fetch_url($scaled);
717                         if (! $i) {
718                                 return $srctext;
719                         }
720
721                         // guess mimetype from headers or filename
722                         $type = Image::guessType($mtch[1], true);
723
724                         if ($i) {
725                                 $Image = new Image($i, $type);
726                                 if ($Image->isValid()) {
727                                         $orig_width = $Image->getWidth();
728                                         $orig_height = $Image->getHeight();
729
730                                         if ($orig_width > 640 || $orig_height > 640) {
731                                                 $Image->scaleDown(640);
732                                                 $new_width = $Image->getWidth();
733                                                 $new_height = $Image->getHeight();
734                                                 logger('scale_external_images: ' . $orig_width . '->' . $new_width . 'w ' . $orig_height . '->' . $new_height . 'h' . ' match: ' . $mtch[0], LOGGER_DEBUG);
735                                                 $s = str_replace(
736                                                         $mtch[0],
737                                                         '[img=' . $new_width . 'x' . $new_height. ']' . $scaled . '[/img]'
738                                                         . "\n" . (($include_link)
739                                                                 ? '[url=' . $mtch[1] . ']' . t('view full size') . '[/url]' . "\n"
740                                                                 : ''),
741                                                         $s
742                                                 );
743                                                 logger('scale_external_images: new string: ' . $s, LOGGER_DEBUG);
744                                         }
745                                 }
746                         }
747                 }
748         }
749
750         // replace the special char encoding
751         $s = htmlspecialchars($s, ENT_NOQUOTES, 'UTF-8');
752         return $s;
753 }
754
755
756 function fix_contact_ssl_policy(&$contact, $new_policy)
757 {
758         $ssl_changed = false;
759         if ((intval($new_policy) == SSL_POLICY_SELFSIGN || $new_policy === 'self') && strstr($contact['url'], 'https:')) {
760                 $ssl_changed = true;
761                 $contact['url']     =   str_replace('https:', 'http:', $contact['url']);
762                 $contact['request'] =   str_replace('https:', 'http:', $contact['request']);
763                 $contact['notify']  =   str_replace('https:', 'http:', $contact['notify']);
764                 $contact['poll']    =   str_replace('https:', 'http:', $contact['poll']);
765                 $contact['confirm'] =   str_replace('https:', 'http:', $contact['confirm']);
766                 $contact['poco']    =   str_replace('https:', 'http:', $contact['poco']);
767         }
768
769         if ((intval($new_policy) == SSL_POLICY_FULL || $new_policy === 'full') && strstr($contact['url'], 'http:')) {
770                 $ssl_changed = true;
771                 $contact['url']     =   str_replace('http:', 'https:', $contact['url']);
772                 $contact['request'] =   str_replace('http:', 'https:', $contact['request']);
773                 $contact['notify']  =   str_replace('http:', 'https:', $contact['notify']);
774                 $contact['poll']    =   str_replace('http:', 'https:', $contact['poll']);
775                 $contact['confirm'] =   str_replace('http:', 'https:', $contact['confirm']);
776                 $contact['poco']    =   str_replace('http:', 'https:', $contact['poco']);
777         }
778
779         if ($ssl_changed) {
780                 $fields = ['url' => $contact['url'], 'request' => $contact['request'],
781                                 'notify' => $contact['notify'], 'poll' => $contact['poll'],
782                                 'confirm' => $contact['confirm'], 'poco' => $contact['poco']];
783                 dba::update('contact', $fields, ['id' => $contact['id']]);
784         }
785 }
786
787 /**
788  * @brief Remove Google Analytics and other tracking platforms params from URL
789  *
790  * @param string $url Any user-submitted URL that may contain tracking params
791  * @return string The same URL stripped of tracking parameters
792  */
793 function strip_tracking_query_params($url)
794 {
795         $urldata = parse_url($url);
796         if (is_string($urldata["query"])) {
797                 $query = $urldata["query"];
798                 parse_str($query, $querydata);
799
800                 if (is_array($querydata)) {
801                         foreach ($querydata as $param => $value) {
802                                 if (in_array(
803                                         $param,
804                                         [
805                                                 "utm_source", "utm_medium", "utm_term", "utm_content", "utm_campaign",
806                                                 "wt_mc", "pk_campaign", "pk_kwd", "mc_cid", "mc_eid",
807                                                 "fb_action_ids", "fb_action_types", "fb_ref",
808                                                 "awesm", "wtrid",
809                                                 "woo_campaign", "woo_source", "woo_medium", "woo_content", "woo_term"]
810                                         )
811                                 ) {
812                                         $pair = $param . "=" . urlencode($value);
813                                         $url = str_replace($pair, "", $url);
814
815                                         // Second try: if the url isn't encoded completely
816                                         $pair = $param . "=" . str_replace(" ", "+", $value);
817                                         $url = str_replace($pair, "", $url);
818
819                                         // Third try: Maybey the url isn't encoded at all
820                                         $pair = $param . "=" . $value;
821                                         $url = str_replace($pair, "", $url);
822
823                                         $url = str_replace(["?&", "&&"], ["?", ""], $url);
824                                 }
825                         }
826                 }
827
828                 if (substr($url, -1, 1) == "?") {
829                         $url = substr($url, 0, -1);
830                 }
831         }
832
833         return $url;
834 }
835
836 /**
837  * @brief Returns the original URL of the provided URL
838  *
839  * This function strips tracking query params and follows redirections, either
840  * through HTTP code or meta refresh tags. Stops after 10 redirections.
841  *
842  * @todo Remove the $fetchbody parameter that generates an extraneous HEAD request
843  *
844  * @see ParseUrl::getSiteinfo
845  *
846  * @param string $url       A user-submitted URL
847  * @param int    $depth     The current redirection recursion level (internal)
848  * @param bool   $fetchbody Wether to fetch the body or not after the HEAD requests
849  * @return string A canonical URL
850  */
851 function original_url($url, $depth = 1, $fetchbody = false)
852 {
853         $a = get_app();
854
855         $url = strip_tracking_query_params($url);
856
857         if ($depth > 10) {
858                 return($url);
859         }
860
861         $url = trim($url, "'");
862
863         $stamp1 = microtime(true);
864
865         $ch = curl_init();
866         curl_setopt($ch, CURLOPT_URL, $url);
867         curl_setopt($ch, CURLOPT_HEADER, 1);
868         curl_setopt($ch, CURLOPT_NOBODY, 1);
869         curl_setopt($ch, CURLOPT_TIMEOUT, 10);
870         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
871         curl_setopt($ch, CURLOPT_USERAGENT, $a->get_useragent());
872
873         curl_exec($ch);
874         $curl_info = @curl_getinfo($ch);
875         $http_code = $curl_info['http_code'];
876         curl_close($ch);
877
878         $a->save_timestamp($stamp1, "network");
879
880         if ($http_code == 0)
881                 return($url);
882
883         if ((($curl_info['http_code'] == "301") || ($curl_info['http_code'] == "302"))
884                 && (($curl_info['redirect_url'] != "") || ($curl_info['location'] != ""))
885         ) {
886                 if ($curl_info['redirect_url'] != "") {
887                         return(original_url($curl_info['redirect_url'], ++$depth, $fetchbody));
888                 } else {
889                         return(original_url($curl_info['location'], ++$depth, $fetchbody));
890                 }
891         }
892
893         // Check for redirects in the meta elements of the body if there are no redirects in the header.
894         if (!$fetchbody) {
895                 return(original_url($url, ++$depth, true));
896         }
897
898         // if the file is too large then exit
899         if ($curl_info["download_content_length"] > 1000000) {
900                 return($url);
901         }
902
903         // if it isn't a HTML file then exit
904         if (($curl_info["content_type"] != "") && !strstr(strtolower($curl_info["content_type"]), "html")) {
905                 return($url);
906         }
907
908         $stamp1 = microtime(true);
909
910         $ch = curl_init();
911         curl_setopt($ch, CURLOPT_URL, $url);
912         curl_setopt($ch, CURLOPT_HEADER, 0);
913         curl_setopt($ch, CURLOPT_NOBODY, 0);
914         curl_setopt($ch, CURLOPT_TIMEOUT, 10);
915         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
916         curl_setopt($ch, CURLOPT_USERAGENT, $a->get_useragent());
917
918         $body = curl_exec($ch);
919         curl_close($ch);
920
921         $a->save_timestamp($stamp1, "network");
922
923         if (trim($body) == "") {
924                 return($url);
925         }
926
927         // Check for redirect in meta elements
928         $doc = new DOMDocument();
929         @$doc->loadHTML($body);
930
931         $xpath = new DomXPath($doc);
932
933         $list = $xpath->query("//meta[@content]");
934         foreach ($list as $node) {
935                 $attr = [];
936                 if ($node->attributes->length) {
937                         foreach ($node->attributes as $attribute) {
938                                 $attr[$attribute->name] = $attribute->value;
939                         }
940                 }
941
942                 if (@$attr["http-equiv"] == 'refresh') {
943                         $path = $attr["content"];
944                         $pathinfo = explode(";", $path);
945                         foreach ($pathinfo as $value) {
946                                 if (substr(strtolower($value), 0, 4) == "url=") {
947                                         return(original_url(substr($value, 4), ++$depth));
948                                 }
949                         }
950                 }
951         }
952
953         return $url;
954 }
955
956 function short_link($url)
957 {
958         require_once 'library/slinky.php';
959         $slinky = new Slinky($url);
960         $yourls_url = Config::get('yourls', 'url1');
961         if ($yourls_url) {
962                 $yourls_username = Config::get('yourls', 'username1');
963                 $yourls_password = Config::get('yourls', 'password1');
964                 $yourls_ssl = Config::get('yourls', 'ssl1');
965                 $yourls = new Slinky_YourLS();
966                 $yourls->set('username', $yourls_username);
967                 $yourls->set('password', $yourls_password);
968                 $yourls->set('ssl', $yourls_ssl);
969                 $yourls->set('yourls-url', $yourls_url);
970                 $slinky->set_cascade([$yourls, new Slinky_Ur1ca(), new Slinky_TinyURL()]);
971         } else {
972                 // setup a cascade of shortening services
973                 // try to get a short link from these services
974                 // in the order ur1.ca, tinyurl
975                 $slinky->set_cascade([new Slinky_Ur1ca(), new Slinky_TinyURL()]);
976         }
977         return $slinky->short();
978 }
979
980 /**
981  * @brief Encodes content to json
982  *
983  * This function encodes an array to json format
984  * and adds an application/json HTTP header to the output.
985  * After finishing the process is getting killed.
986  *
987  * @param array $x The input content
988  */
989 function json_return_and_die($x)
990 {
991         header("content-type: application/json");
992         echo json_encode($x);
993         killme();
994 }
995
996 /**
997  * @brief Find the matching part between two url
998  *
999  * @param string $url1
1000  * @param string $url2
1001  * @return string The matching part
1002  */
1003 function matching_url($url1, $url2)
1004 {
1005         if (($url1 == "") || ($url2 == "")) {
1006                 return "";
1007         }
1008
1009         $url1 = normalise_link($url1);
1010         $url2 = normalise_link($url2);
1011
1012         $parts1 = parse_url($url1);
1013         $parts2 = parse_url($url2);
1014
1015         if (!isset($parts1["host"]) || !isset($parts2["host"])) {
1016                 return "";
1017         }
1018
1019         if ($parts1["scheme"] != $parts2["scheme"]) {
1020                 return "";
1021         }
1022
1023         if ($parts1["host"] != $parts2["host"]) {
1024                 return "";
1025         }
1026
1027         if ($parts1["port"] != $parts2["port"]) {
1028                 return "";
1029         }
1030
1031         $match = $parts1["scheme"]."://".$parts1["host"];
1032
1033         if ($parts1["port"]) {
1034                 $match .= ":".$parts1["port"];
1035         }
1036
1037         $pathparts1 = explode("/", $parts1["path"]);
1038         $pathparts2 = explode("/", $parts2["path"]);
1039
1040         $i = 0;
1041         $path = "";
1042         do {
1043                 $path1 = $pathparts1[$i];
1044                 $path2 = $pathparts2[$i];
1045
1046                 if ($path1 == $path2) {
1047                         $path .= $path1."/";
1048                 }
1049         } while (($path1 == $path2) && ($i++ <= count($pathparts1)));
1050
1051         $match .= $path;
1052
1053         return normalise_link($match);
1054 }
1055
1056 /**
1057  * @brief Glue url parts together
1058  *
1059  * @param array $parsed URL parts
1060  *
1061  * @return string The glued URL
1062  */
1063 function unParseUrl($parsed)
1064 {
1065         $get = function ($key) use ($parsed) {
1066                 return isset($parsed[$key]) ? $parsed[$key] : null;
1067         };
1068
1069         $pass      = $get('pass');
1070         $user      = $get('user');
1071         $userinfo  = $pass !== null ? "$user:$pass" : $user;
1072         $port      = $get('port');
1073         $scheme    = $get('scheme');
1074         $query     = $get('query');
1075         $fragment  = $get('fragment');
1076         $authority = ($userinfo !== null ? $userinfo."@" : '') .
1077                                         $get('host') .
1078                                         ($port ? ":$port" : '');
1079
1080         return  (strlen($scheme) ? $scheme.":" : '') .
1081                 (strlen($authority) ? "//".$authority : '') .
1082                 $get('path') .
1083                 (strlen($query) ? "?".$query : '') .
1084                 (strlen($fragment) ? "#".$fragment : '');
1085 }