[Feature] onplay.c show file progress

first some clean-up of onplay.c

extend/move fileobject copy, move, delete routines in prep for other users

add error checking, better error codes
pre scan to make sure the operation doesn't exceed system resources
show progress for file and directory copies

Change-Id: Ife2e62df554892dab651bab40433bf70b27e73ff

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;
+}