/*

 * Copyright (c) 2009, 2010, 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

 * @library ..

 * @build CheckPermissions

 * @run main/othervm CheckPermissions

 */

import java.nio.ByteBuffer;

import java.nio.file.*;

import java.nio.file.attribute.*;

import java.nio.channels.SeekableByteChannel;

import java.security.Permission;

import java.io.*;

import java.util.*;

/**

 * Checks each method that accesses the file system does the right permission

 * check when there is a security manager set.

 */

public class CheckPermissions {

    static class Checks {

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

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

        List<String> readsChecked()            { return readsChecked; }

        List<String> writesChecked()           { return writesChecked; }

        List<String> deletesChecked()          { return deletesChecked; }

        List<String> execsChecked()            { return execsChecked; }

    }

    static ThreadLocal<Checks> myChecks =

        new ThreadLocal<Checks>() {

            @Override protected Checks initialValue() {

                return null;

            }

        };

    static void prepare() {

        myChecks.set(new Checks());

    }

    static void assertCheckPermission(Class<? extends Permission> type,

                                      String name)

    {

        for (Permission perm: myChecks.get().permissionsChecked()) {

            if (type.isInstance(perm) && perm.getName().equals(name))

                return;

        }

    }

    static void assertCheckPropertyAccess(String key) {

        if (!myChecks.get().propertiesChecked().contains(key))

            throw new RuntimeException("Property " + key + " not checked");

    }

    static void assertChecked(Path file, List<String> list) {

        String s = file.toString();

        for (String f: list) {

            if (f.endsWith(s))

                return;

        }

        throw new RuntimeException("Access not checked");

    }

    static void assertCheckRead(Path file) {

        assertChecked(file, myChecks.get().readsChecked());

    }

    static void assertCheckWrite(Path file) {

        assertChecked(file, myChecks.get().writesChecked());

    }

    static void assertCheckDelete(Path file) {

        assertChecked(file, myChecks.get().deletesChecked());

    }

    static void assertCheckExec(Path file) {

        assertChecked(file, myChecks.get().execsChecked());

    }

    static class LoggingSecurityManager extends SecurityManager {

        static void install() {

            System.setSecurityManager(new LoggingSecurityManager());

        }

        @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);

        }

        @Override

        public void checkRead(String file) {

            Checks checks = myChecks.get();

            if (checks != null)

                checks.readsChecked().add(file);

        }

        @Override

        public void checkWrite(String file) {

            Checks checks = myChecks.get();

            if (checks != null)

                checks.writesChecked().add(file);

        }

        @Override

        public void checkDelete(String file) {

            Checks checks = myChecks.get();

            if (checks != null)

                checks.deletesChecked().add(file);

        }

        @Override

        public void checkExec(String file) {

            Checks checks = myChecks.get();

            if (checks != null)

                checks.execsChecked().add(file);

        }

    }

    static void testBasicFileAttributeView(BasicFileAttributeView view, Path file)

        throws IOException

    {

        prepare();

        view.readAttributes();

        assertCheckRead(file);

        prepare();

        FileTime now = FileTime.fromMillis(System.currentTimeMillis());

        view.setTimes(null, now, now);

        assertCheckWrite(file);

    }

    static void testPosixFileAttributeView(PosixFileAttributeView view, Path file)

        throws IOException

    {

        prepare();

        PosixFileAttributes attrs = view.readAttributes();

        assertCheckRead(file);

        assertCheckPermission(RuntimePermission.class, "accessUserInformation");

        prepare();

        view.setPermissions(attrs.permissions());

        assertCheckWrite(file);

        assertCheckPermission(RuntimePermission.class, "accessUserInformation");

        prepare();

        view.setOwner(attrs.owner());

        assertCheckWrite(file);

        assertCheckPermission(RuntimePermission.class, "accessUserInformation");

        prepare();

        view.setOwner(attrs.owner());

        assertCheckWrite(file);

        assertCheckPermission(RuntimePermission.class, "accessUserInformation");

    }

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

        try {

            LoggingSecurityManager.install();

            prepare();

            assertCheckRead(file);

            prepare();

            assertCheckWrite(file);

            prepare();

            assertCheckExec(file);

            prepare();

            try {

                assertCheckRead(file);

                assertCheckWrite(target);

            } finally {

            }

                try {

                    prepare();

                    try {

                        assertCheckRead(link);

                        assertCheckWrite(target);

                        assertCheckPermission(LinkPermission.class, "symbolic");

                    } finally {

                    }

                } finally {

                }

            }

            // -- createDirectory --

            prepare();

            try {

                assertCheckWrite(subdir);

            } finally {

            }

            // -- createFile --

            prepare();

            try {

                assertCheckWrite(fileToCreate);

            } finally {

            }

            // -- createSymbolicLink --

                prepare();

                try {

                    assertCheckWrite(link);

                    assertCheckPermission(LinkPermission.class, "symbolic");

                } finally {

                }

            }

            // -- delete/deleteIfExists --

            prepare();

            assertCheckDelete(fileToDelete);

            prepare();

            assertCheckDelete(fileToDelete);

            // -- exists/notExists --

            prepare();

            assertCheckRead(file);

            prepare();

            assertCheckRead(file);

            // -- getFileStore --

            prepare();

            assertCheckRead(file);

            assertCheckPermission(RuntimePermission.class, "getFileStoreAttributes");

            // -- isSameFile --

            prepare();

            assertCheckRead(file);

            prepare();

            try {

                assertCheckWrite(file);

                assertCheckWrite(target2);

            } finally {

                // restore file

            }

            // -- newByteChannel --

            prepare();

                assertCheckRead(file);

            }

            prepare();

                assertCheckWrite(file);

            }

            prepare();

                assertCheckRead(file);

                assertCheckWrite(file);

            }

            prepare();

                assertCheckRead(file);

                assertCheckDelete(file);

            }

            // -- newInputStream/newOutptuStream --

            prepare();

                assertCheckRead(file);

            }

            prepare();

                assertCheckWrite(file);

            }

            // -- newDirectoryStream --

            prepare();

                if (stream instanceof SecureDirectoryStream<?>) {

                    Path entry;

                    SecureDirectoryStream<Path> sds =

                        (SecureDirectoryStream<Path>)stream;

                    // newByteChannel

                    prepare();

                        assertCheckRead(file);

                    }

                    prepare();

                        assertCheckWrite(file);

                    }

                    // deleteFile

                    prepare();

                    sds.deleteFile(entry);

                    assertCheckDelete(file);

                    // deleteDirectory

                    entry = Paths.get("subdir1234");

                    prepare();

                    sds.deleteDirectory(entry);

                    // move

                    entry = Paths.get("tempname1234");

                    prepare();

                    assertCheckWrite(file);

                    // newDirectoryStream

                    entry = Paths.get("subdir1234");

                    try {

                        prepare();

                        sds.newDirectoryStream(entry).close();

                    } finally {

                    }

                    // getFileAttributeView to access attributes of directory

                    testBasicFileAttributeView(sds

                    testPosixFileAttributeView(sds

                    // getFileAttributeView to access attributes of entry

                    testBasicFileAttributeView(sds

                        .getFileAttributeView(entry, BasicFileAttributeView.class), file);

                    testPosixFileAttributeView(sds

                        .getFileAttributeView(entry, PosixFileAttributeView.class), file);