src/Model/GServer.php

   1 <?php
   2
   3 /**
   4  * @file src/Model/GServer.php
   5  * This file includes the GServer class to handle with servers
   6  */
   7 namespace Friendica\Model;
   8
   9 use DOMDocument;
  10 use DOMXPath;
  11 use Friendica\Core\Config;
  12 use Friendica\Core\Protocol;
  13 use Friendica\Database\DBA;
  14 use Friendica\Module\Register;
  15 use Friendica\Util\Network;
  16 use Friendica\Util\DateTimeFormat;
  17 use Friendica\Util\Strings;
  18 use Friendica\Util\XML;
  19 use Friendica\Core\Logger;
  20 use Friendica\Protocol\PortableContact;
  21 use Friendica\Protocol\Diaspora;
  22 use Friendica\Network\Probe;
  23
  24 /**
  25  * This class handles GServer related functions
  26  */
  27 class GServer
  28 {
  29         /**
  30          * Checks if the given server is reachable
  31          *
  32          * @param string  $profile URL of the given profile
  33          * @param string  $server  URL of the given server (If empty, taken from profile)
  34          * @param string  $network Network value that is used, when detection failed
  35          * @param boolean $force   Force an update.
  36          *
  37          * @return boolean 'true' if server seems vital
  38          */
  39         public static function reachable(string $profile, string $server = '', string $network = '', bool $force = false)
  40         {
  41                 if ($server == '') {
  42                         $server = Contact::getBasepath($profile);
  43                 }
  44
  45                 if ($server == '') {
  46                         return true;
  47                 }
  48
  49                 return self::check($server, $network, $force);
  50         }
  51
  52         /**
  53          * Checks the state of the given server.
  54          *
  55          * @param string  $server_url URL of the given server
  56          * @param string  $network    Network value that is used, when detection failed
  57          * @param boolean $force      Force an update.
  58          *
  59          * @return boolean 'true' if server seems vital
  60          */
  61         public static function check(string $server_url, string $network = '', bool $force = false)
  62         {
  63                 // Unify the server address
  64                 $server_url = trim($server_url, '/');
  65                 $server_url = str_replace('/index.php', '', $server_url);
  66
  67                 if ($server_url == '') {
  68                         return false;
  69                 }
  70
  71                 $gserver = DBA::selectFirst('gserver', [], ['nurl' => Strings::normaliseLink($server_url)]);
  72                 if (DBA::isResult($gserver)) {
  73                         if ($gserver['created'] <= DBA::NULL_DATETIME) {
  74                                 $fields = ['created' => DateTimeFormat::utcNow()];
  75                                 $condition = ['nurl' => Strings::normaliseLink($server_url)];
  76                                 DBA::update('gserver', $fields, $condition);
  77                         }
  78
  79                         $last_contact = $gserver['last_contact'];
  80                         $last_failure = $gserver['last_failure'];
  81
  82                         // See discussion under https://forum.friendi.ca/display/0b6b25a8135aabc37a5a0f5684081633
  83                         // It can happen that a zero date is in the database, but storing it again is forbidden.
  84                         if ($last_contact < DBA::NULL_DATETIME) {
  85                                 $last_contact = DBA::NULL_DATETIME;
  86                         }
  87
  88                         if ($last_failure < DBA::NULL_DATETIME) {
  89                                 $last_failure = DBA::NULL_DATETIME;
  90                         }
  91
  92                         if (!$force && !PortableContact::updateNeeded($gserver['created'], '', $last_failure, $last_contact)) {
  93                                 Logger::info('No update needed', ['server' => $server_url]);
  94                                 return ($last_contact >= $last_failure);
  95                         }
  96                         Logger::info('Server is outdated. Start discovery.', ['Server' => $server_url, 'Force' => $force, 'Created' => $gserver['created'], 'Failure' => $last_failure, 'Contact' => $last_contact]);
  97                 } else {
  98                         Logger::info('Server is unknown. Start discovery.', ['Server' => $server_url]);
  99                 }
 100
 101                 return self::detect($server_url, $network);
 102         }
 103
 104         /**
 105          * Detect server data (type, protocol, version number, ...)
 106          * The detected data is then updated or inserted in the gserver table.
 107          *
 108          * @param string  $url     URL of the given server
 109          * @param string  $network Network value that is used, when detection failed
 110          *
 111          * @return boolean 'true' if server could be detected
 112          */
 113         public static function detect(string $url, string $network = '')
 114         {
 115                 $serverdata = [];
 116
 117                 // When a nodeinfo is present, we don't need to dig further
 118                 $xrd_timeout = Config::get('system', 'xrd_timeout');
 119                 $curlResult = Network::curl($url . '/.well-known/nodeinfo', false, ['timeout' => $xrd_timeout]);
 120                 if ($curlResult->isTimeout()) {
 121                         DBA::update('gserver', ['last_failure' => DateTimeFormat::utcNow()], ['nurl' => Strings::normaliseLink($url)]);
 122                         return false;
 123                 }
 124
 125                 $nodeinfo = self::fetchNodeinfo($url, $curlResult);
 126
 127                 // When nodeinfo isn't present, we use the older 'statistics.json' endpoint
 128                 if (empty($nodeinfo)) {
 129                         $nodeinfo = self::fetchStatistics($url);
 130                 }
 131
 132                 // If that didn't work out well, we use some protocol specific endpoints
 133                 // For Friendica and Zot based networks we have to dive deeper to reveal more details
 134                 if (empty($nodeinfo['network']) || in_array($nodeinfo['network'], [Protocol::DFRN, Protocol::ZOT])) {
 135                         // Fetch the landing page, possibly it reveals some data
 136                         if (empty($nodeinfo['network'])) {
 137                                 $curlResult = Network::curl($url, false, ['timeout' => $xrd_timeout]);
 138                                 if ($curlResult->isSuccess()) {
 139                                         $serverdata = self::analyseRootHeader($curlResult, $serverdata);
 140                                         $serverdata = self::analyseRootBody($curlResult, $serverdata, $url);
 141                                 }
 142
 143                                 if (!$curlResult->isSuccess() || empty($curlResult->getBody())) {
 144                                         DBA::update('gserver', ['last_failure' => DateTimeFormat::utcNow()], ['nurl' => Strings::normaliseLink($url)]);
 145                                         return false;
 146                                 }
 147                         }
 148
 149                         if (empty($serverdata['network']) || ($serverdata['network'] == Protocol::ACTIVITYPUB)) {
 150                                 $serverdata = self::detectMastodonAlikes($url, $serverdata);
 151                         }
 152
 153                         // All following checks are done for systems that always have got a "host-meta" endpoint.
 154                         // With this check we don't have to waste time and ressources for dead systems.
 155                         // Also this hopefully prevents us from receiving abuse messages.
 156                         if (empty($serverdata['network']) && !self::validHostMeta($url)) {
 157                                 DBA::update('gserver', ['last_failure' => DateTimeFormat::utcNow()], ['nurl' => Strings::normaliseLink($url)]);
 158                                 return false;
 159                         }
 160
 161                         if (empty($serverdata['network']) || in_array($serverdata['network'], [Protocol::DFRN, Protocol::ACTIVITYPUB])) {
 162                                 $serverdata = self::detectFriendica($url, $serverdata);
 163                         }
 164
 165                         // the 'siteinfo.json' is some specific endpoint of Hubzilla and Red
 166                         if (empty($serverdata['network']) || ($serverdata['network'] == Protocol::ZOT)) {
 167                                 $serverdata = self::fetchSiteinfo($url, $serverdata);
 168                         }
 169
 170                         // The 'siteinfo.json' doesn't seem to be present on older Hubzilla installations
 171                         if (empty($serverdata['network'])) {
 172                                 $serverdata = self::detectHubzilla($url, $serverdata);
 173                         }
 174
 175                         if (empty($serverdata['network'])) {
 176                                 $serverdata = self::detectNextcloud($url, $serverdata);
 177                         }
 178
 179                         if (empty($serverdata['network'])) {
 180                                 $serverdata = self::detectGNUSocial($url, $serverdata);
 181                         }
 182                 } else {
 183                         $serverdata = $nodeinfo;
 184                 }
 185
 186                 $serverdata = self::checkPoCo($url, $serverdata);
 187
 188                 // We can't detect the network type. Possibly it is some system that we don't know yet
 189                 if (empty($serverdata['network'])) {
 190                         $serverdata['network'] = Protocol::PHANTOM;
 191                 }
 192
 193                 // When we hadn't been able to detect the network type, we use the hint from the parameter
 194                 if (($serverdata['network'] == Protocol::PHANTOM) && !empty($network)) {
 195                         $serverdata['network'] = $network;
 196                 }
 197
 198                 $serverdata['url'] = $url;
 199                 $serverdata['nurl'] = Strings::normaliseLink($url);
 200
 201                 // We take the highest number that we do find
 202                 $registeredUsers = $serverdata['registered-users'] ?? 0;
 203
 204                 // On an active server there has to be at least a single user
 205                 if (($serverdata['network'] != Protocol::PHANTOM) && ($registeredUsers == 0)) {
 206                         $registeredUsers = 1;
 207                 }
 208
 209                 if ($serverdata['network'] != Protocol::PHANTOM) {
 210                         $gcontacts = DBA::count('gcontact', ['server_url' => [$url, $serverdata['nurl']]]);
 211                         $apcontacts = DBA::count('apcontact', ['baseurl' => [$url, $serverdata['nurl']]]);
 212                         $contacts = DBA::count('contact', ['uid' => 0, 'baseurl' => [$url, $serverdata['nurl']]]);
 213                         $serverdata['registered-users'] = max($gcontacts, $apcontacts, $contacts, $registeredUsers);
 214                 } else {
 215                         $serverdata['registered-users'] = $registeredUsers;
 216                         $serverdata = self::detectNetworkViaContacts($url, $serverdata);
 217                 }
 218
 219                 $serverdata['last_contact'] = DateTimeFormat::utcNow();
 220
 221                 $gserver = DBA::selectFirst('gserver', ['network'], ['nurl' => Strings::normaliseLink($url)]);
 222                 if (!DBA::isResult($gserver)) {
 223                         $serverdata['created'] = DateTimeFormat::utcNow();
 224                         $ret = DBA::insert('gserver', $serverdata);
 225                 } else {
 226                         // Don't override the network with 'unknown' when there had been a valid entry before
 227                         if (($serverdata['network'] == Protocol::PHANTOM) && !empty($gserver['network'])) {
 228                                 unset($serverdata['network']);
 229                         }
 230
 231                         $ret = DBA::update('gserver', $serverdata, ['nurl' => $serverdata['nurl']]);
 232                 }
 233
 234                 if (!empty($serverdata['network']) && in_array($serverdata['network'], [Protocol::DFRN, Protocol::DIASPORA])) {
 235                         self::discoverRelay($url);
 236                 }
 237
 238                 return $ret;
 239         }
 240
 241         /**
 242          * Fetch relay data from a given server url
 243          *
 244          * @param string $server_url address of the server
 245          * @throws \Friendica\Network\HTTPException\InternalServerErrorException
 246          */
 247         private static function discoverRelay(string $server_url)
 248         {
 249                 Logger::info('Discover relay data', ['server' => $server_url]);
 250
 251                 $curlResult = Network::curl($server_url . '/.well-known/x-social-relay');
 252                 if (!$curlResult->isSuccess()) {
 253                         return;
 254                 }
 255
 256                 $data = json_decode($curlResult->getBody(), true);
 257                 if (!is_array($data)) {
 258                         return;
 259                 }
 260
 261                 $gserver = DBA::selectFirst('gserver', ['id', 'relay-subscribe', 'relay-scope'], ['nurl' => Strings::normaliseLink($server_url)]);
 262                 if (!DBA::isResult($gserver)) {
 263                         return;
 264                 }
 265
 266                 if (($gserver['relay-subscribe'] != $data['subscribe']) || ($gserver['relay-scope'] != $data['scope'])) {
 267                         $fields = ['relay-subscribe' => $data['subscribe'], 'relay-scope' => $data['scope']];
 268                         DBA::update('gserver', $fields, ['id' => $gserver['id']]);
 269                 }
 270
 271                 DBA::delete('gserver-tag', ['gserver-id' => $gserver['id']]);
 272
 273                 if ($data['scope'] == 'tags') {
 274                         // Avoid duplicates
 275                         $tags = [];
 276                         foreach ($data['tags'] as $tag) {
 277                                 $tag = mb_strtolower($tag);
 278                                 if (strlen($tag) < 100) {
 279                                         $tags[$tag] = $tag;
 280                                 }
 281                         }
 282
 283                         foreach ($tags as $tag) {
 284                                 DBA::insert('gserver-tag', ['gserver-id' => $gserver['id'], 'tag' => $tag], true);
 285                         }
 286                 }
 287
 288                 // Create or update the relay contact
 289                 $fields = [];
 290                 if (isset($data['protocols'])) {
 291                         if (isset($data['protocols']['diaspora'])) {
 292                                 $fields['network'] = Protocol::DIASPORA;
 293
 294                                 if (isset($data['protocols']['diaspora']['receive'])) {
 295                                         $fields['batch'] = $data['protocols']['diaspora']['receive'];
 296                                 } elseif (is_string($data['protocols']['diaspora'])) {
 297                                         $fields['batch'] = $data['protocols']['diaspora'];
 298                                 }
 299                         }
 300
 301                         if (isset($data['protocols']['dfrn'])) {
 302                                 $fields['network'] = Protocol::DFRN;
 303
 304                                 if (isset($data['protocols']['dfrn']['receive'])) {
 305                                         $fields['batch'] = $data['protocols']['dfrn']['receive'];
 306                                 } elseif (is_string($data['protocols']['dfrn'])) {
 307                                         $fields['batch'] = $data['protocols']['dfrn'];
 308                                 }
 309                         }
 310                 }
 311                 Diaspora::setRelayContact($server_url, $fields);
 312         }
 313
 314         /**
 315          * Fetch server data from '/statistics.json' on the given server
 316          *
 317          * @param string $url URL of the given server
 318          *
 319          * @return array server data
 320          */
 321         private static function fetchStatistics(string $url)
 322         {
 323                 $curlResult = Network::curl($url . '/statistics.json');
 324                 if (!$curlResult->isSuccess()) {
 325                         return [];
 326                 }
 327
 328                 $data = json_decode($curlResult->getBody(), true);
 329                 if (empty($data)) {
 330                         return [];
 331                 }
 332
 333                 $serverdata = [];
 334
 335                 if (!empty($data['version'])) {
 336                         $serverdata['version'] = $data['version'];
 337                         // Version numbers on statistics.json are presented with additional info, e.g.:
 338                         // 0.6.3.0-p1702cc1c, 0.6.99.0-p1b9ab160 or 3.4.3-2-1191.
 339                         $serverdata['version'] = preg_replace('=(.+)-(.{4,})=ism', '$1', $serverdata['version']);
 340                 }
 341
 342                 if (!empty($data['name'])) {
 343                         $serverdata['site_name'] = $data['name'];
 344                 }
 345
 346                 if (!empty($data['network'])) {
 347                         $serverdata['platform'] = $data['network'];
 348
 349                         if ($serverdata['platform'] == 'Diaspora') {
 350                                 $serverdata['network'] = Protocol::DIASPORA;
 351                         } elseif ($serverdata['platform'] == 'Friendica') {
 352                                 $serverdata['network'] = Protocol::DFRN;
 353                         } elseif ($serverdata['platform'] == 'hubzilla') {
 354                                 $serverdata['network'] = Protocol::ZOT;
 355                         } elseif ($serverdata['platform'] == 'redmatrix') {
 356                                 $serverdata['network'] = Protocol::ZOT;
 357                         }
 358                 }
 359
 360
 361                 if (!empty($data['registrations_open'])) {
 362                         $serverdata['register_policy'] = Register::OPEN;
 363                 } else {
 364                         $serverdata['register_policy'] = Register::CLOSED;
 365                 }
 366
 367                 return $serverdata;
 368         }
 369
 370         /**
 371          * Detect server type by using the nodeinfo data
 372          *
 373          * @param string $url address of the server
 374          * @return array Server data
 375          * @throws \Friendica\Network\HTTPException\InternalServerErrorException
 376          */
 377         private static function fetchNodeinfo(string $url, $curlResult)
 378         {
 379                 $nodeinfo = json_decode($curlResult->getBody(), true);
 380
 381                 if (!is_array($nodeinfo) || empty($nodeinfo['links'])) {
 382                         return [];
 383                 }
 384
 385                 $nodeinfo1_url = '';
 386                 $nodeinfo2_url = '';
 387
 388                 foreach ($nodeinfo['links'] as $link) {
 389                         if (!is_array($link) || empty($link['rel']) || empty($link['href'])) {
 390                                 Logger::info('Invalid nodeinfo format', ['url' => $url]);
 391                                 continue;
 392                         }
 393                         if ($link['rel'] == 'http://nodeinfo.diaspora.software/ns/schema/1.0') {
 394                                 $nodeinfo1_url = $link['href'];
 395                         } elseif ($link['rel'] == 'http://nodeinfo.diaspora.software/ns/schema/2.0') {
 396                                 $nodeinfo2_url = $link['href'];
 397                         }
 398                 }
 399
 400                 if ($nodeinfo1_url . $nodeinfo2_url == '') {
 401                         return [];
 402                 }
 403
 404                 $server = [];
 405
 406                 // When the nodeinfo url isn't on the same host, then there is obviously something wrong
 407                 if (!empty($nodeinfo2_url) && (parse_url($url, PHP_URL_HOST) == parse_url($nodeinfo2_url, PHP_URL_HOST))) {
 408                         $server = self::parseNodeinfo2($nodeinfo2_url);
 409                 }
 410
 411                 // When the nodeinfo url isn't on the same host, then there is obviously something wrong
 412                 if (empty($server) && !empty($nodeinfo1_url) && (parse_url($url, PHP_URL_HOST) == parse_url($nodeinfo1_url, PHP_URL_HOST))) {
 413                         $server = self::parseNodeinfo1($nodeinfo1_url);
 414                 }
 415
 416                 return $server;
 417         }
 418
 419         /**
 420          * Parses Nodeinfo 1
 421          *
 422          * @param string $nodeinfo_url address of the nodeinfo path
 423          * @return array Server data
 424          * @throws \Friendica\Network\HTTPException\InternalServerErrorException
 425          */
 426         private static function parseNodeinfo1(string $nodeinfo_url)
 427         {
 428                 $curlResult = Network::curl($nodeinfo_url);
 429
 430                 if (!$curlResult->isSuccess()) {
 431                         return [];
 432                 }
 433
 434                 $nodeinfo = json_decode($curlResult->getBody(), true);
 435
 436                 if (!is_array($nodeinfo)) {
 437                         return [];
 438                 }
 439
 440                 $server = [];
 441
 442                 $server['register_policy'] = Register::CLOSED;
 443
 444                 if (!empty($nodeinfo['openRegistrations'])) {
 445                         $server['register_policy'] = Register::OPEN;
 446                 }
 447
 448                 if (is_array($nodeinfo['software'])) {
 449                         if (!empty($nodeinfo['software']['name'])) {
 450                                 $server['platform'] = $nodeinfo['software']['name'];
 451                         }
 452
 453                         if (!empty($nodeinfo['software']['version'])) {
 454                                 $server['version'] = $nodeinfo['software']['version'];
 455                                 // Version numbers on Nodeinfo are presented with additional info, e.g.:
 456                                 // 0.6.3.0-p1702cc1c, 0.6.99.0-p1b9ab160 or 3.4.3-2-1191.
 457                                 $server['version'] = preg_replace('=(.+)-(.{4,})=ism', '$1', $server['version']);
 458                         }
 459                 }
 460
 461                 if (!empty($nodeinfo['metadata']['nodeName'])) {
 462                         $server['site_name'] = $nodeinfo['metadata']['nodeName'];
 463                 }
 464
 465                 if (!empty($nodeinfo['usage']['users']['total'])) {
 466                         $server['registered-users'] = $nodeinfo['usage']['users']['total'];
 467                 }
 468
 469                 if (!empty($nodeinfo['protocols']['inbound']) && is_array($nodeinfo['protocols']['inbound'])) {
 470                         $protocols = [];
 471                         foreach ($nodeinfo['protocols']['inbound'] as $protocol) {
 472                                 $protocols[$protocol] = true;
 473                         }
 474
 475                         if (!empty($protocols['friendica'])) {
 476                                 $server['network'] = Protocol::DFRN;
 477                         } elseif (!empty($protocols['activitypub'])) {
 478                                 $server['network'] = Protocol::ACTIVITYPUB;
 479                         } elseif (!empty($protocols['diaspora'])) {
 480                                 $server['network'] = Protocol::DIASPORA;
 481                         } elseif (!empty($protocols['ostatus'])) {
 482                                 $server['network'] = Protocol::OSTATUS;
 483                         } elseif (!empty($protocols['gnusocial'])) {
 484                                 $server['network'] = Protocol::OSTATUS;
 485                         } elseif (!empty($protocols['zot'])) {
 486                                 $server['network'] = Protocol::ZOT;
 487                         }
 488                 }
 489
 490                 if (empty($server)) {
 491                         return [];
 492                 }
 493
 494                 return $server;
 495         }
 496
 497         /**
 498          * Parses Nodeinfo 2
 499          *
 500          * @param string $nodeinfo_url address of the nodeinfo path
 501          * @return array Server data
 502          * @throws \Friendica\Network\HTTPException\InternalServerErrorException
 503          */
 504         private static function parseNodeinfo2(string $nodeinfo_url)
 505         {
 506                 $curlResult = Network::curl($nodeinfo_url);
 507                 if (!$curlResult->isSuccess()) {
 508                         return [];
 509                 }
 510
 511                 $nodeinfo = json_decode($curlResult->getBody(), true);
 512
 513                 if (!is_array($nodeinfo)) {
 514                         return [];
 515                 }
 516
 517                 $server = [];
 518
 519                 $server['register_policy'] = Register::CLOSED;
 520
 521                 if (!empty($nodeinfo['openRegistrations'])) {
 522                         $server['register_policy'] = Register::OPEN;
 523                 }
 524
 525                 if (is_array($nodeinfo['software'])) {
 526                         if (!empty($nodeinfo['software']['name'])) {
 527                                 $server['platform'] = $nodeinfo['software']['name'];
 528                         }
 529
 530                         if (!empty($nodeinfo['software']['version'])) {
 531                                 $server['version'] = $nodeinfo['software']['version'];
 532                                 // Version numbers on Nodeinfo are presented with additional info, e.g.:
 533                                 // 0.6.3.0-p1702cc1c, 0.6.99.0-p1b9ab160 or 3.4.3-2-1191.
 534                                 $server['version'] = preg_replace('=(.+)-(.{4,})=ism', '$1', $server['version']);
 535                         }
 536                 }
 537
 538                 if (!empty($nodeinfo['metadata']['nodeName'])) {
 539                         $server['site_name'] = $nodeinfo['metadata']['nodeName'];
 540                 }
 541
 542                 if (!empty($nodeinfo['usage']['users']['total'])) {
 543                         $server['registered-users'] = $nodeinfo['usage']['users']['total'];
 544                 }
 545
 546                 if (!empty($nodeinfo['protocols'])) {
 547                         $protocols = [];
 548                         foreach ($nodeinfo['protocols'] as $protocol) {
 549                                 $protocols[$protocol] = true;
 550                         }
 551
 552                         if (!empty($protocols['friendica'])) {
 553                                 $server['network'] = Protocol::DFRN;
 554                         } elseif (!empty($protocols['activitypub'])) {
 555                                 $server['network'] = Protocol::ACTIVITYPUB;
 556                         } elseif (!empty($protocols['diaspora'])) {
 557                                 $server['network'] = Protocol::DIASPORA;
 558                         } elseif (!empty($protocols['ostatus'])) {
 559                                 $server['network'] = Protocol::OSTATUS;
 560                         } elseif (!empty($protocols['gnusocial'])) {
 561                                 $server['network'] = Protocol::OSTATUS;
 562                         } elseif (!empty($protocols['zot'])) {
 563                                 $server['network'] = Protocol::ZOT;
 564                         }
 565                 }
 566
 567                 if (empty($server)) {
 568                         return [];
 569                 }
 570
 571                 return $server;
 572         }
 573
 574         /**
 575          * Fetch server information from a 'siteinfo.json' file on the given server
 576          *
 577          * @param string $url        URL of the given server
 578          * @param array  $serverdata array with server data
 579          *
 580          * @return array server data
 581          */
 582         private static function fetchSiteinfo(string $url, array $serverdata)
 583         {
 584                 $curlResult = Network::curl($url . '/siteinfo.json');
 585                 if (!$curlResult->isSuccess()) {
 586                         return $serverdata;
 587                 }
 588
 589                 $data = json_decode($curlResult->getBody(), true);
 590                 if (empty($data)) {
 591                         return $serverdata;
 592                 }
 593
 594                 if (!empty($data['url'])) {
 595                         $serverdata['platform'] = $data['platform'];
 596                         $serverdata['version'] = $data['version'];
 597                 }
 598
 599                 if (!empty($data['plugins'])) {
 600                         if (in_array('pubcrawl', $data['plugins'])) {
 601                                 $serverdata['network'] = Protocol::ACTIVITYPUB;
 602                         } elseif (in_array('diaspora', $data['plugins'])) {
 603                                 $serverdata['network'] = Protocol::DIASPORA;
 604                         } elseif (in_array('gnusoc', $data['plugins'])) {
 605                                 $serverdata['network'] = Protocol::OSTATUS;
 606                         } else {
 607                                 $serverdata['network'] = Protocol::ZOT;
 608                         }
 609                 }
 610
 611                 if (!empty($data['site_name'])) {
 612                         $serverdata['site_name'] = $data['site_name'];
 613                 }
 614
 615                 if (!empty($data['channels_total'])) {
 616                         $serverdata['registered-users'] = $data['channels_total'];
 617                 }
 618
 619                 if (!empty($data['register_policy'])) {
 620                         switch ($data['register_policy']) {
 621                                 case 'REGISTER_OPEN':
 622                                         $serverdata['register_policy'] = Register::OPEN;
 623                                         break;
 624
 625                                 case 'REGISTER_APPROVE':
 626                                         $serverdata['register_policy'] = Register::APPROVE;
 627                                         break;
 628
 629                                 case 'REGISTER_CLOSED':
 630                                 default:
 631                                         $serverdata['register_policy'] = Register::CLOSED;
 632                                         break;
 633                         }
 634                 }
 635
 636                 return $serverdata;
 637         }
 638
 639         /**
 640          * Checks if the server contains a valid host meta file
 641          *
 642          * @param string $url URL of the given server
 643          *
 644          * @return boolean 'true' if the server seems to be vital
 645          */
 646         private static function validHostMeta(string $url)
 647         {
 648                 $xrd_timeout = Config::get('system', 'xrd_timeout');
 649                 $curlResult = Network::curl($url . '/.well-known/host-meta', false, ['timeout' => $xrd_timeout]);
 650                 if (!$curlResult->isSuccess()) {
 651                         return false;
 652                 }
 653
 654                 $xrd = XML::parseString($curlResult->getBody(), false);
 655                 if (!is_object($xrd)) {
 656                         return false;
 657                 }
 658
 659                 $elements = XML::elementToArray($xrd);
 660                 if (empty($elements) || empty($elements['xrd']) || empty($elements['xrd']['link'])) {
 661                         return false;
 662                 }
 663
 664                 $valid = false;
 665                 foreach ($elements['xrd']['link'] as $link) {
 666                         // When there is more than a single "link" element, the array looks slightly different
 667                         if (!empty($link['@attributes'])) {
 668                                 $link = $link['@attributes'];
 669                         }
 670
 671                         if (empty($link['rel']) || empty($link['template'])) {
 672                                 continue;
 673                         }
 674
 675                         if ($link['rel'] == 'lrdd') {
 676                                 // When the webfinger host is the same like the system host, it should be ok.
 677                                 $valid = (parse_url($url, PHP_URL_HOST) == parse_url($link['template'], PHP_URL_HOST));
 678                         }
 679                 }
 680
 681                 return $valid;
 682         }
 683
 684         /**
 685          * Detect the network of the given server via their known contacts
 686          *
 687          * @param string $url        URL of the given server
 688          * @param array  $serverdata array with server data
 689          *
 690          * @return array server data
 691          */
 692         private static function detectNetworkViaContacts(string $url, array $serverdata)
 693         {
 694                 $contacts = [];
 695
 696                 $gcontacts = DBA::select('gcontact', ['url', 'nurl'], ['server_url' => [$url, $serverdata['nurl']]]);
 697                 while ($gcontact = DBA::fetch($gcontacts)) {
 698                         $contacts[$gcontact['nurl']] = $gcontact['url'];
 699                 }
 700                 DBA::close($gcontacts);
 701
 702                 $apcontacts = DBA::select('apcontact', ['url'], ['baseurl' => [$url, $serverdata['nurl']]]);
 703                 while ($gcontact = DBA::fetch($gcontacts)) {
 704                         $contacts[Strings::normaliseLink($apcontact['url'])] = $apcontact['url'];
 705                 }
 706                 DBA::close($apcontacts);
 707
 708                 $pcontacts = DBA::select('contact', ['url', 'nurl'], ['uid' => 0, 'baseurl' => [$url, $serverdata['nurl']]]);
 709                 while ($gcontact = DBA::fetch($gcontacts)) {
 710                         $contacts[$pcontact['nurl']] = $pcontact['url'];
 711                 }
 712                 DBA::close($pcontacts);
 713
 714                 if (empty($contacts)) {
 715                         return $serverdata;
 716                 }
 717
 718                 foreach ($contacts as $contact) {
 719                         $probed = Probe::uri($contact);
 720                         if (in_array($probed['network'], Protocol::FEDERATED)) {
 721                                 $serverdata['network'] = $probed['network'];
 722                                 break;
 723                         }
 724                 }
 725
 726                 $serverdata['registered-users'] = max($serverdata['registered-users'], count($contacts));
 727
 728                 return $serverdata;
 729         }
 730
 731         /**
 732          * Checks if the given server does have a '/poco' endpoint.
 733          * This is used for the 'PortableContact' functionality,
 734          * which is used by both Friendica and Hubzilla.
 735          *
 736          * @param string $url        URL of the given server
 737          * @param array  $serverdata array with server data
 738          *
 739          * @return array server data
 740          */
 741         private static function checkPoCo(string $url, array $serverdata)
 742         {
 743                 $curlResult = Network::curl($url. '/poco');
 744                 if (!$curlResult->isSuccess()) {
 745                         return $serverdata;
 746                 }
 747
 748                 $data = json_decode($curlResult->getBody(), true);
 749                 if (empty($data)) {
 750                         return $serverdata;
 751                 }
 752
 753                 if (!empty($data['totalResults'])) {
 754                         $registeredUsers = $serverdata['registered-users'] ?? 0;
 755                         $serverdata['registered-users'] = max($data['totalResults'], $registeredUsers);
 756                         $serverdata['poco'] = $url . '/poco';
 757                 } else {
 758                         $serverdata['poco'] = '';
 759                 }
 760
 761                 return $serverdata;
 762         }
 763
 764         /**
 765          * Detects the version number of a given server when it was a NextCloud installation
 766          *
 767          * @param string $url        URL of the given server
 768          * @param array  $serverdata array with server data
 769          *
 770          * @return array server data
 771          */
 772         private static function detectNextcloud(string $url, array $serverdata)
 773         {
 774                 $curlResult = Network::curl($url . '/status.php');
 775
 776                 if (!$curlResult->isSuccess() || ($curlResult->getBody() == '')) {
 777                         return $serverdata;
 778                 }
 779
 780                 $data = json_decode($curlResult->getBody(), true);
 781                 if (empty($data)) {
 782                         return $serverdata;
 783                 }
 784
 785                 if (!empty($data['version'])) {
 786                         $serverdata['platform'] = 'nextcloud';
 787                         $serverdata['version'] = $data['version'];
 788                         $serverdata['network'] = Protocol::ACTIVITYPUB;
 789                 }
 790
 791                 return $serverdata;
 792         }
 793
 794         /**
 795          * Detects data from a given server url if it was a mastodon alike system
 796          *
 797          * @param string $url        URL of the given server
 798          * @param array  $serverdata array with server data
 799          *
 800          * @return array server data
 801          */
 802         private static function detectMastodonAlikes(string $url, array $serverdata)
 803         {
 804                 $curlResult = Network::curl($url . '/api/v1/instance');
 805
 806                 if (!$curlResult->isSuccess() || ($curlResult->getBody() == '')) {
 807                         return $serverdata;
 808                 }
 809
 810                 $data = json_decode($curlResult->getBody(), true);
 811                 if (empty($data)) {
 812                         return $serverdata;
 813                 }
 814
 815                 if (!empty($data['version'])) {
 816                         $serverdata['platform'] = 'mastodon';
 817                         $serverdata['version'] = $data['version'] ?? '';
 818                         $serverdata['network'] = Protocol::ACTIVITYPUB;
 819                 }
 820
 821                 if (!empty($data['title'])) {
 822                         $serverdata['site_name'] = $data['title'];
 823                 }
 824
 825                 if (!empty($data['description'])) {
 826                         $serverdata['info'] = trim($data['description']);
 827                 }
 828
 829                 if (!empty($data['stats']['user_count'])) {
 830                         $serverdata['registered-users'] = $data['stats']['user_count'];
 831                 }
 832
 833                 if (!empty($serverdata['version']) && preg_match('/.*?\(compatible;\s(.*)\s(.*)\)/ism', $serverdata['version'], $matches)) {
 834                         $serverdata['platform'] = $matches[1];
 835                         $serverdata['version'] = $matches[2];
 836                 }
 837
 838                 if (!empty($serverdata['version']) && strstr($serverdata['version'], 'Pleroma')) {
 839                         $serverdata['platform'] = 'pleroma';
 840                         $serverdata['version'] = trim(str_replace('Pleroma', '', $serverdata['version']));
 841                 }
 842
 843                 return $serverdata;
 844         }
 845
 846         /**
 847          * Detects data from typical Hubzilla endpoints
 848          *
 849          * @param string $url        URL of the given server
 850          * @param array  $serverdata array with server data
 851          *
 852          * @return array server data
 853          */
 854         private static function detectHubzilla(string $url, array $serverdata)
 855         {
 856                 $curlResult = Network::curl($url . '/api/statusnet/config.json');
 857                 if (!$curlResult->isSuccess() || ($curlResult->getBody() == '')) {
 858                         return $serverdata;
 859                 }
 860
 861                 $data = json_decode($curlResult->getBody(), true);
 862                 if (empty($data)) {
 863                         return $serverdata;
 864                 }
 865
 866                 if (!empty($data['site']['name'])) {
 867                         $serverdata['site_name'] = $data['site']['name'];
 868                 }
 869
 870                 if (!empty($data['site']['platform'])) {
 871                         $serverdata['platform'] = $data['site']['platform']['PLATFORM_NAME'];
 872                         $serverdata['version'] = $data['site']['platform']['STD_VERSION'];
 873                         $serverdata['network'] = Protocol::ZOT;
 874                 }
 875
 876                 if (!empty($data['site']['hubzilla'])) {
 877                         $serverdata['platform'] = $data['site']['hubzilla']['PLATFORM_NAME'];
 878                         $serverdata['version'] = $data['site']['hubzilla']['RED_VERSION'];
 879                         $serverdata['network'] = Protocol::ZOT;
 880                 }
 881
 882                 if (!empty($data['site']['redmatrix'])) {
 883                         if (!empty($data['site']['redmatrix']['PLATFORM_NAME'])) {
 884                                 $serverdata['platform'] = $data['site']['redmatrix']['PLATFORM_NAME'];
 885                         } elseif (!empty($data['site']['redmatrix']['RED_PLATFORM'])) {
 886                                 $serverdata['platform'] = $data['site']['redmatrix']['RED_PLATFORM'];
 887                         }
 888
 889                         $serverdata['version'] = $data['site']['redmatrix']['RED_VERSION'];
 890                         $serverdata['network'] = Protocol::ZOT;
 891                 }
 892
 893                 $private = false;
 894                 $inviteonly = false;
 895                 $closed = false;
 896
 897                 if (!empty($data['site']['closed'])) {
 898                         $closed = self::toBoolean($data['site']['closed']);
 899                 }
 900
 901                 if (!empty($data['site']['private'])) {
 902                         $private = self::toBoolean($data['site']['private']);
 903                 }
 904
 905                 if (!empty($data['site']['inviteonly'])) {
 906                         $inviteonly = self::toBoolean($data['site']['inviteonly']);
 907                 }
 908
 909                 if (!$closed && !$private and $inviteonly) {
 910                         $register_policy = Register::APPROVE;
 911                 } elseif (!$closed && !$private) {
 912                         $register_policy = Register::OPEN;
 913                 } else {
 914                         $register_policy = Register::CLOSED;
 915                 }
 916
 917                 return $serverdata;
 918         }
 919
 920         /**
 921          * Converts input value to a boolean value
 922          *
 923          * @param string|integer $val
 924          *
 925          * @return boolean
 926          */
 927         private static function toBoolean($val)
 928         {
 929                 if (($val == 'true') || ($val == 1)) {
 930                         return true;
 931                 } elseif (($val == 'false') || ($val == 0)) {
 932                         return false;
 933                 }
 934
 935                 return $val;
 936         }
 937
 938         /**
 939          * Detect if the URL belongs to a GNU Social server
 940          *
 941          * @param string $url        URL of the given server
 942          * @param array  $serverdata array with server data
 943          *
 944          * @return array server data
 945          */
 946         private static function detectGNUSocial(string $url, array $serverdata)
 947         {
 948                 // Test for GNU Social
 949                 $curlResult = Network::curl($url . '/api/gnusocial/version.json');
 950                 if ($curlResult->isSuccess() && ($curlResult->getBody() != '{"error":"not implemented"}') &&
 951                         ($curlResult->getBody() != '') && (strlen($curlResult->getBody()) < 30)) {
 952                         $serverdata['platform'] = 'gnusocial';
 953                         // Remove junk that some GNU Social servers return
 954                         $serverdata['version'] = str_replace(chr(239) . chr(187) . chr(191), '', $curlResult->getBody());
 955                         $serverdata['version'] = trim($serverdata['version'], '"');
 956                         $serverdata['network'] = Protocol::OSTATUS;
 957                         return $serverdata;
 958                 }
 959
 960                 // Test for Statusnet
 961                 $curlResult = Network::curl($url . '/api/statusnet/version.json');
 962                 if ($curlResult->isSuccess() && ($curlResult->getBody() != '{"error":"not implemented"}') &&
 963                         ($curlResult->getBody() != '') && (strlen($curlResult->getBody()) < 30)) {
 964                         $serverdata['platform'] = 'statusnet';
 965                         // Remove junk that some GNU Social servers return
 966                         $serverdata['version'] = str_replace(chr(239).chr(187).chr(191), '', $curlResult->getBody());
 967                         $serverdata['version'] = trim($serverdata['version'], '"');
 968                         $serverdata['network'] = Protocol::OSTATUS;
 969                 }
 970
 971                 return $serverdata;
 972         }
 973
 974         /**
 975          * Detect if the URL belongs to a Friendica server
 976          *
 977          * @param string $url        URL of the given server
 978          * @param array  $serverdata array with server data
 979          *
 980          * @return array server data
 981          */
 982         private static function detectFriendica(string $url, array $serverdata)
 983         {
 984                 $curlResult = Network::curl($url . '/friendica/json');
 985                 if (!$curlResult->isSuccess()) {
 986                         $curlResult = Network::curl($url . '/friendika/json');
 987                 }
 988
 989                 if (!$curlResult->isSuccess()) {
 990                         return $serverdata;
 991                 }
 992
 993                 $data = json_decode($curlResult->getBody(), true);
 994                 if (empty($data) || empty($data['version'])) {
 995                         return $serverdata;
 996                 }
 997
 998                 $serverdata['network'] = Protocol::DFRN;
 999                 $serverdata['version'] = $data['version'];
1000
1001                 if (!empty($data['no_scrape_url'])) {
1002                         $serverdata['noscrape'] = $data['no_scrape_url'];
1003                 }
1004
1005                 if (!empty($data['site_name'])) {
1006                         $serverdata['site_name'] = $data['site_name'];
1007                 }
1008
1009                 if (!empty($data['info'])) {
1010                         $serverdata['info'] = trim($data['info']);
1011                 }
1012
1013                 $register_policy = ($data['register_policy'] ?? '') ?: 'REGISTER_CLOSED';
1014                 switch ($register_policy) {
1015                         case 'REGISTER_OPEN':
1016                                 $serverdata['register_policy'] = Register::OPEN;
1017                                 break;
1018
1019                         case 'REGISTER_APPROVE':
1020                                 $serverdata['register_policy'] = Register::APPROVE;
1021                                 break;
1022
1023                         case 'REGISTER_CLOSED':
1024                         case 'REGISTER_INVITATION':
1025                                 $serverdata['register_policy'] = Register::CLOSED;
1026                                 break;
1027                         default:
1028                                 Logger::info('Register policy is invalid', ['policy' => $register_policy, 'server' => $url]);
1029                                 $serverdata['register_policy'] = Register::CLOSED;
1030                                 break;
1031                 }
1032
1033                 $serverdata['platform'] = $data['platform'] ?? '';
1034
1035                 return $serverdata;
1036         }
1037
1038         /**
1039          * Analyses the landing page of a given server for hints about type and system of that server
1040          *
1041          * @param object $curlResult result of curl execution
1042          * @param array  $serverdata array with server data
1043          * @param string $url        Server URL
1044          *
1045          * @return array server data
1046          */
1047         private static function analyseRootBody($curlResult, array $serverdata, string $url)
1048         {
1049                 $doc = new DOMDocument();
1050                 @$doc->loadHTML($curlResult->getBody());
1051                 $xpath = new DOMXPath($doc);
1052
1053                 $title = trim(XML::getFirstNodeValue($xpath, '//head/title/text()'));
1054                 if (!empty($title)) {
1055                         $serverdata['site_name'] = $title;
1056                 }
1057
1058                 $list = $xpath->query('//meta[@name]');
1059
1060                 foreach ($list as $node) {
1061                         $attr = [];
1062                         if ($node->attributes->length) {
1063                                 foreach ($node->attributes as $attribute) {
1064                                         $value = trim($attribute->value);
1065                                         if (empty($value)) {
1066                                                 continue;
1067                                         }
1068
1069                                         $attr[$attribute->name] = $value;
1070                                 }
1071
1072                                 if (empty($attr['name']) || empty($attr['content'])) {
1073                                         continue;
1074                                 }
1075                         }
1076
1077                         if ($attr['name'] == 'description') {
1078                                 $serverdata['info'] = $attr['content'];
1079                         }
1080
1081                         if ($attr['name'] == 'application-name') {
1082                                 $serverdata['platform'] = $attr['content'];
1083                                 if (in_array($attr['content'], ['Misskey', 'Write.as'])) {
1084                                         $serverdata['network'] = Protocol::ACTIVITYPUB;
1085                                 }
1086                         }
1087
1088                         if ($attr['name'] == 'generator') {
1089                                 $serverdata['platform'] = $attr['content'];
1090
1091                                 $version_part = explode(' ', $attr['content']);
1092
1093                                 if (count($version_part) == 2) {
1094                                         if (in_array($version_part[0], ['WordPress'])) {
1095                                                 $serverdata['platform'] = $version_part[0];
1096                                                 $serverdata['version'] = $version_part[1];
1097
1098                                                 // We still do need a reliable test if some AP plugin is activated
1099                                                 if (DBA::exists('apcontact', ['baseurl' => $url])) {
1100                                                         $serverdata['network'] = Protocol::ACTIVITYPUB;
1101                                                 } else {
1102                                                         $serverdata['network'] = Protocol::FEED;
1103                                                 }
1104                                         }
1105                                         if (in_array($version_part[0], ['Friendika', 'Friendica'])) {
1106                                                 $serverdata['platform'] = $version_part[0];
1107                                                 $serverdata['version'] = $version_part[1];
1108                                                 $serverdata['network'] = Protocol::DFRN;
1109                                         }
1110                                 }
1111                         }
1112                 }
1113
1114                 $list = $xpath->query('//meta[@property]');
1115
1116                 foreach ($list as $node) {
1117                         $attr = [];
1118                         if ($node->attributes->length) {
1119                                 foreach ($node->attributes as $attribute) {
1120                                         $value = trim($attribute->value);
1121                                         if (empty($value)) {
1122                                                 continue;
1123                                         }
1124
1125                                         $attr[$attribute->name] = $value;
1126                                 }
1127
1128                                 if (empty($attr['property']) || empty($attr['content'])) {
1129                                         continue;
1130                                 }
1131                         }
1132
1133                         if ($attr['property'] == 'og:site_name') {
1134                                 $serverdata['site_name'] = $attr['content'];
1135                         }
1136
1137                         if ($attr['property'] == 'og:description') {
1138                                 $serverdata['info'] = $attr['content'];
1139                         }
1140
1141                         if ($attr['property'] == 'og:platform') {
1142                                 $serverdata['platform'] = $attr['content'];
1143
1144                                 if (in_array($attr['content'], ['PeerTube'])) {
1145                                         $serverdata['network'] = Protocol::ACTIVITYPUB;
1146                                 }
1147                         }
1148
1149                         if ($attr['property'] == 'generator') {
1150                                 $serverdata['platform'] = $attr['content'];
1151
1152                                 if (in_array($attr['content'], ['hubzilla'])) {
1153                                         // We later check which compatible protocol modules are loaded.
1154                                         $serverdata['network'] = Protocol::ZOT;
1155                                 }
1156                         }
1157                 }
1158
1159                 return $serverdata;
1160         }
1161
1162         /**
1163          * Analyses the header data of a given server for hints about type and system of that server
1164          *
1165          * @param object $curlResult result of curl execution
1166          * @param array  $serverdata array with server data
1167          *
1168          * @return array server data
1169          */
1170         private static function analyseRootHeader($curlResult, array $serverdata)
1171         {
1172                 if ($curlResult->getHeader('server') == 'Mastodon') {
1173                         $serverdata['platform'] = 'mastodon';
1174                         $serverdata['network'] = $network = Protocol::ACTIVITYPUB;
1175                 } elseif ($curlResult->inHeader('x-diaspora-version')) {
1176                         $serverdata['platform'] = 'diaspora';
1177                         $serverdata['network'] = $network = Protocol::DIASPORA;
1178                         $serverdata['version'] = $curlResult->getHeader('x-diaspora-version');
1179
1180                 } elseif ($curlResult->inHeader('x-friendica-version')) {
1181                         $serverdata['platform'] = 'friendica';
1182                         $serverdata['network'] = $network = Protocol::DFRN;
1183                         $serverdata['version'] = $curlResult->getHeader('x-friendica-version');
1184                 }
1185                 return $serverdata;
1186         }
1187 }