/**
* write random seq to file
* t_write_seq <fd> <size>
*/
static int cmd_twrite_seq(int argc, char *argv[])
{
int fd;
int len = 0, size = 0;
long pos = 0;
int ret = 0, w_ret = 0;
u8 buf[MAX_TEST_BUF_LEN];
CHK_ARGC(3, 3);
if (sscanf(argv[1], "%d", &fd) != 1) {
return -1;
}
if (sscanf(argv[2], "%d", &len) != 1) {
return -1;
}
pos = uffs_tell(fd);
while (len > 0) {
size = (len < sizeof(buf) ? len : sizeof(buf));
memcp_seq(buf, size, pos);
if ((w_ret = uffs_write(fd, buf, size)) < 0) {
MSGLN("write fail! fd = %d, size = %d, pos = %ld", fd, size, pos);
ret = -1;
break;
}
pos += w_ret;
len -= w_ret;
}
if (ret == 0)
cli_env_set('1', len);
return ret;
}
/** rm <obj> */
static int cmd_rm(int argc, char *argv[])
{
const char *name = NULL;
int ret = 0;
struct uffs_stat st;
CHK_ARGC(2, 2);
name = argv[1];
ret = uffs_stat(name, &st);
if (ret < 0) {
MSGLN("Can't stat '%s'", name);
return ret;
}
if (st.st_mode & US_IFDIR) {
ret = uffs_rmdir(name);
}
else {
ret = uffs_remove(name);
}
if (ret == 0)
MSGLN("Delete '%s' succ.", name);
else
MSGLN("Delete '%s' fail!", name);
return ret;
}
/**
* write file
* t_write <fd> <txt> [..]
*/
static int cmd_twrite(int argc, char *argv[])
{
int fd;
int i, len = 0;
int ret = 0;
CHK_ARGC(3, 0);
if (sscanf(argv[1], "%d", &fd) != 1) {
return -1;
}
else {
for (i = 2; i < argc; i++) {
len = strlen(argv[i]);
if (uffs_write(fd, argv[i], len) != len) {
ret = -1;
break;
}
}
}
if (ret == 0)
cli_env_set('1', len);
return ret;
}
/**
* read and check file
* t_read <fd> <txt>
*/
static int cmd_tread(int argc, char *argv[])
{
int fd;
int len, n;
int ret = 0;
char buf[64];
char *p;
CHK_ARGC(3, 3);
if (sscanf(argv[1], "%d", &fd) != 1) {
return -1;
}
else {
len = strlen(argv[2]);
n = 0;
p = argv[2];
while (n < len) {
n = (len > sizeof(buf) ? sizeof(buf) : len);
if (uffs_read(fd, buf, n) != n ||
memcmp(buf, p, n) != 0) {
ret = -1;
break;
}
len -= n;
p += n;
}
}
return ret;
}
/**
* close file
* t_close <fd>
*/
static int cmd_tclose(int argc, char *argv[])
{
int fd;
CHK_ARGC(2, 2);
if (sscanf(argv[1], "%d", &fd) == 1) {
return uffs_close(fd);
}
else
return -1;
}
/** print block wear-leveling information
* wl [<mount>]
*/
static int cmd_wl(int argc, char *argv[])
{
const char *mount = "/";
uffs_Device *dev;
struct uffs_PartitionSt *par;
uffs_FileEmu *emu;
int i, max;
u32 n;
#define NUM_PER_LINE 10
CHK_ARGC(1, 2);
if (argc > 1) {
mount = argv[1];
}
dev = uffs_GetDeviceFromMountPoint(mount);
if (dev == NULL) {
MSGLN("Can't get device from mount point %s", mount);
return -1;
}
par = &dev->par;
emu = (uffs_FileEmu *)(dev->attr->_private);
max = -1;
for (i = 0; i < par->end - par->start; i++) {
if ((i % NUM_PER_LINE) == 0) {
MSG("%04d:", i + par->start);
}
n = i + par->start;
max = (max == -1 ? n :
(emu->em_monitor_block[n] > emu->em_monitor_block[max] ? n : max)
);
MSG(" %4d", emu->em_monitor_block[n]);
if (uffs_TreeFindBadNodeByBlock(dev, n))
MSG("%c", 'x');
else if (uffs_TreeFindErasedNodeByBlock(dev, n))
MSG("%c", ' ');
else
MSG("%c", '.');
if (((i + 1) % NUM_PER_LINE) == 0)
MSG("\n");
}
MSG("\n");
MSG("Total blocks %d, peak erase count %d at block %d\n",
par->end - par->start, max == -1 ? 0 : emu->em_monitor_block[max], max);
uffs_PutDevice(dev);
return 0;
}
/** ls [<dir>] */
static int cmd_ls(int argc, char *argv[])
{
uffs_DIR *dirp;
struct uffs_dirent *ent;
struct uffs_stat stat_buf;
int count = 0;
char buf[MAX_PATH_LENGTH+2];
const char *name = "/";
char *sub;
int ret = 0;
CHK_ARGC(1, 2);
if (argc > 1)
name = argv[1];
dirp = uffs_opendir(name);
if (dirp == NULL) {
MSGLN("Can't open '%s' for list", name);
ret = -1;
}
else {
MSG("------name-----------size---------serial-----" TENDSTR);
ent = uffs_readdir(dirp);
while (ent) {
MSG("%9s", ent->d_name);
strcpy(buf, name);
sub = buf;
if (name[strlen(name)-1] != '/')
sub = strcat(buf, "/");
sub = strcat(sub, ent->d_name);
if (ent->d_type & FILE_ATTR_DIR) {
sub = strcat(sub, "/");
MSG("/ \t<%8d>", CountObjectUnder(sub));
}
else {
uffs_stat(sub, &stat_buf);
MSG(" \t %8d ", stat_buf.st_size);
}
MSG("\t%6d" TENDSTR, ent->d_ino);
count++;
ent = uffs_readdir(dirp);
}
uffs_closedir(dirp);
MSG("Total: %d objects." TENDSTR, count);
}
return ret;
}
/** cat <file> [<offset>] [<size>] */
static int cmd_cat(int argc, char *argv[])
{
int fd;
const char *name = NULL;
char buf[100];
int start = 0, size = 0, printed = 0, n, len;
int ret = -1;
CHK_ARGC(2, 4);
name = argv[1];
if ((fd = uffs_open(name, UO_RDONLY)) < 0) {
MSGLN("Can't open %s", name);
goto fail;
}
if (argc > 2) {
start = strtol(argv[2], NULL, 10);
if (argc > 3) size = strtol(argv[3], NULL, 10);
}
if (start >= 0)
uffs_seek(fd, start, USEEK_SET);
else
uffs_seek(fd, -start, USEEK_END);
while (uffs_eof(fd) == 0) {
len = uffs_read(fd, buf, sizeof(buf) - 1);
if (len == 0)
break;
if (len > 0) {
if (size == 0 || printed < size) {
n = (size == 0 ? len : (size - printed > len ? len : size - printed));
buf[n] = 0;
MSG("%s", buf);
printed += n;
}
else {
break;
}
}
}
MSG(TENDSTR);
uffs_close(fd);
ret = 0;
fail:
return ret;
}
/**
* read and check seq file
* t_check_seq <fd> <size>
*/
static int cmd_tcheck_seq(int argc, char *argv[])
{
int fd;
int len, size;
int ret = 0, r_ret = 0;
long pos;
u8 buf[MAX_TEST_BUF_LEN];
int i;
u8 x;
CHK_ARGC(3, 3);
if (sscanf(argv[1], "%d", &fd) != 1) {
return -1;
}
if (sscanf(argv[2], "%d", &len) != 1) {
return -1;
}
pos = uffs_tell(fd);
while (len > 0) {
size = (len > sizeof(buf) ? sizeof(buf) : len);
if ((r_ret = uffs_read(fd, buf, size)) < 0) {
MSGLN("Read fail! fd = %d, size = %d, pos = %ld", fd, size, pos);
ret = -1;
break;
}
// check seq
for (i = 0; i < r_ret; i++) {
x = (pos + SEQ_INIT + i) % SEQ_MOD_LEN;
if (buf[i] != x) {
MSGLN("Check fail! fd = %d, pos = %ld (expect 0x%02x but 0x%02x)\n", fd, pos + i, x, buf[i]);
ret = -1;
break;
}
}
if (ret < 0)
break;
len -= r_ret;
pos += r_ret;
}
return ret;
}
/** inspect buffers
* inspb [<mount>]
*/
static int cmd_inspb(int argc, char *argv[])
{
uffs_Device *dev;
const char *mount = "/";
CHK_ARGC(1, 2);
dev = uffs_GetDeviceFromMountPoint(mount);
if (dev == NULL) {
MSGLN("Can't get device from mount point %s", mount);
return -1;
}
uffs_BufInspect(dev);
uffs_PutDevice(dev);
return 0;
}
/** mkdir <dir> */
static int cmd_mkdir(int argc, char *argv[])
{
const char *name;
CHK_ARGC(2, 0);
name = argv[1];
if (uffs_mkdir(name) < 0) {
MSGLN("Create %s fail, err: %d", name, uffs_get_error());
return -1;
}
else {
MSGLN("Create %s succ.", name);
}
return 0;
}
static int cmd_truncate(int argc, char *argv[])
{
int fd;
int ret = 0;
long remain;
CHK_ARGC(3, 3);
if (sscanf(argv[1], "%d", &fd) != 1) {
return -1;
}
if (sscanf(argv[2], "%ld", &remain) != 1) {
return -1;
}
ret = uffs_ftruncate(fd, remain);
return (ret < 0 ? -1 : 0);
}
/** ren|mv <old> <new> */
static int cmd_ren(int argc, char *argv[])
{
const char *oldname;
const char *newname;
int ret;
CHK_ARGC(3, 3);
oldname = argv[1];
newname = argv[2];
if ((ret = uffs_rename(oldname, newname)) == 0) {
MSGLN("Rename from '%s' to '%s' succ.", oldname, newname);
}
else {
MSGLN("Rename from '%s' to '%s' fail!", oldname, newname);
}
return ret;
}
/**
* Open <file> with <oflag>, save fd to $1
*
* t_open <oflag> <file>
*/
static int cmd_topen(int argc, char *argv[])
{
int fd;
const char *name;
char *p;
int oflag = 0;
CHK_ARGC(3, 3);
name = argv[2];
p = argv[1];
while(*p) {
switch(*p++) {
case 'a':
oflag |= UO_APPEND;
break;
case 'c':
oflag |= UO_CREATE;
break;
case 't':
oflag |= UO_TRUNC;
break;
case 'w':
oflag |= UO_RDWR;
break;
case 'r':
oflag |= UO_RDONLY;
break;
}
}
fd = uffs_open(name, oflag);
if (fd >= 0) {
cli_env_set('1', fd);
return 0;
}
else {
return -1;
}
}
/** mkf <file> */
static int cmd_mkf(int argc, char *argv[])
{
int fd;
const char *name;
int oflags = UO_RDWR | UO_CREATE;
CHK_ARGC(2, 2);
name = argv[1];
fd = uffs_open(name, oflags);
if (fd < 0) {
MSGLN("Create %s fail, err: %d", name, uffs_get_error());
return -1;
}
else {
MSGLN("Create %s succ.", name);
uffs_close(fd);
}
return 0;
}
/**
* seek file pointer
* t_seek <fd> <offset> [<origin>]
* if success, $1 = file position after seek
*/
static int cmd_tseek(int argc, char *argv[])
{
int origin = USEEK_SET;
int offset;
int fd;
int ret;
CHK_ARGC(3, 4);
if (sscanf(argv[1], "%d", &fd) != 1 ||
sscanf(argv[2], "%d", &offset) != 1)
{
return CLI_INVALID_ARG;
}
if (argc > 3) {
switch(argv[3][0]) {
case 's':
origin = USEEK_SET;
break;
case 'c':
origin = USEEK_CUR;
break;
case 'e':
origin = USEEK_END;
break;
default:
return CLI_INVALID_ARG;
}
}
ret = uffs_seek(fd, offset, origin);
if (ret >= 0) {
cli_env_set('1', ret);
return 0;
}
else {
return -1;
}
}
/** cp <src> <des> */
static int cmd_cp(int argc, char *argv[])
{
const char *src;
const char *des;
char buf[100];
int fd1 = -1, fd2 = -1;
int len;
BOOL src_local = FALSE, des_local = FALSE;
FILE *fp1 = NULL, *fp2 = NULL;
int ret = -1;
CHK_ARGC(3, 3);
src = argv[1];
des = argv[2];
if (memcmp(src, "::", 2) == 0) {
src += 2;
src_local = TRUE;
}
if (memcmp(des, "::", 2) == 0) {
des += 2;
des_local = TRUE;
}
if (src_local) {
if ((fp1 = fopen(src, "rb")) == NULL) {
MSGLN("Can't open %s for copy.", src);
goto fail_ext;
}
}
else {
if ((fd1 = uffs_open(src, UO_RDONLY)) < 0) {
MSGLN("Can't open %s for copy.", src);
goto fail_ext;
}
}
if (des_local) {
if ((fp2 = fopen(des, "wb")) == NULL) {
MSGLN("Can't open %s for copy.", des);
goto fail_ext;
}
}
else {
if ((fd2 = uffs_open(des, UO_RDWR|UO_CREATE|UO_TRUNC)) < 0) {
MSGLN("Can't open %s for copy.", des);
goto fail_ext;
}
}
ret = 0;
while ( (src_local ? (feof(fp1) == 0) : (uffs_eof(fd1) == 0)) ) {
ret = -1;
if (src_local) {
len = fread(buf, 1, sizeof(buf), fp1);
}
else {
len = uffs_read(fd1, buf, sizeof(buf));
}
if (len == 0) {
ret = -1;
break;
}
if (len < 0) {
MSGLN("read file %s fail ?", src);
break;
}
if (des_local) {
if ((int)fwrite(buf, 1, len, fp2) != len) {
MSGLN("write file %s fail ? ", des);
break;
}
}
else {
if (uffs_write(fd2, buf, len) != len) {
MSGLN("write file %s fail ? ", des);
break;
}
}
ret = 0;
}
fail_ext:
if (fd1 > 0)
uffs_close(fd1);
if (fd2 > 0)
uffs_close(fd2);
if (fp1)
fclose(fp1);
if (fp2)
fclose(fp2);
return ret;
}
