/* fatfsRm():
* Remove the specified file from the FATFS.
* If the path is a directory, then don't remove anything.
*/
static int
fatfsRm(char *fatfspath)
{
DIRINFO di;
di.scratch = sector;
if (DFS_OpenDir(&vi, (uint8_t *)fatfspath, &di) == 0) {
printf("can't remove directory '%s'\n",fatfspath);
return(-1);
}
if (DFS_UnlinkFile(&vi, (uint8_t *)fatfspath, sector)) {
printf("error unlinking file %s\n",fatfspath);
return(-1);
}
return(0);
}
// function called by remove
static int File_remove(const char *fname)
{
int errnum;
int retval = -1;
//DIRINFO dirinfo;
char path[MAX_PATH];
dfs_resolve_path(fname, path);
if (!(errnum = DFS_UnlinkFile(&dfs_volinfo, (uint8_t *)path, dfs_scratch)))
retval = 0;
// OpenDir seems to be causing a problem, so it's commented out for now
//else if (!DFS_OpenDir(&dfs_volinfo, (uint8_t *)path, &dirinfo))
// errno = EISDIR;
else
errno = dfs_stdio_errno(errnum);
return retval;
}
void telnet_rm( file_handle_t handle, char** argv, unsigned int argc )
{
if( argc != 2 )
{
file_puts("rm [filename]\r\n", telnet_handle);
return;
}
u8_t* scratch = malloc(SECTOR_SIZE);
VOLINFO* volinfo = malloc( sizeof(VOLINFO) );
//get partition start sector
uint32_t startsector = DFS_GetPtnStart( 0, scratch, 0 , NULL, NULL, NULL );
if( startsector == DFS_ERRMISC )
{
file_puts("Error finding partition start\r\n", handle);
goto exit;
}
//get volume info
if( DFS_GetVolInfo(0,scratch,startsector,volinfo) )
{
file_puts("Error getting volume info\r\n", handle);
goto exit;
}
//unlink file
uint32_t result = DFS_UnlinkFile( volinfo, (u8_t*)argv[1], scratch );
if( result != DFS_OK )
{
file_puts("Error unlinking file ", handle);
file_puts( argv[1], handle );
file_puts(". RC=", handle );
file_putchar( (char)result + '0', handle);
file_puts( CRLF, handle );
}
exit:
free( volinfo );
free( scratch );
}
bool
walkfs(int pass)
{
int a;
int e;
int ms;
uint32 i;
uint32 j;
uint32 rv;
uint32 pstart;
uint32 rfilesize;
VOLINFO vi;
DIRINFO di;
DIRENT de;
bool skip;
bool first;
int wfilesize;
uint32 namei[DEPTH];
uint32 skips[DEPTH];
static char dirname[MAX_PATH];
static char rfilename[MAX_PATH];
static char wfilename[MAX_PATH];
static char tfilename[MAX_PATH];
static byte scratch[SECTOR_SIZE];
ms = ticks;
printf("walkfs\n");
#if ! _WIN32
while (adc_result[0] < 20000) {
DFS_HostFlush(0);
led_sad(code_battery);
delay(1000);
}
led_unknown();
#endif
params_get(¶ms);
assert(params.roflip == true || params.roflip == false);
memset(scratch, -1, sizeof(scratch)); // remove
pstart = DFS_GetPtnStart(0, scratch, 0, NULL, NULL, NULL);
if (pstart == DFS_ERRMISC) {
return 0;
}
memset(scratch, -1, sizeof(scratch)); // remove
if (DFS_GetVolInfo(0, scratch, pstart, &vi)) {
return 0;
}
if (! vi.secperclus || (vi.secperclus & (vi.secperclus-1))) {
printf("invalid fs cluster size %d\n", vi.secperclus);
return 0;
}
printf("fs cluster size %d\n", vi.secperclus);
i = 0;
namei[i] = 0;
skips[i] = 0;
strcpy(dirname, "");
first = 1;
for (;;) {
XXX_LOOP_XXX:
if (panic) {
return 0;
}
// open a new directory
memset(scratch, -1, sizeof(scratch)); // remove
di.scratch = scratch;
if (DFS_OpenDir(&vi, (unsigned char *)dirname, &di)) {
return 0;
}
memset(&de, 0, sizeof(de));
skip = 0;
for (j = 0; j < skips[i]; j++) {
if (DFS_GetNext(&vi, &di, &de)) {
skip = 1;
}
}
// enumerate the directory
if (! skip && ! DFS_GetNext(&vi, &di, &de)) {
skips[i]++;
if (! de.name[0] || de.name[0] == '.') {
continue;
}
#if ! _WIN32
while (adc_result[0] < 20000) {
DFS_HostFlush(0);
led_sad(code_battery);
delay(1000);
}
led_unknown();
while ((MCF_GPIO_SETNQ & 0x10) == 0) {
// we're paused
DFS_HostFlush(0);
}
#endif
if (de.attr & ATTR_DIRECTORY) {
if (i+1 < DEPTH) {
namei[i] = strlen(dirname);
if (namei[i]) {
strcat(dirname, "/");
}
strncat(dirname, (char *)de.name, 8);
tailtrim(dirname);
if (strncmp((char *)de.name+8, " ", 3)) {
strcat(dirname, ".");
strncat(dirname, (char *)de.name+8, 3);
tailtrim(dirname);
}
i++;
skips[i] = 0;
printf("dir: '%s'\n", dirname);
goto XXX_LOOP_XXX;
}
} else if (! (de.attr & (ATTR_HIDDEN|ATTR_SYSTEM|ATTR_VOLUME_ID)) && !!(de.attr & ATTR_READ_ONLY) == params.roflip) {
// force upper case
for (a = 0; a < sizeof(de.name); a++) {
if (de.name[a] >= 'a' && de.name[a] <= 'z') {
de.name[a] = de.name[a] - 'a' + 'A';
}
}
if (pass == 0) {
// pass 0: check for extension match for tmp file
if (! strncmp("TMP", (char *)de.name+8, 3)) {
strcpy(rfilename, dirname);
if (strlen(rfilename)) {
strcat(rfilename, "/");
}
strncat(rfilename, (char *)de.name, 8);
tailtrim(rfilename);
if (strncmp((char *)de.name+8, " ", 3)) {
strcat(rfilename, ".");
strncat(rfilename, (char *)de.name+8, 3);
tailtrim(rfilename);
}
// rfilename needs to be purged!
rfilesize = (de.filesize_3<<24)|(de.filesize_2<<16)|(de.filesize_1<<8)|de.filesize_0;
printf("temp: '%s (%d bytes)'\n", rfilename, rfilesize);
// we have to rewrite rfilename
rv = encrypt_file(&vi, scratch, NULL, 0, rfilename, rfilesize);
if (! rv) {
printf("rewrite failed\n");
return 0;
}
// and unlink it
rv = DFS_UnlinkFile(&vi, (unsigned char *)rfilename, scratch);
if (rv) {
printf("unlink failed\n");
return 0;
}
DFS_HostFlush(0);
}
} else {
assert(pass == 1);
// pass 1: check for extension match for image file
for (e = 0; e < NEXTS; e++) {
if (params.extensions[e][0] != 0 && params.extensions[e][0] != (char)-1) {
if (! strncmp(params.extensions[e], (char *)de.name+8, 3)) {
break;
}
}
}
if (e != NEXTS) {
strcpy(rfilename, dirname);
if (strlen(rfilename)) {
strcat(rfilename, "/");
}
strncat(rfilename, (char *)de.name, 8);
tailtrim(rfilename);
if (strncmp((char *)de.name+8, " ", 3)) {
strcat(rfilename, ".");
strncat(rfilename, (char *)de.name+8, 3);
tailtrim(rfilename);
}
// rfilename needs to be encrypted!
rfilesize = (de.filesize_3<<24)|(de.filesize_2<<16)|(de.filesize_1<<8)|de.filesize_0;
printf("encrypt: '%s (%d bytes)'\n", rfilename, rfilesize);
if (first) {
// for the first rfilename we create a new (unallocated) .REC file directly
output_file(rfilename, ".REC", wfilename);
wfilesize = 0;
}
// we'll encrypt to wfilename
rv = encrypt_file(&vi, scratch, rfilename, rfilesize, wfilename, wfilesize);
if (! rv) {
printf("encryption failed\n");
return 0;
}
// and then we rename wfilename to rfilename with .REC
if (! first) {
// and then rename the old file
output_file(rfilename, ".REC", tfilename);
rv = DFS_RenameFile(&vi, (unsigned char *)wfilename, (unsigned char *)tfilename, scratch);
if (rv) {
printf("rename failed\n");
return 0;
}
}
// and rename rfilename to rfilename with .TMP
output_file(rfilename, ".TMP", wfilename);
wfilesize = rfilesize;
rv = DFS_RenameFile(&vi, (unsigned char *)rfilename, (unsigned char *)wfilename, scratch);
if (rv) {
printf("rename failed\n");
return 0;
}
// we reuse an old (allocated) file
first = 0;
}
}
}
} else {
skip = 1;
}
if (! skip) {
// we have more files in this directory
goto XXX_LOOP_XXX;
}
// we're leaving this directory
if (pass == 1 && ! first) {
// lastly we have to rewrite wfilename
rv = encrypt_file(&vi, scratch, NULL, 0, wfilename, wfilesize);
if (! rv) {
printf("rewrite failed\n");
return 0;
}
// and unlink it
rv = DFS_UnlinkFile(&vi, (unsigned char *)wfilename, scratch);
if (rv) {
printf("unlink failed\n");
return 0;
}
DFS_HostFlush(0);
first = 1;
}
// if this is the root dirtectory...
if (! i) {
// we're done
break;
}
// continue a previous directory
i--;
dirname[namei[i]] = '\0';
}
DFS_HostFlush(0);
total_ticks += ticks-ms;
return 1;
}
// function called by fopen
static int File_fopen(FILE *fp, const char *fname1, const char *mode)
{
int retval;
PFILEINFO fileinfo;
char fname[MAX_PATH];
uint8_t dfs_mode;
if (!dfs_mountflag && dfs_mount_defaults() != DFS_OK)
{
errno = EIO;
return -1;
}
dfs_resolve_path((char *)fname1, fname);
fileinfo = malloc(sizeof(FILEINFO) + FILE_BUFFER_SIZE);
if (!fileinfo)
{
errno = ENOMEM;
return -1;
}
if (mode[1] == '+')
dfs_mode = DFS_READ | DFS_WRITE;
else if (mode[0] == 'r')
dfs_mode = DFS_READ;
else
dfs_mode = DFS_WRITE;
if (mode[0] == 'w')
{
retval = DFS_OpenFile(&dfs_volinfo, (uint8_t *)fname, DFS_READ, dfs_scratch, fileinfo);
if (retval == DFS_OK)
DFS_UnlinkFile(&dfs_volinfo, (uint8_t *)fname, dfs_scratch);
retval = DFS_OpenFile(&dfs_volinfo, (uint8_t *)fname, dfs_mode, dfs_scratch, fileinfo);
}
else if (mode[0] == 'a')
{
retval = DFS_OpenFile(&dfs_volinfo, (uint8_t *)fname, dfs_mode, dfs_scratch, fileinfo);
}
else if (mode[0] == 'r')
{
retval = DFS_OpenFile(&dfs_volinfo, (uint8_t *)fname, DFS_READ, dfs_scratch, fileinfo);
if (retval == DFS_OK && (dfs_mode & DFS_WRITE))
retval = DFS_OpenFile(&dfs_volinfo, (uint8_t *)fname, dfs_mode, dfs_scratch, fileinfo);
}
else
{
errno = EINVAL;
free(fileinfo);
return -1;
}
if (retval != DFS_OK)
{
errno = dfs_stdio_errno(retval);
free(fileinfo);
return -1;
}
fp->drvarg[0] = (int)fileinfo;
// Set up file buffer in the FILE struct
fp->_ptr = fp->_base = ((void *)fileinfo) + sizeof(FILEINFO);
fp->_bsiz = FILE_BUFFER_SIZE;
fp->_flag |= _IOFREEBUF;
return 0;
}
