Kernel/vfs/fs/fat.c

   1 /*\r
   2  * Acess 2\r
   3  * FAT12/16/32 Driver Version (Incl LFN)\r
   4  */\r
   5 #define DEBUG   0\r
   6 #define VERBOSE 1\r
   7 \r
   8 #define CACHE_FAT       1       //!< Caches the FAT in memory\r
   9 #define USE_LFN         1       //!< Enables the use of Long File Names\r
  10 \r
  11 #include <acess.h>\r
  12 #include <modules.h>\r
  13 #include <vfs.h>\r
  14 #include "fs_fat.h"\r
  15 \r
  16 \r
  17 // === TYPES ===\r
  18 #if USE_LFN\r
  19 typedef struct s_lfncache {\r
  20         Uint    Inode, Impl;\r
  21          int    id;\r
  22         char    Name[256];\r
  23         struct s_lfncache       *Next;\r
  24 }       t_lfncache;\r
  25 #endif\r
  26 \r
  27 // === PROTOTYPES ===\r
  28  int    FAT_Install(char **Arguments);\r
  29 tVFS_Node       *FAT_InitDevice(char *device, char **options);\r
  30 void    FAT_Unmount(tVFS_Node *Node);\r
  31 Uint64  FAT_Read(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer);\r
  32 Uint64  FAT_Write(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer);\r
  33 char    *FAT_ReadDir(tVFS_Node *dirNode, int dirpos);\r
  34 tVFS_Node       *FAT_FindDir(tVFS_Node *dirNode, char *file);\r
  35  int    FAT_Mknod(tVFS_Node *Node, char *Name, Uint Flags);\r
  36  int    FAT_Relink(tVFS_Node *node, char *OldName, char *NewName);\r
  37 void    FAT_CloseFile(tVFS_Node *node);\r
  38 \r
  39 // === SEMI-GLOBALS ===\r
  40 MODULE_DEFINE(0, 0x51 /*v0.80*/, VFAT, FAT_Install, NULL, NULL);\r
  41 tFAT_VolInfo    gFAT_Disks[8];\r
  42  int    giFAT_PartCount = 0;\r
  43 #if USE_LFN\r
  44 t_lfncache      *fat_lfncache;\r
  45 #endif\r
  46 tVFS_Driver     gFAT_FSInfo = {\r
  47         "fat", 0, FAT_InitDevice, FAT_Unmount, NULL\r
  48         };\r
  49 \r
  50 // === CODE ===\r
  51 /**\r
  52  * \fn int FAT_Install(char **Arguments)\r
  53  * \brief \r
  54  */\r
  55 int FAT_Install(char **Arguments)\r
  56 {\r
  57         VFS_AddDriver( &gFAT_FSInfo );\r
  58         return MODULE_INIT_SUCCESS;\r
  59 }\r
  60 \r
  61 /**\r
  62  * \fn tVFS_Node *FAT_InitDevice(char *Device, char **options)\r
  63  * \brief Reads the boot sector of a disk and prepares the structures for it\r
  64  */\r
  65 tVFS_Node *FAT_InitDevice(char *Device, char **options)\r
  66 {\r
  67         fat_bootsect *bs;\r
  68          int    i;\r
  69         Uint32  FATSz, RootDirSectors, TotSec, CountofClusters;\r
  70         tVFS_Node       *node = NULL;\r
  71         tFAT_VolInfo    *diskInfo = &gFAT_Disks[giFAT_PartCount];\r
  72         \r
  73         //Temporary Pointer\r
  74         bs = &diskInfo->bootsect;\r
  75         \r
  76         //Open device and read boot sector\r
  77         diskInfo->fileHandle = VFS_Open(Device, VFS_OPENFLAG_READ|VFS_OPENFLAG_WRITE);\r
  78         if(diskInfo->fileHandle == -1) {\r
  79                 Warning("FAT_InitDisk - Unable to open device '%s'", Device);\r
  80                 return NULL;\r
  81         }\r
  82         \r
  83         VFS_ReadAt(diskInfo->fileHandle, 0, 512, bs);\r
  84         \r
  85         if(bs->bps == 0 || bs->spc == 0) {\r
  86                 Warning("FAT_InitDisk - Error in FAT Boot Sector\n");\r
  87                 return NULL;\r
  88         }\r
  89         \r
  90         //FAT Type Determining\r
  91         // From Microsoft FAT Specifcation\r
  92         RootDirSectors = ((bs->files_in_root*32) + (bs->bps - 1)) / bs->bps;\r
  93         \r
  94         if(bs->fatSz16 != 0)            FATSz = bs->fatSz16;\r
  95         else                                    FATSz = bs->spec.fat32.fatSz32;\r
  96         \r
  97         if(bs->totalSect16 != 0)                TotSec = bs->totalSect16;\r
  98         else                                            TotSec = bs->totalSect32;\r
  99         \r
 100         CountofClusters = (TotSec - (bs->resvSectCount + (bs->fatCount * FATSz) + RootDirSectors)) / bs->spc;\r
 101         \r
 102         if(CountofClusters < 4085)\r
 103                 diskInfo->type = FAT12;\r
 104         else if(CountofClusters < 65525)\r
 105                 diskInfo->type = FAT16;\r
 106         else\r
 107                 diskInfo->type = FAT32;\r
 108         \r
 109         #if VERBOSE\r
 110         {\r
 111                 char    *sFatType, *sSize;\r
 112                 Uint    iSize = CountofClusters * bs->spc / 2;\r
 113                 \r
 114                 switch(diskInfo->type)\r
 115                 {\r
 116                 case FAT12:     sFatType = "FAT12";     break;\r
 117                 case FAT16:     sFatType = "FAT16";     break;\r
 118                 case FAT32:     sFatType = "FAT32";     break;\r
 119                 }\r
 120                 if(iSize <= 2*1024) {\r
 121                         sSize = "KiB";\r
 122                 }\r
 123                 else if(iSize <= 2*1024*1024) {\r
 124                         sSize = "MiB";\r
 125                         iSize >>= 10;\r
 126                 }\r
 127                 else {\r
 128                         sSize = "GiB";\r
 129                         iSize >>= 20;\r
 130                 }\r
 131                 Log("[FAT ] '%s' %s, %i %s", Device, sFatType, iSize, sSize);\r
 132         }\r
 133         #endif\r
 134         \r
 135         //Get Name\r
 136         if(diskInfo->type == FAT32) {\r
 137                 for(i=0;i<11;i++)\r
 138                         diskInfo->name[i] = (bs->spec.fat32.label[i] == ' ' ? '\0' : bs->spec.fat32.label[i]);\r
 139         }\r
 140         else {\r
 141                 for(i=0;i<11;i++)\r
 142                         diskInfo->name[i] = (bs->spec.fat16.label[i] == ' ' ? '\0' : bs->spec.fat16.label[i]);\r
 143         }\r
 144         diskInfo->name[11] = '\0';\r
 145         \r
 146         //Compute Root directory offset\r
 147         if(diskInfo->type == FAT32)\r
 148                 diskInfo->rootOffset = bs->spec.fat32.rootClust;\r
 149         else\r
 150                 diskInfo->rootOffset = (FATSz * bs->fatCount) / bs->spc;\r
 151         \r
 152         diskInfo->clusterCount = CountofClusters;\r
 153         \r
 154         diskInfo->firstDataSect = bs->resvSectCount + (bs->fatCount * FATSz) + RootDirSectors;\r
 155         \r
 156         //Allow for Caching the FAT\r
 157         #if CACHE_FAT\r
 158         {\r
 159         Uint32  Ofs;\r
 160         diskInfo->FATCache = (Uint32*)malloc(sizeof(Uint32)*CountofClusters);\r
 161         if(diskInfo->FATCache == NULL) {\r
 162                 Warning("FAT_InitDisk - Heap Exhausted\n");\r
 163                 return NULL;\r
 164         }\r
 165         Ofs = bs->resvSectCount*512;\r
 166         if(diskInfo->type == FAT12) {\r
 167                 Uint32  val;\r
 168                  int    j;\r
 169                 char    buf[1536];\r
 170                 for(i=0;i<CountofClusters/2;i++) {\r
 171                         j = i & 511;    //%512\r
 172                         if( j == 0 ) {\r
 173                                 VFS_ReadAt(diskInfo->fileHandle, Ofs, 3*512, buf);\r
 174                                 Ofs += 3*512;\r
 175                         }\r
 176                         val = *((int*)(buf+j*3));\r
 177                         diskInfo->FATCache[i*2] = val & 0xFFF;\r
 178                         diskInfo->FATCache[i*2+1] = (val>>12) & 0xFFF;\r
 179                 }\r
 180         }\r
 181         if(diskInfo->type == FAT16) {\r
 182                 Uint16  buf[256];\r
 183                 for(i=0;i<CountofClusters;i++) {\r
 184                         if( (i & 255) == 0 ) {\r
 185                                 VFS_ReadAt(diskInfo->fileHandle, Ofs, 512, buf);\r
 186                                 Ofs += 512;\r
 187                         }\r
 188                         diskInfo->FATCache[i] = buf[i&255];\r
 189                 }\r
 190         }\r
 191         if(diskInfo->type == FAT32) {\r
 192                 Uint32  buf[128];\r
 193                 for(i=0;i<CountofClusters;i++) {\r
 194                         if( (i & 127) == 0 ) {\r
 195                                 VFS_ReadAt(diskInfo->fileHandle, Ofs, 512, buf);\r
 196                                 Ofs += 512;\r
 197                         }\r
 198                         diskInfo->FATCache[i] = buf[i&127];\r
 199                 }\r
 200         }\r
 201         LOG("FAT Fully Cached");\r
 202         }\r
 203         #endif /*CACHE_FAT*/\r
 204         \r
 205         //Initalise inode cache for FAT\r
 206         diskInfo->inodeHandle = Inode_GetHandle();\r
 207         LOG("Inode Cache handle is %i", diskInfo->inodeHandle);\r
 208         \r
 209         // == VFS Interface\r
 210         node = &diskInfo->rootNode;\r
 211         node->Inode = diskInfo->rootOffset;\r
 212         node->Size = bs->files_in_root; // Unknown - To be set on readdir\r
 213         node->ImplInt = giFAT_PartCount;\r
 214         \r
 215         node->ReferenceCount = 1;\r
 216         \r
 217         node->UID = 0;  node->GID = 0;\r
 218         node->NumACLs = 1;\r
 219         node->ACLs = &gVFS_ACL_EveryoneRWX;\r
 220         node->Flags = VFS_FFLAG_DIRECTORY;\r
 221         node->CTime = node->MTime = node->ATime = now();\r
 222         \r
 223         node->Read = node->Write = NULL;\r
 224         node->ReadDir = FAT_ReadDir;\r
 225         node->FindDir = FAT_FindDir;\r
 226         node->Relink = FAT_Relink;\r
 227         node->MkNod = FAT_Mknod;\r
 228         //node->Close = FAT_CloseDevice;\r
 229         \r
 230         giFAT_PartCount ++;\r
 231         return node;\r
 232 }\r
 233 \r
 234 /**\r
 235  * \fn void FAT_Unmount(tVFS_Node *Node)\r
 236  * \brief Closes a mount and marks it as free\r
 237  */\r
 238 void FAT_Unmount(tVFS_Node *Node)\r
 239 {\r
 240         // Close Disk Handle\r
 241         VFS_Close( gFAT_Disks[Node->ImplInt].fileHandle );\r
 242         // Clear Node Cache\r
 243         Inode_ClearCache(gFAT_Disks[Node->ImplInt].inodeHandle);\r
 244         // Mark as unused\r
 245         gFAT_Disks[Node->ImplInt].fileHandle = -2;\r
 246         return;\r
 247 }\r
 248 \r
 249 /**\r
 250  * \fn static Uint32 FAT_int_GetFatValue(tFAT_VolInfo *Disk, Uint32 cluster)\r
 251  * \brief Fetches a value from the FAT\r
 252  */\r
 253 static Uint32 FAT_int_GetFatValue(tFAT_VolInfo *Disk, Uint32 cluster)\r
 254 {\r
 255         Uint32  val = 0;\r
 256         #if !CACHE_FAT\r
 257         Uint32  ofs = Disk->bootsect.resvSectCount*512;\r
 258         #endif\r
 259         ENTER("pDisk xCluster", Disk, cluster);\r
 260         #if CACHE_FAT\r
 261         val = Disk->FATCache[cluster];\r
 262         if(Disk->type == FAT12 && val == EOC_FAT12)     val = -1;\r
 263         if(Disk->type == FAT16 && val == EOC_FAT16)     val = -1;\r
 264         if(Disk->type == FAT32 && val == EOC_FAT32)     val = -1;\r
 265         #else\r
 266         if(Disk->type == FAT12) {\r
 267                 VFS_ReadAt(Disk->fileHandle, ofs+(cluster>>1)*3, 3, &val);\r
 268                 val = (cluster&1 ? val&0xFFF : val>>12);\r
 269                 if(val == EOC_FAT12)    val = -1;\r
 270         } else if(Disk->type == FAT16) {\r
 271                 VFS_ReadAt(Disk->fileHandle, ofs+cluster*2, 2, &val);\r
 272                 if(val == EOC_FAT16)    val = -1;\r
 273         } else {\r
 274                 VFS_ReadAt(Disk->fileHandle, ofs+cluster*4, 4, &val);\r
 275                 if(val == EOC_FAT32)    val = -1;\r
 276         }\r
 277         #endif /*CACHE_FAT*/\r
 278         LEAVE('x', val);\r
 279         return val;\r
 280 }\r
 281 \r
 282 /* Reads a cluster's data\r
 283  */\r
 284 static void FAT_int_ReadCluster(int Handle, Uint32 Cluster, int Length, void *Buffer)\r
 285 {\r
 286         ENTER("iHandle xCluster iLength pBuffer", Handle, Cluster, Length, Buffer);\r
 287         //Log("Cluster = %i (0x%x)", Cluster, Cluster);\r
 288         VFS_ReadAt(\r
 289                 gFAT_Disks[Handle].fileHandle,\r
 290                 (gFAT_Disks[Handle].firstDataSect + (Cluster-2)*gFAT_Disks[Handle].bootsect.spc )\r
 291                         * gFAT_Disks[Handle].bootsect.bps,\r
 292                 Length,\r
 293                 Buffer\r
 294                 );\r
 295         LEAVE('-');\r
 296 }\r
 297 \r
 298 /**\r
 299  * \fn Uint64 FAT_Read(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer)\r
 300  * \brief Reads data from a specified file\r
 301  */\r
 302 Uint64 FAT_Read(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer)\r
 303 {\r
 304          int    preSkip, count;\r
 305          int    handle = node->ImplInt;\r
 306          int    i, cluster, pos;\r
 307          int    bpc;\r
 308         void    *tmpBuf;\r
 309         tFAT_VolInfo    *disk = &gFAT_Disks[node->ImplInt];\r
 310         \r
 311         ENTER("Xoffset Xlength pbuffer", offset, length, buffer);\r
 312         \r
 313         // Calculate and Allocate Bytes Per Cluster\r
 314         bpc = disk->bootsect.spc * disk->bootsect.bps;\r
 315         tmpBuf = (void*) malloc(bpc);\r
 316         LOG("malloc'd %i bytes", bpc);\r
 317         \r
 318         // Cluster is stored in Inode Field\r
 319         cluster = node->Inode;\r
 320         \r
 321         // Sanity Check offset\r
 322         if(offset > node->Size) {\r
 323                 //LOG("Reading past EOF (%i > %i)", offset, node->Size);\r
 324                 LEAVE('i', 0);\r
 325                 return 0;\r
 326         }\r
 327         // Clamp Size\r
 328         if(offset + length > node->Size) {\r
 329                 //LOG("Reading past EOF (%lli + %lli > %lli), clamped to %lli",\r
 330                 //      offset, length, node->Size, node->Size - offset);\r
 331                 length = node->Size - offset;\r
 332         }\r
 333         \r
 334         // Single Cluster including offset\r
 335         if(length + offset < bpc)\r
 336         {\r
 337                 FAT_int_ReadCluster(handle, cluster, bpc, tmpBuf);\r
 338                 memcpy( buffer, (void*)( tmpBuf + offset%bpc ), length );\r
 339                 free(tmpBuf);\r
 340                 LEAVE('i', 1);\r
 341                 return length;\r
 342         }\r
 343         \r
 344         preSkip = offset / bpc;\r
 345         \r
 346         //Skip previous clusters\r
 347         for(i=preSkip;i--;)     {\r
 348                 cluster = FAT_int_GetFatValue(disk, cluster);\r
 349                 if(cluster == -1) {\r
 350                         Warning("FAT_Read - Offset is past end of cluster chain mark");\r
 351                         LEAVE('i', 0);\r
 352                         return 0;\r
 353                 }\r
 354         }\r
 355         \r
 356         // Get Count of Clusters to read\r
 357         count = ((offset%bpc+length) / bpc) + 1;\r
 358         \r
 359         // Get buffer Position after 1st cluster\r
 360         pos = bpc - offset%bpc;\r
 361         \r
 362         // Read 1st Cluster\r
 363         FAT_int_ReadCluster(handle, cluster, bpc, tmpBuf);\r
 364         memcpy(\r
 365                 buffer,\r
 366                 (void*)( tmpBuf + (bpc-pos) ),\r
 367                 (pos < length ? pos : length)\r
 368                 );\r
 369         \r
 370         if (count == 1) {\r
 371                 free(tmpBuf);\r
 372                 LEAVE('i', 1);\r
 373                 return length;\r
 374         }\r
 375         \r
 376         cluster = FAT_int_GetFatValue(disk, cluster);\r
 377         \r
 378         #if DEBUG\r
 379         LOG("pos=%i\n", pos);\r
 380         LOG("Reading the rest of the clusters\n");\r
 381         #endif\r
 382         \r
 383         \r
 384         //Read the rest of the cluster data\r
 385         for( i = 1; i < count-1; i++ )\r
 386         {\r
 387                 FAT_int_ReadCluster(handle, cluster, bpc, tmpBuf);\r
 388                 memcpy((void*)(buffer+pos), tmpBuf, bpc);\r
 389                 pos += bpc;\r
 390                 cluster = FAT_int_GetFatValue(disk, cluster);\r
 391                 if(cluster == -1) {\r
 392                         Warning("FAT_Read - Read past End of Cluster Chain");\r
 393                         free(tmpBuf);\r
 394                         LEAVE('i', 0);\r
 395                         return 0;\r
 396                 }\r
 397         }\r
 398         \r
 399         FAT_int_ReadCluster(handle, cluster, bpc, tmpBuf);\r
 400         memcpy((void*)(buffer+pos), tmpBuf, length-pos);\r
 401         \r
 402         #if DEBUG\r
 403         LOG("Free tmpBuf(0x%x) and Return\n", tmpBuf);\r
 404         #endif\r
 405         \r
 406         free(tmpBuf);\r
 407         LEAVE('X', length);\r
 408         return length;\r
 409 }\r
 410 \r
 411 /**\r
 412  * \fn Uint64 FAT_Write(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer)\r
 413  */\r
 414 Uint64 FAT_Write(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer)\r
 415 {\r
 416         return 0;\r
 417 }\r
 418 \r
 419 /**\r
 420  * \fn static void FAT_int_ProperFilename(char *dest, char *src)\r
 421  * \brief Converts a FAT directory entry name into a proper filename\r
 422  */\r
 423 static void FAT_int_ProperFilename(char *dest, char *src)\r
 424 {\r
 425          int    a, b;\r
 426         \r
 427         for( a = 0; a < 8; a++) {\r
 428                 if(src[a] == ' ')       break;\r
 429                 dest[a] = src[a];\r
 430         }\r
 431         b = a;\r
 432         a = 8;\r
 433         if(src[8] != ' ')\r
 434                 dest[b++] = '.';\r
 435         for( ; a < 11; a++, b++)        {\r
 436                 if(src[a] == ' ')       break;\r
 437                 dest[b] = src[a];\r
 438         }\r
 439         dest[b] = '\0';\r
 440         #if DEBUG\r
 441         //Log("FAT_int_ProperFilename: dest='%s'", dest);\r
 442         #endif\r
 443 }\r
 444 \r
 445 /**\r
 446  * \fn char *FAT_int_CreateName(tVFS_Node *parent, fat_filetable *ft, char *LongFileName)\r
 447  * \brief Converts either a LFN or a 8.3 Name into a proper name\r
 448  */\r
 449 char *FAT_int_CreateName(tVFS_Node *parent, fat_filetable *ft, char *LongFileName)\r
 450 {\r
 451         char    *ret;\r
 452          int    len;\r
 453         #if USE_LFN\r
 454         if(LongFileName && LongFileName[0] != '\0')\r
 455         {       \r
 456                 len = strlen(LongFileName);\r
 457                 ret = malloc(len+1);\r
 458                 strcpy(ret, LongFileName);\r
 459         }\r
 460         else\r
 461         {\r
 462         #endif\r
 463                 ret = (char*) malloc(13);\r
 464                 memset(ret, 13, '\0');\r
 465                 FAT_int_ProperFilename(ret, ft->name);\r
 466         #if USE_LFN\r
 467         }\r
 468         #endif\r
 469         return ret;\r
 470 }\r
 471 \r
 472 /**\r
 473  * \fn tVFS_Node *FAT_int_CreateNode(tVFS_Node *parent, fat_filetable *ft, char *LongFileName)\r
 474  * \brief Creates a tVFS_Node structure for a given file entry\r
 475  */\r
 476 tVFS_Node *FAT_int_CreateNode(tVFS_Node *parent, fat_filetable *ft, char *LongFileName)\r
 477 {\r
 478         tVFS_Node       node = {0};\r
 479         tVFS_Node       *ret;\r
 480         \r
 481         ENTER("pParent pFT sLongFileName", parent, ft, LongFileName);\r
 482         \r
 483         // Set Other Data\r
 484         node.Inode = ft->cluster | (ft->clusterHi<<16);\r
 485         node.Size = ft->size;\r
 486         LOG("ft->size = %i", ft->size);\r
 487         node.ImplInt = parent->ImplInt;\r
 488         node.UID = 0;   node.GID = 0;\r
 489         node.NumACLs = 1;\r
 490         node.ACLs = &gVFS_ACL_EveryoneRWX;      // RWXRWXRWX\r
 491         \r
 492         node.Flags = 0;\r
 493         if(ft->attrib & ATTR_DIRECTORY) node.Flags |= VFS_FFLAG_DIRECTORY;\r
 494         if(ft->attrib & ATTR_READONLY)  node.Flags |= VFS_FFLAG_READONLY;\r
 495         \r
 496         node.ATime = timestamp(0,0,0,\r
 497                         ((ft->adate&0x1F)-1),   //Days\r
 498                         ((ft->adate&0x1E0)-1),          //Months\r
 499                         1980+((ft->adate&0xFF00)>>8));  //Years\r
 500         \r
 501         node.CTime = ft->ctimems * 10;  //Miliseconds\r
 502         node.CTime += timestamp(\r
 503                         (ft->ctime&0x1F)<<1,    //Seconds\r
 504                         ((ft->ctime&0x3F0)>>5), //Minutes\r
 505                         ((ft->ctime&0xF800)>>11),       //Hours\r
 506                         ((ft->cdate&0x1F)-1),           //Days\r
 507                         ((ft->cdate&0x1E0)-1),          //Months\r
 508                         1980+((ft->cdate&0xFF00)>>8));  //Years\r
 509                         \r
 510         node.MTime = timestamp(\r
 511                         (ft->mtime&0x1F)<<1,    //Seconds\r
 512                         ((ft->mtime&0x3F0)>>5), //Minuites\r
 513                         ((ft->mtime&0xF800)>>11),       //Hours\r
 514                         ((ft->mdate&0x1F)-1),           //Days\r
 515                         ((ft->mdate&0x1E0)-1),          //Months\r
 516                         1980+((ft->mdate&0xFF00)>>8));  //Years\r
 517         \r
 518         if(node.Flags & VFS_FFLAG_DIRECTORY) {\r
 519                 node.ReadDir = FAT_ReadDir;\r
 520                 node.FindDir = FAT_FindDir;\r
 521                 node.MkNod = FAT_Mknod;\r
 522                 node.Size = -1;\r
 523         } else {\r
 524                 node.Read = FAT_Read;\r
 525                 node.Write = FAT_Write;\r
 526         }\r
 527         node.Close = FAT_CloseFile;\r
 528         node.Relink = FAT_Relink;\r
 529         \r
 530         ret = Inode_CacheNode(gFAT_Disks[parent->ImplInt].inodeHandle, &node);\r
 531         LEAVE('p', ret);\r
 532         return ret;\r
 533 }\r
 534 \r
 535 #if USE_LFN\r
 536 /**\r
 537  \fn char *FAT_int_GetLFN(tVFS_Node *node)\r
 538  \brief Return pointer to LFN cache entry\r
 539  */\r
 540 char *FAT_int_GetLFN(tVFS_Node *node)\r
 541 {\r
 542         t_lfncache      *tmp;\r
 543         tmp = fat_lfncache;\r
 544         while(tmp)\r
 545         {\r
 546                 if(tmp->Inode == node->Inode && tmp->Impl == node->ImplInt)\r
 547                         return tmp->Name;\r
 548                 tmp = tmp->Next;\r
 549         }\r
 550         tmp = malloc(sizeof(t_lfncache));\r
 551         tmp->Inode = node->Inode;\r
 552         tmp->Impl = node->ImplInt;\r
 553         memset(tmp->Name, 0, 256);\r
 554         \r
 555         tmp->Next = fat_lfncache;\r
 556         fat_lfncache = tmp;\r
 557         \r
 558         return tmp->Name;\r
 559 }\r
 560 \r
 561 /**\r
 562  \fn void FAT_int_DelLFN(tVFS_Node *node)\r
 563  \brief Delete a LFN cache entry\r
 564 */\r
 565 void FAT_int_DelLFN(tVFS_Node *node)\r
 566 {\r
 567         t_lfncache      *tmp;\r
 568         \r
 569         if(!fat_lfncache)       return;\r
 570         \r
 571         if(!fat_lfncache->Next)\r
 572         {\r
 573                 tmp = fat_lfncache;\r
 574                 fat_lfncache = tmp->Next;\r
 575                 free(tmp);\r
 576                 return;\r
 577         }\r
 578         tmp = fat_lfncache;\r
 579         while(tmp && tmp->Next)\r
 580         {\r
 581                 if(tmp->Inode == node->Inode && tmp->Impl == node->ImplInt)\r
 582                 {\r
 583                         free(tmp->Next);\r
 584                         tmp->Next = tmp->Next->Next;\r
 585                         return;\r
 586                 }\r
 587                 tmp = tmp->Next;\r
 588         }\r
 589 }\r
 590 #endif\r
 591 \r
 592 /**\r
 593  \fn char *FAT_ReadDir(tVFS_Node *dirNode, int dirPos)\r
 594  \param dirNode Node structure of directory\r
 595  \param dirPos  Directory position\r
 596 **/\r
 597 char *FAT_ReadDir(tVFS_Node *dirNode, int dirpos)\r
 598 {\r
 599         fat_filetable   fileinfo[16];   //Sizeof=32, 16 per sector\r
 600          int    a=0;\r
 601         tFAT_VolInfo    *disk = &gFAT_Disks[dirNode->ImplInt&7];\r
 602         Uint32  cluster, offset;\r
 603          int    preSkip;\r
 604         char    *ret;\r
 605         #if USE_LFN\r
 606         char    *lfn = NULL;\r
 607         #endif\r
 608         \r
 609         ENTER("pDirNode iDirPos", dirNode, dirpos);\r
 610         \r
 611         // Get Byte Offset and skip\r
 612         offset = dirpos * sizeof(fat_filetable);\r
 613         preSkip = offset / (512 * disk->bootsect.spc);\r
 614         LOG("disk->bootsect.spc = %i", disk->bootsect.spc);\r
 615         LOG("dirNode->size = %i", dirNode->Size);\r
 616         cluster = dirNode->Inode;       // Cluster ID\r
 617         \r
 618         // Do Cluster Skip\r
 619         // - Pre FAT32 had a reserved area for the root.\r
 620         if( disk->type == FAT32 || cluster != disk->rootOffset )\r
 621         {\r
 622                 //Skip previous clusters\r
 623                 for(a=preSkip;a--;)     {\r
 624                         cluster = FAT_int_GetFatValue(disk, cluster);\r
 625                         // Check for end of cluster chain\r
 626                         if(cluster == -1) {     LEAVE('n');     return NULL;}\r
 627                 }\r
 628         }\r
 629         \r
 630         // Bounds Checking (Used to spot heap overflows)\r
 631         if(cluster > disk->clusterCount + 2)\r
 632         {\r
 633                 Warning("FAT_ReadDir - Cluster ID is over cluster count (0x%x>0x%x)",\r
 634                         cluster, disk->clusterCount+2);\r
 635                 LEAVE('n');\r
 636                 return NULL;\r
 637         }\r
 638         \r
 639         LOG("cluster=0x%x, dirpos=%i", cluster, dirpos);\r
 640         \r
 641         // Compute Offsets\r
 642         // - Pre FAT32 cluster base (in sectors)\r
 643         if( cluster == disk->rootOffset && disk->type != FAT32 )\r
 644                 offset = disk->bootsect.resvSectCount + cluster*disk->bootsect.spc;\r
 645         else\r
 646         {       // FAT32 cluster base (in sectors)\r
 647                 offset = disk->firstDataSect;\r
 648                 offset += (cluster - 2) * disk->bootsect.spc;\r
 649         }\r
 650         // Sector in cluster\r
 651         if(disk->bootsect.spc == 1)\r
 652                 offset += (dirpos / 16);\r
 653         else\r
 654                 offset += (dirpos / 16) % disk->bootsect.spc;\r
 655         // Offset in sector\r
 656         a = dirpos % 16;\r
 657 \r
 658         LOG("offset=%i, a=%i", (Uint)offset, a);\r
 659         \r
 660         // Read Sector\r
 661         VFS_ReadAt(disk->fileHandle, offset*512, 512, fileinfo);        // Read Dir Data\r
 662         \r
 663         LOG("name[0] = 0x%x", (Uint8)fileinfo[a].name[0]);\r
 664         //Check if this is the last entry\r
 665         if( fileinfo[a].name[0] == '\0' ) {\r
 666                 dirNode->Size = dirpos;\r
 667                 LOG("End of list");\r
 668                 LEAVE('n');\r
 669                 return NULL;    // break\r
 670         }\r
 671         \r
 672         // Check for empty entry\r
 673         if( (Uint8)fileinfo[a].name[0] == 0xE5 ) {\r
 674                 LOG("Empty Entry");\r
 675                 LEAVE('p', VFS_SKIP);\r
 676                 return VFS_SKIP;        // Skip\r
 677         }\r
 678         \r
 679         #if USE_LFN\r
 680         // Get Long File Name Cache\r
 681         lfn = FAT_int_GetLFN(dirNode);\r
 682         if(fileinfo[a].attrib == ATTR_LFN)\r
 683         {\r
 684                 fat_longfilename        *lfnInfo;\r
 685                  int    len;\r
 686                 \r
 687                 lfnInfo = (fat_longfilename *) &fileinfo[a];\r
 688                 if(lfnInfo->id & 0x40)  memset(lfn, 0, 256);\r
 689                 // Get the current length\r
 690                 len = strlen(lfn);\r
 691                 \r
 692                 // Sanity Check (FAT implementations should not allow >255 bytes)\r
 693                 if(len + 13 > 255)      return VFS_SKIP;\r
 694                 // Rebase all bytes\r
 695                 for(a=len+1;a--;)       lfn[a+13] = lfn[a];\r
 696                 \r
 697                 // Append new bytes\r
 698                 lfn[ 0] = lfnInfo->name1[0];    lfn[ 1] = lfnInfo->name1[1];\r
 699                 lfn[ 2] = lfnInfo->name1[2];    lfn[ 3] = lfnInfo->name1[3];\r
 700                 lfn[ 4] = lfnInfo->name1[4];    \r
 701                 lfn[ 5] = lfnInfo->name2[0];    lfn[ 6] = lfnInfo->name2[1];\r
 702                 lfn[ 7] = lfnInfo->name2[2];    lfn[ 8] = lfnInfo->name2[3];\r
 703                 lfn[ 9] = lfnInfo->name2[4];    lfn[10] = lfnInfo->name2[5];\r
 704                 lfn[11] = lfnInfo->name3[0];    lfn[12] = lfnInfo->name3[1];\r
 705                 LEAVE('p', VFS_SKIP);\r
 706                 return VFS_SKIP;\r
 707         }\r
 708         #endif\r
 709         \r
 710         //Check if it is a volume entry\r
 711         if(fileinfo[a].attrib & 0x08) {\r
 712                 LEAVE('p', VFS_SKIP);\r
 713                 return VFS_SKIP;\r
 714         }\r
 715         // Ignore . and ..\r
 716         if(fileinfo[a].name[0] == '.') {\r
 717                 LEAVE('p', VFS_SKIP);\r
 718                 return VFS_SKIP;\r
 719         }       \r
 720         \r
 721         LOG("name='%c%c%c%c%c%c%c%c.%c%c%c'\n",\r
 722                 fileinfo[a].name[0], fileinfo[a].name[1], fileinfo[a].name[2], fileinfo[a].name[3],\r
 723                 fileinfo[a].name[4], fileinfo[a].name[5], fileinfo[a].name[6], fileinfo[a].name[7],\r
 724                 fileinfo[a].name[8], fileinfo[a].name[9], fileinfo[a].name[10] );\r
 725         \r
 726         #if USE_LFN\r
 727         //node = FAT_int_CreateNode(dirNode, &fileinfo[a], lfn);\r
 728         ret = FAT_int_CreateName(dirNode, &fileinfo[a], lfn);\r
 729         lfn[0] = '\0';\r
 730         #else\r
 731         //node = FAT_int_CreateNode(dirNode, &fileinfo[a], NULL);\r
 732         ret = FAT_int_CreateName(dirNode, &fileinfo[a], NULL);\r
 733         #endif\r
 734         \r
 735         LEAVE('s', ret);\r
 736         return ret;\r
 737 }\r
 738 \r
 739 /**\r
 740  * \fn tVFS_Node *FAT_FindDir(tVFS_Node *node, char *name)\r
 741  * \brief Finds an entry in the current directory\r
 742  */\r
 743 tVFS_Node *FAT_FindDir(tVFS_Node *node, char *name)\r
 744 {\r
 745         fat_filetable   fileinfo[16];\r
 746         char    tmpName[11];\r
 747         #if USE_LFN\r
 748         fat_longfilename        *lfnInfo;\r
 749         char    *lfn = NULL;\r
 750          int    lfnPos=255, lfnId = -1;\r
 751         #endif\r
 752          int    i=0;\r
 753         tVFS_Node       *tmpNode;\r
 754         Uint64  diskOffset;\r
 755         tFAT_VolInfo    *disk = &gFAT_Disks[node->ImplInt];\r
 756         Uint32  dirCluster;\r
 757         Uint32  cluster;\r
 758         \r
 759         ENTER("pnode sname", node, name);\r
 760         \r
 761         // Fast Returns\r
 762         if(!name || name[0] == '\0') {\r
 763                 LEAVE('n');\r
 764                 return NULL;\r
 765         }\r
 766         \r
 767         #if USE_LFN\r
 768         lfn = FAT_int_GetLFN(node);\r
 769         #endif\r
 770         \r
 771         dirCluster = node->Inode;\r
 772         // Seek to Directory\r
 773         if( dirCluster == disk->rootOffset && disk->type != FAT32 )\r
 774                 diskOffset = (disk->bootsect.resvSectCount+dirCluster*disk->bootsect.spc) << 9;\r
 775         else\r
 776                 diskOffset = (disk->firstDataSect+(dirCluster-2)*disk->bootsect.spc) << 9;\r
 777         \r
 778         for(;;i++)\r
 779         {\r
 780                 // Load sector\r
 781                 if((i & 0xF) == 0) {\r
 782                         //Log("FAT_FindDir: diskOffset = 0x%x", diskOffset);\r
 783                         VFS_ReadAt(disk->fileHandle, diskOffset, 512, fileinfo);\r
 784                         diskOffset += 512;\r
 785                 }\r
 786                 \r
 787                 //Check if the files are free\r
 788                 if(fileinfo[i&0xF].name[0] == '\0')     break;          //Free and last\r
 789                 if(fileinfo[i&0xF].name[0] == '\xE5')   goto loadCluster;       //Free\r
 790                 \r
 791                 \r
 792                 #if USE_LFN\r
 793                 // Long File Name Entry\r
 794                 if(fileinfo[i&0xF].attrib == ATTR_LFN)\r
 795                 {\r
 796                         lfnInfo = (fat_longfilename *) &fileinfo[i&0xF];\r
 797                         if(lfnInfo->id & 0x40) {\r
 798                                 memset(lfn, 0, 256);\r
 799                                 lfnPos = 255;\r
 800                         }\r
 801                         lfn[lfnPos--] = lfnInfo->name3[1];      lfn[lfnPos--] = lfnInfo->name3[0];\r
 802                         lfn[lfnPos--] = lfnInfo->name2[5];      lfn[lfnPos--] = lfnInfo->name2[4];\r
 803                         lfn[lfnPos--] = lfnInfo->name2[3];      lfn[lfnPos--] = lfnInfo->name2[2];\r
 804                         lfn[lfnPos--] = lfnInfo->name2[1];      lfn[lfnPos--] = lfnInfo->name2[0];\r
 805                         lfn[lfnPos--] = lfnInfo->name1[4];      lfn[lfnPos--] = lfnInfo->name1[3];\r
 806                         lfn[lfnPos--] = lfnInfo->name1[2];      lfn[lfnPos--] = lfnInfo->name1[1];\r
 807                         lfn[lfnPos--] = lfnInfo->name1[0];\r
 808                         if((lfnInfo->id&0x3F) == 1)\r
 809                         {\r
 810                                 memcpy(lfn, lfn+lfnPos+1, 256-lfnPos);\r
 811                                 lfnId = i+1;\r
 812                         }\r
 813                 }\r
 814                 else\r
 815                 {\r
 816                         // Remove LFN if it does not apply\r
 817                         if(lfnId != i)  lfn[0] = '\0';\r
 818                 #endif\r
 819                         // Get Real Filename\r
 820                         FAT_int_ProperFilename(tmpName, fileinfo[i&0xF].name);\r
 821                 \r
 822                         LOG("tmpName = '%s'", tmpName);\r
 823                 \r
 824                         //Only Long name is case sensitive, 8.3 is not\r
 825                         #if USE_LFN\r
 826                         if(strucmp(tmpName, name) == 0 || strcmp(lfn, name) == 0) {\r
 827                         #else\r
 828                         if(strucmp(tmpName, name) == 0) {\r
 829                         #endif\r
 830                                 cluster = fileinfo[i&0xF].cluster | (fileinfo[i&0xF].clusterHi << 16);\r
 831                                 tmpNode = Inode_GetCache(disk->inodeHandle, cluster);\r
 832                                 if(tmpNode == NULL)     // Node is not cached\r
 833                                 {\r
 834                                         #if USE_LFN\r
 835                                         tmpNode = FAT_int_CreateNode(node, &fileinfo[i&0xF], lfn);\r
 836                                         #else\r
 837                                         tmpNode = FAT_int_CreateNode(node, &fileinfo[i&0xF], NULL);\r
 838                                         #endif\r
 839                                 }\r
 840                                 #if USE_LFN\r
 841                                 lfn[0] = '\0';\r
 842                                 #endif\r
 843                                 LEAVE('p', tmpNode);\r
 844                                 return tmpNode;\r
 845                         }\r
 846                 #if USE_LFN\r
 847                 }\r
 848                 #endif\r
 849                 \r
 850         loadCluster:\r
 851                 //Load Next cluster?\r
 852                 if( ((i+1) >> 4) % disk->bootsect.spc == 0 && ((i+1) & 0xF) == 0)\r
 853                 {\r
 854                         if( dirCluster == disk->rootOffset && disk->type != FAT32 )\r
 855                                 continue;\r
 856                         dirCluster = FAT_int_GetFatValue(disk, dirCluster);\r
 857                         if(dirCluster == -1)    break;\r
 858                         diskOffset = (disk->firstDataSect+(dirCluster-2)*disk->bootsect.spc)*512;\r
 859                 }\r
 860         }\r
 861         \r
 862         LEAVE('n');\r
 863         return NULL;\r
 864 }\r
 865 \r
 866 /**\r
 867  * \fn int FAT_Mknod(tVFS_Node *Node, char *Name, Uint Flags)\r
 868  * \brief Create a new node\r
 869  */\r
 870 int FAT_Mknod(tVFS_Node *Node, char *Name, Uint Flags)\r
 871 {\r
 872         return 0;\r
 873 }\r
 874 \r
 875 /**\r
 876  * \fn int FAT_Relink(tVFS_Node *Node, char *OldName, char *NewName)\r
 877  * \brief Rename / Delete a file\r
 878  */\r
 879 int FAT_Relink(tVFS_Node *Node, char *OldName, char *NewName)\r
 880 {\r
 881         return 0;\r
 882 }\r
 883 \r
 884 /**\r
 885  * \fn void FAT_CloseFile(tVFS_Node *Node)\r
 886  * \brief Close an open file\r
 887  */\r
 888 void FAT_CloseFile(tVFS_Node *Node)\r
 889 {\r
 890         if(Node == NULL)        return ;\r
 891         \r
 892         Inode_UncacheNode(gFAT_Disks[Node->ImplInt].inodeHandle, Node->Inode);\r
 893         #if USE_LFN\r
 894         if(     !Inode_GetCache(gFAT_Disks[Node->ImplInt].inodeHandle, Node->Inode)\r
 895         &&      Node->Flags & VFS_FFLAG_DIRECTORY)\r
 896                 FAT_int_DelLFN(Node);\r
 897         else    // Get Cache references the node, so dereference it\r
 898                 Inode_UncacheNode(gFAT_Disks[Node->ImplInt].inodeHandle, Node->Inode);\r
 899         #endif\r
 900         return ;\r
 901 }\r
 902 \r
 903 /**\r
 904  * \fn void fat_install()\r
 905  * \brief Add the FAT Filesystem to the VFS\r
 906  */\r
 907 void fat_install()\r
 908 {\r
 909         VFS_AddDriver( &gFAT_FSInfo );\r
 910 }\r