vendor/contao/core-bundle/src/Resources/contao/library/Contao/File.php line 259

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of Contao.
  5.  *
  6.  * (c) Leo Feyer
  7.  *
  8.  * @license LGPL-3.0-or-later
  9.  */
  11. namespace Contao;
  13. use Contao\CoreBundle\Exception\ResponseException;
  14. use Contao\Image\DeferredImageInterface;
  15. use Contao\Image\ImageDimensions;
  16. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  17. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  18. use Symfony\Component\String\UnicodeString;
  20. /**
  21.  * Creates, reads, writes and deletes files
  22.  *
  23.  * Usage:
  24.  *
  25.  *     $file = new File('test.txt');
  26.  *     $file->write('This is a test');
  27.  *     $file->close();
  28.  *
  29.  *     $file->delete();
  30.  *
  31.  *     File::putContent('test.txt', 'This is a test');
  32.  *
  33.  * @property integer  $size          The file size
  34.  * @property integer  $filesize      Alias of $size
  35.  * @property string   $name          The file name and extension
  36.  * @property string   $basename      Alias of $name
  37.  * @property string   $dirname       The path of the parent folder
  38.  * @property string   $extension     The lowercase file extension
  39.  * @property string   $origext       The original file extension
  40.  * @property string   $filename      The file name without extension
  41.  * @property string   $tmpname       The name of the temporary file
  42.  * @property string   $path          The file path
  43.  * @property string   $value         Alias of $path
  44.  * @property string   $mime          The mime type
  45.  * @property string   $hash          The MD5 checksum
  46.  * @property string   $ctime         The ctime
  47.  * @property string   $mtime         The mtime
  48.  * @property string   $atime         The atime
  49.  * @property string   $icon          The mime icon name
  50.  * @property string   $dataUri       The data URI
  51.  * @property array    $imageSize     The file dimensions (images only)
  52.  * @property integer  $width         The file width (images only)
  53.  * @property integer  $height        The file height (images only)
  54.  * @property array    $imageViewSize The viewbox dimensions
  55.  * @property integer  $viewWidth     The viewbox width
  56.  * @property integer  $viewHeight    The viewbox height
  57.  * @property boolean  $isImage       True if the file is an image
  58.  * @property boolean  $isGdImage     True if the file can be handled by the GDlib
  59.  * @property boolean  $isSvgImage    True if the file is an SVG image
  60.  * @property integer  $channels      The number of channels (images only)
  61.  * @property integer  $bits          The number of bits for each color (images only)
  62.  * @property boolean  $isRgbImage    True if the file is an RGB image
  63.  * @property boolean  $isCmykImage   True if the file is a CMYK image
  64.  * @property resource $handle        The file handle (returned by fopen())
  65.  * @property string   $title         The file title
  66.  */
  67. class File extends System
  68. {
  69.     /**
  70.      * File handle
  71.      * @var resource
  72.      */
  73.     protected $resFile;
  75.     /**
  76.      * File name
  77.      * @var string
  78.      */
  79.     protected $strFile;
  81.     /**
  82.      * Temp name
  83.      * @var string
  84.      */
  85.     protected $strTmp;
  87.     /**
  88.      * Files model
  89.      * @var FilesModel
  90.      */
  91.     protected $objModel;
  93.     /**
  94.      * Root dir
  95.      * @var string
  96.      */
  97.     protected $strRootDir;
  99.     /**
  100.      * Pathinfo
  101.      * @var array
  102.      */
  103.     protected $arrPathinfo = array();
  105.     /**
  106.      * Image size
  107.      * @var array
  108.      */
  109.     protected $arrImageSize = array();
  111.     /**
  112.      * Image size runtime cache
  113.      * @var array
  114.      */
  115.     protected static $arrImageSizeCache = array();
  117.     /**
  118.      * Image view size
  119.      * @var array
  120.      */
  121.     protected $arrImageViewSize = array();
  123.     /**
  124.      * Instantiate a new file object
  125.      *
  126.      * @param string $strFile The file path
  127.      *
  128.      * @throws \Exception If $strFile is a directory
  129.      */
  130.     public function __construct($strFile)
  131.     {
  132.         // Handle open_basedir restrictions
  133.         if ($strFile == '.')
  134.         {
  135.             $strFile = '';
  136.         }
  138.         $this->strRootDir = System::getContainer()->getParameter('kernel.project_dir');
  140.         // Make sure we are not pointing to a directory
  141.         if (is_dir($this->strRootDir . '/' . $strFile))
  142.         {
  143.             throw new \Exception(sprintf('Directory "%s" is not a file', $strFile));
  144.         }
  146.         $this->import(Files::class, 'Files');
  148.         $this->strFile = $strFile;
  149.     }
  151.     /**
  152.      * Close the file handle if it has not been done yet
  153.      */
  154.     public function __destruct()
  155.     {
  156.         if (\is_resource($this->resFile))
  157.         {
  158.             $this->Files->fclose($this->resFile);
  159.         }
  160.     }
  162.     /**
  163.      * Return an object property
  164.      *
  165.      * @param string $strKey The property name
  166.      *
  167.      * @return mixed The property value
  168.      */
  169.     public function __get($strKey)
  170.     {
  171.         switch ($strKey)
  172.         {
  173.             case 'size':
  174.             case 'filesize':
  175.                 return filesize($this->strRootDir . '/' . $this->strFile);
  177.             case 'name':
  178.             case 'basename':
  179.                 if (!isset($this->arrPathinfo[$strKey]))
  180.                 {
  181.                     $this->arrPathinfo = $this->getPathinfo();
  182.                 }
  184.                 return $this->arrPathinfo['basename'];
  186.             case 'dirname':
  187.             case 'filename':
  188.                 if (!isset($this->arrPathinfo[$strKey]))
  189.                 {
  190.                     $this->arrPathinfo = $this->getPathinfo();
  191.                 }
  193.                 return $this->arrPathinfo[$strKey];
  195.             case 'extension':
  196.                 if (!isset($this->arrPathinfo['extension']))
  197.                 {
  198.                     $this->arrPathinfo = $this->getPathinfo();
  199.                 }
  201.                 return strtolower($this->arrPathinfo['extension']);
  203.             case 'origext':
  204.                 if (!isset($this->arrPathinfo['extension']))
  205.                 {
  206.                     $this->arrPathinfo = $this->getPathinfo();
  207.                 }
  209.                 return $this->arrPathinfo['extension'];
  211.             case 'tmpname':
  212.                 return basename($this->strTmp);
  214.             case 'path':
  215.             case 'value':
  216.                 return $this->strFile;
  218.             case 'mime':
  219.                 return $this->getMimeType();
  221.             case 'hash':
  222.                 return $this->getHash();
  224.             case 'ctime':
  225.                 return filectime($this->strRootDir . '/' . $this->strFile);
  227.             case 'mtime':
  228.                 return filemtime($this->strRootDir . '/' . $this->strFile);
  230.             case 'atime':
  231.                 return fileatime($this->strRootDir . '/' . $this->strFile);
  233.             case 'icon':
  234.                 return $this->getIcon();
  236.             case 'dataUri':
  237.                 if ($this->extension == 'svgz')
  238.                 {
  239.                     return 'data:' . $this->mime . ';base64,' . base64_encode(gzdecode($this->getContent()));
  240.                 }
  242.                 return 'data:' . $this->mime . ';base64,' . base64_encode($this->getContent());
  244.             case 'imageSize':
  245.                 if (empty($this->arrImageSize))
  246.                 {
  247.                     $strCacheKey = $this->strFile . '|' . ($this->exists() ? $this->mtime : 0);
  249.                     if (isset(static::$arrImageSizeCache[$strCacheKey]))
  250.                     {
  251.                         $this->arrImageSize = static::$arrImageSizeCache[$strCacheKey];
  252.                     }
  253.                     else
  254.                     {
  255.                         $imageFactory = System::getContainer()->get('contao.image.factory');
  257.                         try
  258.                         {
  259.                             $dimensions = $imageFactory->create($this->strRootDir . '/' . $this->strFile)->getDimensions();
  261.                             if (!$dimensions->isRelative() && !$dimensions->isUndefined())
  262.                             {
  263.                                 $mapper = array
  264.                                 (
  265.                                     'gif' => IMAGETYPE_GIF,
  266.                                     'jpg' => IMAGETYPE_JPEG,
  267.                                     'jpeg' => IMAGETYPE_JPEG,
  268.                                     'png' => IMAGETYPE_PNG,
  269.                                     'webp' => IMAGETYPE_WEBP,
  270.                                     'avif' => \defined('IMAGETYPE_AVIF') ? IMAGETYPE_AVIF : 19,
  271.                                     'heic' => IMAGETYPE_UNKNOWN, // TODO: replace with IMAGETYPE_HEIC once available
  272.                                     'jxl' => IMAGETYPE_UNKNOWN, // TODO: replace with IMAGETYPE_JXL once available
  273.                                 );
  275.                                 $this->arrImageSize = array
  276.                                 (
  277.                                     $dimensions->getSize()->getWidth(),
  278.                                     $dimensions->getSize()->getHeight(),
  279.                                     $mapper[$this->extension] ?? 0,
  280.                                     'width="' . $dimensions->getSize()->getWidth() . '" height="' . $dimensions->getSize()->getHeight() . '"',
  281.                                     'bits' => 8,
  282.                                     'channels' => 3,
  283.                                     'mime' => $this->getMimeType()
  284.                                 );
  285.                             }
  286.                         }
  287.                         catch (\Exception $e)
  288.                         {
  289.                             // ignore
  290.                         }
  291.                     }
  293.                     if (!isset(static::$arrImageSizeCache[$strCacheKey]))
  294.                     {
  295.                         static::$arrImageSizeCache[$strCacheKey] = $this->arrImageSize;
  296.                     }
  297.                 }
  299.                 return $this->arrImageSize;
  301.             case 'width':
  302.                 return $this->imageSize[0] ?? null;
  304.             case 'height':
  305.                 return $this->imageSize[1] ?? null;
  307.             case 'imageViewSize':
  308.                 if (empty($this->arrImageViewSize))
  309.                 {
  310.                     if ($this->imageSize)
  311.                     {
  312.                         $this->arrImageViewSize = array
  313.                         (
  314.                             $this->imageSize[0],
  315.                             $this->imageSize[1]
  316.                         );
  317.                     }
  318.                     elseif ($this->isSvgImage)
  319.                     {
  320.                         try
  321.                         {
  322.                             $dimensions = new ImageDimensions(
  323.                                 System::getContainer()
  324.                                     ->get('contao.image.imagine_svg')
  325.                                     ->open($this->strRootDir . '/' . $this->strFile)
  326.                                     ->getSize()
  327.                             );
  329.                             $this->arrImageViewSize = array
  330.                             (
  331.                                 (int) $dimensions->getSize()->getWidth(),
  332.                                 (int) $dimensions->getSize()->getHeight()
  333.                             );
  335.                             if (!$this->arrImageViewSize[0] || !$this->arrImageViewSize[1] || $dimensions->isUndefined())
  336.                             {
  337.                                 $this->arrImageViewSize = false;
  338.                             }
  339.                         }
  340.                         catch (\Exception $e)
  341.                         {
  342.                             $this->arrImageViewSize = false;
  343.                         }
  344.                     }
  345.                 }
  347.                 return $this->arrImageViewSize;
  349.             case 'viewWidth':
  350.                 // Store in variable as empty() calls __isset() which is not implemented and thus always true
  351.                 $imageViewSize = $this->imageViewSize;
  353.                 return !empty($imageViewSize) ? $imageViewSize[0] : null;
  355.             case 'viewHeight':
  356.                 // Store in variable as empty() calls __isset() which is not implemented and thus always true
  357.                 $imageViewSize = $this->imageViewSize;
  359.                 return !empty($imageViewSize) ? $imageViewSize[1] : null;
  361.             case 'isImage':
  362.                 return $this->isGdImage || $this->isSvgImage;
  364.             case 'isGdImage':
  365.                 return \in_array($this->extension, array('gif', 'jpg', 'jpeg', 'png', 'webp', 'avif', 'heic', 'jxl'));
  367.             case 'isSvgImage':
  368.                 return \in_array($this->extension, array('svg', 'svgz'));
  370.             case 'channels':
  371.                 return $this->imageSize['channels'];
  373.             case 'bits':
  374.                 return $this->imageSize['bits'];
  376.             case 'isRgbImage':
  377.                 return $this->channels == 3;
  379.             case 'isCmykImage':
  380.                 return $this->channels == 4;
  382.             case 'handle':
  383.                 if (!\is_resource($this->resFile))
  384.                 {
  385.                     $this->resFile = fopen($this->strRootDir . '/' . $this->strFile, 'r');
  386.                 }
  388.                 return $this->resFile;
  390.             default:
  391.                 return parent::__get($strKey);
  392.         }
  393.     }
  395.     /**
  396.      * Create the file if it does not yet exist
  397.      *
  398.      * @throws \Exception If the file cannot be written
  399.      */
  400.     protected function createIfNotExists()
  401.     {
  402.         // The file exists
  403.         if (file_exists($this->strRootDir . '/' . $this->strFile))
  404.         {
  405.             return;
  406.         }
  408.         // Handle open_basedir restrictions
  409.         if (($strFolder = \dirname($this->strFile)) == '.')
  410.         {
  411.             $strFolder = '';
  412.         }
  414.         // Create the folder
  415.         if (!is_dir($this->strRootDir . '/' . $strFolder))
  416.         {
  417.             new Folder($strFolder);
  418.         }
  420.         // Open the file
  421.         if (!$this->resFile = $this->Files->fopen($this->strFile, 'wb'))
  422.         {
  423.             throw new \Exception(sprintf('Cannot create file "%s"', $this->strFile));
  424.         }
  425.     }
  427.     /**
  428.      * Check whether the file exists
  429.      *
  430.      * @return boolean True if the file exists
  431.      */
  432.     public function exists()
  433.     {
  434.         return file_exists($this->strRootDir . '/' . $this->strFile);
  435.     }
  437.     /**
  438.      * Truncate the file and reset the file pointer
  439.      *
  440.      * @return boolean True if the operation was successful
  441.      */
  442.     public function truncate()
  443.     {
  444.         if (\is_resource($this->resFile))
  445.         {
  446.             ftruncate($this->resFile, 0);
  447.             rewind($this->resFile);
  448.         }
  450.         return $this->write('');
  451.     }
  453.     /**
  454.      * Write data to the file
  455.      *
  456.      * @param mixed $varData The data to be written
  457.      *
  458.      * @return boolean True if the operation was successful
  459.      */
  460.     public function write($varData)
  461.     {
  462.         return $this->fputs($varData, 'wb');
  463.     }
  465.     /**
  466.      * Append data to the file
  467.      *
  468.      * @param mixed  $varData The data to be appended
  469.      * @param string $strLine The line ending (defaults to LF)
  470.      *
  471.      * @return boolean True if the operation was successful
  472.      */
  473.     public function append($varData, $strLine="\n")
  474.     {
  475.         return $this->fputs($varData . $strLine, 'ab');
  476.     }
  478.     /**
  479.      * Prepend data to the file
  480.      *
  481.      * @param mixed  $varData The data to be prepended
  482.      * @param string $strLine The line ending (defaults to LF)
  483.      *
  484.      * @return boolean True if the operation was successful
  485.      */
  486.     public function prepend($varData, $strLine="\n")
  487.     {
  488.         return $this->fputs($varData . $strLine . $this->getContent(), 'wb');
  489.     }
  491.     /**
  492.      * Delete the file
  493.      *
  494.      * @return boolean True if the operation was successful
  495.      */
  496.     public function delete()
  497.     {
  498.         $return = $this->Files->delete($this->strFile);
  500.         // Update the database
  501.         if (Dbafs::shouldBeSynchronized($this->strFile))
  502.         {
  503.             Dbafs::deleteResource($this->strFile);
  504.         }
  506.         return $return;
  507.     }
  509.     /**
  510.      * Set the file permissions
  511.      *
  512.      * @param integer $intChmod The CHMOD settings
  513.      *
  514.      * @return boolean True if the operation was successful
  515.      */
  516.     public function chmod($intChmod)
  517.     {
  518.         return $this->Files->chmod($this->strFile, $intChmod);
  519.     }
  521.     /**
  522.      * Close the file handle
  523.      *
  524.      * @return boolean True if the operation was successful
  525.      */
  526.     public function close()
  527.     {
  528.         if (\is_resource($this->resFile))
  529.         {
  530.             $this->Files->fclose($this->resFile);
  531.         }
  533.         // Create the file path
  534.         if (!file_exists($this->strRootDir . '/' . $this->strFile))
  535.         {
  536.             // Handle open_basedir restrictions
  537.             if (($strFolder = \dirname($this->strFile)) == '.')
  538.             {
  539.                 $strFolder = '';
  540.             }
  542.             // Create the parent folder
  543.             if (!is_dir($this->strRootDir . '/' . $strFolder))
  544.             {
  545.                 new Folder($strFolder);
  546.             }
  547.         }
  549.         // Move the temporary file to its destination
  550.         $return = $this->Files->rename($this->strTmp, $this->strFile);
  551.         $this->strTmp = null;
  553.         // Update the database
  554.         if (Dbafs::shouldBeSynchronized($this->strFile))
  555.         {
  556.             $this->objModel = Dbafs::addResource($this->strFile);
  557.         }
  559.         return $return;
  560.     }
  562.     /**
  563.      * Return the files model
  564.      *
  565.      * @return FilesModel The files model
  566.      */
  567.     public function getModel()
  568.     {
  569.         if ($this->objModel === null && Dbafs::shouldBeSynchronized($this->strFile))
  570.         {
  571.             $this->objModel = FilesModel::findByPath($this->strFile);
  572.         }
  574.         return $this->objModel;
  575.     }
  577.     /**
  578.      * Generate the image if the current file is a deferred image and does not exist yet
  579.      *
  580.      * @return bool True if a deferred image was resized otherwise false
  581.      */
  582.     public function createIfDeferred()
  583.     {
  584.         if (!$this->exists())
  585.         {
  586.             try
  587.             {
  588.                 $image = System::getContainer()->get('contao.image.factory')->create($this->strRootDir . '/' . $this->strFile);
  590.                 if ($image instanceof DeferredImageInterface)
  591.                 {
  592.                     System::getContainer()->get('contao.image.legacy_resizer')->resizeDeferredImage($image);
  594.                     return true;
  595.                 }
  596.             }
  597.             catch (\Throwable $e)
  598.             {
  599.                 // ignore
  600.             }
  601.         }
  603.         return false;
  604.     }
  606.     /**
  607.      * Return the file content as string
  608.      *
  609.      * @return string The file content without BOM
  610.      */
  611.     public function getContent()
  612.     {
  613.         $this->createIfDeferred();
  615.         $strContent = file_get_contents($this->strRootDir . '/' . ($this->strTmp ?: $this->strFile));
  617.         // Remove BOMs (see #4469)
  618.         if (strncmp($strContent, "\xEF\xBB\xBF", 3) === 0)
  619.         {
  620.             $strContent = substr($strContent, 3);
  621.         }
  622.         elseif (strncmp($strContent, "\xFF\xFE", 2) === 0)
  623.         {
  624.             $strContent = substr($strContent, 2);
  625.         }
  626.         elseif (strncmp($strContent, "\xFE\xFF", 2) === 0)
  627.         {
  628.             $strContent = substr($strContent, 2);
  629.         }
  631.         return $strContent;
  632.     }
  634.     /**
  635.      * Write to a file
  636.      *
  637.      * @param string $strFile    Relative file name
  638.      * @param string $strContent Content to be written
  639.      */
  640.     public static function putContent($strFile, $strContent)
  641.     {
  642.         $objFile = new static($strFile);
  643.         $objFile->write($strContent);
  644.         $objFile->close();
  645.     }
  647.     /**
  648.      * Return the file content as array
  649.      *
  650.      * @return array The file content as array
  651.      */
  652.     public function getContentAsArray()
  653.     {
  654.         return array_map('rtrim', file($this->strRootDir . '/' . $this->strFile));
  655.     }
  657.     /**
  658.      * Rename the file
  659.      *
  660.      * @param string $strNewName The new path
  661.      *
  662.      * @return boolean True if the operation was successful
  663.      */
  664.     public function renameTo($strNewName)
  665.     {
  666.         $strParent = \dirname($strNewName);
  668.         // Create the parent folder if it does not exist
  669.         if (!is_dir($this->strRootDir . '/' . $strParent))
  670.         {
  671.             new Folder($strParent);
  672.         }
  674.         $return = $this->Files->rename($this->strFile, $strNewName);
  676.         // Update the database AFTER the file has been renamed
  677.         $syncSource = Dbafs::shouldBeSynchronized($this->strFile);
  678.         $syncTarget = Dbafs::shouldBeSynchronized($strNewName);
  680.         // Synchronize the database
  681.         if ($syncSource && $syncTarget)
  682.         {
  683.             $this->objModel = Dbafs::moveResource($this->strFile, $strNewName);
  684.         }
  685.         elseif ($syncSource)
  686.         {
  687.             $this->objModel = Dbafs::deleteResource($this->strFile);
  688.         }
  689.         elseif ($syncTarget)
  690.         {
  691.             $this->objModel = Dbafs::addResource($strNewName);
  692.         }
  694.         // Reset the object AFTER the database has been updated
  695.         if ($return)
  696.         {
  697.             $this->strFile = $strNewName;
  698.             $this->arrImageSize = array();
  699.             $this->arrPathinfo = array();
  700.         }
  702.         return $return;
  703.     }
  705.     /**
  706.      * Copy the file
  707.      *
  708.      * @param string $strNewName The target path
  709.      *
  710.      * @return boolean True if the operation was successful
  711.      */
  712.     public function copyTo($strNewName)
  713.     {
  714.         $strParent = \dirname($strNewName);
  716.         // Create the parent folder if it does not exist
  717.         if (!is_dir($this->strRootDir . '/' . $strParent))
  718.         {
  719.             new Folder($strParent);
  720.         }
  722.         $return = $this->Files->copy($this->strFile, $strNewName);
  724.         // Update the database AFTER the file has been renamed
  725.         $syncSource = Dbafs::shouldBeSynchronized($this->strFile);
  726.         $syncTarget = Dbafs::shouldBeSynchronized($strNewName);
  728.         // Synchronize the database
  729.         if ($syncSource && $syncTarget)
  730.         {
  731.             Dbafs::copyResource($this->strFile, $strNewName);
  732.         }
  733.         elseif ($syncTarget)
  734.         {
  735.             Dbafs::addResource($strNewName);
  736.         }
  738.         return $return;
  739.     }
  741.     /**
  742.      * Resize the file if it is an image
  743.      *
  744.      * @param integer $width  The target width
  745.      * @param integer $height The target height
  746.      * @param string  $mode   The resize mode
  747.      *
  748.      * @return boolean True if the image could be resized successfully
  749.      */
  750.     public function resizeTo($width, $height, $mode='')
  751.     {
  752.         if (!$this->isImage)
  753.         {
  754.             return false;
  755.         }
  757.         System::getContainer()
  758.             ->get('contao.image.factory')
  759.             ->create($this->strRootDir . '/' . $this->strFile, array($width, $height, $mode), $this->strRootDir . '/' . $this->strFile)
  760.         ;
  762.         $this->arrPathinfo = array();
  763.         $this->arrImageSize = array();
  765.         // Clear the image size cache as mtime could potentially not change
  766.         unset(static::$arrImageSizeCache[$this->strFile . '|' . $this->mtime]);
  768.         return true;
  769.     }
  771.     /**
  772.      * Send the file to the browser
  773.      *
  774.      * @param string  $filename An optional filename
  775.      * @param boolean $inline   Show the file in the browser instead of opening the download dialog
  776.      *
  777.      * @throws ResponseException
  778.      */
  779.     public function sendToBrowser($filename='', $inline=false)
  780.     {
  781.         $response = new BinaryFileResponse($this->strRootDir . '/' . $this->strFile);
  782.         $response->setPrivate(); // public by default
  783.         $response->setAutoEtag();
  785.         $response->setContentDisposition
  786.         (
  787.             $inline ? ResponseHeaderBag::DISPOSITION_INLINE : ResponseHeaderBag::DISPOSITION_ATTACHMENT,
  788.             $filename,
  789.             (new UnicodeString($this->basename))->ascii()->toString()
  790.         );
  792.         $response->headers->addCacheControlDirective('must-revalidate');
  793.         $response->headers->set('Connection', 'close');
  794.         $response->headers->set('Content-Type', $this->getMimeType());
  796.         throw new ResponseException($response);
  797.     }
  799.     /**
  800.      * Check if any parent folder contains a .public file
  801.      *
  802.      * @return bool
  803.      */
  804.     public function isUnprotected()
  805.     {
  806.         return (new Folder(\dirname($this->strFile)))->isUnprotected();
  807.     }
  809.     /**
  810.      * Write data to a file
  811.      *
  812.      * @param mixed  $varData The data to be written
  813.      * @param string $strMode The operation mode
  814.      *
  815.      * @return boolean True if the operation was successful
  816.      */
  817.     protected function fputs($varData, $strMode)
  818.     {
  819.         if (!\is_resource($this->resFile))
  820.         {
  821.             $this->strTmp = 'system/tmp/' . md5(uniqid(mt_rand(), true));
  823.             // Copy the contents of the original file to append data
  824.             if (strncmp($strMode, 'a', 1) === 0 && file_exists($this->strRootDir . '/' . $this->strFile))
  825.             {
  826.                 $this->Files->copy($this->strFile, $this->strTmp);
  827.             }
  829.             // Open the temporary file
  830.             if (!$this->resFile = $this->Files->fopen($this->strTmp, $strMode))
  831.             {
  832.                 return false;
  833.             }
  834.         }
  836.         fwrite($this->resFile, $varData);
  838.         return true;
  839.     }
  841.     /**
  842.      * Return the mime type and icon of the file based on its extension
  843.      *
  844.      * @return array An array with mime type and icon name
  845.      */
  846.     protected function getMimeInfo()
  847.     {
  848.         return $GLOBALS['TL_MIME'][$this->extension] ?? array('application/octet-stream', 'iconPLAIN.svg');
  849.     }
  851.     /**
  852.      * Get the mime type of the file based on its extension
  853.      *
  854.      * @return string The mime type
  855.      */
  856.     protected function getMimeType()
  857.     {
  858.         $arrMime = $this->getMimeInfo();
  860.         return $arrMime[0];
  861.     }
  863.     /**
  864.      * Return the file icon depending on the file type
  865.      *
  866.      * @return string The icon name
  867.      */
  868.     protected function getIcon()
  869.     {
  870.         $arrMime = $this->getMimeInfo();
  872.         return $arrMime[1];
  873.     }
  875.     /**
  876.      * Return the MD5 hash of the file
  877.      *
  878.      * @return string The MD5 hash
  879.      */
  880.     protected function getHash()
  881.     {
  882.         return md5_file($this->strRootDir . '/' . $this->strFile);
  883.     }
  885.     /**
  886.      * Return the path info (binary-safe)
  887.      *
  888.      * @return array The path info
  889.      *
  890.      * @see https://github.com/PHPMailer/PHPMailer/blob/master/class.phpmailer.php#L3520
  891.      */
  892.     protected function getPathinfo()
  893.     {
  894.         $matches = array();
  895.         $return = array('dirname'=>'', 'basename'=>'', 'extension'=>'', 'filename'=>'');
  897.         preg_match('%^(.*?)[\\\\/]*(([^/\\\\]*?)(\.([^.\\\\/]+?)|))[\\\\/.]*$%m', $this->strFile, $matches);
  899.         if (isset($matches[1]))
  900.         {
  901.             $return['dirname'] = $this->strRootDir . '/' . $matches[1]; // see #8325
  902.         }
  904.         if (isset($matches[2]))
  905.         {
  906.             $return['basename'] = $matches[2];
  907.         }
  909.         if (isset($matches[5]))
  910.         {
  911.             $return['extension'] = $matches[5];
  912.         }
  914.         if (isset($matches[3]))
  915.         {
  916.             $return['filename'] = $matches[3];
  917.         }
  919.         return $return;
  920.     }
  921. }
  923. class_alias(File::class, 'File');