src/Core/System.php

   1 <?php
   2 /**
   3  * @copyright Copyright (C) 2020, Friendica
   4  *
   5  * @license GNU AGPL version 3 or any later version
   6  *
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as
   9  * published by the Free Software Foundation, either version 3 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  19  *
  20  */
  21
  22 namespace Friendica\Core;
  23
  24 use Friendica\DI;
  25 use Friendica\Network\HTTPException\InternalServerErrorException;
  26 use Friendica\Util\XML;
  27
  28 /**
  29  * Contains the class with system relevant stuff
  30  */
  31 class System
  32 {
  33         /**
  34          * Returns a string with a callstack. Can be used for logging.
  35          *
  36          * @param integer $depth optional, default 4
  37          * @return string
  38          */
  39         public static function callstack($depth = 4)
  40         {
  41                 $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
  42
  43                 // We remove the first two items from the list since they contain data that we don't need.
  44                 array_shift($trace);
  45                 array_shift($trace);
  46
  47                 $callstack = [];
  48                 $previous = ['class' => '', 'function' => '', 'database' => false];
  49
  50                 // The ignore list contains all functions that are only wrapper functions
  51                 $ignore = ['fetchUrl', 'call_user_func_array'];
  52
  53                 while ($func = array_pop($trace)) {
  54                         if (!empty($func['class'])) {
  55                                 // Don't show multiple calls from the Database classes to show the essential parts of the callstack
  56                                 $func['database'] = in_array($func['class'], ['Friendica\Database\DBA', 'Friendica\Database\Database']);
  57                                 if (!$previous['database'] || !$func['database']) {
  58                                         $classparts = explode("\\", $func['class']);
  59                                         $callstack[] = array_pop($classparts).'::'.$func['function'];
  60                                         $previous = $func;
  61                                 }
  62                         } elseif (!in_array($func['function'], $ignore)) {
  63                                 $func['database'] = ($func['function'] == 'q');
  64                                 $callstack[] = $func['function'];
  65                                 $func['class'] = '';
  66                                 $previous = $func;
  67                         }
  68                 }
  69
  70                 $callstack2 = [];
  71                 while ((count($callstack2) < $depth) && (count($callstack) > 0)) {
  72                         $callstack2[] = array_pop($callstack);
  73                 }
  74
  75                 return implode(', ', $callstack2);
  76         }
  77
  78         /**
  79          * Generic XML return
  80          * Outputs a basic dfrn XML status structure to STDOUT, with a <status> variable
  81          * of $st and an optional text <message> of $message and terminates the current process.
  82          *
  83          * @param        $st
  84          * @param string $message
  85          * @throws \Exception
  86          */
  87         public static function xmlExit($st, $message = '')
  88         {
  89                 $result = ['status' => $st];
  90
  91                 if ($message != '') {
  92                         $result['message'] = $message;
  93                 }
  94
  95                 if ($st) {
  96                         Logger::log('xml_status returning non_zero: ' . $st . " message=" . $message);
  97                 }
  98
  99                 header("Content-type: text/xml");
 100
 101                 $xmldata = ["result" => $result];
 102
 103                 echo XML::fromArray($xmldata, $xml);
 104
 105                 exit();
 106         }
 107
 108         /**
 109          * Send HTTP status header and exit.
 110          *
 111          * @param integer $val     HTTP status result value
 112          * @param string  $message Error message. Optional.
 113          * @param string  $content Response body. Optional.
 114          * @throws \Exception
 115          */
 116         public static function httpExit($val, $message = '', $content = '')
 117         {
 118                 Logger::log('http_status_exit ' . $val);
 119                 header($_SERVER["SERVER_PROTOCOL"] . ' ' . $val . ' ' . $message);
 120
 121                 echo $content;
 122
 123                 exit();
 124         }
 125
 126         public static function jsonError($httpCode, $data, $content_type = 'application/json')
 127         {
 128                 header($_SERVER["SERVER_PROTOCOL"] . ' ' . $httpCode);
 129                 self::jsonExit($data, $content_type);
 130         }
 131
 132         /**
 133          * Encodes content to json.
 134          *
 135          * This function encodes an array to json format
 136          * and adds an application/json HTTP header to the output.
 137          * After finishing the process is getting killed.
 138          *
 139          * @param mixed  $x The input content.
 140          * @param string $content_type Type of the input (Default: 'application/json').
 141          */
 142         public static function jsonExit($x, $content_type = 'application/json') {
 143                 header("Content-type: $content_type");
 144                 echo json_encode($x);
 145                 exit();
 146         }
 147
 148         /**
 149          * Generates a random string in the UUID format
 150          *
 151          * @param bool|string $prefix A given prefix (default is empty)
 152          * @return string a generated UUID
 153          * @throws \Exception
 154          */
 155         public static function createUUID($prefix = '')
 156         {
 157                 $guid = System::createGUID(32, $prefix);
 158                 return substr($guid, 0, 8) . '-' . substr($guid, 8, 4) . '-' . substr($guid, 12, 4) . '-' . substr($guid, 16, 4) . '-' . substr($guid, 20, 12);
 159         }
 160
 161         /**
 162          * Generates a GUID with the given parameters
 163          *
 164          * @param int         $size   The size of the GUID (default is 16)
 165          * @param bool|string $prefix A given prefix (default is empty)
 166          * @return string a generated GUID
 167          * @throws \Exception
 168          */
 169         public static function createGUID($size = 16, $prefix = '')
 170         {
 171                 if (is_bool($prefix) && !$prefix) {
 172                         $prefix = '';
 173                 } elseif (empty($prefix)) {
 174                         $prefix = hash('crc32', DI::baseUrl()->getHostname());
 175                 }
 176
 177                 while (strlen($prefix) < ($size - 13)) {
 178                         $prefix .= mt_rand();
 179                 }
 180
 181                 if ($size >= 24) {
 182                         $prefix = substr($prefix, 0, $size - 22);
 183                         return str_replace('.', '', uniqid($prefix, true));
 184                 } else {
 185                         $prefix = substr($prefix, 0, max($size - 13, 0));
 186                         return uniqid($prefix);
 187                 }
 188         }
 189
 190         /**
 191          * Returns the current Load of the System
 192          *
 193          * @return integer
 194          */
 195         public static function currentLoad()
 196         {
 197                 if (!function_exists('sys_getloadavg')) {
 198                         return false;
 199                 }
 200
 201                 $load_arr = sys_getloadavg();
 202
 203                 if (!is_array($load_arr)) {
 204                         return false;
 205                 }
 206
 207                 return max($load_arr[0], $load_arr[1]);
 208         }
 209
 210         /**
 211          * Redirects to an external URL (fully qualified URL)
 212          * If you want to route relative to the current Friendica base, use App->internalRedirect()
 213          *
 214          * @param string $url  The new Location to redirect
 215          * @param int    $code The redirection code, which is used (Default is 302)
 216          *
 217          * @throws InternalServerErrorException If the URL is not fully qualified
 218          */
 219         public static function externalRedirect($url, $code = 302)
 220         {
 221                 if (empty(parse_url($url, PHP_URL_SCHEME))) {
 222                         throw new InternalServerErrorException("'$url' is not a fully qualified URL, please use App->internalRedirect() instead");
 223                 }
 224
 225                 switch ($code) {
 226                         case 302:
 227                                 // this is the default code for a REDIRECT
 228                                 // We don't need a extra header here
 229                                 break;
 230                         case 301:
 231                                 header('HTTP/1.1 301 Moved Permanently');
 232                                 break;
 233                         case 307:
 234                                 header('HTTP/1.1 307 Temporary Redirect');
 235                                 break;
 236                 }
 237
 238                 header("Location: $url");
 239                 exit();
 240         }
 241
 242         /**
 243          * Returns the system user that is executing the script
 244          *
 245          * This mostly returns something like "www-data".
 246          *
 247          * @return string system username
 248          */
 249         public static function getUser()
 250         {
 251                 if (!function_exists('posix_getpwuid') || !function_exists('posix_geteuid')) {
 252                         return '';
 253                 }
 254
 255                 $processUser = posix_getpwuid(posix_geteuid());
 256                 return $processUser['name'];
 257         }
 258
 259         /**
 260          * Checks if a given directory is usable for the system
 261          *
 262          * @param      $directory
 263          * @param bool $check_writable
 264          *
 265          * @return boolean the directory is usable
 266          */
 267         public static function isDirectoryUsable($directory, $check_writable = true)
 268         {
 269                 if ($directory == '') {
 270                         Logger::log('Directory is empty. This shouldn\'t happen.', Logger::DEBUG);
 271                         return false;
 272                 }
 273
 274                 if (!file_exists($directory)) {
 275                         Logger::log('Path "' . $directory . '" does not exist for user ' . static::getUser(), Logger::DEBUG);
 276                         return false;
 277                 }
 278
 279                 if (is_file($directory)) {
 280                         Logger::log('Path "' . $directory . '" is a file for user ' . static::getUser(), Logger::DEBUG);
 281                         return false;
 282                 }
 283
 284                 if (!is_dir($directory)) {
 285                         Logger::log('Path "' . $directory . '" is not a directory for user ' . static::getUser(), Logger::DEBUG);
 286                         return false;
 287                 }
 288
 289                 if ($check_writable && !is_writable($directory)) {
 290                         Logger::log('Path "' . $directory . '" is not writable for user ' . static::getUser(), Logger::DEBUG);
 291                         return false;
 292                 }
 293
 294                 return true;
 295         }
 296
 297         /**
 298          * Exit method used by asynchronous update modules
 299          *
 300          * @param string $o
 301          */
 302         public static function htmlUpdateExit($o)
 303         {
 304                 header("Content-type: text/html");
 305                 echo "<!DOCTYPE html><html><body>\r\n";
 306                 // We can remove this hack once Internet Explorer recognises HTML5 natively
 307                 echo "<section>";
 308                 // reportedly some versions of MSIE don't handle tabs in XMLHttpRequest documents very well
 309                 echo str_replace("\t", "       ", $o);
 310                 echo "</section>";
 311                 echo "</body></html>\r\n";
 312                 exit();
 313         }
 314
 315         /// @todo Move the following functions from boot.php
 316         /*
 317         function local_user()
 318         function public_contact()
 319         function remote_user()
 320         function notice($s)
 321         function info($s)
 322         function is_site_admin()
 323         function get_temppath()
 324         function get_cachefile($file, $writemode = true)
 325         function get_itemcachepath()
 326         function get_spoolpath()
 327         */
 328 }