[Summary view] [Print] [Text 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          while (false !== ($filename = readdir($dh))) {
 101              if (empty($filename)) {
 102                  continue;
 103              }
 104              if ($filename[0] === '.') {
 105                  continue;
 106              }
 107              unlink($dir . '/' . $filename);
 108          }
 109      }
 110  
 111      /**
 112       * @param HTMLPurifier_Config $config
 113       * @return bool
 114       */
 115      public function cleanup($config)
 116      {
 117          if (!$this->_prepareDir($config)) {
 118              return false;
 119          }
 120          $dir = $this->generateDirectoryPath($config);
 121          $dh = opendir($dir);
 122          while (false !== ($filename = readdir($dh))) {
 123              if (empty($filename)) {
 124                  continue;
 125              }
 126              if ($filename[0] === '.') {
 127                  continue;
 128              }
 129              $key = substr($filename, 0, strlen($filename) - 4);
 130              if ($this->isOld($key, $config)) {
 131                  unlink($dir . '/' . $filename);
 132              }
 133          }
 134      }
 135  
 136      /**
 137       * Generates the file path to the serial file corresponding to
 138       * the configuration and definition name
 139       * @param HTMLPurifier_Config $config
 140       * @return string
 141       * @todo Make protected
 142       */
 143      public function generateFilePath($config)
 144      {
 145          $key = $this->generateKey($config);
 146          return $this->generateDirectoryPath($config) . '/' . $key . '.ser';
 147      }
 148  
 149      /**
 150       * Generates the path to the directory contain this cache's serial files
 151       * @param HTMLPurifier_Config $config
 152       * @return string
 153       * @note No trailing slash
 154       * @todo Make protected
 155       */
 156      public function generateDirectoryPath($config)
 157      {
 158          $base = $this->generateBaseDirectoryPath($config);
 159          return $base . '/' . $this->type;
 160      }
 161  
 162      /**
 163       * Generates path to base directory that contains all definition type
 164       * serials
 165       * @param HTMLPurifier_Config $config
 166       * @return mixed|string
 167       * @todo Make protected
 168       */
 169      public function generateBaseDirectoryPath($config)
 170      {
 171          $base = $config->get('Cache.SerializerPath');
 172          $base = is_null($base) ? HTMLPURIFIER_PREFIX . '/HTMLPurifier/DefinitionCache/Serializer' : $base;
 173          return $base;
 174      }
 175  
 176      /**
 177       * Convenience wrapper function for file_put_contents
 178       * @param string $file File name to write to
 179       * @param string $data Data to write into file
 180       * @param HTMLPurifier_Config $config
 181       * @return int|bool Number of bytes written if success, or false if failure.
 182       */
 183      private function _write($file, $data, $config)
 184      {
 185          $result = file_put_contents($file, $data);
 186          if ($result !== false) {
 187              // set permissions of the new file (no execute)
 188              $chmod = $config->get('Cache.SerializerPermissions');
 189              if (!$chmod) {
 190                  $chmod = 0644; // invalid config or simpletest
 191              }
 192              $chmod = $chmod & 0666;
 193              chmod($file, $chmod);
 194          }
 195          return $result;
 196      }
 197  
 198      /**
 199       * Prepares the directory that this type stores the serials in
 200       * @param HTMLPurifier_Config $config
 201       * @return bool True if successful
 202       */
 203      private function _prepareDir($config)
 204      {
 205          $directory = $this->generateDirectoryPath($config);
 206          $chmod = $config->get('Cache.SerializerPermissions');
 207          if (!$chmod) {
 208              $chmod = 0755; // invalid config or simpletest
 209          }
 210          if (!is_dir($directory)) {
 211              $base = $this->generateBaseDirectoryPath($config);
 212              if (!is_dir($base)) {
 213                  trigger_error(
 214                      'Base directory ' . $base . ' does not exist,
 215                      please create or change using %Cache.SerializerPath',
 216                      E_USER_WARNING
 217                  );
 218                  return false;
 219              } elseif (!$this->_testPermissions($base, $chmod)) {
 220                  return false;
 221              }
 222              mkdir($directory, $chmod);
 223              if (!$this->_testPermissions($directory, $chmod)) {
 224                  trigger_error(
 225                      'Base directory ' . $base . ' does not exist,
 226                      please create or change using %Cache.SerializerPath',
 227                      E_USER_WARNING
 228                  );
 229                  return false;
 230              }
 231          } elseif (!$this->_testPermissions($directory, $chmod)) {
 232              return false;
 233          }
 234          return true;
 235      }
 236  
 237      /**
 238       * Tests permissions on a directory and throws out friendly
 239       * error messages and attempts to chmod it itself if possible
 240       * @param string $dir Directory path
 241       * @param int $chmod Permissions
 242       * @return bool True if directory is writable
 243       */
 244      private function _testPermissions($dir, $chmod)
 245      {
 246          // early abort, if it is writable, everything is hunky-dory
 247          if (is_writable($dir)) {
 248              return true;
 249          }
 250          if (!is_dir($dir)) {
 251              // generally, you'll want to handle this beforehand
 252              // so a more specific error message can be given
 253              trigger_error(
 254                  'Directory ' . $dir . ' does not exist',
 255                  E_USER_WARNING
 256              );
 257              return false;
 258          }
 259          if (function_exists('posix_getuid')) {
 260              // POSIX system, we can give more specific advice
 261              if (fileowner($dir) === posix_getuid()) {
 262                  // we can chmod it ourselves
 263                  $chmod = $chmod | 0700;
 264                  if (chmod($dir, $chmod)) {
 265                      return true;
 266                  }
 267              } elseif (filegroup($dir) === posix_getgid()) {
 268                  $chmod = $chmod | 0070;
 269              } else {
 270                  // PHP's probably running as nobody, so we'll
 271                  // need to give global permissions
 272                  $chmod = $chmod | 0777;
 273              }
 274              trigger_error(
 275                  'Directory ' . $dir . ' not writable, ' .
 276                  'please chmod to ' . decoct($chmod),
 277                  E_USER_WARNING
 278              );
 279          } else {
 280              // generic error message
 281              trigger_error(
 282                  'Directory ' . $dir . ' not writable, ' .
 283                  'please alter file permissions',
 284                  E_USER_WARNING
 285              );
 286          }
 287          return false;
 288      }
 289  }
 290  
 291  // vim: et sw=4 sts=4