2 Copyright (C) 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
5 Written by: 1994, 1995 Janne Kukonlehto
6 1994, 1995 Fred Leeflang
7 1994, 1995, 1996 Miguel de Icaza
8 1995, 1996 Jakub Jelinek
12 The copy code was based in GNU's cp, and was written by:
13 Torbjorn Granlund, David MacKenzie, and Jim Meyering.
15 The move code was based in GNU's mv, and was written by:
16 Mike Parker and David MacKenzie.
18 Janne Kukonlehto added much error recovery to them for being used
19 in an interactive program.
21 This program is free software; you can redistribute it and/or modify
22 it under the terms of the GNU General Public License as published by
23 the Free Software Foundation; either version 2 of the License, or
24 (at your option) any later version.
26 This program is distributed in the hope that it will be useful,
27 but WITHOUT ANY WARRANTY; without even the implied warranty of
28 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29 GNU General Public License for more details.
31 You should have received a copy of the GNU General Public License
32 along with this program; if not, write to the Free Software
33 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
36 * Please note that all dialogs used here must be safe for background
41 * \brief Source: file management
44 /* {{{ Include files */
53 #include <sys/types.h>
59 #include "lib/global.h"
60 #include "lib/tty/tty.h"
61 #include "lib/tty/key.h"
62 #include "lib/search.h"
63 #include "lib/vfs/mc-vfs/vfs-impl.h"
64 #include "lib/vfs/mc-vfs/vfs.h"
65 #include "lib/strescape.h"
66 #include "lib/strutil.h"
75 #include "background.h" /* we_are_background */
77 /* Needed for current_panel, other_panel and WTree */
86 /* Hack: the vfs code should not rely on this */
87 #define WITH_FULL_PATHS 1
92 * Whether the Midnight Commander tries to provide more
93 * information about copy/move sizes and bytes transfered
94 * at the expense of some speed
96 int file_op_compute_totals
= 1;
98 /* This is a hard link cache */
101 struct vfs_class
*vfs
;
109 /* the hard link cache */
110 static struct link
*linklist
= NULL
;
112 /* the files-to-be-erased list */
113 static struct link
*erase_list
;
116 * In copy_dir_dir we use two additional single linked lists: The first -
117 * variable name `parent_dirs' - holds information about already copied
118 * directories and is used to detect cyclic symbolic links.
119 * The second (`dest_dirs' below) holds information about just created
120 * target directories and is used to detect when an directory is copied
121 * into itself (we don't want to copy infinitly).
122 * Both lists don't use the linkcount and name structure members of struct
125 static struct link
*dest_dirs
= NULL
;
127 /* TRANSLATORS: no need to translate 'DialogTitle', it's just a context prefix */
128 const char *op_names
[3] = {
129 N_("DialogTitle|Copy"),
130 N_("DialogTitle|Move"),
131 N_("DialogTitle|Delete")
136 static FileProgressStatus
query_replace (FileOpContext
* ctx
, const char *destname
,
137 struct stat
*_s_stat
, struct stat
*_d_stat
);
138 static FileProgressStatus
query_recursive (FileOpContext
* ctx
, const char *s
);
139 static FileProgressStatus
do_file_error (const char *str
);
140 static FileProgressStatus
erase_dir_iff_empty (FileOpContext
*ctx
, const char *s
);
141 static FileProgressStatus
erase_file (FileOpContext
*ctx
, const char *s
,
142 off_t
*progress_count
, double *progress_bytes
,
143 int is_toplevel_file
);
144 static FileProgressStatus
files_error (const char *format
, const char *file1
,
147 static FileProgressStatus transform_error
= FILE_CONT
;
150 transform_source (FileOpContext
*ctx
, const char *source
)
155 s
= g_strdup (source
);
157 /* We remove \n from the filename since regex routines would use \n as an anchor */
158 /* this is just to be allowed to maniupulate file names with \n on it */
159 for (q
= s
; *q
!= '\0'; q
++)
163 fnsource
= (char *) x_basename (s
);
165 if (mc_search_run (ctx
->search_handle
, fnsource
, 0, strlen (fnsource
), NULL
))
166 q
= mc_search_prepare_replace_str2 (ctx
->search_handle
, ctx
->dest_mask
);
169 transform_error
= FILE_SKIP
;
177 free_linklist (struct link
**lc_linklist
)
179 struct link
*lp
, *lp2
;
181 for (lp
= *lc_linklist
; lp
!= NULL
; lp
= lp2
) {
189 is_in_linklist (struct link
*lp
, const char *path
, struct stat
*sb
)
191 ino_t ino
= sb
->st_ino
;
192 dev_t dev
= sb
->st_dev
;
194 struct vfs_class
*vfs
= vfs_get_class (path
);
195 #endif /* ENABLE_VFS */
202 #endif /* ENABLE_VFS */
203 if (lp
->ino
== ino
&& lp
->dev
== dev
)
211 * Returns 0 if the inode wasn't found in the cache and 1 if it was found
212 * and a hardlink was succesfully made
215 check_hardlinks (const char *src_name
, const char *dst_name
, struct stat
*pstat
)
218 struct vfs_class
*my_vfs
= vfs_get_class (src_name
);
219 ino_t ino
= pstat
->st_ino
;
220 dev_t dev
= pstat
->st_dev
;
221 struct stat link_stat
;
224 if (vfs_file_class_flags (src_name
) & VFSF_NOLINKS
)
227 for (lp
= linklist
; lp
!= NULL
; lp
= lp
->next
)
228 if (lp
->vfs
== my_vfs
&& lp
->ino
== ino
&& lp
->dev
== dev
) {
229 if (!mc_stat (lp
->name
, &link_stat
) && link_stat
.st_ino
== ino
230 && link_stat
.st_dev
== dev
231 && vfs_get_class (lp
->name
) == my_vfs
) {
232 p
= strchr (lp
->name
, 0) + 1; /* i.e. where the `name' file
234 if (vfs_get_class (dst_name
) == vfs_get_class (p
)) {
235 if (!mc_stat (p
, &link_stat
)) {
236 if (!mc_link (p
, dst_name
))
241 message (D_ERROR
, MSG_ERROR
, _(" Cannot make the hardlink "));
244 lp
= (struct link
*) g_try_malloc (sizeof (struct link
) + strlen (src_name
)
245 + strlen (dst_name
) + 1);
251 strcpy (lp
->name
, src_name
);
252 lpdstname
= lp
->name
+ strlen(lp
->name
) + 1;
253 strcpy (lpdstname
, dst_name
);
261 * Duplicate the contents of the symbolic link src_path in dst_path.
262 * Try to make a stable symlink if the option "stable symlink" was
263 * set in the file mask dialog.
264 * If dst_path is an existing symlink it will be deleted silently
265 * (upper levels take already care of existing files at dst_path).
267 static FileProgressStatus
268 make_symlink (FileOpContext
*ctx
, const char *src_path
, const char *dst_path
)
270 char link_target
[MC_MAXPATHLEN
];
272 FileProgressStatus return_status
;
276 if (mc_lstat (dst_path
, &sb
) == 0 && S_ISLNK (sb
.st_mode
))
282 len
= mc_readlink (src_path
, link_target
, MC_MAXPATHLEN
- 1);
285 file_error (_(" Cannot read source link \"%s\" \n %s "),
287 if (return_status
== FILE_RETRY
)
288 goto retry_src_readlink
;
289 return return_status
;
291 link_target
[len
] = 0;
293 if (ctx
->stable_symlinks
)
294 if (!vfs_file_is_local (src_path
) || !vfs_file_is_local (dst_path
)) {
295 message (D_ERROR
, MSG_ERROR
,
296 _(" Cannot make stable symlinks across "
297 "non-local filesystems: \n\n"
298 " Option Stable Symlinks will be disabled "));
299 ctx
->stable_symlinks
= 0;
302 if (ctx
->stable_symlinks
&& *link_target
!= PATH_SEP
) {
305 const char *r
= strrchr (src_path
, PATH_SEP
);
308 p
= g_strndup (src_path
, r
- src_path
+ 1);
309 if (*dst_path
== PATH_SEP
)
310 q
= g_strdup (dst_path
);
312 q
= g_strconcat (p
, dst_path
, (char *) NULL
);
313 s
= strrchr (q
, PATH_SEP
);
316 s
= g_strconcat (p
, link_target
, (char *) NULL
);
318 g_strlcpy (link_target
, s
, sizeof (link_target
));
320 s
= diff_two_paths (q
, link_target
);
322 g_strlcpy (link_target
, s
, sizeof (link_target
));
331 if (mc_symlink (link_target
, dst_path
) == 0)
335 * if dst_exists, it is obvious that this had failed.
336 * We can delete the old symlink and try again...
338 if (dst_is_symlink
) {
339 if (!mc_unlink (dst_path
))
340 if (mc_symlink (link_target
, dst_path
) == 0)
345 file_error (_(" Cannot create target symlink \"%s\" \n %s "),
347 if (return_status
== FILE_RETRY
)
348 goto retry_dst_symlink
;
349 return return_status
;
353 progress_update_one (FileOpContext
*ctx
,
354 off_t
*progress_count
,
355 double *progress_bytes
, off_t add
, int is_toplevel_file
)
359 if (is_toplevel_file
|| ctx
->progress_totals_computed
) {
361 (*progress_bytes
) += add
;
364 /* Apply some heuristic here to not call the update stuff very often */
366 file_progress_show_count (ctx
, *progress_count
,
367 ctx
->progress_count
);
368 if (ret
!= FILE_CONT
)
371 file_progress_show_bytes (ctx
, *progress_bytes
,
372 ctx
->progress_bytes
);
377 /* Status of the destination file */
379 DEST_NONE
, /* Not created */
380 DEST_SHORT
, /* Created, not fully copied */
381 DEST_FULL
/* Created, fully copied */
384 static FileProgressStatus
385 real_warn_same_file (enum OperationMode mode
, const char *fmt
,
386 const char *a
, const char *b
)
390 const char *head_msg
;
392 head_msg
= mode
== Foreground
? MSG_ERROR
:
393 _(" Background process error ");
395 msg
= g_strdup_printf (fmt
, a
, b
);
396 result
= query_dialog (head_msg
, msg
, D_ERROR
, 2, _("&Skip"), _("&Abort"));
399 if ( result
) { /* 1 == Abort */
406 #ifdef WITH_BACKGROUND
407 static FileProgressStatus
408 warn_same_file (const char *fmt
, const char *a
, const char *b
)
412 FileProgressStatus (*f
) (enum OperationMode
, const char *fmt
,
413 const char *a
, const char *b
);
415 pntr
.f
= real_warn_same_file
;
417 if (we_are_background
)
418 return parent_call (pntr
.p
, NULL
, 3, strlen (fmt
),
419 fmt
, strlen(a
), a
, strlen(b
), b
);
421 return real_warn_same_file (Foreground
, fmt
, a
, b
);
424 static FileProgressStatus
425 warn_same_file (const char *fmt
, const char *a
, const char *b
)
427 return real_warn_same_file (Foreground
, fmt
, a
, b
);
432 copy_file_file (FileOpContext
*ctx
, const char *src_path
, const char *dst_path
,
433 int ask_overwrite
, off_t
*progress_count
,
434 double *progress_bytes
, int is_toplevel_file
)
436 uid_t src_uid
= (uid_t
) - 1;
437 gid_t src_gid
= (gid_t
) - 1;
440 int buf_size
= BUF_8K
;
441 int src_desc
, dest_desc
= -1;
442 int n_read
, n_written
;
443 mode_t src_mode
= 0; /* The mode of the source file */
446 int dst_exists
= 0, appending
= 0;
447 off_t n_read_total
= 0, file_size
= -1;
448 FileProgressStatus return_status
, temp_status
;
449 struct timeval tv_transfer_start
;
450 int dst_status
= DEST_NONE
; /* 1 if the file is not fully copied */
453 /* FIXME: We should not be using global variables! */
455 return_status
= FILE_RETRY
;
457 if (file_progress_show_source (ctx
, src_path
) == FILE_ABORT
||
458 file_progress_show_target (ctx
, dst_path
) == FILE_ABORT
)
463 while (mc_stat (dst_path
, &sb2
) == 0) {
464 if (S_ISDIR (sb2
.st_mode
)) {
466 file_error (_(" Cannot overwrite directory \"%s\" \n %s "),
468 if (return_status
== FILE_RETRY
)
470 return return_status
;
476 while ((*ctx
->stat_func
) (src_path
, &sb
)) {
478 file_error (_(" Cannot stat source file \"%s\" \n %s "),
480 if (return_status
!= FILE_RETRY
)
481 return return_status
;
485 /* Destination already exists */
486 if (sb
.st_dev
== sb2
.st_dev
&& sb
.st_ino
== sb2
.st_ino
)
487 return warn_same_file (_(" `%s' \n and \n `%s' \n are the same file "),
489 /* Should we replace destination? */
492 return_status
= query_replace (ctx
, dst_path
, &sb
, &sb2
);
493 if (return_status
!= FILE_CONT
)
494 return return_status
;
498 if (!ctx
->do_append
) {
499 /* Check the hardlinks */
500 if (!ctx
->follow_links
&& sb
.st_nlink
> 1 &&
501 check_hardlinks (src_path
, dst_path
, &sb
) == 1) {
502 /* We have made a hardlink - no more processing is necessary */
506 if (S_ISLNK (sb
.st_mode
))
507 return make_symlink (ctx
, src_path
, dst_path
);
509 if (S_ISCHR (sb
.st_mode
) || S_ISBLK (sb
.st_mode
) ||
510 S_ISFIFO (sb
.st_mode
) || S_ISNAM (sb
.st_mode
) ||
511 S_ISSOCK (sb
.st_mode
)) {
512 while (mc_mknod (dst_path
, sb
.st_mode
& ctx
->umask_kill
,
514 return_status
= file_error (
515 _(" Cannot create special file \"%s\" \n %s "), dst_path
);
516 if (return_status
== FILE_RETRY
)
518 return return_status
;
522 while (ctx
->preserve_uidgid
523 && mc_chown (dst_path
, sb
.st_uid
, sb
.st_gid
)) {
524 temp_status
= file_error (
525 _(" Cannot chown target file \"%s\" \n %s "), dst_path
);
526 if (temp_status
== FILE_RETRY
)
530 while (ctx
->preserve
&&
531 mc_chmod (dst_path
, sb
.st_mode
& ctx
->umask_kill
)) {
532 temp_status
= file_error (
533 _(" Cannot chmod target file \"%s\" \n %s "), dst_path
);
534 if (temp_status
== FILE_RETRY
)
542 gettimeofday (&tv_transfer_start
, (struct timezone
*) NULL
);
544 while ((src_desc
= mc_open (src_path
, O_RDONLY
| O_LINEAR
)) < 0) {
545 return_status
= file_error (
546 _(" Cannot open source file \"%s\" \n %s "), src_path
);
547 if (return_status
== FILE_RETRY
)
550 return return_status
;
554 if (mc_lseek (src_desc
, ctx
->do_reget
, SEEK_SET
) != ctx
->do_reget
) {
555 message (D_ERROR
, _("Warning"),
556 _(" Reget failed, about to overwrite file "));
557 ctx
->do_reget
= ctx
->do_append
= 0;
561 while (mc_fstat (src_desc
, &sb
)) {
562 return_status
= file_error (
563 _(" Cannot fstat source file \"%s\" \n %s "), src_path
);
564 if (return_status
== FILE_RETRY
)
569 src_mode
= sb
.st_mode
;
572 utb
.actime
= sb
.st_atime
;
573 utb
.modtime
= sb
.st_mtime
;
574 file_size
= sb
.st_size
;
576 open_flags
= O_WRONLY
;
577 if (dst_exists
!= 0) {
578 if (ctx
->do_append
!= 0)
579 open_flags
|= O_APPEND
;
581 open_flags
|= O_CREAT
| O_TRUNC
;
583 open_flags
|= O_CREAT
| O_EXCL
;
585 while ((dest_desc
= mc_open (dst_path
, open_flags
, src_mode
)) < 0) {
586 if (errno
== EEXIST
) {
589 return_status
= file_error (
590 _(" Cannot create target file \"%s\" \n %s "), dst_path
);
591 if (return_status
== FILE_RETRY
)
596 dst_status
= DEST_SHORT
; /* file opened, but not fully copied */
598 appending
= ctx
->do_append
;
601 /* Find out the optimal buffer size. */
602 while (mc_fstat (dest_desc
, &sb
)) {
603 return_status
= file_error (
604 _(" Cannot fstat target file \"%s\" \n %s "), dst_path
);
605 if (return_status
== FILE_RETRY
)
609 buf
= g_malloc (buf_size
);
614 return_status
= file_progress_show (ctx
, 0, file_size
);
618 if (return_status
!= FILE_CONT
)
622 struct timeval tv_current
, tv_last_update
, tv_last_input
;
623 int secs
, update_secs
;
625 const char *stalled_msg
;
627 tv_last_update
= tv_transfer_start
;
631 if (mc_ctl (src_desc
, VFS_CTL_IS_NOTREADY
, 0))
634 while ((n_read
= mc_read (src_desc
, buf
, buf_size
)) < 0) {
635 return_status
= file_error (
636 _(" Cannot read source file \"%s\" \n %s "), src_path
);
637 if (return_status
== FILE_RETRY
)
644 gettimeofday (&tv_current
, NULL
);
648 n_read_total
+= n_read
;
650 /* Windows NT ftp servers report that files have no
651 * permissions: -------, so if we happen to have actually
652 * read something, we should fix the permissions.
654 if (!(src_mode
& (S_IRWXU
| S_IRWXG
| S_IRWXO
)))
655 src_mode
= S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IROTH
;
656 gettimeofday (&tv_last_input
, NULL
);
660 mc_write (dest_desc
, t
, n_read
)) < n_read
) {
667 file_error (_(" Cannot write target file \"%s\" \n %s "),
669 if (return_status
!= FILE_RETRY
)
674 /* 1. Update rotating dash after some time (hardcoded to 2 seconds) */
675 secs
= (tv_current
.tv_sec
- tv_last_update
.tv_sec
);
678 tv_last_update
= tv_current
;
681 /* 2. Check for a stalled condition */
682 update_secs
= (tv_current
.tv_sec
- tv_last_input
.tv_sec
);
684 if (update_secs
> 4) {
685 stalled_msg
= _("(stalled)");
690 dt
= (tv_current
.tv_sec
- tv_transfer_start
.tv_sec
);
694 ((dt
/ (double) n_read_total
) * file_size
) - dt
;
695 ctx
->bps
= n_read_total
/ ((dt
< 1) ? 1 : dt
);
700 /* 4. Compute BPS rate */
703 (tv_current
.tv_sec
- tv_transfer_start
.tv_sec
);
704 if (ctx
->bps_time
< 1)
706 ctx
->bps
= n_read_total
/ ctx
->bps_time
;
709 file_progress_set_stalled_label (ctx
, stalled_msg
);
710 return_status
= file_progress_show_bytes (ctx
, *progress_bytes
+
711 n_read_total
+ ctx
->do_reget
, ctx
->progress_bytes
);
712 if (return_status
== FILE_CONT
) {
714 file_progress_show (ctx
, n_read_total
+ ctx
->do_reget
, file_size
);
717 if (return_status
!= FILE_CONT
)
722 dst_status
= DEST_FULL
; /* copy successful, don't remove target file */
727 while (src_desc
!= -1 && mc_close (src_desc
) < 0) {
728 temp_status
= file_error (
729 _(" Cannot close source file \"%s\" \n %s "), src_path
);
730 if (temp_status
== FILE_RETRY
)
732 if (temp_status
== FILE_ABORT
)
733 return_status
= temp_status
;
737 while (dest_desc
!= -1 && mc_close (dest_desc
) < 0) {
738 temp_status
= file_error (
739 _(" Cannot close target file \"%s\" \n %s "), dst_path
);
740 if (temp_status
== FILE_RETRY
)
742 return_status
= temp_status
;
746 if (dst_status
== DEST_SHORT
) {
747 /* Remove short file */
749 result
= query_dialog (Q_("DialogTitle|Copy"),
750 _("Incomplete file was retrieved. Keep it?"),
751 D_ERROR
, 2, _("&Delete"), _("&Keep"));
753 mc_unlink (dst_path
);
754 } else if (dst_status
== DEST_FULL
) {
755 /* Copy has succeeded */
756 if (!appending
&& ctx
->preserve_uidgid
) {
757 while (mc_chown (dst_path
, src_uid
, src_gid
)) {
758 temp_status
= file_error (
759 _(" Cannot chown target file \"%s\" \n %s "), dst_path
);
760 if (temp_status
== FILE_RETRY
)
762 return_status
= temp_status
;
769 while (mc_chmod (dst_path
, (src_mode
& ctx
->umask_kill
))) {
770 temp_status
= file_error (
771 _(" Cannot chmod target file \"%s\" \n %s "), dst_path
);
772 if (temp_status
!= FILE_RETRY
) {
773 return_status
= temp_status
;
778 src_mode
= umask(-1);
780 src_mode
= 0100666 & ~src_mode
;
781 mc_chmod (dst_path
, (src_mode
& ctx
->umask_kill
));
783 mc_utime (dst_path
, &utb
);
787 if (return_status
== FILE_CONT
)
789 progress_update_one (ctx
, progress_count
, progress_bytes
,
790 file_size
, is_toplevel_file
);
792 return return_status
;
796 * I think these copy_*_* functions should have a return type.
797 * anyway, this function *must* have two directories as arguments.
799 /* FIXME: This function needs to check the return values of the
802 copy_dir_dir (FileOpContext
*ctx
, const char *s
, const char *_d
, int toplevel
,
803 int move_over
, int delete, struct link
*parent_dirs
,
804 off_t
*progress_count
, double *progress_bytes
)
807 struct stat buf
, cbuf
;
809 char *dest_dir
= NULL
;
810 FileProgressStatus return_status
= FILE_CONT
;
815 d
= strutils_shell_unescape (_d
);
817 /* First get the mode of the source dir */
819 if ((*ctx
->stat_func
) (s
, &cbuf
)) {
821 file_error (_(" Cannot stat source directory \"%s\" \n %s "), s
);
822 if (return_status
== FILE_RETRY
)
827 if (is_in_linklist (dest_dirs
, s
, &cbuf
)) {
828 /* Don't copy a directory we created before (we don't want to copy
829 infinitely if a directory is copied into itself) */
830 /* FIXME: should there be an error message and FILE_SKIP? - Norbert */
831 return_status
= FILE_CONT
;
835 /* Hmm, hardlink to directory??? - Norbert */
836 /* FIXME: In this step we should do something
837 in case the destination already exist */
838 /* Check the hardlinks */
839 if (ctx
->preserve
&& cbuf
.st_nlink
> 1
840 && check_hardlinks (s
, d
, &cbuf
) == 1) {
841 /* We have made a hardlink - no more processing is necessary */
845 if (!S_ISDIR (cbuf
.st_mode
)) {
847 file_error (_(" Source \"%s\" is not a directory \n %s "), s
);
848 if (return_status
== FILE_RETRY
)
853 if (is_in_linklist (parent_dirs
, s
, &cbuf
)) {
854 /* we found a cyclic symbolic link */
855 message (D_ERROR
, MSG_ERROR
,
856 _(" Cannot copy cyclic symbolic link \n `%s' "), s
);
857 return_status
= FILE_SKIP
;
861 lp
= g_new (struct link
, 1);
862 lp
->vfs
= vfs_get_class (s
);
863 lp
->ino
= cbuf
.st_ino
;
864 lp
->dev
= cbuf
.st_dev
;
865 lp
->next
= parent_dirs
;
869 /* Now, check if the dest dir exists, if not, create it. */
870 if (mc_stat (d
, &buf
)) {
871 /* Here the dir doesn't exist : make it ! */
873 if (mc_rename (s
, d
) == 0) {
874 return_status
= FILE_CONT
;
882 * If the destination directory exists, we want to copy the whole
883 * directory, but we only want this to happen once.
885 * Escape sequences added to the * to compiler warnings.
886 * so, say /bla exists, if we copy /tmp/\* to /bla, we get /bla/tmp/\*
887 * or ( /bla doesn't exist ) /tmp/\* to /bla -> /bla/\*
889 if (!S_ISDIR (buf
.st_mode
)) {
890 return_status
= file_error(
891 _(" Destination \"%s\" must be a directory \n %s "), d
);
892 if (return_status
== FILE_RETRY
)
896 /* Dive into subdir if exists */
897 if (toplevel
&& ctx
->dive_into_subdirs
) {
898 dest_dir
= concat_dir_and_file (d
, x_basename (s
));
905 while (my_mkdir (dest_dir
, (cbuf
.st_mode
& ctx
->umask_kill
) | S_IRWXU
)) {
906 return_status
= file_error (
907 _(" Cannot create target directory \"%s\" \n %s "), dest_dir
);
908 if (return_status
!= FILE_RETRY
)
912 lp
= g_new (struct link
, 1);
913 mc_stat (dest_dir
, &buf
);
914 lp
->vfs
= vfs_get_class (dest_dir
);
915 lp
->ino
= buf
.st_ino
;
916 lp
->dev
= buf
.st_dev
;
917 lp
->next
= dest_dirs
;
920 if (ctx
->preserve_uidgid
) {
921 while (mc_chown (dest_dir
, cbuf
.st_uid
, cbuf
.st_gid
)) {
922 return_status
= file_error (
923 _(" Cannot chown target directory \"%s\" \n %s "), dest_dir
);
924 if (return_status
!= FILE_RETRY
)
930 /* open the source dir for reading */
931 reading
= mc_opendir (s
);
935 while ((next
= mc_readdir (reading
)) && return_status
!= FILE_ABORT
) {
938 * Now, we don't want '.' and '..' to be created / copied at any time
940 if (!strcmp (next
->d_name
, "."))
942 if (!strcmp (next
->d_name
, ".."))
945 /* get the filename and add it to the src directory */
946 path
= concat_dir_and_file (s
, next
->d_name
);
948 (*ctx
->stat_func
) (path
, &buf
);
949 if (S_ISDIR (buf
.st_mode
)) {
952 mdpath
= concat_dir_and_file (dest_dir
, next
->d_name
);
954 * From here, we just intend to recursively copy subdirs, not
955 * the double functionality of copying different when the target
956 * dir already exists. So, we give the recursive call the flag 0
957 * meaning no toplevel.
959 return_status
= copy_dir_dir (ctx
, path
, mdpath
, 0, 0, delete,
960 parent_dirs
, progress_count
, progress_bytes
);
965 dest_file
= concat_dir_and_file (dest_dir
, x_basename (path
));
966 return_status
= copy_file_file (ctx
, path
, dest_file
, 1,
967 progress_count
, progress_bytes
, 0);
970 if (delete && return_status
== FILE_CONT
) {
971 if (ctx
->erase_at_end
) {
972 static struct link
*tail
;
973 size_t len
= strlen (path
);
974 lp
= g_malloc (sizeof (struct link
) + len
);
975 strncpy (lp
->name
, path
, len
+ 1);
976 lp
->st_mode
= buf
.st_mode
;
978 if (erase_list
!= NULL
) {
982 erase_list
= tail
= lp
;
984 if (S_ISDIR (buf
.st_mode
)) {
985 return_status
= erase_dir_iff_empty (ctx
, path
);
987 return_status
= erase_file (ctx
, path
, 0, 0, 0);
992 mc_closedir (reading
);
995 mc_chmod (dest_dir
, cbuf
.st_mode
& ctx
->umask_kill
);
996 utb
.actime
= cbuf
.st_atime
;
997 utb
.modtime
= cbuf
.st_mtime
;
998 mc_utime (dest_dir
, &utb
);
1000 cbuf
.st_mode
= umask(-1);
1001 umask(cbuf
.st_mode
);
1002 cbuf
.st_mode
= 0100777 & ~cbuf
.st_mode
;
1003 mc_chmod (dest_dir
, cbuf
.st_mode
& ctx
->umask_kill
);
1008 g_free (parent_dirs
);
1011 return return_status
;
1016 /* {{{ Move routines */
1018 static FileProgressStatus
1019 move_file_file (FileOpContext
*ctx
, const char *s
, const char *d
,
1020 off_t
*progress_count
, double *progress_bytes
)
1022 struct stat src_stats
, dst_stats
;
1023 FileProgressStatus return_status
= FILE_CONT
;
1024 gboolean copy_done
= FALSE
;
1026 if (file_progress_show_source (ctx
, s
) == FILE_ABORT
1027 || file_progress_show_target (ctx
, d
) == FILE_ABORT
)
1032 while (mc_lstat (s
, &src_stats
) != 0) {
1033 /* Source doesn't exist */
1035 file_error (_(" Cannot stat file \"%s\" \n %s "), s
);
1036 if (return_status
!= FILE_RETRY
)
1037 return return_status
;
1040 if (mc_lstat (d
, &dst_stats
) == 0) {
1041 if (src_stats
.st_dev
== dst_stats
.st_dev
1042 && src_stats
.st_ino
== dst_stats
.st_ino
)
1043 return warn_same_file (_(" `%s' \n and \n `%s' \n are the same file "), s
, d
);
1045 if (S_ISDIR (dst_stats
.st_mode
)) {
1046 message (D_ERROR
, MSG_ERROR
,
1047 _(" Cannot overwrite directory `%s' "), d
);
1052 if (confirm_overwrite
) {
1053 return_status
= query_replace (ctx
, d
, &src_stats
, &dst_stats
);
1054 if (return_status
!= FILE_CONT
)
1055 return return_status
;
1057 /* Ok to overwrite */
1060 if (!ctx
->do_append
) {
1061 if (S_ISLNK (src_stats
.st_mode
) && ctx
->stable_symlinks
) {
1062 if ((return_status
= make_symlink (ctx
, s
, d
)) == FILE_CONT
) {
1063 goto retry_src_remove
;
1065 return return_status
;
1068 if (mc_rename (s
, d
) == 0) {
1069 return progress_update_one (ctx
, progress_count
,
1071 src_stats
.st_size
, 1);
1075 /* Comparison to EXDEV seems not to work in nfs if you're moving from
1076 one nfs to the same, but on the server it is on two different
1077 filesystems. Then nfs returns EIO instead of EXDEV.
1078 Hope it will not hurt if we always in case of error try to copy/delete. */
1080 errno
= EXDEV
; /* Hack to copy (append) the file and then delete it */
1082 if (errno
!= EXDEV
) {
1084 files_error (_(" Cannot move file \"%s\" to \"%s\" \n %s "), s
,
1086 if (return_status
== FILE_RETRY
)
1088 return return_status
;
1092 /* Failed because filesystem boundary -> copy the file instead */
1094 copy_file_file (ctx
, s
, d
, 0, progress_count
, progress_bytes
, 1);
1095 if (return_status
!= FILE_CONT
)
1096 return return_status
;
1100 if ((return_status
=
1101 file_progress_show_source (ctx
, NULL
)) != FILE_CONT
1102 || (return_status
= file_progress_show (ctx
, 0, 0)) != FILE_CONT
)
1103 return return_status
;
1108 if (mc_unlink (s
)) {
1110 file_error (_(" Cannot remove file \"%s\" \n %s "), s
);
1111 if (return_status
== FILE_RETRY
)
1112 goto retry_src_remove
;
1113 return return_status
;
1117 return_status
= progress_update_one (ctx
,
1120 src_stats
.st_size
, 1);
1123 return return_status
;
1127 move_dir_dir (FileOpContext
*ctx
, const char *s
, const char *d
,
1128 off_t
*progress_count
, double *progress_bytes
)
1130 struct stat sbuf
, dbuf
, destbuf
;
1133 FileProgressStatus return_status
;
1134 gboolean move_over
= FALSE
;
1137 if (file_progress_show_source (ctx
, s
) == FILE_ABORT
||
1138 file_progress_show_target (ctx
, d
) == FILE_ABORT
)
1144 dstat_ok
= (mc_stat (d
, &dbuf
) == 0);
1146 if (dstat_ok
&& sbuf
.st_dev
== dbuf
.st_dev
&& sbuf
.st_ino
== dbuf
.st_ino
)
1147 return warn_same_file (_(" `%s' \n and \n `%s' \n are the same directory "), s
, d
);
1150 destdir
= g_strdup (d
); /* destination doesn't exist */
1151 else if (!ctx
->dive_into_subdirs
) {
1152 destdir
= g_strdup (d
);
1155 destdir
= concat_dir_and_file (d
, x_basename (s
));
1157 /* Check if the user inputted an existing dir */
1159 if (!mc_stat (destdir
, &destbuf
)) {
1161 return_status
= copy_dir_dir (ctx
, s
, destdir
, 0, 1, 1, 0,
1162 progress_count
, progress_bytes
);
1164 if (return_status
!= FILE_CONT
)
1168 if (S_ISDIR (destbuf
.st_mode
))
1171 (" Cannot overwrite directory \"%s\" %s "),
1175 file_error (_(" Cannot overwrite file \"%s\" %s "),
1177 if (return_status
== FILE_RETRY
)
1178 goto retry_dst_stat
;
1181 return return_status
;
1185 if (mc_rename (s
, destdir
) == 0) {
1186 return_status
= FILE_CONT
;
1190 if (errno
!= EXDEV
) {
1193 (" Cannot move directory \"%s\" to \"%s\" \n %s "),
1195 if (return_status
== FILE_RETRY
)
1199 /* Failed because of filesystem boundary -> copy dir instead */
1201 copy_dir_dir (ctx
, s
, destdir
, 0, 0, 1, 0, progress_count
,
1204 if (return_status
!= FILE_CONT
)
1207 if ((return_status
=
1208 file_progress_show_source (ctx
, NULL
)) != FILE_CONT
1209 || (return_status
= file_progress_show (ctx
, 0, 0)) != FILE_CONT
)
1213 if (ctx
->erase_at_end
) {
1214 for (; erase_list
&& return_status
!= FILE_ABORT
;) {
1215 if (S_ISDIR (erase_list
->st_mode
)) {
1217 erase_dir_iff_empty (ctx
, erase_list
->name
);
1220 erase_file (ctx
, erase_list
->name
, 0, 0, 0);
1222 erase_list
= erase_list
->next
;
1226 erase_dir_iff_empty (ctx
, s
);
1230 while (erase_list
) {
1232 erase_list
= erase_list
->next
;
1235 return return_status
;
1240 /* {{{ Erase routines */
1241 /* Don't update progress status if progress_count==NULL */
1242 static FileProgressStatus
1243 erase_file (FileOpContext
*ctx
, const char *s
, off_t
*progress_count
,
1244 double *progress_bytes
, int is_toplevel_file
)
1249 if (file_progress_show_deleting (ctx
, s
) == FILE_ABORT
)
1253 if (progress_count
&& mc_lstat (s
, &buf
)) {
1254 /* ignore, most likely the mc_unlink fails, too */
1258 while (mc_unlink (s
)) {
1260 file_error (_(" Cannot delete file \"%s\" \n %s "), s
);
1261 if (return_status
!= FILE_RETRY
)
1262 return return_status
;
1266 return progress_update_one (ctx
, progress_count
, progress_bytes
,
1267 buf
.st_size
, is_toplevel_file
);
1272 static FileProgressStatus
1273 recursive_erase (FileOpContext
*ctx
, const char *s
, off_t
*progress_count
,
1274 double *progress_bytes
)
1276 struct dirent
*next
;
1280 FileProgressStatus return_status
= FILE_CONT
;
1282 if (!strcmp (s
, ".."))
1285 reading
= mc_opendir (s
);
1290 while ((next
= mc_readdir (reading
)) && return_status
== FILE_CONT
) {
1291 if (!strcmp (next
->d_name
, "."))
1293 if (!strcmp (next
->d_name
, ".."))
1295 path
= concat_dir_and_file (s
, next
->d_name
);
1296 if (mc_lstat (path
, &buf
)) {
1298 mc_closedir (reading
);
1301 if (S_ISDIR (buf
.st_mode
))
1304 (ctx
, path
, progress_count
, progress_bytes
)
1305 != FILE_CONT
) ? FILE_RETRY
: FILE_CONT
;
1308 erase_file (ctx
, path
, progress_count
, progress_bytes
, 0);
1311 mc_closedir (reading
);
1312 if (return_status
!= FILE_CONT
)
1313 return return_status
;
1314 if (file_progress_show_deleting (ctx
, s
) == FILE_ABORT
)
1318 while (my_rmdir (s
)) {
1320 file_error (_(" Cannot remove directory \"%s\" \n %s "), s
);
1321 if (return_status
!= FILE_RETRY
)
1322 return return_status
;
1328 /* Return -1 on error, 1 if there are no entries besides "." and ".."
1329 in the directory path points to, 0 else. */
1331 check_dir_is_empty (const char *path
)
1337 dir
= mc_opendir (path
);
1341 for (i
= 1, d
= mc_readdir (dir
); d
; d
= mc_readdir (dir
)) {
1342 if (d
->d_name
[0] == '.' && (d
->d_name
[1] == '\0' ||
1343 (d
->d_name
[1] == '.'
1344 && d
->d_name
[2] == '\0')))
1345 continue; /* "." or ".." */
1355 erase_dir (FileOpContext
*ctx
, const char *s
, off_t
*progress_count
,
1356 double *progress_bytes
)
1358 FileProgressStatus error
;
1360 if (strcmp (s
, "..") == 0)
1363 if (strcmp (s
, ".") == 0)
1366 if (file_progress_show_deleting (ctx
, s
) == FILE_ABORT
)
1370 /* The old way to detect a non empty directory was:
1371 error = my_rmdir (s);
1372 if (error && (errno == ENOTEMPTY || errno == EEXIST))){
1373 For the linux user space nfs server (nfs-server-2.2beta29-2)
1374 we would have to check also for EIO. I hope the new way is
1375 fool proof. (Norbert)
1377 error
= check_dir_is_empty (s
);
1378 if (error
== 0) { /* not empty */
1379 error
= query_recursive (ctx
, s
);
1380 if (error
== FILE_CONT
)
1381 return recursive_erase (ctx
, s
, progress_count
,
1387 while (my_rmdir (s
) == -1) {
1389 file_error (_(" Cannot remove directory \"%s\" \n %s "), s
);
1390 if (error
!= FILE_RETRY
)
1397 static FileProgressStatus
1398 erase_dir_iff_empty (FileOpContext
*ctx
, const char *s
)
1400 FileProgressStatus error
;
1402 if (strcmp (s
, "..") == 0)
1405 if (strcmp (s
, ".") == 0)
1408 if (file_progress_show_deleting (ctx
, s
) == FILE_ABORT
)
1412 if (1 != check_dir_is_empty (s
)) /* not empty or error */
1415 while (my_rmdir (s
)) {
1417 file_error (_(" Cannot remove directory \"%s\" \n %s "), s
);
1418 if (error
!= FILE_RETRY
)
1427 /* {{{ Panel operate routines */
1430 * Return currently selected entry name or the name of the first marked
1431 * entry if there is one.
1434 panel_get_file (WPanel
*panel
, struct stat
*stat_buf
)
1438 if (get_current_type () == view_tree
) {
1439 WTree
*tree
= (WTree
*) get_panel_widget (get_current_index ());
1440 char *tree_name
= tree_selected_name (tree
);
1442 mc_stat (tree_name
, stat_buf
);
1446 if (panel
->marked
) {
1447 for (i
= 0; i
< panel
->count
; i
++)
1448 if (panel
->dir
.list
[i
].f
.marked
) {
1449 *stat_buf
= panel
->dir
.list
[i
].st
;
1450 return panel
->dir
.list
[i
].fname
;
1453 *stat_buf
= panel
->dir
.list
[panel
->selected
].st
;
1454 return panel
->dir
.list
[panel
->selected
].fname
;
1456 g_assert_not_reached ();
1462 compute_dir_size_create_ui (void)
1464 ComputeDirSizeUI
*ui
;
1466 const char *b_name
= N_("&Abort");
1472 ui
= g_new (ComputeDirSizeUI
, 1);
1474 ui
->dlg
= create_dlg (0, 0, 8, COLS
/2, dialog_colors
, NULL
,
1475 NULL
, _("Directory scanning"), DLG_CENTER
);
1476 ui
->dirname
= label_new (3, 3, "");
1477 add_widget (ui
->dlg
, ui
->dirname
);
1479 add_widget (ui
->dlg
,
1480 button_new (5, (ui
->dlg
->cols
- strlen (b_name
))/2,
1481 FILE_ABORT
, NORMAL_BUTTON
, b_name
, NULL
));
1483 /* We will manage the dialog without any help,
1484 that's why we have to call init_dlg */
1491 compute_dir_size_destroy_ui (ComputeDirSizeUI
*ui
)
1494 /* schedule to update passive panel */
1495 other_panel
->dirty
= 1;
1497 /* close and destroy dialog */
1498 dlg_run_done (ui
->dlg
);
1499 destroy_dlg (ui
->dlg
);
1505 compute_dir_size_update_ui (const void *ui
, const char *dirname
)
1507 const ComputeDirSizeUI
*this = (const ComputeDirSizeUI
*) ui
;
1514 label_set_text (this->dirname
, name_trunc (dirname
, this->dlg
->cols
- 6));
1516 event
.x
= -1; /* Don't show the GPM cursor */
1517 c
= tty_get_event (&event
, FALSE
, FALSE
);
1521 /* Reinitialize to avoid old values after events other than
1522 selecting a button */
1523 this->dlg
->ret_value
= FILE_CONT
;
1525 dlg_process_event (this->dlg
, c
, &event
);
1527 switch (this->dlg
->ret_value
) {
1539 * Computes the number of bytes used by the files in a directory
1542 compute_dir_size (const char *dirname
, const void *ui
,
1543 compute_dir_size_callback cback
,
1544 off_t
*ret_marked
, double *ret_total
)
1547 struct dirent
*dirent
;
1548 FileProgressStatus ret
= FILE_CONT
;
1550 dir
= mc_opendir (dirname
);
1555 while ((dirent
= mc_readdir (dir
)) != NULL
) {
1560 ret
= (cback
!= NULL
) ? cback (ui
, dirname
) : FILE_CONT
;
1562 if (ret
!= FILE_CONT
)
1565 if (strcmp (dirent
->d_name
, ".") == 0)
1567 if (strcmp (dirent
->d_name
, "..") == 0)
1570 fullname
= concat_dir_and_file (dirname
, dirent
->d_name
);
1571 res
= mc_lstat (fullname
, &s
);
1578 if (S_ISDIR (s
.st_mode
)) {
1579 off_t subdir_count
= 0;
1580 double subdir_bytes
= 0;
1582 ret
= compute_dir_size (fullname
, ui
, cback
, &subdir_count
, &subdir_bytes
);
1584 if (ret
!= FILE_CONT
) {
1589 *ret_marked
+= subdir_count
;
1590 *ret_total
+= subdir_bytes
;
1593 *ret_total
+= s
.st_size
;
1605 * panel_compute_totals:
1607 * compute the number of files and the number of bytes
1608 * used up by the whole selection, recursing directories
1609 * as required. In addition, it checks to see if it will
1610 * overwrite any files by doing the copy.
1612 static FileProgressStatus
1613 panel_compute_totals (WPanel
*panel
, const void *ui
,
1614 compute_dir_size_callback cback
,
1615 off_t
*ret_marked
, double *ret_total
)
1622 for (i
= 0; i
< panel
->count
; i
++) {
1625 if (!panel
->dir
.list
[i
].f
.marked
)
1628 s
= &panel
->dir
.list
[i
].st
;
1630 if (S_ISDIR (s
->st_mode
)) {
1632 off_t subdir_count
= 0;
1633 double subdir_bytes
= 0;
1634 FileProgressStatus status
;
1637 concat_dir_and_file (panel
->cwd
, panel
->dir
.list
[i
].fname
);
1639 status
= compute_dir_size (dir_name
, ui
, cback
,
1640 &subdir_count
, &subdir_bytes
);
1643 if (status
!= FILE_CONT
)
1646 *ret_marked
+= subdir_count
;
1647 *ret_total
+= subdir_bytes
;
1650 *ret_total
+= s
->st_size
;
1658 * This array introduced to avoid translation problems. The former (op_names)
1659 * is assumed to be nouns, suitable in dialog box titles; this one should
1660 * contain whatever is used in prompt itself (i.e. in russian, it's verb).
1661 * (I don't use spaces around the words, because someday they could be
1662 * dropped, when widgets get smarter)
1665 /* TRANSLATORS: no need to translate 'FileOperation', it's just a context prefix */
1666 static const char *op_names1
[] = {
1667 N_("FileOperation|Copy"),
1668 N_("FileOperation|Move"),
1669 N_("FileOperation|Delete")
1673 * These are formats for building a prompt. Parts encoded as follows:
1674 * %o - operation from op_names1
1675 * %f - file/files or files/directories, as appropriate
1676 * %m - "with source mask" or question mark for delete
1677 * %s - source name (truncated)
1678 * %d - number of marked files
1679 * %e - "to:" or question mark for delete
1681 * xgettext:no-c-format */
1682 static const char *one_format
= N_("%o %f \"%s\"%m");
1683 /* xgettext:no-c-format */
1684 static const char *many_format
= N_("%o %d %f%m");
1686 static const char *prompt_parts
[] = {
1691 N_("files/directories"),
1692 N_(" with source mask:"),
1696 static const char *question_format
= N_("%s?");
1699 * Generate user prompt for panel operation.
1700 * single_source is the name if the source entry or NULL for multiple
1702 * src_stat is only used when single_source is not NULL.
1705 panel_operate_generate_prompt (const WPanel
*panel
, const int operation
,
1706 gboolean single_source
,
1707 const struct stat
*src_stat
)
1709 const char *sp
, *cp
;
1710 char format_string
[BUF_MEDIUM
];
1711 char *dp
= format_string
;
1712 gboolean build_question
= FALSE
;
1715 static gboolean i18n_flag
= FALSE
;
1719 for (i
= sizeof (op_names1
) / sizeof (op_names1
[0]); i
--;)
1720 op_names1
[i
] = Q_(op_names1
[i
]);
1722 for (i
= sizeof (prompt_parts
) / sizeof (prompt_parts
[0]); i
--;)
1723 prompt_parts
[i
] = _(prompt_parts
[i
]);
1725 one_format
= _(one_format
);
1726 many_format
= _(many_format
);
1727 question_format
= _(question_format
);
1730 #endif /* ENABLE_NLS */
1732 sp
= single_source
? one_format
: many_format
;
1734 while (*sp
!= '\0') {
1740 cp
= op_names1
[operation
];
1743 if (operation
== OP_DELETE
) {
1745 build_question
= TRUE
;
1747 cp
= prompt_parts
[5];
1750 if (operation
== OP_DELETE
) {
1752 build_question
= TRUE
;
1754 cp
= prompt_parts
[6];
1757 if (single_source
) {
1758 cp
= S_ISDIR (src_stat
->
1759 st_mode
) ? prompt_parts
[2] : prompt_parts
[0];
1761 cp
= (panel
->marked
== panel
->dirs_marked
)
1763 : (panel
->dirs_marked
? prompt_parts
[4] : prompt_parts
[1]);
1781 if (build_question
) {
1782 char tmp
[BUF_MEDIUM
];
1784 memmove (tmp
, format_string
, sizeof (tmp
));
1785 g_snprintf (format_string
, sizeof (format_string
),
1786 question_format
, tmp
);
1789 return g_strdup (format_string
);
1792 #ifdef WITH_BACKGROUND
1794 end_bg_process (FileOpContext
*ctx
, enum OperationMode mode
) {
1800 unregister_task_with_pid(pid
);
1801 // file_op_context_destroy(ctx);
1809 * Performs one of the operations on the selection on the source_panel
1810 * (copy, delete, move).
1812 * Returns 1 if did change the directory
1813 * structure, Returns 0 if user aborted
1815 * force_single forces operation on the current entry and affects
1816 * default destination. Current filename is used as default.
1819 panel_operate (void *source_panel
, FileOperation operation
, int force_single
)
1821 WPanel
*panel
= (WPanel
*) source_panel
;
1822 const gboolean single_entry
= force_single
|| (panel
->marked
<= 1)
1823 || (get_current_type () == view_tree
);
1825 char *source
= NULL
;
1826 #ifdef WITH_FULL_PATHS
1827 char *source_with_path
= NULL
;
1829 # define source_with_path source
1830 #endif /* !WITH_FULL_PATHS */
1833 char *save_cwd
= NULL
, *save_dest
= NULL
;
1834 struct stat src_stat
, dst_stat
;
1836 FileProgressStatus value
;
1843 int do_bg
= 0; /* do background operation? */
1846 static gboolean i18n_flag
= FALSE
;
1848 for (i
= sizeof (op_names1
) / sizeof (op_names1
[0]); i
--;)
1849 op_names
[i
] = Q_(op_names
[i
]);
1852 #endif /* ENABLE_NLS */
1854 free_linklist (&linklist
);
1855 free_linklist (&dest_dirs
);
1857 /* Update panel contents to avoid actions on deleted files */
1858 if (!panel
->is_panelized
) {
1859 update_panels (UP_RELOAD
, UP_KEEPSEL
);
1865 source
= selection (panel
)->fname
;
1866 src_stat
= selection (panel
)->st
;
1868 source
= panel_get_file (panel
, &src_stat
);
1871 if (!strcmp (source
, "..")) {
1872 message (D_ERROR
, MSG_ERROR
, _(" Cannot operate on \"..\"! "));
1877 ctx
= file_op_context_new (operation
);
1879 /* Show confirmation dialog */
1880 if (operation
!= OP_DELETE
) {
1885 /* Forced single operations default to the original name */
1888 else if (get_other_type () == view_listing
)
1889 dest_dir
= other_panel
->cwd
;
1891 dest_dir
= panel
->cwd
;
1893 * Add trailing backslash only when do non-local ops.
1894 * It saves user from occasional file renames (when destination
1898 && dest_dir
[0] != '\0'
1899 && dest_dir
[strlen (dest_dir
) - 1] != PATH_SEP
) {
1900 /* add trailing separator */
1901 dest_dir_
= g_strconcat (dest_dir
, PATH_SEP_STR
, (char *) NULL
);
1904 dest_dir_
= g_strdup (dest_dir
);
1906 if (dest_dir_
== NULL
) {
1907 file_op_context_destroy (ctx
);
1911 /* Generate confirmation prompt */
1912 format
= panel_operate_generate_prompt (panel
, operation
,
1913 source
!= NULL
, &src_stat
);
1915 dest
= file_mask_dialog (ctx
, operation
, source
!= NULL
, format
,
1916 source
!= NULL
? (void *) source
1917 : (void *) &panel
->marked
,
1923 if (dest
== NULL
|| dest
[0] == '\0') {
1924 file_op_context_destroy (ctx
);
1928 } else if (confirm_delete
) {
1930 char fmd_buf
[BUF_MEDIUM
];
1932 /* Generate confirmation prompt */
1933 format
= panel_operate_generate_prompt (panel
, OP_DELETE
,
1934 source
!= NULL
, &src_stat
);
1937 g_snprintf (fmd_buf
, sizeof (fmd_buf
), format
, panel
->marked
);
1939 const int fmd_xlen
= 64;
1940 i
= fmd_xlen
- str_term_width1 (format
) - 4;
1941 g_snprintf (fmd_buf
, sizeof (fmd_buf
),
1942 format
, str_trunc (source
, i
));
1950 i
= query_dialog (op_names
[operation
], fmd_buf
, D_ERROR
, 2,
1951 _("&Yes"), _("&No"));
1954 file_op_context_destroy (ctx
);
1959 /* Background also need ctx->ui, but not full */
1961 file_op_context_create_ui_without_init (ctx
, 1);
1963 file_op_context_create_ui (ctx
, 1);
1965 #ifdef WITH_BACKGROUND
1966 /* Did the user select to do a background operation? */
1970 v
= do_background (ctx
,
1971 g_strconcat (op_names
[operation
], ": ",
1972 panel
->cwd
, (char *) NULL
));
1974 message (D_ERROR
, MSG_ERROR
,
1975 _(" Sorry, I could not put the job in background "));
1978 /* If we are the parent */
1980 mc_setctl (panel
->cwd
, VFS_SETCTL_FORGET
, NULL
);
1981 mc_setctl (dest
, VFS_SETCTL_FORGET
, NULL
);
1982 /* file_op_context_destroy (ctx); */
1986 #endif /* WITH_BACKGROUND */
1988 /* Initialize things */
1989 /* We do not want to trash cache every time file is
1990 created/touched. However, this will make our cache contain
1993 if (mc_setctl (dest
, VFS_SETCTL_STALE_DATA
, (void *) 1))
1994 save_dest
= g_strdup (dest
);
1997 if (mc_setctl (panel
->cwd
, VFS_SETCTL_STALE_DATA
, (void *) 1))
1998 save_cwd
= g_strdup (panel
->cwd
);
2001 /* Now, let's do the job */
2003 /* This code is only called by the tree and panel code */
2005 /* We now have ETA in all cases */
2007 /* One file: FIXME mc_chdir will take user out of any vfs */
2008 if (operation
!= OP_COPY
&& get_current_type () == view_tree
)
2009 mc_chdir (PATH_SEP_STR
);
2011 /* The source and src_stat variables have been initialized before */
2012 #ifdef WITH_FULL_PATHS
2013 source_with_path
= concat_dir_and_file (panel
->cwd
, source
);
2014 #endif /* WITH_FULL_PATHS */
2016 if (operation
== OP_DELETE
) {
2017 if (S_ISDIR (src_stat
.st_mode
))
2018 value
= erase_dir (ctx
, source_with_path
, &count
, &bytes
);
2021 erase_file (ctx
, source_with_path
, &count
, &bytes
, 1);
2023 temp
= transform_source (ctx
, source_with_path
);
2025 value
= transform_error
;
2027 char *repl_dest
= mc_search_prepare_replace_str2 (ctx
->search_handle
, dest
);
2028 char *temp2
= concat_dir_and_file (repl_dest
, temp
);
2034 switch (operation
) {
2037 * we use file_mask_op_follow_links only with OP_COPY,
2039 (*ctx
->stat_func
) (source_with_path
, &src_stat
);
2041 if (S_ISDIR (src_stat
.st_mode
)) {
2043 copy_dir_dir (ctx
, source_with_path
, dest
, 1,
2044 0, 0, 0, &count
, &bytes
);
2047 copy_file_file (ctx
, source_with_path
, dest
, 1,
2053 if (S_ISDIR (src_stat
.st_mode
))
2055 move_dir_dir (ctx
, source_with_path
, dest
,
2059 move_file_file (ctx
, source_with_path
, dest
,
2064 /* Unknown file operation */
2068 } /* Copy or move operation */
2070 if ((value
== FILE_CONT
) && !force_single
)
2071 unmark_files (panel
);
2074 /* Check destination for copy or move operation */
2075 if (operation
!= OP_DELETE
) {
2076 retry_many_dst_stat
:
2077 dst_result
= mc_stat (dest
, &dst_stat
);
2078 if (dst_result
== 0 && !S_ISDIR (dst_stat
.st_mode
)) {
2080 (_(" Destination \"%s\" must be a directory \n %s "),
2081 dest
) == FILE_RETRY
)
2082 goto retry_many_dst_stat
;
2087 /* Initialize variables for progress bars */
2088 if (operation
!= OP_MOVE
&& verbose
&& file_op_compute_totals
) {
2089 ComputeDirSizeUI
*ui
;
2090 FileProgressStatus status
;
2092 ui
= compute_dir_size_create_ui ();
2093 status
= panel_compute_totals (panel
,
2094 ui
, compute_dir_size_update_ui
,
2095 &ctx
->progress_count
, &ctx
->progress_bytes
);
2096 compute_dir_size_destroy_ui (ui
);
2098 if (status
!= FILE_CONT
)
2101 ctx
->progress_totals_computed
= 1;
2103 ctx
->progress_totals_computed
= 0;
2104 ctx
->progress_count
= panel
->marked
;
2105 ctx
->progress_bytes
= panel
->total
;
2108 /* Loop for every file, perform the actual copy operation */
2109 for (i
= 0; i
< panel
->count
; i
++) {
2110 if (!panel
->dir
.list
[i
].f
.marked
)
2111 continue; /* Skip the unmarked ones */
2113 source
= panel
->dir
.list
[i
].fname
;
2114 src_stat
= panel
->dir
.list
[i
].st
;
2116 #ifdef WITH_FULL_PATHS
2117 g_free (source_with_path
);
2118 source_with_path
= concat_dir_and_file (panel
->cwd
, source
);
2119 #endif /* WITH_FULL_PATHS */
2121 if (operation
== OP_DELETE
) {
2122 if (S_ISDIR (src_stat
.st_mode
))
2124 erase_dir (ctx
, source_with_path
, &count
, &bytes
);
2127 erase_file (ctx
, source_with_path
, &count
, &bytes
,
2130 temp
= transform_source (ctx
, source_with_path
);
2132 value
= transform_error
;
2135 char *repl_dest
= mc_search_prepare_replace_str2 (ctx
->search_handle
, dest
);
2136 char *temp2
= concat_dir_and_file (repl_dest
, temp
);
2140 temp3
= source_with_path
;
2141 source_with_path
= strutils_shell_unescape(source_with_path
);
2144 temp2
= strutils_shell_unescape(temp2
);
2147 switch (operation
) {
2150 * we use file_mask_op_follow_links only with OP_COPY
2152 (*ctx
->stat_func
) (source_with_path
, &src_stat
);
2153 if (S_ISDIR (src_stat
.st_mode
))
2155 copy_dir_dir (ctx
, source_with_path
, temp2
,
2156 1, 0, 0, 0, &count
, &bytes
);
2159 copy_file_file (ctx
, source_with_path
,
2160 temp2
, 1, &count
, &bytes
,
2162 free_linklist (&dest_dirs
);
2166 if (S_ISDIR (src_stat
.st_mode
))
2168 move_dir_dir (ctx
, source_with_path
, temp2
,
2172 move_file_file (ctx
, source_with_path
,
2173 temp2
, &count
, &bytes
);
2177 /* Unknown file operation */
2182 } /* Copy or move operation */
2184 if (value
== FILE_ABORT
)
2187 if (value
== FILE_CONT
)
2188 do_file_mark (panel
, i
, 0);
2190 if (file_progress_show_count (ctx
, count
, ctx
->progress_count
)
2195 && file_progress_show_bytes (ctx
, bytes
,
2196 ctx
->progress_bytes
) ==
2200 if (operation
!= OP_DELETE
&& verbose
2201 && file_progress_show (ctx
, 0, 0) == FILE_ABORT
)
2205 } /* Loop for every file */
2206 } /* Many entries */
2211 mc_setctl (save_cwd
, VFS_SETCTL_STALE_DATA
, NULL
);
2215 mc_setctl (save_dest
, VFS_SETCTL_STALE_DATA
, NULL
);
2219 free_linklist (&linklist
);
2220 free_linklist (&dest_dirs
);
2221 #ifdef WITH_FULL_PATHS
2222 g_free (source_with_path
);
2223 #endif /* WITH_FULL_PATHS */
2225 g_free (ctx
->dest_mask
);
2226 ctx
->dest_mask
= NULL
;
2227 #ifdef WITH_BACKGROUND
2228 /* Let our parent know we are saying bye bye */
2229 if (we_are_background
) {
2230 int cur_pid
= getpid();
2231 /* Send pid to parent with child context, it is fork and
2232 don't modify real parent ctx */
2234 parent_call ((void *) end_bg_process
, ctx
, 0);
2239 #endif /* WITH_BACKGROUND */
2241 file_op_context_destroy (ctx
);
2247 /* {{{ Query/status report routines */
2249 static FileProgressStatus
2250 real_do_file_error (enum OperationMode mode
, const char *error
)
2255 msg
= mode
== Foreground
? MSG_ERROR
: _(" Background process error ");
2257 query_dialog (msg
, error
, D_ERROR
, 3, _("&Skip"), _("&Retry"),
2275 /* Report error with one file */
2277 file_error (const char *format
, const char *file
)
2279 char buf
[BUF_MEDIUM
];
2281 g_snprintf (buf
, sizeof (buf
), format
,
2282 path_trunc (file
, 30), unix_error_string (errno
));
2284 return do_file_error (buf
);
2287 /* Report error with two files */
2288 static FileProgressStatus
2289 files_error (const char *format
, const char *file1
, const char *file2
)
2291 char buf
[BUF_MEDIUM
];
2292 char *nfile1
= g_strdup (path_trunc (file1
, 15));
2293 char *nfile2
= g_strdup (path_trunc (file2
, 15));
2295 g_snprintf (buf
, sizeof (buf
), format
, nfile1
, nfile2
,
2296 unix_error_string (errno
));
2301 return do_file_error (buf
);
2304 static FileProgressStatus
2305 real_query_recursive (FileOpContext
*ctx
, enum OperationMode mode
, const char *s
)
2309 if (ctx
->recursive_result
< RECURSIVE_ALWAYS
) {
2313 _("\n Directory not empty. \n"
2314 " Delete it recursively? ")
2315 : _("\n Background process: Directory not empty \n"
2316 " Delete it recursively? ");
2317 text
= g_strconcat (_(" Delete: "), path_trunc (s
, 30), " ", (char *) NULL
);
2321 ctx
->recursive_result
= query_dialog (text
, msg
, D_ERROR
, 5,
2322 _("&Yes"), _("&No"),
2323 _("A&ll"), _("Non&e"),
2326 if (ctx
->recursive_result
!= RECURSIVE_ABORT
)
2331 switch (ctx
->recursive_result
) {
2333 case RECURSIVE_ALWAYS
:
2337 case RECURSIVE_NEVER
:
2340 case RECURSIVE_ABORT
:
2347 #ifdef WITH_BACKGROUND
2348 static FileProgressStatus
2349 do_file_error (const char *str
)
2353 FileProgressStatus (*f
) (enum OperationMode
, const char *);
2355 pntr
.f
= real_do_file_error
;
2357 if (we_are_background
)
2358 return parent_call (pntr
.p
, NULL
, 1, strlen (str
),
2361 return real_do_file_error (Foreground
, str
);
2364 static FileProgressStatus
2365 query_recursive (FileOpContext
*ctx
, const char *s
)
2369 FileProgressStatus (*f
) (FileOpContext
*, enum OperationMode
, const char *);
2371 pntr
.f
= real_query_recursive
;
2373 if (we_are_background
)
2374 return parent_call (pntr
.p
, ctx
, 1, strlen (s
), s
);
2376 return real_query_recursive (ctx
, Foreground
, s
);
2379 static FileProgressStatus
2380 query_replace (FileOpContext
*ctx
, const char *destname
, struct stat
*_s_stat
,
2381 struct stat
*_d_stat
)
2385 FileProgressStatus (*f
) (FileOpContext
*, enum OperationMode
, const char *,
2386 struct stat
*, struct stat
*);
2388 pntr
.f
= file_progress_real_query_replace
;
2390 if (we_are_background
)
2391 return parent_call (pntr
.p
,
2394 strlen (destname
), destname
,
2395 sizeof (struct stat
), _s_stat
,
2396 sizeof (struct stat
), _d_stat
);
2398 return file_progress_real_query_replace (ctx
, Foreground
, destname
,
2403 static FileProgressStatus
2404 do_file_error (const char *str
)
2406 return real_do_file_error (Foreground
, str
);
2409 static FileProgressStatus
2410 query_recursive (FileOpContext
*ctx
, const char *s
)
2412 return real_query_recursive (ctx
, Foreground
, s
);
2415 static FileProgressStatus
2416 query_replace (FileOpContext
*ctx
, const char *destname
, struct stat
*_s_stat
,
2417 struct stat
*_d_stat
)
2419 return file_progress_real_query_replace (ctx
, Foreground
, destname
,
2423 #endif /* !WITH_BACKGROUND */
2426 Cause emacs to enter folding mode for this file: