/* DOSFS Embedded FAT-Compatible Filesystem (C) 2005 Lewin A.R.W. Edwards (sysadm@zws.com) You are permitted to modify and/or use this code in your own projects without payment of royalty, regardless of the license(s) you choose for those projects. You cannot re-copyright or restrict use of the code as released by Lewin Edwards. */ //#include "common.h" #include #include //#include "fat.h" #define div(a,b) ldiv(a,b) #include "dosfs.h" /* Get starting sector# of specified partition on drive #unit NOTE: This code ASSUMES an MBR on the disk. scratchsector should point to a SECTOR_SIZE scratch area Returns 0xffffffff for any error. If pactive is non-NULL, this function also returns the partition active flag. If pptype is non-NULL, this function also returns the partition type. If psize is non-NULL, this function also returns the partition size. */ uint32_t DFS_GetPtnStart(uint8_t unit, uint8_t *scratchsector, uint8_t pnum, uint8_t *pactive, uint8_t *pptype, uint32_t *psize) { uint32_t result=0; PMBR mbr = (PMBR) scratchsector; // DOS ptable supports maximum 4 partitions if (pnum > 3) return DFS_ERRMISC; // Read MBR from target media if (DFS_ReadSector(unit,scratchsector,0,1)) { return DFS_ERRMISC; } // check if jump to boot, VBR if(mbr->bootcode[0]==0xEB || mbr->bootcode[0]==0xE9){ // MBR is actually VBR return 0; } result = (uint32_t) mbr->ptable[pnum].start_0 | (((uint32_t) mbr->ptable[pnum].start_1) << 8) | (((uint32_t) mbr->ptable[pnum].start_2) << 16) | (((uint32_t) mbr->ptable[pnum].start_3) << 24); if (pactive) *pactive = mbr->ptable[pnum].active; if (pptype) *pptype = mbr->ptable[pnum].type; if (psize) *psize = (uint32_t) mbr->ptable[pnum].size_0 | (((uint32_t) mbr->ptable[pnum].size_1) << 8) | (((uint32_t) mbr->ptable[pnum].size_2) << 16) | (((uint32_t) mbr->ptable[pnum].size_3) << 24); return result; } /* Retrieve volume info from BPB and store it in a VOLINFO structure You must provide the unit and starting sector of the filesystem, and a pointer to a sector buffer for scratch Attempts to read BPB and glean information about the FS from that. Returns 0 OK, nonzero for any error. */ uint32_t DFS_GetVolInfo(uint8_t unit, uint8_t *scratchsector, uint32_t startsector, PVOLINFO volinfo) { PLBR lbr = (PLBR) scratchsector; volinfo->unit = unit; volinfo->startsector = startsector; #ifdef DEBUG_DOSFS printf("DFS_GetVolInfo\r\n"); #endif if(DFS_ReadSector(unit,scratchsector,startsector,1)) return DFS_ERRMISC; // tag: OEMID, refer dosfs.h // strncpy(volinfo->oemid, lbr->oemid, 8); // volinfo->oemid[8] = 0; volinfo->secperclus = lbr->bpb.secperclus; volinfo->reservedsecs = (uint16_t) lbr->bpb.reserved_l | (((uint16_t) lbr->bpb.reserved_h) << 8); volinfo->numsecs = (uint16_t) lbr->bpb.sectors_s_l | (((uint16_t) lbr->bpb.sectors_s_h) << 8); if (!volinfo->numsecs) volinfo->numsecs = (uint32_t) lbr->bpb.sectors_l_0 | (((uint32_t) lbr->bpb.sectors_l_1) << 8) | (((uint32_t) lbr->bpb.sectors_l_2) << 16) | (((uint32_t) lbr->bpb.sectors_l_3) << 24); // If secperfat is 0, we must be in a FAT32 volume; get secperfat // from the FAT32 EBPB. The volume label and system ID string are also // in different locations for FAT12/16 vs FAT32. volinfo->secperfat = (uint16_t) lbr->bpb.secperfat_l | (((uint16_t) lbr->bpb.secperfat_h) << 8); if (!volinfo->secperfat) { volinfo->secperfat = (uint32_t) lbr->ebpb.ebpb32.fatsize_0 | (((uint32_t) lbr->ebpb.ebpb32.fatsize_1) << 8) | (((uint32_t) lbr->ebpb.ebpb32.fatsize_2) << 16) | (((uint32_t) lbr->ebpb.ebpb32.fatsize_3) << 24); memcpy(volinfo->label, lbr->ebpb.ebpb32.label, 11); volinfo->label[11] = 0; // tag: OEMID, refer dosfs.h // memcpy(volinfo->system, lbr->ebpb.ebpb32.system, 8); // volinfo->system[8] = 0; } else { memcpy(volinfo->label, lbr->ebpb.ebpb.label, 11); volinfo->label[11] = 0; // tag: OEMID, refer dosfs.h // memcpy(volinfo->system, lbr->ebpb.ebpb.system, 8); // volinfo->system[8] = 0; } // note: if rootentries is 0, we must be in a FAT32 volume. volinfo->rootentries = (uint16_t) lbr->bpb.rootentries_l | (((uint16_t) lbr->bpb.rootentries_h) << 8); // after extracting raw info we perform some useful precalculations volinfo->fat1 = startsector + volinfo->reservedsecs; // The calculation below is designed to round up the root directory size for FAT12/16 // and to simply ignore the root directory for FAT32, since it's a normal, expandable // file in that situation. if (volinfo->rootentries) { volinfo->rootdir = volinfo->fat1 + (volinfo->secperfat * 2); volinfo->dataarea = volinfo->rootdir + (((volinfo->rootentries * 32) + (SECTOR_SIZE - 1)) / SECTOR_SIZE); } else { volinfo->dataarea = volinfo->fat1 + (volinfo->secperfat * 2); volinfo->rootdir = (uint32_t) lbr->ebpb.ebpb32.root_0 | (((uint32_t) lbr->ebpb.ebpb32.root_1) << 8) | (((uint32_t) lbr->ebpb.ebpb32.root_2) << 16) | (((uint32_t) lbr->ebpb.ebpb32.root_3) << 24); } // Calculate number of clusters in data area and infer FAT type from this information. volinfo->numclusters = (volinfo->numsecs - volinfo->dataarea) / volinfo->secperclus; if (volinfo->numclusters < 4085) volinfo->filesystem = FAT12; else if (volinfo->numclusters < 65525) volinfo->filesystem = FAT16; else volinfo->filesystem = FAT32; return DFS_OK; } /* Fetch FAT entry for specified cluster number You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO Returns a FAT32 BAD_CLUSTER value for any error, otherwise the contents of the desired FAT entry. scratchcache should point to a UINT32. This variable caches the physical sector number last read into the scratch buffer for performance enhancement reasons. */ uint32_t DFS_GetFAT(PVOLINFO volinfo, uint8_t *scratch, uint32_t *scratchcache, uint32_t cluster) { uint32_t offset=0, sector=0, result=0; #ifdef DEBUG_DOSFS printf("DFS_GetFAT\r\n"); #endif if (volinfo->filesystem == FAT12) { offset = cluster + (cluster / 2); } else if (volinfo->filesystem == FAT16) { offset = cluster * 2; } else if (volinfo->filesystem == FAT32) { offset = cluster * 4; } else return 0x0ffffff7; // FAT32 bad cluster // at this point, offset is the BYTE offset of the desired sector from the start // of the FAT. Calculate the physical sector containing this FAT entry. sector = ldiv(offset, SECTOR_SIZE).quot + volinfo->fat1; // If this is not the same sector we last read, then read it into RAM if (sector != *scratchcache) { if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) { // avoid anyone assuming that this cache value is still valid, which // might cause disk corruption *scratchcache = 0; return 0x0ffffff7; // FAT32 bad cluster } *scratchcache = sector; } // At this point, we "merely" need to extract the relevant entry. // This is easy for FAT16 and FAT32, but a royal PITA for FAT12 as a single entry // may span a sector boundary. The normal way around this is always to read two // FAT sectors, but that luxury is (by design intent) unavailable to DOSFS. offset = ldiv(offset, SECTOR_SIZE).rem; if (volinfo->filesystem == FAT12) { // Special case for sector boundary - Store last byte of current sector. // Then read in the next sector and put the first byte of that sector into // the high byte of result. if (offset == SECTOR_SIZE - 1) { result = (uint32_t) scratch[offset]; sector++; if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) { // avoid anyone assuming that this cache value is still valid, which // might cause disk corruption *scratchcache = 0; return 0x0ffffff7; // FAT32 bad cluster } *scratchcache = sector; // Thanks to Claudio Leonel for pointing out this missing line. result |= ((uint32_t) scratch[0]) << 8; } else { result = (uint32_t) scratch[offset] | ((uint32_t) scratch[offset+1]) << 8; } if (cluster & 1) result = result >> 4; else result = result & 0xfff; } else if (volinfo->filesystem == FAT16) { result = (uint32_t) scratch[offset] | ((uint32_t) scratch[offset+1]) << 8; } else if (volinfo->filesystem == FAT32) { result = ((uint32_t) scratch[offset] | ((uint32_t) scratch[offset+1]) << 8 | ((uint32_t) scratch[offset+2]) << 16 | ((uint32_t) scratch[offset+3]) << 24) & 0x0fffffff; } else result = 0x0ffffff7; // FAT32 bad cluster return result; } /* Set FAT entry for specified cluster number You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO Returns DFS_ERRMISC for any error, otherwise DFS_OK scratchcache should point to a UINT32. This variable caches the physical sector number last read into the scratch buffer for performance enhancement reasons. NOTE: This code is HIGHLY WRITE-INEFFICIENT, particularly for flash media. Considerable performance gains can be realized by caching the sector. However this is difficult to achieve on FAT12 without requiring 2 sector buffers of scratch space, and it is a design requirement of this code to operate on a single 512-byte scratch. If you are operating DOSFS over flash, you are strongly advised to implement a writeback cache in your physical I/O driver. This will speed up your code significantly and will also conserve power and flash write life. */ uint32_t DFS_SetFAT(PVOLINFO volinfo, uint8_t *scratch, uint32_t *scratchcache, uint32_t cluster, uint32_t new_contents) { uint32_t offset=0, sector=0, result=0; #ifdef DEBUG_DOSFS printf("DFS_SetFAT (%lu->%lu)\r\n",cluster,new_contents); #endif if (volinfo->filesystem == FAT12) { offset = cluster + (cluster / 2); new_contents &=0xfff; } else if (volinfo->filesystem == FAT16) { offset = cluster * 2; new_contents &=0xffff; } else if (volinfo->filesystem == FAT32) { offset = cluster * 4; new_contents &=0x0fffffff; // FAT32 is really "FAT28" } else return DFS_ERRMISC; // at this point, offset is the BYTE offset of the desired sector from the start // of the FAT. Calculate the physical sector containing this FAT entry. sector = ldiv(offset, SECTOR_SIZE).quot + volinfo->fat1; // If this is not the same sector we last read, then read it into RAM if (sector != *scratchcache) { if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) { // avoid anyone assuming that this cache value is still valid, which // might cause disk corruption *scratchcache = 0; return DFS_ERRMISC; } *scratchcache = sector; } // At this point, we "merely" need to extract the relevant entry. // This is easy for FAT16 and FAT32, but a royal PITA for FAT12 as a single entry // may span a sector boundary. The normal way around this is always to read two // FAT sectors, but that luxury is (by design intent) unavailable to DOSFS. offset = ldiv(offset, SECTOR_SIZE).rem; if (volinfo->filesystem == FAT12) { // If this is an odd cluster, pre-shift the desired new contents 4 bits to // make the calculations below simpler if (cluster & 1) new_contents = new_contents << 4; // Special case for sector boundary if (offset == SECTOR_SIZE - 1) { // Odd cluster: High 12 bits being set if (cluster & 1) { scratch[offset] = (scratch[offset] & 0x0f) | (new_contents & 0xf0); } // Even cluster: Low 12 bits being set else { scratch[offset] = new_contents & 0xff; } result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1); // mirror the FAT into copy 2 if (DFS_OK == result) result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1); // If we wrote that sector OK, then read in the subsequent sector // and poke the first byte with the remainder of this FAT entry. if (DFS_OK == result) { // *scratchcache++; ++*scratchcache; // TK: to avoid warning "value computed is not used" result = DFS_ReadSector(volinfo->unit, scratch, *scratchcache, 1); if (DFS_OK == result) { // Odd cluster: High 12 bits being set if (cluster & 1) { scratch[0] = new_contents & 0xff00; } // Even cluster: Low 12 bits being set else { scratch[0] = (scratch[0] & 0xf0) | (new_contents & 0x0f); } result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1); // mirror the FAT into copy 2 if (DFS_OK == result) result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1); } else { // avoid anyone assuming that this cache value is still valid, which // might cause disk corruption *scratchcache = 0; } } } // if (offset == SECTOR_SIZE - 1) // Not a sector boundary. But we still have to worry about if it's an odd // or even cluster number. else { // Odd cluster: High 12 bits being set if (cluster & 1) { scratch[offset] = (scratch[offset] & 0x0f) | (new_contents & 0xf0); scratch[offset+1] = new_contents & 0xff00; } // Even cluster: Low 12 bits being set else { scratch[offset] = new_contents & 0xff; scratch[offset+1] = (scratch[offset+1] & 0xf0) | (new_contents & 0x0f); } result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1); // mirror the FAT into copy 2 if (DFS_OK == result) result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1); } } else if (volinfo->filesystem == FAT16) { scratch[offset] = (new_contents & 0xff); scratch[offset+1] = (new_contents & 0xff00) >> 8; result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1); // mirror the FAT into copy 2 - XXX if (DFS_OK == result) result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1); } else if (volinfo->filesystem == FAT32) { scratch[offset] = (new_contents & 0xff); scratch[offset+1] = (new_contents & 0xff00) >> 8; scratch[offset+2] = (new_contents & 0xff0000) >> 16; scratch[offset+3] = (scratch[offset+3] & 0xf0) | ((new_contents & 0x0f000000) >> 24); // Note well from the above: Per Microsoft's guidelines we preserve the upper // 4 bits of the FAT32 cluster value. It's unclear what these bits will be used // for; in every example I've encountered they are always zero. result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1); // mirror the FAT into copy 2 if (DFS_OK == result) result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1); } else result = DFS_ERRMISC; return result; } /* Convert a filename element from canonical (8.3) to directory entry (11) form src must point to the first non-separator character. dest must point to a 12-byte buffer. */ uint8_t *DFS_CanonicalToDir(uint8_t *dest, uint8_t *src) { uint8_t *destptr = dest; memset(dest, ' ', 11); dest[11] = 0; while (*src && (*src != DIR_SEPARATOR) && (destptr - dest < 11)) { if (*src >= 'a' && *src <='z') { *destptr++ = (*src - 'a') + 'A'; src++; } else if (*src == '.') { src++; destptr = dest + 8; } else { *destptr++ = *src++; } } return dest; } /* Find the first unused FAT entry You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO Returns a FAT32 BAD_CLUSTER value for any error, otherwise the contents of the desired FAT entry. Returns FAT32 bad_sector (0x0ffffff7) if there is no free cluster available */ uint32_t DFS_GetFreeFAT(PVOLINFO volinfo, uint8_t *scratch) { uint32_t i, result = 0xffffffff, scratchcache = 0; #ifdef DEBUG_DOSFS printf("DFS_GetFreeFAT\r\n"); #endif // Search starts at cluster 2, which is the first usable cluster // NOTE: This search can't terminate at a bad cluster, because there might // legitimately be bad clusters on the disk. for (i=2; i < volinfo->numclusters; i++) { result = DFS_GetFAT(volinfo, scratch, &scratchcache, i); if (!result) { return i; } } return 0x0ffffff7; // Can't find a free cluster } /* Open a directory for enumeration by DFS_GetNextDirEnt You must supply a populated VOLINFO (see DFS_GetVolInfo) ** you must also make sure dirinfo->scratch is valid in the dirinfo you pass it** //reza The empty string or a string containing only the directory separator are considered to be the root directory. Returns 0 OK, nonzero for any error. */ uint32_t DFS_OpenDir(PVOLINFO volinfo, uint8_t *dirname, PDIRINFO dirinfo) { // Default behavior is a regular search for existing entries dirinfo->flags = 0; #ifdef DEBUG_DOSFS printf("DFS_OpenDir\r\n"); #endif if (!strlen((char *) dirname) || (strlen((char *) dirname) == 1 && dirname[0] == DIR_SEPARATOR)) { if (volinfo->filesystem == FAT32) { dirinfo->currentcluster = volinfo->rootdir; dirinfo->currentsector = 0; dirinfo->currententry = 0; // read first sector of directory return DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((volinfo->rootdir - 2) * volinfo->secperclus), 1); } else { dirinfo->currentcluster = 0; dirinfo->currentsector = 0; dirinfo->currententry = 0; // read first sector of directory return DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->rootdir, 1); } } // This is not the root directory. We need to find the start of this subdirectory. // We do this by devious means, using our own companion function DFS_GetNext. else { uint8_t tmpfn[12]; uint8_t *ptr = dirname; uint32_t result; DIRENT de; if (volinfo->filesystem == FAT32) { dirinfo->currentcluster = volinfo->rootdir; dirinfo->currentsector = 0; dirinfo->currententry = 0; // read first sector of directory if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((volinfo->rootdir - 2) * volinfo->secperclus), 1)) return DFS_ERRMISC; } else { dirinfo->currentcluster = 0; dirinfo->currentsector = 0; dirinfo->currententry = 0; // read first sector of directory if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->rootdir, 1)) return DFS_ERRMISC; } // skip leading path separators while (*ptr == DIR_SEPARATOR && *ptr) ptr++; // Scan the path from left to right, finding the start cluster of each entry // Observe that this code is inelegant, but obviates the need for recursion. while (*ptr) { DFS_CanonicalToDir(tmpfn, ptr); de.name[0] = 0; do { result = DFS_GetNext(volinfo, dirinfo, &de); } while (!result && memcmp(de.name, tmpfn, 11)); if (!memcmp(de.name, tmpfn, 11) && ((de.attr & ATTR_DIRECTORY) == ATTR_DIRECTORY)) { if (volinfo->filesystem == FAT32) { dirinfo->currentcluster = (uint32_t) de.startclus_l_l | ((uint32_t) de.startclus_l_h) << 8 | ((uint32_t) de.startclus_h_l) << 16 | ((uint32_t) de.startclus_h_h) << 24; } else { dirinfo->currentcluster = (uint32_t) de.startclus_l_l | ((uint32_t) de.startclus_l_h) << 8; } dirinfo->currentsector = 0; dirinfo->currententry = 0; if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((dirinfo->currentcluster - 2) * volinfo->secperclus), 1)) return DFS_ERRMISC; } else if (!memcmp(de.name, tmpfn, 11) && !(de.attr & ATTR_DIRECTORY)) return DFS_NOTFOUND; // seek to next item in list while (*ptr != DIR_SEPARATOR && *ptr) ptr++; if (*ptr == DIR_SEPARATOR) ptr++; } if (!dirinfo->currentcluster) return DFS_NOTFOUND; } return DFS_OK; } /* Get next entry in opened directory structure. Copies fields into the dirent structure, updates dirinfo. Note that it is the _caller's_ responsibility to handle the '.' and '..' entries. A deleted file will be returned as a NULL entry (first char of filename=0) by this code. Filenames beginning with 0x05 will be translated to 0xE5 automatically. Long file name entries will be returned as NULL. returns DFS_EOF if there are no more entries, DFS_OK if this entry is valid, or DFS_ERRMISC for a media error */ uint32_t DFS_GetNext(PVOLINFO volinfo, PDIRINFO dirinfo, PDIRENT dirent) { uint32_t tempint; // required by DFS_GetFAT #ifdef DEBUG_DOSFS printf("DFS_GetNext\r\n"); #endif // Do we need to read the next sector of the directory? if (dirinfo->currententry >= SECTOR_SIZE / sizeof(DIRENT)) { dirinfo->currententry = 0; dirinfo->currentsector++; // Root directory; special case handling // Note that currentcluster will only ever be zero if both: // (a) this is the root directory, and // (b) we are on a FAT12/16 volume, where the root dir can't be expanded if (dirinfo->currentcluster == 0) { // Trying to read past end of root directory? if (dirinfo->currentsector * (SECTOR_SIZE / sizeof(DIRENT)) >= volinfo->rootentries) return DFS_EOF; // Otherwise try to read the next sector if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->rootdir + dirinfo->currentsector, 1)) return DFS_ERRMISC; } // Normal handling else { if (dirinfo->currentsector >= volinfo->secperclus) { dirinfo->currentsector = 0; if ((dirinfo->currentcluster >= 0xff7 && volinfo->filesystem == FAT12) || (dirinfo->currentcluster >= 0xfff7 && volinfo->filesystem == FAT16) || (dirinfo->currentcluster >= 0x0ffffff7 && volinfo->filesystem == FAT32)) { // We are at the end of the directory chain. If this is a normal // find operation, we should indicate that there is nothing more // to see. if (!(dirinfo->flags & DFS_DI_BLANKENT)) return DFS_EOF; // On the other hand, if this is a "find free entry" search, // we need to tell the caller to allocate a new cluster else return DFS_ALLOCNEW; } dirinfo->currentcluster = DFS_GetFAT(volinfo, dirinfo->scratch, &tempint, dirinfo->currentcluster); } if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((dirinfo->currentcluster - 2) * volinfo->secperclus) + dirinfo->currentsector, 1)) return DFS_ERRMISC; } } memcpy(dirent, &(((PDIRENT) dirinfo->scratch)[dirinfo->currententry]), sizeof(DIRENT)); if (dirent->name[0] == 0) { // no more files in this directory // If this is a "find blank" then we can reuse this name. #if 0 if (dirinfo->flags & DFS_DI_BLANKENT) return DFS_OK; #else // TK: DFS_GetFreeDirEnt() expects that currententry has been incremented by 1 if (dirinfo->flags & DFS_DI_BLANKENT) { dirinfo->currententry++; return DFS_OK; } #endif else return DFS_EOF; } if (dirent->name[0] == 0xe5) // handle deleted file entries dirent->name[0] = 0; #if 1 // TK: ensure that DFS_GetFreeDirEnt() doesn't return entries with long name else if( dirinfo->flags & DFS_DI_BLANKENT ) {} // do nothing.. #endif else if ((dirent->attr & ATTR_LONG_NAME) == ATTR_LONG_NAME) dirent->name[0] = 0; else if (dirent->name[0] == 0x05) // handle kanji filenames beginning with 0xE5 dirent->name[0] = 0xe5; dirinfo->currententry++; return DFS_OK; } /* INTERNAL Find a free directory entry in the directory specified by path This function MAY cause a disk write if it is necessary to extend the directory size. Note - di.scratch must be preinitialized to point to a sector scratch buffer de is a scratch structure Returns DFS_ERRMISC if a new entry could not be located or created de is updated with the same return information you would expect from DFS_GetNext */ uint32_t DFS_GetFreeDirEnt(PVOLINFO volinfo, uint8_t *path, PDIRINFO di, PDIRENT de) { uint32_t tempclus=0,i=0; #ifdef DEBUG_DOSFS printf("DFS_GetFreeDirEnt\r\n"); #endif if (DFS_OpenDir(volinfo, path, di)) return DFS_NOTFOUND; // Set "search for empty" flag so DFS_GetNext knows what we're doing di->flags |= DFS_DI_BLANKENT; // We seek through the directory looking for an empty entry // Note we are reusing tempclus as a temporary result holder. tempclus = 0; do { tempclus = DFS_GetNext(volinfo, di, de); // Empty entry found if (tempclus == DFS_OK && (!de->name[0])) { return DFS_OK; } // End of root directory reached else if (tempclus == DFS_EOF) return DFS_ERRMISC; else if (tempclus == DFS_ALLOCNEW) { tempclus = DFS_GetFreeFAT(volinfo, di->scratch); if (tempclus == 0x0ffffff7) return DFS_ERRMISC; // write out zeroed sectors to the new cluster memset(di->scratch, 0, SECTOR_SIZE); for (i=0;isecperclus;i++) { if (DFS_WriteSector(volinfo->unit, di->scratch, volinfo->dataarea + ((tempclus - 2) * volinfo->secperclus) + i, 1)) return DFS_ERRMISC; } // Point old end cluster to newly allocated cluster i = 0; DFS_SetFAT(volinfo, di->scratch, &i, di->currentcluster, tempclus); // Update DIRINFO so caller knows where to place the new file di->currentcluster = tempclus; di->currentsector = 0; di->currententry = 1; // since the code coming after this expects to subtract 1 // Mark newly allocated cluster as end of chain switch(volinfo->filesystem) { case FAT12: tempclus = 0xff8; break; case FAT16: tempclus = 0xfff8; break; case FAT32: tempclus = 0x0ffffff8; break; default: return DFS_ERRMISC; } DFS_SetFAT(volinfo, di->scratch, &i, di->currentcluster, tempclus); } } while (!tempclus); // We shouldn't get here return DFS_ERRMISC; } /* Open a file for reading or writing. You supply populated VOLINFO, a path to the file, mode (DFS_READ or DFS_WRITE) and an empty fileinfo structure. You also need to provide a pointer to a sector-sized scratch buffer. Returns various DFS_* error states. If the result is DFS_OK, fileinfo can be used to access the file from this point on. */ uint32_t DFS_OpenFile(PVOLINFO volinfo, uint8_t *path, uint8_t mode, uint8_t *scratch, PFILEINFO fileinfo) { uint8_t tmppath[MAX_PATH]; uint8_t filename[12]; uint8_t *p; DIRINFO di; DIRENT de; uint32_t temp; #ifdef DEBUG_DOSFS printf("DFS_OpenFile\r\n"); #endif // larwe 2006-09-16 +1 zero out file structure memset(fileinfo, 0, sizeof(FILEINFO)); // save access mode fileinfo->mode = mode; // Get a local copy of the path. If it's longer than MAX_PATH, abort. strncpy((char *) tmppath, (char *) path, MAX_PATH); tmppath[MAX_PATH - 1] = 0; if (strcmp((char *) path,(char *) tmppath)) { return DFS_PATHLEN; } // strip leading path separators while (tmppath[0] == DIR_SEPARATOR) strcpy((char *) tmppath, (char *) tmppath + 1); // Parse filename off the end of the supplied path p = tmppath; while (*(p++)); p--; while (p > tmppath && *p != DIR_SEPARATOR) // larwe 9/16/06 ">=" to ">" bugfix p--; if (*p == DIR_SEPARATOR) p++; DFS_CanonicalToDir(filename, p); if (p > tmppath) p--; if (*p == DIR_SEPARATOR || p == tmppath) // larwe 9/16/06 +"|| p == tmppath" bugfix *p = 0; // At this point, if our path was MYDIR/MYDIR2/FILE.EXT, filename = "FILE EXT" and // tmppath = "MYDIR/MYDIR2". di.scratch = scratch; if (DFS_OpenDir(volinfo, tmppath, &di)) return DFS_NOTFOUND; while (!DFS_GetNext(volinfo, &di, &de)) { if (!memcmp(de.name, filename, 11)) { // You can't use this function call to open a directory. if (de.attr & ATTR_DIRECTORY) return DFS_NOTFOUND; fileinfo->volinfo = volinfo; fileinfo->pointer = 0; // The reason we store this extra info about the file is so that we can // speedily update the file size, modification date, etc. on a file that is // opened for writing. if (di.currentcluster == 0) fileinfo->dirsector = volinfo->rootdir + di.currentsector; else fileinfo->dirsector = volinfo->dataarea + ((di.currentcluster - 2) * volinfo->secperclus) + di.currentsector; fileinfo->diroffset = di.currententry - 1; if (volinfo->filesystem == FAT32) { fileinfo->cluster = (uint32_t) de.startclus_l_l | ((uint32_t) de.startclus_l_h) << 8 | ((uint32_t) de.startclus_h_l) << 16 | ((uint32_t) de.startclus_h_h) << 24; } else { fileinfo->cluster = (uint32_t) de.startclus_l_l | ((uint32_t) de.startclus_l_h) << 8; } fileinfo->firstcluster = fileinfo->cluster; fileinfo->filelen = (uint32_t) de.filesize_0 | ((uint32_t) de.filesize_1) << 8 | ((uint32_t) de.filesize_2) << 16 | ((uint32_t) de.filesize_3) << 24; return DFS_OK; } } // At this point, we KNOW the file does not exist. If the file was opened // with write access, we can create it. if (mode & DFS_WRITE) { uint32_t cluster; // Locate or create a directory entry for this file if (DFS_OK != DFS_GetFreeDirEnt(volinfo, tmppath, &di, &de)) return DFS_ERRMISC; // put sane values in the directory entry memset(&de, 0, sizeof(de)); memcpy(de.name, filename, 11); de.crttime_l = 0x20; // 01:01:00am, Jan 1, 2006. de.crttime_h = 0x08; de.crtdate_l = 0x11; de.crtdate_h = 0x34; de.lstaccdate_l = 0x11; de.lstaccdate_h = 0x34; de.wrttime_l = 0x20; de.wrttime_h = 0x08; de.wrtdate_l = 0x11; de.wrtdate_h = 0x34; // allocate a starting cluster for the directory entry cluster = DFS_GetFreeFAT(volinfo, scratch); de.startclus_l_l = cluster & 0xff; de.startclus_l_h = (cluster & 0xff00) >> 8; de.startclus_h_l = (cluster & 0xff0000) >> 16; de.startclus_h_h = (cluster & 0xff000000) >> 24; // update FILEINFO for our caller's sake fileinfo->volinfo = volinfo; fileinfo->pointer = 0; // The reason we store this extra info about the file is so that we can // speedily update the file size, modification date, etc. on a file that is // opened for writing. if (di.currentcluster == 0) fileinfo->dirsector = volinfo->rootdir + di.currentsector; else fileinfo->dirsector = volinfo->dataarea + ((di.currentcluster - 2) * volinfo->secperclus) + di.currentsector; fileinfo->diroffset = di.currententry - 1; fileinfo->cluster = cluster; fileinfo->firstcluster = cluster; fileinfo->filelen = 0; // write the directory entry // note that we no longer have the sector containing the directory entry, // tragically, so we have to re-read it if (DFS_ReadSector(volinfo->unit, scratch, fileinfo->dirsector, 1)) return DFS_ERRMISC; memcpy(&(((PDIRENT) scratch)[di.currententry-1]), &de, sizeof(DIRENT)); if (DFS_WriteSector(volinfo->unit, scratch, fileinfo->dirsector, 1)) return DFS_ERRMISC; // Mark newly allocated cluster as end of chain switch(volinfo->filesystem) { case FAT12: cluster = 0xff8; break; case FAT16: cluster = 0xfff8; break; case FAT32: cluster = 0x0ffffff8; break; default: return DFS_ERRMISC; } temp = 0; DFS_SetFAT(volinfo, scratch, &temp, fileinfo->cluster, cluster); return DFS_OK; } return DFS_NOTFOUND; } /* Read an open file You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a pointer to a SECTOR_SIZE scratch buffer. Note that returning DFS_EOF is not an error condition. This function updates the successcount field with the number of bytes actually read. */ uint32_t DFS_ReadFile(PFILEINFO fileinfo, uint8_t *scratch, uint8_t *buffer, uint32_t *successcount, uint32_t len) { uint32_t remain=0; uint32_t result = DFS_OK; uint32_t sector=0; uint32_t bytesread=0; #ifdef DEBUG_DOSFS printf("DFS_ReadFile\r\n"); #endif // Don't try to read past EOF if (len > fileinfo->filelen - fileinfo->pointer) len = fileinfo->filelen - fileinfo->pointer; remain = len; *successcount = 0; while (remain && result == DFS_OK) { // This is a bit complicated. The sector we want to read is addressed at a cluster // granularity by the fileinfo->cluster member. The file pointer tells us how many // extra sectors to add to that number. sector = fileinfo->volinfo->dataarea + ((fileinfo->cluster - 2) * fileinfo->volinfo->secperclus) + div(div(fileinfo->pointer,fileinfo->volinfo->secperclus * SECTOR_SIZE).rem, SECTOR_SIZE).quot; // Case 1 - File pointer is not on a sector boundary if (div(fileinfo->pointer, SECTOR_SIZE).rem) { uint16_t tempreadsize; // We always have to go through scratch in this case result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1); // This is the number of bytes that we actually care about in the sector // just read. tempreadsize = SECTOR_SIZE - (div(fileinfo->pointer, SECTOR_SIZE).rem); // Case 1A - We want the entire remainder of the sector. After this // point, all passes through the read loop will be aligned on a sector // boundary, which allows us to go through the optimal path 2A below. if (remain >= tempreadsize) { memcpy(buffer, scratch + (SECTOR_SIZE - tempreadsize), tempreadsize); bytesread = tempreadsize; buffer += tempreadsize; fileinfo->pointer += tempreadsize; remain -= tempreadsize; } // Case 1B - This read concludes the file read operation else { memcpy(buffer, scratch + (SECTOR_SIZE - tempreadsize), remain); buffer += remain; fileinfo->pointer += remain; bytesread = remain; remain = 0; } } // Case 2 - File pointer is on sector boundary else { // Case 2A - We have at least one more full sector to read and don't have // to go through the scratch buffer. You could insert optimizations here to // read multiple sectors at a time, if you were thus inclined (note that // the maximum multi-read you could perform is a single cluster, so it would // be advantageous to have code similar to case 1A above that would round the // pointer to a cluster boundary the first pass through, so all subsequent // [large] read requests would be able to go a cluster at a time). if (remain >= SECTOR_SIZE) { result = DFS_ReadSector(fileinfo->volinfo->unit, buffer, sector, 1); remain -= SECTOR_SIZE; buffer += SECTOR_SIZE; fileinfo->pointer += SECTOR_SIZE; bytesread = SECTOR_SIZE; } // Case 2B - We are only reading a partial sector else { result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1); memcpy(buffer, scratch, remain); buffer += remain; fileinfo->pointer += remain; bytesread = remain; remain = 0; } } *successcount += bytesread; // check to see if we stepped over a cluster boundary if (div(fileinfo->pointer - bytesread, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot != div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) { // An act of minor evil - we use bytesread as a scratch integer, knowing that // its value is not used after updating *successcount above bytesread = 0; if (((fileinfo->volinfo->filesystem == FAT12) && (fileinfo->cluster >= 0xff8)) || ((fileinfo->volinfo->filesystem == FAT16) && (fileinfo->cluster >= 0xfff8)) || ((fileinfo->volinfo->filesystem == FAT32) && (fileinfo->cluster >= 0x0ffffff8))) result = DFS_EOF; else fileinfo->cluster = DFS_GetFAT(fileinfo->volinfo, scratch, &bytesread, fileinfo->cluster); } } return result; } /* Seek file pointer to a given position This function does not return status - refer to the fileinfo->pointer value to see where the pointer wound up. Requires a SECTOR_SIZE scratch buffer */ void DFS_Seek(PFILEINFO fileinfo, uint32_t offset, uint8_t *scratch) { uint32_t tempint; uint16_t endcluster=0; //canny/reza 5/7 fixed #ifdef DEBUG_DOSFS printf("DFS_Seek\r\n"); #endif // larwe 9/16/06 bugfix split case 0a/0b and changed fallthrough handling // Case 0a - Return immediately for degenerate case if (offset == fileinfo->pointer) { return; } // Case 0b - Don't allow the user to seek past the end of the file if (offset > fileinfo->filelen) { offset = fileinfo->filelen; // NOTE NO RETURN HERE! } // Case 1 - Simple rewind to start // Note _intentional_ fallthrough from Case 0b above if (offset == 0) { fileinfo->cluster = fileinfo->firstcluster; fileinfo->pointer = 0; return; // larwe 9/16/06 +1 bugfix } // Case 2 - Seeking backwards. Need to reset and seek forwards else if (offset < fileinfo->pointer) { fileinfo->cluster = fileinfo->firstcluster; fileinfo->pointer = 0; // NOTE NO RETURN HERE! } // Case 3 - Seeking forwards // Note _intentional_ fallthrough from Case 2 above // Case 3a - Seek size does not cross cluster boundary - // very simple case // larwe 9/16/06 changed .rem to .quot in both div calls, bugfix if (div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot == div(fileinfo->pointer + offset, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) { fileinfo->pointer = offset; } // Case 3b - Seeking across cluster boundary(ies) else { // round file pointer down to cluster boundary fileinfo->pointer = div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot * fileinfo->volinfo->secperclus * SECTOR_SIZE; // seek by clusters // larwe 9/30/06 bugfix changed .rem to .quot in both div calls // canny/reza 5/7 added endcluster related code // TK 2008-12-18: fixed endcluster calculation // old: endcluster = div(fileinfo->pointer + offset, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot; endcluster = div(offset, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot; while (div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot !=endcluster) { fileinfo->cluster = DFS_GetFAT(fileinfo->volinfo, scratch, &tempint, fileinfo->cluster); // Abort if there was an error if (fileinfo->cluster == 0x0ffffff7) { fileinfo->pointer = 0; fileinfo->cluster = fileinfo->firstcluster; return; } fileinfo->pointer += SECTOR_SIZE * fileinfo->volinfo->secperclus; } // since we know the cluster is right, we have no more work to do fileinfo->pointer = offset; } } /* Delete a file scratch must point to a sector-sized buffer */ uint32_t DFS_UnlinkFile(PVOLINFO volinfo, uint8_t *path, uint8_t *scratch) { // PDIRENT de = (PDIRENT) scratch; FILEINFO fi; uint32_t cache = 0; uint32_t tempclus = 0; #ifdef DEBUG_DOSFS printf("DFS_UnlinkFile\r\n"); #endif // DFS_OpenFile gives us all the information we need to delete it if (DFS_OK != DFS_OpenFile(volinfo, path, DFS_READ, scratch, &fi)) return DFS_NOTFOUND; // First, read the directory sector and delete that entry if (DFS_ReadSector(volinfo->unit, scratch, fi.dirsector, 1)) return DFS_ERRMISC; ((PDIRENT) scratch)[fi.diroffset].name[0] = 0xe5; if (DFS_WriteSector(volinfo->unit, scratch, fi.dirsector, 1)) return DFS_ERRMISC; // Now follow the cluster chain to free the file space while (!((volinfo->filesystem == FAT12 && fi.firstcluster >= 0x0ff7) || (volinfo->filesystem == FAT16 && fi.firstcluster >= 0xfff7) || (volinfo->filesystem == FAT32 && fi.firstcluster >= 0x0ffffff7))) { tempclus = fi.firstcluster; fi.firstcluster = DFS_GetFAT(volinfo, scratch, &cache, fi.firstcluster); DFS_SetFAT(volinfo, scratch, &cache, tempclus, 0); } return DFS_OK; } /* Write an open file You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a pointer to a SECTOR_SIZE scratch buffer. This function updates the successcount field with the number of bytes actually written. */ uint32_t DFS_WriteFile(PFILEINFO fileinfo, uint8_t *scratch, uint8_t *buffer, uint32_t *successcount, uint32_t len) { uint32_t remain=0; uint32_t result = DFS_OK; uint32_t sector=0; uint32_t byteswritten=0; #ifdef DEBUG_DOSFS printf("DFS_WriteFile\r\n"); #endif // Don't allow writes to a file that's open as readonly if (!(fileinfo->mode & DFS_WRITE)) return DFS_ERRMISC; remain = len; *successcount = 0; while (remain && result == DFS_OK) { // This is a bit complicated. The sector we want to read is addressed at a cluster // granularity by the fileinfo->cluster member. The file pointer tells us how many // extra sectors to add to that number. sector = fileinfo->volinfo->dataarea + ((fileinfo->cluster - 2) * fileinfo->volinfo->secperclus) + div(div(fileinfo->pointer,fileinfo->volinfo->secperclus * SECTOR_SIZE).rem, SECTOR_SIZE).quot; // Case 1 - File pointer is not on a sector boundary if (div(fileinfo->pointer, SECTOR_SIZE).rem) { uint16_t tempsize; // We always have to go through scratch in this case result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1); // This is the number of bytes that we don't want to molest in the // scratch sector just read. tempsize = div(fileinfo->pointer, SECTOR_SIZE).rem; // Case 1A - We are writing the entire remainder of the sector. After // this point, all passes through the read loop will be aligned on a // sector boundary, which allows us to go through the optimal path // 2A below. if (remain >= (uint32_t)SECTOR_SIZE - tempsize) { memcpy(scratch + tempsize, buffer, SECTOR_SIZE - tempsize); if (!result) result = DFS_WriteSector(fileinfo->volinfo->unit, scratch, sector, 1); byteswritten = SECTOR_SIZE - tempsize; buffer += SECTOR_SIZE - tempsize; fileinfo->pointer += SECTOR_SIZE - tempsize; if (fileinfo->filelen < fileinfo->pointer) { fileinfo->filelen = fileinfo->pointer; } remain -= SECTOR_SIZE - tempsize; } // Case 1B - This concludes the file write operation else { memcpy(scratch + tempsize, buffer, remain); if (!result) result = DFS_WriteSector(fileinfo->volinfo->unit, scratch, sector, 1); buffer += remain; fileinfo->pointer += remain; if (fileinfo->filelen < fileinfo->pointer) { fileinfo->filelen = fileinfo->pointer; } byteswritten = remain; remain = 0; } } // case 1 // Case 2 - File pointer is on sector boundary else { // Case 2A - We have at least one more full sector to write and don't have // to go through the scratch buffer. You could insert optimizations here to // write multiple sectors at a time, if you were thus inclined. Refer to // similar notes in DFS_ReadFile. if (remain >= SECTOR_SIZE) { result = DFS_WriteSector(fileinfo->volinfo->unit, buffer, sector, 1); remain -= SECTOR_SIZE; buffer += SECTOR_SIZE; fileinfo->pointer += SECTOR_SIZE; if (fileinfo->filelen < fileinfo->pointer) { fileinfo->filelen = fileinfo->pointer; } byteswritten = SECTOR_SIZE; } // Case 2B - We are only writing a partial sector and potentially need to // go through the scratch buffer. else { // If the current file pointer is not yet at or beyond the file // length, we are writing somewhere in the middle of the file and // need to load the original sector to do a read-modify-write. if (fileinfo->pointer < fileinfo->filelen) { result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1); if (!result) { memcpy(scratch, buffer, remain); result = DFS_WriteSector(fileinfo->volinfo->unit, scratch, sector, 1); } } else { result = DFS_WriteSector(fileinfo->volinfo->unit, buffer, sector, 1); } buffer += remain; fileinfo->pointer += remain; if (fileinfo->filelen < fileinfo->pointer) { fileinfo->filelen = fileinfo->pointer; } byteswritten = remain; remain = 0; } } *successcount += byteswritten; // check to see if we stepped over a cluster boundary if (div(fileinfo->pointer - byteswritten, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot != div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) { uint32_t lastcluster; // We've transgressed into another cluster. If we were already at EOF, // we need to allocate a new cluster. // An act of minor evil - we use byteswritten as a scratch integer, knowing // that its value is not used after updating *successcount above byteswritten = 0; lastcluster = fileinfo->cluster; fileinfo->cluster = DFS_GetFAT(fileinfo->volinfo, scratch, &byteswritten, fileinfo->cluster); // Allocate a new cluster? if (((fileinfo->volinfo->filesystem == FAT12) && (fileinfo->cluster >= 0xff8)) || ((fileinfo->volinfo->filesystem == FAT16) && (fileinfo->cluster >= 0xfff8)) || ((fileinfo->volinfo->filesystem == FAT32) && (fileinfo->cluster >= 0x0ffffff8))) { uint32_t tempclus; tempclus = DFS_GetFreeFAT(fileinfo->volinfo, scratch); byteswritten = 0; // invalidate cache if (tempclus == 0x0ffffff7) return DFS_ERRMISC; // Link new cluster onto file DFS_SetFAT(fileinfo->volinfo, scratch, &byteswritten, lastcluster, tempclus); fileinfo->cluster = tempclus; // Mark newly allocated cluster as end of chain switch(fileinfo->volinfo->filesystem) { case FAT12: tempclus = 0xff8; break; case FAT16: tempclus = 0xfff8; break; case FAT32: tempclus = 0x0ffffff8; break; default: return DFS_ERRMISC; } DFS_SetFAT(fileinfo->volinfo, scratch, &byteswritten, fileinfo->cluster, tempclus); result = DFS_OK; } // No else clause is required. } } // Update directory entry if (DFS_ReadSector(fileinfo->volinfo->unit, scratch, fileinfo->dirsector, 1)) return DFS_ERRMISC; ((PDIRENT) scratch)[fileinfo->diroffset].filesize_0 = fileinfo->filelen & 0xff; ((PDIRENT) scratch)[fileinfo->diroffset].filesize_1 = (fileinfo->filelen & 0xff00) >> 8; ((PDIRENT) scratch)[fileinfo->diroffset].filesize_2 = (fileinfo->filelen & 0xff0000) >> 16; ((PDIRENT) scratch)[fileinfo->diroffset].filesize_3 = (fileinfo->filelen & 0xff000000) >> 24; if (DFS_WriteSector(fileinfo->volinfo->unit, scratch, fileinfo->dirsector, 1)) return DFS_ERRMISC; return result; } /* // TK: added 2009-02-12 Close a file No original function of DosFS driver It has no effect if writing to SD Card, it's only used by the DosFS wrapper in emulation */ uint32_t DFS_Close(__attribute__((unused)) PFILEINFO fileinfo) { return DFS_OK; }