FAT file system directory-entry. More...
#include <fatfs.h>


Public Member Functions | |
| FATDirectory (FATDrive &drive, LPCTSTR root_path) | |
| FATDirectory (FATDrive &drive, Entry *parent, LPCTSTR path, unsigned cluster) | |
| ~FATDirectory () | |
| virtual void | read_directory (int scan_flags=0) |
| virtual const void * | get_next_path_component (const void *) const |
| virtual Entry * | find_entry (const void *) |
Protected Member Functions | |
| bool | read_dir () |
Protected Attributes | |
| FATDrive & | _drive |
| struct dirsecz * | _secarr |
| int | _cur_bufs |
| int | _ents |
| struct dirent * | _dir |
| struct Kette * | _alloc |
FAT file system directory-entry.
Definition at line 47 of file fatfs.h.
Definition at line 272 of file fatfs.cpp.
References FATEntry::_cluster, _cur_bufs, _dir, _ents, Directory::_path, and _secarr.
Referenced by read_directory().
: FATEntry(), _drive(drive) { _path = _tcsdup(root_path); _secarr = NULL; _cur_bufs = 0; _ents = 0; _dir = NULL; _cluster = 0; }

| FATDirectory::~FATDirectory | ( | ) |
Definition at line 297 of file fatfs.cpp.
References Directory::_path.
| Entry * FATDirectory::find_entry | ( | const void * | p ) | [virtual] |
Reimplemented from Entry.
Definition at line 224 of file fatfs.cpp.
References Entry::_data, Entry::_down, Entry::_next, and TEXT.
{
LPCTSTR name = (LPCTSTR)p;
for(Entry*entry=_down; entry; entry=entry->_next) {
LPCTSTR p = name;
LPCTSTR q = entry->_data.cFileName;
do {
if (!*p || *p==TEXT('\\') || *p==TEXT('/'))
return entry;
} while(tolower(*p++) == tolower(*q++));
p = name;
q = entry->_data.cAlternateFileName;
do {
if (!*p || *p==TEXT('\\') || *p==TEXT('/'))
return entry;
} while(tolower(*p++) == tolower(*q++));
}
return NULL;
}
| const void * FATDirectory::get_next_path_component | ( | const void * | p ) | const [virtual] |
| bool FATDirectory::read_dir | ( | ) | [protected] |
Definition at line 303 of file fatfs.cpp.
References FATDrive::_boot_sector, FATDrive::_bufents, FATDrive::_bufl, FATEntry::_cluster, _cur_bufs, _dir, _drive, _ents, FATDrive::_SClus, _secarr, AddP, BootSector::BytesPerSector, Buffer::dat, BootSector::NumberFATs, FATDrive::read_FAT(), FATDrive::read_sector(), BootSector::ReservedSectors, BootSector::RootEntries, BootSector32::RootSectors, dirsecz::s, BootSector::SectorsPerFAT, and BootSector32::SectorsPerFAT32.
Referenced by read_directory().
{
int i;
if (_cluster == 0) {
if (!_drive._boot_sector.SectorsPerFAT) { // FAT32? [boot_sector32->reserved0==0]
BootSector32* boot_sector32 = (BootSector32*) &_drive._boot_sector;
DWORD sect = _drive._boot_sector.ReservedSectors + _drive._boot_sector.NumberFATs*boot_sector32->SectorsPerFAT32; // lese Root-Directory ein
int RootEntries = boot_sector32->RootSectors * 32; //@@
_secarr = (struct dirsecz*)malloc(sizeof(DWORD) * (_cur_bufs = (int)((_ents=RootEntries)/_drive._bufents)));
for(i=0; i<_cur_bufs; i++)
_secarr->s[i] = sect+i;
_dir = (struct dirent*)malloc((size_t)(_ents+16)*sizeof(union DEntry));
if (!_dir)
return false;
if (!(_drive.read_sector(*_secarr->s,(Buffer*)_dir,_cur_bufs)))
return false;
} else {
DWORD sect = _drive._boot_sector.ReservedSectors + _drive._boot_sector.NumberFATs*_drive._boot_sector.SectorsPerFAT; // read in root directory
_secarr = (struct dirsecz*)malloc(sizeof(DWORD) * (_cur_bufs = (int)((_ents=_drive._boot_sector.RootEntries)/_drive._bufents)));
for(i=0; i<_cur_bufs; i++)
_secarr->s[i] = sect+i;
_dir = (struct dirent*)malloc((size_t)(_ents+16)*sizeof(union DEntry));
if (!_dir)
return false;
if (!_drive.read_sector(*_secarr->s,(Buffer*)_dir,_cur_bufs))
return false;
}
} else {
Buffer* buf;
bool ok;
DWORD h = _cluster;
_cur_bufs = 0;
do {
h = _drive.read_FAT(h, ok);
if (!ok)
return false;
_cur_bufs++;
} while (h<0x0ffffff0 && h);
_secarr = (struct dirsecz*) malloc(sizeof(DWORD) * _cur_bufs);
if (!_secarr)
return false;
_ents = _drive._bufents * (size_t)_cur_bufs * _drive._SClus;
if ((buf=(Buffer*)(_dir=(struct dirent*)malloc((size_t) (_ents+16)*sizeof(union DEntry)))) == NULL)
return false;
h = _cluster;
DWORD fdatsec;
if (!_drive._boot_sector.SectorsPerFAT) { // FAT32 ?
BootSector32* boot_sector32 = (BootSector32*) &_drive._boot_sector;
//int RootEntries = boot_sector32->RootSectors * 32; //@@
//fdatsec = _drive._boot_sector.ReservedSectors + _drive._boot_sector.NumberFATs*boot_sector32->SectorsPerFAT32 + RootEntries*sizeof(DEntry)/_drive._boot_sector.BytesPerSector; // dpb.fdirsec
fdatsec = _drive._boot_sector.ReservedSectors +
_drive._boot_sector.NumberFATs*boot_sector32->SectorsPerFAT32 + boot_sector32->RootSectors;
} else
fdatsec = _drive._boot_sector.ReservedSectors +
_drive._boot_sector.NumberFATs*_drive._boot_sector.SectorsPerFAT +
_drive._boot_sector.RootEntries*sizeof(DEntry)/_drive._boot_sector.BytesPerSector; // dpb.fdirsec
for(i=0; i<_cur_bufs; i++) {
_secarr->s[i] = fdatsec + (DWORD)_drive._SClus*(h-2);
h = _drive.read_FAT(h, ok);
if (!ok)
return false;
}
for(i=0; i<_cur_bufs; i++) {
if ((ok = (_drive.read_sector(_secarr->s[i], buf, _drive._SClus))) == true)
AddP(buf, _drive._bufl*_drive._SClus)
else {
//@@FPara = _secarr->s[i];
return false;
}
}
buf->dat[0] = 0; // Endekennzeichen für Rekurs setzen
}
return true;
}


