]> git.mxchange.org Git - friendica.git/blob - src/Core/System.php
add self for unfollowed contact
[friendica.git] / src / Core / System.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\Core;
23
24 use Friendica\Content\Text\BBCode;
25 use Friendica\Content\Text\HTML;
26 use Friendica\Core\Config\Capability\IManageConfigValues;
27 use Friendica\DI;
28 use Friendica\Model\User;
29 use Friendica\Module\Response;
30 use Friendica\Network\HTTPException\FoundException;
31 use Friendica\Network\HTTPException\InternalServerErrorException;
32 use Friendica\Network\HTTPException\MovedPermanentlyException;
33 use Friendica\Network\HTTPException\TemporaryRedirectException;
34 use Friendica\Util\BasePath;
35 use Friendica\Util\XML;
36 use Psr\Http\Message\ResponseInterface;
37 use Psr\Log\LoggerInterface;
38
39 /**
40  * Contains the class with system relevant stuff
41  */
42 class System
43 {
44         /**
45          * @var LoggerInterface
46          */
47         private $logger;
48
49         /**
50          * @var IManageConfigValues
51          */
52         private $config;
53
54         /**
55          * @var string
56          */
57         private $basePath;
58
59         public function __construct(LoggerInterface $logger, IManageConfigValues $config, string $basepath)
60         {
61                 $this->logger   = $logger;
62                 $this->config   = $config;
63                 $this->basePath = $basepath;
64         }
65
66         /**
67          * Checks if the maximum number of database processes is reached
68          *
69          * @return bool Is the limit reached?
70          */
71         public function isMaxProcessesReached(): bool
72         {
73                 // Deactivated, needs more investigating if this check really makes sense
74                 return false;
75
76                 /*
77                  * Commented out to suppress static analyzer issues
78                  *
79                 if ($this->mode->isBackend()) {
80                         $process = 'backend';
81                         $max_processes = $this->config->get('system', 'max_processes_backend');
82                         if (intval($max_processes) == 0) {
83                                 $max_processes = 5;
84                         }
85                 } else {
86                         $process = 'frontend';
87                         $max_processes = $this->config->get('system', 'max_processes_frontend');
88                         if (intval($max_processes) == 0) {
89                                 $max_processes = 20;
90                         }
91                 }
92
93                 $processlist = DBA::processlist();
94                 if ($processlist['list'] != '') {
95                         $this->logger->debug('Processcheck: Processes: ' . $processlist['amount'] . ' - Processlist: ' . $processlist['list']);
96
97                         if ($processlist['amount'] > $max_processes) {
98                                 $this->logger->debug('Processcheck: Maximum number of processes for ' . $process . ' tasks (' . $max_processes . ') reached.');
99                                 return true;
100                         }
101                 }
102                 return false;
103                  */
104         }
105
106         /**
107          * Checks if the minimal memory is reached
108          *
109          * @return bool Is the memory limit reached?
110          */
111         public function isMinMemoryReached(): bool
112         {
113                 // Deactivated, needs more investigating if this check really makes sense
114                 return false;
115
116                 /*
117                  * Commented out to suppress static analyzer issues
118                  *
119                 $min_memory = $this->config->get('system', 'min_memory', 0);
120                 if ($min_memory == 0) {
121                         return false;
122                 }
123
124                 if (!is_readable('/proc/meminfo')) {
125                         return false;
126                 }
127
128                 $memdata = explode("\n", file_get_contents('/proc/meminfo'));
129
130                 $meminfo = [];
131                 foreach ($memdata as $line) {
132                         $data = explode(':', $line);
133                         if (count($data) != 2) {
134                                 continue;
135                         }
136                         [$key, $val]     = $data;
137                         $meminfo[$key]   = (int)trim(str_replace('kB', '', $val));
138                         $meminfo[$key]   = (int)($meminfo[$key] / 1024);
139                 }
140
141                 if (!isset($meminfo['MemFree'])) {
142                         return false;
143                 }
144
145                 $free = $meminfo['MemFree'];
146
147                 $reached = ($free < $min_memory);
148
149                 if ($reached) {
150                         $this->logger->warning('Minimal memory reached.', ['free' => $free, 'memtotal' => $meminfo['MemTotal'], 'limit' => $min_memory]);
151                 }
152
153                 return $reached;
154                  */
155         }
156
157         /**
158          * Checks if the maximum load is reached
159          *
160          * @return bool Is the load reached?
161          */
162         public function isMaxLoadReached(): bool
163         {
164                 $maxsysload = intval($this->config->get('system', 'maxloadavg'));
165                 if ($maxsysload < 1) {
166                         $maxsysload = 50;
167                 }
168
169                 $load = System::currentLoad();
170                 if ($load) {
171                         if (intval($load) > $maxsysload) {
172                                 $this->logger->notice('system load for process too high.', ['load' => $load, 'process' => 'backend', 'maxsysload' => $maxsysload]);
173                                 return true;
174                         }
175                 }
176                 return false;
177         }
178
179         /**
180          * Executes a child process with 'proc_open'
181          *
182          * @param string $command The command to execute
183          * @param array  $args    Arguments to pass to the command ( [ 'key' => value, 'key2' => value2, ... ]
184          */
185         public function run(string $command, array $args)
186         {
187                 if (!function_exists('proc_open')) {
188                         $this->logger->warning('"proc_open" not available - quitting');
189                         return;
190                 }
191
192                 $cmdline = $this->config->get('config', 'php_path', 'php') . ' ' . escapeshellarg($command);
193
194                 foreach ($args as $key => $value) {
195                         if (!is_null($value) && is_bool($value) && !$value) {
196                                 continue;
197                         }
198
199                         $cmdline .= ' --' . $key;
200                         if (!is_null($value) && !is_bool($value)) {
201                                 $cmdline .= ' ' . $value;
202                         }
203                 }
204
205                 if ($this->isMinMemoryReached()) {
206                         $this->logger->warning('Memory limit reached - quitting');
207                         return;
208                 }
209
210                 if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
211                         $resource = proc_open('cmd /c start /b ' . $cmdline, [], $foo, $this->basePath);
212                 } else {
213                         $resource = proc_open($cmdline . ' &', [], $foo, $this->basePath);
214                 }
215
216                 if (!is_resource($resource)) {
217                         $this->logger->warning('We got no resource for command.', ['command' => $cmdline]);
218                         return;
219                 }
220
221                 proc_close($resource);
222
223                 $this->logger->info('Executed "proc_open"', ['command' => $cmdline, 'callstack' => System::callstack(10)]);
224         }
225
226         /**
227          * Returns a string with a callstack. Can be used for logging.
228          *
229          * @param integer $depth  How many calls to include in the stacks after filtering
230          * @param int     $offset How many calls to shave off the top of the stack, for example if
231          *                        this is called from a centralized method that isn't relevant to the callstack
232          * @param bool    $full   If enabled, the callstack is not compacted
233          * @return string
234          */
235         public static function callstack(int $depth = 4, int $offset = 0, bool $full = false): string
236         {
237                 $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
238
239                 // We remove at least the first two items from the list since they contain data that we don't need.
240                 $trace = array_slice($trace, 2 + $offset);
241
242                 $callstack = [];
243                 $previous = ['class' => '', 'function' => '', 'database' => false];
244
245                 // The ignore list contains all functions that are only wrapper functions
246                 $ignore = ['call_user_func_array'];
247
248                 while ($func = array_pop($trace)) {
249                         if (!empty($func['class'])) {
250                                 if (!$full && in_array($previous['function'], ['insert', 'fetch', 'toArray', 'exists', 'count', 'selectFirst', 'selectToArray',
251                                         'select', 'update', 'delete', 'selectFirstForUser', 'selectForUser'])
252                                         && (substr($previous['class'], 0, 15) === 'Friendica\Model')) {
253                                         continue;
254                                 }
255
256                                 // Don't show multiple calls from the Database classes to show the essential parts of the callstack
257                                 $func['database'] = in_array($func['class'], ['Friendica\Database\DBA', 'Friendica\Database\Database']);
258                                 if ($full || !$previous['database'] || !$func['database']) {
259                                         $classparts = explode("\\", $func['class']);
260                                         $callstack[] = array_pop($classparts).'::'.$func['function'] . (isset($func['line']) ? ' (' . $func['line'] . ')' : '');
261                                         $previous = $func;
262                                 }
263                         } elseif (!in_array($func['function'], $ignore)) {
264                                 $func['database'] = ($func['function'] == 'q');
265                                 $callstack[] = $func['function'] . (isset($func['line']) ? ' (' . $func['line'] . ')' : '');
266                                 $func['class'] = '';
267                                 $previous = $func;
268                         }
269                 }
270
271                 $callstack2 = [];
272                 while ((count($callstack2) < $depth) && (count($callstack) > 0)) {
273                         $callstack2[] = array_pop($callstack);
274                 }
275
276                 return implode(', ', $callstack2);
277         }
278
279         /**
280          * Display current response, including setting all headers
281          *
282          * @param ResponseInterface $response
283          */
284         public static function echoResponse(ResponseInterface $response)
285         {
286                 header(sprintf("HTTP/%s %s %s",
287                                 $response->getProtocolVersion(),
288                                 $response->getStatusCode(),
289                                 $response->getReasonPhrase())
290                 );
291
292                 foreach ($response->getHeaders() as $key => $header) {
293                         if (is_array($header)) {
294                                 $header_str = implode(',', $header);
295                         } else {
296                                 $header_str = $header;
297                         }
298
299                         if (is_int($key)) {
300                                 header($header_str);
301                         } else {
302                                 header("$key: $header_str");
303                         }
304                 }
305
306                 echo $response->getBody();
307         }
308
309         /**
310          * Generic XML return
311          * Outputs a basic dfrn XML status structure to STDOUT, with a <status> variable
312          * of $st and an optional text <message> of $message and terminates the current process.
313          *
314          * @param mixed  $status
315          * @param string $message
316          * @throws \Exception
317          * @deprecated since 2023.09 Use BaseModule->httpExit() instead
318          */
319         public static function xmlExit($status, string $message = '')
320         {
321                 $result = ['status' => $status];
322
323                 if ($message != '') {
324                         $result['message'] = $message;
325                 }
326
327                 if ($status) {
328                         Logger::notice('xml_status returning non_zero: ' . $status . " message=" . $message);
329                 }
330
331                 self::httpExit(XML::fromArray(['result' => $result]), Response::TYPE_XML);
332         }
333
334         /**
335          * Send HTTP status header and exit.
336          *
337          * @param integer $val     HTTP status result value
338          * @param string  $message Error message. Optional.
339          * @param string  $content Response body. Optional.
340          * @throws \Exception
341          * @deprecated since 2023.09 Use BaseModule->httpError instead
342          */
343         public static function httpError($httpCode, $message = '', $content = '')
344         {
345                 if ($httpCode >= 400) {
346                         Logger::debug('Exit with error', ['code' => $httpCode, 'message' => $message, 'callstack' => System::callstack(20), 'method' => DI::args()->getMethod(), 'agent' => $_SERVER['HTTP_USER_AGENT'] ?? '']);
347                 }
348                 DI::apiResponse()->setStatus($httpCode, $message);
349
350                 self::httpExit($content);
351         }
352
353         /**
354          * This function adds the content and a content-type HTTP header to the output.
355          * After finishing the process is getting killed.
356          *
357          * @param string      $content
358          * @param string      $type
359          * @param string|null $content_type
360          * @return void
361          * @throws InternalServerErrorException
362          * @deprecated since 2023.09 Use BaseModule->httpExit() instead
363          */
364         public static function httpExit(string $content, string $type = Response::TYPE_HTML, ?string $content_type = null)
365         {
366                 DI::apiResponse()->setType($type, $content_type);
367                 DI::apiResponse()->addContent($content);
368                 self::echoResponse(DI::apiResponse()->generate());
369
370                 self::exit();
371         }
372
373         /**
374          * @deprecated since 2023.09 Use BaseModule->jsonError instead
375          */
376         public static function jsonError($httpCode, $content, $content_type = 'application/json')
377         {
378                 if ($httpCode >= 400) {
379                         Logger::debug('Exit with error', ['code' => $httpCode, 'content_type' => $content_type, 'callstack' => System::callstack(20), 'method' => DI::args()->getMethod(), 'agent' => $_SERVER['HTTP_USER_AGENT'] ?? '']);
380                 }
381                 DI::apiResponse()->setStatus($httpCode);
382                 self::jsonExit($content, $content_type);
383         }
384
385         /**
386          * Encodes content to json.
387          *
388          * This function encodes an array to json format
389          * and adds an application/json HTTP header to the output.
390          * After finishing the process is getting killed.
391          *
392          * @param mixed   $content      The input content
393          * @param string  $content_type Type of the input (Default: 'application/json')
394          * @param integer $options      JSON options
395          * @throws InternalServerErrorException
396          * @deprecated since 2023.09 Use BaseModule->jsonExit instead
397          */
398         public static function jsonExit($content, string $content_type = 'application/json', int $options = JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT)
399         {
400                 self::httpExit(json_encode($content, $options), Response::TYPE_JSON, $content_type);
401         }
402
403         /**
404          * Exit the program execution.
405          */
406         public static function exit()
407         {
408                 DI::page()->logRuntime(DI::config(), 'exit');
409                 exit();
410         }
411
412         /**
413          * Generates a random string in the UUID format
414          *
415          * @param bool|string $prefix A given prefix (default is empty)
416          * @return string a generated UUID
417          * @throws \Exception
418          */
419         public static function createUUID($prefix = '')
420         {
421                 $guid = System::createGUID(32, $prefix);
422                 return substr($guid, 0, 8) . '-' . substr($guid, 8, 4) . '-' . substr($guid, 12, 4) . '-' . substr($guid, 16, 4) . '-' . substr($guid, 20, 12);
423         }
424
425         /**
426          * Generates a GUID with the given parameters
427          *
428          * @param int         $size   The size of the GUID (default is 16)
429          * @param bool|string $prefix A given prefix (default is empty)
430          * @return string a generated GUID
431          * @throws \Exception
432          */
433         public static function createGUID($size = 16, $prefix = '')
434         {
435                 if (is_bool($prefix) && !$prefix) {
436                         $prefix = '';
437                 } elseif (empty($prefix)) {
438                         $prefix = hash('crc32', DI::baseUrl()->getHost());
439                 }
440
441                 while (strlen($prefix) < ($size - 13)) {
442                         $prefix .= mt_rand();
443                 }
444
445                 if ($size >= 24) {
446                         $prefix = substr($prefix, 0, $size - 22);
447                         return str_replace('.', '', uniqid($prefix, true));
448                 } else {
449                         $prefix = substr($prefix, 0, max($size - 13, 0));
450                         return uniqid($prefix);
451                 }
452         }
453
454         /**
455          * Returns the current Load of the System
456          *
457          * @return integer
458          */
459         public static function currentLoad()
460         {
461                 if (!function_exists('sys_getloadavg')) {
462                         return false;
463                 }
464
465                 $load_arr = sys_getloadavg();
466
467                 if (!is_array($load_arr)) {
468                         return false;
469                 }
470
471                 return max($load_arr[0], $load_arr[1]);
472         }
473
474         /**
475          * Fetch the load and number of processes
476          *
477          * @param bool $get_processes
478          * @return array
479          */
480         public static function getLoadAvg(bool $get_processes = true): array
481         {
482                 $load_arr = sys_getloadavg();
483                 if (empty($load_arr)) {
484                         return [];
485                 }
486
487                 $load = [
488                         'average1'  => $load_arr[0],
489                         'average5'  => $load_arr[1],
490                         'average15' => $load_arr[2],
491                         'runnable'  => 0,
492                         'scheduled' => 0
493                 ];
494
495                 if ($get_processes && @is_readable('/proc/loadavg')) {
496                         $content = @file_get_contents('/proc/loadavg');
497                         if (!empty($content) && preg_match("#([.\d]+)\s([.\d]+)\s([.\d]+)\s(\d+)/(\d+)#", $content, $matches)) {
498                                 $load['runnable']  = (float)$matches[4];
499                                 $load['scheduled'] = (float)$matches[5];
500                         }
501                 }
502
503                 return $load;
504         }
505
506         /**
507          * Redirects to an external URL (fully qualified URL)
508          * If you want to route relative to the current Friendica base, use App->internalRedirect()
509          *
510          * @param string $url  The new Location to redirect
511          * @param int    $code The redirection code, which is used (Default is 302)
512          *
513          * @throws FoundException
514          * @throws MovedPermanentlyException
515          * @throws TemporaryRedirectException
516          *
517          * @throws \Friendica\Network\HTTPException\InternalServerErrorException
518          */
519         public static function externalRedirect($url, $code = 302)
520         {
521                 if (empty(parse_url($url, PHP_URL_SCHEME))) {
522                         Logger::warning('No fully qualified URL provided', ['url' => $url, 'callstack' => self::callstack(20)]);
523                         DI::baseUrl()->redirect($url);
524                 }
525
526                 header("Location: $url");
527
528                 switch ($code) {
529                         case 302:
530                                 throw new FoundException();
531                         case 301:
532                                 throw new MovedPermanentlyException();
533                         case 307:
534                                 throw new TemporaryRedirectException();
535                 }
536                 self::exit();
537         }
538
539         /**
540          * Returns the system user that is executing the script
541          *
542          * This mostly returns something like "www-data".
543          *
544          * @return string system username
545          */
546         public static function getUser()
547         {
548                 if (!function_exists('posix_getpwuid') || !function_exists('posix_geteuid')) {
549                         return '';
550                 }
551
552                 $processUser = posix_getpwuid(posix_geteuid());
553                 return $processUser['name'];
554         }
555
556         /**
557          * Checks if a given directory is usable for the system
558          *
559          * @param      $directory
560          *
561          * @return boolean the directory is usable
562          */
563         private static function isDirectoryUsable(string $directory): bool
564         {
565                 if (empty($directory)) {
566                         Logger::warning('Directory is empty. This shouldn\'t happen.');
567                         return false;
568                 }
569
570                 if (!file_exists($directory)) {
571                         Logger::info('Path does not exist', ['directory' => $directory, 'user' => static::getUser()]);
572                         return false;
573                 }
574
575                 if (is_file($directory)) {
576                         Logger::warning('Path is a file', ['directory' => $directory, 'user' => static::getUser()]);
577                         return false;
578                 }
579
580                 if (!is_dir($directory)) {
581                         Logger::warning('Path is not a directory', ['directory' => $directory, 'user' => static::getUser()]);
582                         return false;
583                 }
584
585                 if (!is_writable($directory)) {
586                         Logger::warning('Path is not writable', ['directory' => $directory, 'user' => static::getUser()]);
587                         return false;
588                 }
589
590                 return true;
591         }
592
593         /**
594          * Exit method used by asynchronous update modules
595          *
596          * @param string $o
597          */
598         public static function htmlUpdateExit($o)
599         {
600                 DI::apiResponse()->setType(Response::TYPE_HTML);
601                 echo "<!DOCTYPE html><html><body>\r\n";
602                 // We can remove this hack once Internet Explorer recognises HTML5 natively
603                 echo "<section>";
604                 // reportedly some versions of MSIE don't handle tabs in XMLHttpRequest documents very well
605                 echo str_replace("\t", "       ", $o);
606                 echo "</section>";
607                 echo "</body></html>\r\n";
608                 self::exit();
609         }
610
611         /**
612          * Fetch the temp path of the system
613          *
614          * @return string Path for temp files
615          */
616         public static function getTempPath()
617         {
618                 $temppath = DI::config()->get("system", "temppath");
619
620                 if (($temppath != "") && self::isDirectoryUsable($temppath)) {
621                         // We have a temp path and it is usable
622                         return BasePath::getRealPath($temppath);
623                 }
624
625                 // We don't have a working preconfigured temp path, so we take the system path.
626                 $temppath = sys_get_temp_dir();
627
628                 // Check if it is usable
629                 if (($temppath != "") && self::isDirectoryUsable($temppath)) {
630                         // Always store the real path, not the path through symlinks
631                         $temppath = BasePath::getRealPath($temppath);
632
633                         // To avoid any interferences with other systems we create our own directory
634                         $new_temppath = $temppath . "/" . DI::baseUrl()->getHost();
635                         if (!is_dir($new_temppath)) {
636                                 /// @TODO There is a mkdir()+chmod() upwards, maybe generalize this (+ configurable) into a function/method?
637                                 @mkdir($new_temppath);
638                         }
639
640                         if (self::isDirectoryUsable($new_temppath)) {
641                                 // The new path is usable, we are happy
642                                 DI::config()->set("system", "temppath", $new_temppath);
643                                 return $new_temppath;
644                         } else {
645                                 // We can't create a subdirectory, strange.
646                                 // But the directory seems to work, so we use it but don't store it.
647                                 return $temppath;
648                         }
649                 }
650
651                 // Reaching this point means that the operating system is configured badly.
652                 return '';
653         }
654
655         /**
656          * Returns the path where spool files are stored
657          *
658          * @return string Spool path
659          */
660         public static function getSpoolPath()
661         {
662                 $spoolpath = DI::config()->get('system', 'spoolpath');
663                 if (($spoolpath != "") && self::isDirectoryUsable($spoolpath)) {
664                         // We have a spool path and it is usable
665                         return $spoolpath;
666                 }
667
668                 // We don't have a working preconfigured spool path, so we take the temp path.
669                 $temppath = self::getTempPath();
670
671                 if ($temppath != "") {
672                         // To avoid any interferences with other systems we create our own directory
673                         $spoolpath = $temppath . "/spool";
674                         if (!is_dir($spoolpath)) {
675                                 mkdir($spoolpath);
676                         }
677
678                         if (self::isDirectoryUsable($spoolpath)) {
679                                 // The new path is usable, we are happy
680                                 DI::config()->set("system", "spoolpath", $spoolpath);
681                                 return $spoolpath;
682                         } else {
683                                 // We can't create a subdirectory, strange.
684                                 // But the directory seems to work, so we use it but don't store it.
685                                 return $temppath;
686                         }
687                 }
688
689                 // Reaching this point means that the operating system is configured badly.
690                 return "";
691         }
692
693         /**
694          * Fetch the system rules
695          * @param bool $numeric_id If set to "true", the rules are returned with a numeric id as key.
696          *
697          * @return array
698          */
699         public static function getRules(bool $numeric_id = false): array
700         {
701                 $rules = [];
702                 $id    = 0;
703
704                 if (DI::config()->get('system', 'tosdisplay')) {
705                         $rulelist = DI::config()->get('system', 'tosrules') ?: DI::config()->get('system', 'tostext');
706                         $msg = BBCode::toPlaintext($rulelist, false);
707                         foreach (explode("\n", trim($msg)) as $line) {
708                                 $line = trim($line);
709                                 if ($line) {
710                                         if ($numeric_id) {
711                                                 $rules[++$id] = $line;
712                                         } else {
713                                                 $rules[] = ['id' => (string)++$id, 'text' => $line];
714                                         }
715                                 }
716                         }
717                 }
718
719                 return $rules;
720         }
721 }