fat cp: more on flags

[z180-stamp.git] / avr / cmd_fat.c

/*
 * (C) Copyright 2014,2016,2018 Leo C. <erbl259-lmu@yahoo.de>
 *
 * SPDX-License-Identifier:	GPL-2.0
 */

/*
 * FAT filesystem commands
 */

#include "cmd_fat.h"
#include <util/delay.h>

#include "ff.h"
#include "z80-if.h"
#include "eval_arg.h"
#include "con-utils.h"
#include "print-utils.h"
#include "time.h"
#include "timer.h"
#include "debug.h"
#include "env.h"
#include "getopt-min.h"

/* 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 MAXBSIZE	512 /* TODO */


/*
 * Multible (fat) partitions per physical drive are not supported,
 * but we have up to 2 sdcard slots.
 */
FATFS FatFs0;
FATFS FatFs1;

command_ret_t command_ret;

void setup_fatfs(void)
{
	f_mount(&FatFs0, "0:", 0);
	f_mount(&FatFs1, "1:", 0);
}

DWORD get_fattime (void)
{
	time_t timer;
	struct tm tm_timer;

	time(&timer);
	gmtime_r(&timer, &tm_timer);

	return fatfs_time(&tm_timer);
}


static bool check_abort(void)
{
	bool ret = ctrlc();

	if (ret)
		printf_P(PSTR("Abort\n"));

	return ret;
}


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"),
			FSTR("INT_ERR"),
			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
void put_rc (FRESULT rc)
{
#if GCC_BUG_61443
	printf_P(PSTR("rc=%u FR_"), rc);
	my_puts_P(rc < ARRAY_SIZE(rc_names) ? rc_names[rc] : PSTR(" Unknown Error"));
	my_puts_P(PSTR("\n"));
#else
	printf_P(PSTR("rc=%u FR_%S\n"), rc,
	rc < ARRAY_SIZE(rc_names) ? rc_names[rc] : PSTR(" Unknown Error"));
#endif
}

const FLASH char * rctostr(FRESULT rc)
{
	return 	rc < ARRAY_SIZE(rc_strings) ? rc_strings[rc] : PSTR(" Unknown Error");
}

void err(const char *fmt, ...)
{
	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;

	if (get_timer(0) > tstamp) {
		printf_P(PSTR("\b%c"), swirlchar[cnt]);
		cnt = (cnt+1) % ARRAY_SIZE(swirlchar);
		tstamp = get_timer(0) + 250;
	}
}

/*
 * pwd - Print current directory of the current drive.
 *
 */
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;

	buf = (char *) malloc(BUFFER_SIZE);
	if (buf == NULL) {
		printf_P(PSTR("pwd: Out of Memory!\n"));
		free(buf);
		return CMD_RET_FAILURE;
	}

	res = f_getcwd(buf, BUFFER_SIZE);  /* Get current directory path */

	if (!res) {
		puts(buf);
	}
	free(buf);
	if (res) {
		put_rc(res);
		return CMD_RET_FAILURE;
	}
	return CMD_RET_SUCCESS;
}


/*
 * cd - Change the current/working directory.
 *
 */
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;

	if (argc < 2) {
		arg = getenv_str(PSTR(ENV_HOME));
		if (arg == NULL) {
			printf_P(PSTR("%s: \"%S\" is not set\n"), argv[0], PSTR(ENV_HOME));
			return CMD_RET_FAILURE;
		}
	} else
		arg = argv[1];

	if (arg[1] == ':') {
		char drv[3];
		drv[2] = '\0';
		drv[1] = ':';
		drv[0] = arg[0];
		res = f_chdrive(drv);
	}
	if (!res) {
		res = f_chdir(arg);
	}

	if (res) {
		put_rc(res);
		return CMD_RET_FAILURE;
	}
	return CMD_RET_SUCCESS;
}

#define MAX_PATHLEN CONFIG_SYS_MAX_PATHLEN

/*
 * Remove trailing slashes,
 * but keep a leading slash (absolute path)
 */
void strip_trailing_slash_relpath(char *p)
{
	int n = strlen(p);

	if (n >= 2 && (p[0] & 0x38) == '0' &&  p[1] == ':') {
		p += 2;
		n -= 2;
	}
	if (n >= 1 &&  p[0] == '/') {
		p++;
		n--;
	}
	while (n-- != 0  && p[n] == '/')
			p[n] = '\0';
}

