1 files changed, 255 insertions, 220 deletions

diff --git a/apps/fileop.c b/apps/fileop.c
index 0d2dc774b9..bcd5202cf4 100644
--- a/apps/fileop.c
+++ b/apps/fileop.c
@@ -1,10 +1,10 @@
 /***************************************************************************
- *             __________               __   ___.                  
- *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___  
- *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /  
- *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <   
- *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \  
- *                     \/            \/     \/    \/            \/ 
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
  * $Id$
  *
  * Copyright (C) 2002 Björn Stenberg
@@ -26,6 +26,7 @@
 #include <string.h>
 #include "string-extra.h"
 #include "debug.h"
+#include "powermgmt.h"
 
 #include "misc.h"
 #include "plugin.h"
@@ -44,38 +45,77 @@
 struct file_op_params
 {
     char   path[MAX_PATH]; /* Buffer for full path */
+    const char*  toplevel_name;
     bool   is_dir;
     int    objects;        /* how many files and subdirectories*/
     int    processed;
+    unsigned long long total_size;
+    unsigned long long processed_size;
     size_t append;         /* Append position in 'path' for stack push */
+    size_t extra_len;      /* Length added by dst path compared to src */
 };
 
-static bool poll_cancel_action(const char *path, int operation, int current, int total)
+static int prompt_name(char* buf, size_t bufsz)
 {
-    const char *op_str = "";
-
-    clear_screen_buffer(false);
-
-    if (operation == FOC_COPY)
-        op_str = str(LANG_COPYING);
-    else if (operation == FOC_MOVE)
-        op_str = str(LANG_MOVING);
-    else if (operation == FOC_COUNT)
-        op_str = str(LANG_SCANNING_DISK);
-    else if (operation == FOC_DELETE)
-        op_str = str(LANG_DELETING);
+    if (kbd_input(buf, bufsz, NULL) < 0)
+        return FORC_CANCELLED;
+    /* at least prevent escapes out of the base directory from keyboard-
+       entered filenames; the file code should reject other invalidities */
+    if (*buf != '\0' && !strchr(buf, PATH_SEPCH) && !is_dotdir_name(buf))
+        return FORC_SUCCESS;
+    return FORC_UNKNOWN_FAILURE;
+}
 
-    path_basename(path, &path);
+static bool poll_cancel_action(int operation, struct file_op_params *param)
+{
+    static unsigned long last_tick;
 
-    if (total <= 0)
-        splashf(0, "%s (%d) %s", op_str, current, path);
+    if (operation == FOC_COUNT)
+    {
+        if (param->objects <= 1)
+            last_tick = current_tick;
+        else if (TIME_AFTER(current_tick, last_tick + HZ/2))
+        {
+            clear_screen_buffer(false);
+            splashf(0, "%s (%d)", str(LANG_SCANNING_DISK), param->objects);
+            last_tick = current_tick;
+        }
+    }
     else
-        splash_progress(current, total, "%s %s", op_str, path);
+    {
+        const char *op_str = (operation == FOC_DELETE) ? str(LANG_DELETING) :
+                             (operation == FOC_COPY) ? str(LANG_COPYING) :
+                             str(LANG_MOVING); 
 
+        if ((operation == FOC_DELETE || !param->total_size) &&
+            param->objects > 0)
+        {
+            splash_progress(param->processed, param->objects,
+                            "%s %s", op_str, param->toplevel_name);
+        }
+        else if (param->total_size >= 10 * 1024 * 1024)
+        {
+            int total_shft = (int) (param->total_size >> 15);
+            int current_shft = (int) (param->processed_size >> 15);
+            splash_progress(current_shft, total_shft,
+                            "%s %s (%d MiB)\n%d MiB",
+                            op_str, param->toplevel_name,
+                            total_shft >> 5, current_shft >> 5);
+        }
+        else if (param->total_size >= 1024)
+        {
+            int total_kib = (int) (param->total_size >> 10);
+            int current_kib = (int) (param->processed_size >> 10);
+            splash_progress(current_kib, total_kib,
+                            "%s %s (%d KiB)\n%d KiB",
+                            op_str, param->toplevel_name,
+                            total_kib, current_kib);
+        }
+    }
     return ACTION_STD_CANCEL == get_action(CONTEXT_STD, TIMEOUT_NOBLOCK);
 }
 
