Kernel/vfs/fs/fat.c

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