Code Coverage
 
Classes and Traits
Functions and Methods
Lines
Total
0.00% covered (danger)
0.00%
0 / 1
46.67% covered (danger)
46.67%
7 / 15
CRAP
72.38% covered (warning)
72.38%
152 / 210
file
0.00% covered (danger)
0.00%
0 / 1
46.67% covered (danger)
46.67%
7 / 15
223.66
72.38% covered (warning)
72.38%
152 / 210
 __construct
0.00% covered (danger)
0.00%
0 / 1
4.07
83.33% covered (warning)
83.33%
5 / 6
 load
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
1 / 1
 unload
0.00% covered (danger)
0.00%
0 / 1
2.00
0.00% covered (danger)
0.00%
0 / 4
 save
0.00% covered (danger)
0.00%
0 / 1
5.40
55.56% covered (warning)
55.56%
5 / 9
 tidy
0.00% covered (danger)
0.00%
0 / 1
110.00
0.00% covered (danger)
0.00%
0 / 24
 get
100.00% covered (success)
100.00%
1 / 1
4
100.00% covered (success)
100.00%
5 / 5
 put
100.00% covered (success)
100.00%
1 / 1
2
100.00% covered (success)
100.00%
6 / 6
 purge
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
3 / 3
 destroy
0.00% covered (danger)
0.00%
0 / 1
24.33
59.38% covered (warning)
59.38%
19 / 32
 _exists
100.00% covered (success)
100.00%
1 / 1
5
100.00% covered (success)
100.00%
9 / 9
 sql_save
0.00% covered (danger)
0.00%
0 / 1
3.01
90.00% covered (success)
90.00%
9 / 10
 cleanup_invalid_data_global
100.00% covered (success)
100.00%
1 / 1
2
100.00% covered (success)
100.00%
6 / 6
 _read
0.00% covered (danger)
0.00%
0 / 1
22.66
88.89% covered (warning)
88.89%
56 / 63
 _write
