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

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. * @return never
  778. *
  779. * @throws ResponseException
  780. */
  781. public function sendToBrowser($filename='', $inline=false)
  782. {
  783. $response = new BinaryFileResponse($this->strRootDir . '/' . $this->strFile);
  784. $response->setPrivate(); // public by default
  785. $response->setAutoEtag();
  787. $response->setContentDisposition
  788. (
  789. $inline ? ResponseHeaderBag::DISPOSITION_INLINE : ResponseHeaderBag::DISPOSITION_ATTACHMENT,
  790. $filename,
  791. (new UnicodeString($this->basename))->ascii()->toString()
  792. );
  794. $response->headers->addCacheControlDirective('must-revalidate');
  795. $response->headers->set('Connection', 'close');
  796. $response->headers->set('Content-Type', $this->getMimeType());
  798. throw new ResponseException($response);
  799. }
  801. /**
  802. * Check if any parent folder contains a .public file
  803. *
  804. * @return bool
  805. */
  806. public function isUnprotected()
  807. {
  808. return (new Folder(\dirname($this->strFile)))->isUnprotected();
  809. }
  811. /**
  812. * Write data to a file
  813. *
  814. * @param mixed $varData The data to be written
  815. * @param string $strMode The operation mode
  816. *
  817. * @return boolean True if the operation was successful
  818. */
  819. protected function fputs($varData, $strMode)
  820. {
  821. if (!\is_resource($this->resFile))
  822. {
  823. $this->strTmp = 'system/tmp/' . md5(uniqid(mt_rand(), true));
  825. // Copy the contents of the original file to append data
  826. if (strncmp($strMode, 'a', 1) === 0 && file_exists($this->strRootDir . '/' . $this->strFile))
  827. {
  828. $this->Files->copy($this->strFile, $this->strTmp);
  829. }
  831. // Open the temporary file
  832. if (!$this->resFile = $this->Files->fopen($this->strTmp, $strMode))
  833. {
  834. return false;
  835. }
  836. }
  838. fwrite($this->resFile, $varData);
  840. return true;
  841. }
  843. /**
  844. * Return the mime type and icon of the file based on its extension
  845. *
  846. * @return array An array with mime type and icon name
  847. */
  848. protected function getMimeInfo()
  849. {
  850. return $GLOBALS['TL_MIME'][$this->extension] ?? array('application/octet-stream', 'iconPLAIN.svg');
  851. }
  853. /**
  854. * Get the mime type of the file based on its extension
  855. *
  856. * @return string The mime type
  857. */
  858. protected function getMimeType()
  859. {
  860. $arrMime = $this->getMimeInfo();
  862. return $arrMime[0];
  863. }
  865. /**
  866. * Return the file icon depending on the file type
  867. *
  868. * @return string The icon name
  869. */
  870. protected function getIcon()
  871. {
  872. $arrMime = $this->getMimeInfo();
  874. return $arrMime[1];
  875. }
  877. /**
  878. * Return the MD5 hash of the file
  879. *
  880. * @return string The MD5 hash
  881. */
  882. protected function getHash()
  883. {
  884. return md5_file($this->strRootDir . '/' . $this->strFile);
  885. }
  887. /**
  888. * Return the path info (binary-safe)
  889. *
  890. * @return array The path info
  891. *
  892. * @see https://github.com/PHPMailer/PHPMailer/blob/master/class.phpmailer.php#L3520
  893. */
  894. protected function getPathinfo()
  895. {
  896. $matches = array();
  897. $return = array('dirname'=>'', 'basename'=>'', 'extension'=>'', 'filename'=>'');
  899. preg_match('%^(.*?)[\\\\/]*(([^/\\\\]*?)(\.([^.\\\\/]+?)|))[\\\\/.]*$%m', $this->strFile, $matches);
  901. if (isset($matches[1]))
  902. {
  903. $return['dirname'] = $this->strRootDir . '/' . $matches[1]; // see #8325
  904. }
  906. if (isset($matches[2]))
  907. {
  908. $return['basename'] = $matches[2];
  909. }
  911. if (isset($matches[5]))
  912. {
  913. $return['extension'] = $matches[5];
  914. }
  916. if (isset($matches[3]))
  917. {
  918. $return['filename'] = $matches[3];
  919. }
  921. return $return;
  922. }
  923. }
  925. class_alias(File::class, 'File');