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.io.IOException;
29 import java.nio.file.AtomicMoveNotSupportedException;
30 import java.nio.file.CopyOption;
31 import java.nio.file.DirectoryNotEmptyException;
32 import java.nio.file.FileAlreadyExistsException;
33 import java.nio.file.LinkOption;
34 import java.nio.file.LinkPermission;
35 import java.nio.file.StandardCopyOption;
36 import java.security.AccessController;
37 import java.security.PrivilegedAction;
38 import java.util.concurrent.ExecutionException;
39 import java.util.concurrent.TimeUnit;
40
41 import static sun.nio.fs.UnixNativeDispatcher.*;
42 import static sun.nio.fs.UnixConstants.*;
43
44
45 /**
46 * Unix implementation of Path#copyTo and Path#moveTo methods.
47 */
48
49 class UnixCopyFile {
50 private UnixCopyFile() { }
51
52 // The flags that control how a file is copied or moved
53 private static class Flags {
54 boolean replaceExisting;
55 boolean atomicMove;
56 boolean followLinks;
57 boolean interruptible;
58
59 // the attributes to copy
60 boolean copyBasicAttributes;
61 boolean copyPosixAttributes;
62 boolean copyNonPosixAttributes;
63
64 // flags that indicate if we should fail if attributes cannot be copied
65 boolean failIfUnableToCopyBasic;
66 boolean failIfUnableToCopyPosix;
67 boolean failIfUnableToCopyNonPosix;
68
69 static Flags fromCopyOptions(CopyOption... options) {
70 Flags flags = new Flags();
71 flags.followLinks = true;
72 for (CopyOption option: options) {
73 if (option == StandardCopyOption.REPLACE_EXISTING) {
74 flags.replaceExisting = true;
75 continue;
76 }
77 if (option == LinkOption.NOFOLLOW_LINKS) {
78 flags.followLinks = false;
79 continue;
80 }
81 if (option == StandardCopyOption.COPY_ATTRIBUTES) {
82 // copy all attributes but only fail if basic attributes
83 // cannot be copied
84 flags.copyBasicAttributes = true;
85 flags.copyPosixAttributes = true;
86 flags.copyNonPosixAttributes = true;
87 flags.failIfUnableToCopyBasic = true;
88 continue;
89 }
90 if (ExtendedOptions.INTERRUPTIBLE.matches(option)) {
91 flags.interruptible = true;
92 continue;
93 }
94 if (option == null)
95 throw new NullPointerException();
96 throw new UnsupportedOperationException("Unsupported copy option");
97 }
98 return flags;
99 }
100
101 static Flags fromMoveOptions(CopyOption... options) {
102 Flags flags = new Flags();
103 for (CopyOption option: options) {
104 if (option == StandardCopyOption.ATOMIC_MOVE) {
105 flags.atomicMove = true;
106 continue;
107 }
108 if (option == StandardCopyOption.REPLACE_EXISTING) {
109 flags.replaceExisting = true;
110 continue;
111 }
112 if (option == LinkOption.NOFOLLOW_LINKS) {
113 // ignore
114 continue;
115 }
116 if (option == null)
117 throw new NullPointerException();
118 throw new UnsupportedOperationException("Unsupported copy option");
119 }
120
121 // a move requires that all attributes be copied but only fail if
122 // the basic attributes cannot be copied
123 flags.copyBasicAttributes = true;
124 flags.copyPosixAttributes = true;
125 flags.copyNonPosixAttributes = true;
126 flags.failIfUnableToCopyBasic = true;
127 return flags;
128 }
129 }
130
131 // copy directory from source to target
132 private static void copyDirectory(UnixPath source,
133 UnixFileAttributes attrs,
134 UnixPath target,
135 Flags flags)
136 throws IOException
137 {
138 try {
139 mkdir(target, attrs.mode());
140 } catch (UnixException x) {
141 x.rethrowAsIOException(target);
142 }
143
144 // no attributes to copy
145 if (!flags.copyBasicAttributes &&
146 !flags.copyPosixAttributes &&
147 !flags.copyNonPosixAttributes) return;
148
149 // open target directory if possible (this can fail when copying a
150 // directory for which we don't have read access).
151 int dfd = -1;
152 try {
153 dfd = open(target, O_RDONLY, 0);
154 } catch (UnixException x) {
155 // access to target directory required to copy named attributes
156 if (flags.copyNonPosixAttributes && flags.failIfUnableToCopyNonPosix) {
157 try { rmdir(target); } catch (UnixException ignore) { }
158 x.rethrowAsIOException(target);
159 }
160 }
161
162 boolean done = false;
163 try {
164 // copy owner/group/permissions
165 if (flags.copyPosixAttributes){
166 try {
167 if (dfd >= 0) {
168 fchown(dfd, attrs.uid(), attrs.gid());
169 fchmod(dfd, attrs.mode());
170 } else {
171 chown(target, attrs.uid(), attrs.gid());
172 chmod(target, attrs.mode());
173 }
174 } catch (UnixException x) {
175 // unable to set owner/group
176 if (flags.failIfUnableToCopyPosix)
177 x.rethrowAsIOException(target);
178 }
179 }
180 // copy other attributes
181 if (flags.copyNonPosixAttributes && (dfd >= 0)) {
182 int sfd = -1;
183 try {
184 sfd = open(source, O_RDONLY, 0);
185 } catch (UnixException x) {
186 if (flags.failIfUnableToCopyNonPosix)
187 x.rethrowAsIOException(source);
188 }
189 if (sfd >= 0) {
190 source.getFileSystem().copyNonPosixAttributes(sfd, dfd);
191 close(sfd);
192 }
193 }
194 // copy time stamps last
195 if (flags.copyBasicAttributes) {
196 try {
197 if (dfd >= 0 && futimesSupported()) {
198 futimes(dfd,
199 attrs.lastAccessTime().to(TimeUnit.MICROSECONDS),
200 attrs.lastModifiedTime().to(TimeUnit.MICROSECONDS));
201 } else {
202 utimes(target,
203 attrs.lastAccessTime().to(TimeUnit.MICROSECONDS),
204 attrs.lastModifiedTime().to(TimeUnit.MICROSECONDS));
205 }
206 } catch (UnixException x) {
207 // unable to set times
208 if (flags.failIfUnableToCopyBasic)
209 x.rethrowAsIOException(target);
210 }
211 }
212 done = true;
213 } finally {
214 if (dfd >= 0)
215 close(dfd);
216 if (!done) {
217 // rollback
218 try { rmdir(target); } catch (UnixException ignore) { }
219 }
220 }
221 }
222
223 // copy regular file from source to target
224 private static void copyFile(UnixPath source,
225 UnixFileAttributes attrs,
226 UnixPath target,
227 Flags flags,
228 long addressToPollForCancel)
229 throws IOException
230 {
231 int fi = -1;
232 try {
233 fi = open(source, O_RDONLY, 0);
234 } catch (UnixException x) {
235 x.rethrowAsIOException(source);
236 }
237
238 try {
239 // open new file
240 int fo = -1;
241 try {
242 fo = open(target,
243 (O_WRONLY |
244 O_CREAT |
245 O_EXCL),
246 attrs.mode());
247 } catch (UnixException x) {
248 x.rethrowAsIOException(target);
249 }
250
251 // set to true when file and attributes copied
252 boolean complete = false;
253 try {
254 // transfer bytes to target file
255 try {
256 transfer(fo, fi, addressToPollForCancel);
257 } catch (UnixException x) {
258 x.rethrowAsIOException(source, target);
259 }
260 // copy owner/permissions
261 if (flags.copyPosixAttributes) {
262 try {
263 fchown(fo, attrs.uid(), attrs.gid());
264 fchmod(fo, attrs.mode());
265 } catch (UnixException x) {
266 if (flags.failIfUnableToCopyPosix)
267 x.rethrowAsIOException(target);
268 }
269 }
270 // copy non POSIX attributes (depends on file system)
271 if (flags.copyNonPosixAttributes) {
272 source.getFileSystem().copyNonPosixAttributes(fi, fo);
273 }
274 // copy time attributes
275 if (flags.copyBasicAttributes) {
276 try {
277 if (futimesSupported()) {
278 futimes(fo,
279 attrs.lastAccessTime().to(TimeUnit.MICROSECONDS),
280 attrs.lastModifiedTime().to(TimeUnit.MICROSECONDS));
281 } else {
282 utimes(target,
283 attrs.lastAccessTime().to(TimeUnit.MICROSECONDS),
284 attrs.lastModifiedTime().to(TimeUnit.MICROSECONDS));
285 }
286 } catch (UnixException x) {
287 if (flags.failIfUnableToCopyBasic)
288 x.rethrowAsIOException(target);
289 }
290 }
291 complete = true;
292 } finally {
293 close(fo);
294
295 // copy of file or attributes failed so rollback
296 if (!complete) {
297 try {
298 unlink(target);
299 } catch (UnixException ignore) { }
300 }
301 }
302 } finally {
303 close(fi);
304 }
305 }
306
307 // copy symbolic link from source to target
308 private static void copyLink(UnixPath source,
309 UnixFileAttributes attrs,
310 UnixPath target,
311 Flags flags)
312 throws IOException
313 {
314 byte[] linktarget = null;
315 try {
316 linktarget = readlink(source);
317 } catch (UnixException x) {
318 x.rethrowAsIOException(source);
319 }
320 try {
321 symlink(linktarget, target);
322
323 if (flags.copyPosixAttributes) {
324 try {
325 lchown(target, attrs.uid(), attrs.gid());
326 } catch (UnixException x) {
327 // ignore since link attributes not required to be copied
328 }
329 }
330 } catch (UnixException x) {
331 x.rethrowAsIOException(target);
332 }
333 }
334
335 // copy special file from source to target
336 private static void copySpecial(UnixPath source,
337 UnixFileAttributes attrs,
338 UnixPath target,
339 Flags flags)
340 throws IOException
341 {
342 try {
343 mknod(target, attrs.mode(), attrs.rdev());
344 } catch (UnixException x) {
345 x.rethrowAsIOException(target);
346 }
347 boolean done = false;
348 try {
349 if (flags.copyPosixAttributes) {
350 try {
351 chown(target, attrs.uid(), attrs.gid());
352 chmod(target, attrs.mode());
353 } catch (UnixException x) {
354 if (flags.failIfUnableToCopyPosix)
355 x.rethrowAsIOException(target);
356 }
357 }
358 if (flags.copyBasicAttributes) {
359 try {
360 utimes(target,
361 attrs.lastAccessTime().to(TimeUnit.MICROSECONDS),
362 attrs.lastModifiedTime().to(TimeUnit.MICROSECONDS));
363 } catch (UnixException x) {
364 if (flags.failIfUnableToCopyBasic)
365 x.rethrowAsIOException(target);
366 }
367 }
368 done = true;
369 } finally {
370 if (!done) {
371 try { unlink(target); } catch (UnixException ignore) { }
372 }
373 }
374 }
375
376 // throw a DirectoryNotEmpty exception if appropriate
377 static void ensureEmptyDir(UnixPath dir) throws IOException {
378 try {
379 long ptr = opendir(dir);
380 try (UnixDirectoryStream stream =
381 new UnixDirectoryStream(dir, ptr, e -> true)) {
382 if (stream.iterator().hasNext()) {
383 throw new DirectoryNotEmptyException(
384 dir.getPathForExceptionMessage());
385 }
386 }
387 } catch (UnixException e) {
388 e.rethrowAsIOException(dir);
389 }
390 }
391
392 // move file from source to target
393 static void move(UnixPath source, UnixPath target, CopyOption... options)
394 throws IOException
395 {
396 // permission check
397 SecurityManager sm = System.getSecurityManager();
398 if (sm != null) {
399 source.checkWrite();
400 target.checkWrite();
401 }
402
403 // translate options into flags
404 Flags flags = Flags.fromMoveOptions(options);
405
406 // handle atomic rename case
407 if (flags.atomicMove) {
408 try {
409 rename(source, target);
410 } catch (UnixException x) {
411 if (x.errno() == EXDEV) {
412 throw new AtomicMoveNotSupportedException(
413 source.getPathForExceptionMessage(),
414 target.getPathForExceptionMessage(),
415 x.errorString());
416 }
417 x.rethrowAsIOException(source, target);
418 }
419 return;
420 }
421
422 // move using rename or copy+delete
423 UnixFileAttributes sourceAttrs = null;
424 UnixFileAttributes targetAttrs = null;
425
426 // get attributes of source file (don't follow links)
427 try {
428 sourceAttrs = UnixFileAttributes.get(source, false);
429 } catch (UnixException x) {
430 x.rethrowAsIOException(source);
431 }
432
433 // get attributes of target file (don't follow links)
434 try {
435 targetAttrs = UnixFileAttributes.get(target, false);
436 } catch (UnixException x) {
437 // ignore
438 }
439 boolean targetExists = (targetAttrs != null);
440
441 // if the target exists:
442 // 1. check if source and target are the same file
443 // 2. throw exception if REPLACE_EXISTING option is not set
444 // 3. delete target if REPLACE_EXISTING option set
445 if (targetExists) {
446 if (sourceAttrs.isSameFile(targetAttrs))
447 return; // nothing to do as files are identical
448 if (!flags.replaceExisting) {
449 throw new FileAlreadyExistsException(
450 target.getPathForExceptionMessage());
451 }
452
453 // attempt to delete target
454 try {
455 if (targetAttrs.isDirectory()) {
456 rmdir(target);
457 } else {
458 unlink(target);
459 }
460 } catch (UnixException x) {
461 // target is non-empty directory that can't be replaced.
462 if (targetAttrs.isDirectory() &&
463 (x.errno() == EEXIST || x.errno() == ENOTEMPTY))
464 {
465 throw new DirectoryNotEmptyException(
466 target.getPathForExceptionMessage());
467 }
468 x.rethrowAsIOException(target);
469 }
470 }
471
472 // first try rename
473 try {
474 rename(source, target);
475 return;
476 } catch (UnixException x) {
477 if (x.errno() != EXDEV && x.errno() != EISDIR) {
478 x.rethrowAsIOException(source, target);
479 }
480 }
481
482 // copy source to target
483 if (sourceAttrs.isDirectory()) {
484 ensureEmptyDir(source);
485 copyDirectory(source, sourceAttrs, target, flags);
486 } else {
487 if (sourceAttrs.isSymbolicLink()) {
488 copyLink(source, sourceAttrs, target, flags);
489 } else {
490 if (sourceAttrs.isDevice()) {
491 copySpecial(source, sourceAttrs, target, flags);
492 } else {
493 copyFile(source, sourceAttrs, target, flags, 0L);
494 }
495 }
496 }
497
498 // delete source
499 try {
500 if (sourceAttrs.isDirectory()) {
501 rmdir(source);
502 } else {
503 unlink(source);
504 }
505 } catch (UnixException x) {
506 // file was copied but unable to unlink the source file so attempt
507 // to remove the target and throw a reasonable exception
508 try {
509 if (sourceAttrs.isDirectory()) {
510 rmdir(target);
511 } else {
512 unlink(target);
513 }
514 } catch (UnixException ignore) { }
515
516 if (sourceAttrs.isDirectory() &&
517 (x.errno() == EEXIST || x.errno() == ENOTEMPTY))
518 {
519 throw new DirectoryNotEmptyException(
520 source.getPathForExceptionMessage());
521 }
522 x.rethrowAsIOException(source);
523 }
524 }
525
526 // copy file from source to target
527 static void copy(final UnixPath source,
528 final UnixPath target,
529 CopyOption... options) throws IOException
530 {
531 // permission checks
532 SecurityManager sm = System.getSecurityManager();
533 if (sm != null) {
534 source.checkRead();
535 target.checkWrite();
536 }
537
538 // translate options into flags
539 final Flags flags = Flags.fromCopyOptions(options);
540
541 UnixFileAttributes sourceAttrs = null;
542 UnixFileAttributes targetAttrs = null;
543
544 // get attributes of source file
545 try {
546 sourceAttrs = UnixFileAttributes.get(source, flags.followLinks);
547 } catch (UnixException x) {
548 x.rethrowAsIOException(source);
549 }
550
551 // if source file is symbolic link then we must check LinkPermission
552 if (sm != null && sourceAttrs.isSymbolicLink()) {
553 sm.checkPermission(new LinkPermission("symbolic"));
554 }
555
556 // get attributes of target file (don't follow links)
557 try {
558 targetAttrs = UnixFileAttributes.get(target, false);
559 } catch (UnixException x) {
560 // ignore
561 }
562 boolean targetExists = (targetAttrs != null);
563
564 // if the target exists:
565 // 1. check if source and target are the same file
566 // 2. throw exception if REPLACE_EXISTING option is not set
567 // 3. try to unlink the target
568 if (targetExists) {
569 if (sourceAttrs.isSameFile(targetAttrs))
570 return; // nothing to do as files are identical
571 if (!flags.replaceExisting)
572 throw new FileAlreadyExistsException(
573 target.getPathForExceptionMessage());
574 try {
575 if (targetAttrs.isDirectory()) {
576 rmdir(target);
577 } else {
578 unlink(target);
579 }
580 } catch (UnixException x) {
581 // target is non-empty directory that can't be replaced.
582 if (targetAttrs.isDirectory() &&
583 (x.errno() == EEXIST || x.errno() == ENOTEMPTY))
584 {
585 throw new DirectoryNotEmptyException(
586 target.getPathForExceptionMessage());
587 }
588 x.rethrowAsIOException(target);
589 }
590 }
591
592 // do the copy
593 if (sourceAttrs.isDirectory()) {
594 copyDirectory(source, sourceAttrs, target, flags);
595 return;
596 }
597 if (sourceAttrs.isSymbolicLink()) {
598 copyLink(source, sourceAttrs, target, flags);
599 return;
600 }
601 if (!flags.interruptible) {
602 // non-interruptible file copy
603 copyFile(source, sourceAttrs, target, flags, 0L);
604 return;
605 }
606
607 // interruptible file copy
608 final UnixFileAttributes attrsToCopy = sourceAttrs;
609 Cancellable copyTask = new Cancellable() {
610 @Override public void implRun() throws IOException {
611 copyFile(source, attrsToCopy, target, flags,
612 addressToPollForCancel());
613 }
614 };
615 try {
616 Cancellable.runInterruptibly(copyTask);
617 } catch (ExecutionException e) {
618 Throwable t = e.getCause();
619 if (t instanceof IOException)
620 throw (IOException)t;
621 throw new IOException(t);
622 }
623 }
624
625 // -- native methods --
626
627 static native void transfer(int dst, int src, long addressToPollForCancel)
628 throws UnixException;
629
630 static {
631 AccessController.doPrivileged(new PrivilegedAction<>() {
632 @Override
633 public Void run() {
634 System.loadLibrary("nio");
635 return null;
636 }});
637 }
638
639 }