reactos/modules/rosapps/applications/explorer-old/shell/fatfs.cpp

640 lines
14 KiB
C++
Raw Blame History

/*
* Copyright 2004 Martin Fuchs
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
//
// Explorer clone
//
// fatfs.cpp
//
// Martin Fuchs, 01.02.2004
//
#include <precomp.h>
#include "fatfs.h"
#ifdef _DEBUG
static union DEntry* link_dir_entries(struct dirent* dir, struct Kette* K, int cnt)
{
union DEntry* Ent = (union DEntry*) dir;
struct Kette* L = NULL;
for(; cnt; cnt--) {
K->Rueck = L;
(L=K)->Ent = Ent;
AddP(K, sizeof(struct Kette));
L->Vorw = K;
AddP(Ent, sizeof(union DEntry));
}
L->Vorw = NULL;
return Ent;
}
void FATDirectory::read_directory(int scan_flags)
{
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 filedate& date = e.date;
const filetime& 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;
}
const void* FATDirectory::get_next_path_component(const void* p) const
{
LPCTSTR s = (LPCTSTR) p;
while(*s && *s!=TEXT('\\') && *s!=TEXT('/'))
++s;
while(*s==TEXT('\\') || *s==TEXT('/'))
++s;
if (!*s)
return NULL;
return s;
}
Entry* FATDirectory::find_entry(const void* p)
{
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;
}
// get full path of specified directory entry
bool FATEntry::get_path(PTSTR path, size_t path_count) const
{
return get_path_base ( path, path_count, ET_FAT );
}
ShellPath FATEntry::create_absolute_pidl() const
{
CONTEXT("WinEntry::create_absolute_pidl()");
return (LPCITEMIDLIST)NULL;
/* prepend root path if the drive is currently actually mounted in the file system -> return working PIDL
TCHAR path[MAX_PATH];
if (get_path(path, COUNTOF(path)))
return ShellPath(path);
return ShellPath();
*/
}
FATDirectory::FATDirectory(FATDrive& drive, LPCTSTR root_path)
: FATEntry(),
_drive(drive)
{
_path = _tcsdup(root_path);
_secarr = NULL;
_cur_bufs = 0;
_ents = 0;
_dir = NULL;
_cluster = 0;
}
FATDirectory::FATDirectory(FATDrive& drive, Entry* parent, LPCTSTR path, unsigned cluster)
: FATEntry(parent, cluster),
_drive(drive)
{
_path = _tcsdup(path);
_secarr = NULL;
_cur_bufs = 0;
_ents = 0;
_dir = NULL;
}
FATDirectory::~FATDirectory()
{
free(_path);
_path = NULL;
}
bool FATDirectory::read_dir()
{
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;
}
#ifdef _MSC_VER
#pragma warning(disable: 4355)
#endif
FATDrive::FATDrive(LPCTSTR path)
: FATDirectory(*this, TEXT("\\"))
{
_bufl = 0;
_bufents = 0;
_SClus = 0;
_FATCache = NULL;
_CacheCount = 0;
_CacheSec = NULL;
_CacheCnt = NULL;
_CacheDty = NULL;
_Caches = 0;
_hDrive = CreateFile(path, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
if (_hDrive != INVALID_HANDLE_VALUE) {
_boot_sector.BytesPerSector = 512;
if (read_sector(0, (Buffer*)&_boot_sector, 1)) {
_bufl = _boot_sector.BytesPerSector;
_SClus = _boot_sector.SectorsPerCluster;
_bufents = _bufl / sizeof(union DEntry);
}
small_cache();
}
}
FATDrive::~FATDrive()
{
if (_hDrive != INVALID_HANDLE_VALUE)
CloseHandle(_hDrive);
free(_path);
_path = NULL;
}
void FATDrive::small_cache()
{
if (_FATCache)
free(_FATCache);
if (_CacheSec) {
free(_CacheSec), _CacheSec = NULL;
free(_CacheCnt);
free(_CacheDty);
}
_Caches = CACHE_SIZE_LOW;
_FATCache = (struct Cache *) malloc((_Caches+1) * _drive._bufl);
reset_cache();
}
void FATDrive::reset_cache() // mark cache as empty
{
int i;
if (!_CacheSec) {
_CacheSec = (DWORD*) malloc(_Caches * sizeof(DWORD));
_CacheCnt = (int*) malloc(_Caches * sizeof(int));
_CacheDty = (bool*) malloc(_Caches * sizeof(bool));
} else {
_CacheSec = (DWORD*) realloc(_CacheSec, _Caches * sizeof(DWORD));
_CacheCnt = (int*) realloc(_CacheCnt, _Caches * sizeof(int));
_CacheDty = (bool*) realloc(_CacheDty, _Caches * sizeof(bool));
}
for(i=0; i<_Caches; i++)
_CacheSec[i] = 0;
_read_ahead = (_Caches+1) / 2;
}
bool FATDrive::read_sector(DWORD sec, Buffer* buf, int len)
{
sec += 63; //@@ jump to first partition
if (SetFilePointer(_hDrive, sec*_drive._boot_sector.BytesPerSector, 0, 0) == INVALID_SET_FILE_POINTER)
return false;
DWORD read;
if (!ReadFile(_hDrive, buf, len*_drive._boot_sector.BytesPerSector, &read, 0))
return false;
return true;
}
DWORD FATDrive::read_FAT(DWORD cluster, bool& ok) //@@ use exception handling
{
DWORD nClus;
Buffer* FATBuf;
DWORD nclus = (_boot_sector.Sectors32? _boot_sector.Sectors32: _boot_sector.Sectors16) / _boot_sector.SectorsPerCluster; ///@todo cache result
if (cluster > nclus) {
ok = false;
return (DWORD)-1;
}
if (nclus >= 65536) { // FAT32
DWORD FATsec = cluster / (_boot_sector.BytesPerSector/4);
DWORD z = (cluster - _boot_sector.BytesPerSector/4 * FATsec)*4;
FATsec += _boot_sector.ReservedSectors;
if (!read_cache(FATsec, &FATBuf))
ok = false;
nClus = dpeek(&FATBuf->dat[z]);
} else if (nclus >= 4096) { // 16 Bit-FAT
DWORD FATsec = cluster / (_boot_sector.BytesPerSector/2);
DWORD z = (cluster - _boot_sector.BytesPerSector/2 * FATsec)*2;
FATsec += _boot_sector.ReservedSectors;
if (!read_cache(FATsec, &FATBuf))
ok = false;
nClus = wpeek(&FATBuf->dat[z]);
if (nClus >= 0xfff0)
nClus |= 0x0fff0000;
} else { // 12 Bit-FAT
DWORD FATsec = cluster*3 / (_boot_sector.BytesPerSector*2);
DWORD z = (cluster*3 - _boot_sector.BytesPerSector*2*FATsec)/2;
FATsec += _boot_sector.ReservedSectors;
if (!read_cache(FATsec,&FATBuf))
ok = false;
BYTE a = FATBuf->dat[z++];
if (z >= _boot_sector.BytesPerSector)
if (!read_cache(FATsec+1,&FATBuf))
ok = false;
z = 0;
BYTE b = FATBuf->dat[z];
if (cluster & 1)
nClus = (a>>4) | (b<<4);
else
nClus = a | ((b & 0xf)<<8);
if (nClus >= 0xff0)
nClus |= 0x0ffff000;
}
return nClus;
}
bool FATDrive::read_cache(DWORD sec, Buffer** bufptr)
{
int i, C, anz;
if (_boot_sector.BytesPerSector != BufLen) // no standard sector size?
return read_sector(sec, *bufptr=(Buffer*)&_FATCache[0], 1);
_CacheCount++;
for(i=0; _CacheSec[i]!=sec && i<_Caches; )
++i;
if (i < _Caches)
{
*bufptr = (Buffer*) &_FATCache[i]; // FAT-Sektor schon gepuffert
_CacheCnt[i]++;
return true;
}
i = get_cache_buffer();
if (_cache_empty) // von get_cache_buffer() gesetzt
{
C = _CacheCount-1;
anz = _boot_sector.SectorsPerFAT*_boot_sector.NumberFATs - sec;
if (anz > _read_ahead)
anz = _read_ahead;
for(i=0; i<anz; i++) {
_CacheSec[i] = sec++;
_CacheCnt[i] = C;
_CacheDty[i] = 0;
}
_CacheCnt[0] = _CacheCount;
return read_sector(_CacheSec[0], *bufptr=(Buffer*) &_FATCache[0], anz);
}
else
{
_CacheDty[i] = 0;
_CacheCnt[i] = _CacheCount;
return read_sector(_CacheSec[i]=sec, *bufptr=(Buffer*) &_FATCache[i], 1);
}
}
int FATDrive::get_cache_buffer() // search for free cache buffer
{
int i, j, minCnt;
for(i=0; i<_Caches; i++)
if (_CacheSec[i])
break;
_cache_empty = i==_Caches? true: false;
for(i=0; _CacheSec[i] && i<_Caches; )
++i;
if (i < _Caches)
j = i;
else
{
minCnt = 0; // search for least used buffer
for(j=i=0; i<_Caches; i++)
if (minCnt < _CacheCnt[i]) {
minCnt = _CacheCnt[i];
j = i;
}
/**@todo enable write back
if (CacheDty[j]) // Dirty-Flag gesetzt?
if (writesec(_CacheSec[j], (Buffer*) &_FATCache[j], 1))
FPara = _CacheSec[j], Frag(SecWriteErr);
*/
}
return j;
}
#endif // _DEBUG