* dir.c
* - Directory access/manipulation code
*/
-#define DEBUG 1
+#define DEBUG 0
#include <acess.h>
#include <vfs.h>
#include "common.h"
// === PROTOTYPES ===
void FAT_int_ProperFilename(char *dest, const char *src);
-char *FAT_int_CreateName(fat_filetable *ft, const Uint16 *LongFileName);
+ int FAT_int_CreateName(fat_filetable *ft, const Uint16 *LongFileName, char *Dest);
int FAT_int_ConvertUTF16_to_UTF8(Uint8 *Dest, const Uint16 *Source);
int FAT_int_ConvertUTF8_to_UTF16(Uint16 *Dest, const Uint8 *Source);
Uint16 *FAT_int_GetLFN(tVFS_Node *Node, int ID);
void FAT_int_DelLFN(tVFS_Node *Node, int ID);
#endif
-char *FAT_ReadDir(tVFS_Node *Node, int ID);
-tVFS_Node *FAT_FindDir(tVFS_Node *Node, const char *Name);
+ int FAT_ReadDir(tVFS_Node *Node, int ID, char Dest[FILENAME_MAX]);
+tVFS_Node *FAT_FindDir(tVFS_Node *Node, const char *Name, Uint Flags);
tVFS_Node *FAT_GetNodeFromINode(tVFS_Node *Root, Uint64 Inode);
#if SUPPORT_WRITE
- int FAT_Mknod(tVFS_Node *Node, const char *Name, Uint Flags);
+tVFS_Node *FAT_Mknod(tVFS_Node *Node, const char *Name, Uint Flags);
int FAT_int_IsValid83Filename(const char *Name);
int FAT_Link(tVFS_Node *DirNode, const char *NewName, tVFS_Node *Node);
int FAT_Relink(tVFS_Node *node, const char *OldName, const char *NewName);
* \param LongFileName Long file name pointer
* \return Filename as a heap string
*/
-char *FAT_int_CreateName(fat_filetable *ft, const Uint16 *LongFileName)
+int FAT_int_CreateName(fat_filetable *ft, const Uint16 *LongFileName, char *Dest)
{
- char *ret;
ENTER("pft sLongFileName", ft, LongFileName);
- //Log_Debug("FAT", "FAT_int_CreateName(ft=%p, LongFileName=%p'%s')", ft, LongFileName);
#if USE_LFN
if(LongFileName && LongFileName[0] != 0)
{
int len = FAT_int_ConvertUTF16_to_UTF8(NULL, LongFileName);
- ret = malloc( len + 1 );
- FAT_int_ConvertUTF16_to_UTF8((Uint8*)ret, LongFileName);
+ if( len > FILENAME_MAX ) {
+ LEAVE('i', -1);
+ return -1;
+ }
+ FAT_int_ConvertUTF16_to_UTF8((Uint8*)Dest, LongFileName);
}
else
{
#endif
- ret = (char*) malloc(13);
- if( !ret ) {
- Log_Warning("FAT", "FAT_int_CreateName: malloc(13) failed");
- return NULL;
- }
- FAT_int_ProperFilename(ret, ft->name);
+ FAT_int_ProperFilename(Dest, ft->name);
#if USE_LFN
}
#endif
- LEAVE('s', ret);
- return ret;
+ LEAVE('i', 0);
+ return 0;
}
#if USE_LFN
fat_filetable fileinfo[ents_per_sector];
int i, sector;
- Mutex_Acquire(&DirNode->Lock);
+ if( Mutex_Acquire(&DirNode->Lock) ) {
+ return -EINTR;
+ }
+
sector = 0;
for( i = 0; ; i ++ )
{
if(fileinfo[i].attrib == ATTR_LFN) continue;
- LOG("fileinfo[i].cluster = %x %04x", fileinfo[i].clusterHi, fileinfo[i].cluster);
+ LOG("fileinfo[i].cluster = %x:%04x", fileinfo[i].clusterHi, fileinfo[i].cluster);
#if DEBUG
{
char tmpName[13];
}
Mutex_Release(&DirNode->Lock);
- return -1;
+ return -ENOENT;
}
/*
*/
Uint16 *FAT_int_GetLFN(tVFS_Node *Node, int ID)
{
- tFAT_LFNCache *cache;
- int i, firstFree;
-
- Mutex_Acquire( &Node->Lock );
+ if( Mutex_Acquire( &Node->Lock ) ) {
+ return NULL;
+ }
// TODO: Thread Safety (Lock things)
- cache = Node->Data;
+ tFAT_LFNCache *cache = Node->Data;
// Create a cache if it isn't there
if(!cache) {
}
// Scan for this entry
- firstFree = -1;
- for( i = 0; i < cache->NumEntries; i++ )
+ int firstFree = -1;
+ for( int i = 0; i < cache->NumEntries; i++ )
{
if( cache->Entries[i].ID == ID ) {
Mutex_Release( &Node->Lock );
firstFree = i;
}
- if(firstFree == -1) {
- // Use `i` for temp length
- i = sizeof(tFAT_LFNCache) + (cache->NumEntries+1)*sizeof(tFAT_LFNCacheEnt);
- Node->Data = realloc( Node->Data, i );
- if( !Node->Data ) {
- Log_Error("FAT", "realloc() fail, unable to allocate %i for LFN cache", i);
+ int cache_entry = firstFree;
+
+ if(firstFree == -1)
+ {
+ size_t newsize = offsetof(tFAT_LFNCache, Entries[cache->NumEntries+1]);
+ tFAT_LFNCache *new_alloc = realloc( Node->Data, newsize );
+ if( !new_alloc ) {
+ Log_Error("FAT", "realloc() fail, unable to allocate %zi for LFN cache", newsize);
Mutex_Release( &Node->Lock );
return NULL;
}
+ Node->Data = new_alloc;
//Log_Debug("FAT", "Realloc (%i)\n", i);
cache = Node->Data;
- i = cache->NumEntries;
+ cache_entry = cache->NumEntries;
cache->NumEntries ++;
}
- else {
- i = firstFree;
+ else
+ {
+ cache_entry = firstFree;
}
// Create new entry
- cache->Entries[ i ].ID = ID;
- cache->Entries[ i ].Data[0] = '\0';
+ cache->Entries[ cache_entry ].ID = ID;
+ cache->Entries[ cache_entry ].Data[0] = '\0';
Mutex_Release( &Node->Lock );
//Log_Debug("FAT", "Return = %p (firstFree, i = %i)", cache->Entries[i].Data, i);
- return cache->Entries[ i ].Data;
+ return cache->Entries[ cache_entry ].Data;
}
/**
* \param ID Directory position
* \return Filename as a heap string, NULL or VFS_SKIP
*/
-char *FAT_ReadDir(tVFS_Node *Node, int ID)
+int FAT_ReadDir(tVFS_Node *Node, int ID, char Dest[FILENAME_MAX])
{
fat_filetable fileinfo[16]; // sizeof(fat_filetable)=32, so 16 per sector
int a;
- char *ret;
#if USE_LFN
Uint16 *lfn = NULL;
#endif
if(FAT_int_ReadDirSector(Node, ID/16, fileinfo))
{
LOG("End of chain, end of dir");
- LEAVE('n');
- return NULL;
+ LEAVE('i', -EIO);
+ return -EIO;
}
// Offset in sector
if( fileinfo[a].name[0] == '\0' ) {
Node->Size = ID;
LOG("End of list");
- LEAVE('n');
- return NULL; // break
+ LEAVE('i', -ENOENT);
+ return -ENOENT; // break
}
// Check for empty entry
if( (Uint8)fileinfo[a].name[0] == 0xE5 ) {
LOG("Empty Entry");
- #if 0 // Stop on empty entry?
- LEAVE('n');
- return NULL; // Stop
- #else
- LEAVE('p', VFS_SKIP);
- return VFS_SKIP; // Skip
- #endif
+ LEAVE_RET('i', 1); // Skip
}
#if USE_LFN
a = FAT_int_ParseLFN(&fileinfo[a], lfn);
if( a < 0 ) {
LOG("Invalid LFN, error");
- LEAVE('n');
- return NULL;
+ LEAVE_RET('i', -EIO);
}
-// LOG("lfn = '%s'", lfn);
- //Log_Debug("FAT", "lfn = '%s'", lfn);
- LEAVE('p', VFS_SKIP);
- return VFS_SKIP;
+ LEAVE_RET('i', 1); // Skip
}
#endif
// Check if it is a volume entry
if(fileinfo[a].attrib & 0x08) {
- LEAVE('p', VFS_SKIP);
- return VFS_SKIP;
+ LEAVE_RET('i', 1); // Skip
}
// Ignore .
if(fileinfo[a].name[0] == '.' && fileinfo[a].name[1] == ' ') {
- LEAVE('p', VFS_SKIP);
- return VFS_SKIP;
+ LEAVE_RET('i', 1); // Skip
}
// and ..
if(fileinfo[a].name[0] == '.' && fileinfo[a].name[1] == '.' && fileinfo[a].name[2] == ' ') {
- LEAVE('p', VFS_SKIP);
- return VFS_SKIP;
+ LEAVE_RET('i', 1); // Skip
}
LOG("name='%c%c%c%c%c%c%c%c.%c%c%c'",
#if USE_LFN
lfn = FAT_int_GetLFN(Node, ID);
//Log_Debug("FAT", "lfn = %p'%s'", lfn, lfn);
- ret = FAT_int_CreateName(&fileinfo[a], lfn);
+ FAT_int_CreateName(&fileinfo[a], lfn, Dest);
#else
- ret = FAT_int_CreateName(&fileinfo[a], NULL);
+ FAT_int_CreateName(&fileinfo[a], NULL, Dest);
#endif
- LEAVE('s', ret);
- return ret;
+ LEAVE('i', 0);
+ return 0;
}
/**
* \fn tVFS_Node *FAT_FindDir(tVFS_Node *node, char *name)
* \brief Finds an entry in the current directory
*/
-tVFS_Node *FAT_FindDir(tVFS_Node *Node, const char *Name)
+tVFS_Node *FAT_FindDir(tVFS_Node *Node, const char *Name, Uint Flags)
{
fat_filetable fileent;
if( ret ) {
if( (ret->Inode >> 32) != 0 ) {
LOG("Node in cache, quick return");
+ LEAVE('p', ret);
return ret;
}
else {
/**
* \brief Create a new node
*/
-int FAT_Mknod(tVFS_Node *DirNode, const char *Name, Uint Flags)
+tVFS_Node *FAT_Mknod(tVFS_Node *DirNode, const char *Name, Uint Flags)
{
tFAT_VolInfo *disk = DirNode->ImplPtr;
int rv;
tVFS_Node *newnode = FAT_int_CreateNode(DirNode, &ft);
if( !newnode ) {
- return -1;
+ errno = -EINTERNAL;
+ return NULL;
}
LOG("newnode = %p", newnode);
if( (rv = FAT_Link(DirNode, Name, newnode)) ) {
newnode->ImplInt |= FAT_FLAG_DELETE;
}
- FAT_CloseFile(newnode);
- LEAVE('i', rv);
- return rv;
+ LEAVE('p', newnode);
+ return newnode;
}
/**
if( 'A' <= ch && ch <= 'Z' )
return 1;
if( 'a' <= ch && ch <= 'z' )
- return 0;
- if( strchr(";+=[]',\"*\\<>/?:| ", ch) )
- return 0;
- return 1;
+ return 1;
+ if( strchr("$%'-_@~`#!(){}^#&", ch) )
+ return 1;
+ if( ch > 128 )
+ return 1;
+ return 0;
+}
+
+Uint8 FAT_int_UnicodeTo83(Uint32 Input)
+{
+ Input = toupper(Input);
+ // Input = unicode_to_oem(Input);
+ if( Input > 256 )
+ Input = '_';
+ if(!is_valid_83_char(Input))
+ Input = '_';
+ return Input;
}
/**
}
// After the extension must be the end
- if( !Name[i+j] )
+ if( Name[i+j] )
return 0;
return 1;
}
+Uint8 FAT_int_MakeLFNChecksum(const char *ShortName)
+{
+ Uint8 ret = 0;
+ for( int i = 0; i < 11; i++ )
+ {
+ // ret = (ret >>> 1) + ShortName[i]
+ // where >>> is rotate right
+ ret = ((ret & 1) ? 0x80 : 0x00) + (ret >> 1) + ShortName[i];
+ }
+ return ret;
+}
+
/**
* \brief Create a new name for a file
* \note Since FAT doesn't support reference counting, this will cause double-references if
const int eps = 512 / sizeof(fat_filetable);
fat_filetable fileinfo[eps];
- Mutex_Acquire( &DirNode->Lock );
+ if( Mutex_Acquire( &DirNode->Lock ) ) {
+ return EINTR;
+ }
// -- Ensure duplicates aren't created --
if( FAT_int_GetEntryByName(DirNode, NewName, &ft) >= 0 ) {
}
// -- Create filetable entry --
+ #if 0
+ {
+ int bDirty = 0;
+ int inofs = 0;
+ while( NewName[inofs] && NewName[inofs] == '.' )
+ inofs ++, bDirty = 1;
+ for( int i = 0; i < 8 && NewName[inofs] && NewName[inofs] != '.'; i ++ )
+ {
+ Uint32 cp;
+ inofs += ReadUTF8(NewName + inofs, &cp);
+ // Spaces are silently skipped
+ if(isspace(cp)) {
+ i --, bDirty = 1;
+ continue ;
+ }
+ ft.name[i] = FAT_int_UnicodeTo83(cp);
+ if(ft.name[i] != cp)
+ bDirty = 1;
+ }
+ while( NewName[inofs] && NewName[inofs] != '.' )
+ inofs ++, bDirty = 1;
+ for( ; i < 8+3 && NewName[inofs]; i ++ )
+ {
+ Uint32 cp;
+ inofs += ReadUTF8(NewName + inofs, &cp);
+ // Spaces are silently skipped
+ if(isspace(cp)) {
+ i --, bDirty = 1;
+ continue ;
+ }
+ ft.name[i] = FAT_int_UnicodeTo83(cp);
+ if(ft.name[i] != cp)
+ bDirty = 1;
+ }
+ if( !NewName[inofs] ) bDirty = 1;
+
+ if( bDirty )
+ {
+ int lfnlen = FAT_int_ConvertUTF8_to_UTF16(lfn, (const Uint8*)NewName);
+ lfn[lfnlen] = 0;
+ nLFNEnt = DivUp(lfnlen, 13);
+ }
+ }
+ #endif
int bNeedsLFN = !FAT_int_IsValid83Filename(NewName);
if( bNeedsLFN )
{
ft.name[i] = toupper(NewName[j]);
}
ft.name[i++] = '~';
- ft.name[i++] = '0';
+ ft.name[i++] = '1';
while(i < 8) ft.name[i++] = ' ';
while(NewName[j] && NewName[j] != '.') j ++;
for( ; i < 8+3 && NewName[j]; i ++, j ++ )
ft.attrib = 0;
if(NewNode->Flags & VFS_FFLAG_DIRECTORY )
ft.attrib |= ATTR_DIRECTORY;
- // TODO: Fill in creation/modifcation times
+ ft.ntres = 0;
+ FAT_int_GetFATTimestamp(NewNode->CTime, &ft.cdate, &ft.ctime, &ft.ctimems);
+// ft.ctimems = ft.ctimems;
+ ft.ctime = LittleEndian16(ft.ctime);
+ ft.cdate = LittleEndian16(ft.cdate);
+ FAT_int_GetFATTimestamp(NewNode->MTime, &ft.mdate, &ft.mtime, NULL);
+ ft.mtime = LittleEndian16(ft.mtime);
+ ft.mdate = LittleEndian16(ft.mdate);
+ FAT_int_GetFATTimestamp(NewNode->ATime, &ft.adate, NULL, NULL);
+ ft.adate = LittleEndian16(ft.adate);
ft.clusterHi = LittleEndian16((NewNode->Inode >> 16) & 0xFFFF);
ft.cluster = LittleEndian16(NewNode->Inode & 0xFFFF);
ft.size = LittleEndian32(NewNode->Size);
return ENOTIMPL;
}
+ // Calculate the checksum used for LFN
+ Uint8 lfn_checksum = 0;
+ if( nLFNEnt )
+ {
+ lfn_checksum = FAT_int_MakeLFNChecksum(ft.name);
+ }
+
// Insert entries
if( range_first % eps != 0 )
FAT_int_ReadDirSector(DirNode, range_first/eps, fileinfo);
lfnent->attrib = ATTR_LFN;
lfnent->type = 0;
lfnent->firstCluster = 0;
- lfnent->checksum = 0; // ???
+ lfnent->checksum = lfn_checksum; // ???
for( i = 0; i < 13; i ++ )
{
else
lfnent->name3[i-5-6] = wd;
}
-
- lfnent->checksum = 0; // ???
}
}
FAT_int_WriteDirSector(DirNode, range_last/eps, fileinfo);
tVFS_Node *child;
fat_filetable ft;
- Mutex_Acquire(&Node->Lock);
+ if( Mutex_Acquire(&Node->Lock) ) {
+ return EINTR;
+ }
int id = FAT_int_GetEntryByName(Node, OldName, &ft);
if(id == -1) {
git.ucc.asn.au / tpg / acess2.git / blobdiff
UCC git Repository :: git.ucc.asn.au