1 /*
   2  * Copyright (c) 2008, 2009, 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.io.IOException;
  32 import java.util.*;
  33 
  34 import com.sun.nio.file.ExtendedOpenOption;
  35 
  36 import sun.nio.ch.FileChannelImpl;
  37 import sun.nio.ch.ThreadPool;
  38 import sun.nio.ch.WindowsAsynchronousFileChannelImpl;
  39 import sun.misc.SharedSecrets;
  40 import sun.misc.JavaIOFileDescriptorAccess;
  41 
  42 import static sun.nio.fs.WindowsNativeDispatcher.*;
  43 import static sun.nio.fs.WindowsConstants.*;
  44 
  45 /**
  46  * Factory to create FileChannels and AsynchronousFileChannels.
  47  */
  48 
  49 class WindowsChannelFactory {
  50     private static final JavaIOFileDescriptorAccess fdAccess =
  51         SharedSecrets.getJavaIOFileDescriptorAccess();
  52 
  53     private WindowsChannelFactory() { }
  54 
  55     /**
  56      * Do not follow reparse points when opening an existing file. Do not fail
  57      * if the file is a reparse point.
  58      */
  59     static final OpenOption OPEN_REPARSE_POINT = new OpenOption() { };
  60 
  61     /**
  62      * Represents the flags from a user-supplied set of open options.
  63      */
  64     private static class Flags {
  65         boolean read;
  66         boolean write;
  67         boolean append;
  68         boolean truncateExisting;
  69         boolean create;
  70         boolean createNew;
  71         boolean deleteOnClose;
  72         boolean sparse;
  73         boolean overlapped;
  74         boolean sync;
  75         boolean dsync;
  76 
  77         // non-standard
  78         boolean shareRead = true;
  79         boolean shareWrite = true;
  80         boolean shareDelete = true;
  81         boolean noFollowLinks;
  82         boolean openReparsePoint;
  83 
  84         static Flags toFlags(Set<? extends OpenOption> options) {
  85             Flags flags = new Flags();
  86             for (OpenOption option: options) {
  87                 if (option instanceof StandardOpenOption) {
  88                     switch ((StandardOpenOption)option) {
  89                         case READ : flags.read = true; break;
  90                         case WRITE : flags.write = true; break;
  91                         case APPEND : flags.append = true; break;
  92                         case TRUNCATE_EXISTING : flags.truncateExisting = true; break;
  93                         case CREATE : flags.create = true; break;
  94                         case CREATE_NEW : flags.createNew = true; break;
  95                         case DELETE_ON_CLOSE : flags.deleteOnClose = true; break;
  96                         case SPARSE : flags.sparse = true; break;
  97                         case SYNC : flags.sync = true; break;
  98                         case DSYNC : flags.dsync = true; break;
  99                         default: throw new UnsupportedOperationException();
 100                     }
 101                     continue;
 102                 }
 103                 if (option instanceof ExtendedOpenOption) {
 104                     switch ((ExtendedOpenOption)option) {
 105                         case NOSHARE_READ : flags.shareRead = false; break;
 106                         case NOSHARE_WRITE : flags.shareWrite = false; break;
 107                         case NOSHARE_DELETE : flags.shareDelete = false; break;
 108                         default: throw new UnsupportedOperationException();
 109                     }
 110                     continue;
 111                 }
 112                 if (option == LinkOption.NOFOLLOW_LINKS) {
 113                     flags.noFollowLinks = true;
 114                     continue;
 115                 }
 116                 if (option == OPEN_REPARSE_POINT) {
 117                     flags.openReparsePoint = true;
 118                     continue;
 119                 }
 120                 if (option == null)
 121                     throw new NullPointerException();
 122                 throw new UnsupportedOperationException();
 123             }
 124             return flags;
 125         }
 126     }
 127 
 128     /**
 129      * Open/creates file, returning FileChannel to access the file
 130      *
 131      * @param   pathForWindows
 132      *          The path of the file to open/create
 133      * @param   pathToCheck
 134      *          The path used for permission checks (if security manager)
 135      */
 136     static FileChannel newFileChannel(String pathForWindows,
 137                                       String pathToCheck,
 138                                       Set<? extends OpenOption> options,
 139                                       long pSecurityDescriptor)
 140         throws WindowsException
 141     {
 142         Flags flags = Flags.toFlags(options);
 143 
 144         // default is reading; append => writing
 145         if (!flags.read && !flags.write) {
 146             if (flags.append) {
 147                 flags.write = true;
 148             } else {
 149                 flags.read = true;
 150             }
 151         }
 152 
 153         // validation
 154         if (flags.read && flags.append)
 155             throw new IllegalArgumentException("READ + APPEND not allowed");
 156         if (flags.append && flags.truncateExisting)
 157             throw new IllegalArgumentException("APPEND + TRUNCATE_EXISTING not allowed");
 158 
 159         FileDescriptor fdObj = open(pathForWindows, pathToCheck, flags, pSecurityDescriptor);
 160         return FileChannelImpl.open(fdObj, flags.read, flags.write, flags.append, null);
 161     }
 162 
 163     /**
 164      * Open/creates file, returning AsynchronousFileChannel to access the file
 165      *
 166      * @param   pathForWindows
 167      *          The path of the file to open/create
 168      * @param   pathToCheck
 169      *          The path used for permission checks (if security manager)
 170      * @param   pool
 171      *          The thread pool that the channel is associated with
 172      */
 173     static AsynchronousFileChannel newAsynchronousFileChannel(String pathForWindows,
 174                                                               String pathToCheck,
 175                                                               Set<? extends OpenOption> options,
 176                                                               long pSecurityDescriptor,
 177                                                               ThreadPool pool)
 178         throws IOException
 179     {
 180         Flags flags = Flags.toFlags(options);
 181 
 182         // Overlapped I/O required
 183         flags.overlapped = true;
 184 
 185         // default is reading
 186         if (!flags.read && !flags.write) {
 187             flags.read = true;
 188         }
 189 
 190         // validation
 191         if (flags.append)
 192             throw new UnsupportedOperationException("APPEND not allowed");
 193 
 194         // open file for overlapped I/O
 195         FileDescriptor fdObj;
 196         try {
 197             fdObj = open(pathForWindows, pathToCheck, flags, pSecurityDescriptor);
 198         } catch (WindowsException x) {
 199             x.rethrowAsIOException(pathForWindows);
 200             return null;
 201         }
 202 
 203         // create the AsynchronousFileChannel
 204         try {
 205             return WindowsAsynchronousFileChannelImpl.open(fdObj, flags.read, flags.write, pool);
 206         } catch (IOException x) {
 207             // IOException is thrown if the file handle cannot be associated
 208             // with the completion port. All we can do is close the file.
 209             long handle = fdAccess.getHandle(fdObj);
 210             CloseHandle(handle);
 211             throw x;
 212         }
 213     }
 214 
 215     /**
 216      * Opens file based on parameters and options, returning a FileDescriptor
 217      * encapsulating the handle to the open file.
 218      */
 219     private static FileDescriptor open(String pathForWindows,
 220                                        String pathToCheck,
 221                                        Flags flags,
 222                                        long pSecurityDescriptor)
 223         throws WindowsException
 224     {
 225         // set to true if file must be truncated after open
 226         boolean truncateAfterOpen = false;
 227 
 228         // map options
 229         int dwDesiredAccess = 0;
 230         if (flags.read)
 231             dwDesiredAccess |= GENERIC_READ;
 232         if (flags.write)
 233             dwDesiredAccess |= GENERIC_WRITE;
 234 
 235         int dwShareMode = 0;
 236         if (flags.shareRead)
 237             dwShareMode |= FILE_SHARE_READ;
 238         if (flags.shareWrite)
 239             dwShareMode |= FILE_SHARE_WRITE;
 240         if (flags.shareDelete)
 241             dwShareMode |= FILE_SHARE_DELETE;
 242 
 243         int dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
 244         int dwCreationDisposition = OPEN_EXISTING;
 245         if (flags.write) {
 246             if (flags.createNew) {
 247                 dwCreationDisposition = CREATE_NEW;
 248                 // force create to fail if file is orphaned reparse point
 249                 dwFlagsAndAttributes |= FILE_FLAG_OPEN_REPARSE_POINT;
 250             } else {
 251                 if (flags.create)
 252                     dwCreationDisposition = OPEN_ALWAYS;
 253                 if (flags.truncateExisting) {
 254                     // Windows doesn't have a creation disposition that exactly
 255                     // corresponds to CREATE + TRUNCATE_EXISTING so we use
 256                     // the OPEN_ALWAYS mode and then truncate the file.
 257                     if (dwCreationDisposition == OPEN_ALWAYS) {
 258                         truncateAfterOpen = true;
 259                     } else {
 260                         dwCreationDisposition = TRUNCATE_EXISTING;
 261                     }
 262                 }
 263             }
 264         }
 265 
 266         if (flags.dsync || flags.sync)
 267             dwFlagsAndAttributes |= FILE_FLAG_WRITE_THROUGH;
 268         if (flags.overlapped)
 269             dwFlagsAndAttributes |= FILE_FLAG_OVERLAPPED;
 270         if (flags.deleteOnClose)
 271             dwFlagsAndAttributes |= FILE_FLAG_DELETE_ON_CLOSE;
 272 
 273         // NOFOLLOW_LINKS and NOFOLLOW_REPARSEPOINT mean open reparse point
 274         boolean okayToFollowLinks = true;
 275         if (dwCreationDisposition != CREATE_NEW &&
 276             (flags.noFollowLinks ||
 277              flags.openReparsePoint ||
 278              flags.deleteOnClose))
 279         {
 280             if (flags.noFollowLinks || flags.deleteOnClose)
 281                 okayToFollowLinks = false;
 282             dwFlagsAndAttributes |= FILE_FLAG_OPEN_REPARSE_POINT;
 283         }
 284 
 285         // permission check
 286         if (pathToCheck != null) {
 287             SecurityManager sm = System.getSecurityManager();
 288             if (sm != null) {
 289                 if (flags.read)
 290                     sm.checkRead(pathToCheck);
 291                 if (flags.write)
 292                     sm.checkWrite(pathToCheck);
 293                 if (flags.deleteOnClose)
 294                     sm.checkDelete(pathToCheck);
 295             }
 296         }
 297 
 298         // open file
 299         long handle = CreateFile(pathForWindows,
 300                                  dwDesiredAccess,
 301                                  dwShareMode,
 302                                  pSecurityDescriptor,
 303                                  dwCreationDisposition,
 304                                  dwFlagsAndAttributes);
 305 
 306         // make sure this isn't a symbolic link.
 307         if (!okayToFollowLinks) {
 308             try {
 309                 if (WindowsFileAttributes.readAttributes(handle).isSymbolicLink())
 310                     throw new WindowsException("File is symbolic link");
 311             } catch (WindowsException x) {
 312                 CloseHandle(handle);
 313                 throw x;
 314             }
 315         }
 316 
 317         // truncate file (for CREATE + TRUNCATE_EXISTING case)
 318         if (truncateAfterOpen) {
 319             try {
 320                 SetEndOfFile(handle);
 321             } catch (WindowsException x) {
 322                 CloseHandle(handle);
 323                 throw x;
 324             }
 325         }
 326 
 327         // make the file sparse if needed
 328         if (dwCreationDisposition == CREATE_NEW && flags.sparse) {
 329             try {
 330                 DeviceIoControlSetSparse(handle);
 331             } catch (WindowsException x) {
 332                 // ignore as sparse option is hint
 333             }
 334         }
 335 
 336         // create FileDescriptor and return
 337         FileDescriptor fdObj = new FileDescriptor();
 338         fdAccess.setHandle(fdObj, handle);
 339         return fdObj;
 340     }
 341 }