/*
- * (C) Copyright 2014,2016 Leo C. <erbl259-lmu@yahoo.de>
+ * (C) Copyright 2014,2016,2018 Leo C. <erbl259-lmu@yahoo.de>
*
* SPDX-License-Identifier: GPL-2.0
*/
*/
#include "cmd_fat.h"
+#include <util/delay.h>
#include "ff.h"
#include "z80-if.h"
#include "env.h"
#include "getopt-min.h"
-/* TODO: use memory size test function (cmd_mem.c) */
-#define MAX_MEMORY (1ul << 19)
+
+#define DEBUG_CP 1 /* set to 1 to debug */
+#define DEBUG_LS 1 /* set to 1 to debug */
+
+#define debug_cp(fmt, args...) \
+ debug_cond(DEBUG_CP, fmt, ##args)
+#define debug_ls(fmt, args...) \
+ debug_cond(DEBUG_LS, fmt, ##args)
+
+
+/* TODO: use memory size test function (detect_ramsize() in cmd_loadihex.c) */
+/* TODO: detect_ramsize() should be moved to z80-if.c */
+#define MAX_MEMORY CONFIG_SYS_RAMSIZE_MAX
#define BUFFER_SIZE 512
+#define MAX_PATHLEN CONFIG_SYS_MAX_PATHLEN
+typedef struct {
+ char *p_end; /* pointer to NULL at end of path */
+ char p_path[MAX_PATHLEN + 1]; /* pointer to the start of a path */
+} PATH_T;
+
+/*
+ * Multible (fat) partitions per physical drive are not supported,
+ * but we have up to 2 sdcard slots.
+ */
FATFS FatFs0;
FATFS FatFs1;
-char chur_drv[3];
+uint8_t *blockbuf;
+int blockbuf_size;
+PATH_T from;
+PATH_T to;
+command_ret_t command_ret;
+
+void setup_fatfs(void)
+{
+ f_mount(&FatFs0, "0:", 0);
+ f_mount(&FatFs1, "1:", 0);
+}
DWORD get_fattime (void)
{
}
+static const FLASH char * const FLASH rc_strings[] = {
+ FSTR("OK"),
+ FSTR("disk error"),
+ FSTR("internal error"),
+ FSTR("not ready"),
+ FSTR("no file"),
+ FSTR("no path"),
+ FSTR("invalid name"),
+ FSTR("denied"),
+ FSTR("exist"),
+ FSTR("invalid object"),
+ FSTR("write protected"),
+ FSTR("invalid drive"),
+ FSTR("not enabled"),
+ FSTR("no file system"),
+ FSTR("mkfs aborted"),
+ FSTR("timeout"),
+ FSTR("locked"),
+ FSTR("not enough core"),
+ FSTR("too many open files"),
+ FSTR("invalid parameter")
+ };
+
static const FLASH char * const FLASH rc_names[] = {
FSTR("OK"),
FSTR("DISK_ERR"),
#endif
}
+const FLASH char * rctostr(FRESULT rc)
+{
+ return rc < ARRAY_SIZE(rc_strings) ? rc_strings[rc] : PSTR(" Unknown Error");
+}
-void setup_fatfs(void)
+void err(const char *fmt, ...)
{
- f_mount(&FatFs0, "0:", 0);
- f_mount(&FatFs1, "1:", 0);
+ va_list ap;
+ va_start(ap, fmt);
+// (void)fprintf(stderr, "%s: ", progname);
+ (void)vfprintf_P(stdout, fmt, ap);
+ va_end(ap);
+ (void)printf_P(PSTR("\n"));
+ _delay_ms(20);
+ command_ret = CMD_RET_FAILURE;
}
+/******************************************************************************/
-static void swirl(void)
-{
- static const FLASH char swirlchar[] = { '-','\\','|','/' };
- static uint_fast8_t cnt;
- static uint32_t tstamp;
+/*
+ * These functions manipulate paths in PATH_T structures.
+ *
+ * They eliminate multiple slashes in paths when they notice them,
+ * and keep the path non-slash terminated.
+ *
+ * Both path_set() and path_append() return 0 if the requested name
+ * would be too long.
+ */
- if (get_timer(0) > tstamp) {
- printf_P(PSTR("\b%c"), swirlchar[cnt]);
- cnt = (cnt+1) % ARRAY_SIZE(swirlchar);
- tstamp = get_timer(0) + 250;
- }
+
+static void path_init(void)
+{
+ from.p_end = from.p_path; from.p_path[0] = '\0';
+ to.p_end = to.p_path; to.p_path[0] = '\0';
}
-/* Work register for fs command */
-struct stat_dat_s {
- DWORD AccSize;
- WORD AccFiles, AccDirs;
- FILINFO Finfo;
-};
+static void strip_trailing_slash(PATH_T *p)
+{
+ char *beg = p->p_path;
+ char *end = p->p_end;
+ if ((beg + 2) < end && (*beg & 0x38) == '0' && *(beg+1) == ':')
+ beg += 2;
+ if (beg < end && *beg == '/')
+ ++beg;
+ while (end > beg && end[-1] == '/')
+ *--end = '\0';
+
+ p->p_end =end;
+}
-static
-FRESULT scan_files (
- char *path, /* Pointer to the working buffer with start path */
- struct stat_dat_s *statp
-)
+/*
+ * Move specified string into path. Convert "" to "." to handle BSD
+ * semantics for a null path. Strip trailing slashes.
+ */
+int
+path_set(PATH_T *p, char *string)
{
- DIR dirs;
- FRESULT res;
- int i;
- char *fn;
+ if (strlen(string) > MAX_PATHLEN) {
+ err(PSTR("set: '%s': name too long"), string);
+ return 0;
+ }
- res = f_opendir(&dirs, path);
- swirl();
- if (res == FR_OK) {
- i = strlen(path);
- while (((res = f_readdir(&dirs, &statp->Finfo)) == FR_OK) &&
- statp->Finfo.fname[0]) {
- if (_FS_RPATH && statp->Finfo.fname[0] == '.')
- continue;
- fn = statp->Finfo.fname;
- if (statp->Finfo.fattrib & AM_DIR) {
- statp->AccDirs++;
- path[i] = '/';
- strcpy(path+i+1, fn);
- res = scan_files(path, statp);
- path[i] = '\0';
- if (res != FR_OK)
- break;
- } else {
- //printf_P(PSTR("%s/%s\n"), path, fn);
- statp->AccFiles++;
- statp->AccSize += statp->Finfo.fsize;
- }
- if (check_abort()) {
- res = 255;
- break;
- }
- }
+ (void)strcpy(p->p_path, string);
+ p->p_end = p->p_path + strlen(p->p_path);
+
+ if (p->p_path == p->p_end) {
+ *p->p_end++ = '.';
+ *p->p_end = 0;
}
- return res;
+ strip_trailing_slash(p);
+ return 1;
}
-
/*
- * fatstat path - Show logical drive status
- *
+ * Append specified string to path, inserting '/' if necessary. Return a
+ * pointer to the old end of path for restoration.
*/
-command_ret_t do_stat(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[])
+char *
+path_append(PATH_T *p, char *name)
{
- FATFS *fs;
- DWORD nfreeclst;
- FRESULT res;
- char *buf;
- char *path = "";
- struct stat_dat_s statp;
+ char *old = p->p_end;
+ int len = strlen(name);
- (void) cmdtp; (void) flag; (void) argc;
+ /* The "+ 1" accounts for the '/' between old path and name. */
+ if ((len + p->p_end - p->p_path + 1) > MAX_PATHLEN) {
+ err(PSTR("append: '%s/%s': name too long"), p->p_path, name);
+ return(0);
+ }
- buf = (char *) malloc(BUFFER_SIZE);
- if (buf == NULL) {
- printf_P(PSTR("fat stat: Out of Memory!\n"));
- return CMD_RET_FAILURE;
+ /*
+ * This code should always be executed, since paths shouldn't
+ * end in '/'.
+ */
+ if (p->p_end[-1] != '/') {
+ *p->p_end++ = '/';
+ *p->p_end = '\0';
}
- if (argc > 1)
- path = argv[1];
- res = f_getfree(path, &nfreeclst, &fs);
- if (!res) {
- printf_P(PSTR(
- "FAT type: %u\n"
- "Bytes/Cluster: %lu\n"
- "Number of FATs: %u\n"
- "Root DIR entries: %u\n"
- "Sectors/FAT: %lu\n"
- "Number of clusters: %lu\n"
- "FAT start (lba): %lu\n"
- "DIR start (lba,cluster): %lu\n"
- "Data start (lba): %lu\n"),
- fs->fs_type, (DWORD)fs->csize * 512, fs->n_fats,
- fs->n_rootdir, fs->fsize, fs->n_fatent - 2,
- fs->fatbase, fs->dirbase, fs->database);
+ (void)strncat(p->p_end, name, len);
+ p->p_end += len;
+ *p->p_end = '\0';
-#if _USE_LABEL
- DWORD serial;
- res = f_getlabel(path, buf, &serial);
- if (!res) {
- printf_P(PSTR(
- "Volume name: %s\n"
- "Volume S/N: %04X-%04X\n"),
- buf, (WORD)(serial >> 16), (WORD)(serial & 0xFFFF));
- }
-#endif
- if (!res) {
- my_puts_P(PSTR("\nCounting... "));
- statp.AccSize = statp.AccFiles = statp.AccDirs = 0;
- strcpy(buf, path);
+ strip_trailing_slash(p);
+ return old;
+}
- res = scan_files(buf, &statp);
- }
- if (!res) {
- printf_P(PSTR("\r%u files, %lu bytes.\n%u folders.\n"
- "%lu KB total disk space.\n%lu KB available.\n"),
- statp.AccFiles, statp.AccSize, statp.AccDirs,
- (fs->n_fatent - 2) * (fs->csize / 2), nfreeclst * (fs->csize / 2)
- );
- }
+/*
+ * Restore path to previous value. (As returned by path_append.)
+ */
+void
+path_restore(PATH_T *p, char *old)
+{
+ p->p_end = old;
+ *p->p_end = '\0';
+}
+
+/*
+ * Return basename of path.
+ */
+char *path_basename(PATH_T *p)
+{
+ char *basename = strrchr(p->p_path, '/');
+
+ if (basename) {
+ ++basename;
+ } else {
+ basename = p->p_path;
+ if ((basename[0] & 0x38) == '0' && basename[1] == ':')
+ basename += 2;
}
- free(buf);
- if (res) {
- put_rc(res);
- return CMD_RET_FAILURE;
+ return basename;
+}
+
+
+
+static void swirl(void)
+{
+ static const FLASH char swirlchar[] = { '-','\\','|','/' };
+ static uint_fast8_t cnt;
+ static uint32_t tstamp;
+
+ if (get_timer(0) > tstamp) {
+ printf_P(PSTR("\b%c"), swirlchar[cnt]);
+ cnt = (cnt+1) % ARRAY_SIZE(swirlchar);
+ tstamp = get_timer(0) + 250;
}
- return CMD_RET_SUCCESS;
}
/*
* pwd - Print current directory of the current drive.
*
*/
-command_ret_t do_pwd(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[])
+command_ret_t do_pwd(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc UNUSED, char * const argv[] UNUSED)
{
FRESULT res;
char *buf;
- (void) cmdtp; (void) flag; (void) argc; (void) argv;
-
buf = (char *) malloc(BUFFER_SIZE);
if (buf == NULL) {
printf_P(PSTR("pwd: Out of Memory!\n"));
* cd - Change the current/working directory.
*
*/
-command_ret_t do_cd(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[])
+command_ret_t do_cd(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
{
char *arg;
FRESULT res = 0;
- (void) cmdtp; (void) flag; (void) argc;
-
if (argc < 2) {
arg = getenv_str(PSTR(ENV_HOME));
if (arg == NULL) {
return CMD_RET_SUCCESS;
}
-#define MAX_PATHLEN 255
-
- /* Remove trailing slashes,
- * but keep a leading slash (absolute path)
- */
+#if 0
+/*
+ * Remove trailing slashes,
+ * but keep a leading slash (absolute path)
+ */
void strip_trailing_slash_relpath(char *p)
{
int n = strlen(p);
while (n-- != 0 && p[n] == '/')
p[n] = '\0';
}
+#endif
int print_dirent(FILINFO *f)
{
}
/*
- * fatls path - Directory listing
+ * ls path - Directory listing
*
*/
-command_ret_t do_ls(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[])
+command_ret_t do_ls(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
{
FATFS *fs;
DIR Dir; /* Directory object */
unsigned long p1;
unsigned int s1, s2;
FRESULT res;
- (void) cmdtp; (void) flag; (void) argc;
- char *path = "";
+ path_init();
if (argc > 1)
- path = argv[1];
- strip_trailing_slash_relpath(path);
-
- char *p = strrchr(path, '/');
- if (p)
- p++;
- else {
- p = path;
- char *q = p;
- if ((*q++ & 0x38) == '0' && *q++ == ':')
- p = q;
- }
+ if (!path_set(&from, argv[1])) {
+ /* TODO: error out*/
+ }
- char *pattern = NULL;
+ char *p = path_basename(&from);
if (strpbrk_P(p, PSTR("*?")) ||
- (f_stat(path, &Finfo) == FR_OK && !(Finfo.fattrib & AM_DIR))) {
- pattern = strdup(p);
+ (f_stat(from.p_path, &Finfo) == FR_OK && !(Finfo.fattrib & AM_DIR))) {
+ path_set(&to, p);
*p = '\0';
+ } else {
+ to.p_path[0] = '*';
+ to.p_path[1] = '\0';
}
- strip_trailing_slash_relpath(path);
-printf_P(PSTR("*: |%s| |%s|\n"), path ? path : "<NULL>", pattern ? pattern : "<NULL>");
+debug_ls("==== path: '%s', pattern: '%s'\n", from.p_path ? from.p_path : "<NULL>", to.p_path ? to.p_path : "<NULL>");
p1 = s1 = s2 = 0;
- res = f_findfirst(&Dir, &Finfo, path, pattern ? pattern : "*"); /* Start to search for files */
+ res = f_findfirst(&Dir, &Finfo, from.p_path, to.p_path); /* Start to search for files */
while (res == FR_OK && Finfo.fname[0]) {
if (Finfo.fattrib & AM_DIR) {
s2++;
res = f_findnext(&Dir, &Finfo);
}
f_closedir(&Dir);
- free(pattern);
if (res == FR_OK) {
printf_P(PSTR("%4u File(s),%10lu bytes total\n%4u Dir(s)"), s1, p1, s2);
- if (f_getfree(path, (DWORD*)&p1, &fs) == FR_OK)
+ if (f_getfree(from.p_path, (DWORD*)&p1, &fs) == FR_OK)
printf_P(PSTR(", %10luK bytes free\n"), p1 * fs->csize / 2);
}
return CMD_RET_SUCCESS;
}
-command_ret_t do_tst(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[])
+/*
+ * tst path - for debugging: test access with different functions
+ *
+ */
+command_ret_t do_tst(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
{
DIR Dir; /* Directory object */
FILINFO Finfo;
FRESULT res = FR_OK;
char *path;
- (void) cmdtp; (void) flag;
-
printf_P(PSTR("sizeof DIR: %u, sizeof FIL: %u\n"), sizeof (DIR), sizeof (FILINFO));
char * buf = (char *) malloc(BUFFER_SIZE);
if (buf == NULL) {
- printf_P(PSTR("pwd: Out of Memory!\n"));
+ printf_P(PSTR("tst: Out of Memory!\n"));
free(buf);
return CMD_RET_FAILURE;
}
res = f_getcwd(buf, BUFFER_SIZE); /* Get current directory path */
if (!res) {
- printf_P(PSTR("cwd: |%s|\n"), buf);
+ printf_P(PSTR("cwd: '%s'\n"), buf);
}
free(buf);
if (res) {
else
path = "";
- printf_P(PSTR("arg: |%s|\n"), path);
+ printf_P(PSTR("arg: '%s'\n"), path);
printf_P(PSTR("==== f_stat: "));
res = f_stat(path, &Finfo);
put_rc(res);
return CMD_RET_SUCCESS;
}
-static
-FRESULT mkpath(TCHAR *path)
-{
- /* TODO: */
- (void) path;
-#if 0
- FILINFO fd
- TCHAR *p, *q;
- FRESULT ret;
+/******************************************************************************/
- res = f_stat (path, &fd)
+static uint8_t flags;
+#define F_FLAG (1<<3) // overwrite existing file ignoring write protection
+#define I_FLAG (1<<1) // prompt before overwrite (overrides a previous -n option)
+#define N_FLAG (1<<2) // do not overwrite an existing file (overrides a previous -i option)
+#define P_FLAG (1<<4) // preserve attributes and timestamps
+#define R_FLAG (1<<0) // copy directories recursively
+#define V_FLAG (1<<5) // explain what is being done
- p = strchr(path, ':');
- if (p == NULL || *++p == '\0' || *p++ != '/')
- return FR_OK;
+static void
+setfile(FILINFO *fs)
+{
+ FRESULT fr;
- while ((q = strchr(p, '/')) != NULL) {
- *q = '\0';
- ret = f_mkdir(path);
- *q = '/';
- if (ret != FR_OK && ret != FR_EXIST)
- return ret;
- p = q + 1;
- }
-#endif
+ fr = f_utime(to.p_path, fs);
+ if (fr != FR_OK)
+ err(PSTR("f_utime: %s: %S"), to.p_path, rctostr(fr));
+ fr = f_chmod(to.p_path, fs->fattrib, AM_RDO|AM_ARC|AM_SYS|AM_HID);
+ if (fr != FR_OK)
+ err(PSTR("f_chmod: %s: %S"), to.p_path, rctostr(fr));
- return FR_OK;
}
-/*
- * fatread/write - load binary file to/from a dos filesystem
- * read <d:/path/filename> <addr> [bytes [pos]]
- * write <d:/path/filename> <addr> <bytes>
- */
-command_ret_t do_rw(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[])
+void copy_file(FILINFO *fs, uint_fast8_t dne)
{
- FIL File;
- uint32_t addr;
- unsigned long bytes;
- unsigned long pos;
- unsigned long bytes_rw;
-
- bool dowrite = (argv[0][0] == 'w');
- FRESULT res = FR_OK;
- bool buserr = 0;
- uint32_t timer;
- uint8_t *buffer;
+ FIL from_fd, to_fd;
+ UINT rcount, wcount;
+ FRESULT fr;
+ BYTE open_mode;
+
+ if (blockbuf == NULL) {
+ blockbuf_size = get_freemem() / 512 * 512;
+ if (blockbuf_size != 0)
+ blockbuf = (uint8_t *) malloc(blockbuf_size);
+ if (blockbuf == NULL) {
+ err(PSTR("Not enough memory!\n"));
+ return;
+ }
+ }
- (void) cmdtp; (void) flag;
+debug_cp("==== copy_file(): dne: %u, blockbuf_size: %d\n", dne, blockbuf_size);
+debug_cp(" from:'%s' to:'%s'\n", from.p_path, to.p_path);
- if (argc < (dowrite ? 4 : 3))
- return CMD_RET_USAGE;
- addr = eval_arg(argv[2], NULL);
- if (addr >= MAX_MEMORY) {
- printf_P(PSTR("address too high: 0x%0lx\n"), addr);
- return CMD_RET_FAILURE;
+ if ((fr = f_open(&from_fd, from.p_path, FA_READ)) != FR_OK) {
+ err(PSTR("%s: %S"), from.p_path, rctostr(fr));
+ return;
}
- if (argc > 3)
- bytes = eval_arg(argv[3], NULL);
- else
- bytes = MAX_MEMORY;
- if (argc > 4)
- pos = eval_arg(argv[4], NULL);
- else
- pos = 0;
-
- if (addr + bytes > MAX_MEMORY)
- bytes = MAX_MEMORY - addr;
- buffer = (uint8_t *) malloc(BUFFER_SIZE);
- if (buffer == NULL) {
- printf_P(PSTR("fatstat: Out of Memory!\n"));
- free(buffer);
- return CMD_RET_FAILURE;
+ /*
+ * If the file exists and we're interactive, verify with the user.
+ */
+ if (!dne) {
+ if (flags & N_FLAG) {
+ if (flags & V_FLAG)
+ printf_P(PSTR("%s not overwritten\n"), to.p_path);
+ f_close(&from_fd);
+ return;
+ } if (flags & I_FLAG) {
+ printf_P(PSTR("overwrite '%s'? "), to.p_path);
+ if (!confirm_yes()) {
+ f_close(&from_fd);
+ return;
+ }
+ }
+ if (flags & F_FLAG) {
+ /* Remove existing destination file name create a new file. */
+ f_chmod(to.p_path,0, AM_RDO);
+ f_unlink(to.p_path);
+ open_mode = FA_WRITE|FA_CREATE_NEW;
+ } else {
+ /* Overwrite existing destination file name. */
+ open_mode = FA_WRITE|FA_CREATE_ALWAYS;
+ }
+ } else {
+ open_mode = FA_WRITE|FA_CREATE_NEW;
}
+ fr = f_open(&to_fd, to.p_path, open_mode);
- if (dowrite) {
- res = mkpath(argv[1]);
+ if (fr != FR_OK) {
+ err(PSTR("%s: %S"), to.p_path, rctostr(fr));
+ f_close(&from_fd);
+ return;
}
+
+ while ((fr = f_read(&from_fd, blockbuf, blockbuf_size, &rcount)) == FR_OK &&
+ rcount > 0) {
+ fr = f_write(&to_fd, blockbuf, rcount, &wcount);
+ if (fr || wcount < rcount) {
+ err(PSTR("%s: %S"), to.p_path, rctostr(fr));
+ break;
+ }
+ }
+ if (fr != FR_OK)
+ err(PSTR("%s: S"), from.p_path, rctostr(fr));
+
+ f_close(&from_fd);
+ if ((fr = f_close(&to_fd)) != FR_OK)
+ err(PSTR("%s: %S"), to.p_path, rctostr(fr));
+
+ if (flags & P_FLAG)
+ setfile(fs);
+}
+
+static void copy();
+
+#if 0
+static void copy_dir(void)
+{
+debug_cp("==== copy_dir()");
+debug_cp(" from:'%s' to:'%s'\n", from->p_path, to.p_path);
+
+ printf_P(PSTR("directory copy not supported, ommitting dir '%s'\n"),
+ from->p_path);
+ command_ret = CMD_RET_FAILURE;
+}
+#else
+static void copy_dir(void)
+{
+ DIR Dir; /* Directory object */
+ FILINFO Finfo;
+ char *old_from, *old_to;
+ FRESULT res;
+ char *pattern = {"*"};
+
+debug_cp("==== copy_dir()");
+debug_cp(" from:'%s' to:'%s'\n", from.p_path, to.p_path);
+
+
+ for (res = f_findfirst(&Dir, &Finfo, from.p_path, pattern);
+ res == FR_OK && Finfo.fname[0];
+ res = f_findfirst(&Dir, &Finfo, from.p_path, pattern)) {
+
+ if (!(Finfo.fattrib & AM_DIR) &&
+ (old_from = path_append(&from, Finfo.fname))) {
+ if ((old_to = path_append(&to, Finfo.fname))) {
+ copy();
+ path_restore(&to, old_to);
+ }
+ path_restore(&from, old_from);
+ }
+ }
+
+ for (res = f_findfirst(&Dir, &Finfo, from.p_path, pattern);
+ res == FR_OK && Finfo.fname[0];
+ res = f_findnext(&Dir, &Finfo)) {
+
+ if ((Finfo.fattrib & AM_DIR) &&
+ (old_from = path_append(&from, Finfo.fname))) {
+ if ((old_to = path_append(&to, Finfo.fname))) {
+ copy();
+ path_restore(&to, old_to);
+ }
+ path_restore(&from, old_from);
+ }
+ }
+}
+#endif
+#if 0
+static void copy_dir(void)
+{
+ FILINFO from_stat;
+ struct dirent *dp, **dir_list;
+ int dir_cnt, i;
+ char *old_from, *old_to;
+
+debug_cp("==== copy_file(): dne: %u\n", dne);
+debug_cp(" from:'%s' to:'%s'\n", from->p_path, to.p_path);
+
+ dir_cnt = scandir(from->p_path, &dir_list, NULL, NULL);
+ if (dir_cnt == -1) {
+ (void)fprintf(stderr, "%s: can't read directory %s.\n",
+ progname, from->p_path);
+ command_ret = CMD_RET_FAILURE;
+ }
+
+ /*
+ * Instead of handling directory entries in the order they appear
+ * on disk, do non-directory files before directory files.
+ * There are two reasons to do directories last. The first is
+ * efficiency. Files tend to be in the same cylinder group as
+ * their parent, whereas directories tend not to be. Copying files
+ * all at once reduces seeking. Second, deeply nested tree's
+ * could use up all the file descriptors if we didn't close one
+ * directory before recursivly starting on the next.
+ */
+ /* copy files */
+ for (i = 0; i < dir_cnt; ++i) {
+ dp = dir_list[i];
+ if (dp->d_namlen <= 2 && dp->d_name[0] == '.'
+ && (dp->d_name[1] == NULL || dp->d_name[1] == '.'))
+ goto done;
+ if (!(old_from =
+ path_append(&from, dp->d_name, (int)dp->d_namlen)))
+ goto done;
+
+ if (statfcn(from->p_path, &from_stat) < 0) {
+ err(PSTR("%s: %s"), dp->d_name, strerror(errno));
+ path_restore(&from, old_from);
+ goto done;
+ }
+ if (S_ISDIR(from_stat.st_mode)) {
+ path_restore(&from, old_from);
+ continue;
+ }
+ if (old_to = path_append(&to, dp->d_name, (int)dp->d_namlen)) {
+ copy();
+ path_restore(&to, old_to);
+ }
+ path_restore(&from, old_from);
+done: dir_list[i] = NULL;
+ free(dp);
+ }
+
+ /* copy directories */
+ for (i = 0; i < dir_cnt; ++i) {
+ dp = dir_list[i];
+ if (!dp)
+ continue;
+ if (!(old_from =
+ path_append(&from, dp->d_name, (int)dp->d_namlen))) {
+ free(dp);
+ continue;
+ }
+ if (!(old_to =
+ path_append(&to, dp->d_name, (int)dp->d_namlen))) {
+ free(dp);
+ path_restore(&from, old_from);
+ continue;
+ }
+ copy();
+ free(dp);
+ path_restore(&from, old_from);
+ path_restore(&to, old_to);
+ }
+ free(dir_list);
+}
+#endif
+
+/*
+ * copy file or directory at "from" to "to".
+ */
+static void copy()
+{
+ FILINFO from_stat, to_stat;
+ uint_fast8_t dne;
+ FRESULT fr;
+
+debug_cp("==== copy()\n");
+debug_cp(" from:'%s' to:'%s'\n", from.p_path, to.p_path);
+
+ fr = f_stat(from.p_path, &from_stat);
+ if (fr != FR_OK) {
+ err(PSTR("%s: %S"), from.p_path, rctostr(fr));
+ return;
+ }
+
+ /* not an error, but need to remember it happened */
+ if (f_stat(to.p_path, &to_stat) != FR_OK)
+ dne = 1;
+ else {
+ if (strcmp(to.p_path, from.p_path) == 0) {
+ (void)printf_P(PSTR("%s and %s are identical (not copied).\n"),
+ to.p_path, from.p_path);
+ command_ret = CMD_RET_FAILURE;
+ return;
+ }
+ dne = 0;
+ }
+
+ if(from_stat.fattrib & AM_DIR) {
+ if (!(flags & R_FLAG)) {
+ (void)printf_P(PSTR("-r not specified; ommitting dir '%s'\n"),
+ from.p_path);
+ command_ret = CMD_RET_FAILURE;
+ return;
+ }
+ if (dne) {
+ /*
+ * If the directory doesn't exist, create the new one.
+ */
+ if ((fr = f_mkdir(to.p_path)) != FR_OK) {
+ err(PSTR("%s: %S"), to.p_path, rctostr(fr));
+ return;
+ }
+ }
+ else if (!(to_stat.fattrib & AM_DIR)) {
+ (void)printf_P(PSTR("%s: not a directory.\n"), to.p_path);
+ return;
+ }
+ copy_dir();
+ if (flags & P_FLAG)
+ setfile(&from_stat);
+
+ return;
+ }
+ copy_file(&from_stat, dne);
+}
+
+command_ret_t do_cp(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
+{
+
+ FRESULT fr; /* Return value */
+ //DIR dj; /* Directory search object */
+ FILINFO to_stat; /* File information */
+ char *old_to;
+
+
+ uint8_t tflags = 0;
+ command_ret = CMD_RET_SUCCESS;
+
+ /* reset getopt() */
+ optind = 0;
+
+ int opt;
+ while ((opt = getopt(argc, argv, PSTR("finprv"))) != -1) {
+ switch (opt) {
+ case 'f':
+ tflags &= ~(I_FLAG | N_FLAG);
+ tflags |= F_FLAG;
+ break;
+ case 'i':
+ tflags &= ~(F_FLAG | N_FLAG);
+ tflags |= I_FLAG;
+ break;
+ case 'n':
+ tflags &= ~(F_FLAG | I_FLAG);
+ tflags |= N_FLAG;
+ break;
+ case 'p':
+ tflags |= P_FLAG;
+ break;
+ case 'r':
+ tflags |= R_FLAG;
+ break;
+ case 'v':
+ tflags |= V_FLAG;
+ break;
+ default:
+ return CMD_RET_USAGE;
+ break;
+ }
+ }
+ flags = tflags;
+ argc -= optind;
+ argv += optind;
+
+ if (argc < 2)
+ return CMD_RET_USAGE;
+
+ path_init();
+
+ /* last argument is destination */
+ if (!path_set(&to, argv[--argc]))
+ goto cleanup;
+
+ /*
+ * Cp has two distinct cases:
+ *
+ * % cp [-rip] source target
+ * % cp [-rip] source1 ... directory
+ *
+ * In both cases, source can be either a file or a directory.
+ *
+ * In (1), the target becomes a copy of the source. That is, if the
+ * source is a file, the target will be a file, and likewise for
+ * directories.
+ *
+ * In (2), the real target is not directory, but "directory/source".
+ */
+
+ fr = f_stat(to.p_path, &to_stat);
+debug_cp("==== main, stat to: fr: %d, attr: %02x, flags:%02x\n", fr, to_stat.fattrib, flags);
+debug_cp(" from:'%s' to:'%s'\n", from.p_path, to.p_path);
+
+ if (fr != FR_OK && fr != FR_NO_FILE && fr != FR_NO_PATH) {
+ err(PSTR("Test1: %s: %S"), to.p_path, rctostr(fr));
+ command_ret = CMD_RET_FAILURE;
+ goto cleanup;
+ }
+ if (!(fr == FR_OK && (to_stat.fattrib & AM_DIR))) {
+ /*
+ * Case (1). Target is not a directory.
+ */
+ if (argc > 1) {
+ err(PSTR("target '%s' is not a directory"), to.p_path);
+ //command_ret = CMD_RET_USAGE;
+ goto cleanup;
+ }
+ if (!path_set(&from, *argv)) {
+ command_ret = CMD_RET_FAILURE;
+ goto cleanup;
+ }
+ copy();
+ }
+ else {
+ /*
+ * Case (2). Target is a directory.
+ */
+ for (;; ++argv) {
+ if (!path_set(&from, *argv))
+ continue;
+ if (!(old_to = path_append(&to, path_basename(&from))))
+ continue;
+ copy();
+ if (!--argc)
+ break;
+ path_restore(&to, old_to);
+ }
+ }
+
+cleanup:
+ free(blockbuf);
+ blockbuf = NULL;
+ blockbuf_size = 0;
+
+ return command_ret;
+}
+
+#if 0
+ if (flags & V_FLAG)
+ printf_P((PSTR("%s %s -> %s\n", badcp ? : "ERR:" : " ", curr->fts_path, to.p_path)));
+
+#endif
+
+
+
+
+
+
+/******************************************************************************/
+
+/*
+ * Work register for stat command
+ */
+struct stat_dat_s {
+ DWORD AccSize;
+ WORD AccFiles, AccDirs;
+ FILINFO Finfo;
+};
+
+static
+FRESULT scan_files (
+ char *path, /* Pointer to the working buffer with start path */
+ struct stat_dat_s *statp
+)
+{
+ DIR dirs;
+ FRESULT res;
+ int i;
+ char *fn;
+
+ res = f_opendir(&dirs, path);
+ swirl();
+ if (res == FR_OK) {
+ i = strlen(path);
+ while (((res = f_readdir(&dirs, &statp->Finfo)) == FR_OK) &&
+ statp->Finfo.fname[0]) {
+ if (_FS_RPATH && statp->Finfo.fname[0] == '.')
+ continue;
+ fn = statp->Finfo.fname;
+ if (statp->Finfo.fattrib & AM_DIR) {
+ statp->AccDirs++;
+ path[i] = '/';
+ strcpy(path+i+1, fn);
+ res = scan_files(path, statp);
+ path[i] = '\0';
+ if (res != FR_OK)
+ break;
+ } else {
+ //printf_P(PSTR("%s/%s\n"), path, fn);
+ statp->AccFiles++;
+ statp->AccSize += statp->Finfo.fsize;
+ }
+ if (check_abort()) {
+ res = 255;
+ break;
+ }
+ }
+ }
+
+ return res;
+}
+
+
+/*
+ * fatstat path - Show logical drive status
+ *
+ */
+command_ret_t do_stat(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
+{
+ FATFS *fs;
+ DWORD nfreeclst;
+ FRESULT res;
+ char *buf;
+ char *path = "";
+ struct stat_dat_s statp;
+
+ buf = (char *) malloc(BUFFER_SIZE);
+ if (buf == NULL) {
+ printf_P(PSTR("fat stat: Out of Memory!\n"));
+ return CMD_RET_FAILURE;
+ }
+
+ if (argc > 1)
+ path = argv[1];
+ res = f_getfree(path, &nfreeclst, &fs);
+ if (!res) {
+ printf_P(PSTR(
+ "FAT type: %u\n"
+ "Bytes/Cluster: %lu\n"
+ "Number of FATs: %u\n"
+ "Root DIR entries: %u\n"
+ "Sectors/FAT: %lu\n"
+ "Number of clusters: %lu\n"
+ "FAT start (lba): %lu\n"
+ "DIR start (lba,cluster): %lu\n"
+ "Data start (lba): %lu\n"),
+ fs->fs_type, (DWORD)fs->csize * 512, fs->n_fats,
+ fs->n_rootdir, fs->fsize, fs->n_fatent - 2,
+ fs->fatbase, fs->dirbase, fs->database);
+
+#if _USE_LABEL
+ DWORD serial;
+ res = f_getlabel(path, buf, &serial);
+ if (!res) {
+ printf_P(PSTR(
+ "Volume name: %s\n"
+ "Volume S/N: %04X-%04X\n"),
+ buf, (WORD)(serial >> 16), (WORD)(serial & 0xFFFF));
+ }
+#endif
+ if (!res) {
+ my_puts_P(PSTR("\nCounting... "));
+ statp.AccSize = statp.AccFiles = statp.AccDirs = 0;
+ strcpy(buf, path);
+
+ res = scan_files(buf, &statp);
+ }
+ if (!res) {
+ printf_P(PSTR("\r%u files, %lu bytes.\n%u folders.\n"
+ "%lu KB total disk space.\n%lu KB available.\n"),
+ statp.AccFiles, statp.AccSize, statp.AccDirs,
+ (fs->n_fatent - 2) * (fs->csize / 2), nfreeclst * (fs->csize / 2)
+ );
+ }
+ }
+
+ free(buf);
+ if (res) {
+ put_rc(res);
+ return CMD_RET_FAILURE;
+ }
+ return CMD_RET_SUCCESS;
+}
+
+/*
+ * fatread/write - load binary file to/from a dos filesystem
+ * read <d:/path/filename> <addr> [bytes [pos]]
+ * write <d:/path/filename> <addr> <bytes>
+ */
+command_ret_t do_rw(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
+{
+ FIL File;
+ uint32_t addr;
+ unsigned long bytes;
+ unsigned long pos;
+ unsigned long bytes_rw;
+
+ bool dowrite = (argv[0][0] == 'w');
+ FRESULT res = FR_OK;
+ bool buserr = 0;
+ uint32_t timer;
+ uint8_t *buffer;
+
+ if (argc < (dowrite ? 4 : 3))
+ return CMD_RET_USAGE;
+
+ addr = eval_arg(argv[2], NULL);
+ if (addr >= MAX_MEMORY) {
+ printf_P(PSTR("address too high: 0x%0lx\n"), addr);
+ return CMD_RET_FAILURE;
+ }
+ if (argc > 3)
+ bytes = eval_arg(argv[3], NULL);
+ else
+ bytes = MAX_MEMORY;
+ if (argc > 4)
+ pos = eval_arg(argv[4], NULL);
+ else
+ pos = 0;
+
+ if (addr + bytes > MAX_MEMORY)
+ bytes = MAX_MEMORY - addr;
+
+ buffer = (uint8_t *) malloc(BUFFER_SIZE);
+ if (buffer == NULL) {
+ printf_P(PSTR("fatstat: Out of Memory!\n"));
+ free(buffer);
+ return CMD_RET_FAILURE;
+ }
+
if (!res) {
res = f_open(&File, argv[1], dowrite ? FA_WRITE | FA_CREATE_ALWAYS
: FA_READ );
return CMD_RET_SUCCESS;
}
-/* ========================================================================== */
-
-
-typedef struct {
- char *p_end; /* pointer to NULL at end of path */
- char p_path[MAX_PATHLEN + 1]; /* pointer to the start of a path */
-} PATH_T;
-
-static inline void strip_trailing_slash(PATH_T *p)
-{
- while (p->p_end > p->p_path && p->p_end[-1] == '/')
- *--p->p_end = 0;
-}
-
/*
- * Move specified string into path. Convert "" to "." to handle BSD
- * semantics for a null path. Strip trailing slashes.
+ * command table for fat subcommands
*/
-int
-path_set(PATH_T *p, char *string)
-{
- if (strlen(string) > MAX_PATHLEN) {
- //err("%s: name too long", string);
- return(0);
- }
-
- (void)strcpy(p->p_path, string);
- p->p_end = p->p_path + strlen(p->p_path);
-
- if (p->p_path == p->p_end) {
- *p->p_end++ = '.';
- *p->p_end = 0;
- }
-
- strip_trailing_slash(p);
- return(1);
-}
-
-#define R_FLAG (1<<0)
-#define I_FLAG (1<<1)
-#define N_FLAG (1<<2)
-#define F_FLAG (1<<3)
-#define P_FLAG (1<<4)
-#define V_FLAG (1<<5)
-
-command_ret_t do_cp(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
-{
-
- FRESULT fr; /* Return value */
- DIR dj; /* Directory search object */
- FILINFO fno; /* File information */
-
- uint8_t flags = 0;
-
-
- /* reset getopt() */
- optind = 0;
-
- int opt;
- while ((opt = getopt(argc, argv, PSTR("Rrfip"))) != -1) {
- switch (opt) {
- case 'f':
- flags &= I_FLAG;
- break;
- case 'i':
- flags |= I_FLAG;
- flags &= F_FLAG;
- break;
- case 'p':
- flags |= P_FLAG;
- break;
- case 'R':
- case 'r':
- flags |= R_FLAG;
- break;
- case 'v':
- flags |= V_FLAG;
- break;
- default:
- return CMD_RET_USAGE;
- break;
- }
- }
- argc -= optind;
- argv += optind;
-
- if (argc < 2)
- return CMD_RET_USAGE;
-
-#if 0
- /* consume last argument first. */
- if (!path_set(&to, argv[--argc]))
- exit(1);
-
-
- if (flags & V_FLAG)
- printf_P((PSTR("%s %s -> %s\n", badcp ? : "ERR:" : " ",
- curr->fts_path, to.p_path);
-#endif
-
-/* Search a directory for objects and display it */
-
-
- fr = f_findfirst(&dj, &fno, argv[1], argv[2]); /* Start to search for files */
-
- while (fr == FR_OK && fno.fname[0]) { /* Repeat while an item is found */
- printf_P(PSTR("%c%c%c%c%c %u/%02u/%02u %02u:%02u %9lu %s\n"),
- (fno.fattrib & AM_DIR) ? 'D' : '-',
- (fno.fattrib & AM_RDO) ? 'R' : '-',
- (fno.fattrib & AM_HID) ? 'H' : '-',
- (fno.fattrib & AM_SYS) ? 'S' : '-',
- (fno.fattrib & AM_ARC) ? 'A' : '-',
- (fno.fdate >> 9) + 1980, (fno.fdate >> 5) & 15, fno.fdate & 31,
- (fno.ftime >> 11), (fno.ftime >> 5) & 63,
- fno.fsize, fno.fname);
- fr = f_findnext(&dj, &fno); /* Search for next item */
- }
-
- f_closedir(&dj);
-
- return CMD_RET_SUCCESS;
-}
-
cmd_tbl_t cmd_tbl_fat[] = {
CMD_TBL_ITEM(
- stat, 2, CTBL_REPEAT, do_stat,
+ stat, 2, CTBL_RPT, do_stat,
"Show logical drive status",
"dev"
),
CMD_TBL_ITEM(
- pwd, 2, CTBL_REPEAT, do_pwd,
+ pwd, 2, CTBL_RPT, do_pwd,
"Print name of current/working directory",
""
),
CMD_TBL_ITEM(
- cd, 2, CTBL_REPEAT, do_cd,
+ cd, 2, 0, do_cd,
"Change the current/working directory.",
"path"
),
CMD_TBL_ITEM(
- ls, 2, CTBL_REPEAT, do_ls,
+ ls, 2, CTBL_RPT, do_ls,
"Directory listing",
"path"
),
CMD_TBL_ITEM(
- tst, 2, CTBL_REPEAT, do_tst,
+ tst, 2, CTBL_DBG|CTBL_RPT, do_tst,
"FatFS test function",
"path"
),
CMD_TBL_ITEM(
- load, 5, 0, do_rw,
+ load, 5, 0, do_rw,
"load binary file from a dos filesystem",
"<d:/path/filename> <addr> [bytes [pos]]\n"
" - Load binary file 'path/filename' on logical drive 'd'\n"
" the load stops on end of file."
),
CMD_TBL_ITEM(
- write, 4, 0, do_rw,
+ write, 4, 0, do_rw,
"write file into a dos filesystem",
"<d:/path/filename> <addr> <bytes>\n"
" - Write file to 'path/filename' on logical drive 'd' from RAM\n"
),
CMD_TBL_ITEM(
- cp, CONFIG_SYS_MAXARGS, 0, do_cp,
+ cp, CONFIG_SYS_MAXARGS, CTBL_DBG, do_cp,
"copy files",
- "cp [-R] [-f | -i | -n] [-aprv] source_file target_file\n"
- " - \n"
+ "[-f | -i | -n] [-prv] source_file target_file\n"
+// "[-f | -i | -n] [-prv] source_file target_file\n"
+// "cp [-f | -i | -n] [-prv] source_file ... target_dir\n"
+ " -f overwrite existing file ignoring write protection\n"
+ " this option is ignored when the -n option is also used\n"
+ " -i prompt before overwrite (overrides a previous -n option)\n"
+ " -n do not overwrite an existing file (overrides a previous -i option)\n"
+ " -p preserve attributes and timestamps\n"
+ " -r copy directories recursively\n"
+ " -v explain what is being done\n"
),
CMD_TBL_ITEM(
- help, CONFIG_SYS_MAXARGS, CTBL_REPEAT, do_help,
+ help, CONFIG_SYS_MAXARGS, CTBL_RPT, do_help,
"Print sub command description/usage",
"\n"
" - print brief description of all sub commands\n"
};
-command_ret_t do_fat(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[])
+command_ret_t do_fat(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc UNUSED, char * const argv[] UNUSED)
{
puts_P(PSTR("Huch?"));
projects / z180-stamp.git / blobdiff