test/jdk/java/io/File/CheckPermission.java

/*
 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/* @test
 * @bug 8017212
 * @summary Examine methods in File.java that access the file system do the
 *          right permission check when a security manager exists.
 * @author Dan Xu
 */

import java.io.File;
import java.io.FilenameFilter;
import java.io.FileFilter;
import java.io.IOException;
import java.security.Permission;
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class CheckPermission {

    private static final String CHECK_PERMISSION_TEST = "CheckPermissionTest";

    public enum FileOperation {
        READ, WRITE, DELETE, EXEC
    }

    static class Checks {
        private List<Permission> permissionsChecked = new ArrayList<>();
        private Set<String> propertiesChecked = new HashSet<>();

        private Map<FileOperation, List<String>> fileOperationChecked =
            new EnumMap<>(FileOperation.class);

        List<Permission> permissionsChecked() {
            return permissionsChecked;
        }

        Set<String> propertiesChecked() {
            return propertiesChecked;
        }

        List<String> fileOperationChecked(FileOperation op) {
            return fileOperationChecked.get(op);
        }

        void addFileOperation(FileOperation op, String file) {
            List<String> opList = fileOperationChecked.get(op);
            if (opList == null) {
                opList = new ArrayList<>();
                fileOperationChecked.put(op, opList);
            }
            opList.add(file);
        }
    }

    static ThreadLocal<Checks> myChecks = new ThreadLocal<>();

    static void prepare() {
        myChecks.set(new Checks());
    }

    static class LoggingSecurityManager extends SecurityManager {
        static void install() {
            System.setSecurityManager(new LoggingSecurityManager());
        }

        private void checkFileOperation(FileOperation op, String file) {
            Checks checks = myChecks.get();
            if (checks != null)
                checks.addFileOperation(op, file);
        }

        @Override
        public void checkRead(String file) {
            checkFileOperation(FileOperation.READ, file);
        }

        @Override
        public void checkWrite(String file) {
            checkFileOperation(FileOperation.WRITE, file);
        }

        @Override
        public void checkDelete(String file) {
            checkFileOperation(FileOperation.DELETE, file);
        }

        @Override
        public void checkExec(String file) {
            checkFileOperation(FileOperation.EXEC, file);
        }

        @Override
        public void checkPermission(Permission perm) {
            Checks checks = myChecks.get();
            if (checks != null)
                checks.permissionsChecked().add(perm);
        }

        @Override
        public void checkPropertyAccess(String key) {
            Checks checks = myChecks.get();
            if (checks != null)
                checks.propertiesChecked().add(key);
        }
    }

    static void assertCheckPermission(Class<? extends Permission> type,
            String name)
    {
        for (Permission perm : myChecks.get().permissionsChecked()) {
            if (type.isInstance(perm) && perm.getName().equals(name))
                return;
        }
        throw new RuntimeException(type.getName() + "(\"" + name
            + "\") not checked");
    }

    static void assertCheckPropertyAccess(String key) {
        if (!myChecks.get().propertiesChecked().contains(key))
            throw new RuntimeException("Property " + key + " not checked");
    }

    static void assertChecked(File file, List<String> list) {
        if (list != null && !list.isEmpty()) {
            for (String path : list) {
                if (path.equals(file.getPath()))
                    return;
            }
        }
        throw new RuntimeException("Access not checked");
    }

    static void assertNotChecked(File file, List<String> list) {
        if (list != null && !list.isEmpty()) {
            for (String path : list) {
                if (path.equals(file.getPath()))
                    throw new RuntimeException("Access checked");
            }
        }
    }

    static void assertCheckOperation(File file, Set<FileOperation> ops) {
        for (FileOperation op : ops)
            assertChecked(file, myChecks.get().fileOperationChecked(op));
    }

    static void assertNotCheckOperation(File file, Set<FileOperation> ops) {
        for (FileOperation op : ops)
            assertNotChecked(file, myChecks.get().fileOperationChecked(op));
    }

    static void assertOnlyCheckOperation(File file,
            EnumSet<FileOperation> ops)
    {
        assertCheckOperation(file, ops);
        assertNotCheckOperation(file, EnumSet.complementOf(ops));
    }

    static File testFile, another;

    static void setup() {
        testFile = new File(CHECK_PERMISSION_TEST + System.currentTimeMillis());
        if (testFile.exists()) {
            testFile.delete();
        }

        another = new File(CHECK_PERMISSION_TEST + "Another"
                           + System.currentTimeMillis());
        if (another.exists()) {
            another.delete();
        }

        LoggingSecurityManager.install();
    }

    public static void main(String[] args) throws IOException {
        setup();

        prepare();
        testFile.canRead();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.canWrite();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.exists();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.isDirectory();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.isFile();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.isHidden();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.lastModified();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.length();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.createNewFile();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.list();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return false;
            }
        });
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.listFiles();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return false;
            }
        });
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.listFiles(new FileFilter() {
            @Override
            public boolean accept(File file) {
                return false;
            }
        });
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.mkdir();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        if (testFile.exists()) {
            prepare();
            testFile.mkdirs();
            assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));
        }

        if (!another.exists()) {
            prepare();
            another.mkdirs();
            assertOnlyCheckOperation(another,
                    EnumSet.of(FileOperation.READ, FileOperation.WRITE));
        }

        prepare();
        another.delete();
        assertOnlyCheckOperation(another, EnumSet.of(FileOperation.DELETE));

        prepare();
        boolean renRst = testFile.renameTo(another);
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));
        assertOnlyCheckOperation(another, EnumSet.of(FileOperation.WRITE));

        if (renRst) {
            if (testFile.exists())
                throw new RuntimeException(testFile + " is already renamed to "
                    + another);
            testFile = another;
        }

        prepare();
        testFile.setLastModified(0);
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.setReadOnly();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.setWritable(true, true);
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.setWritable(true);
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.setReadable(true, true);
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.setReadable(true);
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.setExecutable(true, true);
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.setExecutable(true);
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.canExecute();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.EXEC));

        prepare();
        testFile.getTotalSpace();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));
        assertCheckPermission(RuntimePermission.class,
                "getFileSystemAttributes");

        prepare();
        testFile.getFreeSpace();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));
        assertCheckPermission(RuntimePermission.class,
                "getFileSystemAttributes");

        prepare();
        testFile.getUsableSpace();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));
        assertCheckPermission(RuntimePermission.class,
                "getFileSystemAttributes");

        prepare();
        File tmpFile = File.createTempFile(CHECK_PERMISSION_TEST, null);
        assertOnlyCheckOperation(tmpFile, EnumSet.of(FileOperation.WRITE));
        tmpFile.delete();
        assertCheckOperation(tmpFile, EnumSet.of(FileOperation.DELETE));

        prepare();
        tmpFile = File.createTempFile(CHECK_PERMISSION_TEST, null, null);
        assertOnlyCheckOperation(tmpFile, EnumSet.of(FileOperation.WRITE));
        tmpFile.delete();
        assertCheckOperation(tmpFile, EnumSet.of(FileOperation.DELETE));

        prepare();
        testFile.deleteOnExit();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.DELETE));
    }
}