From: Leo C Date: Wed, 11 Apr 2018 09:08:39 +0000 (+0200) Subject: + cp command (WIP) X-Git-Url: http://cloudbase.mooo.com/gitweb/z180-stamp.git/commitdiff_plain/326d0992fc4ce1d3284fdfaa17213df46c09b068 + cp command (WIP) --- diff --git a/avr/cmd_fat.c b/avr/cmd_fat.c index de484b6..7717d6e 100644 --- a/avr/cmd_fat.c +++ b/avr/cmd_fat.c @@ -25,6 +25,8 @@ /* 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, @@ -33,6 +35,8 @@ FATFS FatFs0; FATFS FatFs1; +command_ret_t command_ret; + void setup_fatfs(void) { f_mount(&FatFs0, "0:", 0); @@ -62,6 +66,29 @@ static bool check_abort(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"), @@ -98,6 +125,23 @@ void put_rc (FRESULT rc) #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")); + command_ret = CMD_RET_FAILURE; +} + + static void swirl(void) { @@ -178,7 +222,7 @@ command_ret_t do_cd(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, return CMD_RET_SUCCESS; } -#define MAX_PATHLEN 255 +#define MAX_PATHLEN CONFIG_SYS_MAX_PATHLEN /* * Remove trailing slashes, @@ -241,18 +285,19 @@ command_ret_t do_ls(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, p = q; } - char *pattern = NULL; + 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 : "", pattern ? pattern : ""); +//printf_P(PSTR("*: |%s| |%s|\n"), path ? path : "", pattern ? pattern : ""); p1 = s1 = s2 = 0; - res = f_findfirst(&Dir, &Finfo, path, pattern ? pattern : "*"); /* Start to search for files */ + 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++; @@ -371,16 +416,26 @@ FRESULT mkpath(TCHAR *path) /******************************************************************************/ +/* + * 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 inline void strip_trailing_slash(PATH_T *p) +static void strip_trailing_slash(PATH_T *p) { while (p->p_end > p->p_path && p->p_end[-1] == '/') - *--p->p_end = 0; + *--p->p_end = '\0'; } /* @@ -391,8 +446,8 @@ int path_set(PATH_T *p, char *string) { if (strlen(string) > MAX_PATHLEN) { - //err("%s: name too long", string); - return(0); + err(PSTR("%s: name too long"), string); + return 0; } (void)strcpy(p->p_path, string); @@ -404,9 +459,75 @@ path_set(PATH_T *p, char *string) } strip_trailing_slash(p); - return(1); + 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) @@ -414,15 +535,251 @@ path_set(PATH_T *p, char *string) #define P_FLAG (1<<4) #define V_FLAG (1<<5) +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) +{ + static char buf[MAXBSIZE]; + FIL from_fd, to_fd; + UINT rcount, wcount; + //FILINFO to_stat; + //char *p; + FRESULT fr; + +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)); + 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') { + 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, MAXBSIZE, &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) +{ + printf(PSTR("directory copy not supported, ommitting dir '%s'\n"), + from->p_path); +} +#else +static void copy_dir(void) +{ + FILINFO from_stat; + struct dirent *dp, **dir_list; + int dir_cnt, i; + char *old_from, *old_to; + + 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) { + 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(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 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 + 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 fno; /* File information */ + FRESULT fr; /* Return value */ + //DIR dj; /* Directory search object */ + FILINFO to_stat; /* File information */ + char *old_to; - uint8_t flags = 0; + command_ret = CMD_RET_SUCCESS; /* reset getopt() */ optind = 0; @@ -458,43 +815,95 @@ command_ret_t do_cp(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, if (argc < 2) return CMD_RET_USAGE; -#if 0 + 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])) - exit(1); + 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); + if (fr != FR_OK && fr != FR_NO_FILE) { + err(PSTR("%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) { + 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))); + 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; -} /******************************************************************************/ -/* Work register for fs command */ +/* + * Work register for stat command + */ struct stat_dat_s { DWORD AccSize; WORD AccFiles, AccDirs; diff --git a/include/config.h b/include/config.h index 369a861..2986285 100644 --- a/include/config.h +++ b/include/config.h @@ -65,6 +65,7 @@ #define CONFIG_SYS_HIST_MAX 20 #define CONFIG_SYS_MAXARGS 20 #define CONFIG_SYS_ENV_NAMELEN 16 +#define CONFIG_SYS_MAX_PATHLEN 127 #define CONFIG_SYS_MALLOC_MARGIN 256 #define CONFIG_SYS_PROMPT "-> "