1 /*
   2  * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package jdk.internal.jrtfs;
  27 
  28 import java.io.*;
  29 import java.nio.channels.*;
  30 import java.nio.file.*;
  31 import java.nio.file.DirectoryStream.Filter;
  32 import java.nio.file.attribute.*;
  33 import java.nio.file.spi.FileSystemProvider;
  34 import java.net.URI;
  35 import java.net.URISyntaxException;
  36 import java.util.HashMap;
  37 import java.util.Map;
  38 import java.util.Set;
  39 import java.util.concurrent.ExecutorService;
  40 
  41 public final class JrtFileSystemProvider extends FileSystemProvider {
  42     private volatile FileSystem theFileSystem;
  43 
  44     public JrtFileSystemProvider() { }
  45 
  46     @Override
  47     public String getScheme() {
  48         return "jrt";
  49     }
  50 
  51     /**
  52      * Need FilePermission ${java.home}/-", "read" to create or get jrt:/
  53      */
  54     private void checkPermission() {
  55         SecurityManager sm = System.getSecurityManager();
  56         if (sm != null) {
  57             String home = SystemImages.RUNTIME_HOME;
  58             FilePermission perm =
  59                 new FilePermission(home + File.separator + "-", "read");
  60             sm.checkPermission(perm);
  61         }
  62     }
  63 
  64     private void checkUri(URI uri) {
  65         if (!uri.getScheme().equalsIgnoreCase(getScheme()))
  66             throw new IllegalArgumentException("URI does not match this provider");
  67         if (uri.getAuthority() != null)
  68             throw new IllegalArgumentException("Authority component present");
  69         if (uri.getPath() == null)
  70             throw new IllegalArgumentException("Path component is undefined");
  71         if (!uri.getPath().equals("/"))
  72             throw new IllegalArgumentException("Path component should be '/'");
  73         if (uri.getQuery() != null)
  74             throw new IllegalArgumentException("Query component present");
  75         if (uri.getFragment() != null)
  76             throw new IllegalArgumentException("Fragment component present");
  77     }
  78 
  79     @Override
  80     public FileSystem newFileSystem(URI uri, Map<String, ?> env)
  81         throws IOException
  82     {
  83         checkPermission();
  84         checkUri(uri);
  85         return new JrtFileSystem(this, env);
  86     }
  87 
  88     @Override
  89     public Path getPath(URI uri) {
  90         checkPermission();
  91         if (!uri.getScheme().equalsIgnoreCase(getScheme()))
  92             throw new IllegalArgumentException("URI does not match this provider");
  93         if (uri.getAuthority() != null)
  94             throw new IllegalArgumentException("Authority component present");
  95         if (uri.getQuery() != null)
  96             throw new IllegalArgumentException("Query component present");
  97         if (uri.getFragment() != null)
  98             throw new IllegalArgumentException("Fragment component present");
  99         String path = uri.getPath();
 100         if (path == null || path.charAt(0) != '/')
 101             throw new IllegalArgumentException("Invalid path component");
 102         return getTheFileSystem().getPath(path);
 103     }
 104 
 105     private FileSystem getTheFileSystem() {
 106         checkPermission();
 107         FileSystem fs = this.theFileSystem;
 108         if (fs == null) {
 109             synchronized (this) {
 110                 fs = this.theFileSystem;
 111                 if (fs == null) {
 112                     try {
 113                         this.theFileSystem = fs = new JrtFileSystem(this, null) {
 114                             @Override public void close() {
 115                                 throw new UnsupportedOperationException();
 116                             }
 117                         };
 118                     } catch (IOException ioe) {
 119                         throw new InternalError(ioe);
 120                     }
 121                 }
 122             }
 123         }
 124         return fs;
 125     }
 126 
 127     @Override
 128     public FileSystem getFileSystem(URI uri) {
 129         checkPermission();
 130         checkUri(uri);
 131         return getTheFileSystem();
 132     }
 133 
 134     // Checks that the given file is a JrtPath
 135     static final JrtPath toJrtPath(Path path) {
 136         if (path == null)
 137             throw new NullPointerException();
 138         if (!(path instanceof JrtPath))
 139             throw new ProviderMismatchException();
 140         return (JrtPath)path;
 141     }
 142 
 143     @Override
 144     public void checkAccess(Path path, AccessMode... modes) throws IOException {
 145         toJrtPath(path).checkAccess(modes);
 146     }
 147 
 148     @Override
 149     public void copy(Path src, Path target, CopyOption... options)
 150         throws IOException
 151     {
 152         toJrtPath(src).copy(toJrtPath(target), options);
 153     }
 154 
 155     @Override
 156     public void createDirectory(Path path, FileAttribute<?>... attrs)
 157         throws IOException
 158     {
 159         toJrtPath(path).createDirectory(attrs);
 160     }
 161 
 162     @Override
 163     public final void delete(Path path) throws IOException {
 164         toJrtPath(path).delete();
 165     }
 166 
 167     @Override
 168     @SuppressWarnings("unchecked")
 169     public <V extends FileAttributeView> V
 170         getFileAttributeView(Path path, Class<V> type, LinkOption... options)
 171     {
 172         return JrtFileAttributeView.get(toJrtPath(path), type);
 173     }
 174 
 175     @Override
 176     public FileStore getFileStore(Path path) throws IOException {
 177         return toJrtPath(path).getFileStore();
 178     }
 179 
 180     @Override
 181     public boolean isHidden(Path path) {
 182         return toJrtPath(path).isHidden();
 183     }
 184 
 185     @Override
 186     public boolean isSameFile(Path path, Path other) throws IOException {
 187         return toJrtPath(path).isSameFile(other);
 188     }
 189 
 190     @Override
 191     public void move(Path src, Path target, CopyOption... options)
 192         throws IOException
 193     {
 194         toJrtPath(src).move(toJrtPath(target), options);
 195     }
 196 
 197     @Override
 198     public AsynchronousFileChannel newAsynchronousFileChannel(Path path,
 199             Set<? extends OpenOption> options,
 200             ExecutorService exec,
 201             FileAttribute<?>... attrs)
 202             throws IOException
 203     {
 204         throw new UnsupportedOperationException();
 205     }
 206 
 207     @Override
 208     public SeekableByteChannel newByteChannel(Path path,
 209                                               Set<? extends OpenOption> options,
 210                                               FileAttribute<?>... attrs)
 211         throws IOException
 212     {
 213         return toJrtPath(path).newByteChannel(options, attrs);
 214     }
 215 
 216     @Override
 217     public DirectoryStream<Path> newDirectoryStream(
 218         Path path, Filter<? super Path> filter) throws IOException
 219     {
 220         return toJrtPath(path).newDirectoryStream(filter);
 221     }
 222 
 223     @Override
 224     public FileChannel newFileChannel(Path path,
 225                                       Set<? extends OpenOption> options,
 226                                       FileAttribute<?>... attrs)
 227         throws IOException
 228     {
 229         return toJrtPath(path).newFileChannel(options, attrs);
 230     }
 231 
 232     @Override
 233     public InputStream newInputStream(Path path, OpenOption... options)
 234         throws IOException
 235     {
 236         return toJrtPath(path).newInputStream(options);
 237     }
 238 
 239     @Override
 240     public OutputStream newOutputStream(Path path, OpenOption... options)
 241         throws IOException
 242     {
 243         return toJrtPath(path).newOutputStream(options);
 244     }
 245 
 246     @Override
 247     @SuppressWarnings("unchecked") // Cast to A
 248     public <A extends BasicFileAttributes> A
 249         readAttributes(Path path, Class<A> type, LinkOption... options)
 250         throws IOException
 251     {
 252         if (type == BasicFileAttributes.class || type == JrtFileAttributes.class)
 253             return (A)toJrtPath(path).getAttributes();
 254         return null;
 255     }
 256 
 257     @Override
 258     public Map<String, Object>
 259         readAttributes(Path path, String attribute, LinkOption... options)
 260         throws IOException
 261     {
 262         return toJrtPath(path).readAttributes(attribute, options);
 263     }
 264 
 265     @Override
 266     public void setAttribute(Path path, String attribute,
 267                              Object value, LinkOption... options)
 268         throws IOException
 269     {
 270         toJrtPath(path).setAttribute(attribute, value, options);
 271     }
 272 }