int print_dirent(FILINFO *f)
{
	return printf_P(PSTR("%c%c%c%c%c %u/%02u/%02u %02u:%02u %9lu  %s\n"),
				(f->fattrib & AM_DIR) ? 'D' : '-',
				(f->fattrib & AM_RDO) ? 'R' : '-',
				(f->fattrib & AM_HID) ? 'H' : '-',
				(f->fattrib & AM_SYS) ? 'S' : '-',
				(f->fattrib & AM_ARC) ? 'A' : '-',
				(f->fdate >> 9) + 1980, (f->fdate >> 5) & 15, f->fdate & 31,
				(f->ftime >> 11), (f->ftime >> 5) & 63,
				f->fsize, f->fname);
}

/*
 * ls path - Directory listing
 *
 */
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 */
	FILINFO Finfo;
	unsigned long p1;
	unsigned int s1, s2;
	FRESULT res;

	char *path = "";
	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;
	}

	char *pattern;
	if (strpbrk_P(p, PSTR("*?")) ||
			(f_stat(path, &Finfo) == FR_OK && !(Finfo.fattrib & AM_DIR))) {
		pattern = strdup(p);
		*p = '\0';
	} else
		pattern = strdup("*");
	strip_trailing_slash_relpath(path);

//printf_P(PSTR("*: |%s| |%s|\n"), path ? path : "<NULL>", pattern ? pattern : "<NULL>");

	p1 = s1 = s2 = 0;
	res = f_findfirst(&Dir, &Finfo, path, pattern);  /* Start to search for files */
	while (res == FR_OK && Finfo.fname[0]) {
		if (Finfo.fattrib & AM_DIR) {
			s2++;
		} else {
			s1++; p1 += Finfo.fsize;
		}
		print_dirent(&Finfo);
		if (check_abort())
			break;
		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)
			printf_P(PSTR(", %10luK bytes free\n"), p1 * fs->csize / 2);
	}

	if (res) {
		put_rc(res);
		return CMD_RET_FAILURE;
	}

	return CMD_RET_SUCCESS;
}

/*
 * 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;

	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"));
		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);
	}
	free(buf);
	if (res) {
		put_rc(res);
		return CMD_RET_FAILURE;
	}

	if (argc > 1)
		path = argv[1];
	else
		path = "";

	printf_P(PSTR("arg: |%s|\n"), path);
	printf_P(PSTR("==== f_stat:      "));
	res = f_stat(path, &Finfo);
	put_rc(res);
	if (res == FR_OK) {
		print_dirent(&Finfo);
	}

	printf_P(PSTR("==== f_findfirst: "));
	res = f_findfirst(&Dir, &Finfo, path, "*");  /* Start to search for files */
	put_rc(res);
	if (res == FR_OK) {
		print_dirent(&Finfo);
	}
	f_closedir(&Dir);

	printf_P(PSTR("==== f_opendir:   "));
	res = f_opendir(&Dir, path);
	put_rc(res);
	f_closedir(&Dir);

	return CMD_RET_SUCCESS;
}

#if 0
static
FRESULT mkpath(TCHAR *path)
{
	/* TODO: */
	(void) path;
	FILINFO fd
	TCHAR *p, *q;
	FRESULT ret;

	res = f_stat (path, &fd)

	p = strchr(path, ':');
	if (p == NULL || *++p == '\0' || *p++ != '/')
		return FR_OK;

	while ((q = strchr(p, '/')) != NULL) {
		*q = '\0';
		ret = f_mkdir(path);
		*q = '/';
			if (ret != FR_OK && ret != FR_EXIST)
				return ret;
		p = q + 1;
	}

	return FR_OK;
}
#endif

/******************************************************************************/

/*
 * 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.
 */


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 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.
 */
