[Summary view]

   1  <?php
   2  
   3  class HTMLPurifier_DefinitionCache_Serializer extends HTMLPurifier_DefinitionCache
   4  {
   5  
   6      /**

   7       * @param HTMLPurifier_Definition $def

   8       * @param HTMLPurifier_Config $config

   9       * @return int|bool

  10       */
  11      public function add($def, $config)
  12      {
  13          if (!$this->checkDefType($def)) {
  14              return;
  15          }
  16          $file = $this->generateFilePath($config);
  17          if (file_exists($file)) {
  18              return false;
  19          }
  20          if (!$this->_prepareDir($config)) {
  21              return false;
  22          }
  23          return $this->_write($file, serialize($def), $config);
  24      }
  25  
  26      /**

  27       * @param HTMLPurifier_Definition $def

  28       * @param HTMLPurifier_Config $config

  29       * @return int|bool

  30       */
  31      public function set($def, $config)
  32      {
  33          if (!$this->checkDefType($def)) {
  34              return;
  35          }
  36          $file = $this->generateFilePath($config);
  37          if (!$this->_prepareDir($config)) {
  38              return false;
  39          }
  40          return $this->_write($file, serialize($def), $config);
  41      }
  42  
  43      /**

  44       * @param HTMLPurifier_Definition $def

  45       * @param HTMLPurifier_Config $config

  46       * @return int|bool

  47       */
  48      public function replace($def, $config)
  49      {
  50          if (!$this->checkDefType($def)) {
  51              return;
  52          }
  53          $file = $this->generateFilePath($config);
  54          if (!file_exists($file)) {
  55              return false;
  56          }
  57          if (!$this->_prepareDir($config)) {
  58              return false;
  59          }
  60          return $this->_write($file, serialize($def), $config);
  61      }
  62  
  63      /**

  64       * @param HTMLPurifier_Config $config

  65       * @return bool|HTMLPurifier_Config

  66       */
  67      public function get($config)
  68      {
  69          $file = $this->generateFilePath($config);
  70          if (!file_exists($file)) {
  71              return false;
  72          }
  73          return unserialize(file_get_contents($file));
  74      }
  75  
  76      /**

  77       * @param HTMLPurifier_Config $config

  78       * @return bool

  79       */
  80      public function remove($config)
  81      {
  82          $file = $this->generateFilePath($config);
  83          if (!file_exists($file)) {
  84              return false;
  85          }
  86          return unlink($file);
  87      }
  88  
  89      /**

  90       * @param HTMLPurifier_Config $config

  91       * @return bool

  92       */
  93      public function flush($config)
  94      {
  95          if (!$this->_prepareDir($config)) {
  96              return false;
  97          }
  98          $dir = $this->generateDirectoryPath($config);
  99          $dh = opendir($dir);
 100          // Apparently, on some versions of PHP, readdir will return

 101          // an empty string if you pass an invalid argument to readdir.

 102          // So you need this test.  See #49.

 103          if (false === $dh) {
 104              return false;
 105          }
 106          while (false !== ($filename = readdir($dh))) {
 107              if (empty($filename)) {
 108                  continue;
 109              }
 110              if ($filename[0] === '.') {
 111                  continue;
 112              }
 113              unlink($dir . '/' . $filename);
 114          }
 115          closedir($dh);
 116          return true;
 117      }
 118  
 119      /**

 120       * @param HTMLPurifier_Config $config

 121       * @return bool

 122       */
 123      public function cleanup($config)
 124      {
 125          if (!$this->_prepareDir($config)) {
 126              return false;
 127          }
 128          $dir = $this->generateDirectoryPath($config);
 129          $dh = opendir($dir);
 130          // See #49 (and above).

 131          if (false === $dh) {
 132              return false;
 133          }
 134          while (false !== ($filename = readdir($dh))) {
 135              if (empty($filename)) {
 136                  continue;
 137              }
 138              if ($filename[0] === '.') {
 139                  continue;
 140              }
 141              $key = substr($filename, 0, strlen($filename) - 4);
 142              if ($this->isOld($key, $config)) {
 143                  unlink($dir . '/' . $filename);
 144              }
 145          }
 146          closedir($dh);
 147          return true;
 148      }
 149  
 150      /**

 151       * Generates the file path to the serial file corresponding to

 152       * the configuration and definition name

 153       * @param HTMLPurifier_Config $config

 154       * @return string

 155       * @todo Make protected

 156       */
 157      public function generateFilePath($config)
 158      {
 159          $key = $this->generateKey($config);
 160          return $this->generateDirectoryPath($config) . '/' . $key . '.ser';
 161      }
 162  
 163      /**

 164       * Generates the path to the directory contain this cache's serial files

 165       * @param HTMLPurifier_Config $config

 166       * @return string

 167       * @note No trailing slash

 168       * @todo Make protected

 169       */
 170      public function generateDirectoryPath($config)
 171      {
 172          $base = $this->generateBaseDirectoryPath($config);
 173          return $base . '/' . $this->type;
 174      }
 175  
 176      /**

 177       * Generates path to base directory that contains all definition type

 178       * serials

 179       * @param HTMLPurifier_Config $config

 180       * @return mixed|string

 181       * @todo Make protected

 182       */
 183      public function generateBaseDirectoryPath($config)
 184      {
 185          $base = $config->get('Cache.SerializerPath');
 186          $base = is_null($base) ? HTMLPURIFIER_PREFIX . '/HTMLPurifier/DefinitionCache/Serializer' : $base;
 187          return $base;
 188      }
 189  
 190      /**

 191       * Convenience wrapper function for file_put_contents

 192       * @param string $file File name to write to

 193       * @param string $data Data to write into file

 194       * @param HTMLPurifier_Config $config

 195       * @return int|bool Number of bytes written if success, or false if failure.

 196       */
 197      private function _write($file, $data, $config)
 198      {
 199          $result = file_put_contents($file, $data);
 200          if ($result !== false) {
 201              // set permissions of the new file (no execute)

 202              $chmod = $config->get('Cache.SerializerPermissions');
 203              if ($chmod !== null) {
 204                  chmod($file, $chmod & 0666);
 205              }
 206          }
 207          return $result;
 208      }
 209  
 210      /**

 211       * Prepares the directory that this type stores the serials in

 212       * @param HTMLPurifier_Config $config

 213       * @return bool True if successful

 214       */
 215      private function _prepareDir($config)
 216      {
 217          $directory = $this->generateDirectoryPath($config);
 218          $chmod = $config->get('Cache.SerializerPermissions');
 219          if ($chmod === null) {
 220              if (!@mkdir($directory) && !is_dir($directory)) {
 221                  trigger_error(
 222                      'Could not create directory ' . $directory . '',
 223                      E_USER_WARNING
 224                  );
 225                  return false;
 226              }
 227              return true;
 228          }
 229          if (!is_dir($directory)) {
 230              $base = $this->generateBaseDirectoryPath($config);
 231              if (!is_dir($base)) {
 232                  trigger_error(
 233                      'Base directory ' . $base . ' does not exist,
 234                      please create or change using %Cache.SerializerPath',
 235                      E_USER_WARNING
 236                  );
 237                  return false;
 238              } elseif (!$this->_testPermissions($base, $chmod)) {
 239                  return false;
 240              }
 241              if (!@mkdir($directory, $chmod) && !is_dir($directory)) {
 242                  trigger_error(
 243                      'Could not create directory ' . $directory . '',
 244                      E_USER_WARNING
 245                  );
 246                  return false;
 247              }
 248              if (!$this->_testPermissions($directory, $chmod)) {
 249                  return false;
 250              }
 251          } elseif (!$this->_testPermissions($directory, $chmod)) {
 252              return false;
 253          }
 254          return true;
 255      }
 256  
 257      /**

 258       * Tests permissions on a directory and throws out friendly

 259       * error messages and attempts to chmod it itself if possible

 260       * @param string $dir Directory path

 261       * @param int $chmod Permissions

 262       * @return bool True if directory is writable

 263       */
 264      private function _testPermissions($dir, $chmod)
 265      {
 266          // early abort, if it is writable, everything is hunky-dory

 267          if (is_writable($dir)) {
 268              return true;
 269          }
 270          if (!is_dir($dir)) {
 271              // generally, you'll want to handle this beforehand

 272              // so a more specific error message can be given

 273              trigger_error(
 274                  'Directory ' . $dir . ' does not exist',
 275                  E_USER_WARNING
 276              );
 277              return false;
 278          }
 279          if (function_exists('posix_getuid') && $chmod !== null) {
 280              // POSIX system, we can give more specific advice

 281              if (fileowner($dir) === posix_getuid()) {
 282                  // we can chmod it ourselves

 283                  $chmod = $chmod | 0700;
 284                  if (chmod($dir, $chmod)) {
 285                      return true;
 286                  }
 287              } elseif (filegroup($dir) === posix_getgid()) {
 288                  $chmod = $chmod | 0070;
 289              } else {
 290                  // PHP's probably running as nobody, so we'll

 291                  // need to give global permissions

 292                  $chmod = $chmod | 0777;
 293              }
 294              trigger_error(
 295                  'Directory ' . $dir . ' not writable, ' .
 296                  'please chmod to ' . decoct($chmod),
 297                  E_USER_WARNING
 298              );
 299          } else {
 300              // generic error message

 301              trigger_error(
 302                  'Directory ' . $dir . ' not writable, ' .
 303                  'please alter file permissions',
 304                  E_USER_WARNING
 305              );
 306          }
 307          return false;
 308      }
 309  }
 310  
 311  // vim: et sw=4 sts=4