-static struct file_op_params* init_file_op(struct file_op_params *param,
+static void init_file_op(struct file_op_params *param,
                                     const char *basename,
                                     const char *selected_file)
 {
@@ -83,15 +123,21 @@ static struct file_op_params* init_file_op(struct file_op_params *param,
     if (selected_file == NULL)
     {
         param->append = strlcpy(param->path, basename, sizeof (param->path));
+        path_basename(basename, &basename);
+        param->toplevel_name = basename;
     }
     else
+    {
         param->append = path_append(param->path, basename,
                                     selected_file, sizeof (param->path));
+        param->toplevel_name = selected_file;
+    }
     param->is_dir = dir_exists(param->path);
+    param->extra_len = 0;
     param->objects = 0; /* how many files and subdirectories*/
     param->processed = 0;
-
-    return param;
+    param->total_size = 0;
+    param->processed_size = 0;
 }
 
 /* counts file objects, deletes file objects */
@@ -144,10 +190,10 @@ static int directory_fileop(struct file_op_params *param, enum file_op_current f
 
             if (info.attribute & ATTR_DIRECTORY) {
                 /* remove a subdirectory */
-                rc = directory_fileop(param, fileop);
+                rc = directory_fileop(param, fileop); /* recursion */
             } else {
                 /* remove a file */
-                if (poll_cancel_action(param->path, FOC_DELETE, param->processed, param->objects))
+                if (poll_cancel_action(FOC_DELETE, param))
                 {
                     rc = FORC_CANCELLED;
                     break;
@@ -158,21 +204,22 @@ static int directory_fileop(struct file_op_params *param, enum file_op_current f
         else /* count objects */
         {
             param->objects++;
+            param->total_size += info.size;
 
-            if (param->append >= sizeof (param->path)) {
+            if (poll_cancel_action(FOC_COUNT, param))
+            {
+                rc = FORC_CANCELLED;
+                break;
+            }
+
+            if (param->append + param->extra_len >= sizeof (param->path)) {
                 rc = FORC_PATH_TOO_LONG;
                 break; /* no space left in buffer */
             }
 
             if (info.attribute & ATTR_DIRECTORY) {
-                /* remove a subdirectory */
-                rc = directory_fileop(param, FOC_COUNT);
-            } else {
-                if (poll_cancel_action(param->path, FOC_COUNT, param->objects, 0))
-                {
-                    rc = FORC_CANCELLED;
-                    break;
-                }
+                /* enter subdirectory */
+                rc = directory_fileop(param, FOC_COUNT); /* recursion */
             }
         }
         param->append = append; /* other functions may use param, reset append */
@@ -184,7 +231,7 @@ static int directory_fileop(struct file_op_params *param, enum file_op_current f
 
     if (fileop == FOC_DELETE && rc == FORC_SUCCESS) {
         /* remove the now empty directory */
-        if (poll_cancel_action(param->path, FOC_DELETE, param->processed, param->objects))
+        if (poll_cancel_action(FOC_DELETE, param))
         {
             rc = FORC_CANCELLED;
         } else {
@@ -195,161 +242,54 @@ static int directory_fileop(struct file_op_params *param, enum file_op_current f
     return rc;
 }
 
+/* Walk a directory tree and count the number of objects (dirs & files)
+ * also check that enough resources exist to do an operation */
 static int check_count_fileobjects(struct file_op_params *param)
 {
+    cpu_boost(true);
     int rc = directory_fileop(param, FOC_COUNT);
+    cpu_boost(false);
     DEBUGF("%s res:(%d) objects %d \n", __func__, rc, param->objects);
     return rc;
 }
 
-static bool check_new_name(const char *basename)
-{
-    /* at least prevent escapes out of the base directory from keyboard-
-       entered filenames; the file code should reject other invalidities */
-    return *basename != '\0' && !strchr(basename, PATH_SEPCH) &&
-           !is_dotdir_name(basename);
-}
-
-int create_dir(void)
-{
-    int rc = FORC_UNKNOWN_FAILURE;
-    char dirname[MAX_PATH];
-    size_t pathlen = path_append(dirname, getcwd(NULL, 0), PA_SEP_HARD,
-                                 sizeof (dirname));
-    char *basename = dirname + pathlen;
-
-    if (pathlen >= sizeof (dirname)) {
-        /* Too long */
-    } else if (kbd_input(basename, sizeof (dirname) - pathlen, NULL) < 0) {
-        rc = FORC_CANCELLED;
-    } else if (check_new_name(basename)) {
-        rc = mkdir(dirname);
-    }
-
-    return rc;
-}
-
-/************************************************************************************/
-/* share code for file and directory deletion, saves space */
-static int delete_file_dir(struct file_op_params *param)
-{
-    /* Note: delete_file_dir() will happily delete whatever
-     * path is passed (after confirmation) */
-    if (confirm_delete_yesno(param->path) != YESNO_YES) {
-        return FORC_CANCELLED;
-    }
-
-    clear_screen_buffer(true);
-    poll_cancel_action(param->path, FOC_DELETE, param->processed, param->objects);
-
-    int rc = FORC_UNKNOWN_FAILURE;
-
-    if (param->is_dir) { /* if directory */
-        cpu_boost(true);
-        rc = directory_fileop(param, FOC_DELETE);
-        cpu_boost(false);
-    } else {
-        rc = remove(param->path);
-    }
-
-    return rc;
-}
-
-int delete_fileobject(const char *selected_file)
-{
-    struct file_op_params param;
-    if (init_file_op(&param, selected_file, NULL)->is_dir == true)
-    {
-        int rc = check_count_fileobjects(&param);
-        DEBUGF("%s res: %d, ct: %d, %s", __func__, rc, param.objects, param.path);
-        if (rc != FORC_SUCCESS)
-            return rc;
-    }
-
-    return delete_file_dir(&param);
-}
-
-int rename_file(const char *selected_file)
-{
-    int rc = FORC_UNKNOWN_FAILURE;
-    char newname[MAX_PATH];
-    const char *oldbase, *selection = selected_file;
-
-    path_basename(selection, &oldbase);
-    size_t pathlen = oldbase - selection;
-    char *newbase = newname + pathlen;
-
-    if (strmemccpy(newname, selection, sizeof (newname)) == NULL) {
-        /* Too long */
-    } else if (kbd_input(newbase, sizeof (newname) - pathlen, NULL) < 0) {
-        rc = FORC_CANCELLED;
-    } else if (!strcmp(oldbase, newbase)) {
-        rc = FORC_NOOP; /* No change at all */
-    } else if (check_new_name(newbase)) {
-        switch (relate(selection, newname))
-        {
-        case RELATE_DIFFERENT:
-            if (file_exists(newname)) {
-                break; /* don't overwrite */
-            }
-            /* Fall-through */
-        case RELATE_SAME:
-            rc = rename(selection, newname);
-            break;
-        case RELATE_PREFIX:
-        default:
-            break;
-        }
-    }
-
-    return rc;
-}
-
-static int move_by_rename(const char *src_path,
+/* Attempt to just rename a file or directory */
+static int move_by_rename(struct file_op_params *src,
                           const char *dst_path,
                           unsigned int *pflags)
 {
     unsigned int flags = *pflags;
     int rc = FORC_UNKNOWN_FAILURE;
-    while (!(flags & (PASTE_COPY | PASTE_EXDEV))) {
+    reset_poweroff_timer();
+    if (!(flags & (PASTE_COPY | PASTE_EXDEV))) {
         if ((flags & PASTE_OVERWRITE) || !file_exists(dst_path)) {
             /* Just try to move the directory / file */
-            if (poll_cancel_action(src_path, FOC_MOVE, 0 , 0)) {
-                rc = FORC_CANCELLED;
-            } else {
-                rc = rename(src_path, dst_path);
-            }
-
-            if (rc < 0) {
-                int errnum = errno;
-                if (errnum == ENOTEMPTY && (flags & PASTE_OVERWRITE)) {
-                    /* Directory is not empty thus rename() will not do a quick
-                       overwrite */
-                    break;
-                }
-            #ifdef HAVE_MULTIVOLUME
-                else if (errnum == EXDEV) {
-                    /* Failed because cross volume rename doesn't work; force
-                       a move instead */
-                    *pflags |= PASTE_EXDEV;
-                    break;
-                }
-            #endif /* HAVE_MULTIVOLUME */
+            rc = rename(src->path, dst_path);
+#ifdef HAVE_MULTIVOLUME
+            if (rc < FORC_SUCCESS && errno == EXDEV) {
+                /* Failed because cross volume rename doesn't work */
+                *pflags |= PASTE_EXDEV; /* force a move instead */
             }
+#endif /* HAVE_MULTIVOLUME */
+             /* if (errno == ENOTEMPTY && (flags & PASTE_OVERWRITE)) {
+              * Directory is not empty thus rename() will not do a quick overwrite */
         }
 
-        break;
     }
     return rc;
 }
 
 /* Paste a file */
-static int copy_move_file(const char *src_path, const char *dst_path, unsigned int flags)
+static int copy_move_file(struct file_op_params *src, const char *dst_path,
+                          unsigned int flags)
 {
     /* Try renaming first */
-    int rc = move_by_rename(src_path, dst_path, &flags);
+    int rc = move_by_rename(src, dst_path, &flags);
     if (rc == FORC_SUCCESS)
+    {
+        src->total_size = 0; /* switch from counting size to number of items */
         return rc;
+    }
 
     /* See if we can get the plugin buffer for the file copy buffer */
     size_t buffersize;
@@ -365,12 +305,13 @@ static int copy_move_file(const char *src_path, const char *dst_path, unsigned i
         return FORC_NO_BUFFER_AVAIL;
     }
 
-    buffersize &= ~0x1ff;  /* Round buffer size to multiple of sector
-                              size */
+    buffersize &= ~0x1ff;  /* Round buffer size to multiple of sector size */
 
-    int src_fd = open(src_path, O_RDONLY);
+    int src_fd = open(src->path, O_RDONLY);
     if (src_fd >= 0) {
         off_t src_sz = lseek(src_fd, 0, SEEK_END);
+        if (!src->total_size && !src->processed) /* single file copy */
+            src->total_size = src_sz;
         lseek(src_fd, 0, SEEK_SET);
 
         int oflag = O_WRONLY|O_CREAT;
@@ -389,9 +330,8 @@ static int copy_move_file(const char *src_path, const char *dst_path, unsigned i
             while (rc == FORC_SUCCESS) {
                 if (total_size >= next_cancel_test) {
                     next_cancel_test = total_size + 0x10000;
-                    if (poll_cancel_action(src_path,
-                                        !(flags & PASTE_COPY) ? FOC_MOVE : FOC_COPY,
-                                        total_size, src_sz))
+                    if (poll_cancel_action(!(flags & PASTE_COPY) ?
+                                           FOC_MOVE : FOC_COPY, src))
                     {
                        rc = FORC_CANCELLED;
                        break;
@@ -415,6 +355,7 @@ static int copy_move_file(const char *src_path, const char *dst_path, unsigned i
                 }
 
                 total_size += byteswritten;
+                src->processed_size += byteswritten;
 
                 if (bytesread < (ssize_t)buffersize) {
                     /* EOF with trailing bytes */
@@ -423,9 +364,12 @@ static int copy_move_file(const char *src_path, const char *dst_path, unsigned i
             }
 
             if (rc == FORC_SUCCESS) {
-                /* If overwriting, set the correct length if original was
-                   longer */
-                rc = ftruncate(dst_fd, total_size) * 10;
+                if (total_size != src_sz)
+                    rc = FORC_UNKNOWN_FAILURE;
+                else {
+                /* If overwriting, set the correct length if original was longer */
+                    rc = ftruncate(dst_fd, total_size) * 10;
+                }
             }
 
             close(dst_fd);
@@ -441,7 +385,7 @@ static int copy_move_file(const char *src_path, const char *dst_path, unsigned i
 
     if (rc == FORC_SUCCESS && !(flags & PASTE_COPY)) {
         /* Remove the source file */
-        rc = remove(src_path) * 10;
+        rc = remove(src->path) * 10;
     }
 
     return rc;
@@ -449,20 +393,19 @@ static int copy_move_file(const char *src_path, const char *dst_path, unsigned i
 
 /* Paste a directory */
 static int copy_move_directory(struct file_op_params *src,
-                                    struct file_op_params *dst,
-                                    unsigned int flags)
+                               struct file_op_params *dst,
+                                        unsigned int flags)
 {
-    int rc = FORC_UNKNOWN_FAILURE;
-
     DIR *srcdir = opendir(src->path);
 
-    if (srcdir) {
-        /* Make a directory to copy things to */
-        rc = mkdir(dst->path) * 10;
-        if (rc < 0 && errno == EEXIST && (flags & PASTE_OVERWRITE)) {
-            /* Exists and overwrite was approved */
-            rc = FORC_SUCCESS;
-        }
+    if (!srcdir)
+        return FORC_PATH_NOT_EXIST;
+
+    /* Make a directory to copy things to */
+    int rc = mkdir(dst->path) * 10;
+    if (rc < 0 && errno == EEXIST && (flags & PASTE_OVERWRITE)) {
+        /* Exists and overwrite was approved */
+        rc = FORC_SUCCESS;
     }
 
     size_t srcap = src->append, dstap = dst->append;
@@ -488,7 +431,7 @@ static int copy_move_directory(struct file_op_params *src,
         /* Append names to current directories */
         src->append = srcap +
             path_append(&src->path[srcap], PA_SEP_HARD, entry->d_name,
-                        sizeof(src->path) - srcap);
+                        sizeof (src->path) - srcap);
 
         dst->append = dstap +
             path_append(&dst->path[dstap], PA_SEP_HARD, entry->d_name,
@@ -506,9 +449,8 @@ static int copy_move_directory(struct file_op_params *src,
             break;
         }
 
-        if (poll_cancel_action(src->path,
-                                    !(flags & PASTE_COPY) ? FOC_MOVE : FOC_COPY,
-                                    src->processed, src->objects))
+        if (poll_cancel_action(!(flags & PASTE_COPY) ?
+                               FOC_MOVE : FOC_COPY, src))
         {
             rc = FORC_CANCELLED;
             break;
@@ -517,11 +459,12 @@ static int copy_move_directory(struct file_op_params *src,
         DEBUGF("Copy %s to %s\n", src->path, dst->path);
 
         if (info.attribute & ATTR_DIRECTORY) {
+            src->processed_size += info.size;
             /* Copy/move a subdirectory */
             rc = copy_move_directory(src, dst, flags); /* recursion */;
         } else {
             /* Copy/move a file */
-            rc = copy_move_file(src->path, dst->path, flags);
+            rc = copy_move_file(src, dst->path, flags);
         }
 
         /* Remove basenames we added above */
@@ -538,13 +481,16 @@ static int copy_move_directory(struct file_op_params *src,
     return rc;
 }
 
+/************************************************************************************/
+/* PUBLIC FUNCTIONS                                                                 */
+/************************************************************************************/
+
+/* Copy or move a file or directory see: file_op_flags */
 int copy_move_fileobject(const char *src_path, const char *dst_path, unsigned int flags)
 {
     if (!src_path[0])
         return FORC_NOOP;
 
-    int rc = FORC_UNKNOWN_FAILURE;
-
     struct file_op_params src, dst;
 
     /* Figure out the name of the selection */
@@ -553,54 +499,143 @@ int copy_move_fileobject(const char *src_path, const char *dst_path, unsigned in
 
     /* Final target is current directory plus name of selection  */
     init_file_op(&dst, dst_path, nameptr);
+    if (dst.append >= sizeof (dst.path))
+        return FORC_PATH_TOO_LONG;
 
-    switch (dst.append < sizeof (dst.path) ?
-                relate(src_path, dst.path) : FORC_PATH_TOO_LONG)
-    {
-    case RELATE_SAME:
-        rc = FORC_NOOP;
-        break;
+    int rel = relate(src_path, dst.path);
+    if (rel == RELATE_SAME)
+        return FORC_NOOP;
 
-    case RELATE_DIFFERENT:
+    if (rel == RELATE_DIFFERENT) {
+        int rc;
         if (file_exists(dst.path)) {
             /* If user chooses not to overwrite, cancel */
             if (confirm_overwrite_yesno() == YESNO_NO) {
-                rc = FORC_NOOVERWRT;
-                break;
+                return FORC_NOOVERWRT;
             }
 
             flags |= PASTE_OVERWRITE;
         }
 
+        init_file_op(&src, src_path, NULL);
+        if (src.append >= sizeof (src.path))
+            return FORC_PATH_TOO_LONG;
         /* Now figure out what we're doing */
         cpu_boost(true);
-
-        init_file_op(&src, src_path, NULL);
-
         if (src.is_dir) {
             /* Copy or move a subdirectory */
-
-            if (src.append < sizeof (src.path)) {
-                /* Try renaming first */
-                rc = move_by_rename(src.path, dst.path, &flags);
-                if (rc != FORC_SUCCESS && rc != FORC_CANCELLED) {
-                     if (check_count_fileobjects(&src) == FORC_SUCCESS) {
-                        rc = copy_move_directory(&src, &dst, flags);
-                    }
+            /* Try renaming first */
+            rc = move_by_rename(&src, dst.path, &flags);
+            if (rc < FORC_SUCCESS) {
+                int extra_len = dst.append - src.append;
+                if (extra_len > 0)
+                    src.extra_len = extra_len;
+
+                rc = check_count_fileobjects(&src);
+                if (rc == FORC_SUCCESS) {
+                    rc = copy_move_directory(&src, &dst, flags);
                 }
             }
         } else {
             /* Copy or move a file */
-            rc = copy_move_file(src_path, dst.path, flags);
+            rc = copy_move_file(&src, dst.path, flags);
         }
 
         cpu_boost(false);
-        break;
+        DEBUGF("%s res: %d, ct: %d/%d %s\n",
+               __func__, rc, src.objects, src.processed, src.path);
+        return rc;
+    }
+
+    /* Else Some other relation / failure */
+    DEBUGF("%s res: %d, rel: %d\n", __func__, FORC_UNKNOWN_FAILURE, rel);
+    return FORC_UNKNOWN_FAILURE;
+}
+
+int create_dir(void)
+{
+    int rc;
+    char dirname[MAX_PATH];
+    size_t pathlen = path_append(dirname, getcwd(NULL, 0), PA_SEP_HARD,
+                                 sizeof (dirname));
+    char *basename = dirname + pathlen;
+
+    if (pathlen >= sizeof (dirname))
+        return FORC_PATH_TOO_LONG;
+
+    rc = prompt_name(basename, sizeof (dirname) - pathlen);
+    if (rc == FORC_SUCCESS)
+        rc = mkdir(dirname) * 10;
+    return rc;
+}
+
+/* share code for file and directory deletion, saves space */
+int delete_fileobject(const char *selected_file)
+{
+    int rc;
+    struct file_op_params param;
+    init_file_op(&param, selected_file, NULL);
+    if (param.append >= sizeof (param.path))
+        return FORC_PATH_TOO_LONG;
 
-    case RELATE_PREFIX:
-    default: /* Some other relation / failure */
-        break;
+    /* Note: delete_fileobject() will happily delete whatever
+     * path is passed (after confirmation) */
+    if (confirm_delete_yesno(param.path) != YESNO_YES) {
+        return FORC_CANCELLED;
+    }
+
+    if (param.is_dir) {
+        int rc = check_count_fileobjects(&param);
+        DEBUGF("%s res: %d, ct: %d, %s", __func__, rc, param.objects, param.path);
+        if (rc != FORC_SUCCESS)
+            return rc;
+    }
+
+    clear_screen_buffer(true);
+
+    if (param.is_dir) { /* if directory */
+        cpu_boost(true);
+        rc = directory_fileop(&param, FOC_DELETE);
+        cpu_boost(false);
+    } else {
+        rc = remove(param.path) * 10;
     }
 
     return rc;
 }
+
+int rename_file(const char *selected_file)
+{
+    int rc;
+    char newname[MAX_PATH];
+    const char *oldbase, *selection = selected_file;
+
+    path_basename(selection, &oldbase);
+    size_t pathlen = oldbase - selection;
+    char *newbase = newname + pathlen;
+
+    if (strmemccpy(newname, selection, sizeof (newname)) == NULL)
+        return FORC_PATH_TOO_LONG;
+
+    rc = prompt_name(newbase, sizeof (newname) - pathlen);
+
+    if (rc != FORC_SUCCESS)
+        return rc;
+
+    if (!strcmp(oldbase, newbase))
+        return FORC_NOOP; /* No change at all */
+
+    int rel = relate(selection, newname);
+    if (rel == RELATE_DIFFERENT)
+    {
+        if (file_exists(newname)) { /* don't overwrite */
+            return FORC_PATH_EXISTS;
+        }
+        return rename(selection, newname) * 10;
+    }
+    if (rel == RELATE_SAME)
+        return rename(selection, newname) * 10;
+
+    /* Else Some other relation / failure */
+    return FORC_UNKNOWN_FAILURE;
+}