001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.util;
016    
017    import com.liferay.portal.kernel.security.pacl.permission.PortalFilePermission;
018    import com.liferay.portal.kernel.security.pacl.permission.PortalRuntimePermission;
019    
020    import java.io.File;
021    import java.io.FileInputStream;
022    import java.io.IOException;
023    import java.io.InputStream;
024    import java.io.Reader;
025    
026    import java.util.List;
027    import java.util.Properties;
028    
029    /**
030     * @author Brian Wing Shun Chan
031     * @author Alexander Chow
032     */
033    public class FileUtil {
034    
035            public static String appendParentheticalSuffix(
036                    String fileName, String suffix) {
037    
038                    return getFile().appendParentheticalSuffix(fileName, suffix);
039            }
040    
041            public static String appendSuffix(String fileName, String suffix) {
042                    return getFile().appendSuffix(fileName, suffix);
043            }
044    
045            public static void copyDirectory(File source, File destination)
046                    throws IOException {
047    
048                    PortalFilePermission.checkCopy(_getPath(source), _getPath(destination));
049    
050                    getFile().copyDirectory(source, destination);
051            }
052    
053            public static void copyDirectory(
054                            String sourceDirName, String destinationDirName)
055                    throws IOException {
056    
057                    PortalFilePermission.checkCopy(sourceDirName, destinationDirName);
058    
059                    getFile().copyDirectory(sourceDirName, destinationDirName);
060            }
061    
062            public static void copyFile(File source, File destination)
063                    throws IOException {
064    
065                    PortalFilePermission.checkCopy(_getPath(source), _getPath(destination));
066    
067                    getFile().copyFile(source, destination);
068            }
069    
070            public static void copyFile(File source, File destination, boolean lazy)
071                    throws IOException {
072    
073                    PortalFilePermission.checkCopy(_getPath(source), _getPath(destination));
074    
075                    getFile().copyFile(source, destination, lazy);
076            }
077    
078            public static void copyFile(String source, String destination)
079                    throws IOException {
080    
081                    PortalFilePermission.checkCopy(source, destination);
082    
083                    getFile().copyFile(source, destination);
084            }
085    
086            public static void copyFile(String source, String destination, boolean lazy)
087                    throws IOException {
088    
089                    PortalFilePermission.checkCopy(source, destination);
090    
091                    getFile().copyFile(source, destination, lazy);
092            }
093    
094            public static File createTempFile() {
095                    PortalFilePermission.checkWrite(
096                            SystemProperties.get(SystemProperties.TMP_DIR));
097    
098                    return getFile().createTempFile();
099            }
100    
101            public static File createTempFile(byte[] bytes) throws IOException {
102                    PortalFilePermission.checkWrite(
103                            SystemProperties.get(SystemProperties.TMP_DIR));
104    
105                    return getFile().createTempFile(bytes);
106            }
107    
108            public static File createTempFile(InputStream is) throws IOException {
109                    PortalFilePermission.checkWrite(
110                            SystemProperties.get(SystemProperties.TMP_DIR));
111    
112                    return getFile().createTempFile(is);
113            }
114    
115            public static File createTempFile(String extension) {
116                    PortalFilePermission.checkWrite(
117                            SystemProperties.get(SystemProperties.TMP_DIR));
118    
119                    return getFile().createTempFile(extension);
120            }
121    
122            public static File createTempFile(String prefix, String extension) {
123                    PortalFilePermission.checkWrite(
124                            SystemProperties.get(SystemProperties.TMP_DIR));
125    
126                    return getFile().createTempFile(prefix, extension);
127            }
128    
129            public static String createTempFileName() {
130                    PortalFilePermission.checkWrite(
131                            SystemProperties.get(SystemProperties.TMP_DIR));
132    
133                    return getFile().createTempFileName();
134            }
135    
136            public static String createTempFileName(String extension) {
137                    PortalFilePermission.checkWrite(
138                            SystemProperties.get(SystemProperties.TMP_DIR));
139    
140                    return getFile().createTempFileName(extension);
141            }
142    
143            public static String createTempFileName(String prefix, String extension) {
144                    PortalFilePermission.checkWrite(
145                            SystemProperties.get(SystemProperties.TMP_DIR));
146    
147                    return getFile().createTempFileName(prefix, extension);
148            }
149    
150            public static File createTempFolder() throws IOException {
151                    PortalFilePermission.checkWrite(
152                            SystemProperties.get(SystemProperties.TMP_DIR));
153    
154                    return getFile().createTempFolder();
155            }
156    
157            public static String decodeSafeFileName(String fileName) {
158                    return getFile().decodeSafeFileName(fileName);
159            }
160    
161            public static boolean delete(File file) {
162                    PortalFilePermission.checkDelete(_getPath(file));
163    
164                    return getFile().delete(file);
165            }
166    
167            public static boolean delete(String file) {
168                    PortalFilePermission.checkDelete(file);
169    
170                    return getFile().delete(file);
171            }
172    
173            public static void deltree(File directory) {
174                    PortalFilePermission.checkDelete(_getPath(directory));
175    
176                    getFile().deltree(directory);
177            }
178    
179            public static void deltree(String directory) {
180                    PortalFilePermission.checkDelete(directory);
181    
182                    getFile().deltree(directory);
183            }
184    
185            public static String encodeSafeFileName(String fileName) {
186                    return getFile().encodeSafeFileName(fileName);
187            }
188    
189            public static boolean exists(File file) {
190                    PortalFilePermission.checkRead(_getPath(file));
191    
192                    return getFile().exists(file);
193            }
194    
195            public static boolean exists(String fileName) {
196                    PortalFilePermission.checkRead(fileName);
197    
198                    return getFile().exists(fileName);
199            }
200    
201            /**
202             * Extracts the text from the input stream and file name.
203             *
204             * @param  is the file's input stream
205             * @param  fileName the file's full name or extension (e.g., "Test.doc" or
206             *         ".doc")
207             * @return the extracted text if it is a supported format or an empty string
208             *         if it is an unsupported format
209             */
210            public static String extractText(InputStream is, String fileName) {
211                    return getFile().extractText(is, fileName);
212            }
213    
214            public static String extractText(
215                    InputStream is, String fileName, int maxStringLength) {
216    
217                    return getFile().extractText(is, fileName, maxStringLength);
218            }
219    
220            public static String[] find(
221                    String directory, String includes, String excludes) {
222    
223                    PortalFilePermission.checkRead(directory);
224    
225                    return getFile().find(directory, includes, excludes);
226            }
227    
228            public static String getAbsolutePath(File file) {
229                    return getFile().getAbsolutePath(file);
230            }
231    
232            public static byte[] getBytes(Class<?> clazz, String fileName)
233                    throws Exception {
234    
235                    return getFile().getBytes(clazz, fileName);
236            }
237    
238            public static byte[] getBytes(File file) throws IOException {
239                    PortalFilePermission.checkRead(_getPath(file));
240    
241                    return getFile().getBytes(file);
242            }
243    
244            public static byte[] getBytes(InputStream is) throws IOException {
245                    return getFile().getBytes(is);
246            }
247    
248            public static byte[] getBytes(InputStream is, int bufferSize)
249                    throws IOException {
250    
251                    return getFile().getBytes(is);
252            }
253    
254            public static byte[] getBytes(
255                            InputStream is, int bufferSize, boolean cleanUpStream)
256                    throws IOException {
257    
258                    return getFile().getBytes(is, bufferSize, cleanUpStream);
259            }
260    
261            public static String getExtension(String fileName) {
262                    return getFile().getExtension(fileName);
263            }
264    
265            public static com.liferay.portal.kernel.util.File getFile() {
266                    PortalRuntimePermission.checkGetBeanProperty(FileUtil.class);
267    
268                    return _file;
269            }
270    
271            public static String getMD5Checksum(java.io.File file) throws IOException {
272                    return getFile().getMD5Checksum(file);
273            }
274    
275            public static String getPath(String fullFileName) {
276                    return getFile().getPath(fullFileName);
277            }
278    
279            public static String getShortFileName(String fullFileName) {
280                    return getFile().getShortFileName(fullFileName);
281            }
282    
283            public static boolean isAscii(File file) throws IOException {
284                    PortalFilePermission.checkRead(_getPath(file));
285    
286                    return getFile().isAscii(file);
287            }
288    
289            public static boolean isSameContent(File file, byte[] bytes, int length) {
290                    PortalFilePermission.checkRead(_getPath(file));
291    
292                    return getFile().isSameContent(file, bytes, length);
293            }
294    
295            public static boolean isSameContent(File file, String s) {
296                    PortalFilePermission.checkRead(_getPath(file));
297    
298                    return getFile().isSameContent(file, s);
299            }
300    
301            public static String[] listDirs(File file) {
302                    PortalFilePermission.checkRead(_getPath(file));
303    
304                    return getFile().listDirs(file);
305            }
306    
307            public static String[] listDirs(String fileName) {
308                    PortalFilePermission.checkRead(fileName);
309    
310                    return getFile().listDirs(fileName);
311            }
312    
313            public static String[] listFiles(File file) {
314                    PortalFilePermission.checkRead(_getPath(file));
315    
316                    return getFile().listFiles(file);
317            }
318    
319            public static String[] listFiles(String fileName) {
320                    PortalFilePermission.checkRead(fileName);
321    
322                    return getFile().listFiles(fileName);
323            }
324    
325            public static void mkdirs(File file) throws IOException {
326                    PortalFilePermission.checkCopy(_getPath(file), _getPath(file));
327    
328                    getFile().mkdirs(file);
329            }
330    
331            public static void mkdirs(String pathName) {
332                    PortalFilePermission.checkCopy(pathName, pathName);
333    
334                    getFile().mkdirs(pathName);
335            }
336    
337            public static boolean move(File source, File destination) {
338                    PortalFilePermission.checkMove(_getPath(source), _getPath(destination));
339    
340                    return getFile().move(source, destination);
341            }
342    
343            public static boolean move(
344                    String sourceFileName, String destinationFileName) {
345    
346                    PortalFilePermission.checkMove(sourceFileName, destinationFileName);
347    
348                    return getFile().move(sourceFileName, destinationFileName);
349            }
350    
351            public static String read(File file) throws IOException {
352                    PortalFilePermission.checkRead(_getPath(file));
353    
354                    return getFile().read(file);
355            }
356    
357            public static String read(File file, boolean raw) throws IOException {
358                    PortalFilePermission.checkRead(_getPath(file));
359    
360                    return getFile().read(file, raw);
361            }
362    
363            public static String read(String fileName) throws IOException {
364                    PortalFilePermission.checkRead(fileName);
365    
366                    return getFile().read(fileName);
367            }
368    
369            public static String replaceSeparator(String fileName) {
370                    return getFile().replaceSeparator(fileName);
371            }
372    
373            public static File[] sortFiles(File[] files) {
374                    return getFile().sortFiles(files);
375            }
376    
377            public static String stripExtension(String fileName) {
378                    return getFile().stripExtension(fileName);
379            }
380    
381            public static String stripParentheticalSuffix(String fileName) {
382                    return getFile().stripParentheticalSuffix(fileName);
383            }
384    
385            public static List<String> toList(Reader reader) {
386                    return getFile().toList(reader);
387            }
388    
389            public static List<String> toList(String fileName) {
390                    return getFile().toList(fileName);
391            }
392    
393            public static Properties toProperties(FileInputStream fis) {
394                    return getFile().toProperties(fis);
395            }
396    
397            public static Properties toProperties(String fileName) {
398                    PortalFilePermission.checkRead(fileName);
399    
400                    return getFile().toProperties(fileName);
401            }
402    
403            public static void touch(File file) throws IOException {
404                    PortalFilePermission.checkWrite(_getPath(file));
405    
406                    getFile().touch(file);
407            }
408    
409            public static void touch(String fileName) throws IOException {
410                    PortalFilePermission.checkWrite(fileName);
411    
412                    getFile().touch(fileName);
413            }
414    
415            public static void unzip(File source, File destination) {
416                    PortalFilePermission.checkCopy(_getPath(source), _getPath(destination));
417    
418                    getFile().unzip(source, destination);
419            }
420    
421            public static void write(File file, byte[] bytes) throws IOException {
422                    write(file, bytes, false);
423            }
424    
425            public static void write(File file, byte[] bytes, boolean append)
426                    throws IOException {
427    
428                    PortalFilePermission.checkWrite(_getPath(file));
429    
430                    getFile().write(file, bytes, append);
431            }
432    
433            public static void write(File file, byte[] bytes, int offset, int length)
434                    throws IOException {
435    
436                    write(file, bytes, offset, length, false);
437            }
438    
439            public static void write(
440                            File file, byte[] bytes, int offset, int length, boolean append)
441                    throws IOException {
442    
443                    PortalFilePermission.checkWrite(_getPath(file));
444    
445                    getFile().write(file, bytes, offset, length, append);
446            }
447    
448            public static void write(File file, InputStream is) throws IOException {
449                    PortalFilePermission.checkWrite(_getPath(file));
450    
451                    getFile().write(file, is);
452            }
453    
454            public static void write(File file, String s) throws IOException {
455                    PortalFilePermission.checkWrite(_getPath(file));
456    
457                    getFile().write(file, s);
458            }
459    
460            public static void write(File file, String s, boolean lazy)
461                    throws IOException {
462    
463                    PortalFilePermission.checkWrite(_getPath(file));
464    
465                    getFile().write(file, s, lazy);
466            }
467    
468            public static void write(File file, String s, boolean lazy, boolean append)
469                    throws IOException {
470    
471                    PortalFilePermission.checkWrite(_getPath(file));
472    
473                    getFile().write(file, s, lazy, append);
474            }
475    
476            public static void write(String fileName, byte[] bytes) throws IOException {
477                    PortalFilePermission.checkWrite(fileName);
478    
479                    getFile().write(fileName, bytes);
480            }
481    
482            public static void write(String fileName, InputStream is)
483                    throws IOException {
484    
485                    PortalFilePermission.checkWrite(fileName);
486    
487                    getFile().write(fileName, is);
488            }
489    
490            public static void write(String fileName, String s) throws IOException {
491                    PortalFilePermission.checkWrite(fileName);
492    
493                    getFile().write(fileName, s);
494            }
495    
496            public static void write(String fileName, String s, boolean lazy)
497                    throws IOException {
498    
499                    PortalFilePermission.checkWrite(fileName);
500    
501                    getFile().write(fileName, s, lazy);
502            }
503    
504            public static void write(
505                            String fileName, String s, boolean lazy, boolean append)
506                    throws IOException {
507    
508                    PortalFilePermission.checkWrite(fileName);
509    
510                    getFile().write(fileName, s, lazy, append);
511            }
512    
513            public static void write(String pathName, String fileName, String s)
514                    throws IOException {
515    
516                    PortalFilePermission.checkWrite(pathName);
517    
518                    getFile().write(pathName, fileName, s);
519            }
520    
521            public static void write(
522                            String pathName, String fileName, String s, boolean lazy)
523                    throws IOException {
524    
525                    PortalFilePermission.checkWrite(pathName);
526    
527                    getFile().write(pathName, fileName, s, lazy);
528            }
529    
530            public static void write(
531                            String pathName, String fileName, String s, boolean lazy,
532                            boolean append)
533                    throws IOException {
534    
535                    PortalFilePermission.checkWrite(pathName);
536    
537                    getFile().write(pathName, fileName, s, lazy, append);
538            }
539    
540            public void setFile(com.liferay.portal.kernel.util.File file) {
541                    PortalRuntimePermission.checkSetBeanProperty(getClass());
542    
543                    _file = file;
544            }
545    
546            private static String _getPath(File file) {
547                    if (file == null) {
548                            return null;
549                    }
550    
551                    return file.getPath();
552            }
553    
554            private static com.liferay.portal.kernel.util.File _file;
555    
556    }