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; BlkZeroWrite(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) {//FUF_JUST_DIRS, 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.\n"); 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 { "%s ",name; PrintErr("File not found.\n"); } 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 ::/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.\n"); 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; }