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