src/filemanager/file.c

   1 /*
   2    File management.
   3
   4    Copyright (C) 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003,
   5    2004, 2005, 2006, 2007, 2011
   6    The Free Software Foundation, Inc.
   7
   8    Written by:
   9    Janne Kukonlehto, 1994, 1995
  10    Fred Leeflang, 1994, 1995
  11    Miguel de Icaza, 1994, 1995, 1996
  12    Jakub Jelinek, 1995, 1996
  13    Norbert Warmuth, 1997
  14    Pavel Machek, 1998
  15
  16    The copy code was based in GNU's cp, and was written by:
  17    Torbjorn Granlund, David MacKenzie, and Jim Meyering.
  18
  19    The move code was based in GNU's mv, and was written by:
  20    Mike Parker and David MacKenzie.
  21
  22    Janne Kukonlehto added much error recovery to them for being used
  23    in an interactive program.
  24
  25    This file is part of the Midnight Commander.
  26
  27    The Midnight Commander is free software: you can redistribute it
  28    and/or modify it under the terms of the GNU General Public License as
  29    published by the Free Software Foundation, either version 3 of the License,
  30    or (at your option) any later version.
  31
  32    The Midnight Commander is distributed in the hope that it will be useful,
  33    but WITHOUT ANY WARRANTY; without even the implied warranty of
  34    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  35    GNU General Public License for more details.
  36
  37    You should have received a copy of the GNU General Public License
  38    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  39  */
  40
  41 /*
  42  * Please note that all dialogs used here must be safe for background
  43  * operations.
  44  */
  45
  46 /** \file src/filemanager/file.c
  47  *  \brief Source: file management
  48  */
  49
  50 /* {{{ Include files */
  51
  52 #include <config.h>
  53
  54 #include <ctype.h>
  55 #include <errno.h>
  56 #include <stdlib.h>
  57 #include <stdio.h>
  58 #include <string.h>
  59 #include <sys/types.h>
  60 #include <sys/stat.h>
  61 #include <unistd.h>
  62 #include <fcntl.h>
  63
  64 #include "lib/global.h"
  65 #include "lib/tty/tty.h"
  66 #include "lib/tty/key.h"
  67 #include "lib/search.h"
  68 #include "lib/strescape.h"
  69 #include "lib/strutil.h"
  70 #include "lib/util.h"
  71 #include "lib/vfs/vfs.h"
  72 #include "lib/widget.h"
  73
  74 #include "src/setup.h"
  75 #ifdef ENABLE_BACKGROUND
  76 #include "src/background.h"     /* do_background() */
  77 #endif
  78
  79 #include "layout.h"             /* rotate_dash() */
  80
  81 /* Needed for current_panel, other_panel and WTree */
  82 #include "dir.h"
  83 #include "filegui.h"
  84 #include "filenot.h"
  85 #include "tree.h"
  86 #include "midnight.h"           /* current_panel */
  87
  88 #include "file.h"
  89
  90 /* }}} */
  91
  92 /*** global variables ****************************************************************************/
  93
  94 /* TRANSLATORS: no need to translate 'DialogTitle', it's just a context prefix  */
  95 const char *op_names[3] = {
  96     N_("DialogTitle|Copy"),
  97     N_("DialogTitle|Move"),
  98     N_("DialogTitle|Delete")
  99 };
 100
 101 /*** file scope macro definitions ****************************************************************/
 102
 103 /* Hack: the vfs code should not rely on this */
 104 #define WITH_FULL_PATHS 1
 105
 106 #define FILEOP_UPDATE_INTERVAL 2
 107 #define FILEOP_STALLING_INTERVAL 4
 108
 109 /*** file scope type declarations ****************************************************************/
 110
 111 /* This is a hard link cache */
 112 struct link
 113 {
 114     const struct vfs_class *vfs;
 115     dev_t dev;
 116     ino_t ino;
 117     short linkcount;
 118     mode_t st_mode;
 119     vfs_path_t *src_vpath;
 120     vfs_path_t *dst_vpath;
 121 };
 122
 123 /* Status of the destination file */
 124 typedef enum
 125 {
 126     DEST_NONE = 0,              /* Not created */
 127     DEST_SHORT = 1,             /* Created, not fully copied */
 128     DEST_FULL = 2               /* Created, fully copied */
 129 } dest_status_t;
 130
 131 /*
 132  * This array introduced to avoid translation problems. The former (op_names)
 133  * is assumed to be nouns, suitable in dialog box titles; this one should
 134  * contain whatever is used in prompt itself (i.e. in russian, it's verb).
 135  * (I don't use spaces around the words, because someday they could be
 136  * dropped, when widgets get smarter)
 137  */
 138
 139 /* TRANSLATORS: no need to translate 'FileOperation', it's just a context prefix  */
 140 static const char *op_names1[] = {
 141     N_("FileOperation|Copy"),
 142     N_("FileOperation|Move"),
 143     N_("FileOperation|Delete")
 144 };
 145
 146 /*
 147  * These are formats for building a prompt. Parts encoded as follows:
 148  * %o - operation from op_names1
 149  * %f - file/files or files/directories, as appropriate
 150  * %m - "with source mask" or question mark for delete
 151  * %s - source name (truncated)
 152  * %d - number of marked files
 153  * %e - "to:" or question mark for delete
 154  *
 155  * xgettext:no-c-format */
 156 static const char *one_format = N_("%o %f \"%s\"%m");
 157 /* xgettext:no-c-format */
 158 static const char *many_format = N_("%o %d %f%m");
 159
 160 static const char *prompt_parts[] = {
 161     N_("file"),
 162     N_("files"),
 163     N_("directory"),
 164     N_("directories"),
 165     N_("files/directories"),
 166     /* TRANSLATORS: keep leading space here to split words in Copy/Move dialog */
 167     N_(" with source mask:"),
 168     N_("to:")
 169 };
 170
 171 static const char *question_format = N_("%s?");
 172
 173 /*** file scope variables ************************************************************************/
 174
 175 /* the hard link cache */
 176 static GSList *linklist = NULL;
 177
 178 /* the files-to-be-erased list */
 179 static GSList *erase_list = NULL;
 180
 181 /*
 182  * In copy_dir_dir we use two additional single linked lists: The first -
 183  * variable name `parent_dirs' - holds information about already copied
 184  * directories and is used to detect cyclic symbolic links.
 185  * The second (`dest_dirs' below) holds information about just created
 186  * target directories and is used to detect when an directory is copied
 187  * into itself (we don't want to copy infinitly).
 188  * Both lists don't use the linkcount and name structure members of struct
 189  * link.
 190  */
 191 static GSList *dest_dirs = NULL;
 192
 193 static FileProgressStatus transform_error = FILE_CONT;
 194
 195 /*** file scope functions ************************************************************************/
 196 /* --------------------------------------------------------------------------------------------- */
 197
 198 static char *
 199 transform_source (FileOpContext * ctx, const char *source)
 200 {
 201     char *s, *q;
 202     char *fnsource;
 203
 204     s = g_strdup (source);
 205
 206     /* We remove \n from the filename since regex routines would use \n as an anchor */
 207     /* this is just to be allowed to maniupulate file names with \n on it */
 208     for (q = s; *q != '\0'; q++)
 209         if (*q == '\n')
 210             *q = ' ';
 211
 212     fnsource = (char *) x_basename (s);
 213
 214     if (mc_search_run (ctx->search_handle, fnsource, 0, strlen (fnsource), NULL))
 215         q = mc_search_prepare_replace_str2 (ctx->search_handle, ctx->dest_mask);
 216     else
 217     {
 218         q = NULL;
 219         transform_error = FILE_SKIP;
 220     }
 221
 222     g_free (s);
 223     return q;
 224 }
 225
 226 /* --------------------------------------------------------------------------------------------- */
 227
 228 static void
 229 free_link (void *data)
 230 {
 231     struct link *lp = (struct link *) data;
 232
 233     vfs_path_free (lp->src_vpath);
 234     vfs_path_free (lp->dst_vpath);
 235     g_free (lp);
 236 }
 237
 238 /* --------------------------------------------------------------------------------------------- */
 239
 240 static void *
 241 free_linklist (GSList * lp)
 242 {
 243     g_slist_foreach (lp, (GFunc) free_link, NULL);
 244     g_slist_free (lp);
 245
 246     return NULL;
 247 }
 248
 249 /* --------------------------------------------------------------------------------------------- */
 250
 251 static gboolean
 252 is_in_linklist (const GSList * lp, const vfs_path_t * vpath, const struct stat *sb)
 253 {
 254     const struct vfs_class *class;
 255     ino_t ino = sb->st_ino;
 256     dev_t dev = sb->st_dev;
 257
 258     class = vfs_path_get_last_path_vfs (vpath);
 259
 260     for (; lp != NULL; lp = g_slist_next (lp))
 261     {
 262         const struct link *lnk = (const struct link *) lp->data;
 263
 264         if (lnk->vfs == class && lnk->ino == ino && lnk->dev == dev)
 265             return TRUE;
 266     }
 267     return FALSE;
 268 }
 269
 270 /* --------------------------------------------------------------------------------------------- */
 271 /**
 272  * Check and made hardlink
 273  *
 274  * @return FALSE if the inode wasn't found in the cache and TRUE if it was found
 275  * and a hardlink was succesfully made
 276  */
 277
 278 static gboolean
 279 check_hardlinks (const vfs_path_t * src_vpath, const vfs_path_t * dst_vpath, struct stat *pstat)
 280 {
 281     GSList *lp;
 282     struct link *lnk;
 283
 284     const struct vfs_class *my_vfs;
 285     ino_t ino = pstat->st_ino;
 286     dev_t dev = pstat->st_dev;
 287     struct stat link_stat;
 288
 289     if ((vfs_file_class_flags (src_vpath) & VFSF_NOLINKS) != 0)
 290         return FALSE;
 291
 292     my_vfs = vfs_path_get_by_index (src_vpath, -1)->class;
 293
 294     for (lp = linklist; lp != NULL; lp = g_slist_next (lp))
 295     {
 296         lnk = (struct link *) lp->data;
 297
 298         if (lnk->vfs == my_vfs && lnk->ino == ino && lnk->dev == dev)
 299         {
 300             const struct vfs_class *lp_name_class;
 301             int stat_result;
 302
 303             lp_name_class = vfs_path_get_last_path_vfs (lnk->src_vpath);
 304             stat_result = mc_stat (lnk->src_vpath, &link_stat);
 305
 306             if (stat_result == 0 && link_stat.st_ino == ino
 307                 && link_stat.st_dev == dev && lp_name_class == my_vfs)
 308             {
 309                 const struct vfs_class *p_class, *dst_name_class;
 310
 311                 dst_name_class = vfs_path_get_last_path_vfs (dst_vpath);
 312                 p_class = vfs_path_get_last_path_vfs (lnk->dst_vpath);
 313
 314                 if (dst_name_class == p_class &&
 315                     mc_stat (lnk->dst_vpath, &link_stat) == 0 &&
 316                     mc_link (lnk->dst_vpath, dst_vpath) == 0)
 317                     return TRUE;
 318             }
 319
 320             message (D_ERROR, MSG_ERROR, _("Cannot make the hardlink"));
 321             return FALSE;
 322         }
 323     }
 324
 325     lnk = g_new0 (struct link, 1);
 326     if (lnk != NULL)
 327     {
 328         lnk->vfs = my_vfs;
 329         lnk->ino = ino;
 330         lnk->dev = dev;
 331         lnk->src_vpath = vfs_path_clone (src_vpath);
 332         lnk->dst_vpath = vfs_path_clone (dst_vpath);
 333         linklist = g_slist_prepend (linklist, lnk);
 334     }
 335
 336     return FALSE;
 337 }
 338
 339 /* --------------------------------------------------------------------------------------------- */
 340 /**
 341  * Duplicate the contents of the symbolic link src_path in dst_path.
 342  * Try to make a stable symlink if the option "stable symlink" was
 343  * set in the file mask dialog.
 344  * If dst_path is an existing symlink it will be deleted silently
 345  * (upper levels take already care of existing files at dst_path).
 346  */
 347
 348 static FileProgressStatus
 349 make_symlink (FileOpContext * ctx, const char *src_path, const char *dst_path)
 350 {
 351     char link_target[MC_MAXPATHLEN];
 352     int len;
 353     FileProgressStatus return_status;
 354     struct stat sb;
 355     vfs_path_t *src_vpath;
 356     vfs_path_t *dst_vpath;
 357     gboolean dst_is_symlink;
 358     vfs_path_t *link_target_vpath = NULL;
 359
 360     src_vpath = vfs_path_from_str (src_path);
 361     dst_vpath = vfs_path_from_str (dst_path);
 362     dst_is_symlink = (mc_lstat (dst_vpath, &sb) == 0) && S_ISLNK (sb.st_mode);
 363
 364   retry_src_readlink:
 365     len = mc_readlink (src_vpath, link_target, MC_MAXPATHLEN - 1);
 366     if (len < 0)
 367     {
 368         if (ctx->skip_all)
 369             return_status = FILE_SKIPALL;
 370         else
 371         {
 372             return_status = file_error (_("Cannot read source link \"%s\"\n%s"), src_path);
 373             if (return_status == FILE_SKIPALL)
 374                 ctx->skip_all = TRUE;
 375             if (return_status == FILE_RETRY)
 376                 goto retry_src_readlink;
 377         }
 378         goto ret;
 379     }
 380     link_target[len] = 0;
 381
 382     if (ctx->stable_symlinks)
 383     {
 384
 385         if (!vfs_file_is_local (src_vpath) || !vfs_file_is_local (dst_vpath))
 386         {
 387             message (D_ERROR, MSG_ERROR,
 388                      _("Cannot make stable symlinks across"
 389                        "non-local filesystems:\n\nOption Stable Symlinks will be disabled"));
 390             ctx->stable_symlinks = FALSE;
 391         }
 392     }
 393
 394     if (ctx->stable_symlinks && !g_path_is_absolute (link_target))
 395     {
 396         char *p, *s;
 397         vfs_path_t *q;
 398
 399         const char *r = strrchr (src_path, PATH_SEP);
 400
 401         if (r)
 402         {
 403             p = g_strndup (src_path, r - src_path + 1);
 404             if (g_path_is_absolute (dst_path))
 405                 q = vfs_path_from_str_flags (dst_path, VPF_NO_CANON);
 406             else
 407                 q = vfs_path_build_filename (p, dst_path, (char *) NULL);
 408
 409             if (vfs_path_tokens_count (q) > 1)
 410             {
 411                 vfs_path_t *tmp_vpath1, *tmp_vpath2;
 412
 413                 tmp_vpath1 = vfs_path_vtokens_get (q, -1, 1);
 414                 s = g_strconcat (p, link_target, (char *) NULL);
 415                 g_free (p);
 416                 g_strlcpy (link_target, s, sizeof (link_target));
 417                 g_free (s);
 418                 tmp_vpath2 = vfs_path_from_str (link_target);
 419                 s = diff_two_paths (tmp_vpath1, tmp_vpath2);
 420                 vfs_path_free (tmp_vpath1);
 421                 vfs_path_free (tmp_vpath2);
 422                 if (s)
 423                 {
 424                     g_strlcpy (link_target, s, sizeof (link_target));
 425                     g_free (s);
 426                 }
 427             }
 428             else
 429                 g_free (p);
 430             vfs_path_free (q);
 431         }
 432     }
 433     link_target_vpath = vfs_path_from_str_flags (link_target, VPF_NO_CANON);
 434
 435   retry_dst_symlink:
 436     if (mc_symlink (link_target_vpath, dst_vpath) == 0)
 437     {
 438         /* Success */
 439         return_status = FILE_CONT;
 440         goto ret;
 441     }
 442     /*
 443      * if dst_exists, it is obvious that this had failed.
 444      * We can delete the old symlink and try again...
 445      */
 446     if (dst_is_symlink)
 447     {
 448         if (mc_unlink (dst_vpath) == 0)
 449             if (mc_symlink (link_target_vpath, dst_vpath) == 0)
 450             {
 451                 /* Success */
 452                 return_status = FILE_CONT;
 453                 goto ret;
 454             }
 455     }
 456     if (ctx->skip_all)
 457         return_status = FILE_SKIPALL;
 458     else
 459     {
 460         return_status = file_error (_("Cannot create target symlink \"%s\"\n%s"), dst_path);
 461         if (return_status == FILE_SKIPALL)
 462             ctx->skip_all = TRUE;
 463         if (return_status == FILE_RETRY)
 464             goto retry_dst_symlink;
 465     }
 466
 467   ret:
 468     vfs_path_free (src_vpath);
 469     vfs_path_free (dst_vpath);
 470     vfs_path_free (link_target_vpath);
 471     return return_status;
 472 }
 473
 474 /* --------------------------------------------------------------------------------------------- */
 475
 476 static FileProgressStatus
 477 progress_update_one (FileOpTotalContext * tctx, FileOpContext * ctx, off_t add)
 478 {
 479     struct timeval tv_current;
 480     static struct timeval tv_start = { };
 481
 482     tctx->progress_count++;
 483     tctx->progress_bytes += (uintmax_t) add;
 484
 485     if (tv_start.tv_sec == 0)
 486     {
 487         gettimeofday (&tv_start, (struct timezone *) NULL);
 488     }
 489     gettimeofday (&tv_current, (struct timezone *) NULL);
 490     if ((tv_current.tv_sec - tv_start.tv_sec) > FILEOP_UPDATE_INTERVAL)
 491     {
 492         if (verbose && ctx->dialog_type == FILEGUI_DIALOG_MULTI_ITEM)
 493         {
 494             file_progress_show_count (ctx, tctx->progress_count, ctx->progress_count);
 495             file_progress_show_total (tctx, ctx, tctx->progress_bytes, TRUE);
 496         }
 497         tv_start.tv_sec = tv_current.tv_sec;
 498     }
 499
 500     return check_progress_buttons (ctx);
 501 }
 502
 503 /* --------------------------------------------------------------------------------------------- */
 504
 505 static FileProgressStatus
 506 real_warn_same_file (enum OperationMode mode, const char *fmt, const char *a, const char *b)
 507 {
 508     char *msg;
 509     int result = 0;
 510     const char *head_msg;
 511
 512     head_msg = mode == Foreground ? MSG_ERROR : _("Background process error");
 513
 514     msg = g_strdup_printf (fmt, a, b);
 515     result = query_dialog (head_msg, msg, D_ERROR, 2, _("&Skip"), _("&Abort"));
 516     g_free (msg);
 517     do_refresh ();
 518
 519     return (result == 1) ? FILE_ABORT : FILE_SKIP;
 520 }
 521
 522 /* --------------------------------------------------------------------------------------------- */
 523
 524 static FileProgressStatus
 525 warn_same_file (const char *fmt, const char *a, const char *b)
 526 {
 527 #ifdef ENABLE_BACKGROUND
 528 /* *INDENT-OFF* */
 529     union
 530     {
 531         void *p;
 532           FileProgressStatus (*f) (enum OperationMode, const char *fmt,
 533                                    const char *a, const char *b);
 534     } pntr;
 535 /* *INDENT-ON* */
 536
 537     pntr.f = real_warn_same_file;
 538
 539     if (mc_global.we_are_background)
 540         return parent_call (pntr.p, NULL, 3, strlen (fmt), fmt, strlen (a), a, strlen (b), b);
 541 #endif
 542     return real_warn_same_file (Foreground, fmt, a, b);
 543 }
 544
 545 /* --------------------------------------------------------------------------------------------- */
 546 /* {{{ Query/status report routines */
 547
 548 static FileProgressStatus
 549 real_do_file_error (enum OperationMode mode, const char *error)
 550 {
 551     int result;
 552     const char *msg;
 553
 554     msg = mode == Foreground ? MSG_ERROR : _("Background process error");
 555     result =
 556         query_dialog (msg, error, D_ERROR, 4, _("&Skip"), _("Ski&p all"), _("&Retry"), _("&Abort"));
 557
 558     switch (result)
 559     {
 560     case 0:
 561         do_refresh ();
 562         return FILE_SKIP;
 563
 564     case 1:
 565         do_refresh ();
 566         return FILE_SKIPALL;
 567
 568     case 2:
 569         do_refresh ();
 570         return FILE_RETRY;
 571
 572     case 3:
 573     default:
 574         return FILE_ABORT;
 575     }
 576 }
 577
 578 /* --------------------------------------------------------------------------------------------- */
 579
 580 static FileProgressStatus
 581 real_query_recursive (FileOpContext * ctx, enum OperationMode mode, const char *s)
 582 {
 583
 584     if (ctx->recursive_result < RECURSIVE_ALWAYS)
 585     {
 586
 587         const char *msg;
 588         char *text;
 589
 590         msg = mode == Foreground
 591             ? _("Directory \"%s\" not empty.\nDelete it recursively?")
 592             : _("Background process:\nDirectory \"%s\" not empty.\nDelete it recursively?");
 593         text = g_strdup_printf (msg, path_trunc (s, 30));
 594
 595         if (safe_delete)
 596             query_set_sel (1);
 597
 598         ctx->recursive_result =
 599             (FileCopyMode) query_dialog (op_names[OP_DELETE], text, D_ERROR, 5,
 600                                          _("&Yes"), _("&No"), _("A&ll"), _("Non&e"), _("&Abort"));
 601         g_free (text);
 602
 603         if (ctx->recursive_result != RECURSIVE_ABORT)
 604             do_refresh ();
 605     }
 606
 607     switch (ctx->recursive_result)
 608     {
 609     case RECURSIVE_YES:
 610     case RECURSIVE_ALWAYS:
 611         return FILE_CONT;
 612
 613     case RECURSIVE_NO:
 614     case RECURSIVE_NEVER:
 615         return FILE_SKIP;
 616
 617     case RECURSIVE_ABORT:
 618     default:
 619         return FILE_ABORT;
 620     }
 621 }
 622
 623 /* --------------------------------------------------------------------------------------------- */
 624
 625 #ifdef ENABLE_BACKGROUND
 626 static FileProgressStatus
 627 do_file_error (const char *str)
 628 {
 629     union
 630     {
 631         void *p;
 632           FileProgressStatus (*f) (enum OperationMode, const char *);
 633     } pntr;
 634     pntr.f = real_do_file_error;
 635
 636     if (mc_global.we_are_background)
 637         return parent_call (pntr.p, NULL, 1, strlen (str), str);
 638     else
 639         return real_do_file_error (Foreground, str);
 640 }
 641
 642 /* --------------------------------------------------------------------------------------------- */
 643
 644 static FileProgressStatus
 645 query_recursive (FileOpContext * ctx, const char *s)
 646 {
 647     union
 648     {
 649         void *p;
 650           FileProgressStatus (*f) (FileOpContext *, enum OperationMode, const char *);
 651     } pntr;
 652     pntr.f = real_query_recursive;
 653
 654     if (mc_global.we_are_background)
 655         return parent_call (pntr.p, ctx, 1, strlen (s), s);
 656     else
 657         return real_query_recursive (ctx, Foreground, s);
 658 }
 659
 660 /* --------------------------------------------------------------------------------------------- */
 661
 662 static FileProgressStatus
 663 query_replace (FileOpContext * ctx, const char *destname, struct stat *_s_stat,
 664                struct stat *_d_stat)
 665 {
 666     union
 667     {
 668         void *p;
 669           FileProgressStatus (*f) (FileOpContext *, enum OperationMode, const char *,
 670                                    struct stat *, struct stat *);
 671     } pntr;
 672     pntr.f = file_progress_real_query_replace;
 673
 674     if (mc_global.we_are_background)
 675         return parent_call (pntr.p, ctx, 3, strlen (destname), destname,
 676                             sizeof (struct stat), _s_stat, sizeof (struct stat), _d_stat);
 677     else
 678         return file_progress_real_query_replace (ctx, Foreground, destname, _s_stat, _d_stat);
 679 }
 680
 681 #else
 682 /* --------------------------------------------------------------------------------------------- */
 683
 684 static FileProgressStatus
 685 do_file_error (const char *str)
 686 {
 687     return real_do_file_error (Foreground, str);
 688 }
 689
 690 /* --------------------------------------------------------------------------------------------- */
 691
 692 static FileProgressStatus
 693 query_recursive (FileOpContext * ctx, const char *s)
 694 {
 695     return real_query_recursive (ctx, Foreground, s);
 696 }
 697
 698 /* --------------------------------------------------------------------------------------------- */
 699
 700 static FileProgressStatus
 701 query_replace (FileOpContext * ctx, const char *destname, struct stat *_s_stat,
 702                struct stat *_d_stat)
 703 {
 704     return file_progress_real_query_replace (ctx, Foreground, destname, _s_stat, _d_stat);
 705 }
 706
 707 #endif /* !ENABLE_BACKGROUND */
 708
 709 /* --------------------------------------------------------------------------------------------- */
 710 /** Report error with two files */
 711
 712 static FileProgressStatus
 713 files_error (const char *format, const char *file1, const char *file2)
 714 {
 715     char buf[BUF_MEDIUM];
 716     char *nfile1 = g_strdup (path_trunc (file1, 15));
 717     char *nfile2 = g_strdup (path_trunc (file2, 15));
 718
 719     g_snprintf (buf, sizeof (buf), format, nfile1, nfile2, unix_error_string (errno));
 720
 721     g_free (nfile1);
 722     g_free (nfile2);
 723
 724     return do_file_error (buf);
 725 }
 726
 727 /* }}} */
 728
 729 /* --------------------------------------------------------------------------------------------- */
 730
 731 static void
 732 copy_file_file_display_progress (FileOpTotalContext * tctx, FileOpContext * ctx,
 733                                  struct timeval tv_current, struct timeval tv_transfer_start,
 734                                  off_t file_size, off_t n_read_total)
 735 {
 736     long dt;
 737
 738     /* 1. Update rotating dash after some time */
 739     rotate_dash ();
 740
 741     /* 3. Compute ETA */
 742     dt = (tv_current.tv_sec - tv_transfer_start.tv_sec);
 743
 744     if (n_read_total == 0)
 745         ctx->eta_secs = 0.0;
 746     else
 747     {
 748         ctx->eta_secs = ((dt / (double) n_read_total) * file_size) - dt;
 749         ctx->bps = n_read_total / ((dt < 1) ? 1 : dt);
 750     }
 751
 752     /* 4. Compute BPS rate */
 753     ctx->bps_time = (tv_current.tv_sec - tv_transfer_start.tv_sec);
 754     if (ctx->bps_time < 1)
 755         ctx->bps_time = 1;
 756     ctx->bps = n_read_total / ctx->bps_time;
 757
 758     /* 5. Compute total ETA and BPS */
 759     if (ctx->progress_bytes != 0)
 760     {
 761         uintmax_t remain_bytes;
 762
 763         remain_bytes = ctx->progress_bytes - tctx->copied_bytes;
 764 #if 1
 765         {
 766             int total_secs = tv_current.tv_sec - tctx->transfer_start.tv_sec;
 767
 768             if (total_secs < 1)
 769                 total_secs = 1;
 770
 771             tctx->bps = tctx->copied_bytes / total_secs;
 772             tctx->eta_secs = (tctx->bps != 0) ? remain_bytes / tctx->bps : 0;
 773         }
 774 #else
 775         /* broken on lot of little files */
 776         tctx->bps_count++;
 777         tctx->bps = (tctx->bps * (tctx->bps_count - 1) + ctx->bps) / tctx->bps_count;
 778         tctx->eta_secs = (tctx->bps != 0) ? remain_bytes / tctx->bps : 0;
 779 #endif
 780     }
 781 }
 782
 783 /* --------------------------------------------------------------------------------------------- */
 784
 785 /* {{{ Move routines */
 786 static FileProgressStatus
 787 move_file_file (FileOpTotalContext * tctx, FileOpContext * ctx, const char *s, const char *d)
 788 {
 789     struct stat src_stats, dst_stats;
 790     FileProgressStatus return_status = FILE_CONT;
 791     gboolean copy_done = FALSE;
 792     gboolean old_ask_overwrite;
 793     vfs_path_t *src_vpath, *dst_vpath;
 794
 795     src_vpath = vfs_path_from_str (s);
 796     dst_vpath = vfs_path_from_str (d);
 797
 798     file_progress_show_source (ctx, src_vpath);
 799     file_progress_show_target (ctx, dst_vpath);
 800
 801     if (check_progress_buttons (ctx) == FILE_ABORT)
 802     {
 803         return_status = FILE_ABORT;
 804         goto ret;
 805     }
 806
 807     mc_refresh ();
 808
 809     while (mc_lstat (src_vpath, &src_stats) != 0)
 810     {
 811         /* Source doesn't exist */
 812         if (ctx->skip_all)
 813             return_status = FILE_SKIPALL;
 814         else
 815         {
 816             return_status = file_error (_("Cannot stat file \"%s\"\n%s"), s);
 817             if (return_status == FILE_SKIPALL)
 818                 ctx->skip_all = TRUE;
 819         }
 820
 821         if (return_status != FILE_RETRY)
 822             goto ret;
 823     }
 824
 825     if (mc_lstat (dst_vpath, &dst_stats) == 0)
 826     {
 827         if (src_stats.st_dev == dst_stats.st_dev && src_stats.st_ino == dst_stats.st_ino)
 828         {
 829             return_status = warn_same_file (_("\"%s\"\nand\n\"%s\"\nare the same file"), s, d);
 830             goto ret;
 831         }
 832
 833         if (S_ISDIR (dst_stats.st_mode))
 834         {
 835             message (D_ERROR, MSG_ERROR, _("Cannot overwrite directory \"%s\""), d);
 836             do_refresh ();
 837             return_status = FILE_SKIP;
 838             goto ret;
 839         }
 840
 841         if (confirm_overwrite)
 842         {
 843             return_status = query_replace (ctx, d, &src_stats, &dst_stats);
 844             if (return_status != FILE_CONT)
 845                 goto ret;
 846         }
 847         /* Ok to overwrite */
 848     }
 849
 850     if (!ctx->do_append)
 851     {
 852         if (S_ISLNK (src_stats.st_mode) && ctx->stable_symlinks)
 853         {
 854             return_status = make_symlink (ctx, s, d);
 855             if (return_status == FILE_CONT)
 856                 goto retry_src_remove;
 857             goto ret;
 858         }
 859
 860         if (mc_rename (src_vpath, dst_vpath) == 0)
 861         {
 862             return_status = progress_update_one (tctx, ctx, src_stats.st_size);
 863             goto ret;
 864         }
 865     }
 866 #if 0
 867     /* Comparison to EXDEV seems not to work in nfs if you're moving from
 868        one nfs to the same, but on the server it is on two different
 869        filesystems. Then nfs returns EIO instead of EXDEV.
 870        Hope it will not hurt if we always in case of error try to copy/delete. */
 871     else
 872         errno = EXDEV;          /* Hack to copy (append) the file and then delete it */
 873
 874     if (errno != EXDEV)
 875     {
 876         if (ctx->skip_all)
 877             return_status = FILE_SKIPALL;
 878         else
 879         {
 880             return_status = files_error (_("Cannot move file \"%s\" to \"%s\"\n%s"), s, d);
 881             if (return_status == FILE_SKIPALL)
 882                 ctx->skip_all = TRUE;
 883             if (return_status == FILE_RETRY)
 884                 goto retry_rename;
 885         }
 886
 887         goto ret;
 888     }
 889 #endif
 890
 891     /* Failed because filesystem boundary -> copy the file instead */
 892     old_ask_overwrite = tctx->ask_overwrite;
 893     tctx->ask_overwrite = FALSE;
 894     return_status = copy_file_file (tctx, ctx, s, d);
 895     tctx->ask_overwrite = old_ask_overwrite;
 896     if (return_status != FILE_CONT)
 897         goto ret;
 898
 899     copy_done = TRUE;
 900
 901     file_progress_show_source (ctx, NULL);
 902     file_progress_show (ctx, 0, 0, "", FALSE);
 903
 904     return_status = check_progress_buttons (ctx);
 905     if (return_status != FILE_CONT)
 906         goto ret;
 907     mc_refresh ();
 908
 909   retry_src_remove:
 910     if (mc_unlink (src_vpath) != 0 && !ctx->skip_all)
 911     {
 912         return_status = file_error (_("Cannot remove file \"%s\"\n%s"), s);
 913         if (return_status == FILE_RETRY)
 914             goto retry_src_remove;
 915         if (return_status == FILE_SKIPALL)
 916             ctx->skip_all = TRUE;
 917         goto ret;
 918     }
 919
 920     if (!copy_done)
 921         return_status = progress_update_one (tctx, ctx, src_stats.st_size);
 922
 923   ret:
 924     vfs_path_free (src_vpath);
 925     vfs_path_free (dst_vpath);
 926
 927     return return_status;
 928 }
 929
 930 /* }}} */
 931
 932 /* --------------------------------------------------------------------------------------------- */
 933 /* {{{ Erase routines */
 934 /** Don't update progress status if progress_count==NULL */
 935
 936 static FileProgressStatus
 937 erase_file (FileOpTotalContext * tctx, FileOpContext * ctx, const vfs_path_t * vpath)
 938 {
 939     int return_status;
 940     struct stat buf;
 941     char *s;
 942
 943     s = vfs_path_to_str (vpath);
 944     file_progress_show_deleting (ctx, s);
 945     if (check_progress_buttons (ctx) == FILE_ABORT)
 946     {
 947         g_free (s);
 948         return FILE_ABORT;
 949     }
 950     mc_refresh ();
 951
 952     if (tctx->progress_count != 0 && mc_lstat (vpath, &buf) != 0)
 953     {
 954         /* ignore, most likely the mc_unlink fails, too */
 955         buf.st_size = 0;
 956     }
 957
 958     while (mc_unlink (vpath) != 0 && !ctx->skip_all)
 959     {
 960         return_status = file_error (_("Cannot delete file \"%s\"\n%s"), s);
 961         if (return_status == FILE_ABORT)
 962         {
 963             g_free (s);
 964             return return_status;
 965         }
 966         if (return_status == FILE_RETRY)
 967             continue;
 968         if (return_status == FILE_SKIPALL)
 969             ctx->skip_all = TRUE;
 970         break;
 971     }
 972     g_free (s);
 973     if (tctx->progress_count == 0)
 974         return FILE_CONT;
 975     return progress_update_one (tctx, ctx, buf.st_size);
 976 }
 977
 978 /* --------------------------------------------------------------------------------------------- */
 979
 980 /**
 981   Recursive remove of files
 982   abort->cancel stack
 983   skip ->warn every level, gets default
 984   skipall->remove as much as possible
 985 */
 986 static FileProgressStatus
 987 recursive_erase (FileOpTotalContext * tctx, FileOpContext * ctx, const char *s)
 988 {
 989     struct dirent *next;
 990     struct stat buf;
 991     DIR *reading;
 992     char *path;
 993     FileProgressStatus return_status = FILE_CONT;
 994     vfs_path_t *vpath;
 995
 996     if (strcmp (s, "..") == 0)
 997         return FILE_RETRY;
 998
 999     vpath = vfs_path_from_str (s);
1000     reading = mc_opendir (vpath);
1001
1002     if (reading == NULL)
1003     {
1004         return_status = FILE_RETRY;
1005         goto ret;
1006     }
1007
1008     while ((next = mc_readdir (reading)) && return_status != FILE_ABORT)
1009     {
1010         vfs_path_t *tmp_vpath;
1011
1012         if (!strcmp (next->d_name, "."))
1013             continue;
1014         if (!strcmp (next->d_name, ".."))
1015             continue;
1016         path = mc_build_filename (s, next->d_name, NULL);
1017         tmp_vpath = vfs_path_from_str (path);
1018         if (mc_lstat (tmp_vpath, &buf) != 0)
1019         {
1020             g_free (path);
1021             mc_closedir (reading);
1022             vfs_path_free (tmp_vpath);
1023             return_status = FILE_RETRY;
1024             goto ret;
1025         }
1026         if (S_ISDIR (buf.st_mode))
1027             return_status = recursive_erase (tctx, ctx, path);
1028         else
1029             return_status = erase_file (tctx, ctx, tmp_vpath);
1030         vfs_path_free (tmp_vpath);
1031         g_free (path);
1032     }
1033     mc_closedir (reading);
1034     if (return_status == FILE_ABORT)
1035         goto ret;
1036
1037     file_progress_show_deleting (ctx, s);
1038     if (check_progress_buttons (ctx) == FILE_ABORT)
1039     {
1040         return_status = FILE_ABORT;
1041         goto ret;
1042     }
1043     mc_refresh ();
1044
1045     while (my_rmdir (s) != 0 && !ctx->skip_all)
1046     {
1047         return_status = file_error (_("Cannot remove directory \"%s\"\n%s"), s);
1048         if (return_status == FILE_RETRY)
1049             continue;
1050         if (return_status == FILE_ABORT)
1051             goto ret;
1052         if (return_status == FILE_SKIPALL)
1053             ctx->skip_all = TRUE;
1054         break;
1055     }
1056
1057   ret:
1058     vfs_path_free (vpath);
1059     return return_status;
1060 }
1061
1062 /* --------------------------------------------------------------------------------------------- */
1063 /** Return -1 on error, 1 if there are no entries besides "." and ".."
1064    in the directory path points to, 0 else. */
1065
1066 static int
1067 check_dir_is_empty (const vfs_path_t * vpath)
1068 {
1069     DIR *dir;
1070     struct dirent *d;
1071     int i;
1072
1073     dir = mc_opendir (vpath);
1074     if (!dir)
1075         return -1;
1076
1077     for (i = 1, d = mc_readdir (dir); d; d = mc_readdir (dir))
1078     {
1079         if (d->d_name[0] == '.' && (d->d_name[1] == '\0' ||
1080                                     (d->d_name[1] == '.' && d->d_name[2] == '\0')))
1081             continue;           /* "." or ".." */
1082         i = 0;
1083         break;
1084     }
1085
1086     mc_closedir (dir);
1087     return i;
1088 }
1089
1090 /* --------------------------------------------------------------------------------------------- */
1091
1092 static FileProgressStatus
1093 erase_dir_iff_empty (FileOpContext * ctx, const char *s)
1094 {
1095     FileProgressStatus error;
1096     vfs_path_t *s_vpath;
1097
1098     if (strcmp (s, "..") == 0)
1099         return FILE_SKIP;
1100
1101     if (strcmp (s, ".") == 0)
1102         return FILE_SKIP;
1103
1104     file_progress_show_deleting (ctx, s);
1105     if (check_progress_buttons (ctx) == FILE_ABORT)
1106         return FILE_ABORT;
1107
1108     mc_refresh ();
1109
1110     s_vpath = vfs_path_from_str (s);
1111
1112     if (check_dir_is_empty (s_vpath) == 1)      /* not empty or error */
1113     {
1114         while (my_rmdir (s) != 0 && !ctx->skip_all)
1115         {
1116             error = file_error (_("Cannot remove directory \"%s\"\n%s"), s);
1117             if (error == FILE_SKIPALL)
1118                 ctx->skip_all = TRUE;
1119             if (error != FILE_RETRY)
1120             {
1121                 vfs_path_free (s_vpath);
1122                 return error;
1123             }
1124         }
1125     }
1126
1127     vfs_path_free (s_vpath);
1128     return FILE_CONT;
1129 }
1130
1131 /* }}} */
1132
1133 /* --------------------------------------------------------------------------------------------- */
1134 /* {{{ Panel operate routines */
1135
1136 /**
1137  * Return currently selected entry name or the name of the first marked
1138  * entry if there is one.
1139  */
1140
1141 static char *
1142 panel_get_file (WPanel * panel)
1143 {
1144     if (get_current_type () == view_tree)
1145     {
1146         WTree *tree;
1147
1148         tree = (WTree *) get_panel_widget (get_current_index ());
1149         return vfs_path_to_str (tree_selected_name (tree));
1150     }
1151
1152     if (panel->marked != 0)
1153     {
1154         int i;
1155
1156         for (i = 0; i < panel->count; i++)
1157             if (panel->dir.list[i].f.marked)
1158                 return g_strdup (panel->dir.list[i].fname);
1159     }
1160     return g_strdup (panel->dir.list[panel->selected].fname);
1161 }
1162
1163 /* --------------------------------------------------------------------------------------------- */
1164 /**
1165  * panel_compute_totals:
1166  *
1167  * compute the number of files and the number of bytes
1168  * used up by the whole selection, recursing directories
1169  * as required.  In addition, it checks to see if it will
1170  * overwrite any files by doing the copy.
1171  */
1172
1173 static FileProgressStatus
1174 panel_compute_totals (const WPanel * panel, const void *ui,
1175                       compute_dir_size_callback cback,
1176                       size_t * ret_marked, uintmax_t * ret_total, gboolean compute_symlinks)
1177 {
1178     int i;
1179
1180     *ret_marked = 0;
1181     *ret_total = 0;
1182
1183     for (i = 0; i < panel->count; i++)
1184     {
1185         struct stat *s;
1186
1187         if (!panel->dir.list[i].f.marked)
1188             continue;
1189
1190         s = &panel->dir.list[i].st;
1191
1192         if (S_ISDIR (s->st_mode))
1193         {
1194             vfs_path_t *p;
1195             size_t subdir_count = 0;
1196             uintmax_t subdir_bytes = 0;
1197             FileProgressStatus status;
1198
1199             p = vfs_path_append_new (panel->cwd_vpath, panel->dir.list[i].fname, NULL);
1200             status =
1201                 compute_dir_size (p, ui, cback, &subdir_count, &subdir_bytes, compute_symlinks);
1202             vfs_path_free (p);
1203
1204             if (status != FILE_CONT)
1205                 return FILE_ABORT;
1206
1207             *ret_marked += subdir_count;
1208             *ret_total += subdir_bytes;
1209         }
1210         else
1211         {
1212             (*ret_marked)++;
1213             *ret_total += (uintmax_t) s->st_size;
1214         }
1215     }
1216
1217     return FILE_CONT;
1218 }
1219
1220 /* --------------------------------------------------------------------------------------------- */
1221
1222 /** Initialize variables for progress bars */
1223 static FileProgressStatus
1224 panel_operate_init_totals (FileOperation operation,
1225                            const WPanel * panel, const char *source, FileOpContext * ctx)
1226 {
1227     FileProgressStatus status;
1228
1229     if (operation != OP_MOVE && verbose && file_op_compute_totals)
1230     {
1231         ComputeDirSizeUI *ui;
1232
1233         ui = compute_dir_size_create_ui ();
1234
1235         if (source == NULL)
1236             status = panel_compute_totals (panel, ui, compute_dir_size_update_ui,
1237                                            &ctx->progress_count, &ctx->progress_bytes,
1238                                            ctx->follow_links);
1239         else
1240         {
1241             vfs_path_t *p;
1242
1243             p = vfs_path_from_str (source);
1244             status = compute_dir_size (p, ui, compute_dir_size_update_ui,
1245                                        &ctx->progress_count, &ctx->progress_bytes,
1246                                        ctx->follow_links);
1247             vfs_path_free (p);
1248         }
1249
1250         compute_dir_size_destroy_ui (ui);
1251
1252         ctx->progress_totals_computed = (status == FILE_CONT);
1253     }
1254     else
1255     {
1256         status = FILE_CONT;
1257         ctx->progress_count = panel->marked;
1258         ctx->progress_bytes = panel->total;
1259         ctx->progress_totals_computed = FALSE;
1260     }
1261
1262     return status;
1263 }
1264
1265 /* --------------------------------------------------------------------------------------------- */
1266 /**
1267  * Generate user prompt for panel operation.
1268  * single_source is the name if the source entry or NULL for multiple
1269  * entries.
1270  * src_stat is only used when single_source is not NULL.
1271  */
1272
1273 static char *
1274 panel_operate_generate_prompt (const WPanel * panel, FileOperation operation,
1275                                gboolean single_source, const struct stat *src_stat)
1276 {
1277     const char *sp, *cp;
1278     char format_string[BUF_MEDIUM];
1279     char *dp = format_string;
1280     gboolean build_question = FALSE;
1281
1282     static gboolean i18n_flag = FALSE;
1283     if (!i18n_flag)
1284     {
1285         size_t i;
1286
1287         for (i = sizeof (op_names1) / sizeof (op_names1[0]); i--;)
1288             op_names1[i] = Q_ (op_names1[i]);
1289
1290 #ifdef ENABLE_NLS
1291         for (i = sizeof (prompt_parts) / sizeof (prompt_parts[0]); i--;)
1292             prompt_parts[i] = _(prompt_parts[i]);
1293
1294         one_format = _(one_format);
1295         many_format = _(many_format);
1296         question_format = _(question_format);
1297 #endif /* ENABLE_NLS */
1298         i18n_flag = TRUE;
1299     }
1300
1301     sp = single_source ? one_format : many_format;
1302
1303     while (*sp != '\0')
1304     {
1305         switch (*sp)
1306         {
1307         case '%':
1308             cp = NULL;
1309             switch (sp[1])
1310             {
1311             case 'o':
1312                 cp = op_names1[operation];
1313                 break;
1314             case 'm':
1315                 if (operation == OP_DELETE)
1316                 {
1317                     cp = "";
1318                     build_question = TRUE;
1319                 }
1320                 else
1321                     cp = prompt_parts[5];
1322                 break;
1323             case 'e':
1324                 if (operation == OP_DELETE)
1325                 {
1326                     cp = "";
1327                     build_question = TRUE;
1328                 }
1329                 else
1330                     cp = prompt_parts[6];
1331                 break;
1332             case 'f':
1333                 if (single_source)
1334                     cp = S_ISDIR (src_stat->st_mode) ? prompt_parts[2] : prompt_parts[0];
1335                 else
1336                     cp = (panel->marked == panel->dirs_marked)
1337                         ? prompt_parts[3]
1338                         : (panel->dirs_marked ? prompt_parts[4] : prompt_parts[1]);
1339                 break;
1340             default:
1341                 *dp++ = *sp++;
1342             }
1343
1344             if (cp != NULL)
1345             {
1346                 sp += 2;
1347
1348                 while (*cp != '\0')
1349                     *dp++ = *cp++;
1350
1351                 /* form two-lines query prompt for file deletion */
1352                 if (operation == OP_DELETE && sp[-1] == 'f')
1353                 {
1354                     *dp++ = '\n';
1355
1356                     while (isblank (*sp) != 0)
1357                         sp++;
1358                 }
1359             }
1360             break;
1361         default:
1362             *dp++ = *sp++;
1363         }
1364     }
1365     *dp = '\0';
1366
1367     if (build_question)
1368     {
1369         char tmp[BUF_MEDIUM];
1370
1371         memmove (tmp, format_string, sizeof (tmp));
1372         g_snprintf (format_string, sizeof (format_string), question_format, tmp);
1373     }
1374
1375     return g_strdup (format_string);
1376 }
1377
1378 /* --------------------------------------------------------------------------------------------- */
1379
1380 #ifdef ENABLE_BACKGROUND
1381 static int
1382 end_bg_process (FileOpContext * ctx, enum OperationMode mode)
1383 {
1384     int pid = ctx->pid;
1385
1386     (void) mode;
1387     ctx->pid = 0;
1388
1389     unregister_task_with_pid (pid);
1390     /*     file_op_context_destroy(ctx); */
1391     return 1;
1392 }
1393 #endif
1394 /* }}} */
1395
1396 /* --------------------------------------------------------------------------------------------- */
1397 /*** public functions ****************************************************************************/
1398 /* --------------------------------------------------------------------------------------------- */
1399
1400 FileProgressStatus
1401 copy_file_file (FileOpTotalContext * tctx, FileOpContext * ctx,
1402                 const char *src_path, const char *dst_path)
1403 {
1404     uid_t src_uid = (uid_t) (-1);
1405     gid_t src_gid = (gid_t) (-1);
1406
1407     int src_desc, dest_desc = -1;
1408     int n_read, n_written;
1409     mode_t src_mode = 0;        /* The mode of the source file */
1410     struct stat sb, sb2;
1411     struct utimbuf utb;
1412     gboolean dst_exists = FALSE, appending = FALSE;
1413     off_t file_size = -1;
1414     FileProgressStatus return_status, temp_status;
1415     struct timeval tv_transfer_start;
1416     dest_status_t dst_status = DEST_NONE;
1417     int open_flags;
1418     gboolean is_first_time = TRUE;
1419     vfs_path_t *src_vpath = NULL, *dst_vpath = NULL;
1420     gboolean write_errno_nospace = FALSE;
1421
1422     /* FIXME: We should not be using global variables! */
1423     ctx->do_reget = 0;
1424     return_status = FILE_RETRY;
1425
1426     dst_vpath = vfs_path_from_str (dst_path);
1427     src_vpath = vfs_path_from_str (src_path);
1428
1429     file_progress_show_source (ctx, src_vpath);
1430     file_progress_show_target (ctx, dst_vpath);
1431
1432     if (check_progress_buttons (ctx) == FILE_ABORT)
1433     {
1434         return_status = FILE_ABORT;
1435         goto ret_fast;
1436     }
1437
1438     mc_refresh ();
1439
1440     while (mc_stat (dst_vpath, &sb2) == 0)
1441     {
1442         if (S_ISDIR (sb2.st_mode))
1443         {
1444             if (ctx->skip_all)
1445                 return_status = FILE_SKIPALL;
1446             else
1447             {
1448                 return_status = file_error (_("Cannot overwrite directory \"%s\"\n%s"), dst_path);
1449                 if (return_status == FILE_SKIPALL)
1450                     ctx->skip_all = TRUE;
1451                 if (return_status == FILE_RETRY)
1452                     continue;
1453             }
1454             goto ret_fast;
1455         }
1456
1457         dst_exists = TRUE;
1458         break;
1459     }
1460
1461     while ((*ctx->stat_func) (src_vpath, &sb) != 0)
1462     {
1463         if (ctx->skip_all)
1464             return_status = FILE_SKIPALL;
1465         else
1466         {
1467             return_status = file_error (_("Cannot stat source file \"%s\"\n%s"), src_path);
1468             if (return_status == FILE_SKIPALL)
1469                 ctx->skip_all = TRUE;
1470         }
1471
1472         if (return_status != FILE_RETRY)
1473             goto ret_fast;
1474     }
1475
1476     if (dst_exists)
1477     {
1478         /* Destination already exists */
1479         if (sb.st_dev == sb2.st_dev && sb.st_ino == sb2.st_ino)
1480         {
1481             return_status = warn_same_file (_("\"%s\"\nand\n\"%s\"\nare the same file"),
1482                                             src_path, dst_path);
1483             goto ret_fast;
1484         }
1485
1486         /* Should we replace destination? */
1487         if (tctx->ask_overwrite)
1488         {
1489             ctx->do_reget = 0;
1490             return_status = query_replace (ctx, dst_path, &sb, &sb2);
1491             if (return_status != FILE_CONT)
1492                 goto ret_fast;
1493         }
1494     }
1495
1496     if (!ctx->do_append)
1497     {
1498         /* Check the hardlinks */
1499         if (!ctx->follow_links && sb.st_nlink > 1 && check_hardlinks (src_vpath, dst_vpath, &sb))
1500         {
1501             /* We have made a hardlink - no more processing is necessary */
1502             return_status = FILE_CONT;
1503             goto ret_fast;
1504         }
1505
1506         if (S_ISLNK (sb.st_mode))
1507         {
1508             return_status = make_symlink (ctx, src_path, dst_path);
1509             goto ret_fast;
1510         }
1511
1512         if (S_ISCHR (sb.st_mode) || S_ISBLK (sb.st_mode) ||
1513             S_ISFIFO (sb.st_mode) || S_ISNAM (sb.st_mode) || S_ISSOCK (sb.st_mode))
1514         {
1515             while (mc_mknod (dst_vpath, sb.st_mode & ctx->umask_kill, sb.st_rdev) < 0
1516                    && !ctx->skip_all)
1517             {
1518                 return_status = file_error (_("Cannot create special file \"%s\"\n%s"), dst_path);
1519                 if (return_status == FILE_RETRY)
1520                     continue;
1521                 if (return_status == FILE_SKIPALL)
1522                     ctx->skip_all = TRUE;
1523                 goto ret_fast;
1524             }
1525             /* Success */
1526
1527             while (ctx->preserve_uidgid && mc_chown (dst_vpath, sb.st_uid, sb.st_gid) != 0
1528                    && !ctx->skip_all)
1529             {
1530                 temp_status = file_error (_("Cannot chown target file \"%s\"\n%s"), dst_path);
1531                 if (temp_status == FILE_SKIP)
1532                     break;
1533                 if (temp_status == FILE_SKIPALL)
1534                     ctx->skip_all = TRUE;
1535                 if (temp_status != FILE_RETRY)
1536                 {
1537                     return_status = temp_status;
1538                     goto ret_fast;
1539                 }
1540             }
1541
1542             while (ctx->preserve && mc_chmod (dst_vpath, sb.st_mode & ctx->umask_kill) != 0
1543                    && !ctx->skip_all)
1544             {
1545                 temp_status = file_error (_("Cannot chmod target file \"%s\"\n%s"), dst_path);
1546                 if (temp_status == FILE_SKIP)
1547                     break;
1548                 if (temp_status == FILE_SKIPALL)
1549                     ctx->skip_all = TRUE;
1550                 if (temp_status != FILE_RETRY)
1551                 {
1552                     return_status = temp_status;
1553                     goto ret_fast;
1554                 }
1555             }
1556
1557             return_status = FILE_CONT;
1558             goto ret_fast;
1559         }
1560     }
1561
1562     gettimeofday (&tv_transfer_start, (struct timezone *) NULL);
1563
1564     while ((src_desc = mc_open (src_vpath, O_RDONLY | O_LINEAR)) < 0 && !ctx->skip_all)
1565     {
1566         return_status = file_error (_("Cannot open source file \"%s\"\n%s"), src_path);
1567         if (return_status == FILE_RETRY)
1568             continue;
1569         if (return_status == FILE_SKIPALL)
1570             ctx->skip_all = TRUE;
1571         if (return_status == FILE_SKIP)
1572             break;
1573         ctx->do_append = 0;
1574         goto ret_fast;
1575     }
1576
1577     if (ctx->do_reget != 0)
1578     {
1579         if (mc_lseek (src_desc, ctx->do_reget, SEEK_SET) != ctx->do_reget)
1580         {
1581             message (D_ERROR, _("Warning"), _("Reget failed, about to overwrite file"));
1582             ctx->do_reget = 0;
1583             ctx->do_append = FALSE;
1584         }
1585     }
1586
1587     while (mc_fstat (src_desc, &sb) != 0)
1588     {
1589         if (ctx->skip_all)
1590             return_status = FILE_SKIPALL;
1591         else
1592         {
1593             return_status = file_error (_("Cannot fstat source file \"%s\"\n%s"), src_path);
1594             if (return_status == FILE_RETRY)
1595                 continue;
1596             if (return_status == FILE_SKIPALL)
1597                 ctx->skip_all = TRUE;
1598             ctx->do_append = FALSE;
1599         }
1600         goto ret;
1601     }
1602
1603     src_mode = sb.st_mode;
1604     src_uid = sb.st_uid;
1605     src_gid = sb.st_gid;
1606     utb.actime = sb.st_atime;
1607     utb.modtime = sb.st_mtime;
1608     file_size = sb.st_size;
1609
1610     open_flags = O_WRONLY;
1611     if (dst_exists)
1612     {
1613         if (ctx->do_append != 0)
1614             open_flags |= O_APPEND;
1615         else
1616             open_flags |= O_CREAT | O_TRUNC;
1617     }
1618     else
1619     {
1620         open_flags |= O_CREAT | O_EXCL;
1621     }
1622
1623     while ((dest_desc = mc_open (dst_vpath, open_flags, src_mode)) < 0)
1624     {
1625         if (errno != EEXIST)
1626         {
1627             if (ctx->skip_all)
1628                 return_status = FILE_SKIPALL;
1629             else
1630             {
1631                 return_status = file_error (_("Cannot create target file \"%s\"\n%s"), dst_path);
1632                 if (return_status == FILE_RETRY)
1633                     continue;
1634                 if (return_status == FILE_SKIPALL)
1635                     ctx->skip_all = TRUE;
1636                 ctx->do_append = FALSE;
1637             }
1638         }
1639         goto ret;
1640     }
1641     dst_status = DEST_SHORT;    /* file opened, but not fully copied */
1642
1643     appending = ctx->do_append;
1644     ctx->do_append = FALSE;
1645
1646     /* Find out the optimal buffer size.  */
1647     while (mc_fstat (dest_desc, &sb) != 0)
1648     {
1649         if (ctx->skip_all)
1650             return_status = FILE_SKIPALL;
1651         else
1652         {
1653             return_status = file_error (_("Cannot fstat target file \"%s\"\n%s"), dst_path);
1654             if (return_status == FILE_RETRY)
1655                 continue;
1656             if (return_status == FILE_SKIPALL)
1657                 ctx->skip_all = TRUE;
1658         }
1659         goto ret;
1660     }
1661
1662     while (TRUE)
1663     {
1664         errno = vfs_preallocate (dest_desc, file_size, (ctx->do_append != 0) ? sb.st_size : 0);
1665         if (errno == 0)
1666             break;
1667
1668         if (ctx->skip_all)
1669             return_status = FILE_SKIPALL;
1670         else
1671         {
1672             return_status =
1673                 file_error (_("Cannot preallocate space for target file \"%s\"\n%s"), dst_path);
1674             if (return_status == FILE_RETRY)
1675                 continue;
1676             if (return_status == FILE_SKIPALL)
1677                 ctx->skip_all = TRUE;
1678         }
1679         mc_close (dest_desc);
1680         dest_desc = -1;
1681         mc_unlink (dst_vpath);
1682         dst_status = DEST_NONE;
1683         goto ret;
1684     }
1685
1686     ctx->eta_secs = 0.0;
1687     ctx->bps = 0;
1688
1689     if (tctx->bps == 0 || (file_size / (tctx->bps)) > FILEOP_UPDATE_INTERVAL)
1690         file_progress_show (ctx, 0, file_size, "", TRUE);
1691     else
1692         file_progress_show (ctx, 1, 1, "", TRUE);
1693     return_status = check_progress_buttons (ctx);
1694     mc_refresh ();
1695
1696     if (return_status != FILE_CONT)
1697         goto ret;
1698
1699     {
1700         off_t n_read_total = 0;
1701         struct timeval tv_current, tv_last_update, tv_last_input;
1702         int secs, update_secs;
1703         const char *stalled_msg = "";
1704
1705         tv_last_update = tv_transfer_start;
1706
1707         while (TRUE)
1708         {
1709             char buf[BUF_8K];
1710
1711             /* src_read */
1712             if (mc_ctl (src_desc, VFS_CTL_IS_NOTREADY, 0))
1713                 n_read = -1;
1714             else
1715                 while ((n_read = mc_read (src_desc, buf, sizeof (buf))) < 0 && !ctx->skip_all)
1716                 {
1717                     return_status = file_error (_("Cannot read source file\"%s\"\n%s"), src_path);
1718                     if (return_status == FILE_RETRY)
1719                         continue;
1720                     if (return_status == FILE_SKIPALL)
1721                         ctx->skip_all = TRUE;
1722                     goto ret;
1723                 }
1724             if (n_read == 0)
1725                 break;
1726
1727             gettimeofday (&tv_current, NULL);
1728
1729             if (n_read > 0)
1730             {
1731                 char *t = buf;
1732                 n_read_total += n_read;
1733
1734                 /* Windows NT ftp servers report that files have no
1735                  * permissions: -------, so if we happen to have actually
1736                  * read something, we should fix the permissions.
1737                  */
1738                 if ((src_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) == 0)
1739                     src_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
1740                 gettimeofday (&tv_last_input, NULL);
1741
1742                 /* dst_write */
1743                 while ((n_written = mc_write (dest_desc, t, n_read)) < n_read)
1744                 {
1745                     if (n_written > 0)
1746                     {
1747                         n_read -= n_written;
1748                         t += n_written;
1749                         continue;
1750                     }
1751
1752                     write_errno_nospace = (n_written < 0 && errno == ENOSPC);
1753
1754                     if (ctx->skip_all)
1755                         return_status = FILE_SKIPALL;
1756                     else
1757                         return_status =
1758                             file_error (_("Cannot write target file \"%s\"\n%s"), dst_path);
1759
1760                     if (return_status == FILE_SKIP)
1761                     {
1762                         if (write_errno_nospace)
1763                             goto ret;
1764                         break;
1765                     }
1766                     if (return_status == FILE_SKIPALL)
1767                     {
1768                         ctx->skip_all = TRUE;
1769                         if (write_errno_nospace)
1770                             goto ret;
1771                     }
1772                     if (return_status != FILE_RETRY)
1773                         goto ret;
1774
1775                     /* User pressed "Retry". Will the next mc_write() call be succesful?
1776                      * Reset error flag to be ready for that. */
1777                     write_errno_nospace = FALSE;
1778                 }
1779             }
1780
1781             tctx->copied_bytes = tctx->progress_bytes + n_read_total + ctx->do_reget;
1782
1783             secs = (tv_current.tv_sec - tv_last_update.tv_sec);
1784             update_secs = (tv_current.tv_sec - tv_last_input.tv_sec);
1785
1786             if (is_first_time || secs > FILEOP_UPDATE_INTERVAL)
1787             {
1788                 copy_file_file_display_progress (tctx, ctx,
1789                                                  tv_current,
1790                                                  tv_transfer_start, file_size, n_read_total);
1791                 tv_last_update = tv_current;
1792             }
1793             is_first_time = FALSE;
1794
1795             if (update_secs > FILEOP_STALLING_INTERVAL)
1796             {
1797                 stalled_msg = _("(stalled)");
1798             }
1799
1800             {
1801                 gboolean force_update;
1802
1803                 force_update =
1804                     (tv_current.tv_sec - tctx->transfer_start.tv_sec) > FILEOP_UPDATE_INTERVAL;
1805
1806                 if (verbose && ctx->dialog_type == FILEGUI_DIALOG_MULTI_ITEM)
1807                 {
1808                     file_progress_show_count (ctx, tctx->progress_count, ctx->progress_count);
1809                     file_progress_show_total (tctx, ctx, tctx->copied_bytes, force_update);
1810                 }
1811
1812                 file_progress_show (ctx, n_read_total + ctx->do_reget, file_size, stalled_msg,
1813                                     force_update);
1814             }
1815             mc_refresh ();
1816
1817             return_status = check_progress_buttons (ctx);
1818
1819             if (return_status != FILE_CONT)
1820             {
1821                 mc_refresh ();
1822                 goto ret;
1823             }
1824         }
1825     }
1826
1827     dst_status = DEST_FULL;     /* copy successful, don't remove target file */
1828
1829   ret:
1830     while (src_desc != -1 && mc_close (src_desc) < 0 && !ctx->skip_all)
1831     {
1832         temp_status = file_error (_("Cannot close source file \"%s\"\n%s"), src_path);
1833         if (temp_status == FILE_RETRY)
1834             continue;
1835         if (temp_status == FILE_ABORT)
1836             return_status = temp_status;
1837         if (temp_status == FILE_SKIPALL)
1838             ctx->skip_all = TRUE;
1839         break;
1840     }
1841
1842     while (dest_desc != -1 && mc_close (dest_desc) < 0 && !ctx->skip_all)
1843     {
1844         temp_status = file_error (_("Cannot close target file \"%s\"\n%s"), dst_path);
1845         if (temp_status == FILE_RETRY)
1846             continue;
1847         if (temp_status == FILE_SKIPALL)
1848             ctx->skip_all = TRUE;
1849         return_status = temp_status;
1850         break;
1851     }
1852
1853     if (dst_status == DEST_SHORT)
1854     {
1855         /* Remove short file */
1856         int result = 0;
1857
1858         /* In case of copy/move to full partition, keep source file
1859          * and remove incomplete destination one */
1860         if (!write_errno_nospace)
1861             result = query_dialog (Q_ ("DialogTitle|Copy"),
1862                                    _("Incomplete file was retrieved. Keep it?"),
1863                                    D_ERROR, 2, _("&Delete"), _("&Keep"));
1864         if (result == 0)
1865             mc_unlink (dst_vpath);
1866     }
1867     else if (dst_status == DEST_FULL)
1868     {
1869         /* Copy has succeeded */
1870         if (!appending && ctx->preserve_uidgid)
1871         {
1872             while (mc_chown (dst_vpath, src_uid, src_gid) != 0 && !ctx->skip_all)
1873             {
1874                 temp_status = file_error (_("Cannot chown target file \"%s\"\n%s"), dst_path);
1875                 if (temp_status == FILE_RETRY)
1876                     continue;
1877                 if (temp_status == FILE_SKIPALL)
1878                 {
1879                     ctx->skip_all = TRUE;
1880                     return_status = FILE_CONT;
1881                 }
1882                 if (temp_status == FILE_SKIP)
1883                     return_status = FILE_CONT;
1884                 break;
1885             }
1886         }
1887
1888         if (!appending)
1889         {
1890             if (ctx->preserve)
1891             {
1892                 while (mc_chmod (dst_vpath, (src_mode & ctx->umask_kill)) != 0 && !ctx->skip_all)
1893                 {
1894                     temp_status = file_error (_("Cannot chmod target file \"%s\"\n%s"), dst_path);
1895                     if (temp_status == FILE_RETRY)
1896                         continue;
1897                     if (temp_status == FILE_SKIPALL)
1898                     {
1899                         ctx->skip_all = TRUE;
1900                         return_status = FILE_CONT;
1901                     }
1902                     if (temp_status == FILE_SKIP)
1903                         return_status = FILE_CONT;
1904                     break;
1905                 }
1906             }
1907             else if (!dst_exists)
1908             {
1909                 src_mode = umask (-1);
1910                 umask (src_mode);
1911                 src_mode = 0100666 & ~src_mode;
1912                 mc_chmod (dst_vpath, (src_mode & ctx->umask_kill));
1913             }
1914             mc_utime (dst_vpath, &utb);
1915         }
1916     }
1917
1918     if (return_status == FILE_CONT)
1919         return_status = progress_update_one (tctx, ctx, file_size);
1920
1921   ret_fast:
1922     vfs_path_free (src_vpath);
1923     vfs_path_free (dst_vpath);
1924     return return_status;
1925 }
1926
1927 /* --------------------------------------------------------------------------------------------- */
1928 /**
1929  * I think these copy_*_* functions should have a return type.
1930  * anyway, this function *must* have two directories as arguments.
1931  */
1932 /* FIXME: This function needs to check the return values of the
1933    function calls */
1934
1935 FileProgressStatus
1936 copy_dir_dir (FileOpTotalContext * tctx, FileOpContext * ctx, const char *s, const char *_d,
1937               gboolean toplevel, gboolean move_over, gboolean do_delete, GSList * parent_dirs)
1938 {
1939     struct dirent *next;
1940     struct stat buf, cbuf;
1941     DIR *reading;
1942     char *dest_dir = NULL;
1943     FileProgressStatus return_status = FILE_CONT;
1944     struct utimbuf utb;
1945     struct link *lp;
1946     char *d;
1947     vfs_path_t *src_vpath, *dst_vpath, *dest_dir_vpath = NULL;
1948
1949     d = g_strdup (_d);
1950
1951     src_vpath = vfs_path_from_str (s);
1952     dst_vpath = vfs_path_from_str (_d);
1953
1954     /* First get the mode of the source dir */
1955
1956   retry_src_stat:
1957     if ((*ctx->stat_func) (src_vpath, &cbuf) != 0)
1958     {
1959         if (ctx->skip_all)
1960             return_status = FILE_SKIPALL;
1961         else
1962         {
1963             return_status = file_error (_("Cannot stat source directory \"%s\"\n%s"), s);
1964             if (return_status == FILE_RETRY)
1965                 goto retry_src_stat;
1966             if (return_status == FILE_SKIPALL)
1967                 ctx->skip_all = TRUE;
1968         }
1969         goto ret_fast;
1970     }
1971
1972     if (is_in_linklist (dest_dirs, src_vpath, &cbuf))
1973     {
1974         /* Don't copy a directory we created before (we don't want to copy
1975            infinitely if a directory is copied into itself) */
1976         /* FIXME: should there be an error message and FILE_SKIP? - Norbert */
1977         return_status = FILE_CONT;
1978         goto ret_fast;
1979     }
1980
1981     /* Hmm, hardlink to directory??? - Norbert */
1982     /* FIXME: In this step we should do something
1983        in case the destination already exist */
1984     /* Check the hardlinks */
1985     if (ctx->preserve && cbuf.st_nlink > 1 && check_hardlinks (src_vpath, dst_vpath, &cbuf))
1986     {
1987         /* We have made a hardlink - no more processing is necessary */
1988         goto ret_fast;
1989     }
1990
1991     if (!S_ISDIR (cbuf.st_mode))
1992     {
1993         if (ctx->skip_all)
1994             return_status = FILE_SKIPALL;
1995         else
1996         {
1997             return_status = file_error (_("Source \"%s\" is not a directory\n%s"), s);
1998             if (return_status == FILE_RETRY)
1999                 goto retry_src_stat;
2000             if (return_status == FILE_SKIPALL)
2001                 ctx->skip_all = TRUE;
2002         }
2003         goto ret_fast;
2004     }
2005
2006     if (is_in_linklist (parent_dirs, src_vpath, &cbuf))
2007     {
2008         /* we found a cyclic symbolic link */
2009         message (D_ERROR, MSG_ERROR, _("Cannot copy cyclic symbolic link\n\"%s\""), s);
2010         return_status = FILE_SKIP;
2011         goto ret_fast;
2012     }
2013
2014     lp = g_new0 (struct link, 1);
2015     lp->vfs = vfs_path_get_by_index (src_vpath, -1)->class;
2016     lp->ino = cbuf.st_ino;
2017     lp->dev = cbuf.st_dev;
2018     parent_dirs = g_slist_prepend (parent_dirs, lp);
2019
2020   retry_dst_stat:
2021     /* Now, check if the dest dir exists, if not, create it. */
2022     if (mc_stat (dst_vpath, &buf) != 0)
2023     {
2024         /* Here the dir doesn't exist : make it ! */
2025         if (move_over)
2026         {
2027             if (mc_rename (src_vpath, dst_vpath) == 0)
2028             {
2029                 return_status = FILE_CONT;
2030                 goto ret;
2031             }
2032         }
2033         dest_dir = d;
2034         d = NULL;
2035     }
2036     else
2037     {
2038         /*
2039          * If the destination directory exists, we want to copy the whole
2040          * directory, but we only want this to happen once.
2041          *
2042          * Escape sequences added to the * to compiler warnings.
2043          * so, say /bla exists, if we copy /tmp/\* to /bla, we get /bla/tmp/\*
2044          * or ( /bla doesn't exist )       /tmp/\* to /bla     ->  /bla/\*
2045          */
2046         if (!S_ISDIR (buf.st_mode))
2047         {
2048             if (ctx->skip_all)
2049                 return_status = FILE_SKIPALL;
2050             else
2051             {
2052                 return_status = file_error (_("Destination \"%s\" must be a directory\n%s"), d);
2053                 if (return_status == FILE_SKIPALL)
2054                     ctx->skip_all = TRUE;
2055                 if (return_status == FILE_RETRY)
2056                     goto retry_dst_stat;
2057             }
2058             goto ret;
2059         }
2060         /* Dive into subdir if exists */
2061         if (toplevel && ctx->dive_into_subdirs)
2062         {
2063             dest_dir = mc_build_filename (d, x_basename (s), NULL);
2064         }
2065         else
2066         {
2067             dest_dir = d;
2068             d = NULL;
2069             dest_dir_vpath = vfs_path_from_str (dest_dir);
2070             goto dont_mkdir;
2071         }
2072     }
2073     dest_dir_vpath = vfs_path_from_str (dest_dir);
2074     while (my_mkdir (dest_dir_vpath, (cbuf.st_mode & ctx->umask_kill) | S_IRWXU) != 0)
2075     {
2076         if (ctx->skip_all)
2077             return_status = FILE_SKIPALL;
2078         else
2079         {
2080             return_status = file_error (_("Cannot create target directory \"%s\"\n%s"), dest_dir);
2081             if (return_status == FILE_SKIPALL)
2082                 ctx->skip_all = TRUE;
2083         }
2084         if (return_status != FILE_RETRY)
2085             goto ret;
2086     }
2087
2088     lp = g_new0 (struct link, 1);
2089     mc_stat (dest_dir_vpath, &buf);
2090     lp->vfs = vfs_path_get_by_index (dest_dir_vpath, -1)->class;
2091     lp->ino = buf.st_ino;
2092     lp->dev = buf.st_dev;
2093     dest_dirs = g_slist_prepend (dest_dirs, lp);
2094
2095   dont_mkdir:
2096     if (ctx->preserve_uidgid)
2097     {
2098         while (mc_chown (dest_dir_vpath, cbuf.st_uid, cbuf.st_gid) != 0)
2099         {
2100             if (ctx->skip_all)
2101                 return_status = FILE_SKIPALL;
2102             else
2103             {
2104                 return_status =
2105                     file_error (_("Cannot chown target directory \"%s\"\n%s"), dest_dir);
2106                 if (return_status == FILE_SKIPALL)
2107                     ctx->skip_all = TRUE;
2108             }
2109             if (return_status != FILE_RETRY)
2110                 goto ret;
2111         }
2112     }
2113
2114     /* open the source dir for reading */
2115     reading = mc_opendir (src_vpath);
2116     if (reading == NULL)
2117         goto ret;
2118
2119     while ((next = mc_readdir (reading)) && return_status != FILE_ABORT)
2120     {
2121         char *path;
2122         vfs_path_t *tmp_vpath;
2123         /*
2124          * Now, we don't want '.' and '..' to be created / copied at any time
2125          */
2126         if (!strcmp (next->d_name, "."))
2127             continue;
2128         if (!strcmp (next->d_name, ".."))
2129             continue;
2130
2131         /* get the filename and add it to the src directory */
2132         path = mc_build_filename (s, next->d_name, NULL);
2133         tmp_vpath = vfs_path_from_str (path);
2134
2135         (*ctx->stat_func) (tmp_vpath, &buf);
2136         if (S_ISDIR (buf.st_mode))
2137         {
2138             char *mdpath;
2139
2140             mdpath = mc_build_filename (dest_dir, next->d_name, NULL);
2141             /*
2142              * From here, we just intend to recursively copy subdirs, not
2143              * the double functionality of copying different when the target
2144              * dir already exists. So, we give the recursive call the flag 0
2145              * meaning no toplevel.
2146              */
2147             return_status =
2148                 copy_dir_dir (tctx, ctx, path, mdpath, FALSE, FALSE, do_delete, parent_dirs);
2149             g_free (mdpath);
2150         }
2151         else
2152         {
2153             char *dest_file;
2154
2155             dest_file = mc_build_filename (dest_dir, x_basename (path), NULL);
2156             return_status = copy_file_file (tctx, ctx, path, dest_file);
2157             g_free (dest_file);
2158         }
2159         if (do_delete && return_status == FILE_CONT)
2160         {
2161             if (ctx->erase_at_end)
2162             {
2163                 lp = g_new0 (struct link, 1);
2164                 lp->src_vpath = vfs_path_clone (tmp_vpath);
2165                 lp->st_mode = buf.st_mode;
2166                 erase_list = g_slist_append (erase_list, lp);
2167             }
2168             else if (S_ISDIR (buf.st_mode))
2169                 return_status = erase_dir_iff_empty (ctx, path);
2170             else
2171                 return_status = erase_file (tctx, ctx, tmp_vpath);
2172         }
2173         g_free (path);
2174         vfs_path_free (tmp_vpath);
2175     }
2176     mc_closedir (reading);
2177
2178     if (ctx->preserve)
2179     {
2180         mc_chmod (dest_dir_vpath, cbuf.st_mode & ctx->umask_kill);
2181         utb.actime = cbuf.st_atime;
2182         utb.modtime = cbuf.st_mtime;
2183         mc_utime (dest_dir_vpath, &utb);
2184     }
2185     else
2186     {
2187         cbuf.st_mode = umask (-1);
2188         umask (cbuf.st_mode);
2189         cbuf.st_mode = 0100777 & ~cbuf.st_mode;
2190         mc_chmod (dest_dir_vpath, cbuf.st_mode & ctx->umask_kill);
2191     }
2192
2193   ret:
2194     g_free (dest_dir);
2195     vfs_path_free (dest_dir_vpath);
2196     free_link (parent_dirs->data);
2197     g_slist_free_1 (parent_dirs);
2198   ret_fast:
2199     g_free (d);
2200     vfs_path_free (src_vpath);
2201     vfs_path_free (dst_vpath);
2202     return return_status;
2203 }
2204
2205 /* }}} */
2206
2207 /* --------------------------------------------------------------------------------------------- */
2208 /* {{{ Move routines */
2209
2210 FileProgressStatus
2211 move_dir_dir (FileOpTotalContext * tctx, FileOpContext * ctx, const char *s, const char *d)
2212 {
2213     struct stat sbuf, dbuf, destbuf;
2214     struct link *lp;
2215     char *destdir;
2216     FileProgressStatus return_status;
2217     gboolean move_over = FALSE;
2218     gboolean dstat_ok;
2219     vfs_path_t *src_vpath, *dst_vpath, *destdir_vpath;
2220
2221     src_vpath = vfs_path_from_str (s);
2222     dst_vpath = vfs_path_from_str (d);
2223
2224     file_progress_show_source (ctx, src_vpath);
2225     file_progress_show_target (ctx, dst_vpath);
2226
2227     if (check_progress_buttons (ctx) == FILE_ABORT)
2228     {
2229         return_status = FILE_ABORT;
2230         goto ret_fast;
2231     }
2232
2233     mc_refresh ();
2234
2235     mc_stat (src_vpath, &sbuf);
2236
2237     dstat_ok = (mc_stat (dst_vpath, &dbuf) == 0);
2238     if (dstat_ok && sbuf.st_dev == dbuf.st_dev && sbuf.st_ino == dbuf.st_ino)
2239     {
2240         return_status = warn_same_file (_("\"%s\"\nand\n\"%s\"\nare the same directory"), s, d);
2241         goto ret_fast;
2242     }
2243
2244     if (!dstat_ok)
2245         destdir = g_strdup (d); /* destination doesn't exist */
2246     else if (!ctx->dive_into_subdirs)
2247     {
2248         destdir = g_strdup (d);
2249         move_over = TRUE;
2250     }
2251     else
2252         destdir = mc_build_filename (d, x_basename (s), NULL);
2253
2254     destdir_vpath = vfs_path_from_str (destdir);
2255
2256     /* Check if the user inputted an existing dir */
2257   retry_dst_stat:
2258     if (mc_stat (destdir_vpath, &destbuf) == 0)
2259     {
2260         if (move_over)
2261         {
2262             return_status = copy_dir_dir (tctx, ctx, s, destdir, FALSE, TRUE, TRUE, NULL);
2263
2264             if (return_status != FILE_CONT)
2265                 goto ret;
2266             goto oktoret;
2267         }
2268         else if (ctx->skip_all)
2269             return_status = FILE_SKIPALL;
2270         else
2271         {
2272             if (S_ISDIR (destbuf.st_mode))
2273                 return_status = file_error (_("Cannot overwrite directory \"%s\"\n%s"), destdir);
2274             else
2275                 return_status = file_error (_("Cannot overwrite file \"%s\"\n%s"), destdir);
2276             if (return_status == FILE_SKIPALL)
2277                 ctx->skip_all = TRUE;
2278             if (return_status == FILE_RETRY)
2279                 goto retry_dst_stat;
2280         }
2281
2282         g_free (destdir);
2283         vfs_path_free (destdir_vpath);
2284         goto ret_fast;
2285     }
2286
2287   retry_rename:
2288     if (mc_rename (src_vpath, destdir_vpath) == 0)
2289     {
2290         return_status = FILE_CONT;
2291         goto ret;
2292     }
2293
2294     if (errno != EXDEV)
2295     {
2296         if (!ctx->skip_all)
2297         {
2298             return_status = files_error (_("Cannot move directory \"%s\" to \"%s\"\n%s"), s, d);
2299             if (return_status == FILE_SKIPALL)
2300                 ctx->skip_all = TRUE;
2301             if (return_status == FILE_RETRY)
2302                 goto retry_rename;
2303         }
2304         goto ret;
2305     }
2306     /* Failed because of filesystem boundary -> copy dir instead */
2307     return_status = copy_dir_dir (tctx, ctx, s, destdir, FALSE, FALSE, TRUE, NULL);
2308
2309     if (return_status != FILE_CONT)
2310         goto ret;
2311   oktoret:
2312     file_progress_show_source (ctx, NULL);
2313     file_progress_show (ctx, 0, 0, "", FALSE);
2314
2315     return_status = check_progress_buttons (ctx);
2316     if (return_status != FILE_CONT)
2317         goto ret;
2318
2319     mc_refresh ();
2320     if (ctx->erase_at_end)
2321     {
2322         for (; erase_list != NULL && return_status != FILE_ABORT;)
2323         {
2324             lp = (struct link *) erase_list->data;
2325
2326             if (S_ISDIR (lp->st_mode))
2327             {
2328                 char *src_path;
2329
2330                 src_path = vfs_path_to_str (lp->src_vpath);
2331                 return_status = erase_dir_iff_empty (ctx, src_path);
2332                 g_free (src_path);
2333             }
2334             else
2335                 return_status = erase_file (tctx, ctx, lp->src_vpath);
2336
2337             erase_list = g_slist_remove (erase_list, lp);
2338             free_link (lp);
2339         }
2340     }
2341     erase_dir_iff_empty (ctx, s);
2342
2343   ret:
2344     g_free (destdir);
2345     vfs_path_free (destdir_vpath);
2346     erase_list = free_linklist (erase_list);
2347   ret_fast:
2348     vfs_path_free (src_vpath);
2349     vfs_path_free (dst_vpath);
2350     return return_status;
2351 }
2352
2353 /* }}} */
2354
2355 /* --------------------------------------------------------------------------------------------- */
2356 /* {{{ Erase routines */
2357
2358 FileProgressStatus
2359 erase_dir (FileOpTotalContext * tctx, FileOpContext * ctx, const vfs_path_t * s_vpath)
2360 {
2361     FileProgressStatus error;
2362     char *s;
2363
2364     s = vfs_path_to_str (s_vpath);
2365
2366     /*
2367        if (strcmp (s, "..") == 0)
2368        return FILE_SKIP;
2369
2370        if (strcmp (s, ".") == 0)
2371        return FILE_SKIP;
2372      */
2373
2374     file_progress_show_deleting (ctx, s);
2375     if (check_progress_buttons (ctx) == FILE_ABORT)
2376     {
2377         g_free (s);
2378         return FILE_ABORT;
2379     }
2380     mc_refresh ();
2381
2382     /* The old way to detect a non empty directory was:
2383        error = my_rmdir (s);
2384        if (error && (errno == ENOTEMPTY || errno == EEXIST))){
2385        For the linux user space nfs server (nfs-server-2.2beta29-2)
2386        we would have to check also for EIO. I hope the new way is
2387        fool proof. (Norbert)
2388      */
2389     error = check_dir_is_empty (s_vpath);
2390     if (error == 0)
2391     {                           /* not empty */
2392         error = query_recursive (ctx, s);
2393         if (error == FILE_CONT)
2394             error = recursive_erase (tctx, ctx, s);
2395         g_free (s);
2396         return error;
2397     }
2398
2399     while (my_rmdir (s) == -1 && !ctx->skip_all)
2400     {
2401         error = file_error (_("Cannot remove directory \"%s\"\n%s"), s);
2402         if (error != FILE_RETRY)
2403         {
2404             g_free (s);
2405             return error;
2406         }
2407     }
2408
2409     g_free (s);
2410     return FILE_CONT;
2411 }
2412
2413 /* }}} */
2414
2415 /* --------------------------------------------------------------------------------------------- */
2416 /* {{{ Panel operate routines */
2417
2418 ComputeDirSizeUI *
2419 compute_dir_size_create_ui (void)
2420 {
2421     ComputeDirSizeUI *ui;
2422
2423     const char *b_name = N_("&Abort");
2424
2425 #ifdef ENABLE_NLS
2426     b_name = _(b_name);
2427 #endif
2428
2429     ui = g_new (ComputeDirSizeUI, 1);
2430
2431     ui->dlg = create_dlg (TRUE, 0, 0, 7, COLS / 2, dialog_colors, NULL, NULL,
2432                           NULL, _("Directory scanning"), DLG_CENTER);
2433     ui->dirname = label_new (2, 3, "");
2434     add_widget (ui->dlg, ui->dirname);
2435     add_widget (ui->dlg, hline_new (3, -1, -1));
2436     add_widget_autopos (ui->dlg,
2437                         button_new (4, 2, FILE_ABORT, NORMAL_BUTTON, b_name, NULL),
2438                         WPOS_KEEP_TOP | WPOS_CENTER_HORZ, NULL);
2439
2440     /* We will manage the dialog without any help,
2441        that's why we have to call init_dlg */
2442     init_dlg (ui->dlg);
2443
2444     return ui;
2445 }
2446
2447 /* --------------------------------------------------------------------------------------------- */
2448
2449 void
2450 compute_dir_size_destroy_ui (ComputeDirSizeUI * ui)
2451 {
2452     if (ui != NULL)
2453     {
2454         /* schedule to update passive panel */
2455         other_panel->dirty = 1;
2456
2457         /* close and destroy dialog */
2458         dlg_run_done (ui->dlg);
2459         destroy_dlg (ui->dlg);
2460         g_free (ui);
2461     }
2462 }
2463
2464 /* --------------------------------------------------------------------------------------------- */
2465
2466 FileProgressStatus
2467 compute_dir_size_update_ui (const void *ui, const vfs_path_t * dirname_vpath)
2468 {
2469     const ComputeDirSizeUI *this = (const ComputeDirSizeUI *) ui;
2470     int c;
2471     Gpm_Event event;
2472     char *dirname;
2473
2474     if (ui == NULL)
2475         return FILE_CONT;
2476
2477     dirname = vfs_path_to_str (dirname_vpath);
2478     label_set_text (this->dirname, str_trunc (dirname, WIDGET (this->dlg)->cols - 6));
2479     g_free (dirname);
2480
2481     event.x = -1;               /* Don't show the GPM cursor */
2482     c = tty_get_event (&event, FALSE, FALSE);
2483     if (c == EV_NONE)
2484         return FILE_CONT;
2485
2486     /* Reinitialize to avoid old values after events other than
2487        selecting a button */
2488     this->dlg->ret_value = FILE_CONT;
2489
2490     dlg_process_event (this->dlg, c, &event);
2491
2492     switch (this->dlg->ret_value)
2493     {
2494     case B_CANCEL:
2495     case FILE_ABORT:
2496         return FILE_ABORT;
2497     default:
2498         return FILE_CONT;
2499     }
2500 }
2501
2502 /* --------------------------------------------------------------------------------------------- */
2503 /**
2504  * compute_dir_size:
2505  *
2506  * Computes the number of bytes used by the files in a directory
2507  */
2508
2509 FileProgressStatus
2510 compute_dir_size (const vfs_path_t * dirname_vpath, const void *ui,
2511                   compute_dir_size_callback cback,
2512                   size_t * ret_marked, uintmax_t * ret_total, gboolean compute_symlinks)
2513 {
2514     int res;
2515     struct stat s;
2516     DIR *dir;
2517     struct dirent *dirent;
2518     FileProgressStatus ret = FILE_CONT;
2519
2520     if (!compute_symlinks)
2521     {
2522         res = mc_lstat (dirname_vpath, &s);
2523         if (res != 0)
2524             return ret;
2525
2526         /* don't scan symlink to directory */
2527         if (S_ISLNK (s.st_mode))
2528         {
2529             (*ret_marked)++;
2530             *ret_total += (uintmax_t) s.st_size;
2531             return ret;
2532         }
2533     }
2534
2535     dir = mc_opendir (dirname_vpath);
2536
2537     if (dir == NULL)
2538         return ret;
2539
2540     while ((dirent = mc_readdir (dir)) != NULL)
2541     {
2542         vfs_path_t *tmp_vpath;
2543
2544         ret = (cback != NULL) ? cback (ui, dirname_vpath) : FILE_CONT;
2545
2546         if (ret != FILE_CONT)
2547             break;
2548
2549         if (strcmp (dirent->d_name, ".") == 0)
2550             continue;
2551         if (strcmp (dirent->d_name, "..") == 0)
2552             continue;
2553
2554         tmp_vpath = vfs_path_append_new (dirname_vpath, dirent->d_name, NULL);
2555         res = mc_lstat (tmp_vpath, &s);
2556         if (res == 0)
2557         {
2558             if (S_ISDIR (s.st_mode))
2559             {
2560                 size_t subdir_count = 0;
2561                 uintmax_t subdir_bytes = 0;
2562
2563                 ret =
2564                     compute_dir_size (tmp_vpath, ui, cback, &subdir_count, &subdir_bytes,
2565                                       compute_symlinks);
2566
2567                 if (ret != FILE_CONT)
2568                 {
2569                     vfs_path_free (tmp_vpath);
2570                     break;
2571                 }
2572
2573                 *ret_marked += subdir_count;
2574                 *ret_total += subdir_bytes;
2575             }
2576             else
2577             {
2578                 (*ret_marked)++;
2579                 *ret_total += (uintmax_t) s.st_size;
2580             }
2581         }
2582         vfs_path_free (tmp_vpath);
2583     }
2584
2585     mc_closedir (dir);
2586     return ret;
2587 }
2588
2589 /* --------------------------------------------------------------------------------------------- */
2590 /**
2591  * panel_operate:
2592  *
2593  * Performs one of the operations on the selection on the source_panel
2594  * (copy, delete, move).
2595  *
2596  * Returns TRUE if did change the directory
2597  * structure, Returns FALSE if user aborted
2598  *
2599  * force_single forces operation on the current entry and affects
2600  * default destination.  Current filename is used as default.
2601  */
2602
2603 gboolean
2604 panel_operate (void *source_panel, FileOperation operation, gboolean force_single)
2605 {
2606     WPanel *panel = (WPanel *) source_panel;
2607     const gboolean single_entry = force_single || (panel->marked <= 1)
2608         || (get_current_type () == view_tree);
2609
2610     char *source = NULL;
2611 #ifdef WITH_FULL_PATHS
2612     vfs_path_t *source_with_vpath = NULL;
2613     char *source_with_path_str = NULL;
2614 #else
2615 #define source_with_path source
2616 #endif /* !WITH_FULL_PATHS */
2617     char *dest = NULL;
2618     vfs_path_t *dest_vpath = NULL;
2619     char *temp = NULL;
2620     char *save_cwd = NULL, *save_dest = NULL;
2621     struct stat src_stat;
2622     gboolean ret_val = TRUE;
2623     int i;
2624     FileProgressStatus value;
2625     FileOpContext *ctx;
2626     FileOpTotalContext *tctx;
2627     vfs_path_t *tmp_vpath;
2628
2629     gboolean do_bg = FALSE;     /* do background operation? */
2630
2631     static gboolean i18n_flag = FALSE;
2632     if (!i18n_flag)
2633     {
2634         for (i = sizeof (op_names) / sizeof (op_names[0]); i--;)
2635             op_names[i] = Q_ (op_names[i]);
2636         i18n_flag = TRUE;
2637     }
2638
2639     linklist = free_linklist (linklist);
2640     dest_dirs = free_linklist (dest_dirs);
2641
2642     if (single_entry)
2643     {
2644         vfs_path_t *source_vpath;
2645
2646         if (force_single)
2647             source = g_strdup (selection (panel)->fname);
2648         else
2649             source = panel_get_file (panel);
2650
2651         if (strcmp (source, "..") == 0)
2652         {
2653             g_free (source);
2654             message (D_ERROR, MSG_ERROR, _("Cannot operate on \"..\"!"));
2655             return FALSE;
2656         }
2657
2658         source_vpath = vfs_path_from_str (source);
2659         /* Update stat to get actual info */
2660         if (mc_lstat (source_vpath, &src_stat) != 0)
2661         {
2662             message (D_ERROR, MSG_ERROR, _("Cannot stat \"%s\"\n%s"),
2663                      path_trunc (source, 30), unix_error_string (errno));
2664
2665             /* Directory was changed outside MC. Reload it forced */
2666             if (!panel->is_panelized)
2667             {
2668                 panel_update_flags_t flags = UP_RELOAD;
2669
2670                 /* don't update panelized panel */
2671                 if (get_other_type () == view_listing && other_panel->is_panelized)
2672                     flags |= UP_ONLY_CURRENT;
2673
2674                 update_panels (flags, UP_KEEPSEL);
2675             }
2676             vfs_path_free (source_vpath);
2677             return FALSE;
2678         }
2679         vfs_path_free (source_vpath);
2680     }
2681
2682     ctx = file_op_context_new (operation);
2683
2684     /* Show confirmation dialog */
2685     if (operation != OP_DELETE)
2686     {
2687         char *tmp_dest_dir, *dest_dir;
2688         char *format;
2689
2690         /* Forced single operations default to the original name */
2691         if (force_single)
2692             tmp_dest_dir = g_strdup (source);
2693         else if (get_other_type () == view_listing)
2694             tmp_dest_dir = vfs_path_to_str (other_panel->cwd_vpath);
2695         else
2696             tmp_dest_dir = vfs_path_to_str (panel->cwd_vpath);
2697         /*
2698          * Add trailing backslash only when do non-local ops.
2699          * It saves user from occasional file renames (when destination
2700          * dir is deleted)
2701          */
2702         if (!force_single && tmp_dest_dir[0] != '\0'
2703             && tmp_dest_dir[strlen (tmp_dest_dir) - 1] != PATH_SEP)
2704         {
2705             /* add trailing separator */
2706             dest_dir = g_strconcat (tmp_dest_dir, PATH_SEP_STR, (char *) NULL);
2707             g_free (tmp_dest_dir);
2708         }
2709         else
2710         {
2711             /* just copy */
2712             dest_dir = tmp_dest_dir;
2713         }
2714         if (dest_dir == NULL)
2715         {
2716             ret_val = FALSE;
2717             goto ret_fast;
2718         }
2719
2720         /* Generate confirmation prompt */
2721         format = panel_operate_generate_prompt (panel, operation, source != NULL, &src_stat);
2722
2723         dest = file_mask_dialog (ctx, operation, source != NULL, format,
2724                                  source != NULL ? (void *) source
2725                                  : (void *) &panel->marked, dest_dir, &do_bg);
2726
2727         g_free (format);
2728         g_free (dest_dir);
2729
2730         if (dest == NULL || dest[0] == '\0')
2731         {
2732             g_free (dest);
2733             ret_val = FALSE;
2734             goto ret_fast;
2735         }
2736         dest_vpath = vfs_path_from_str (dest);
2737     }
2738     else if (confirm_delete)
2739     {
2740         char *format;
2741         char fmd_buf[BUF_MEDIUM];
2742
2743         /* Generate confirmation prompt */
2744         format = panel_operate_generate_prompt (panel, OP_DELETE, source != NULL, &src_stat);
2745
2746         if (source == NULL)
2747             g_snprintf (fmd_buf, sizeof (fmd_buf), format, panel->marked);
2748         else
2749         {
2750             const int fmd_xlen = 64;
2751             i = fmd_xlen - str_term_width1 (format) - 4;
2752             g_snprintf (fmd_buf, sizeof (fmd_buf), format, str_trunc (source, i));
2753         }
2754
2755         g_free (format);
2756
2757         if (safe_delete)
2758             query_set_sel (1);
2759
2760         i = query_dialog (op_names[operation], fmd_buf, D_ERROR, 2, _("&Yes"), _("&No"));
2761
2762         if (i != 0)
2763         {
2764             ret_val = FALSE;
2765             goto ret_fast;
2766         }
2767     }
2768
2769     tctx = file_op_total_context_new ();
2770     gettimeofday (&tctx->transfer_start, (struct timezone *) NULL);
2771
2772     {
2773         filegui_dialog_type_t dialog_type;
2774
2775         if (operation == OP_DELETE)
2776             dialog_type = FILEGUI_DIALOG_DELETE_ITEM;
2777         else
2778         {
2779             dialog_type = !((operation != OP_COPY) || (single_entry) || (force_single))
2780                 ? FILEGUI_DIALOG_MULTI_ITEM : FILEGUI_DIALOG_ONE_ITEM;
2781
2782             if ((single_entry) && (operation == OP_COPY) && S_ISDIR (selection (panel)->st.st_mode))
2783                 dialog_type = FILEGUI_DIALOG_MULTI_ITEM;
2784         }
2785
2786         /* Background also need ctx->ui, but not full */
2787         if (do_bg)
2788             file_op_context_create_ui_without_init (ctx, TRUE, dialog_type);
2789         else
2790             file_op_context_create_ui (ctx, TRUE, dialog_type);
2791     }
2792
2793 #ifdef ENABLE_BACKGROUND
2794     /* Did the user select to do a background operation? */
2795     if (do_bg)
2796     {
2797         int v;
2798         char *cwd_str;
2799
2800         cwd_str = vfs_path_to_str (panel->cwd_vpath);
2801         v = do_background (ctx, g_strconcat (op_names[operation], ": ", cwd_str, (char *) NULL));
2802         g_free (cwd_str);
2803         if (v == -1)
2804             message (D_ERROR, MSG_ERROR, _("Sorry, I could not put the job in background"));
2805
2806         /* If we are the parent */
2807         if (v == 1)
2808         {
2809             mc_setctl (panel->cwd_vpath, VFS_SETCTL_FORGET, NULL);
2810
2811             mc_setctl (dest_vpath, VFS_SETCTL_FORGET, NULL);
2812             vfs_path_free (dest_vpath);
2813             g_free (dest);
2814             /*          file_op_context_destroy (ctx); */
2815             return FALSE;
2816         }
2817     }
2818 #endif /* ENABLE_BACKGROUND */
2819
2820     /* Initialize things */
2821     /* We do not want to trash cache every time file is
2822        created/touched. However, this will make our cache contain
2823        invalid data. */
2824     if ((dest != NULL) && (mc_setctl (dest_vpath, VFS_SETCTL_STALE_DATA, (void *) 1)))
2825         save_dest = g_strdup (dest);
2826
2827     if ((vfs_path_tokens_count (panel->cwd_vpath) != 0)
2828         && (mc_setctl (panel->cwd_vpath, VFS_SETCTL_STALE_DATA, (void *) 1)))
2829         save_cwd = vfs_path_to_str (panel->cwd_vpath);
2830
2831     /* Now, let's do the job */
2832
2833     /* This code is only called by the tree and panel code */
2834     if (single_entry)
2835     {
2836         /* We now have ETA in all cases */
2837
2838         /* One file: FIXME mc_chdir will take user out of any vfs */
2839         if ((operation != OP_COPY) && (get_current_type () == view_tree))
2840         {
2841             vfs_path_t *vpath;
2842             int chdir_retcode;
2843
2844             vpath = vfs_path_from_str (PATH_SEP_STR);
2845             chdir_retcode = mc_chdir (vpath);
2846             vfs_path_free (vpath);
2847             if (chdir_retcode < 0)
2848             {
2849                 ret_val = FALSE;
2850                 goto clean_up;
2851             }
2852         }
2853
2854         /* The source and src_stat variables have been initialized before */
2855 #ifdef WITH_FULL_PATHS
2856         if (g_path_is_absolute (source))
2857             source_with_vpath = vfs_path_from_str (source);
2858         else
2859             source_with_vpath = vfs_path_append_new (panel->cwd_vpath, source, (char *) NULL);
2860         source_with_path_str = vfs_path_to_str (source_with_vpath);
2861 #endif /* WITH_FULL_PATHS */
2862         if (panel_operate_init_totals (operation, panel, source_with_path_str, ctx) == FILE_CONT)
2863         {
2864             if (operation == OP_DELETE)
2865             {
2866                 if (S_ISDIR (src_stat.st_mode))
2867                     value = erase_dir (tctx, ctx, source_with_vpath);
2868                 else
2869                     value = erase_file (tctx, ctx, source_with_vpath);
2870             }
2871             else
2872             {
2873                 temp = transform_source (ctx, source_with_path_str);
2874                 if (temp == NULL)
2875                     value = transform_error;
2876                 else
2877                 {
2878                     char *repl_dest, *temp2;
2879
2880                     repl_dest = mc_search_prepare_replace_str2 (ctx->search_handle, dest);
2881                     temp2 = mc_build_filename (repl_dest, temp, NULL);
2882                     g_free (temp);
2883                     g_free (repl_dest);
2884                     g_free (dest);
2885                     vfs_path_free (dest_vpath);
2886                     dest = temp2;
2887                     dest_vpath = vfs_path_from_str (dest);
2888
2889                     switch (operation)
2890                     {
2891                     case OP_COPY:
2892                         /* we use file_mask_op_follow_links only with OP_COPY */
2893                         ctx->stat_func (source_with_vpath, &src_stat);
2894
2895                         if (S_ISDIR (src_stat.st_mode))
2896                             value = copy_dir_dir (tctx, ctx, source_with_path_str, dest,
2897                                                   TRUE, FALSE, FALSE, NULL);
2898                         else
2899                             value = copy_file_file (tctx, ctx, source_with_path_str, dest);
2900                         break;
2901
2902                     case OP_MOVE:
2903                         if (S_ISDIR (src_stat.st_mode))
2904                             value = move_dir_dir (tctx, ctx, source_with_path_str, dest);
2905                         else
2906                             value = move_file_file (tctx, ctx, source_with_path_str, dest);
2907                         break;
2908
2909                     default:
2910                         /* Unknown file operation */
2911                         abort ();
2912                     }
2913                 }
2914             }                   /* Copy or move operation */
2915
2916             if ((value == FILE_CONT) && !force_single)
2917                 unmark_files (panel);
2918         }
2919     }
2920     else
2921     {
2922         /* Many files */
2923
2924         /* Check destination for copy or move operation */
2925         while (operation != OP_DELETE)
2926         {
2927             int dst_result;
2928             struct stat dst_stat;
2929
2930             dst_result = mc_stat (dest_vpath, &dst_stat);
2931
2932             if ((dst_result != 0) || S_ISDIR (dst_stat.st_mode))
2933                 break;
2934
2935             if (ctx->skip_all
2936                 || file_error (_("Destination \"%s\" must be a directory\n%s"), dest) != FILE_RETRY)
2937                 goto clean_up;
2938         }
2939
2940         if (panel_operate_init_totals (operation, panel, NULL, ctx) == FILE_CONT)
2941         {
2942             /* Loop for every file, perform the actual copy operation */
2943             for (i = 0; i < panel->count; i++)
2944             {
2945                 const char *source2;
2946
2947                 if (!panel->dir.list[i].f.marked)
2948                     continue;   /* Skip the unmarked ones */
2949
2950                 source2 = panel->dir.list[i].fname;
2951                 src_stat = panel->dir.list[i].st;
2952
2953 #ifdef WITH_FULL_PATHS
2954                 g_free (source_with_path_str);
2955                 vfs_path_free (source_with_vpath);
2956                 if (g_path_is_absolute (source2))
2957                     source_with_vpath = vfs_path_from_str (source2);
2958                 else
2959                     source_with_vpath =
2960                         vfs_path_append_new (panel->cwd_vpath, source2, (char *) NULL);
2961                 source_with_path_str = vfs_path_to_str (source_with_vpath);
2962 #endif /* WITH_FULL_PATHS */
2963
2964                 if (operation == OP_DELETE)
2965                 {
2966                     if (S_ISDIR (src_stat.st_mode))
2967                         value = erase_dir (tctx, ctx, source_with_vpath);
2968                     else
2969                         value = erase_file (tctx, ctx, source_with_vpath);
2970                 }
2971                 else
2972                 {
2973                     temp = transform_source (ctx, source_with_path_str);
2974
2975                     if (temp == NULL)
2976                         value = transform_error;
2977                     else
2978                     {
2979                         char *temp2, *temp3, *repl_dest;
2980
2981                         repl_dest = mc_search_prepare_replace_str2 (ctx->search_handle, dest);
2982                         temp2 = mc_build_filename (repl_dest, temp, NULL);
2983                         g_free (temp);
2984                         g_free (repl_dest);
2985                         temp3 = source_with_path_str;
2986                         source_with_path_str = strutils_shell_unescape (source_with_path_str);
2987                         g_free (temp3);
2988                         temp3 = temp2;
2989                         temp2 = strutils_shell_unescape (temp2);
2990                         g_free (temp3);
2991
2992                         switch (operation)
2993                         {
2994                         case OP_COPY:
2995                             /* we use file_mask_op_follow_links only with OP_COPY */
2996                             {
2997                                 vfs_path_t *vpath;
2998
2999                                 vpath = vfs_path_from_str (source_with_path_str);
3000                                 ctx->stat_func (vpath, &src_stat);
3001                                 vfs_path_free (vpath);
3002                             }
3003                             if (S_ISDIR (src_stat.st_mode))
3004                                 value = copy_dir_dir (tctx, ctx, source_with_path_str, temp2,
3005                                                       TRUE, FALSE, FALSE, NULL);
3006                             else
3007                                 value = copy_file_file (tctx, ctx, source_with_path_str, temp2);
3008                             dest_dirs = free_linklist (dest_dirs);
3009                             break;
3010
3011                         case OP_MOVE:
3012                             if (S_ISDIR (src_stat.st_mode))
3013                                 value = move_dir_dir (tctx, ctx, source_with_path_str, temp2);
3014                             else
3015                                 value = move_file_file (tctx, ctx, source_with_path_str, temp2);
3016                             break;
3017
3018                         default:
3019                             /* Unknown file operation */
3020                             abort ();
3021                         }
3022
3023                         g_free (temp2);
3024                     }
3025                 }               /* Copy or move operation */
3026
3027                 if (value == FILE_ABORT)
3028                     break;
3029
3030                 if (value == FILE_CONT)
3031                     do_file_mark (panel, i, 0);
3032
3033                 if (verbose && ctx->dialog_type == FILEGUI_DIALOG_MULTI_ITEM)
3034                 {
3035                     file_progress_show_count (ctx, tctx->progress_count, ctx->progress_count);
3036                     file_progress_show_total (tctx, ctx, tctx->progress_bytes, FALSE);
3037                 }
3038
3039                 if (operation != OP_DELETE)
3040                     file_progress_show (ctx, 0, 0, "", FALSE);
3041
3042                 if (check_progress_buttons (ctx) == FILE_ABORT)
3043                     break;
3044
3045                 mc_refresh ();
3046             }                   /* Loop for every file */
3047         }
3048     }                           /* Many entries */
3049
3050   clean_up:
3051     /* Clean up */
3052     if (save_cwd != NULL)
3053     {
3054         tmp_vpath = vfs_path_from_str (save_cwd);
3055         mc_setctl (tmp_vpath, VFS_SETCTL_STALE_DATA, NULL);
3056         vfs_path_free (tmp_vpath);
3057         g_free (save_cwd);
3058     }
3059
3060     if (save_dest != NULL)
3061     {
3062         tmp_vpath = vfs_path_from_str (save_dest);
3063         mc_setctl (tmp_vpath, VFS_SETCTL_STALE_DATA, NULL);
3064         vfs_path_free (tmp_vpath);
3065         g_free (save_dest);
3066     }
3067
3068     linklist = free_linklist (linklist);
3069     dest_dirs = free_linklist (dest_dirs);
3070 #ifdef WITH_FULL_PATHS
3071     g_free (source_with_path_str);
3072     vfs_path_free (source_with_vpath);
3073 #endif /* WITH_FULL_PATHS */
3074     g_free (dest);
3075     vfs_path_free (dest_vpath);
3076     g_free (ctx->dest_mask);
3077     ctx->dest_mask = NULL;
3078
3079 #ifdef ENABLE_BACKGROUND
3080     /* Let our parent know we are saying bye bye */
3081     if (mc_global.we_are_background)
3082     {
3083         int cur_pid = getpid ();
3084         /* Send pid to parent with child context, it is fork and
3085            don't modify real parent ctx */
3086         ctx->pid = cur_pid;
3087         parent_call ((void *) end_bg_process, ctx, 0);
3088
3089         vfs_shut ();
3090         _exit (0);
3091     }
3092 #endif /* ENABLE_BACKGROUND */
3093
3094     file_op_total_context_destroy (tctx);
3095   ret_fast:
3096     file_op_context_destroy (ctx);
3097     g_free (source);
3098
3099     return ret_val;
3100 }
3101
3102 /* }}} */
3103
3104 /* --------------------------------------------------------------------------------------------- */
3105 /* {{{ Query/status report routines */
3106 /** Report error with one file */
3107 FileProgressStatus
3108 file_error (const char *format, const char *file)
3109 {
3110     char buf[BUF_MEDIUM];
3111
3112     g_snprintf (buf, sizeof (buf), format, path_trunc (file, 30), unix_error_string (errno));
3113
3114     return do_file_error (buf);
3115 }
3116
3117 /* --------------------------------------------------------------------------------------------- */
3118
3119 /*
3120    Cause emacs to enter folding mode for this file:
3121    Local variables:
3122    end:
3123  */