src/Model/Storage/Filesystem.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\Model\Storage;
  23
  24 use Exception;
  25 use Friendica\Core\Config\IConfig;
  26 use Friendica\Core\L10n;
  27 use Friendica\Util\Strings;
  28
  29 /**
  30  * Filesystem based storage backend
  31  *
  32  * This class manage data on filesystem.
  33  * Base folder for storage is set in storage.filesystem_path.
  34  * Best would be for storage folder to be outside webserver folder, we are using a
  35  * folder relative to code tree root as default to ease things for users in shared hostings.
  36  * Each new resource gets a value as reference and is saved in a
  37  * folder tree stucture created from that value.
  38  */
  39 class Filesystem implements ISelectableStorage
  40 {
  41         const NAME = 'Filesystem';
  42
  43         // Default base folder
  44         const DEFAULT_BASE_FOLDER = 'storage';
  45
  46         /** @var IConfig */
  47         private $config;
  48
  49         /** @var string */
  50         private $basePath;
  51
  52         /** @var L10n */
  53         private $l10n;
  54
  55         /**
  56          * Filesystem constructor.
  57          *
  58          * @param IConfig         $config
  59          * @param L10n            $l10n
  60          */
  61         public function __construct(IConfig $config, L10n $l10n)
  62         {
  63                 $this->config = $config;
  64                 $this->l10n   = $l10n;
  65
  66                 $path           = $this->config->get('storage', 'filesystem_path', self::DEFAULT_BASE_FOLDER);
  67                 $this->basePath = rtrim($path, '/');
  68         }
  69
  70         /**
  71          * Split data ref and return file path
  72          *
  73          * @param string $reference Data reference
  74          *
  75          * @return string
  76          */
  77         private function pathForRef(string $reference): string
  78         {
  79                 $fold1 = substr($reference, 0, 2);
  80                 $fold2 = substr($reference, 2, 2);
  81                 $file  = substr($reference, 4);
  82
  83                 return implode('/', [$this->basePath, $fold1, $fold2, $file]);
  84         }
  85
  86
  87         /**
  88          * Create directory tree to store file, with .htaccess and index.html files
  89          *
  90          * @param string $file Path and filename
  91          *
  92          * @throws StorageException
  93          */
  94         private function createFoldersForFile(string $file)
  95         {
  96                 $path = dirname($file);
  97
  98                 if (!is_dir($path)) {
  99                         if (!mkdir($path, 0770, true)) {
 100                                 throw new StorageException(sprintf('Filesystem storage failed to create "%s". Check you write permissions.', $path));
 101                         }
 102                 }
 103
 104                 while ($path !== $this->basePath) {
 105                         if (!is_file($path . '/index.html')) {
 106                                 file_put_contents($path . '/index.html', '');
 107                         }
 108                         chmod($path . '/index.html', 0660);
 109                         chmod($path, 0770);
 110                         $path = dirname($path);
 111                 }
 112                 if (!is_file($path . '/index.html')) {
 113                         file_put_contents($path . '/index.html', '');
 114                         chmod($path . '/index.html', 0660);
 115                 }
 116         }
 117
 118         /**
 119          * @inheritDoc
 120          */
 121         public function get(string $reference): string
 122         {
 123                 $file = $this->pathForRef($reference);
 124                 if (!is_file($file)) {
 125                         throw new ReferenceStorageException(sprintf('Filesystem storage failed to get the file %s, The file is invalid', $reference));
 126                 }
 127
 128                 $result = file_get_contents($file);
 129
 130                 // just in case the result is REALLY false, not zero or empty or anything else, throw the exception
 131                 if ($result === false) {
 132                         throw new StorageException(sprintf('Filesystem storage failed to get data to "%s". Check your write permissions', $file));
 133                 }
 134         }
 135
 136         /**
 137          * @inheritDoc
 138          */
 139         public function put(string $data, string $reference = ''): string
 140         {
 141                 if ($reference === '') {
 142                         try {
 143                                 $reference = Strings::getRandomHex();
 144                         } catch (Exception $exception) {
 145                                 throw new StorageException('Filesystem storage failed to generate a random hex', $exception->getCode(), $exception);
 146                         }
 147                 }
 148                 $file = $this->pathForRef($reference);
 149
 150                 $this->createFoldersForFile($file);
 151
 152                 $result = file_put_contents($file, $data);
 153
 154                 // just in case the result is REALLY false, not zero or empty or anything else, throw the exception
 155                 if ($result === false) {
 156                         throw new StorageException(sprintf('Filesystem storage failed to save data to "%s". Check your write permissions', $file));
 157                 }
 158
 159                 chmod($file, 0660);
 160                 return $reference;
 161         }
 162
 163         /**
 164          * @inheritDoc
 165          */
 166         public function delete(string $reference)
 167         {
 168                 $file = $this->pathForRef($reference);
 169                 if (!is_file($file)) {
 170                         throw new ReferenceStorageException(sprintf('File with reference "%s" doesn\'t exist', $reference));
 171                 }
 172
 173                 if (!unlink($file)) {
 174                         throw new StorageException(sprintf('Cannot delete with file with reference "%s"', $reference));
 175                 }
 176         }
 177
 178         /**
 179          * @inheritDoc
 180          */
 181         public function getOptions(): array
 182         {
 183                 return [
 184                         'storagepath' => [
 185                                 'input',
 186                                 $this->l10n->t('Storage base path'),
 187                                 $this->basePath,
 188                                 $this->l10n->t('Folder where uploaded files are saved. For maximum security, This should be a path outside web server folder tree')
 189                         ]
 190                 ];
 191         }
 192
 193         /**
 194          * @inheritDoc
 195          */
 196         public function saveOptions(array $data): array
 197         {
 198                 $storagePath = $data['storagepath'] ?? '';
 199                 if ($storagePath === '' || !is_dir($storagePath)) {
 200                         return [
 201                                 'storagepath' => $this->l10n->t('Enter a valid existing folder')
 202                         ];
 203                 };
 204                 $this->config->set('storage', 'filesystem_path', $storagePath);
 205                 $this->basePath = $storagePath;
 206                 return [];
 207         }
 208
 209         /**
 210          * @inheritDoc
 211          */
 212         public static function getName(): string
 213         {
 214                 return self::NAME;
 215         }
 216
 217         public function __toString()
 218         {
 219                 return self::getName();
 220         }
 221 }