static FS_i32 _FS_fat_find_file(int Idx, FS_u32 Unit, const char *pFileName,
FS__fat_dentry_type *pDirEntry,
FS_u32 DirStart, FS_u32 DirSize) {
FS__fat_dentry_type *s;
FS_u32 i;
FS_u32 dsec;
int len;
int err;
int c;
char *buffer;
buffer = FS__fat_malloc(FS_FAT_SEC_SIZE);
if (!buffer) {
return -1;
}
len = FS__CLIB_strlen(pFileName);
if (len > 11) {
len = 11;
}
/* Read directory */
for (i = 0; i < DirSize; i++) {
dsec = FS__fat_dir_realsec(Idx, Unit, DirStart, i);
if (dsec == 0) {
FS__fat_free(buffer);
return -1;
}
err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, dsec, (void*)buffer);
if (err < 0) {
FS__fat_free(buffer);
return -1;
}
s = (FS__fat_dentry_type*)buffer;
while (1) {
if (s >= (FS__fat_dentry_type*)(buffer + FS_FAT_SEC_SIZE)) {
break; /* End of sector reached */
}
c = FS__CLIB_strncmp((char*)s->data, pFileName, len);
if (c == 0) { /* Name does match */
if (s->data[11] & FS_FAT_ATTR_ARCHIVE) {
break; /* Entry found */
}
}
s++;
}
if (s < (FS__fat_dentry_type*)(buffer + FS_FAT_SEC_SIZE)) {
/* Entry found. Return number of 1st block of the file */
if (pDirEntry) {
FS__CLIB_memcpy(pDirEntry, s, sizeof(FS__fat_dentry_type));
}
FS__fat_free(buffer);
dsec = (FS_u32)s->data[26];
dsec += (FS_u32)s->data[27] * 0x100UL;
dsec += (FS_u32)s->data[20] * 0x10000UL;
dsec += (FS_u32)s->data[21] * 0x1000000UL;
return ((FS_i32)dsec);
}
}
FS__fat_free(buffer);
return -1;
}
int FS__find_fsl(const char *pFullName, FS_FARCHARPTR *pFileName) {
int idx;
int i;
int j;
int m;
FS_FARCHARPTR s;
/* Find correct FSL (device:unit:name) */
s = (FS_FARCHARPTR)FS__CLIB_strchr(pFullName, ':');
if (s) {
/* Scan for device name */
idx = 0;
m = (int)((FS_u32)(s) - (FS_u32)(pFullName));
while (1) {
j = FS__CLIB_strlen(FS__pDevInfo[idx].devname);
if (m > j) {
j = m;
}
i = FS__CLIB_strncmp(FS__pDevInfo[idx].devname, pFullName, j);
idx++;
if (idx >= (int)FS__maxdev) {
break; /* End of device information table reached */
}
if (i == 0) {
break; /* Device found */
}
}
if (i == 0) {
idx--; /* Correct index */
}
else {
return -1; /* Device not found */
}
s++;
}
else {
/* use 1st FSL as default */
idx = 0;
s = (FS_FARCHARPTR) pFullName;
}
*pFileName = s;
return idx;
}
FS_i32 FS__fat_DeleteFileOrDir(int Idx, FS_u32 Unit, const char *pName,
FS_u32 DirStart, FS_u32 DirSize, char RmFile) {
FS__fat_dentry_type *s;
FS_u32 dsec;
FS_u32 i;
FS_u32 value;
FS_u32 fatsize;
FS_u32 filesize;
FS_i32 len;
FS_i32 bytespersec;
FS_i32 fatindex;
FS_i32 fatsec;
FS_i32 fatoffs;
FS_i32 lastsec;
FS_i32 curclst;
FS_i32 todo;
char *buffer;
int fattype;
int err;
int err2;
int lexp;
int x;
unsigned char a;
unsigned char b;
#if (FS_FAT_NOFAT32==0)
unsigned char c;
unsigned char d;
#endif /* FS_FAT_NOFAT32==0 */
buffer = FS__fat_malloc(FS_FAT_SEC_SIZE);
if (!buffer) {
return 0;
}
fattype = FS__fat_which_type(Idx, Unit);
#if (FS_FAT_NOFAT32!=0)
if (fattype == 2) {
FS__fat_free(buffer);
return -1;
}
#endif /* FS_FAT_NOFAT32!=0 */
fatsize = FS__FAT_aBPBUnit[Idx][Unit].FATSz16;
if (fatsize == 0) {
fatsize = FS__FAT_aBPBUnit[Idx][Unit].FATSz32;
}
bytespersec = (FS_i32)FS__FAT_aBPBUnit[Idx][Unit].BytesPerSec;
len = FS__CLIB_strlen(pName);
if (len > 11) {
len = 11;
}
/* Read directory */
for (i = 0; i < DirSize; i++) {
curclst = -1;
dsec = FS__fat_dir_realsec(Idx, Unit, DirStart, i);
if (dsec == 0) {
FS__fat_free(buffer);
return -1;
}
err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, dsec, (void*)buffer);
if (err < 0) {
FS__fat_free(buffer);
return -1;
}
/* Scan for pName in the directory sector */
s = (FS__fat_dentry_type*) buffer;
while (1) {
if (s >= (FS__fat_dentry_type*)(buffer + bytespersec)) {
break; /* End of sector reached */
}
x = FS__CLIB_strncmp((char*)s->data, pName, len);
if (x == 0) { /* Name does match */
if (s->data[11] != 0) {
break; /* Entry found */
}
}
s++;
}
if (s < (FS__fat_dentry_type*)(buffer + bytespersec)) {
/* Entry has been found, delete directory entry */
s->data[0] = 0xe5;
s->data[11] = 0;
err = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, dsec, (void*)buffer);
if (err < 0) {
FS__fat_free(buffer);
return -1;
}
/* Free blocks in FAT */
/*
For normal files, there are no more clusters freed than the entrie's filesize
does indicate. That avoids corruption of the complete media in case there is
no EOF mark found for the file (FAT is corrupt!!!).
If the function should remove a directory, filesize if always 0 and cannot
be used for that purpose. To avoid running into endless loop, todo is set
to 0x0ffffff8L, which is the maximum number of clusters for FAT32.
*/
if (RmFile) {
filesize = s->data[28] + 0x100UL * s->data[29] + 0x10000UL * s->data[30] + 0x1000000UL * s->data[31];
todo = filesize / (FS__FAT_aBPBUnit[Idx][Unit].SecPerClus * bytespersec);
value = filesize % (FS__FAT_aBPBUnit[Idx][Unit].SecPerClus * bytespersec);
if (value != 0) {
todo++;
}
}
else {
todo = (FS_i32)0x0ffffff8L;
}
curclst = s->data[26] + 0x100L * s->data[27] + 0x10000L * s->data[20] + 0x1000000L * s->data[21];
lastsec = -1;
/* Free cluster loop */
while (todo) {
if (fattype == 1) {
fatindex = curclst + (curclst / 2); /* FAT12 */
}
#if (FS_FAT_NOFAT32==0)
else if (fattype == 2) {
fatindex = curclst * 4; /* FAT32 */
}
#endif /* FS_FAT_NOFAT32==0 */
else {
fatindex = curclst * 2; /* FAT16 */
}
fatsec = FS__FAT_aBPBUnit[Idx][Unit].RsvdSecCnt + (fatindex / bytespersec);
fatoffs = fatindex % bytespersec;
if (fatsec != lastsec) {
err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)buffer);
if (err < 0) {
err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec, (void*)buffer);
if (err < 0) {
FS__fat_free(buffer);
return -1;
}
/* Try to repair original FAT sector with contents of copy */
FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)buffer);
}
lastsec = fatsec;
}
if (fattype == 1) {
if (fatoffs == (bytespersec - 1)) {
a = buffer[fatoffs];
if (curclst & 1) {
buffer[fatoffs] &= 0x0f;
}
else {
buffer[fatoffs] = 0x00;
}
err = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)buffer);
err2 = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec, (void*)buffer);
lexp = (err < 0);
lexp = lexp || (err2 < 0);
if (lexp) {
FS__fat_free(buffer);
return -1;
}
err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsec + 1, (void*)buffer);
if (err < 0) {
err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec + 1, (void*)buffer);
if (err < 0) {
FS__fat_free(buffer);
return -1;
}
/* Try to repair original FAT sector with contents of copy */
FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec + 1, (void*)buffer);
}
lastsec = fatsec + 1;
b = buffer[0];
if (curclst & 1) {
buffer[0] = 0x00;;
}
else {
buffer[0] &= 0xf0;
}
err = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec + 1, (void*)buffer);
err2 = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec + 1, (void*)buffer);
lexp = (err < 0);
lexp = lexp || (err2 < 0);
if (lexp) {
FS__fat_free(buffer);
return -1;
}
}
else {
a = buffer[fatoffs];
b = buffer[fatoffs + 1];
if (curclst & 1) {
buffer[fatoffs] &= 0x0f;
buffer[fatoffs + 1] = 0x00;
}
else {
buffer[fatoffs] = 0x00;
buffer[fatoffs + 1] &= 0xf0;
}
err = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)buffer);
err2 = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec, (void*)buffer);
lexp = (err < 0);
lexp = lexp || (err2 < 0);
if (lexp) {
FS__fat_free(buffer);
return -1;
}
}
if (curclst & 1) {
curclst = ((a & 0xf0) >> 4) + 16 * b;
}
else {
curclst = a + 256 * (b & 0x0f);
}
curclst &= 0x0fff;
if (curclst >= 0x0ff8) {
FS__fat_free(buffer);
return 0;
}
}
#if (FS_FAT_NOFAT32==0)
else if (fattype == 2) { /* FAT32 */
