src/Module/BaseApi.php

   1 <?php
   2 /**
   3  * @copyright Copyright (C) 2010-2021, 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;
  23
  24 use Friendica\BaseModule;
  25 use Friendica\Core\Logger;
  26 use Friendica\Core\System;
  27 use Friendica\DI;
  28 use Friendica\Network\HTTPException;
  29 use Friendica\Security\BasicAuth;
  30 use Friendica\Security\OAuth;
  31 use Friendica\Util\HTTPInputData;
  32
  33 require_once __DIR__ . '/../../include/api.php';
  34
  35 class BaseApi extends BaseModule
  36 {
  37         /** @deprecated Use OAuth class constant */
  38         const SCOPE_READ   = 'read';
  39         /** @deprecated Use OAuth class constant */
  40         const SCOPE_WRITE  = 'write';
  41         /** @deprecated Use OAuth class constant */
  42         const SCOPE_FOLLOW = 'follow';
  43         /** @deprecated Use OAuth class constant */
  44         const SCOPE_PUSH   = 'push';
  45
  46         /**
  47          * @var string json|xml|rss|atom
  48          */
  49         protected static $format = 'json';
  50
  51         public static function init(array $parameters = [])
  52         {
  53                 $arguments = DI::args();
  54
  55                 if (substr($arguments->getCommand(), -4) === '.xml') {
  56                         self::$format = 'xml';
  57                 }
  58                 if (substr($arguments->getCommand(), -4) === '.rss') {
  59                         self::$format = 'rss';
  60                 }
  61                 if (substr($arguments->getCommand(), -4) === '.atom') {
  62                         self::$format = 'atom';
  63                 }
  64         }
  65
  66         public static function delete(array $parameters = [])
  67         {
  68                 if (!api_user()) {
  69                         throw new HTTPException\UnauthorizedException(DI::l10n()->t('Permission denied.'));
  70                 }
  71
  72                 $a = DI::app();
  73
  74                 if (!empty($a->user['uid']) && $a->user['uid'] != api_user()) {
  75                         throw new HTTPException\ForbiddenException(DI::l10n()->t('Permission denied.'));
  76                 }
  77         }
  78
  79         public static function patch(array $parameters = [])
  80         {
  81                 if (!api_user()) {
  82                         throw new HTTPException\UnauthorizedException(DI::l10n()->t('Permission denied.'));
  83                 }
  84
  85                 $a = DI::app();
  86
  87                 if (!empty($a->user['uid']) && $a->user['uid'] != api_user()) {
  88                         throw new HTTPException\ForbiddenException(DI::l10n()->t('Permission denied.'));
  89                 }
  90         }
  91
  92         public static function post(array $parameters = [])
  93         {
  94                 if (!api_user()) {
  95                         throw new HTTPException\UnauthorizedException(DI::l10n()->t('Permission denied.'));
  96                 }
  97
  98                 $a = DI::app();
  99
 100                 if (!empty($a->user['uid']) && $a->user['uid'] != api_user()) {
 101                         throw new HTTPException\ForbiddenException(DI::l10n()->t('Permission denied.'));
 102                 }
 103         }
 104
 105         public static function put(array $parameters = [])
 106         {
 107                 if (!api_user()) {
 108                         throw new HTTPException\UnauthorizedException(DI::l10n()->t('Permission denied.'));
 109                 }
 110
 111                 $a = DI::app();
 112
 113                 if (!empty($a->user['uid']) && $a->user['uid'] != api_user()) {
 114                         throw new HTTPException\ForbiddenException(DI::l10n()->t('Permission denied.'));
 115                 }
 116         }
 117
 118         /**
 119          * Quit execution with the message that the endpoint isn't implemented
 120          *
 121          * @param string $method
 122          * @return void
 123          */
 124         public static function unsupported(string $method = 'all')
 125         {
 126                 $path = DI::args()->getQueryString();
 127                 Logger::info('Unimplemented API call', ['method' => $method, 'path' => $path, 'agent' => $_SERVER['HTTP_USER_AGENT'] ?? '', 'request' => HTTPInputData::process()]);
 128                 $error = DI::l10n()->t('API endpoint %s %s is not implemented', strtoupper($method), $path);
 129                 $error_description = DI::l10n()->t('The API endpoint is currently not implemented but might be in the future.');
 130                 $errorobj = new \Friendica\Object\Api\Mastodon\Error($error, $error_description);
 131                 System::jsonError(501, $errorobj->toArray());
 132         }
 133
 134         /**
 135          * Processes data from GET requests and sets defaults
 136          *
 137          * @return array request data
 138          */
 139         public static function getRequest(array $defaults)
 140         {
 141                 $httpinput = HTTPInputData::process();
 142                 $input = array_merge($httpinput['variables'], $httpinput['files'], $_REQUEST);
 143
 144                 $request = [];
 145
 146                 foreach ($defaults as $parameter => $defaultvalue) {
 147                         if (is_string($defaultvalue)) {
 148                                 $request[$parameter] = $input[$parameter] ?? $defaultvalue;
 149                         } elseif (is_int($defaultvalue)) {
 150                                 $request[$parameter] = (int)($input[$parameter] ?? $defaultvalue);
 151                         } elseif (is_float($defaultvalue)) {
 152                                 $request[$parameter] = (float)($input[$parameter] ?? $defaultvalue);
 153                         } elseif (is_array($defaultvalue)) {
 154                                 $request[$parameter] = $input[$parameter] ?? [];
 155                         } elseif (is_bool($defaultvalue)) {
 156                                 $request[$parameter] = in_array(strtolower($input[$parameter] ?? ''), ['true', '1']);
 157                         } else {
 158                                 Logger::notice('Unhandled default value type', ['parameter' => $parameter, 'type' => gettype($defaultvalue)]);
 159                         }
 160                 }
 161
 162                 foreach ($input ?? [] as $parameter => $value) {
 163                         if ($parameter == 'pagename') {
 164                                 continue;
 165                         }
 166                         if (!in_array($parameter, array_keys($defaults))) {
 167                                 Logger::notice('Unhandled request field', ['parameter' => $parameter, 'value' => $value, 'command' => DI::args()->getCommand()]);
 168                         }
 169                 }
 170
 171                 Logger::debug('Got request parameters', ['request' => $request, 'command' => DI::args()->getCommand()]);
 172                 return $request;
 173         }
 174
 175         /**
 176          * Log in user via OAuth1 or Simple HTTP Auth.
 177          *
 178          * Simple Auth allow username in form of <pre>user@server</pre>, ignoring server part
 179          *
 180          * @param string $scope the requested scope (read, write, follow)
 181          *
 182          * @throws HTTPException\ForbiddenException
 183          * @throws HTTPException\UnauthorizedException
 184          * @throws HTTPException\InternalServerErrorException
 185          * @hook  'authenticate'
 186          *               array $addon_auth
 187          *               'username' => username from login form
 188          *               'password' => password from login form
 189          *               'authenticated' => return status,
 190          *               'user_record' => return authenticated user record
 191          */
 192         protected static function login(string $scope)
 193         {
 194                 $token = OAuth::getCurrentApplicationToken();
 195                 if (!empty($token)) {
 196                         if (!OAuth::isAllowedScope($scope)) {
 197                                 DI::mstdnError()->Forbidden();
 198                         }
 199                         $uid = OAuth::getCurrentUserID();
 200                 }
 201
 202                 if (empty($uid)) {
 203                         // The execution stops here if no one is logged in
 204                         BasicAuth::getCurrentUserID(true);
 205                 }
 206         }
 207
 208         /**
 209          * Get current application token
 210          *
 211          * @return array token
 212          */
 213         protected static function getCurrentApplication()
 214         {
 215                 $token = OAuth::getCurrentApplicationToken();
 216
 217                 if (empty($token)) {
 218                         $token = BasicAuth::getCurrentApplicationToken();
 219                 }
 220
 221                 return $token;
 222         }
 223
 224         /**
 225          * Get current user id, returns 0 if not logged in
 226          *
 227          * @return int User ID
 228          */
 229         public static function getCurrentUserID()
 230         {
 231                 $uid = OAuth::getCurrentUserID();
 232
 233                 if (empty($uid)) {
 234                         $uid = BasicAuth::getCurrentUserID(false);
 235                 }
 236
 237                 return (int)$uid;
 238         }
 239
 240         /**
 241          * Get user info array.
 242          *
 243          * @param int|string $contact_id Contact ID or URL
 244          * @return array|bool
 245          * @throws HTTPException\BadRequestException
 246          * @throws HTTPException\InternalServerErrorException
 247          * @throws HTTPException\UnauthorizedException
 248          * @throws \ImagickException
 249          */
 250         protected static function getUser($contact_id = null)
 251         {
 252                 return api_get_user(DI::app(), $contact_id);
 253         }
 254
 255         /**
 256          * Formats the data according to the data type
 257          *
 258          * @param string $root_element
 259          * @param array $data An array with a single element containing the returned result
 260          * @return false|string
 261          */
 262         protected static function format(string $root_element, array $data)
 263         {
 264                 $return = api_format_data($root_element, self::$format, $data);
 265
 266                 switch (self::$format) {
 267                         case "xml":
 268                                 header("Content-Type: text/xml");
 269                                 break;
 270                         case "json":
 271                                 header("Content-Type: application/json");
 272                                 if (!empty($return)) {
 273                                         $json = json_encode(end($return));
 274                                         if (!empty($_GET['callback'])) {
 275                                                 $json = $_GET['callback'] . "(" . $json . ")";
 276                                         }
 277                                         $return = $json;
 278                                 }
 279                                 break;
 280                         case "rss":
 281                                 header("Content-Type: application/rss+xml");
 282                                 $return  = '<?xml version="1.0" encoding="UTF-8"?>' . "\n" . $return;
 283                                 break;
 284                         case "atom":
 285                                 header("Content-Type: application/atom+xml");
 286                                 $return = '<?xml version="1.0" encoding="UTF-8"?>' . "\n" . $return;
 287                                 break;
 288                 }
 289
 290                 return $return;
 291         }
 292
 293         /**
 294          * Creates the XML from a JSON style array
 295          *
 296          * @param $data
 297          * @param $root_element
 298          * @return string
 299          */
 300         protected static function createXml($data, $root_element)
 301         {
 302                 return api_create_xml($data, $root_element);
 303         }
 304 }