1 <?php
  2 /**
  3  * @package     Joomla.Platform
  4  * @subpackage  FileSystem
  5  *
  6  * @copyright   Copyright (C) 2005 - 2017 Open Source Matters, Inc. All rights reserved.
  7  * @license     GNU General Public License version 2 or later; see LICENSE
  8  */
  9 
 10 defined('JPATH_PLATFORM') or die;
 11 
 12 /**
 13  * A File handling class
 14  *
 15  * @since  11.1
 16  */
 17 class JFile
 18 {
 19     /**
 20      * Gets the extension of a file name
 21      *
 22      * @param   string  $file  The file name
 23      *
 24      * @return  string  The file extension
 25      *
 26      * @since   11.1
 27      */
 28     public static function getExt($file)
 29     {
 30         $dot = strrpos($file, '.');
 31 
 32         if ($dot === false)
 33         {
 34             return '';
 35         }
 36 
 37         return (string) substr($file, $dot + 1);
 38     }
 39 
 40     /**
 41      * Strips the last extension off of a file name
 42      *
 43      * @param   string  $file  The file name
 44      *
 45      * @return  string  The file name without the extension
 46      *
 47      * @since   11.1
 48      */
 49     public static function stripExt($file)
 50     {
 51         return preg_replace('#\.[^.]*$#', '', $file);
 52     }
 53 
 54     /**
 55      * Makes file name safe to use
 56      *
 57      * @param   string  $file  The name of the file [not full path]
 58      *
 59      * @return  string  The sanitised string
 60      *
 61      * @since   11.1
 62      */
 63     public static function makeSafe($file)
 64     {
 65         // Remove any trailing dots, as those aren't ever valid file names.
 66         $file = rtrim($file, '.');
 67 
 68         $regex = array('#(\.){2,}#', '#[^A-Za-z0-9\.\_\- ]#', '#^\.#');
 69 
 70         return trim(preg_replace($regex, '', $file));
 71     }
 72 
 73     /**
 74      * Copies a file
 75      *
 76      * @param   string   $src          The path to the source file
 77      * @param   string   $dest         The path to the destination file
 78      * @param   string   $path         An optional base path to prefix to the file names
 79      * @param   boolean  $use_streams  True to use streams
 80      *
 81      * @return  boolean  True on success
 82      *
 83      * @since   11.1
 84      */
 85     public static function copy($src, $dest, $path = null, $use_streams = false)
 86     {
 87         $pathObject = new JFilesystemWrapperPath;
 88 
 89         // Prepend a base path if it exists
 90         if ($path)
 91         {
 92             $src = $pathObject->clean($path . '/' . $src);
 93             $dest = $pathObject->clean($path . '/' . $dest);
 94         }
 95 
 96         // Check src path
 97         if (!is_readable($src))
 98         {
 99             JLog::add(JText::sprintf('JLIB_FILESYSTEM_ERROR_JFILE_FIND_COPY', $src), JLog::WARNING, 'jerror');
100 
101             return false;
102         }
103 
104         if ($use_streams)
105         {
106             $stream = JFactory::getStream();
107 
108             if (!$stream->copy($src, $dest))
109             {
110                 JLog::add(JText::sprintf('JLIB_FILESYSTEM_ERROR_JFILE_STREAMS', $src, $dest, $stream->getError()), JLog::WARNING, 'jerror');
111 
112                 return false;
113             }
114 
115             return true;
116         }
117         else
118         {
119             $FTPOptions = JClientHelper::getCredentials('ftp');
120 
121             if ($FTPOptions['enabled'] == 1)
122             {
123                 // Connect the FTP client
124                 $ftp = JClientFtp::getInstance($FTPOptions['host'], $FTPOptions['port'], array(), $FTPOptions['user'], $FTPOptions['pass']);
125 
126                 // If the parent folder doesn't exist we must create it
127                 if (!file_exists(dirname($dest)))
128                 {
129                     $folderObject = new JFilesystemWrapperFolder;
130                     $folderObject->create(dirname($dest));
131                 }
132 
133                 // Translate the destination path for the FTP account
134                 $dest = $pathObject->clean(str_replace(JPATH_ROOT, $FTPOptions['root'], $dest), '/');
135 
136                 if (!$ftp->store($src, $dest))
137                 {
138                     // FTP connector throws an error
139                     return false;
140                 }
141 
142                 $ret = true;
143             }
144             else
145             {
146                 if (!@ copy($src, $dest))
147                 {
148                     JLog::add(JText::sprintf('JLIB_FILESYSTEM_ERROR_COPY_FAILED_ERR01', $src, $dest), JLog::WARNING, 'jerror');
149 
150                     return false;
151                 }
152 
153                 $ret = true;
154             }
155 
156             return $ret;
157         }
158     }
159 
160     /**
161      * Delete a file or array of files
162      *
163      * @param   mixed  $file  The file name or an array of file names
164      *
165      * @return  boolean  True on success
166      *
167      * @since   11.1
168      */
169     public static function delete($file)
170     {
171         $FTPOptions = JClientHelper::getCredentials('ftp');
172         $pathObject = new JFilesystemWrapperPath;
173 
174         if (is_array($file))
175         {
176             $files = $file;
177         }
178         else
179         {
180             $files[] = $file;
181         }
182 
183         // Do NOT use ftp if it is not enabled
184         if ($FTPOptions['enabled'] == 1)
185         {
186             // Connect the FTP client
187             $ftp = JClientFtp::getInstance($FTPOptions['host'], $FTPOptions['port'], array(), $FTPOptions['user'], $FTPOptions['pass']);
188         }
189 
190         foreach ($files as $file)
191         {
192             $file = $pathObject->clean($file);
193 
194             if (!is_file($file))
195             {
196                 continue;
197             }
198 
199             // Try making the file writable first. If it's read-only, it can't be deleted
200             // on Windows, even if the parent folder is writable
201             @chmod($file, 0777);
202 
203             // In case of restricted permissions we zap it one way or the other
204             // as long as the owner is either the webserver or the ftp
205             if (@unlink($file))
206             {
207                 // Do nothing
208             }
209             elseif ($FTPOptions['enabled'] == 1)
210             {
211                 $file = $pathObject->clean(str_replace(JPATH_ROOT, $FTPOptions['root'], $file), '/');
212 
213                 if (!$ftp->delete($file))
214                 {
215                     // FTP connector throws an error
216 
217                     return false;
218                 }
219             }
220             else
221             {
222                 $filename = basename($file);
223                 JLog::add(JText::sprintf('JLIB_FILESYSTEM_DELETE_FAILED', $filename), JLog::WARNING, 'jerror');
224 
225                 return false;
226             }
227         }
228 
229         return true;
230     }
231 
232     /**
233      * Moves a file
234      *
235      * @param   string   $src          The path to the source file
236      * @param   string   $dest         The path to the destination file
237      * @param   string   $path         An optional base path to prefix to the file names
238      * @param   boolean  $use_streams  True to use streams
239      *
240      * @return  boolean  True on success
241      *
242      * @since   11.1
243      */
244     public static function move($src, $dest, $path = '', $use_streams = false)
245     {
246         $pathObject = new JFilesystemWrapperPath;
247 
248         if ($path)
249         {
250             $src = $pathObject->clean($path . '/' . $src);
251             $dest = $pathObject->clean($path . '/' . $dest);
252         }
253 
254         // Check src path
255         if (!is_readable($src))
256         {
257             JLog::add(JText::_('JLIB_FILESYSTEM_CANNOT_FIND_SOURCE_FILE'), JLog::WARNING, 'jerror');
258 
259             return false;
260         }
261 
262         if ($use_streams)
263         {
264             $stream = JFactory::getStream();
265 
266             if (!$stream->move($src, $dest))
267             {
268                 JLog::add(JText::sprintf('JLIB_FILESYSTEM_ERROR_JFILE_MOVE_STREAMS', $stream->getError()), JLog::WARNING, 'jerror');
269 
270                 return false;
271             }
272 
273             return true;
274         }
275         else
276         {
277             $FTPOptions = JClientHelper::getCredentials('ftp');
278 
279             if ($FTPOptions['enabled'] == 1)
280             {
281                 // Connect the FTP client
282                 $ftp = JClientFtp::getInstance($FTPOptions['host'], $FTPOptions['port'], array(), $FTPOptions['user'], $FTPOptions['pass']);
283 
284                 // Translate path for the FTP account
285                 $src = $pathObject->clean(str_replace(JPATH_ROOT, $FTPOptions['root'], $src), '/');
286                 $dest = $pathObject->clean(str_replace(JPATH_ROOT, $FTPOptions['root'], $dest), '/');
287 
288                 // Use FTP rename to simulate move
289                 if (!$ftp->rename($src, $dest))
290                 {
291                     JLog::add(JText::_('JLIB_FILESYSTEM_ERROR_RENAME_FILE'), JLog::WARNING, 'jerror');
292 
293                     return false;
294                 }
295             }
296             else
297             {
298                 if (!@ rename($src, $dest))
299                 {
300                     JLog::add(JText::_('JLIB_FILESYSTEM_ERROR_RENAME_FILE'), JLog::WARNING, 'jerror');
301 
302                     return false;
303                 }
304             }
305 
306             return true;
307         }
308     }
309 
310     /**
311      * Read the contents of a file
312      *
313      * @param   string   $filename   The full file path
314      * @param   boolean  $incpath    Use include path
315      * @param   integer  $amount     Amount of file to read
316      * @param   integer  $chunksize  Size of chunks to read
317      * @param   integer  $offset     Offset of the file
318      *
319      * @return  mixed  Returns file contents or boolean False if failed
320      *
321      * @since   11.1
322      * @deprecated  13.3 (Platform) & 4.0 (CMS) - Use the native file_get_contents() instead.
323      */
324     public static function read($filename, $incpath = false, $amount = 0, $chunksize = 8192, $offset = 0)
325     {
326         JLog::add(__METHOD__ . ' is deprecated. Use native file_get_contents() syntax.', JLog::WARNING, 'deprecated');
327 
328         $data = null;
329 
330         if ($amount && $chunksize > $amount)
331         {
332             $chunksize = $amount;
333         }
334 
335         if (false === $fh = fopen($filename, 'rb', $incpath))
336         {
337             JLog::add(JText::sprintf('JLIB_FILESYSTEM_ERROR_READ_UNABLE_TO_OPEN_FILE', $filename), JLog::WARNING, 'jerror');
338 
339             return false;
340         }
341 
342         clearstatcache();
343 
344         if ($offset)
345         {
346             fseek($fh, $offset);
347         }
348 
349         if ($fsize = @ filesize($filename))
350         {
351             if ($amount && $fsize > $amount)
352             {
353                 $data = fread($fh, $amount);
354             }
355             else
356             {
357                 $data = fread($fh, $fsize);
358             }
359         }
360         else
361         {
362             $data = '';
363 
364             /*
365              * While it's:
366              * 1: Not the end of the file AND
367              * 2a: No Max Amount set OR
368              * 2b: The length of the data is less than the max amount we want
369              */
370             while (!feof($fh) && (!$amount || strlen($data) < $amount))
371             {
372                 $data .= fread($fh, $chunksize);
373             }
374         }
375 
376         fclose($fh);
377 
378         return $data;
379     }
380 
381     /**
382      * Write contents to a file
383      *
384      * @param   string   $file         The full file path
385      * @param   string   $buffer       The buffer to write
386      * @param   boolean  $use_streams  Use streams
387      *
388      * @return  boolean  True on success
389      *
390      * @since   11.1
391      */
392     public static function write($file, $buffer, $use_streams = false)
393     {
394         @set_time_limit(ini_get('max_execution_time'));
395 
396         // If the destination directory doesn't exist we need to create it
397         if (!file_exists(dirname($file)))
398         {
399             $folderObject = new JFilesystemWrapperFolder;
400 
401             if ($folderObject->create(dirname($file)) == false)
402             {
403                 return false;
404             }
405         }
406 
407         if ($use_streams)
408         {
409             $stream = JFactory::getStream();
410 
411             // Beef up the chunk size to a meg
412             $stream->set('chunksize', (1024 * 1024));
413 
414             if (!$stream->writeFile($file, $buffer))
415             {
416                 JLog::add(JText::sprintf('JLIB_FILESYSTEM_ERROR_WRITE_STREAMS', $file, $stream->getError()), JLog::WARNING, 'jerror');
417 
418                 return false;
419             }
420 
421             return true;
422         }
423         else
424         {
425             $FTPOptions = JClientHelper::getCredentials('ftp');
426             $pathObject = new JFilesystemWrapperPath;
427 
428             if ($FTPOptions['enabled'] == 1)
429             {
430                 // Connect the FTP client
431                 $ftp = JClientFtp::getInstance($FTPOptions['host'], $FTPOptions['port'], array(), $FTPOptions['user'], $FTPOptions['pass']);
432 
433                 // Translate path for the FTP account and use FTP write buffer to file
434                 $file = $pathObject->clean(str_replace(JPATH_ROOT, $FTPOptions['root'], $file), '/');
435                 $ret = $ftp->write($file, $buffer);
436             }
437             else
438             {
439                 $file = $pathObject->clean($file);
440                 $ret = is_int(file_put_contents($file, $buffer)) ? true : false;
441             }
442 
443             return $ret;
444         }
445     }
446 
447     /**
448      * Append contents to a file
449      *
450      * @param   string   $file         The full file path
451      * @param   string   $buffer       The buffer to write
452      * @param   boolean  $use_streams  Use streams
453      *
454      * @return  boolean  True on success
455      *
456      * @since   3.6.0
457      */
458     public static function append($file, $buffer, $use_streams = false)
459     {
460         @set_time_limit(ini_get('max_execution_time'));
461 
462         // If the file doesn't exist, just write instead of append
463         if (!file_exists($file))
464         {
465             return self::write($file, $buffer, $use_streams);
466         }
467 
468         if ($use_streams)
469         {
470             $stream = JFactory::getStream();
471 
472             // Beef up the chunk size to a meg
473             $stream->set('chunksize', (1024 * 1024));
474 
475             if ($stream->open($file, 'ab') && $stream->write($buffer) && $stream->close())
476             {
477                 return true;
478             }
479 
480             JLog::add(JText::sprintf('JLIB_FILESYSTEM_ERROR_WRITE_STREAMS', $file, $stream->getError()), JLog::WARNING, 'jerror');
481 
482             return false;
483         }
484         else
485         {
486             // Initialise variables.
487             $FTPOptions = JClientHelper::getCredentials('ftp');
488 
489             if ($FTPOptions['enabled'] == 1)
490             {
491                 // Connect the FTP client
492                 $ftp = JClientFtp::getInstance($FTPOptions['host'], $FTPOptions['port'], array(), $FTPOptions['user'], $FTPOptions['pass']);
493 
494                 // Translate path for the FTP account and use FTP write buffer to file
495                 $file = JPath::clean(str_replace(JPATH_ROOT, $FTPOptions['root'], $file), '/');
496                 $ret = $ftp->append($file, $buffer);
497             }
498             else
499             {
500                 $file = JPath::clean($file);
501                 $ret = is_int(file_put_contents($file, $buffer, FILE_APPEND));
502             }
503 
504             return $ret;
505         }
506     }
507 
508     /**
509      * Moves an uploaded file to a destination folder
510      *
511      * @param   string   $src              The name of the php (temporary) uploaded file
512      * @param   string   $dest             The path (including filename) to move the uploaded file to
513      * @param   boolean  $use_streams      True to use streams
514      * @param   boolean  $allow_unsafe     Allow the upload of unsafe files
515      * @param   boolean  $safeFileOptions  Options to JFilterInput::isSafeFile
516      *
517      * @return  boolean  True on success
518      *
519      * @since   11.1
520      */
521     public static function upload($src, $dest, $use_streams = false, $allow_unsafe = false, $safeFileOptions = array())
522     {
523         if (!$allow_unsafe)
524         {
525             $descriptor = array(
526                 'tmp_name' => $src,
527                 'name'     => basename($dest),
528                 'type'     => '',
529                 'error'    => '',
530                 'size'     => '',
531             );
532 
533             $isSafe = JFilterInput::isSafeFile($descriptor, $safeFileOptions);
534 
535             if (!$isSafe)
536             {
537                 JLog::add(JText::sprintf('JLIB_FILESYSTEM_ERROR_WARNFS_ERR03', $dest), JLog::WARNING, 'jerror');
538 
539                 return false;
540             }
541         }
542 
543         // Ensure that the path is valid and clean
544         $pathObject = new JFilesystemWrapperPath;
545         $dest = $pathObject->clean($dest);
546 
547         // Create the destination directory if it does not exist
548         $baseDir = dirname($dest);
549 
550         if (!file_exists($baseDir))
551         {
552             $folderObject = new JFilesystemWrapperFolder;
553             $folderObject->create($baseDir);
554         }
555 
556         if ($use_streams)
557         {
558             $stream = JFactory::getStream();
559 
560             if (!$stream->upload($src, $dest))
561             {
562                 JLog::add(JText::sprintf('JLIB_FILESYSTEM_ERROR_UPLOAD', $stream->getError()), JLog::WARNING, 'jerror');
563 
564                 return false;
565             }
566 
567             return true;
568         }
569         else
570         {
571             $FTPOptions = JClientHelper::getCredentials('ftp');
572             $ret = false;
573 
574             if ($FTPOptions['enabled'] == 1)
575             {
576                 // Connect the FTP client
577                 $ftp = JClientFtp::getInstance($FTPOptions['host'], $FTPOptions['port'], array(), $FTPOptions['user'], $FTPOptions['pass']);
578 
579                 // Translate path for the FTP account
580                 $dest = $pathObject->clean(str_replace(JPATH_ROOT, $FTPOptions['root'], $dest), '/');
581 
582                 // Copy the file to the destination directory
583                 if (is_uploaded_file($src) && $ftp->store($src, $dest))
584                 {
585                     unlink($src);
586                     $ret = true;
587                 }
588                 else
589                 {
590                     JLog::add(JText::sprintf('JLIB_FILESYSTEM_ERROR_WARNFS_ERR04', $src, $dest), JLog::WARNING, 'jerror');
591                 }
592             }
593             else
594             {
595                 if (is_writeable($baseDir) && move_uploaded_file($src, $dest))
596                 {
597                     // Short circuit to prevent file permission errors
598                     if ($pathObject->setPermissions($dest))
599                     {
600                         $ret = true;
601                     }
602                     else
603                     {
604                         JLog::add(JText::_('JLIB_FILESYSTEM_ERROR_WARNFS_ERR01'), JLog::WARNING, 'jerror');
605                     }
606                 }
607                 else
608                 {
609                     JLog::add(JText::sprintf('JLIB_FILESYSTEM_ERROR_WARNFS_ERR04', $src, $dest), JLog::WARNING, 'jerror');
610                 }
611             }
612 
613             return $ret;
614         }
615     }
616 
617     /**
618      * Wrapper for the standard file_exists function
619      *
620      * @param   string  $file  File path
621      *
622      * @return  boolean  True if path is a file
623      *
624      * @since   11.1
625      */
626     public static function exists($file)
627     {
628         $pathObject = new JFilesystemWrapperPath;
629 
630         return is_file($pathObject->clean($file));
631     }
632 
633     /**
634      * Returns the name, without any path.
635      *
636      * @param   string  $file  File path
637      *
638      * @return  string  filename
639      *
640      * @since   11.1
641      * @deprecated  13.3 (Platform) & 4.0 (CMS) - Use basename() instead.
642      */
643     public static function getName($file)
644     {
645         JLog::add(__METHOD__ . ' is deprecated. Use native basename() syntax.', JLog::WARNING, 'deprecated');
646 
647         // Convert back slashes to forward slashes
648         $file = str_replace('\\', '/', $file);
649         $slash = strrpos($file, '/');
650 
651         if ($slash !== false)
652         {
653             return substr($file, $slash + 1);
654         }
655         else
656         {
657             return $file;
658         }
659     }
660 }
661 

Joomla! Framework TM API documentation generated by ApiGen 2.8.0
Joomla!® and Joomla! Framework™ are trademarks of Open Source Matters, Inc. in the United States and other countries.