960 lines
25 KiB
HolyC
Executable File
960 lines
25 KiB
HolyC
Executable File
U0 CDate2Dos(U16 *t,U16 *d,CDate cdt)
|
||
{
|
||
CDateStruct ds;
|
||
Date2Struct(&ds,cdt);
|
||
*d=ds.day_of_mon+(ds.mon+(ds.year-1980)<<4)<<5;
|
||
*t=ds.sec>>1+(ds.min+ds.hour<<6)<<5;
|
||
}
|
||
|
||
CDate Dos2CDate(U16 t,U16 d)
|
||
{
|
||
CDateStruct ds;
|
||
MemSet(&ds,0,sizeof(CDateStruct));
|
||
ds.day_of_mon=d&0x1F; d=d>>5;
|
||
ds.mon=d&0xF;
|
||
ds.year=d>>4+1980;
|
||
ds.sec=(t&0x1F)*2; t=t>>5;
|
||
ds.min=t&0x3F;
|
||
ds.hour=t>>6;
|
||
return Struct2Date(&ds);
|
||
}
|
||
|
||
U0 FAT32Init(CDrv *dv)
|
||
{
|
||
CFAT32Boot br32;
|
||
Bool unlock;
|
||
try {
|
||
unlock=DrvLock(dv);
|
||
dv->fs_type=FSt_FAT32;
|
||
BlkRead(dv,&br32,dv->drv_offset,1);
|
||
dv->file_system_info_sect=dv->drv_offset+br32.file_system_info_sect;
|
||
dv->fat1=dv->drv_offset+br32.reserved_sects;
|
||
dv->fat2=dv->fat1+br32.sects_per_fat;
|
||
dv->data_area=dv->fat2+br32.sects_per_fat
|
||
-2*br32.sects_per_clus; //Starts at Clus 2
|
||
dv->spc=br32.sects_per_clus;
|
||
dv->root_clus=br32.root_clus;
|
||
DrvFATBlkAlloc(dv);
|
||
Free(dv->fis);
|
||
dv->fis=AMAlloc(BLK_SIZE);
|
||
BlkRead(dv,dv->fis,dv->file_system_info_sect,1);
|
||
if (unlock)
|
||
DrvUnlock(dv);
|
||
} catch
|
||
if (unlock)
|
||
DrvUnlock(dv);
|
||
}
|
||
|
||
U0 FAT32Fmt(U8 drv_let,Bool quick=TRUE)
|
||
{
|
||
CFAT32Boot *br=CAlloc(BLK_SIZE);
|
||
CFAT32FileInfoSect *fis=CAlloc(BLK_SIZE);
|
||
CDrv *dv=Let2Drv(drv_let);
|
||
I64 i,l;
|
||
try {
|
||
DrvLock(dv);
|
||
DrvTypeSet(drv_let,FSt_FAT32);
|
||
dv->fs_type=FSt_FAT32;
|
||
br->jump_and_nop[0]=OC_JMP_REL8;
|
||
br->jump_and_nop[1]=offset(CFAT32Boot.code)-2;
|
||
br->jump_and_nop[2]=OC_NOP;
|
||
br->oem_name[0](I64)='MSWIN4.1';
|
||
br->bytes_per_sect=BLK_SIZE;
|
||
if (dv->size<= 500000)
|
||
br->sects_per_clus=1;
|
||
else if (dv->size<=2000000)
|
||
br->sects_per_clus=2;
|
||
else if (dv->size<=6000000)
|
||
br->sects_per_clus=4;
|
||
else if (dv->size<=12000000)
|
||
br->sects_per_clus=8;
|
||
else if (dv->size<=33000000)
|
||
br->sects_per_clus=16;
|
||
else if (dv->size<=67000000)
|
||
br->sects_per_clus=32;
|
||
else
|
||
br->sects_per_clus=64;
|
||
|
||
br->reserved_sects=32;
|
||
br->copies_of_fat=2;
|
||
br->media_desc=0xF8;
|
||
br->sects=dv->size;
|
||
l=(br->sects/br->sects_per_clus)>>(BLK_SIZE_BITS-2)+1;
|
||
br->sects_per_fat=l;
|
||
br->root_clus=2;
|
||
br->file_system_info_sect=1;
|
||
br->log_drv_num=0x80;
|
||
br->ext_signature=0x29;
|
||
br->serial_num=RandU32;
|
||
MemCpy(br->vol_name,"NO NAME ",11);
|
||
br->fat_name[0](I64)='FAT32 ';
|
||
br->signature=0xAA55;
|
||
fis->signature1='RRaA';
|
||
fis->signature2='rrAa';
|
||
fis->free_clus=-1;
|
||
fis->most_recently_alloced=0;
|
||
fis->signature3=0xAA550000;
|
||
|
||
if (quick)
|
||
i=br->reserved_sects+2*l+4*br->sects_per_clus;
|
||
else
|
||
i=dv->size;
|
||
BlkWriteZero(dv,dv->drv_offset,i);
|
||
|
||
BlkWrite(dv,fis,dv->drv_offset+br->file_system_info_sect,1);
|
||
BlkWrite(dv,br,dv->drv_offset,1);
|
||
FAT32Init(dv);
|
||
ClusAlloc(dv,0,1,FALSE); //Alloc #1
|
||
br->root_clus=ClusAlloc(dv,0,1,FALSE);
|
||
BlkWrite(dv,br,dv->drv_offset,1);
|
||
FAT32Init(dv);
|
||
DrvUnlock(dv);
|
||
} catch
|
||
DrvUnlock(dv);
|
||
Free(br);
|
||
Free(fis);
|
||
}
|
||
|
||
Bool FATNameTo(U8 *dst,U8 *src)
|
||
{
|
||
I64 i;
|
||
MemSet(dst,CH_SPACE,11);
|
||
if (!FileNameChk(src))
|
||
return FALSE;
|
||
if (!StrCmp(src,"..")) {
|
||
*dst='.';
|
||
dst[1]='.';
|
||
return TRUE;
|
||
} else if (!StrCmp(src,".")) {
|
||
*dst='.';
|
||
return TRUE;
|
||
}
|
||
i=0;
|
||
while (i<8 && *src && *src!='.')
|
||
dst[i++]=ToUpper(*src++);
|
||
i=8;
|
||
if (*src=='.') src++;
|
||
while (*src)
|
||
if (*src!='.')
|
||
dst[i++]=ToUpper(*src++);
|
||
else
|
||
src++;
|
||
return TRUE;
|
||
}
|
||
|
||
I64 FATNameXSum(U8 *src)
|
||
{
|
||
I64 i,res=0;
|
||
for (i=0;i<11;i++)
|
||
if (res&1)
|
||
res.u8[0]=0x80+res>>1+*src++;
|
||
else
|
||
res.u8[0]=res>>1+*src++;
|
||
return res;
|
||
}
|
||
|
||
Bool FATFromName(U8 *dst,U8 *src)
|
||
{
|
||
I64 i,j,k=0;
|
||
for (j=7;j>=0 && src[j]==CH_SPACE;j--);
|
||
for(i=0;i<=j;i++)
|
||
dst[k++]=src[i];
|
||
for (j=10;j>=8 && src[j]==CH_SPACE;j--);
|
||
if (*src!='.' && j!=7)
|
||
dst[k++]='.';
|
||
for(i=8;i<=j;i++)
|
||
dst[k++]=src[i];
|
||
dst[k++]=0;
|
||
return FileNameChk(dst);
|
||
}
|
||
|
||
U8 fat_long_name_map[13]={
|
||
offset(CFAT32DirEntryLong.name1),
|
||
offset(CFAT32DirEntryLong.name1)+2,
|
||
offset(CFAT32DirEntryLong.name1)+4,
|
||
offset(CFAT32DirEntryLong.name1)+6,
|
||
offset(CFAT32DirEntryLong.name1)+8,
|
||
offset(CFAT32DirEntryLong.name2),
|
||
offset(CFAT32DirEntryLong.name2)+2,
|
||
offset(CFAT32DirEntryLong.name2)+4,
|
||
offset(CFAT32DirEntryLong.name2)+6,
|
||
offset(CFAT32DirEntryLong.name2)+8,
|
||
offset(CFAT32DirEntryLong.name2)+10,
|
||
offset(CFAT32DirEntryLong.name3),
|
||
offset(CFAT32DirEntryLong.name3)+2
|
||
};
|
||
|
||
Bool DirLongNameFill(CDirEntry *tmpde,CFAT32DirEntryLong *de,I64 *xsum)
|
||
{
|
||
I64 i;
|
||
U8 *ptr=de;
|
||
if (de->ord&0x40) {
|
||
MemSet(tmpde,0,sizeof(CDirEntry));
|
||
*xsum=de->xsum;
|
||
} else if (de->type || de->zero || de->xsum!=*xsum) {
|
||
MemSet(tmpde,0,sizeof(CDirEntry));
|
||
*xsum=0;
|
||
return FALSE;
|
||
}
|
||
switch (de->ord&0x3F) {
|
||
case 1:
|
||
for (i=0;i<13;i++)
|
||
if (!(tmpde->name[i]=ptr[fat_long_name_map[i]]))
|
||
return TRUE;
|
||
break;
|
||
case 2:
|
||
for (i=0;i<12;i++)
|
||
if (!(tmpde->name[i+13]=ptr[fat_long_name_map[i]]))
|
||
return TRUE;
|
||
break;
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
Bool FAT32CDirFill(CDirEntry *tmpde,
|
||
CFAT32DirEntry *de,CDate _local_time_offset)
|
||
{
|
||
Bool res;
|
||
if (*tmpde->name)
|
||
res=TRUE;
|
||
else
|
||
res=FATFromName(tmpde->name,de->name);
|
||
tmpde->clus=de->clus_lo+de->clus_hi<<16;
|
||
tmpde->size=de->size;
|
||
tmpde->attr=de->attr;
|
||
tmpde->datetime=Dos2CDate(de->WrtTime,de->WrtDate)-_local_time_offset;
|
||
return res;
|
||
}
|
||
|
||
Bool FAT32DirFill(CFAT32DirEntry *de,
|
||
CDirEntry *tmpde,I64 *_de_cnt,CDate _local_time_offset)
|
||
{//Fill up to 3 entries and store cnt of entries.
|
||
I64 de_cnt=0,i,l,xsum,ord;
|
||
U8 *ptr,dname[16];
|
||
CFAT32DirEntryLong *ld=de;
|
||
Bool res;
|
||
|
||
MemSet(de,0,sizeof(CFAT32DirEntry));
|
||
res=FATNameTo(de->name,tmpde->name);
|
||
FATFromName(dname,de->name);
|
||
if (StrCmp(dname,tmpde->name)) {
|
||
ord=0x41;
|
||
xsum=FATNameXSum(de->name);
|
||
if ((l=StrLen(tmpde->name))>13) {
|
||
ptr=&ld[de_cnt];
|
||
MemSet(ptr,0,sizeof(CFAT32DirEntryLong));
|
||
ld[de_cnt].attr=RS_ATTR_LONG_NAME;
|
||
ld[de_cnt].xsum=xsum;
|
||
ld[de_cnt].ord=0x42;
|
||
for (i=13;i<l;i++)
|
||
ptr[fat_long_name_map[i-13]]=tmpde->name[i];
|
||
i++;
|
||
for (;i<26;i++)
|
||
ptr[fat_long_name_map[i-13]](U16)=0xFFFF;
|
||
ord=1;
|
||
l=13;
|
||
de_cnt++;
|
||
}
|
||
ptr=&de[de_cnt];
|
||
MemSet(ptr,0,sizeof(CFAT32DirEntryLong));
|
||
ld[de_cnt].attr=RS_ATTR_LONG_NAME;
|
||
ld[de_cnt].xsum=xsum;
|
||
ld[de_cnt].ord=ord;
|
||
for (i=0;i<l;i++)
|
||
ptr[fat_long_name_map[i]]=tmpde->name[i];
|
||
i++;
|
||
for (;i<13;i++)
|
||
ptr[fat_long_name_map[i]](U16)=0xFFFF;
|
||
de_cnt++;
|
||
MemSet(&de[de_cnt],0,sizeof(CFAT32DirEntry));
|
||
res=FATNameTo(de[de_cnt].name,tmpde->name);
|
||
}
|
||
de[de_cnt].clus_lo=tmpde->clus.u16[0];
|
||
de[de_cnt].clus_hi=tmpde->clus.u16[1];
|
||
if (!(tmpde->attr&RS_ATTR_DIR))
|
||
de[de_cnt].size=tmpde->size;
|
||
de[de_cnt].attr=tmpde->attr;
|
||
if (!tmpde->datetime)
|
||
tmpde->datetime=Now;
|
||
CDate2Dos(&de[de_cnt].WrtTime,&de[de_cnt].WrtDate,
|
||
tmpde->datetime+_local_time_offset);
|
||
if (_de_cnt)
|
||
*_de_cnt=de_cnt+1;
|
||
return res;
|
||
}
|
||
|
||
Bool FAT32FileFind(CDrv *dv,I64 cur_dir_clus,
|
||
U8 *name,CDirEntry *_res,I64 fuf_flags=0)
|
||
{//$LK,"FUF_JUST_DIRS",A="MN:FUF_JUST_DIRS"$, $LK,"FUF_JUST_FILES",A="MN:FUF_JUST_FILES"$
|
||
Bool res=FALSE,unlock;
|
||
CFAT32DirEntry *buf;
|
||
I64 xsum=0,attr,cur_dir_entry,entries_per_clus;
|
||
U8 dname[CDIR_FILENAME_LEN],ch;
|
||
CDirEntry long_name;
|
||
if (fuf_flags&~FUG_FILE_FIND)
|
||
throw('FUF');
|
||
MemSet(_res,0,sizeof(CDirEntry));
|
||
MemSet(&long_name,0,sizeof(CDirEntry));
|
||
DrvChk(dv);
|
||
if (dv->fs_type!=FSt_FAT32)
|
||
PrintErr("Not FAT32 Drv\n");
|
||
else if (!CFileNameTo(dname,name))
|
||
PrintErr("Invalid FileName: \"%s\".\n",name);
|
||
else
|
||
try {
|
||
unlock=DrvLock(dv);
|
||
buf=MAlloc(BLK_SIZE*dv->spc);
|
||
entries_per_clus=dv->spc<<FAT32_ENTRIES_BITS;
|
||
ClusRead(dv,buf,cur_dir_clus,1);
|
||
cur_dir_entry=0;
|
||
while (ch=*buf[cur_dir_entry].name) {
|
||
attr=buf[cur_dir_entry].attr;
|
||
if (ch!=0xE5) {
|
||
if (attr&RS_ATTR_LONG_NAME_MASK==RS_ATTR_LONG_NAME)
|
||
DirLongNameFill(&long_name,&buf[cur_dir_entry],&xsum);
|
||
else {
|
||
if (!(attr&RS_ATTR_VOL_ID)) {
|
||
if (xsum==FATNameXSum(buf[cur_dir_entry].name))
|
||
MemCpy(_res,&long_name,sizeof(CDirEntry));
|
||
else
|
||
MemSet(_res,0,sizeof(CDirEntry));
|
||
if (!(fuf_flags&FUF_JUST_DIRS && !(attr & RS_ATTR_DIR)) &&
|
||
!(fuf_flags&FUF_JUST_FILES && attr & RS_ATTR_DIR) &&
|
||
FAT32CDirFill(_res,&buf[cur_dir_entry],
|
||
dv->fat32_local_time_offset) &&
|
||
!StrCmp(dname,_res->name)) {
|
||
res=TRUE;
|
||
goto fff_done;
|
||
}
|
||
}
|
||
MemSet(&long_name,0,sizeof(CDirEntry));
|
||
}
|
||
} else
|
||
MemSet(&long_name,0,sizeof(CDirEntry));
|
||
if (++cur_dir_entry==entries_per_clus) {
|
||
cur_dir_clus=ClusNumNext(dv,cur_dir_clus);
|
||
if (!(0<cur_dir_clus<0x0FFFFFF8))
|
||
break;
|
||
else {
|
||
ClusRead(dv,buf,cur_dir_clus,1);
|
||
cur_dir_entry=0;
|
||
}
|
||
}
|
||
}
|
||
MemSet(_res,0,sizeof(CDirEntry));
|
||
fff_done:
|
||
Free(buf);
|
||
if (unlock)
|
||
DrvUnlock(dv);
|
||
} catch
|
||
if (unlock)
|
||
DrvUnlock(dv);
|
||
return res;
|
||
}
|
||
|
||
U8 *FAT32FileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
|
||
{
|
||
U8 *buf=NULL;
|
||
CDirEntry de;
|
||
I64 c,blk_cnt,cur_dir_clus;
|
||
DrvChk(dv);
|
||
*_size=0;
|
||
*_attr=0;
|
||
if (dv->fs_type!=FSt_FAT32)
|
||
PrintErr("Not FAT32 Drv\n");
|
||
else
|
||
try {
|
||
DrvLock(dv);
|
||
cur_dir_clus=Name2DirClus(dv,cur_dir);
|
||
if (FAT32FileFind(dv,cur_dir_clus,filename,&de,FUF_JUST_FILES)) {
|
||
blk_cnt=(de.size+BLK_SIZE-1)>>BLK_SIZE_BITS;
|
||
buf=MAlloc(blk_cnt<<BLK_SIZE_BITS+1);
|
||
c=de.clus;
|
||
if (!(0<c<0x0FFFFFF8))
|
||
c=0x0FFFFFFF;
|
||
else
|
||
c=ClusBlkRead(dv,buf,c,blk_cnt);
|
||
buf[de.size]=0; //Terminate
|
||
*_size=de.size;
|
||
*_attr=FileAttr(de.name,de.attr);
|
||
}
|
||
DrvUnlock(dv);
|
||
} catch
|
||
DrvUnlock(dv);
|
||
return buf;
|
||
}
|
||
|
||
Bool FAT32Cd(U8 *name,I64 cur_dir_clus)
|
||
{
|
||
CDirEntry de;
|
||
if (Fs->cur_dv->fs_type!=FSt_FAT32)
|
||
PrintErr("Not FAT32 Drv\n");
|
||
else if (FAT32FileFind(Fs->cur_dv,cur_dir_clus,name,&de,FUF_JUST_DIRS))
|
||
return TRUE;
|
||
else
|
||
PrintErr("File not found: \"%s\".\n",name);
|
||
return FALSE;
|
||
}
|
||
|
||
U0 FAT32FreeClus(CDrv *dv,I64 c)
|
||
{
|
||
I64 next,saved_c=c;
|
||
Bool unlock,unlock_break;
|
||
DrvChk(dv);
|
||
if (!(0<c<0x0FFFFFF8)) return;
|
||
if (dv->fs_type!=FSt_FAT32)
|
||
PrintErr("Not FAT32 Drv\n");
|
||
else
|
||
try {
|
||
unlock_break=BreakLock;
|
||
unlock=DrvLock(dv);
|
||
DrvFATBlkClean(dv);
|
||
do {
|
||
DrvFATBlkSet(dv,c,0);
|
||
next=dv->cur_fat_blk[c&(BLK_SIZE/4-1)];
|
||
dv->cur_fat_blk[c&(BLK_SIZE/4-1)]=0;
|
||
LBts(&dv->fat_blk_dirty,0);
|
||
c=next;
|
||
} while (0<c<0x0FFFFFF8);
|
||
DrvFATBlkClean(dv,0);
|
||
|
||
c=saved_c;
|
||
do {
|
||
DrvFATBlkSet(dv,c,1);
|
||
next=dv->cur_fat_blk[c&(BLK_SIZE/4-1)];
|
||
dv->cur_fat_blk[c&(BLK_SIZE/4-1)]=0;
|
||
LBts(&dv->fat_blk_dirty,0);
|
||
c=next;
|
||
} while (0<c<0x0FFFFFF8);
|
||
DrvFATBlkClean(dv,1);
|
||
if (unlock)
|
||
DrvUnlock(dv);
|
||
if (unlock_break)
|
||
BreakUnlock;
|
||
} catch {
|
||
if (unlock)
|
||
DrvUnlock(dv);
|
||
if (unlock_break)
|
||
BreakUnlock;
|
||
}
|
||
}
|
||
|
||
I64 FAT32AllocClus(CDrv *dv,I64 c,I64 cnt)
|
||
{
|
||
Bool wrap_around=FALSE,unlock,unlock_break;
|
||
I64 first=INVALID_CLUS,j,l;
|
||
|
||
if (cnt<=0) return 0x0FFFFFFF;
|
||
try {
|
||
unlock_break=BreakLock;
|
||
unlock=DrvLock(dv);
|
||
l=(dv->size+dv->drv_offset-dv->data_area)/dv->spc-1;
|
||
j=dv->fis->most_recently_alloced;
|
||
while (cnt-->0) {
|
||
while (TRUE) {
|
||
j++;
|
||
if (j<1) j=1;
|
||
if (j>=l) {
|
||
if (wrap_around)
|
||
throw('Drv');
|
||
j=1;
|
||
wrap_around=TRUE;
|
||
}
|
||
DrvFATBlkSet(dv,j);
|
||
if (!dv->cur_fat_blk[j&(BLK_SIZE/4-1)])
|
||
break;
|
||
}
|
||
if (!(0<first<0x0FFFFFF8))
|
||
first=j;
|
||
if (0<c<l) {
|
||
DrvFATBlkSet(dv,c);
|
||
dv->cur_fat_blk[c&(BLK_SIZE/4-1)]=j;
|
||
LBts(&dv->fat_blk_dirty,0);
|
||
}
|
||
c=j;
|
||
}
|
||
|
||
if (0<c<l) {
|
||
DrvFATBlkSet(dv,c);
|
||
dv->cur_fat_blk[c&(BLK_SIZE/4-1)]=0x0FFFFFFF;
|
||
LBts(&dv->fat_blk_dirty,0);
|
||
}
|
||
DrvFATBlkClean(dv);
|
||
|
||
dv->fis->most_recently_alloced=j;
|
||
dv->fis->free_clus=-1;
|
||
BlkWrite(dv,dv->fis,dv->file_system_info_sect,1);
|
||
} catch {
|
||
if (unlock)
|
||
DrvUnlock(dv);
|
||
if (unlock_break)
|
||
BreakUnlock;
|
||
}
|
||
if (unlock)
|
||
DrvUnlock(dv);
|
||
if (unlock_break)
|
||
BreakUnlock;
|
||
return first;
|
||
}
|
||
|
||
I64 FAT32AllocContiguousClus(CDrv *dv,I64 cnt)
|
||
{
|
||
I64 i,first=1;
|
||
Bool cont,unlock,unlock_break;
|
||
|
||
if (cnt<=0) return 0x0FFFFFFF;
|
||
try {
|
||
unlock_break=BreakLock;
|
||
unlock=DrvLock(dv);
|
||
while (TRUE) {
|
||
first++;
|
||
i=0;
|
||
cont=TRUE;
|
||
while (cont && i<cnt) {
|
||
if ((first+i+1)*dv->spc+dv->data_area>dv->size+dv->drv_offset)
|
||
throw('Drv');
|
||
DrvFATBlkSet(dv,first+i);
|
||
if (dv->cur_fat_blk[(first+i)&(BLK_SIZE/4-1)])
|
||
cont=FALSE;
|
||
else
|
||
i++;
|
||
}
|
||
if (!cont)
|
||
first=first+i;
|
||
else {
|
||
DrvFATBlkClean(dv);
|
||
|
||
for (i=0;i<cnt;i++) {
|
||
DrvFATBlkSet(dv,first+i,0);
|
||
if (i+1==cnt)
|
||
dv->cur_fat_blk[(first+i)&(BLK_SIZE/4-1)]=0x0FFFFFFF;
|
||
else
|
||
dv->cur_fat_blk[(first+i)&(BLK_SIZE/4-1)]=first+i+1;
|
||
LBts(&dv->fat_blk_dirty,0);
|
||
}
|
||
DrvFATBlkClean(dv,0);
|
||
|
||
for (i=0;i<cnt;i++) {
|
||
DrvFATBlkSet(dv,first+i,1);
|
||
if (i+1==cnt)
|
||
dv->cur_fat_blk[(first+i)&(BLK_SIZE/4-1)]=0x0FFFFFFF;
|
||
else
|
||
dv->cur_fat_blk[(first+i)&(BLK_SIZE/4-1)]=first+i+1;
|
||
LBts(&dv->fat_blk_dirty,0);
|
||
}
|
||
DrvFATBlkClean(dv,1);
|
||
break;
|
||
}
|
||
}
|
||
} catch {
|
||
if (unlock)
|
||
DrvUnlock(dv);
|
||
if (unlock_break)
|
||
BreakUnlock;
|
||
}
|
||
if (unlock)
|
||
DrvUnlock(dv);
|
||
if (unlock_break)
|
||
BreakUnlock;
|
||
return first;
|
||
}
|
||
|
||
Bool FAT32DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tmpde,Bool free_old_chain)
|
||
{
|
||
//See $LK,"::/Doc/CutCorners.DD"$.
|
||
CFAT32DirEntry *buf,*last_buf,*tmp_buf,de[3];
|
||
I64 i,attr,avail_cnt,de_cnt,c,
|
||
cur_dir_entry,entries_per_clus,
|
||
cur_dir_clus,xsum=0,last_dir_clus=INVALID_CLUS;
|
||
U8 ch;
|
||
Bool written=FALSE,unlock,unlock_break;
|
||
CDirEntry long_name;
|
||
FAT32DirFill(&de,tmpde,&de_cnt,dv->fat32_local_time_offset);
|
||
MemSet(&long_name,0,sizeof(CDirEntry));
|
||
try {
|
||
unlock_break=BreakLock;
|
||
unlock=DrvLock(dv);
|
||
cur_dir_clus=Name2DirClus(dv,cur_dir);
|
||
buf =MAlloc(BLK_SIZE*dv->spc);
|
||
last_buf=CAlloc(BLK_SIZE*dv->spc);
|
||
entries_per_clus=dv->spc<<FAT32_ENTRIES_BITS;
|
||
ClusRead(dv,buf,cur_dir_clus,1);
|
||
cur_dir_entry=0;
|
||
while (ch=*buf[cur_dir_entry].name) {
|
||
attr=buf[cur_dir_entry].attr;
|
||
if (ch!=0xE5 && attr&RS_ATTR_LONG_NAME_MASK==RS_ATTR_LONG_NAME)
|
||
DirLongNameFill(&long_name,&buf[cur_dir_entry],&xsum);
|
||
else {
|
||
avail_cnt=FAT32_ENTRIES_PER_BLK-cur_dir_entry
|
||
&(FAT32_ENTRIES_PER_BLK-1);
|
||
for (i=0;i<avail_cnt;i++)
|
||
if (*buf[cur_dir_entry+i].name!=0xE5) {
|
||
if (*buf[cur_dir_entry+i].name)
|
||
avail_cnt=i;
|
||
break;
|
||
}
|
||
if (ch==0xE5 && !written && avail_cnt>=de_cnt) {
|
||
MemCpy(&buf[cur_dir_entry],&de,de_cnt*sizeof(CFAT32DirEntry));
|
||
BlkWrite(dv,&buf[cur_dir_entry & -FAT32_ENTRIES_PER_BLK],
|
||
dv->data_area+cur_dir_clus*dv->spc
|
||
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
|
||
cur_dir_entry+=de_cnt-1; //gets inc'ed
|
||
written=TRUE;
|
||
} else if (ch!=0xE5 && !(attr&RS_ATTR_VOL_ID)) {
|
||
if (xsum!=FATNameXSum(buf[cur_dir_entry].name))
|
||
MemSet(&long_name,0,sizeof(CDirEntry));
|
||
if (!*long_name.name)
|
||
FATFromName(long_name.name,buf[cur_dir_entry].name);
|
||
//Del old entry with same name
|
||
if (!StrCmp(long_name.name,tmpde->name)) {
|
||
if (free_old_chain)
|
||
FAT32FreeClus(dv,buf[cur_dir_entry].clus_lo+
|
||
buf[cur_dir_entry].clus_hi<<16);
|
||
if (!written) {
|
||
MemCpy(&buf[cur_dir_entry],&de[de_cnt-1],sizeof(CFAT32DirEntry));
|
||
BlkWrite(dv,&buf[cur_dir_entry & -FAT32_ENTRIES_PER_BLK],
|
||
dv->data_area+cur_dir_clus*dv->spc
|
||
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
|
||
written=TRUE;
|
||
} else {
|
||
*buf[cur_dir_entry].name=0xE5;
|
||
i=1;
|
||
while (i<=cur_dir_entry &&
|
||
buf[cur_dir_entry-i].attr&RS_ATTR_LONG_NAME_MASK
|
||
==RS_ATTR_LONG_NAME)
|
||
*buf[cur_dir_entry-i++].name=0xE5;
|
||
i--;
|
||
BlkWrite(dv,&buf[(cur_dir_entry-i)&-FAT32_ENTRIES_PER_BLK],
|
||
dv->data_area+cur_dir_clus*dv->spc
|
||
+(cur_dir_entry-i)>>FAT32_ENTRIES_BITS,
|
||
(i+FAT32_ENTRIES_PER_BLK)>>FAT32_ENTRIES_BITS);
|
||
if (i==cur_dir_entry && 0<last_dir_clus<0x0FFFFFF8) {
|
||
i=1;
|
||
while (i<=entries_per_clus &&
|
||
last_buf[entries_per_clus-i].attr
|
||
&RS_ATTR_LONG_NAME_MASK==RS_ATTR_LONG_NAME)
|
||
*last_buf[entries_per_clus-i++].name=0xE5;
|
||
if (--i>0)
|
||
BlkWrite(dv,&buf[(entries_per_clus-i)&-FAT32_ENTRIES_PER_BLK],
|
||
dv->data_area+last_dir_clus*dv->spc
|
||
+(entries_per_clus-i)>>FAT32_ENTRIES_BITS,
|
||
(i+FAT32_ENTRIES_PER_BLK-1)>>FAT32_ENTRIES_BITS);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
MemSet(&long_name,0,sizeof(CDirEntry));
|
||
}
|
||
if (++cur_dir_entry==entries_per_clus) {
|
||
last_dir_clus=cur_dir_clus;
|
||
tmp_buf=buf; buf=last_buf; last_buf=tmp_buf;
|
||
c=ClusNumNext(dv,cur_dir_clus);
|
||
if (!(0<c<0x0FFFFFF8)) {
|
||
c=ClusAlloc(dv,cur_dir_clus,1,FALSE);
|
||
MemSet(buf,0,BLK_SIZE*dv->spc);
|
||
ClusWrite(dv,buf,c,1);
|
||
} else
|
||
ClusRead(dv,buf,c,1);
|
||
cur_dir_clus=c;
|
||
cur_dir_entry=0;
|
||
}
|
||
}
|
||
if (!written) {
|
||
avail_cnt=FAT32_ENTRIES_PER_BLK-cur_dir_entry & (FAT32_ENTRIES_PER_BLK-1);
|
||
if (avail_cnt<de_cnt) {
|
||
for (i=0;i<avail_cnt;i++)
|
||
*buf[cur_dir_entry+i].name=0xE5;
|
||
BlkWrite(dv,&buf[cur_dir_entry &-FAT32_ENTRIES_PER_BLK],
|
||
dv->data_area+cur_dir_clus*dv->spc
|
||
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
|
||
cur_dir_entry+=avail_cnt;
|
||
if (cur_dir_entry==entries_per_clus) {
|
||
last_dir_clus=cur_dir_clus;
|
||
tmp_buf=buf; buf=last_buf; last_buf=tmp_buf;
|
||
cur_dir_clus=ClusAlloc(dv,cur_dir_clus,1);
|
||
cur_dir_entry=0;
|
||
MemSet(buf,0,BLK_SIZE*dv->spc);
|
||
ClusWrite(dv,buf,cur_dir_clus,1);
|
||
}
|
||
}
|
||
MemCpy(&buf[cur_dir_entry],&de,de_cnt*sizeof(CFAT32DirEntry));
|
||
BlkWrite(dv,&buf[cur_dir_entry &-FAT32_ENTRIES_PER_BLK],
|
||
dv->data_area+cur_dir_clus*dv->spc+
|
||
cur_dir_entry>>FAT32_ENTRIES_BITS,1);
|
||
cur_dir_entry+=de_cnt;
|
||
if (cur_dir_entry==entries_per_clus) {
|
||
cur_dir_clus=ClusAlloc(dv,cur_dir_clus,1);
|
||
MemSet(buf,0,BLK_SIZE*dv->spc);
|
||
ClusWrite(dv,buf,cur_dir_clus,1);
|
||
} else {
|
||
MemSet(&buf[cur_dir_entry],0,sizeof(CFAT32DirEntry));
|
||
BlkWrite(dv,&buf[cur_dir_entry &-FAT32_ENTRIES_PER_BLK],
|
||
dv->data_area+cur_dir_clus*dv->spc
|
||
+cur_dir_entry>>FAT32_ENTRIES_BITS,1);
|
||
}
|
||
}
|
||
Free(last_buf);
|
||
Free(buf);
|
||
if (unlock)
|
||
DrvUnlock(dv);
|
||
if (unlock_break)
|
||
BreakUnlock;
|
||
} catch {
|
||
if (unlock)
|
||
DrvUnlock(dv);
|
||
if (unlock_break)
|
||
BreakUnlock;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
I64 FAT32FilesDel(CDrv *dv,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
|
||
Bool del_dir,Bool print_msg)
|
||
{
|
||
CFAT32DirEntry *buf,*last_buf,*tmp_buf;
|
||
I64 i,res=0,attr,xsum=0,last_dir_clus=INVALID_CLUS,
|
||
cur_dir_entry,entries_per_clus,cur_dir_clus;
|
||
U8 ch;
|
||
Bool unlock_break;
|
||
CDirEntry long_name;
|
||
MemSet(&long_name,0,sizeof(CDirEntry));
|
||
try {
|
||
unlock_break=BreakLock;
|
||
DrvLock(dv);
|
||
cur_dir_clus=Name2DirClus(dv,cur_dir);
|
||
buf =MAlloc(BLK_SIZE*dv->spc);
|
||
last_buf=CAlloc(BLK_SIZE*dv->spc);
|
||
entries_per_clus=dv->spc<<FAT32_ENTRIES_BITS;
|
||
ClusRead(dv,buf,cur_dir_clus,1);
|
||
cur_dir_entry=0;
|
||
while (ch=*buf[cur_dir_entry].name) {
|
||
attr=buf[cur_dir_entry].attr;
|
||
if (ch!=0xE5 && ch!='.') {
|
||
if (attr&RS_ATTR_LONG_NAME_MASK==RS_ATTR_LONG_NAME)
|
||
DirLongNameFill(&long_name,&buf[cur_dir_entry],&xsum);
|
||
else {
|
||
if (!(attr & RS_ATTR_VOL_ID) &&
|
||
(del_dir || !(attr & RS_ATTR_DIR))) {
|
||
if (xsum!=FATNameXSum(buf[cur_dir_entry].name))
|
||
MemSet(&long_name,0,sizeof(CDirEntry));
|
||
if (!*long_name.name)
|
||
FATFromName(long_name.name,buf[cur_dir_entry].name);
|
||
if (FilesFindMatch(long_name.name,files_find_mask,fuf_flags)) {
|
||
if (!(attr & RS_ATTR_DIR)) res++;
|
||
if (print_msg)
|
||
"Del %s\n",long_name.name;
|
||
*buf[cur_dir_entry].name=0xE5;
|
||
i=1;
|
||
while (i<=cur_dir_entry &&
|
||
buf[cur_dir_entry-i].attr&RS_ATTR_LONG_NAME_MASK
|
||
==RS_ATTR_LONG_NAME)
|
||
*buf[cur_dir_entry-i++].name=0xE5;
|
||
i--;
|
||
BlkWrite(dv,&buf[(cur_dir_entry-i)&-FAT32_ENTRIES_PER_BLK],
|
||
dv->data_area+cur_dir_clus*dv->spc
|
||
+(cur_dir_entry-i)>>FAT32_ENTRIES_BITS,
|
||
(i+FAT32_ENTRIES_PER_BLK)>>FAT32_ENTRIES_BITS);
|
||
if (i==cur_dir_entry && last_dir_clus!=INVALID_CLUS) {
|
||
i=1;
|
||
while (i<=entries_per_clus &&
|
||
last_buf[entries_per_clus-i].attr
|
||
&RS_ATTR_LONG_NAME_MASK==RS_ATTR_LONG_NAME)
|
||
*last_buf[entries_per_clus-i++].name=0xE5;
|
||
if (--i>0)
|
||
BlkWrite(dv,&buf[(entries_per_clus-i)&-FAT32_ENTRIES_PER_BLK],
|
||
dv->data_area+last_dir_clus*dv->spc
|
||
+(entries_per_clus-i)>>FAT32_ENTRIES_BITS,
|
||
(i+FAT32_ENTRIES_PER_BLK-1)>>FAT32_ENTRIES_BITS);
|
||
}
|
||
FAT32FreeClus(dv,buf[cur_dir_entry].clus_lo+
|
||
buf[cur_dir_entry].clus_hi<<16);
|
||
}
|
||
}
|
||
MemSet(&long_name,0,sizeof(CDirEntry));
|
||
}
|
||
} else
|
||
MemSet(&long_name,0,sizeof(CDirEntry));
|
||
if (++cur_dir_entry==entries_per_clus) {
|
||
last_dir_clus=cur_dir_clus;
|
||
cur_dir_clus=ClusNumNext(dv,cur_dir_clus,1);
|
||
tmp_buf=buf; buf=last_buf; last_buf=tmp_buf;
|
||
ClusRead(dv,buf,cur_dir_clus,1);
|
||
cur_dir_entry=0;
|
||
}
|
||
}
|
||
Free(buf);
|
||
Free(last_buf);
|
||
DrvUnlock(dv);
|
||
if (unlock_break)
|
||
BreakUnlock;
|
||
} catch {
|
||
DrvUnlock(dv);
|
||
if (unlock_break)
|
||
BreakUnlock;
|
||
}
|
||
return res;
|
||
}
|
||
|
||
I64 FAT32FileWrite(CDrv *dv,U8 *cur_dir,U8 *name,U8 *buf,I64 size,
|
||
CDate cdt,I64 attr)
|
||
{
|
||
CDirEntry de;
|
||
I64 c=0,blk_cnt;
|
||
Bool contiguous;
|
||
MemSet(&de,0,sizeof(CDirEntry));
|
||
if (size<0) size=0;
|
||
if (dv->fs_type!=FSt_FAT32)
|
||
PrintErr("Not FAT32 Drv\n");
|
||
else if (!CFileNameTo(de.name,name))
|
||
PrintErr("Invalid FileName: \"%s\".\n",name);
|
||
else {
|
||
FAT32FilesDel(dv,cur_dir,de.name,0,FALSE,FALSE);
|
||
if (attr & RS_ATTR_CONTIGUOUS)
|
||
contiguous=TRUE;
|
||
else
|
||
contiguous=FALSE;
|
||
de.size=size;
|
||
if (blk_cnt=(size+BLK_SIZE-1)>>BLK_SIZE_BITS)
|
||
c=ClusAlloc(dv,0,(blk_cnt+dv->spc-1)/dv->spc,contiguous);
|
||
else
|
||
c=0x0FFFFFFF;
|
||
de.clus=c;
|
||
de.attr=attr;
|
||
de.datetime=cdt;
|
||
if (blk_cnt)
|
||
ClusBlkWrite(dv,buf,c,blk_cnt);
|
||
FAT32DirNew(dv,cur_dir,&de,TRUE);
|
||
}
|
||
return c;
|
||
}
|
||
|
||
CDirEntry *FAT32FilesFind(U8 *files_find_mask,
|
||
I64 fuf_flags,CDirEntry *parent=NULL,I64 *_dir_size=NULL)
|
||
{
|
||
CDrv *dv=Fs->cur_dv;
|
||
CFAT32DirEntry *buf;
|
||
I64 attr,xsum=0,dir_size=0,sub_dir_size,
|
||
cur_dir_clus,cur_dir_entry,entries_per_clus;
|
||
U8 ch;
|
||
CDirEntry *res=NULL,*tmpde,long_name;
|
||
if (fuf_flags&~FUG_FILES_FIND)
|
||
throw('FUF');
|
||
try {
|
||
MemSet(&long_name,0,sizeof(CDirEntry));
|
||
DrvLock(dv);
|
||
cur_dir_clus=Name2DirClus(dv,Fs->cur_dir);
|
||
buf=MAlloc(BLK_SIZE*dv->spc);
|
||
entries_per_clus=dv->spc<<FAT32_ENTRIES_BITS;
|
||
ClusRead(dv,buf,cur_dir_clus,1);
|
||
dir_size+=dv->spc*BLK_SIZE;
|
||
cur_dir_entry=0;
|
||
while (ch=*buf[cur_dir_entry].name) {
|
||
attr=buf[cur_dir_entry].attr;
|
||
if (ch!=0xE5) {
|
||
if (attr&RS_ATTR_LONG_NAME_MASK==RS_ATTR_LONG_NAME)
|
||
DirLongNameFill(&long_name,&buf[cur_dir_entry],&xsum);
|
||
else {
|
||
if (!(attr&RS_ATTR_VOL_ID)) {
|
||
tmpde=MAlloc(sizeof(CDirEntry));
|
||
if (xsum==FATNameXSum(buf[cur_dir_entry].name))
|
||
MemCpy(tmpde,&long_name,sizeof(CDirEntry));
|
||
else
|
||
MemSet(tmpde,0,sizeof(CDirEntry));
|
||
if (FAT32CDirFill(tmpde,&buf[cur_dir_entry],
|
||
dv->fat32_local_time_offset)) {
|
||
tmpde->parent=parent;
|
||
if (Bt(&fuf_flags,FUf_RECURSE) && attr&RS_ATTR_DIR &&
|
||
*tmpde->name!='.') {
|
||
tmpde->next=res;
|
||
res=tmpde;
|
||
tmpde->full_name=DirNameAbs(tmpde->name);
|
||
DrvUnlock(dv);
|
||
if (Cd(tmpde->name)) {
|
||
tmpde->sub=FAT32FilesFind(files_find_mask,fuf_flags,
|
||
tmpde,&sub_dir_size);
|
||
tmpde->size=sub_dir_size;
|
||
Cd("..");
|
||
}
|
||
DrvLock(dv);
|
||
} else {
|
||
tmpde->full_name=FileNameAbs(tmpde->name);
|
||
if ((attr&RS_ATTR_DIR || !Bt(&fuf_flags,FUf_JUST_DIRS)) &&
|
||
!(Bt(&fuf_flags,FUf_RECURSE) &&
|
||
*tmpde->name=='.' && attr&RS_ATTR_DIR) &&
|
||
FilesFindMatch(tmpde->full_name,files_find_mask,
|
||
fuf_flags)) {
|
||
tmpde->next=res;
|
||
res=tmpde;
|
||
} else
|
||
DirEntryDel(tmpde);
|
||
}
|
||
} else
|
||
DirEntryDel(tmpde);
|
||
}
|
||
MemSet(&long_name,0,sizeof(CDirEntry));
|
||
}
|
||
} else
|
||
MemSet(&long_name,0,sizeof(CDirEntry));
|
||
if (++cur_dir_entry==entries_per_clus) {
|
||
cur_dir_clus=ClusNumNext(dv,cur_dir_clus);
|
||
if (cur_dir_clus==INVALID_CLUS)
|
||
break;
|
||
else {
|
||
ClusRead(dv,buf,cur_dir_clus,1);
|
||
dir_size+=dv->spc*BLK_SIZE;
|
||
cur_dir_entry=0;
|
||
}
|
||
}
|
||
}
|
||
Free(buf);
|
||
DrvUnlock(dv);
|
||
} catch
|
||
DrvUnlock(dv);
|
||
if (_dir_size)
|
||
*_dir_size=dir_size;
|
||
return res;
|
||
}
|
||
|
||
Bool FAT32MkDir(CDrv *dv,U8 *cur_dir,U8 *name,I64 entry_cnt)
|
||
{
|
||
I64 c,cur_dir_clus=Name2DirClus(dv,cur_dir),
|
||
//Rough estimate of size
|
||
size=CeilU64((entry_cnt+2)<<FAT32_ENTRIES_BITS,dv->spc<<BLK_SIZE_BITS);
|
||
U8 *buf=CAlloc(size);
|
||
CDirEntry d_native;
|
||
CFAT32DirEntry *dFAT=buf;
|
||
Bool unlock_break;
|
||
|
||
try {
|
||
unlock_break=BreakLock;
|
||
c=FileWrite(name,buf,size,0,RS_ATTR_DIR);
|
||
MemSet(&d_native,0,sizeof(CDirEntry));
|
||
d_native.attr=RS_ATTR_DIR;
|
||
*d_native.name='.';
|
||
d_native.name[1]=0;
|
||
d_native.clus=c;
|
||
d_native.size=0;
|
||
d_native.datetime=Now;
|
||
FAT32DirFill(dFAT,&d_native,NULL,dv->fat32_local_time_offset);
|
||
dFAT++;
|
||
|
||
MemSet(&d_native,0,sizeof(CDirEntry));
|
||
d_native.attr=RS_ATTR_DIR;
|
||
*d_native.name='.';
|
||
d_native.name[1]='.';
|
||
d_native.name[2]=0;
|
||
d_native.clus=cur_dir_clus;
|
||
d_native.size=0;
|
||
d_native.datetime=Now;
|
||
FAT32DirFill(dFAT,&d_native,NULL,dv->fat32_local_time_offset);
|
||
ClusWrite(dv,buf,c,1);
|
||
Free(buf);
|
||
if (unlock_break)
|
||
BreakUnlock;
|
||
} catch
|
||
if (unlock_break)
|
||
BreakUnlock;
|
||
return TRUE;
|
||
}
|