src/Module/Diaspora/Receive.php

   1 <?php
   2 /**
   3  * @copyright Copyright (C) 2010-2022, the Friendica project
   4  *
   5  * @license GNU AGPL version 3 or any later version
   6  *
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as
   9  * published by the Free Software Foundation, either version 3 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  19  *
  20  */
  21
  22 namespace Friendica\Module\Diaspora;
  23
  24 use Friendica\App;
  25 use Friendica\BaseModule;
  26 use Friendica\Core\Config\Capability\IManageConfigValues;
  27 use Friendica\Core\L10n;
  28 use Friendica\Model\User;
  29 use Friendica\Module\Response;
  30 use Friendica\Network\HTTPException;
  31 use Friendica\Protocol\Diaspora;
  32 use Friendica\Util\Network;
  33 use Friendica\Util\Profiler;
  34 use Psr\Log\LoggerInterface;
  35
  36 /**
  37  * This module is part of the Diaspora protocol.
  38  * It is used for receiving single posts either for public or for a specific user.
  39  */
  40 class Receive extends BaseModule
  41 {
  42         /** @var IManageConfigValues */
  43         protected $config;
  44
  45         public function __construct(L10n $l10n, App\BaseURL $baseUrl, App\Arguments $args, LoggerInterface $logger, Profiler $profiler, Response $response, IManageConfigValues $config, array $server, array $parameters = [])
  46         {
  47                 parent::__construct($l10n, $baseUrl, $args, $logger, $profiler, $response, $server, $parameters);
  48
  49                 $this->config = $config;
  50         }
  51
  52         protected function post(array $request = [])
  53         {
  54                 $enabled = $this->config->get('system', 'diaspora_enabled', false);
  55                 if (!$enabled) {
  56                         $this->logger->info('Diaspora disabled.');
  57                         throw new HTTPException\ForbiddenException($this->t('Access denied.'));
  58                 }
  59
  60                 if ($this->parameters['type'] === 'public') {
  61                         $this->receivePublic();
  62                 } else if ($this->parameters['type'] === 'users') {
  63                         $this->receiveUser();
  64                 }
  65         }
  66
  67         /**
  68          * Receive a public Diaspora posting
  69          *
  70          * @throws HTTPException\InternalServerErrorException
  71          * @throws \ImagickException
  72          */
  73         private  function receivePublic()
  74         {
  75                 $this->logger->info('Diaspora: Receiving post.');
  76
  77                 $msg = $this->decodePost();
  78
  79                 $this->logger->info('Diaspora: Dispatching.');
  80
  81                 Diaspora::dispatchPublic($msg, Diaspora::PUSHED);
  82         }
  83
  84         /**
  85          * Receive a Diaspora posting for a user
  86          *
  87          * @throws HTTPException\InternalServerErrorException
  88          * @throws \ImagickException
  89          */
  90         private function receiveUser()
  91         {
  92                 $this->logger->info('Diaspora: Receiving post.');
  93
  94                 $importer = User::getByGuid($this->parameters['guid']);
  95                 if (empty($importer)) {
  96                         // We haven't found the user.
  97                         // To avoid the remote system trying again we send the message that we accepted the content.
  98                         throw new HTTPException\AcceptedException();
  99                 }
 100
 101                 if ($importer['account-type'] == User::ACCOUNT_TYPE_COMMUNITY) {
 102                         // Communities aren't working with the Diaspora protoccol
 103                         // We throw an "accepted" here, so that the sender doesn't repeat the delivery
 104                         throw new HTTPException\AcceptedException();
 105                 }
 106
 107                 $msg = $this->decodePost(false, $importer['prvkey']);
 108
 109                 $this->logger->info('Diaspora: Dispatching.');
 110
 111                 if (Diaspora::dispatch($importer, $msg)) {
 112                         throw new HTTPException\OKException();
 113                 } else {
 114                         // We couldn't process the content.
 115                         // To avoid the remote system trying again we send the message that we accepted the content.
 116                         throw new HTTPException\AcceptedException();
 117                 }
 118         }
 119
 120         /**
 121          * Decodes a Diaspora message based on the posted data
 122          *
 123          * @param string $privKey The private key of the importer
 124          * @param bool   $public  True, if the post is public
 125          *
 126          * @return array
 127          * @throws HTTPException\InternalServerErrorException
 128          * @throws \ImagickException
 129          */
 130         private function decodePost(bool $public = true, string $privKey = '')
 131         {
 132                 if (empty($_POST['xml'])) {
 133
 134                         $postdata = Network::postdata();
 135
 136                         if (empty($postdata)) {
 137                                 throw new HTTPException\InternalServerErrorException('Missing postdata.');
 138                         }
 139
 140                         $this->logger->info('Diaspora: Message is in the new format.');
 141
 142                         $msg = Diaspora::decodeRaw($postdata, $privKey);
 143                 } else {
 144
 145                         $xml = urldecode($_POST['xml']);
 146
 147                         $this->logger->info('Diaspora: Decode message in the old format.');
 148                         $msg = Diaspora::decode($xml, $privKey);
 149
 150                         if ($public && !$msg) {
 151                                 $this->logger->info('Diaspora: Decode message in the new format.');
 152                                 $msg = Diaspora::decodeRaw($xml, $privKey);
 153                         }
 154                 }
 155
 156                 $this->logger->info('Diaspora: Post decoded.');
 157                 $this->logger->debug('Diaspora: Decoded message.', ['msg' => $msg]);
 158
 159                 if (!is_array($msg)) {
 160                         throw new HTTPException\InternalServerErrorException('Message is not an array.');
 161                 }
 162
 163                 return $msg;
 164         }
 165 }