src/Model/GServer.php

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