| /* |
| * Copyright (c) 2008, 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. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * 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. |
| */ |
| |
| package sun.nio.fs; |
| |
| import java.nio.file.*; |
| import java.nio.channels.*; |
| import java.io.FileDescriptor; |
| import java.util.Set; |
| |
| import sun.nio.ch.FileChannelImpl; |
| import sun.nio.ch.ThreadPool; |
| import sun.nio.ch.SimpleAsynchronousFileChannelImpl; |
| import jdk.internal.access.SharedSecrets; |
| import jdk.internal.access.JavaIOFileDescriptorAccess; |
| |
| import static sun.nio.fs.UnixNativeDispatcher.*; |
| import static sun.nio.fs.UnixConstants.*; |
| |
| /** |
| * Factory for FileChannels and AsynchronousFileChannels |
| */ |
| |
| class UnixChannelFactory { |
| private static final JavaIOFileDescriptorAccess fdAccess = |
| SharedSecrets.getJavaIOFileDescriptorAccess(); |
| |
| protected UnixChannelFactory() { |
| } |
| |
| /** |
| * Represents the flags from a user-supplied set of open options. |
| */ |
| protected static class Flags { |
| boolean read; |
| boolean write; |
| boolean append; |
| boolean truncateExisting; |
| boolean noFollowLinks; |
| boolean create; |
| boolean createNew; |
| boolean deleteOnClose; |
| boolean sync; |
| boolean dsync; |
| |
| static Flags toFlags(Set<? extends OpenOption> options) { |
| Flags flags = new Flags(); |
| for (OpenOption option: options) { |
| if (option instanceof StandardOpenOption) { |
| switch ((StandardOpenOption)option) { |
| case READ : flags.read = true; break; |
| case WRITE : flags.write = true; break; |
| case APPEND : flags.append = true; break; |
| case TRUNCATE_EXISTING : flags.truncateExisting = true; break; |
| case CREATE : flags.create = true; break; |
| case CREATE_NEW : flags.createNew = true; break; |
| case DELETE_ON_CLOSE : flags.deleteOnClose = true; break; |
| case SPARSE : /* ignore */ break; |
| case SYNC : flags.sync = true; break; |
| case DSYNC : flags.dsync = true; break; |
| default: throw new UnsupportedOperationException(); |
| } |
| continue; |
| } |
| if (option == LinkOption.NOFOLLOW_LINKS && O_NOFOLLOW != 0) { |
| flags.noFollowLinks = true; |
| continue; |
| } |
| if (option == null) |
| throw new NullPointerException(); |
| throw new UnsupportedOperationException(option + " not supported"); |
| } |
| return flags; |
| } |
| } |
| |
| |
| /** |
| * Constructs a file channel from an existing (open) file descriptor |
| */ |
| static FileChannel newFileChannel(int fd, String path, boolean reading, boolean writing) { |
| FileDescriptor fdObj = new FileDescriptor(); |
| fdAccess.set(fdObj, fd); |
| return FileChannelImpl.open(fdObj, path, reading, writing, null); |
| } |
| |
| /** |
| * Constructs a file channel by opening a file using a dfd/path pair |
| */ |
| static FileChannel newFileChannel(int dfd, |
| UnixPath path, |
| String pathForPermissionCheck, |
| Set<? extends OpenOption> options, |
| int mode) |
| throws UnixException |
| { |
| Flags flags = Flags.toFlags(options); |
| |
| // default is reading; append => writing |
| if (!flags.read && !flags.write) { |
| if (flags.append) { |
| flags.write = true; |
| } else { |
| flags.read = true; |
| } |
| } |
| |
| // validation |
| if (flags.read && flags.append) |
| throw new IllegalArgumentException("READ + APPEND not allowed"); |
| if (flags.append && flags.truncateExisting) |
| throw new IllegalArgumentException("APPEND + TRUNCATE_EXISTING not allowed"); |
| |
| FileDescriptor fdObj = open(dfd, path, pathForPermissionCheck, flags, mode); |
| return FileChannelImpl.open(fdObj, path.toString(), flags.read, |
| // Android-changed: TODO: Remove this patch when the direct flag is supported. |
| // flags.write, flags.direct, null); |
| flags.write, null); |
| } |
| |
| /** |
| * Constructs a file channel by opening the given file. |
| */ |
| static FileChannel newFileChannel(UnixPath path, |
| Set<? extends OpenOption> options, |
| int mode) |
| throws UnixException |
| { |
| return newFileChannel(-1, path, null, options, mode); |
| } |
| |
| /** |
| * Constructs an asynchronous file channel by opening the given file. |
| */ |
| static AsynchronousFileChannel newAsynchronousFileChannel(UnixPath path, |
| Set<? extends OpenOption> options, |
| int mode, |
| ThreadPool pool) |
| throws UnixException |
| { |
| Flags flags = Flags.toFlags(options); |
| |
| // default is reading |
| if (!flags.read && !flags.write) { |
| flags.read = true; |
| } |
| |
| // validation |
| if (flags.append) |
| throw new UnsupportedOperationException("APPEND not allowed"); |
| |
| // for now use simple implementation |
| FileDescriptor fdObj = open(-1, path, null, flags, mode); |
| return SimpleAsynchronousFileChannelImpl.open(fdObj, flags.read, flags.write, pool); |
| } |
| |
| /** |
| * Opens file based on parameters and options, returning a FileDescriptor |
| * encapsulating the handle to the open file. |
| */ |
| protected static FileDescriptor open(int dfd, |
| UnixPath path, |
| String pathForPermissionCheck, |
| Flags flags, |
| int mode) |
| throws UnixException |
| { |
| // map to oflags |
| int oflags; |
| if (flags.read && flags.write) { |
| oflags = O_RDWR; |
| } else { |
| oflags = (flags.write) ? O_WRONLY : O_RDONLY; |
| } |
| if (flags.write) { |
| if (flags.truncateExisting) |
| oflags |= O_TRUNC; |
| if (flags.append) |
| oflags |= O_APPEND; |
| |
| // create flags |
| if (flags.createNew) { |
| byte[] pathForSysCall = path.asByteArray(); |
| |
| // throw exception if file name is "." to avoid confusing error |
| if ((pathForSysCall[pathForSysCall.length-1] == '.') && |
| (pathForSysCall.length == 1 || |
| (pathForSysCall[pathForSysCall.length-2] == '/'))) |
| { |
| throw new UnixException(EEXIST); |
| } |
| oflags |= (O_CREAT | O_EXCL); |
| } else { |
| if (flags.create) |
| oflags |= O_CREAT; |
| } |
| } |
| |
| // follow links by default |
| boolean followLinks = true; |
| if (!flags.createNew && (flags.noFollowLinks || flags.deleteOnClose)) { |
| if (flags.deleteOnClose && O_NOFOLLOW == 0) { |
| try { |
| if (UnixFileAttributes.get(path, false).isSymbolicLink()) |
| throw new UnixException("DELETE_ON_CLOSE specified and file is a symbolic link"); |
| } catch (UnixException x) { |
| if (!flags.create || x.errno() != ENOENT) |
| throw x; |
| } |
| } |
| followLinks = false; |
| oflags |= O_NOFOLLOW; |
| } |
| |
| if (flags.dsync) |
| oflags |= O_DSYNC; |
| if (flags.sync) |
| oflags |= O_SYNC; |
| |
| // permission check before we open the file |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) { |
| if (pathForPermissionCheck == null) |
| pathForPermissionCheck = path.getPathForPermissionCheck(); |
| if (flags.read) |
| sm.checkRead(pathForPermissionCheck); |
| if (flags.write) |
| sm.checkWrite(pathForPermissionCheck); |
| if (flags.deleteOnClose) |
| sm.checkDelete(pathForPermissionCheck); |
| } |
| |
| int fd; |
| try { |
| if (dfd >= 0) { |
| fd = openat(dfd, path.asByteArray(), oflags, mode); |
| } else { |
| fd = UnixNativeDispatcher.open(path, oflags, mode); |
| } |
| } catch (UnixException x) { |
| // Linux error can be EISDIR or EEXIST when file exists |
| if (flags.createNew && (x.errno() == EISDIR)) { |
| x.setError(EEXIST); |
| } |
| |
| // handle ELOOP to avoid confusing message |
| if (!followLinks && (x.errno() == ELOOP)) { |
| x = new UnixException(x.getMessage() + " (NOFOLLOW_LINKS specified)"); |
| } |
| |
| throw x; |
| } |
| |
| // unlink file immediately if delete on close. The spec is clear that |
| // an implementation cannot guarantee to unlink the correct file when |
| // replaced by an attacker after it is opened. |
| if (flags.deleteOnClose) { |
| try { |
| if (dfd >= 0) { |
| unlinkat(dfd, path.asByteArray(), 0); |
| } else { |
| unlink(path); |
| } |
| } catch (UnixException ignore) { |
| // best-effort |
| } |
| } |
| |
| // create java.io.FileDescriptor |
| FileDescriptor fdObj = new FileDescriptor(); |
| fdAccess.set(fdObj, fd); |
| return fdObj; |
| } |
| } |
