1 files changed, 606 insertions, 0 deletions

diff --git a/apps/fileop.c b/apps/fileop.c
new file mode 100644
index 0000000000..0d2dc774b9
--- /dev/null
+++ b/apps/fileop.c
@@ -0,0 +1,606 @@
+/***************************************************************************
+ *             __________               __   ___.                  
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___  
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /  
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <   
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \  
+ *                     \/            \/     \/    \/            \/ 
+ * $Id$
+ *
+ * Copyright (C) 2002 Björn Stenberg
+ * Copyright (C) 2024 William Wilgus
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+#include <stdbool.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "string-extra.h"
+#include "debug.h"
+
+#include "misc.h"
+#include "plugin.h"
+#include "dir.h"
+#include "tree.h"
+#include "fileop.h"
+#include "pathfuncs.h"
+
+#include "settings.h"
+#include "lang.h"
+#include "yesno.h"
+#include "splash.h"
+#include "keyboard.h"
+
+/* Used for directory move, copy and delete */
+struct file_op_params
+{
+    char   path[MAX_PATH]; /* Buffer for full path */
+    bool   is_dir;
+    int    objects;        /* how many files and subdirectories*/
+    int    processed;
+    size_t append;         /* Append position in 'path' for stack push */
+};
+
+static bool poll_cancel_action(const char *path, int operation, int current, int total)
+{
+    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);
+
+    path_basename(path, &path);
+
+    if (total <= 0)
+        splashf(0, "%s (%d) %s", op_str, current, path);
+    else
+        splash_progress(current, total, "%s %s", op_str, path);
+
+    return ACTION_STD_CANCEL == get_action(CONTEXT_STD, TIMEOUT_NOBLOCK);
+}
+
+static struct file_op_params* init_file_op(struct file_op_params *param,
+                                    const char *basename,
+                                    const char *selected_file)
+{
+    /* Assumes: basename will never be NULL */
+    if (selected_file == NULL)
+    {
+        param->append = strlcpy(param->path, basename, sizeof (param->path));
+    }
+    else
+        param->append = path_append(param->path, basename,
+                                    selected_file, sizeof (param->path));
+    param->is_dir = dir_exists(param->path);
+    param->objects = 0; /* how many files and subdirectories*/
+    param->processed = 0;
+
+    return param;
+}
+
+/* counts file objects, deletes file objects */
+static int directory_fileop(struct file_op_params *param, enum file_op_current fileop)
+{
+    errno = 0;
+    DIR *dir = opendir(param->path);
+    if (!dir) {
+            if (errno == EMFILE) {
+                return FORC_TOO_MANY_SUBDIRS;
+            }
+        return FORC_PATH_NOT_EXIST; /* open error */
+    }
+    int rc = FORC_SUCCESS;
+    size_t append = param->append;
+
+    /* walk through the directory content */
+    while (rc == FORC_SUCCESS) {
+        errno = 0; /* distinguish failure from eod */
+        struct dirent *entry = readdir(dir);
+        if (!entry) {
+            if (errno) {
+                rc = FORC_PATH_NOT_EXIST;
+            }
+            break;
+        }
+
+        struct dirinfo info = dir_get_info(dir, entry);
+        if ((info.attribute & ATTR_DIRECTORY) &&
+            is_dotdir_name(entry->d_name)) {
+            continue; /* skip these */
+        }
+
+        /* append name to current directory */
+        param->append = append + path_append(&param->path[append],
+                                            PA_SEP_HARD, entry->d_name,
+                                            sizeof (param->path) - append);
+
+        if (fileop == FOC_DELETE)
+        {
+            param->processed++;
+            /* at this point we've already counted and never had a path too long
+               in the other branch so we 'should not' encounter one here either */
+
+            if (param->processed > param->objects)
+            {
+                rc = FORC_UNKNOWN_FAILURE;
+                break;
+            }
+
+            if (info.attribute & ATTR_DIRECTORY) {
+                /* remove a subdirectory */
+                rc = directory_fileop(param, fileop);
+            } else {
+                /* remove a file */
+                if (poll_cancel_action(param->path, FOC_DELETE, param->processed, param->objects))
+                {
+                    rc = FORC_CANCELLED;
+                    break;
+                }
+                rc = remove(param->path);
+            }
+        }
+        else /* count objects */
+        {
+            param->objects++;
+
+            if (param->append >= 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;
+                }
+            }
+        }
+        param->append = append; /* other functions may use param, reset append */
+        /* Remove basename we added above */
+        param->path[append] = '\0';
+    }
+
+    closedir(dir);
+
+    if (fileop == FOC_DELETE && rc == FORC_SUCCESS) {
+        /* remove the now empty directory */
+        if (poll_cancel_action(param->path, FOC_DELETE, param->processed, param->objects))
+        {
+            rc = FORC_CANCELLED;
+        } else {
+            rc = rmdir(param->path);
+        }
+    }
+
+    return rc;
+}
+
+static int check_count_fileobjects(struct file_op_params *param)
+{
+    int rc = directory_fileop(param, FOC_COUNT);
+    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,
+                          const char *dst_path,
+                          unsigned int *pflags)
+{
+    unsigned int flags = *pflags;
+    int rc = FORC_UNKNOWN_FAILURE;
+    while (!(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 */
+            }
+        }
+
+        break;
+    }
+    return rc;
+}
+
+/* Paste a file */
+static int copy_move_file(const char *src_path, const char *dst_path, unsigned int flags)
+{
+    /* Try renaming first */
+    int rc = move_by_rename(src_path, dst_path, &flags);
+    if (rc == FORC_SUCCESS)
+        return rc;
+
+    /* See if we can get the plugin buffer for the file copy buffer */
+    size_t buffersize;
+    char *buffer = (char *) plugin_get_buffer(&buffersize);
+    if (buffer == NULL || buffersize < 512) {
+        /* Not large enough, try for a disk sector worth of stack
+           instead */
+        buffersize = 512;
+        buffer = (char *)alloca(buffersize);
+    }
+
+    if (buffer == NULL) {
+        return FORC_NO_BUFFER_AVAIL;
+    }
+
+    buffersize &= ~0x1ff;  /* Round buffer size to multiple of sector
+                              size */
+
+    int src_fd = open(src_path, O_RDONLY);
+    if (src_fd >= 0) {
+        off_t src_sz = lseek(src_fd, 0, SEEK_END);
+        lseek(src_fd, 0, SEEK_SET);
+
+        int oflag = O_WRONLY|O_CREAT;
+
+        if (!(flags & PASTE_OVERWRITE)) {
+            oflag |= O_EXCL;
+        }
+
+        int dst_fd = open(dst_path, oflag, 0666);
+        if (dst_fd >= 0) {
+            off_t total_size = 0;
+            off_t next_cancel_test = 0; /* No excessive button polling */
+
+            rc = FORC_SUCCESS;
+
+            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))
+                    {
+                       rc = FORC_CANCELLED;
+                       break;
+                    }
+                }
+
+                ssize_t bytesread = read(src_fd, buffer, buffersize);
+                if (bytesread <= 0) {
+                    if (bytesread < 0) {
+                        rc = FORC_READ_FAILURE;
+                    }
+                    /* else eof on buffer boundary; nothing to write */
+                    break;
+                }
+
+                ssize_t byteswritten = write(dst_fd, buffer, bytesread);
+                if (byteswritten < bytesread) {
+                    /* Some I/O error */
+                    rc = FORC_WRITE_FAILURE;
+                    break;
+                }
+
+                total_size += byteswritten;
+
+                if (bytesread < (ssize_t)buffersize) {
+                    /* EOF with trailing bytes */
+                    break;
+                }
+            }
+
+            if (rc == FORC_SUCCESS) {
+                /* If overwriting, set the correct length if original was
+                   longer */
+                rc = ftruncate(dst_fd, total_size) * 10;
+            }
+
+            close(dst_fd);
+
+            if (rc != FORC_SUCCESS) {
+                /* Copy failed. Cleanup. */
+                remove(dst_path);
+            }
+        }
+
+        close(src_fd);
+    }
+
+    if (rc == FORC_SUCCESS && !(flags & PASTE_COPY)) {
+        /* Remove the source file */
+        rc = remove(src_path) * 10;
+    }
+
+    return rc;
+}
+
+/* Paste a directory */
+static int copy_move_directory(struct file_op_params *src,
+                                    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;
+        }
+    }
+
+    size_t srcap = src->append, dstap = dst->append;
+
+    /* Walk through the directory content; this loop will exit as soon as
+       there's a problem */
+    while (rc == FORC_SUCCESS) {
+        errno = 0; /* Distinguish failure from eod */
+        struct dirent *entry = readdir(srcdir);
+        if (!entry) {
+            if (errno) {
+                rc = FORC_PATH_NOT_EXIST;
+            }
+            break;
+        }
+
+        struct dirinfo info = dir_get_info(srcdir, entry);
+        if ((info.attribute & ATTR_DIRECTORY) &&
+            is_dotdir_name(entry->d_name)) {
+            continue; /* Skip these */
+        }
+
+        /* Append names to current directories */
+        src->append = srcap +
+            path_append(&src->path[srcap], PA_SEP_HARD, entry->d_name,
+                        sizeof(src->path) - srcap);
+
+        dst->append = dstap +
+            path_append(&dst->path[dstap], PA_SEP_HARD, entry->d_name,
+                        sizeof (dst->path) - dstap);
+        /* src length was already checked by check_count_fileobjects() */
+        if (dst->append >= sizeof (dst->path)) {
+            rc = FORC_PATH_TOO_LONG; /* No space left in buffer */
+            break;
+        }
+
+        src->processed++;
+        if (src->processed > src->objects)
+        {
+            rc = FORC_UNKNOWN_FAILURE;
+            break;
+        }
+
+        if (poll_cancel_action(src->path,
+                                    !(flags & PASTE_COPY) ? FOC_MOVE : FOC_COPY,
+                                    src->processed, src->objects))
+        {
+            rc = FORC_CANCELLED;
+            break;
+        }
+
+        DEBUGF("Copy %s to %s\n", src->path, dst->path);
+
+        if (info.attribute & ATTR_DIRECTORY) {
+            /* 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);
+        }
+
+        /* Remove basenames we added above */
+        src->path[srcap] = '\0';
+        dst->path[dstap] = '\0';
+    }
+
+    if (rc == FORC_SUCCESS && !(flags & PASTE_COPY)) {
+        /* Remove the now empty directory */
+        rc = rmdir(src->path) * 10;
+    }
+
+    closedir(srcdir);
+    return rc;
+}
+
+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 */
+    const char *nameptr;
+    path_basename(src_path, &nameptr);
+
+    /* Final target is current directory plus name of selection  */
+    init_file_op(&dst, dst_path, nameptr);
+
+    switch (dst.append < sizeof (dst.path) ?
+                relate(src_path, dst.path) : FORC_PATH_TOO_LONG)
+    {
+    case RELATE_SAME:
+        rc = FORC_NOOP;
+        break;
+
+    case RELATE_DIFFERENT:
+        if (file_exists(dst.path)) {
+            /* If user chooses not to overwrite, cancel */
+            if (confirm_overwrite_yesno() == YESNO_NO) {
+                rc = FORC_NOOVERWRT;
+                break;
+            }
+
+            flags |= PASTE_OVERWRITE;
+        }
+
+        /* 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);
+                    }
+                }
+            }
+        } else {
+            /* Copy or move a file */
+            rc = copy_move_file(src_path, dst.path, flags);
+        }
+
+        cpu_boost(false);
+        break;
+
+    case RELATE_PREFIX:
+    default: /* Some other relation / failure */
+        break;
+    }
+
+    return rc;
+}