| void FATDirectory::read_directory | ( | int | scan_flags = 0 ) |
[virtual] |
Reimplemented from Entry.
Definition at line 52 of file fatfs.cpp.
References _A_DELETED, _A_ILLEGAL, _alloc, Entry::_content, Entry::_data, _dir, _drive, _ents, Entry::_level, Entry::_next, Directory::_path, _tcscpy_s, _tcslen, FAT_attribute::a, AddP, DEntry_E::attr, ATTRIBUTE_ERASED, ATTRIBUTE_LONGNAME, ATTRIBUTE_VOLNAME, DEntry::B, FAT_attribute::b, CONTEXT, COUNTOF, fdate::day, fattr::directory, DEntry::E, FAT_DEL_CHAR, FATDirectory(), FATEntry::FATEntry(), ftime::hour, IS_LNAME, ftime::min, fdate::month, DEntry_E::name, read_dir(), ftime::sec2, fattr::volume, and fdate::year.
{
CONTEXT("FATDirectory::read_directory()");
read_dir();
union DEntry* p = (union DEntry*) _dir;
int i = 0;
do {
/* if (!IS_LNAME(p->E.attr) && p->E.name[0]!=FAT_DEL_CHAR)
gesBytes += p->E.size;
*/
AddP(p, sizeof(union DEntry));
} while(++i<_ents && p->E.name[0]);
_alloc = (struct Kette*) malloc((size_t)((_ents=i)+8)*sizeof(struct Kette));
if (!_alloc)
return;
link_dir_entries(_dir, _alloc, i);
Entry* first_entry = NULL;
int level = _level + 1;
Entry* last = NULL;
WIN32_FIND_DATA w32fd;
FAT_attribute attr;
String long_name;
TCHAR buffer[MAX_PATH];
_tcscpy(buffer, (LPCTSTR)_path);
LPTSTR pname = buffer + _tcslen(buffer);
int plen = COUNTOF(buffer) - _tcslen(buffer);
*pname++ = '\\';
--plen;
for(Kette*p=_alloc; p; p=p->Vorw) {
memset(&w32fd, 0, sizeof(WIN32_FIND_DATA));
DEntry_E& e = p->Ent->E;
// get file/directory attributes
attr.b = e.attr;
if (attr.b & (_A_DELETED | _A_ILLEGAL))
attr.b |= _A_ILLEGAL;
const char* s = e.name;
LPTSTR d = w32fd.cFileName;
if (!IS_LNAME(attr.b) || e.name[0]==FAT_DEL_CHAR) {
if (e.name[0] == FAT_DEL_CHAR)
w32fd.dwFileAttributes |= ATTRIBUTE_ERASED;
else if (IS_LNAME(attr.b))
w32fd.dwFileAttributes |= ATTRIBUTE_LONGNAME;
else if (attr.a.directory)
w32fd.dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
else if (attr.a.volume)
w32fd.dwFileAttributes |= ATTRIBUTE_VOLNAME; //@@ -> in Volume-Name der Root kopieren
// get file name
*d++ = *s==FAT_DEL_CHAR? '?': *s;
++s;
for(i=0; i<7; ++i)
*d++ = *s++;
while(d>w32fd.cFileName && d[-1]==' ')
--d;
*d++ = '.';
for(; i<10; ++i)
*d++ = *s++;
while(d>w32fd.cFileName && d[-1]==' ')
--d;
if (d>w32fd.cFileName && d[-1]=='.')
--d;
*d = '\0';
} else {
s = (const char*)p->Ent->B; // no change of the pointer, just to avoid overung warnings in code checkers
// read long file name
TCHAR lname[] = {s[1], s[3], s[5], s[7], s[9], s[14], s[16], s[18], s[20], s[22], s[24], s[28], s[30]};
long_name = String(lname, 13) + long_name;
}
if (!IS_LNAME(attr.b) && !attr.a.volume) {
// get file size
w32fd.nFileSizeLow = e.size;
// convert date/time attribute into FILETIME
const fdate& date = e.date;
const ftime& time = e.time;
SYSTEMTIME stime;
FILETIME ftime;
stime.wYear = date.year + 1980;
stime.wMonth = date.month;
stime.wDayOfWeek = (WORD)-1;
stime.wDay = date.day;
stime.wHour = time.hour;
stime.wMinute = time.min;
stime.wSecond = time.sec2 * 2;
stime.wMilliseconds = 0;
if (SystemTimeToFileTime(&stime, &ftime))
LocalFileTimeToFileTime(&ftime, &w32fd.ftLastWriteTime);
if (!(w32fd.dwFileAttributes & ATTRIBUTE_ERASED)) { //@@
Entry* entry;
if (w32fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
_tcscpy_s(pname, plen, w32fd.cFileName);
entry = new FATDirectory(_drive, this, buffer, e.fclus);
} else
entry = new FATEntry(this, e.fclus);
memcpy(&entry->_data, &w32fd, sizeof(WIN32_FIND_DATA));
if (!long_name.empty()) {
entry->_content = _tcsdup(long_name);
long_name.erase();
}
if (!first_entry)
first_entry = entry;
if (last)
last->_next = entry;
entry->_level = level;
last = entry;
}
}
}
if (last)
last->_next = NULL;
_down = first_entry;
_scanned = true;
}

struct Kette* FATDirectory::_alloc [protected] |
Definition at line 64 of file fatfs.h.
Referenced by read_directory().
int FATDirectory::_cur_bufs [protected] |
Definition at line 61 of file fatfs.h.
Referenced by FATDirectory(), and read_dir().
struct dirent* FATDirectory::_dir [protected] |
Definition at line 63 of file fatfs.h.
Referenced by FATDirectory(), read_dir(), and read_directory().
FATDrive& FATDirectory::_drive [protected] |
Definition at line 58 of file fatfs.h.
Referenced by read_dir(), read_directory(), FATDrive::read_sector(), and FATDrive::small_cache().
int FATDirectory::_ents [protected] |
Definition at line 62 of file fatfs.h.
Referenced by FATDirectory(), read_dir(), and read_directory().
struct dirsecz* FATDirectory::_secarr [protected] |
Definition at line 60 of file fatfs.h.
Referenced by FATDirectory(), and read_dir().
|
ROS Explorer Source Code Documentation
generated on 02.01.2013 by
|