1 /*
   2  * Copyright (c) 2008, 2013, 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.file.attribute.*;
  30 import java.nio.channels.*;
  31 import java.net.URI;
  32 import java.util.concurrent.ExecutorService;
  33 import java.io.*;
  34 import java.util.*;
  35 import java.security.AccessController;
  36 import jdk.internal.misc.Unsafe;
  37 import sun.nio.ch.ThreadPool;
  38 import sun.security.util.SecurityConstants;
  39 
  40 import static sun.nio.fs.WindowsNativeDispatcher.*;
  41 import static sun.nio.fs.WindowsSecurity.*;
  42 import static sun.nio.fs.WindowsConstants.*;
  43 
  44 public class WindowsFileSystemProvider
  45     extends AbstractFileSystemProvider
  46 {
  47     private static final Unsafe unsafe = Unsafe.getUnsafe();
  48 
  49     private static final String USER_DIR = "user.dir";
  50     private final WindowsFileSystem theFileSystem;
  51 
  52     public WindowsFileSystemProvider() {
  53         theFileSystem = new WindowsFileSystem(this, System.getProperty(USER_DIR));
  54     }
  55 
  56     @Override
  57     public String getScheme() {
  58         return "file";
  59     }
  60 
  61     private void checkUri(URI uri) {
  62         if (!uri.getScheme().equalsIgnoreCase(getScheme()))
  63             throw new IllegalArgumentException("URI does not match this provider");
  64         if (uri.getAuthority() != null)
  65             throw new IllegalArgumentException("Authority component present");
  66         if (uri.getPath() == null)
  67             throw new IllegalArgumentException("Path component is undefined");
  68         if (!uri.getPath().equals("/"))
  69             throw new IllegalArgumentException("Path component should be '/'");
  70         if (uri.getQuery() != null)
  71             throw new IllegalArgumentException("Query component present");
  72         if (uri.getFragment() != null)
  73             throw new IllegalArgumentException("Fragment component present");
  74     }
  75 
  76     @Override
  77     public FileSystem newFileSystem(URI uri, Map<String,?> env)
  78         throws IOException
  79     {
  80         checkUri(uri);
  81         throw new FileSystemAlreadyExistsException();
  82     }
  83 
  84     @Override
  85     public final FileSystem getFileSystem(URI uri) {
  86         checkUri(uri);
  87         return theFileSystem;
  88     }
  89 
  90     @Override
  91     public Path getPath(URI uri) {
  92         return WindowsUriSupport.fromUri(theFileSystem, uri);
  93     }
  94 
  95     @Override
  96     public FileChannel newFileChannel(Path path,
  97                                       Set<? extends OpenOption> options,
  98                                       FileAttribute<?>... attrs)
  99         throws IOException
 100     {
 101         if (path == null)
 102             throw new NullPointerException();
 103         if (!(path instanceof WindowsPath))
 104             throw new ProviderMismatchException();
 105         WindowsPath file = (WindowsPath)path;
 106 
 107         WindowsSecurityDescriptor sd = WindowsSecurityDescriptor.fromAttribute(attrs);
 108         try {
 109             return WindowsChannelFactory
 110                 .newFileChannel(file.getPathForWin32Calls(),
 111                                 file.getPathForPermissionCheck(),
 112                                 options,
 113                                 sd.address());
 114         } catch (WindowsException x) {
 115             x.rethrowAsIOException(file);
 116             return null;
 117         } finally {
 118             if (sd != null)
 119                 sd.release();
 120         }
 121     }
 122 
 123     @Override
 124     public AsynchronousFileChannel newAsynchronousFileChannel(Path path,
 125                                                               Set<? extends OpenOption> options,
 126                                                               ExecutorService executor,
 127                                                               FileAttribute<?>... attrs)
 128         throws IOException
 129     {
 130         if (path == null)
 131             throw new NullPointerException();
 132         if (!(path instanceof WindowsPath))
 133             throw new ProviderMismatchException();
 134         WindowsPath file = (WindowsPath)path;
 135         ThreadPool pool = (executor == null) ? null : ThreadPool.wrap(executor, 0);
 136         WindowsSecurityDescriptor sd =
 137             WindowsSecurityDescriptor.fromAttribute(attrs);
 138         try {
 139             return WindowsChannelFactory
 140                 .newAsynchronousFileChannel(file.getPathForWin32Calls(),
 141                                             file.getPathForPermissionCheck(),
 142                                             options,
 143                                             sd.address(),
 144                                             pool);
 145         } catch (WindowsException x) {
 146             x.rethrowAsIOException(file);
 147             return null;
 148         } finally {
 149             if (sd != null)
 150                 sd.release();
 151         }
 152     }
 153 
 154     @Override
 155     @SuppressWarnings("unchecked")
 156     public <V extends FileAttributeView> V
 157         getFileAttributeView(Path obj, Class<V> view, LinkOption... options)
 158     {
 159         WindowsPath file = WindowsPath.toWindowsPath(obj);
 160         if (view == null)
 161             throw new NullPointerException();
 162         boolean followLinks = Util.followLinks(options);
 163         if (view == BasicFileAttributeView.class)
 164             return (V) WindowsFileAttributeViews.createBasicView(file, followLinks);
 165         if (view == DosFileAttributeView.class)
 166             return (V) WindowsFileAttributeViews.createDosView(file, followLinks);
 167         if (view == AclFileAttributeView.class)
 168             return (V) new WindowsAclFileAttributeView(file, followLinks);
 169         if (view == FileOwnerAttributeView.class)
 170             return (V) new FileOwnerAttributeViewImpl(
 171                 new WindowsAclFileAttributeView(file, followLinks));
 172         if (view == UserDefinedFileAttributeView.class)
 173             return (V) new WindowsUserDefinedFileAttributeView(file, followLinks);
 174         return (V) null;
 175     }
 176 
 177     @Override
 178     @SuppressWarnings("unchecked")
 179     public <A extends BasicFileAttributes> A readAttributes(Path file,
 180                                                             Class<A> type,
 181                                                             LinkOption... options)
 182         throws IOException
 183     {
 184         Class<? extends BasicFileAttributeView> view;
 185         if (type == BasicFileAttributes.class)
 186             view = BasicFileAttributeView.class;
 187         else if (type == DosFileAttributes.class)
 188             view = DosFileAttributeView.class;
 189         else if (type == null)
 190             throw new NullPointerException();
 191         else
 192             throw new UnsupportedOperationException();
 193         return (A) getFileAttributeView(file, view, options).readAttributes();
 194     }
 195 
 196     @Override
 197     public DynamicFileAttributeView getFileAttributeView(Path obj, String name, LinkOption... options) {
 198         WindowsPath file = WindowsPath.toWindowsPath(obj);
 199         boolean followLinks = Util.followLinks(options);
 200         if (name.equals("basic"))
 201             return WindowsFileAttributeViews.createBasicView(file, followLinks);
 202         if (name.equals("dos"))
 203             return WindowsFileAttributeViews.createDosView(file, followLinks);
 204         if (name.equals("acl"))
 205             return new WindowsAclFileAttributeView(file, followLinks);
 206         if (name.equals("owner"))
 207             return new FileOwnerAttributeViewImpl(
 208                 new WindowsAclFileAttributeView(file, followLinks));
 209         if (name.equals("user"))
 210             return new WindowsUserDefinedFileAttributeView(file, followLinks);
 211         return null;
 212     }
 213 
 214     @Override
 215     public SeekableByteChannel newByteChannel(Path obj,
 216                                               Set<? extends OpenOption> options,
 217                                               FileAttribute<?>... attrs)
 218          throws IOException
 219     {
 220         WindowsPath file = WindowsPath.toWindowsPath(obj);
 221         WindowsSecurityDescriptor sd =
 222             WindowsSecurityDescriptor.fromAttribute(attrs);
 223         try {
 224             return WindowsChannelFactory
 225                 .newFileChannel(file.getPathForWin32Calls(),
 226                                 file.getPathForPermissionCheck(),
 227                                 options,
 228                                 sd.address());
 229         } catch (WindowsException x) {
 230             x.rethrowAsIOException(file);
 231             return null;  // keep compiler happy
 232         } finally {
 233             sd.release();
 234         }
 235     }
 236 
 237     @Override
 238     boolean implDelete(Path obj, boolean failIfNotExists) throws IOException {
 239         WindowsPath file = WindowsPath.toWindowsPath(obj);
 240         file.checkDelete();
 241 
 242         WindowsFileAttributes attrs = null;
 243         try {
 244              // need to know if file is a directory or junction
 245              attrs = WindowsFileAttributes.get(file, false);
 246              if (attrs.isDirectory() || attrs.isDirectoryLink()) {
 247                 RemoveDirectory(file.getPathForWin32Calls());
 248              } else {
 249                 DeleteFile(file.getPathForWin32Calls());
 250              }
 251              return true;
 252         } catch (WindowsException x) {
 253 
 254             // no-op if file does not exist
 255             if (!failIfNotExists &&
 256                 (x.lastError() == ERROR_FILE_NOT_FOUND ||
 257                  x.lastError() == ERROR_PATH_NOT_FOUND)) return false;
 258 
 259             if (attrs != null && attrs.isDirectory()) {
 260                 // ERROR_ALREADY_EXISTS is returned when attempting to delete
 261                 // non-empty directory on SAMBA servers.
 262                 if (x.lastError() == ERROR_DIR_NOT_EMPTY ||
 263                     x.lastError() == ERROR_ALREADY_EXISTS)
 264                 {
 265                     throw new DirectoryNotEmptyException(
 266                         file.getPathForExceptionMessage());
 267                 }
 268             }
 269             x.rethrowAsIOException(file);
 270             return false;
 271         }
 272     }
 273 
 274     @Override
 275     public void copy(Path source, Path target, CopyOption... options)
 276         throws IOException
 277     {
 278         WindowsFileCopy.copy(WindowsPath.toWindowsPath(source),
 279                              WindowsPath.toWindowsPath(target),
 280                              options);
 281     }
 282 
 283     @Override
 284     public void move(Path source, Path target, CopyOption... options)
 285         throws IOException
 286     {
 287         WindowsFileCopy.move(WindowsPath.toWindowsPath(source),
 288                              WindowsPath.toWindowsPath(target),
 289                              options);
 290     }
 291 
 292     /**
 293      * Checks the file security against desired access.
 294      */
 295     private static boolean hasDesiredAccess(WindowsPath file, int rights) throws IOException {
 296         // read security descriptor containing ACL (symlinks are followed)
 297         boolean hasRights = false;
 298         String target = WindowsLinkSupport.getFinalPath(file, true);
 299         NativeBuffer aclBuffer = WindowsAclFileAttributeView
 300             .getFileSecurity(target,
 301                 DACL_SECURITY_INFORMATION
 302                 | OWNER_SECURITY_INFORMATION
 303                 | GROUP_SECURITY_INFORMATION);
 304         try {
 305             hasRights = checkAccessMask(aclBuffer.address(), rights,
 306                 FILE_GENERIC_READ,
 307                 FILE_GENERIC_WRITE,
 308                 FILE_GENERIC_EXECUTE,
 309                 FILE_ALL_ACCESS);
 310         } catch (WindowsException exc) {
 311             exc.rethrowAsIOException(file);
 312         } finally {
 313             aclBuffer.release();
 314         }
 315         return hasRights;
 316     }
 317 
 318     /**
 319      * Checks if the given file(or directory) exists and is readable.
 320      */
 321     private void checkReadAccess(WindowsPath file) throws IOException {
 322         try {
 323             Set<OpenOption> opts = Collections.emptySet();
 324             FileChannel fc = WindowsChannelFactory
 325                 .newFileChannel(file.getPathForWin32Calls(),
 326                                 file.getPathForPermissionCheck(),
 327                                 opts,
 328                                 0L);
 329             fc.close();
 330         } catch (WindowsException exc) {
 331             // Windows errors are very inconsistent when the file is a directory
 332             // (ERROR_PATH_NOT_FOUND returned for root directories for example)
 333             // so we retry by attempting to open it as a directory.
 334             try {
 335                 new WindowsDirectoryStream(file, null).close();
 336             } catch (IOException ioe) {
 337                 // translate and throw original exception
 338                 exc.rethrowAsIOException(file);
 339             }
 340         }
 341     }
 342 
 343     @Override
 344     public void checkAccess(Path obj, AccessMode... modes) throws IOException {
 345         WindowsPath file = WindowsPath.toWindowsPath(obj);
 346 
 347         boolean r = false;
 348         boolean w = false;
 349         boolean x = false;
 350         for (AccessMode mode: modes) {
 351             switch (mode) {
 352                 case READ : r = true; break;
 353                 case WRITE : w = true; break;
 354                 case EXECUTE : x = true; break;
 355                 default: throw new AssertionError("Should not get here");
 356             }
 357         }
 358 
 359         // special-case read access to avoid needing to determine effective
 360         // access to file; default if modes not specified
 361         if (!w && !x) {
 362             checkReadAccess(file);
 363             return;
 364         }
 365 
 366         int mask = 0;
 367         if (r) {
 368             file.checkRead();
 369             mask |= FILE_READ_DATA;
 370         }
 371         if (w) {
 372             file.checkWrite();
 373             mask |= FILE_WRITE_DATA;
 374         }
 375         if (x) {
 376             SecurityManager sm = System.getSecurityManager();
 377             if (sm != null)
 378                 sm.checkExec(file.getPathForPermissionCheck());
 379             mask |= FILE_EXECUTE;
 380         }
 381 
 382         if (!hasDesiredAccess(file, mask))
 383             throw new AccessDeniedException(
 384                 file.getPathForExceptionMessage(), null,
 385                 "Permissions does not allow requested access");
 386 
 387         // for write access we need to check if the DOS readonly attribute
 388         // and if the volume is read-only
 389         if (w) {
 390             try {
 391                 WindowsFileAttributes attrs = WindowsFileAttributes.get(file, true);
 392                 if (!attrs.isDirectory() && attrs.isReadOnly())
 393                     throw new AccessDeniedException(
 394                         file.getPathForExceptionMessage(), null,
 395                         "DOS readonly attribute is set");
 396             } catch (WindowsException exc) {
 397                 exc.rethrowAsIOException(file);
 398             }
 399 
 400             if (WindowsFileStore.create(file).isReadOnly()) {
 401                 throw new AccessDeniedException(
 402                     file.getPathForExceptionMessage(), null, "Read-only file system");
 403             }
 404         }
 405     }
 406 
 407     @Override
 408     public boolean isSameFile(Path obj1, Path obj2) throws IOException {
 409         WindowsPath file1 = WindowsPath.toWindowsPath(obj1);
 410         if (file1.equals(obj2))
 411             return true;
 412         if (obj2 == null)
 413             throw new NullPointerException();
 414         if (!(obj2 instanceof WindowsPath))
 415             return false;
 416         WindowsPath file2 = (WindowsPath)obj2;
 417 
 418         // check security manager access to both files
 419         file1.checkRead();
 420         file2.checkRead();
 421 
 422         // open both files and see if they are the same
 423         long h1 = 0L;
 424         try {
 425             h1 = file1.openForReadAttributeAccess(true);
 426         } catch (WindowsException x) {
 427             x.rethrowAsIOException(file1);
 428         }
 429         try {
 430             WindowsFileAttributes attrs1 = null;
 431             try {
 432                 attrs1 = WindowsFileAttributes.readAttributes(h1);
 433             } catch (WindowsException x) {
 434                 x.rethrowAsIOException(file1);
 435             }
 436             long h2 = 0L;
 437             try {
 438                 h2 = file2.openForReadAttributeAccess(true);
 439             } catch (WindowsException x) {
 440                 x.rethrowAsIOException(file2);
 441             }
 442             try {
 443                 WindowsFileAttributes attrs2 = null;
 444                 try {
 445                     attrs2 = WindowsFileAttributes.readAttributes(h2);
 446                 } catch (WindowsException x) {
 447                     x.rethrowAsIOException(file2);
 448                 }
 449                 return WindowsFileAttributes.isSameFile(attrs1, attrs2);
 450             } finally {
 451                 CloseHandle(h2);
 452             }
 453         } finally {
 454             CloseHandle(h1);
 455         }
 456     }
 457 
 458     @Override
 459     public boolean isHidden(Path obj) throws IOException {
 460         WindowsPath file = WindowsPath.toWindowsPath(obj);
 461         file.checkRead();
 462         WindowsFileAttributes attrs = null;
 463         try {
 464             attrs = WindowsFileAttributes.get(file, true);
 465         } catch (WindowsException x) {
 466             x.rethrowAsIOException(file);
 467         }
 468         // DOS hidden attribute not meaningful when set on directories
 469         if (attrs.isDirectory())
 470             return false;
 471         return attrs.isHidden();
 472     }
 473 
 474     @Override
 475     public FileStore getFileStore(Path obj) throws IOException {
 476         WindowsPath file = WindowsPath.toWindowsPath(obj);
 477         SecurityManager sm = System.getSecurityManager();
 478         if (sm != null) {
 479             sm.checkPermission(new RuntimePermission("getFileStoreAttributes"));
 480             file.checkRead();
 481         }
 482         return WindowsFileStore.create(file);
 483     }
 484 
 485 
 486     @Override
 487     public void createDirectory(Path obj, FileAttribute<?>... attrs)
 488         throws IOException
 489     {
 490         WindowsPath dir = WindowsPath.toWindowsPath(obj);
 491         dir.checkWrite();
 492         WindowsSecurityDescriptor sd = WindowsSecurityDescriptor.fromAttribute(attrs);
 493         try {
 494             CreateDirectory(dir.getPathForWin32Calls(), sd.address());
 495         } catch (WindowsException x) {
 496             // convert ERROR_ACCESS_DENIED to FileAlreadyExistsException if we can
 497             // verify that the directory exists
 498             if (x.lastError() == ERROR_ACCESS_DENIED) {
 499                 try {
 500                     if (WindowsFileAttributes.get(dir, false).isDirectory())
 501                         throw new FileAlreadyExistsException(dir.toString());
 502                 } catch (WindowsException ignore) { }
 503             }
 504             x.rethrowAsIOException(dir);
 505         } finally {
 506             sd.release();
 507         }
 508     }
 509 
 510     @Override
 511     public DirectoryStream<Path> newDirectoryStream(Path obj, DirectoryStream.Filter<? super Path> filter)
 512         throws IOException
 513     {
 514         WindowsPath dir = WindowsPath.toWindowsPath(obj);
 515         dir.checkRead();
 516         if (filter == null)
 517             throw new NullPointerException();
 518         return new WindowsDirectoryStream(dir, filter);
 519     }
 520 
 521     @Override
 522     public void createSymbolicLink(Path obj1, Path obj2, FileAttribute<?>... attrs)
 523         throws IOException
 524     {
 525         WindowsPath link = WindowsPath.toWindowsPath(obj1);
 526         WindowsPath target = WindowsPath.toWindowsPath(obj2);
 527 
 528         if (!link.getFileSystem().supportsLinks()) {
 529             throw new UnsupportedOperationException("Symbolic links not supported "
 530                 + "on this operating system");
 531         }
 532 
 533         // no attributes allowed
 534         if (attrs.length > 0) {
 535             WindowsSecurityDescriptor.fromAttribute(attrs);  // may throw NPE or UOE
 536             throw new UnsupportedOperationException("Initial file attributes" +
 537                 "not supported when creating symbolic link");
 538         }
 539 
 540         // permission check
 541         SecurityManager sm = System.getSecurityManager();
 542         if (sm != null) {
 543             sm.checkPermission(new LinkPermission("symbolic"));
 544             link.checkWrite();
 545         }
 546 
 547         /**
 548          * Throw I/O exception for the drive-relative case because Windows
 549          * creates a link with the resolved target for this case.
 550          */
 551         if (target.type() == WindowsPathType.DRIVE_RELATIVE) {
 552             throw new IOException("Cannot create symbolic link to working directory relative target");
 553         }
 554 
 555         /*
 556          * Windows treats symbolic links to directories differently than it
 557          * does to other file types. For that reason we need to check if the
 558          * target is a directory (or a directory junction).
 559          */
 560         WindowsPath resolvedTarget;
 561         if (target.type() == WindowsPathType.RELATIVE) {
 562             WindowsPath parent = link.getParent();
 563             resolvedTarget = (parent == null) ? target : parent.resolve(target);
 564         } else {
 565             resolvedTarget = link.resolve(target);
 566         }
 567         int flags = 0;
 568         try {
 569             WindowsFileAttributes wattrs = WindowsFileAttributes.get(resolvedTarget, false);
 570             if (wattrs.isDirectory() || wattrs.isDirectoryLink())
 571                 flags |= SYMBOLIC_LINK_FLAG_DIRECTORY;
 572         } catch (WindowsException x) {
 573             // unable to access target so assume target is not a directory
 574         }
 575 
 576         // create the link
 577         try {
 578             CreateSymbolicLink(link.getPathForWin32Calls(),
 579                                WindowsPath.addPrefixIfNeeded(target.toString()),
 580                                flags);
 581         } catch (WindowsException x) {
 582             if (x.lastError() == ERROR_INVALID_REPARSE_DATA) {
 583                 x.rethrowAsIOException(link, target);
 584             } else {
 585                 x.rethrowAsIOException(link);
 586             }
 587         }
 588     }
 589 
 590     @Override
 591     public void createLink(Path obj1, Path obj2) throws IOException {
 592         WindowsPath link = WindowsPath.toWindowsPath(obj1);
 593         WindowsPath existing = WindowsPath.toWindowsPath(obj2);
 594 
 595         // permission check
 596         SecurityManager sm = System.getSecurityManager();
 597         if (sm != null) {
 598             sm.checkPermission(new LinkPermission("hard"));
 599             link.checkWrite();
 600             existing.checkWrite();
 601         }
 602 
 603         // create hard link
 604         try {
 605             CreateHardLink(link.getPathForWin32Calls(),
 606                            existing.getPathForWin32Calls());
 607         } catch (WindowsException x) {
 608             x.rethrowAsIOException(link, existing);
 609         }
 610     }
 611 
 612     @Override
 613     public Path readSymbolicLink(Path obj1) throws IOException {
 614         WindowsPath link = WindowsPath.toWindowsPath(obj1);
 615         WindowsFileSystem fs = link.getFileSystem();
 616         if (!fs.supportsLinks()) {
 617             throw new UnsupportedOperationException("symbolic links not supported");
 618         }
 619 
 620         // permission check
 621         SecurityManager sm = System.getSecurityManager();
 622         if (sm != null) {
 623             FilePermission perm = new FilePermission(link.getPathForPermissionCheck(),
 624                 SecurityConstants.FILE_READLINK_ACTION);
 625             sm.checkPermission(perm);
 626         }
 627 
 628         String target = WindowsLinkSupport.readLink(link);
 629         return WindowsPath.createFromNormalizedPath(fs, target);
 630     }
 631 }