src/Console/ServerBlock.php

   1 <?php
   2 /**
   3  * @copyright Copyright (C) 2020, Friendica
   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\Console;
  23
  24 use Asika\SimpleConsole\CommandArgsException;
  25 use Asika\SimpleConsole\Console;
  26 use Console_Table;
  27 use Friendica\Core\Config\IConfig;
  28
  29 /**
  30  * Manage blocked servers
  31  *
  32  * With this tool, you can list the current blocked servers
  33  * or you can add / remove a blocked server from the list
  34  */
  35 class ServerBlock extends Console
  36 {
  37         const DEFAULT_REASON = 'blocked';
  38
  39         protected $helpOptions = ['h', 'help', '?'];
  40
  41         /**
  42          * @var IConfig
  43          */
  44         private $config;
  45
  46         protected function getHelp()
  47         {
  48                 $help = <<<HELP
  49 console serverblock - Manage blocked server domain patterns
  50 Usage
  51     bin/console serverblock [-h|--help|-?] [-v]
  52     bin/console serverblock add <pattern> <reason> [-h|--help|-?] [-v]
  53     bin/console serverblock remove <pattern> [-h|--help|-?] [-v]
  54     bin/console serverblock export <filename>
  55     bin/console serverblock import <filename>
  56
  57 Description
  58     With this tool, you can list the current blocked server domain patterns
  59     or you can add / remove a blocked server domain pattern from the list.
  60     Using the export and import options you can share your server blocklist
  61     with other node admins by CSV files.
  62
  63     Patterns are case-insensitive shell wildcard comprising the following special characters:
  64     - * : Any number of characters
  65     - ? : Any single character
  66     - [<char1><char2>...] : char1 or char2 or...
  67
  68 Options
  69     -h|--help|-? Show help information
  70     -v           Show more debug information.
  71 HELP;
  72                 return $help;
  73         }
  74
  75         public function __construct(IConfig $config, $argv = null)
  76         {
  77                 parent::__construct($argv);
  78
  79                 $this->config = $config;
  80         }
  81
  82         protected function doExecute()
  83         {
  84                 if (count($this->args) == 0) {
  85                         $this->printBlockedServers($this->config);
  86                         return 0;
  87                 }
  88
  89                 switch ($this->getArgument(0)) {
  90                         case 'add':
  91                                 return $this->addBlockedServer($this->config);
  92                         case 'remove':
  93                                 return $this->removeBlockedServer($this->config);
  94                         case 'export':
  95                                 return $this->exportBlockedServers($this->config);
  96                         case 'import':
  97                                 return $this->importBlockedServers($this->config);
  98                         default:
  99                                 throw new CommandArgsException('Unknown command.');
 100                                 break;
 101                 }
 102         }
 103
 104         /**
 105          * Exports the list of blocked domains including the reason for the
 106          * block to a CSV file.
 107          *
 108          * @param IConfig $config
 109          */
 110         private function exportBlockedServers(IConfig $config)
 111         {
 112                 $filename = $this->getArgument(1);
 113                 $blocklist = $config->get('system', 'blocklist', []);
 114                 $fp = fopen($filename, 'w');
 115                 foreach ($blocklist as $domain) {
 116                         fputcsv($fp, $domain);
 117                 }
 118         }
 119         /**
 120          * Imports a list of domains and a reason for the block from a CSV
 121          * file, e.g. created with the export function.
 122          *
 123          * @param IConfig $config
 124          */
 125         private function importBlockedServers(IConfig $config)
 126         {
 127                 $filename = $this->getArgument(1);
 128                 $currBlockList = $config->get('system', 'blocklist', []);
 129                 $newBlockList = [];
 130                 if (($fp = fopen($filename, 'r')) !== false) {
 131                         while (($data = fgetcsv($fp, 1000, ',')) !== false) {
 132                                 $domain = $data[0];
 133                                 if (count($data) == 0) {
 134                                         $reason = self::DEFAULT_REASON;
 135                                 } else {
 136                                         $reason = $data[1];
 137                                 }
 138                                 $data = [
 139                                         'domain' => $domain,
 140                                         'reason' => $reason
 141                                 ];
 142                                 if (!in_array($data, $newBlockList)) {
 143                                         $newBlockList[] = $data;
 144                 }
 145                         }
 146                         foreach ($currBlockList as $blocked) {
 147                                 if (!in_array($blocked, $newBlockList)) {
 148                                         $newBlockList[] = $blocked;
 149                 }
 150                         }
 151                         if ($config->set('system', 'blocklist', $newBlockList)) {
 152                                 $this->out(sprintf("Entries from %s that were not blocked before are now blocked", $filename));
 153                                 return 0;
 154                         } else {
 155                                 $this->out(sprintf("Couldn't save '%s' as blocked server", $domain));
 156                                 return 1;
 157                         }
 158
 159                 }
 160         }
 161
 162         /**
 163          * Prints the whole list of blocked domains including the reason
 164          *
 165          /* @param IConfig $config
 166          */
 167         private function printBlockedServers(IConfig $config)
 168         {
 169                 $table = new Console_Table();
 170                 $table->setHeaders(['Domain', 'Reason']);
 171                 $blocklist = $config->get('system', 'blocklist', []);
 172                 foreach ($blocklist as $domain) {
 173                         $table->addRow($domain);
 174                 }
 175                 $this->out($table->getTable());
 176         }
 177
 178         /**
 179          * Adds a server to the blocked list
 180          *
 181          * @param IConfig $config
 182          *
 183          * @return int The return code (0 = success, 1 = failed)
 184          */
 185         private function addBlockedServer(IConfig $config)
 186         {
 187                 if (count($this->args) < 2 || count($this->args) > 3) {
 188                         throw new CommandArgsException('Add needs a domain and optional a reason.');
 189                 }
 190
 191                 $domain = $this->getArgument(1);
 192                 $reason = (count($this->args) === 3) ? $this->getArgument(2) : self::DEFAULT_REASON;
 193
 194                 $update = false;
 195
 196                 $currBlockList = $config->get('system', 'blocklist', []);
 197                 $newBlockList = [];
 198                 foreach ($currBlockList  as $blocked) {
 199                         if ($blocked['domain'] === $domain) {
 200                                 $update = true;
 201                                 $newBlockList[] = [
 202                                         'domain' => $domain,
 203                                         'reason' => $reason,
 204                                 ];
 205                         } else {
 206                                 $newBlockList[] = $blocked;
 207                         }
 208                 }
 209
 210                 if (!$update) {
 211                         $newBlockList[] = [
 212                                 'domain' => $domain,
 213                                 'reason' => $reason,
 214                         ];
 215                 }
 216
 217                 if ($config->set('system', 'blocklist', $newBlockList)) {
 218                         if ($update) {
 219                                 $this->out(sprintf("The domain '%s' is now updated. (Reason: '%s')", $domain, $reason));
 220                         } else {
 221                                 $this->out(sprintf("The domain '%s' is now blocked. (Reason: '%s')", $domain, $reason));
 222                         }
 223                         return 0;
 224                 } else {
 225                         $this->out(sprintf("Couldn't save '%s' as blocked server", $domain));
 226                         return 1;
 227                 }
 228         }
 229
 230         /**
 231          * Removes a server from the blocked list
 232          *
 233          * @param IConfig $config
 234          *
 235          * @return int The return code (0 = success, 1 = failed)
 236          */
 237         private function removeBlockedServer(IConfig $config)
 238         {
 239                 if (count($this->args) !== 2) {
 240                         throw new CommandArgsException('Remove needs a second parameter.');
 241                 }
 242
 243                 $domain = $this->getArgument(1);
 244
 245                 $found = false;
 246
 247                 $currBlockList = $config->get('system', 'blocklist', []);
 248                 $newBlockList = [];
 249                 foreach ($currBlockList as $blocked) {
 250                         if ($blocked['domain'] === $domain) {
 251                                 $found = true;
 252                         } else {
 253                                 $newBlockList[] = $blocked;
 254                         }
 255                 }
 256
 257                 if (!$found) {
 258                         $this->out(sprintf("The domain '%s' is not blocked.", $domain));
 259                         return 1;
 260                 }
 261
 262                 if ($config->set('system', 'blocklist', $newBlockList)) {
 263                         $this->out(sprintf("The domain '%s' is not more blocked", $domain));
 264                         return 0;
 265                 } else {
 266                         $this->out(sprintf("Couldn't remove '%s' from blocked servers", $domain));
 267                         return 1;
 268                 }
 269         }
 270 }