int
path_set(PATH_T *p, char *string)
{
	if (strlen(string) > MAX_PATHLEN) {
		err(PSTR("set: '%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;
}

/*
 * Append specified string to path, inserting '/' if necessary.  Return a
 * pointer to the old end of path for restoration.
 */
char *
path_append(PATH_T *p, char *name, int len)
{
	char *old;

	old = p->p_end;
	if (len == -1)
		len = strlen(name);

	/* 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);
	}

	/*
	 * This code should always be executed, since paths shouldn't
	 * end in '/'.
	 */
	if (p->p_end[-1] != '/') {
		*p->p_end++ = '/';
		*p->p_end = '\0';
	}

	(void)strncat(p->p_end, name, len);
	p->p_end += len;
	*p->p_end = '\0';

	strip_trailing_slash(p);
	return old;
}

/*
 * 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;

	basename = strrchr(p->p_path, '/');
	return(basename ? basename + 1 : p->p_path);
}


static uint8_t flags;
PATH_T *from;
PATH_T *to;

#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

static void
setfile(FILINFO *fs, FIL *fd)
{
	(void) fs;(void) fd;
#if 0 /* TODO: */
	static struct timeval tv[2];

	fs->st_mode &= S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO;

	tv[0].tv_sec = fs->st_atime;
	tv[1].tv_sec = fs->st_mtime;
	if (utimes(to->p_path, tv))
		err(PSTR("utimes: %s: %s"), to->p_path, strerror(errno));
#endif
}

void copy_file(FILINFO *fs, uint_fast8_t dne)
{
	FIL from_fd, to_fd;
	UINT rcount, wcount;
	//FILINFO to_stat;
	//char *p;
	FRESULT fr;

	int buf_size = get_freemem() / 512 * 512;
	uint8_t * buf = (uint8_t *) malloc(buf_size);
	if (buf == NULL) {
		free(buf);
		err(PSTR("cp: Out of Memory!\n"));
		return;
	}

debug("==== copy_file(): dne: %u, buf_zize: %d\n", dne, buf_size);
debug("     from:'%s'  to:'%s'\n", from->p_path, to->p_path);


	if ((fr = f_open(&from_fd, from->p_path, FA_READ)) != FR_OK) {
		err(PSTR("%s: %S"), from->p_path, rctostr(fr));
		return;
	}

	/*
	 * If the file exists and we're interactive, verify with the user.
	 * If the file DNE, set the mode to be the from file, minus setuid
	 * bits, modified by the umask; arguably wrong, but it makes copying
	 * executables work right and it's been that way forever.  (The
	 * other choice is 666 or'ed with the execute bits on the from file
	 * modified by the umask.)
	 */
	if (!dne) {
		if (flags & I_FLAG) {
			printf_P(PSTR("overwrite '%s'? "), to->p_path);
			if (!confirm_yes()) {
				f_close(&from_fd);
				return;
			}
		}
		fr = f_open(&to_fd, to->p_path, FA_WRITE|FA_CREATE_ALWAYS);
	} else
		fr = f_open(&to_fd, to->p_path, FA_WRITE|FA_CREATE_NEW);

	if (fr != FR_OK) {
		err(PSTR("%s: %S"), to->p_path, rctostr(fr));
		f_close(&from_fd);
		return;
	}

	while ((fr = f_read(&from_fd, buf, buf_size, &rcount)) == FR_OK &&
											rcount > 0) {
		fr = f_write(&to_fd, buf, 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));

	if (flags & P_FLAG)
		setfile(fs, &to_fd);

	f_close(&from_fd);
	if ((fr = f_close(&to_fd)) != FR_OK)
		err(PSTR("%s: %S"), to->p_path, rctostr(fr));
}

#if 1
static void copy_dir(void)
{
debug("==== copy_dir()");
debug("     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)
{
	FILINFO from_stat;
	struct dirent *dp, **dir_list;
	int dir_cnt, i;
	char *old_from, *old_to;

debug("==== copy_file(): dne: %u\n", dne);
debug("     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("==== copy()\n");
debug("     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, 0);

		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("fiprv"))) != -1) {
	while ((opt = getopt(argc, argv, PSTR("fiprv"))) != -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;

	from = (PATH_T *) malloc(sizeof(PATH_T));
	to   = (PATH_T *) malloc(sizeof(PATH_T));
	if (from == NULL || to == NULL) {
		printf_P(PSTR("cp: Out of Memory!\n"));
		command_ret = CMD_RET_FAILURE;
		goto cleanup;
	}
	from->p_end = from->p_path; *from->p_path = '\0';
	to->p_end = to->p_path; *to->p_path = '\0';

	/* consume last argument first. */
	if (!path_set(to, argv[--argc])) {
		command_ret = CMD_RET_FAILURE;
		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("==== main, stat to: fr: %d, attr: %02x, flags:%02x\n", fr, to_stat.fattrib, flags);
debug("     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), -1)))
				continue;
			copy();
			if (!--argc)
				break;
			path_restore(to, old_to);
		}
	}

cleanup:
	free(to);
	free(from);

	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 );

		if (!res) {
			res = f_lseek(&File, pos);
			if (!res) {
				bytes_rw = 0;
				timer = get_timer(0);
				while (bytes) {
					unsigned int cnt, br;

					if (bytes >= BUFFER_SIZE)	{
						cnt = BUFFER_SIZE;
						bytes -= BUFFER_SIZE;
					} else {
						cnt = bytes; bytes = 0;
					}
					if (dowrite) {
						if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
							buserr = 1;
							break;
						}
						z80_read_block(buffer, addr, cnt);
						z80_bus_cmd(Release);
						res = f_write(&File, buffer, cnt, &br);
						if (res != FR_OK)
							break;
					} else {
						res = f_read(&File, buffer, cnt, &br);
						if (res != FR_OK)
							break;
						if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
							buserr = 1;
							break;
						}
						z80_write_block(buffer, addr, br);
						z80_bus_cmd(Release);
					}
					addr += br;

					bytes_rw += br;
					if (cnt != br) {
						if (dowrite)
							printf_P(PSTR("Disk full?\n"));
						break;
					}
					if (check_abort())
						break;
				}

				FRESULT fr = f_close(&File);
				if (!res)
					res = fr;
				timer = get_timer(timer);
				printf_P(PSTR("%lu (0x%lx) bytes read/written with %lu bytes/sec.\n"),
							bytes_rw, bytes_rw, timer ? (bytes_rw * 1000 / timer) : 0);
			}
		}
	}

	free(buffer);

	if (buserr)
		my_puts_P(PSTR("Bus timeout\n"));
	if (res)
		put_rc(res);
	if (buserr || res)
		return CMD_RET_FAILURE;

	return CMD_RET_SUCCESS;
}

/*
 * command table for fat subcommands
 */

cmd_tbl_t cmd_tbl_fat[] = {
CMD_TBL_ITEM(
	stat,	2,	CTBL_RPT,	do_stat,
	"Show logical drive status",
	"dev"
),
CMD_TBL_ITEM(
	pwd,	2,	CTBL_RPT,	do_pwd,
	"Print name of current/working directory",
	""
),
CMD_TBL_ITEM(
	cd,		2,	0,			do_cd,
	"Change the current/working directory.",
	"path"
),
CMD_TBL_ITEM(
	ls,		2,	CTBL_RPT,	do_ls,
	"Directory listing",
	"path"
),
CMD_TBL_ITEM(
	tst,	2,	CTBL_DBG|CTBL_RPT,	do_tst,
	"FatFS test function",
	"path"
),
CMD_TBL_ITEM(
	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"
	"      to address 'addr' from dos filesystem.\n"
	"      'pos' gives the file position to start loading from.\n"
	"      If 'pos' is omitted, 0 is used. 'pos' requires 'bytes'.\n"
	"      'bytes' gives the size to load. If 'bytes' is 0 or omitted,\n"
	"      the load stops on end of file."
),
CMD_TBL_ITEM(
	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"
	"      starting at address 'addr'.\n"
),

CMD_TBL_ITEM(
	cp,	CONFIG_SYS_MAXARGS,	CTBL_DBG,	do_cp,
	"copy files",
	"[-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_RPT,	do_help,
	"Print sub command description/usage",
	"\n"
	"       - print brief description of all sub commands\n"
	"fat help command ...\n"
	"       - print detailed usage of sub cmd 'command'"
),

/* This does not use the CMD_TBL_ITEM macro as ? can't be used in symbol names */
	{FSTR("?"),   CONFIG_SYS_MAXARGS, 1, do_help,
	 FSTR("Alias for 'help'"),
#ifdef  CONFIG_SYS_LONGHELP
	FSTR(""),
#endif /* CONFIG_SYS_LONGHELP */
	NULL,
#ifdef CONFIG_AUTO_COMPLETE
	NULL,
#endif
},
/* Mark end of table */
CMD_TBL_END(cmd_tbl_fat)
};


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?"));

	return CMD_RET_USAGE;
}