1 /*
   2  * Copyright (c) 2008, 2011, 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 sun.nio.fs;
  27 
  28 import java.nio.file.*;
  29 import java.nio.channels.*;
  30 import java.io.FileDescriptor;
  31 import java.util.Set;
  32 
  33 import sun.nio.ch.FileChannelImpl;
  34 import sun.nio.ch.ThreadPool;
  35 import sun.nio.ch.SimpleAsynchronousFileChannelImpl;
  36 import sun.misc.SharedSecrets;
  37 import sun.misc.JavaIOFileDescriptorAccess;
  38 
  39 import static sun.nio.fs.UnixNativeDispatcher.*;
  40 import static sun.nio.fs.UnixConstants.*;
  41 
  42 /**
  43  * Factory for FileChannels and AsynchronousFileChannels
  44  */
  45 
  46 class UnixChannelFactory {
  47     private static final JavaIOFileDescriptorAccess fdAccess =
  48         SharedSecrets.getJavaIOFileDescriptorAccess();
  49 
  50     protected UnixChannelFactory() {
  51     }
  52 
  53     /**
  54      * Represents the flags from a user-supplied set of open options.
  55      */
  56     protected static class Flags {
  57         boolean read;
  58         boolean write;
  59         boolean append;
  60         boolean truncateExisting;
  61         boolean noFollowLinks;
  62         boolean create;
  63         boolean createNew;
  64         boolean deleteOnClose;
  65         boolean sync;
  66         boolean dsync;
  67 
  68         static Flags toFlags(Set<? extends OpenOption> options) {
  69             Flags flags = new Flags();
  70             for (OpenOption option: options) {
  71                 if (option instanceof StandardOpenOption) {
  72                     switch ((StandardOpenOption)option) {
  73                         case READ : flags.read = true; break;
  74                         case WRITE : flags.write = true; break;
  75                         case APPEND : flags.append = true; break;
  76                         case TRUNCATE_EXISTING : flags.truncateExisting = true; break;
  77                         case CREATE : flags.create = true; break;
  78                         case CREATE_NEW : flags.createNew = true; break;
  79                         case DELETE_ON_CLOSE : flags.deleteOnClose = true; break;
  80                         case SPARSE : /* ignore */ break;
  81                         case SYNC : flags.sync = true; break;
  82                         case DSYNC : flags.dsync = true; break;
  83                         default: throw new UnsupportedOperationException();
  84                     }
  85                     continue;
  86                 }
  87                 if (option == LinkOption.NOFOLLOW_LINKS && supportsNoFollowLinks()) {
  88                     flags.noFollowLinks = true;
  89                     continue;
  90                 }
  91                 if (option == null)
  92                     throw new NullPointerException();
  93                throw new UnsupportedOperationException(option + " not supported");
  94             }
  95             return flags;
  96         }
  97     }
  98 
  99 
 100     /**
 101      * Constructs a file channel from an existing (open) file descriptor
 102      */
 103     static FileChannel newFileChannel(int fd, String path, boolean reading, boolean writing) {
 104         FileDescriptor fdObj = new FileDescriptor();
 105         fdAccess.set(fdObj, fd);
 106         return FileChannelImpl.open(fdObj, path, reading, writing, null);
 107     }
 108 
 109     /**
 110      * Constructs a file channel by opening a file using a dfd/path pair
 111      */
 112     static FileChannel newFileChannel(int dfd,
 113                                       UnixPath path,
 114                                       String pathForPermissionCheck,
 115                                       Set<? extends OpenOption> options,
 116                                       int mode)
 117         throws UnixException
 118     {
 119         Flags flags = Flags.toFlags(options);
 120 
 121         // default is reading; append => writing
 122         if (!flags.read && !flags.write) {
 123             if (flags.append) {
 124                 flags.write = true;
 125             } else {
 126                 flags.read = true;
 127             }
 128         }
 129 
 130         // validation
 131         if (flags.read && flags.append)
 132             throw new IllegalArgumentException("READ + APPEND not allowed");
 133         if (flags.append && flags.truncateExisting)
 134             throw new IllegalArgumentException("APPEND + TRUNCATE_EXISTING not allowed");
 135 
 136         FileDescriptor fdObj = open(dfd, path, pathForPermissionCheck, flags, mode);
 137         return FileChannelImpl.open(fdObj, path.toString(),
 138             flags.read, flags.write, flags.append, null);
 139     }
 140 
 141     /**
 142      * Constructs a file channel by opening the given file.
 143      */
 144     static FileChannel newFileChannel(UnixPath path,
 145                                       Set<? extends OpenOption> options,
 146                                       int mode)
 147         throws UnixException
 148     {
 149         return newFileChannel(-1, path, null, options, mode);
 150     }
 151 
 152     /**
 153      * Constructs an asynchronous file channel by opening the given file.
 154      */
 155     static AsynchronousFileChannel newAsynchronousFileChannel(UnixPath path,
 156                                                               Set<? extends OpenOption> options,
 157                                                               int mode,
 158                                                               ThreadPool pool)
 159         throws UnixException
 160     {
 161         Flags flags = Flags.toFlags(options);
 162 
 163         // default is reading
 164         if (!flags.read && !flags.write) {
 165             flags.read = true;
 166         }
 167 
 168         // validation
 169         if (flags.append)
 170             throw new UnsupportedOperationException("APPEND not allowed");
 171 
 172         // for now use simple implementation
 173         FileDescriptor fdObj = open(-1, path, null, flags, mode);
 174         return SimpleAsynchronousFileChannelImpl.open(fdObj, flags.read, flags.write, pool);
 175     }
 176 
 177     /**
 178      * Opens file based on parameters and options, returning a FileDescriptor
 179      * encapsulating the handle to the open file.
 180      */
 181     protected static FileDescriptor open(int dfd,
 182                                          UnixPath path,
 183                                          String pathForPermissionCheck,
 184                                          Flags flags,
 185                                          int mode)
 186         throws UnixException
 187     {
 188         // map to oflags
 189         int oflags;
 190         if (flags.read && flags.write) {
 191             oflags = O_RDWR;
 192         } else {
 193             oflags = (flags.write) ? O_WRONLY : O_RDONLY;
 194         }
 195         if (flags.write) {
 196             if (flags.truncateExisting)
 197                 oflags |= O_TRUNC;
 198             if (flags.append)
 199                 oflags |= O_APPEND;
 200 
 201             // create flags
 202             if (flags.createNew) {
 203                 byte[] pathForSysCall = path.asByteArray();
 204 
 205                 // throw exception if file name is "." to avoid confusing error
 206                 if ((pathForSysCall[pathForSysCall.length-1] == '.') &&
 207                     (pathForSysCall.length == 1 ||
 208                     (pathForSysCall[pathForSysCall.length-2] == '/')))
 209                 {
 210                     throw new UnixException(EEXIST);
 211                 }
 212                 oflags |= (O_CREAT | O_EXCL);
 213             } else {
 214                 if (flags.create)
 215                     oflags |= O_CREAT;
 216             }
 217         }
 218 
 219         // follow links by default
 220         boolean followLinks = true;
 221         if (!flags.createNew && (flags.noFollowLinks || flags.deleteOnClose)) {
 222             if (flags.deleteOnClose && !supportsNoFollowLinks()) {
 223                 try {
 224                     if (UnixFileAttributes.get(path, false).isSymbolicLink())
 225                         throw new UnixException("DELETE_ON_CLOSE specified and file is a symbolic link");
 226                 } catch (UnixException x) {
 227                     if (!flags.create || x.errno() != ENOENT)
 228                         throw x;
 229                 }
 230             }
 231             followLinks = false;
 232             oflags |= O_NOFOLLOW;
 233         }
 234 
 235         if (flags.dsync)
 236             oflags |= O_DSYNC;
 237         if (flags.sync)
 238             oflags |= O_SYNC;
 239 
 240         // permission check before we open the file
 241         SecurityManager sm = System.getSecurityManager();
 242         if (sm != null) {
 243             if (pathForPermissionCheck == null)
 244                 pathForPermissionCheck = path.getPathForPermissionCheck();
 245             if (flags.read)
 246                 sm.checkRead(pathForPermissionCheck);
 247             if (flags.write)
 248                 sm.checkWrite(pathForPermissionCheck);
 249             if (flags.deleteOnClose)
 250                 sm.checkDelete(pathForPermissionCheck);
 251         }
 252 
 253         int fd;
 254         try {
 255             if (dfd >= 0) {
 256                 fd = openat(dfd, path.asByteArray(), oflags, mode);
 257             } else {
 258                 fd = UnixNativeDispatcher.open(path, oflags, mode);
 259             }
 260         } catch (UnixException x) {
 261             // Linux error can be EISDIR or EEXIST when file exists
 262             if (flags.createNew && (x.errno() == EISDIR)) {
 263                 x.setError(EEXIST);
 264             }
 265 
 266             // handle ELOOP to avoid confusing message
 267             if (!followLinks && (x.errno() == ELOOP)) {
 268                 x = new UnixException(x.getMessage() + " (NOFOLLOW_LINKS specified)");
 269             }
 270 
 271             throw x;
 272         }
 273 
 274         // unlink file immediately if delete on close. The spec is clear that
 275         // an implementation cannot guarantee to unlink the correct file when
 276         // replaced by an attacker after it is opened.
 277         if (flags.deleteOnClose) {
 278             try {
 279                 if (dfd >= 0) {
 280                     unlinkat(dfd, path.asByteArray(), 0);
 281                 } else {
 282                     unlink(path);
 283                 }
 284             } catch (UnixException ignore) {
 285                 // best-effort
 286             }
 287         }
 288 
 289         // create java.io.FileDescriptor
 290         FileDescriptor fdObj = new FileDescriptor();
 291         fdAccess.set(fdObj, fd);
 292         return fdObj;
 293     }
 294 }