*/
#include "cmd_fat.h"
+#include <util/delay.h>
#include "ff.h"
#include "z80-if.h"
#include "env.h"
#include "getopt-min.h"
+
+#define DEBUG_CP 1 /* set to 1 to debug */
+#define DEBUG_LS 1 /* set to 1 to debug */
+#define DEBUG_RM 1 /* set to 1 to debug */
+#define DEBUG_FA 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)
+#define debug_rm(fmt, args...) \
+ debug_cond(DEBUG_RM, fmt, ##args)
+#define debug_fa(fmt, args...) \
+ debug_cond(DEBUG_FA, 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 MAXBSIZE 512 /* TODO */
+#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,
FATFS FatFs0;
FATFS FatFs1;
+uint8_t *blockbuf;
+int blockbuf_size;
+PATH_T from;
+PATH_T to;
command_ret_t command_ret;
+char *cmdname;
+
+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
+
+
void setup_fatfs(void)
{
{
va_list ap;
va_start(ap, fmt);
-// (void)fprintf(stderr, "%s: ", progname);
- (void)vfprintf_P(stdout, fmt, ap);
+ printf_P(PSTR("fat %s: "), cmdname);
+ vfprintf_P(stdout, fmt, ap);
va_end(ap);
- (void)printf_P(PSTR("\n"));
+ printf_P(PSTR("\n"));
+ _delay_ms(20);
command_ret = CMD_RET_FAILURE;
}
+/******************************************************************************/
+
+/*
+ * 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.
+ */
+
+
+static void path_init(void)
+{
+ from.p_path[0] = '\0'; from.p_end = from.p_path;
+ to.p_path[0] = '\0'; to.p_end = to.p_path;
+}
+
+static char *path_skip_heading(char *p)
+{
+ if ((p[0] & 0x38) == '0' && p[1] == ':') {
+ p += 2;
+ } else {
+ char *q = p;
+ if (*q++ == '.') {
+ if (*q == '.')
+ ++q;
+ if (*q == '\0' || *q == '/')
+ p = q;
+ }
+ return p;
+ }
+ if (*p == '/')
+ ++p;
+
+ return p;
+}
+
+static void strip_trailing_slash(PATH_T *p)
+{
+ char *beg = path_skip_heading(p->p_path);
+ char *end = p->p_end;
+
+ while (end > beg && end[-1] == '/')
+ *--end = '\0';
+
+ p->p_end =end;
+}
+
+/*
+ * 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)
+{
+ char *old = p->p_end;
+ int 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 NULL;
+ }
+
+ /*
+ * This code should always be executed, since paths shouldn't
+ * end in '/'.
+ */
+ if (p->p_end[-1] != '/') {
+ *p->p_end++ = '/';
+ *p->p_end = '\0';
+ }
+
+ 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 = strrchr(p->p_path, '/');
+
+ if (basename) {
+ ++basename;
+ } else {
+ basename = p->p_path;
+ if ((basename[0] & 0x38) == '0' && basename[1] == ':')
+ basename += 2;
+ }
+
+ return basename;
+}
+#if 0
+char *path_basename_pattern(PATH_T *p)
+{
+ char *pattern = path_basename(p);
+ if (strpbrk_P(pattern, PSTR("*?"))) {
+ memmove(pattern+1, pattern, strlen(pattern)+1);
+ *pattern++ = '\0';
+ } else {
+ //p->p_pattern = p->p_end + 1;
+ pattern = p->p_end + 1;
+ pattern[0] = '*';
+ pattern[1] = '\0';
+ }
+ return pattern;
+}
+#endif
+
+/*
+ * Split path
+ * Return basename/pattern of path.
+ */
+
+char *path_split_pattern(PATH_T *p)
+{
+ char *pp = path_skip_heading(p->p_path);
+ char *pattern = strrchr(pp, '/');
+
+ if (pattern == NULL) {
+ pattern = pp;
+ p->p_end = pattern;
+ } else {
+ p->p_end = pattern;
+ pattern++;
+ }
+ memmove(pattern+2, pattern, strlen(pattern)+1);
+ pattern += 2;
+ *p->p_end = '\0' ;
+
+ return pattern;
+}
+
+void path_fix(PATH_T *p)
+{
+ char *pp = path_skip_heading(p->p_path);
+
+ if (pp != p->p_end) {
+ *p->p_end++ = '/';
+ *p->p_end = '\0' ;
+ }
+}
+
+void path_unfix(PATH_T *p)
+{
+ char *pp = path_skip_heading(p->p_path);
+
+ if (pp != p->p_end) {
+ *--p->p_end = '\0' ;
+ }
+}
static void swirl(void)
{
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;
- }
+ cmdname = argv[0];
+ command_ret = CMD_RET_SUCCESS;
- res = f_getcwd(buf, BUFFER_SIZE); /* Get current directory path */
+ res = f_getcwd(from.p_path, MAX_PATHLEN); /* Get current directory path */
- if (!res) {
- puts(buf);
- }
- free(buf);
- if (res) {
- put_rc(res);
- return CMD_RET_FAILURE;
- }
- return CMD_RET_SUCCESS;
+ if (res == FR_OK)
+ puts(from.p_path);
+ else
+ err(PSTR("Error: %S"), rctostr(res));
+
+ return command_ret;
}
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;
+ FRESULT res = FR_OK;
+
+ cmdname = argv[0];
+ command_ret = CMD_RET_SUCCESS;
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;
+ err(PSTR("'%S' is not set"), PSTR(ENV_HOME));
+ return command_ret;
}
} 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) {
+ if (arg[1] == ':')
+ res = f_chdrive(arg);
+ if (res == FR_OK)
res = f_chdir(arg);
- }
+ if (res != FR_OK)
+ err(PSTR("'%s': %S"), arg, rctostr(res));
- if (res) {
- put_rc(res);
- return CMD_RET_FAILURE;
+ return command_ret;
+}
+
+
+static int decode_arg(const char *arg)
+{
+ BYTE attr = 0;
+ char c;
+
+ while ((c = *++arg) != '\0') {
+ switch (c) {
+ case 'a':
+ attr |= AM_ARC; /* Archive */
+ break;
+ case 'h':
+ attr |= AM_HID; /* Hidden */
+ break;
+ case 'r':
+ attr |= AM_RDO; /* Read only */
+ break;
+ case 's':
+ attr |= AM_SYS; /* System */
+ break;
+ default:
+ err(PSTR("unknown attribute: '%c'"), c);
+ return -1;
+ }
}
- return CMD_RET_SUCCESS;
+ return attr;
}
-#define MAX_PATHLEN CONFIG_SYS_MAX_PATHLEN
+static void print_attrib(char *path, FILINFO *f)
+{
+ printf_P(PSTR("%c%c%c%c%c %s%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' : '-',
+ path, f->fname);
+}
-/*
- * Remove trailing slashes,
- * but keep a leading slash (absolute path)
- */
-void strip_trailing_slash_relpath(char *p)
+command_ret_t do_attrib(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, UNUSED char * const argv[])
{
- int n = strlen(p);
+ DIR Dir; /* Directory object */
+ FILINFO Finfo;
+ FRESULT res;
+ BYTE set_mask = 0;
+ BYTE clear_mask = 0;
- if (n >= 2 && (p[0] & 0x38) == '0' && p[1] == ':') {
- p += 2;
- n -= 2;
+ cmdname = argv[0];
+ command_ret = CMD_RET_SUCCESS;
+
+
+ for (;;) {
+ int attr;
+ char *arg = *++argv;
+
+ if (!arg)
+ return CMD_RET_USAGE;
+ if (arg[0] != '-' && arg[0] != '+')
+ break;
+ attr = decode_arg(arg);
+ if (attr < 0)
+ return CMD_RET_FAILURE;
+ if (arg[0] == '+')
+ set_mask |= attr;
+ else
+ clear_mask |= attr;
}
- if (n >= 1 && p[0] == '/') {
- p++;
- n--;
+
+ do {
+ if (!path_set(&from, *argv)) {
+ /* TODO: error out*/
+ }
+ char *pattern = path_split_pattern(&from);
+ if (*pattern == '\0')
+ pattern = "*";
+ debug_fa("==== path: '%s', pattern: '%s'\n", from.p_path ? from.p_path : "<NULL>", pattern ? pattern : "<NULL>");
+ res = f_findfirst(&Dir, &Finfo, from.p_path, pattern);
+ debug_fa("==== findfirst %d\n", res);
+ if (res != FR_OK || !Finfo.fname[0]) {
+ path_fix(&from);
+ err(PSTR("'%s%s': No such file or directory"), from.p_path, pattern);
+ } else {
+ do {
+ if (set_mask | clear_mask) {
+ if ((res = f_chmod(Finfo.fname, set_mask, set_mask | clear_mask)) != FR_OK) {
+ path_fix(&from);
+ err(PSTR("'%s%s': %S"), from.p_path, Finfo.fname, rctostr(res));
+ path_unfix(&from);
+ }
+ } else {
+ path_fix(&from);
+ print_attrib(from.p_path, &Finfo);
+ path_unfix(&from);
+ }
+
+ res = f_findnext(&Dir, &Finfo);
+ //debug_fa("==== findnext %d\n", res);
+ } while (res == FR_OK && Finfo.fname[0]);
+ }
+ f_closedir(&Dir);
+ } while (*++argv);
+
+ return command_ret;
+}
+
+command_ret_t do_rm(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
+{
+ DIR Dir; /* Directory object */
+ FILINFO Finfo;
+ FRESULT res;
+
+ cmdname = argv[0];
+ command_ret = CMD_RET_SUCCESS;
+
+ /* reset getopt() */
+ optind = 0;
+ flags = 0;
+
+ int opt;
+ while ((opt = getopt(argc, argv, PSTR("nv"))) != -1) {
+ switch (opt) {
+ case 'n':
+ flags |= N_FLAG;
+ break;
+ case 'v':
+ flags |= V_FLAG;
+ break;
+ default:
+ return CMD_RET_USAGE;
+ break;
+ }
}
- while (n-- != 0 && p[n] == '/')
- p[n] = '\0';
+ argc -= optind;
+ argv += optind;
+
+ if (argc < 1) {
+ err(PSTR("missing operand"));
+ } else {
+ for (int i = 0; i < argc; i++) {
+ if (!path_set(&from, argv[i])) {
+ /* TODO: error out*/
+ }
+ char *pattern = path_split_pattern(&from);
+
+ debug_rm("==== path: '%s', pattern: '%s'\n", from.p_path ? from.p_path : "<NULL>", pattern ? pattern : "<NULL>");
+
+ res = f_findfirst(&Dir, &Finfo, from.p_path, pattern);
+ debug_rm("==== findfirst %d\n", res);
+
+ if (res != FR_OK || !Finfo.fname[0]) {
+ path_fix(&from);
+ err(PSTR("cannot remove '%s%s': No such file or directory"), from.p_path, pattern);
+ } else {
+ do {
+ if (Finfo.fattrib & AM_DIR) {
+ path_fix(&from);
+ err(PSTR("cannot remove '%s%s': Is a directory"), from.p_path, Finfo.fname);
+ } else {
+ if (!(flags & N_FLAG)) {
+ if ((res = f_unlink(Finfo.fname)) == FR_OK) {
+ if (flags & V_FLAG)
+ path_fix(&from);
+ printf_P(PSTR("removed '%s%s'\n"), from.p_path, Finfo.fname);
+ path_unfix(&from);
+ } else {
+ path_fix(&from);
+ err(PSTR("cannot remove '%s%s': %S"), from.p_path, Finfo.fname, rctostr(res));
+ }
+ } else {
+ path_fix(&from);
+ printf_P(PSTR("not removed '%s%s'\n"), from.p_path, Finfo.fname);
+ path_unfix(&from);
+ }
+ }
+ res = f_findnext(&Dir, &Finfo);
+ //debug_rm("==== findnext %d\n", res);
+ } while (res == FR_OK && Finfo.fname[0]);
+ }
+ f_closedir(&Dir);
+ }
+
+ /* TODO */
+ if (res) {
+ put_rc(res);
+ return CMD_RET_FAILURE;
+ }
+ }
+ return command_ret;
+}
+
+command_ret_t do_rmdir(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
+{
+ cmdname = argv[0];
+ command_ret = CMD_RET_SUCCESS;
+
+ return command_ret;
+}
+
+command_ret_t do_mkdir(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
+{
+ cmdname = argv[0];
+ command_ret = CMD_RET_SUCCESS;
+
+ return command_ret;
}
-int print_dirent(FILINFO *f)
+
+static void print_dirent(FILINFO *f)
{
- return printf_P(PSTR("%c%c%c%c%c %u/%02u/%02u %02u:%02u %9lu %s\n"),
+ 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' : '-',
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;
- }
+ cmdname = argv[0];
+ command_ret = CMD_RET_SUCCESS;
- 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);
+ path_init();
+ if (argc > 1)
+ if (!path_set(&from, argv[1])) {
+ /* TODO: error out*/
+ }
-//printf_P(PSTR("*: |%s| |%s|\n"), path ? path : "<NULL>", pattern ? pattern : "<NULL>");
+#if 0
+ char *pattern = path_basename_pattern(&from);
+#else
+ char *pattern = path_split_pattern(&from);
+ if (*pattern == '\0')
+ pattern = "*";
+#endif
+ debug_ls("==== path: '%s', pattern: '%s'\n", from.p_path ? from.p_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);
+ res = f_findfirst(&Dir, &Finfo, from.p_path, pattern); /* Start to search for files */
+ if (res != FR_OK || !Finfo.fname[0]) {
+ path_fix(&from);
+ err(PSTR("'%s%s': No such file or directory"), from.p_path, pattern);
+ } else {
+ do {
+ if (Finfo.fattrib & AM_DIR) {
+ s2++;
+ } else {
+ s1++; p1 += Finfo.fsize;
+ }
+ print_dirent(&Finfo);
+ if (check_abort())
+ break;
+ res = f_findnext(&Dir, &Finfo);
+ } while (res == FR_OK && Finfo.fname[0]);
}
f_closedir(&Dir);
- free(pattern);
- if (res == FR_OK) {
+ if (res == FR_OK && command_ret == CMD_RET_SUCCESS) {
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);
}
- if (res) {
+ if (res && command_ret == CMD_RET_SUCCESS) {
put_rc(res);
return CMD_RET_FAILURE;
}
- return CMD_RET_SUCCESS;
+ return command_ret;
}
/*
DIR Dir; /* Directory object */
FILINFO Finfo;
FRESULT res = FR_OK;
- char *path;
+ char *path = "";
+ char *pattern = "*";
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);
+ printf_P(PSTR("tst: Out of Memory!\n"));
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) {
if (argc > 1)
path = argv[1];
- else
- path = "";
+ if (argc > 2)
+ pattern = argv[2];
- printf_P(PSTR("arg: |%s|\n"), path);
+ printf_P(PSTR("arg: '%s' '%s'\n"), path, pattern);
printf_P(PSTR("==== f_stat: "));
res = f_stat(path, &Finfo);
put_rc(res);
}
printf_P(PSTR("==== f_findfirst: "));
- res = f_findfirst(&Dir, &Finfo, path, "*"); /* Start to search for files */
+ res = f_findfirst(&Dir, &Finfo, path, pattern); /* Start to search for files */
put_rc(res);
if (res == FR_OK) {
print_dirent(&Finfo);
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("%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("%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(p, old)
- PATH_T *p;
- char *old;
-{
- p->p_end = old;
- *p->p_end = 0;
-}
-
-/*
- * Return basename of path.
- */
-char *
-path_basename(p)
- PATH_T *p;
-{
- char *basename;
-
- basename = strrchr(p->p_path, '/');
- return(basename ? basename + 1 : p->p_path);
-}
-
-
-uint8_t flags = 0;
-PATH_T *from;
-PATH_T *to;
-
-#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)
-
static void
-setfile(FILINFO *fs, FIL *fd)
+setfile(FILINFO *fs)
{
- (void) fs;(void) fd;
-#if 0 /* TODO: */
- static struct timeval tv[2];
+ FRESULT fr;
- fs->st_mode &= S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO;
+ 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));
- 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)
{
- static char buf[MAXBSIZE];
FIL from_fd, to_fd;
UINT rcount, wcount;
- //FILINFO to_stat;
- //char *p;
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;
+ }
+ }
+
+debug_cp("==== copy_file(): dne: %u, blockbuf_size: %d, freemem: %u\n", dne, blockbuf_size, get_freemem());
+debug_cp(" from:'%s' to:'%s'\n", from.p_path, to.p_path);
-debug("==== copy_file(): dne: %u\n", dne);
-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));
+ 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) {
- int checkch, ch;
-
- printf_P(PSTR("overwrite %s? "), to->p_path);
- checkch = ch = getchar();
- while (ch != '\n' && ch != EOF)
- ch = getchar();
- if (checkch != 'y') {
+ 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;
}
}
- 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 (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 (fr != FR_OK) {
- err(PSTR("%s: %S"), to->p_path, rctostr(fr));
+ err(PSTR("%s: %S"), to.p_path, rctostr(fr));
f_close(&from_fd);
return;
}
- while ((fr = f_read(&from_fd, buf, MAXBSIZE, &rcount)) == FR_OK &&
+ while ((fr = f_read(&from_fd, blockbuf, blockbuf_size, &rcount)) == FR_OK &&
rcount > 0) {
- fr = f_write(&to_fd, buf, rcount, &wcount);
+ fr = f_write(&to_fd, blockbuf, rcount, &wcount);
if (fr || wcount < rcount) {
- err(PSTR("%s: %S"), to->p_path, rctostr(fr));
+ 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);
+ 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));
+ err(PSTR("%s: %S"), to.p_path, rctostr(fr));
+
+ if (flags & P_FLAG)
+ setfile(fs);
}
-#if 1
+static void copy();
+
static void copy_dir(void)
{
-debug("==== copy_dir()");
-debug(" from:'%s' to:'%s'\n", from->p_path, to->p_path);
+ DIR Dir; /* Directory object */
+ FILINFO Finfo;
+ char *old_from, *old_to;
+ FRESULT res;
+ char *pattern = {"*"};
+
+debug_cp("==== copy_dir(): freemem: %u\n", get_freemem());
+debug_cp(" from:'%s' to:'%s'\n", from.p_path, to.p_path);
+
+#if 0
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);
+#else
- 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;
- }
+ for (res = f_findfirst(&Dir, &Finfo, from.p_path, pattern);
+ res == FR_OK && Finfo.fname[0];
+ res = f_findnext(&Dir, &Finfo)) {
- /*
- * 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)) {
+ 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);
- 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);
+ 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);
- continue;
}
- copy();
- free(dp);
- path_restore(&from, old_from);
- path_restore(&to, old_to);
}
- free(dir_list);
}
#endif
uint_fast8_t dne;
FRESULT fr;
-debug("==== copy()\n");
-debug(" from:'%s' to:'%s'\n", from->p_path, to->p_path);
+debug_cp("==== copy(); freemem: %u\n", get_freemem());
+debug_cp(" from:'%s' to:'%s'\n", from.p_path, to.p_path);
- fr = f_stat(from->p_path, &from_stat);
+ fr = f_stat(from.p_path, &from_stat);
if (fr != FR_OK) {
- err(PSTR("%s: %S"), from->p_path, rctostr(fr));
+ 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)
+ if (f_stat(to.p_path, &to_stat) != FR_OK)
dne = 1;
else {
- if (strcmp(to->p_path, from->p_path) == 0) {
+ 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);
+ to.p_path, from.p_path);
command_ret = CMD_RET_FAILURE;
return;
}
if(from_stat.fattrib & AM_DIR) {
if (!(flags & R_FLAG)) {
(void)printf_P(PSTR("-r not specified; ommitting dir '%s'\n"),
- from->p_path);
+ from.p_path);
command_ret = CMD_RET_FAILURE;
return;
}
/*
* 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));
+ 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);
+ } else if (!(to_stat.fattrib & AM_DIR)) {
+ (void)printf_P(PSTR("%s: not a directory.\n"), to.p_path);
return;
}
copy_dir();
- /*
- * If not -p and directory didn't exist, set it to be the
- * same as the from directory, umodified by the umask;
- * arguably wrong, but it's been that way forever.
- */
-#if 0
if (flags & P_FLAG)
- setfile(&from_stat, 0);
- else if (dne)
- (void)chmod(to->p_path, from_stat.st_mode);
-#endif
+ setfile(&from_stat);
+
return;
}
copy_file(&from_stat, dne);
char *old_to;
+ cmdname = argv[0];
+ uint8_t tflags = 0;
command_ret = CMD_RET_SUCCESS;
/* reset getopt() */
optind = 0;
int opt;
- while ((opt = getopt(argc, argv, PSTR("Rrfip"))) != -1) {
+ while ((opt = getopt(argc, argv, PSTR("finprv"))) != -1) {
switch (opt) {
case 'f':
- flags &= I_FLAG;
+ tflags &= ~(I_FLAG | N_FLAG);
+ tflags |= F_FLAG;
break;
case 'i':
- flags |= I_FLAG;
- flags &= F_FLAG;
+ tflags &= ~(F_FLAG | N_FLAG);
+ tflags |= I_FLAG;
+ break;
+ case 'n':
+ tflags &= ~(F_FLAG | I_FLAG);
+ tflags |= N_FLAG;
break;
case 'p':
- flags |= P_FLAG;
+ tflags |= P_FLAG;
break;
- case 'R':
case 'r':
- flags |= R_FLAG;
+ tflags |= R_FLAG;
break;
case 'v':
- flags |= V_FLAG;
+ 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';
+ path_init();
- /* consume last argument first. */
- if (!path_set(to, argv[--argc])) {
- command_ret = CMD_RET_FAILURE;
+ /* last argument is destination */
+ if (!path_set(&to, argv[--argc]))
goto cleanup;
- }
/*
* Cp has two distinct cases:
* 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\n", fr, to_stat.fattrib);
-debug(" from:'%s' to:'%s'\n", from->p_path, to->p_path);
+ fr = f_stat(to.p_path, &to_stat);
+debug_cp("==== main, stat to: fr: %d, attr: %02x, flags:%02x, freemem: %u\n",
+ fr, to_stat.fattrib, flags, get_freemem());
+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));
+ err(PSTR("Test1: %s: %S"), to.p_path, rctostr(fr));
command_ret = CMD_RET_FAILURE;
goto cleanup;
}
* Case (1). Target is not a directory.
*/
if (argc > 1) {
- command_ret = CMD_RET_USAGE;
+ err(PSTR("target '%s' is not a directory"), to.p_path);
+ //command_ret = CMD_RET_USAGE;
goto cleanup;
}
- if (!path_set(from, *argv)) {
+ if (!path_set(&from, *argv)) {
command_ret = CMD_RET_FAILURE;
goto cleanup;
}
* Case (2). Target is a directory.
*/
for (;; ++argv) {
- if (!path_set(from, *argv))
+ if (!path_set(&from, *argv))
continue;
- if (!(old_to = path_append(to, path_basename(from), -1)))
+ if (!(old_to = path_append(&to, path_basename(&from))))
continue;
copy();
if (!--argc)
}
cleanup:
- free(to);
- free(from);
+ 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)));
+ printf_P((PSTR("%s %s -> %s\n", badcp ? : "ERR:" : " ", curr->fts_path, to.p_path)));
#endif
-
-
-
-
/******************************************************************************/
/*
i = strlen(path);
while (((res = f_readdir(&dirs, &statp->Finfo)) == FR_OK) &&
statp->Finfo.fname[0]) {
- if (_FS_RPATH && statp->Finfo.fname[0] == '.')
+ if (FF_FS_RPATH && statp->Finfo.fname[0] == '.')
continue;
fn = statp->Finfo.fname;
if (statp->Finfo.fattrib & AM_DIR) {
"dev"
),
CMD_TBL_ITEM(
- pwd, 2, CTBL_RPT, do_pwd,
+ pwd, 1, CTBL_RPT, do_pwd,
"Print name of current/working directory",
""
),
+CMD_TBL_ITEM(
+ attrib, CONFIG_SYS_MAXARGS, 0, do_attrib,
+ "Display or change attributes on a FAT filesystem",
+ "[+-ahrs] files...\n"
+ "\n"
+ " - Clear attributes\n"
+ " + Set attributes\n"
+ " a Archive\n"
+ " h Hidden\n"
+ " r Read only\n"
+ " s System\n"
+ "Display only:\n"
+ " v Volume label\n"
+ " d Directory\n"
+),
CMD_TBL_ITEM(
cd, 2, 0, do_cd,
"Change the current/working directory.",
"path"
),
+CMD_TBL_ITEM(
+ rm, CONFIG_SYS_MAXARGS, 0, do_rm,
+ "Remove FILE(s)",
+ "[OPTION]... [FILE]...\n"
+ //" -i prompt before removal\n"
+ " -v explain what is being done\n"
+ "\n"
+ "rm does not remove directories."
+),
+CMD_TBL_ITEM(
+ rmdir, CONFIG_SYS_MAXARGS, 0, do_rmdir,
+ "Remove the DIRECTORY(ies), if they are empty",
+ "[OPTION]... DIRECTORY..."
+),
+CMD_TBL_ITEM(
+ mkdir, CONFIG_SYS_MAXARGS, 0, do_mkdir,
+ "Create the DIRECTORY(ies), if they do not already exist.",
+ "[OPTION]... DIRECTORY..."
+),
CMD_TBL_ITEM(
ls, 2, CTBL_RPT, do_ls,
"Directory listing",
"path"
),
CMD_TBL_ITEM(
- tst, 2, CTBL_DBG|CTBL_RPT, do_tst,
+ tst, 3, CTBL_DBG|CTBL_RPT, do_tst,
"FatFS test function",
"path"
),
CMD_TBL_ITEM(
cp, CONFIG_SYS_MAXARGS, CTBL_DBG, do_cp,
"copy files",
- "[-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(
projects / z180-stamp.git / blobdiff