0.00% covered (danger)
0.00%
0 / 1
9.17
87.10% covered (warning)
87.10%
27 / 31
 clean_varname
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
1 / 1
<?php
/**
*
* This file is part of the phpBB Forum Software package.
*
* @copyright (c) phpBB Limited <https://www.phpbb.com>
* @license GNU General Public License, version 2 (GPL-2.0)
*
* For full copyright and license information, please see
* the docs/CREDITS.txt file.
*
*/
namespace phpbb\cache\driver;
/**
* ACM File Based Caching
*/
class file extends \phpbb\cache\driver\base
{
    var $var_expires = array();
    /**
     * @var    \phpbb\filesystem\filesystem_interface
     */
    protected $filesystem;
    /**
    * Set cache path
    *
    * @param string $cache_dir Define the path to the cache directory (default: $phpbb_root_path . 'cache/')
    */
    function __construct($cache_dir = null)
    {
        global $phpbb_container;
        $this->cache_dir = !is_null($cache_dir) ? $cache_dir : $phpbb_container->getParameter('core.cache_dir');
        $this->filesystem = new \phpbb\filesystem\filesystem();
        if ($this->filesystem->is_writable(dirname($this->cache_dir)) && !is_dir($this->cache_dir))
        {
            mkdir($this->cache_dir, 0777, true);
        }
    }
    /**
    * {@inheritDoc}
    */
    function load()
    {
        return $this->_read('data_global');
    }
    /**
    * {@inheritDoc}
    */
    function unload()
    {
        parent::unload();
        unset($this->var_expires);
        $this->var_expires = array();
    }
    /**
    * {@inheritDoc}
    */
    function save()
    {
        if (!$this->is_modified)
        {
            return;
        }
        global $phpEx;
        if (!$this->_write('data_global'))
        {
            // Now, this occurred how often? ... phew, just tell the user then...
            if (!$this->filesystem->is_writable($this->cache_dir))
            {
                // We need to use die() here, because else we may encounter an infinite loop (the message handler calls $cache->unload())
                die('Fatal: ' . $this->cache_dir . ' is NOT writable.');
                exit;
            }
            die('Fatal: Not able to open ' . $this->cache_dir . 'data_global.' . $phpEx);
            exit;
        }
        $this->is_modified = false;
    }
    /**
    * {@inheritDoc}
    */
    function tidy()
    {
        global $config, $phpEx;
        $dir = @opendir($this->cache_dir);
        if (!$dir)
        {
            return;
        }
        $time = time();
        while (($entry = readdir($dir)) !== false)
        {
            if (!preg_match('/^(sql_|data_(?!global))/', $entry))
            {
                continue;
            }
            if (!($handle = @fopen($this->cache_dir . $entry, 'rb')))
            {
                continue;
            }
            // Skip the PHP header
            fgets($handle);
            // Skip expiration
            $expires = (int) fgets($handle);
            fclose($handle);
            if ($time >= $expires)
            {
                $this->remove_file($this->cache_dir . $entry);
            }
        }
        closedir($dir);
        if (file_exists($this->cache_dir . 'data_global.' . $phpEx))
        {
            if (!count($this->vars))
            {
                $this->load();
            }
            foreach ($this->var_expires as $var_name => $expires)
            {
                if ($time >= $expires)
                {
                    $this->destroy($var_name);
                }
            }
        }
        $config->set('cache_last_gc', time(), false);
    }
    /**
    * {@inheritDoc}
    */
    function get($var_name)
    {
        if ($var_name[0] == '_')
        {
            if (!$this->_exists($var_name))
            {
                return false;
            }
            return $this->_read('data' . $var_name);
        }
        else
        {
            return ($this->_exists($var_name)) ? $this->vars[$var_name] : false;
        }
    }
    /**
    * {@inheritDoc}
    */
    function put($var_name, $var, $ttl = 31536000)
    {
        if ($var_name[0] == '_')
        {
            $this->_write('data' . $var_name, $var, time() + $ttl);
        }
        else
        {
            $this->vars[$var_name] = $var;
            $this->var_expires[$var_name] = time() + $ttl;
            $this->is_modified = true;
        }
    }
    /**
    * {@inheritDoc}
    */
    function purge()
    {
        parent::purge();
        $this->var_expires = array();
    }
    /**
    * {@inheritDoc}
    */
    function destroy($var_name, $table = '')
    {
        global $phpEx;
        if ($var_name == 'sql' && !empty($table))
        {
            if (!is_array($table))
            {
                $table = array($table);
            }
            $dir = @opendir($this->cache_dir);
            if (!$dir)
            {
                return;
            }
            while (($entry = readdir($dir)) !== false)
            {
                if (strpos($entry, 'sql_') !== 0)
                {
                    continue;
                }
                if (!($handle = @fopen($this->cache_dir . $entry, 'rb')))
                {
                    continue;
                }
                // Skip the PHP header
                fgets($handle);
                // Skip expiration
                fgets($handle);
                // Grab the query, remove the LF
                $query = substr(fgets($handle), 0, -1);
                fclose($handle);
                foreach ($table as $check_table)
                {
                    // Better catch partial table names than no table names. ;)
                    if (strpos($query, $check_table) !== false)
                    {
                        $this->remove_file($this->cache_dir . $entry);
                        break;
                    }
                }
            }
            closedir($dir);
            return;
        }
        if (!$this->_exists($var_name))
        {
            return;
        }
        if ($var_name[0] == '_')
        {
            $this->remove_file($this->cache_dir . 'data' . $var_name . ".$phpEx", true);
        }
        else if (isset($this->vars[$var_name]))
        {
            $this->is_modified = true;
            unset($this->vars[$var_name]);
            unset($this->var_expires[$var_name]);
            // We save here to let the following cache hits succeed
            $this->save();
        }
    }
    /**
    * {@inheritDoc}
    */
    function _exists($var_name)
    {
        if ($var_name[0] == '_')
        {
            global $phpEx;
            $var_name = $this->clean_varname($var_name);
            return file_exists($this->cache_dir . 'data' . $var_name . ".$phpEx");
        }
        else
        {
            if (!count($this->vars))
            {
                $this->load();
            }
            if (!isset($this->var_expires[$var_name]))
            {
                return false;
            }
            return (time() > $this->var_expires[$var_name]) ? false : isset($this->vars[$var_name]);
        }
    }
    /**
    * {@inheritDoc}
    */
    function sql_save(\phpbb\db\driver\driver_interface $db, $query, $query_result, $ttl)
    {
        // Remove extra spaces and tabs
        $query = preg_replace('/[\n\r\s\t]+/', ' ', $query);
        $query_id = md5($query);
        $this->sql_rowset[$query_id] = array();
        $this->sql_row_pointer[$query_id] = 0;
        while ($row = $db->sql_fetchrow($query_result))
        {
            $this->sql_rowset[$query_id][] = $row;
        }
        $db->sql_freeresult($query_result);
        if ($this->_write('sql_' . $query_id, $this->sql_rowset[$query_id], $ttl + time(), $query))
        {
            return $query_id;
        }
        return $query_result;
    }
    /**
     * Cleanup when loading invalid data global file
     *
     * @param string $file Filename
     * @param resource $handle
     *
     * @return void
     */
    private function cleanup_invalid_data_global(string $file, $handle): void
    {
        if (is_resource($handle))
        {
            fclose($handle);
        }
        $this->vars = $this->var_expires = [];
        $this->is_modified = false;
        $this->remove_file($file);
    }
    /**
    * Read cached data from a specified file
    *
    * @access private
    * @param string $filename Filename to write
    * @return mixed False if an error was encountered, otherwise the data type of the cached data
    */
    function _read($filename)
    {
        global $phpEx;
        $filename = $this->clean_varname($filename);
        $file = "{$this->cache_dir}$filename.$phpEx";
        $type = substr($filename, 0, strpos($filename, '_'));
        if (!file_exists($file))
        {
            return false;
        }
        if (!($handle = @fopen($file, 'rb')))
        {
            return false;
        }
        // Skip the PHP header
        fgets($handle);
        if ($filename == 'data_global')
        {
            $this->vars = $this->var_expires = array();
            $time = time();
            while (($expires = (int) fgets($handle)) && !feof($handle))
            {
                // Number of bytes of data
                $bytes = substr(fgets($handle), 0, -1);
                if (!is_numeric($bytes) || ($bytes = (int) $bytes) === 0)
                {
                    $this->cleanup_invalid_data_global($file, $handle);
                    return false;
                }
                if ($time >= $expires)
                {
                    fseek($handle, $bytes, SEEK_CUR);
                    continue;
                }
                $var_name = substr(fgets($handle), 0, -1);
                $data_length = $bytes - strlen($var_name);
                if ($data_length <= 0)
                {
                    $this->cleanup_invalid_data_global($file, $handle);
                    return false;
                }
                // Read the length of bytes that consists of data.
                $data = fread($handle, $data_length);
                $data = @unserialize($data);
                // Don't use the data if it was invalid
                if ($data !== false)
                {
                    $this->vars[$var_name] = $data;
                    $this->var_expires[$var_name] = $expires;
                }
                // Absorb the LF
                fgets($handle);
            }
            fclose($handle);
            $this->is_modified = false;
            return true;
        }
        else
        {
            $data = false;
            $line = 0;
            while (($buffer = fgets($handle)) && !feof($handle))
            {
                $buffer = substr($buffer, 0, -1); // Remove the LF
                // $buffer is only used to read integers
                // if it is non numeric we have an invalid
                // cache file, which we will now remove.
                if (!is_numeric($buffer))
                {
                    break;
                }
                if ($line == 0)
                {
                    $expires = (int) $buffer;
                    if (time() >= $expires)
                    {
                        break;
                    }
                    if ($type == 'sql')
                    {
                        // Skip the query
                        fgets($handle);
                    }
                }
                else if ($line == 1)
                {
                    $bytes = (int) $buffer;
                    // Never should have 0 bytes
                    if (!$bytes)
                    {
                        break;
                    }
                    // Grab the serialized data
                    $data = fread($handle, $bytes);
                    // Read 1 byte, to trigger EOF
                    fread($handle, 1);
                    if (!feof($handle))
                    {
                        // Somebody tampered with our data
                        $data = false;
                    }
                    break;
                }
                else
                {
                    // Something went wrong
                    break;
                }
                $line++;
            }
            fclose($handle);
            // unserialize if we got some data
            $data = ($data !== false) ? @unserialize($data) : $data;
            if ($data === false)
            {
                $this->remove_file($file);
                return false;
            }
            return $data;
        }
    }
    /**
    * Write cache data to a specified file
    *
    * 'data_global' is a special case and the generated format is different for this file:
    * <code>
    * <?php exit; ?>
    * (expiration)
    * (length of var and serialised data)
    * (var)
    * (serialised data)
    * ... (repeat)
    * </code>
    *
    * The other files have a similar format:
    * <code>
    * <?php exit; ?>
    * (expiration)
    * (query) [SQL files only]
    * (length of serialised data)
    * (serialised data)
    * </code>
    *
    * @access private
    * @param string $filename Filename to write
    * @param mixed $data Data to store
    * @param int $expires Timestamp when the data expires
    * @param string $query Query when caching SQL queries
    * @return bool True if the file was successfully created, otherwise false
    */
    function _write($filename, $data = null, $expires = 0, $query = '')
    {
        global $phpEx;
        $filename = $this->clean_varname($filename);
        $file = "{$this->cache_dir}$filename.$phpEx";
        $lock = new \phpbb\lock\flock($file);
        $lock->acquire();
        if ($handle = @fopen($file, 'wb'))
        {
            // File header
            fwrite($handle, '<' . '?php exit; ?' . '>');
            if ($filename == 'data_global')
            {
                // Global data is a different format
                foreach ($this->vars as $var => $data)
                {
                    if (strpos($var, "\r") !== false || strpos($var, "\n") !== false)
                    {
                        // CR/LF would cause fgets() to read the cache file incorrectly
                        // do not cache test entries, they probably won't be read back
                        // the cache keys should really be alphanumeric with a few symbols.
                        continue;
                    }
                    $data = serialize($data);
                    // Write out the expiration time
                    fwrite($handle, "\n" . $this->var_expires[$var] . "\n");
                    // Length of the remaining data for this var (ignoring two LF's)
                    fwrite($handle, strlen($data . $var) . "\n");
                    fwrite($handle, $var . "\n");
                    fwrite($handle, $data);
                }
            }
            else
            {
                fwrite($handle, "\n" . $expires . "\n");
                if (strpos($filename, 'sql_') === 0)
                {
                    fwrite($handle, $query . "\n");
                }
                $data = serialize($data);
                fwrite($handle, strlen($data) . "\n");
                fwrite($handle, $data);
            }
            fclose($handle);
            if (function_exists('opcache_invalidate'))
            {
                @opcache_invalidate($file);
            }
            try
            {
                $this->filesystem->phpbb_chmod($file, \phpbb\filesystem\filesystem_interface::CHMOD_READ | \phpbb\filesystem\filesystem_interface::CHMOD_WRITE);
            }
            catch (\phpbb\filesystem\exception\filesystem_exception $e)
            {
                // Do nothing
            }
            $return_value = true;
        }
        else
        {
            $return_value = false;
        }
        $lock->release();
        return $return_value;
    }
    /**
    * Replace slashes in the file name
    *
    * @param string $varname name of a cache variable
    * @return string $varname name that is safe to use as a filename
    */
    protected function clean_varname($varname)
    {
        return str_replace(array('/', '\\'), '-', $varname);
    }
}