FAT12-Dateisystem

struct RootDirectoryEntry
{
   unsigned char FileName[8];
   unsigned char Extension[3];
   unsigned char Attributes[1];
   unsigned char Reserved[2];
   unsigned CreationSecond: 5;
   unsigned CreationMinute: 6;
   unsigned CreationHour: 5;
   unsigned CreationDay: 5;
   unsigned CreationMonth: 4;
   unsigned CreationYear: 7;
   unsigned LastAccessDay: 5;
   unsigned LastAccessMonth: 4;
   unsigned LastAccessYear: 7;
   unsigned char Ignore[2];
   unsigned LastWriteSecond: 5;
   unsigned LastWriteMinute: 6;
   unsigned LastWriteHour: 5;
   unsigned LastWriteDay: 5;
   unsigned LastWriteMonth: 4;
   unsigned LastWriteYear: 7;
   unsigned short FirstCluster;
   unsigned int FileSize;
} __attribute__ ((packed));

typedef struct RootDirectoryEntry 
   RootDirectoryEntry; 

static void LoadRootDirectory()
{
   // Calculate the Root Directory Size:
   // 14 sectors: => 32 * 224 / 512
   short rootDirectorySectors =
      32 * ROOT_DIRECTORY_ENTRIES / 
      BYTES_PER_SECTOR;
   // Calculate the LBA address of the Root 
   // Directory: 19: => 2 * 9 + 1
   short lbaAddressRootDirectory =
      FAT_COUNT * SECTORS_PER_FAT + 
      RESERVED_SECTORS;
   // Load the whole Root Directory (14 sectors)
   // into memory
   ROOT_DIRECTORY_BUFFER = 
      malloc(rootDirectorySectors * 
      BYTES_PER_SECTOR);
   ReadSectors(
      (unsigned char *)
         ROOT_DIRECTORY_BUFFER, 
      lbaAddressRootDirectory, 
      rootDirectorySectors);
   // Load the whole FAT (18 sectors)
   // into memory
   FAT_BUFFER = malloc(FAT_COUNT * 
      SECTORS_PER_FAT * BYTES_PER_SECTOR);
   ReadSectors((unsigned char *)FAT_BUFFER, 
      FAT1_CLUSTER, FAT_COUNT * 
      SECTORS_PER_FAT);
} 

void PrintRootDirectory()
{
   char str[32] = "";
   int fileCount = 0;
   int fileSize = 0;
   int i;
   RootDirectoryEntry *entry = (RootDirectoryEntry *)
      ROOT_DIRECTORY_BUFFER;
   for (i = 0; i < ROOT_DIRECTORY_ENTRIES; i++)
   {
      if (entry->FileName[0] != 0x00)
      {
         // Print out the file size
         itoa(entry->FileSize, 10, str);
         printf(str);
         printf(" bytes");
         printf("\t");
         // Extract the name and the extension
         char name[9] = "";
         char extension[4] = "";
         substring(entry->FileName, 0, 8, name);
         substring(entry->FileName, 8, 3, 
            extension);
         // Convert everything to lower case
         tolower(name);
         tolower(extension);
         // Print out the file name
         int pos = find(name, ' ');
         char trimmedName[9] = "";
         substring(name, 0, pos, trimmedName);
         printf(trimmedName);
         printf(".");
         printf(extension);
         printf("\n");
         // Calculate the file count and the file size
         fileCount++;
         fileSize += entry->FileSize;
      }
      // Move to the next Root Directory Entry
      entry = entry + 1;
   }
   // Print out the file count and the file size
   printf("\t\t");
   itoa(fileCount, 10, str);
   printf(str);
   printf(" File(s)");
   printf("\t");
   itoa(fileSize, 10, str);
   printf(str);
   printf(" bytes");
   printf("\n");
} 

static void CreateFile(
      unsigned char *FileName,
      unsigned char *Extension)
{
   // Find the next free RootDirectoryEntry
   RootDirectoryEntry *freeEntry = 
      FindNextFreeRootDirectoryEntry();
   if (freeEntry != 0x0)
   {
      // Getting a reference to the
      // BIOS Information Block
      BiosInformationBlock *bib = 
         (BiosInformationBlock *)BIB_OFFSET;
      // Allocate the first cluster for the new file
      unsigned short startCluster = 
         FindNextFreeFATEntry();
      FATWrite(startCluster, 0xFFF);
      strcpy(freeEntry->FileName, FileName);
      strcpy(freeEntry->Extension, Extension);
      freeEntry->FirstCluster = startCluster;
      freeEntry->FileSize = 0;
      // Set the Date/Time information of the
      // new file
      freeEntry->LastWriteYear =
         freeEntry->LastAccessYear =
         freeEntry->CreationYear =
         bib->Year - FAT12_YEAROFFSET;
      freeEntry->LastWriteMonth =
         freeEntry->LastAccessMonth =
         freeEntry->CreationMonth =
         bib->Month;
      freeEntry->LastWriteDay = 
         freeEntry->LastAccessDay =
         freeEntry->CreationDay = bib->Day;
      freeEntry->LastWriteHour =
         freeEntry->CreationHour = bib->Hour;
      freeEntry->LastWriteMinute =
         freeEntry->CreationMinute = bib->Minute;
      freeEntry->LastWriteSecond =
         freeEntry->CreationSecond =
         bib->Second / 2;
      // Write the changed Root Directory and the 
      // FAT tables back to disk
      WriteRootDirectoryAndFAT();
      // Allocate a new cluster of 512 bytes in
      // memory, and copy the initial content
      // into it.
      // Therefore, we can make sure that the 
      // remaining bytes are all zeroed out.
      unsigned char *content = 
         (unsigned char *)
         malloc(BYTES_PER_SECTOR);
      memset(content, 0x00,
         BYTES_PER_SECTOR);
      // Write the intial file content to disk
      WriteSectors((unsigned int *)content, 
         startCluster + DATA_AREA_BEGINNING, 1);
      // Release the block of memory
      free(content);
   }
} 

static RootDirectoryEntry 
      *FindNextFreeRootDirectoryEntry()
{
   RootDirectoryEntry *entry = 
      (RootDirectoryEntry *)
      ROOT_DIRECTORY_BUFFER;
   for (int i = 0; i < ROOT_DIRECTORY_ENTRIES; 
         i++)
   {
      if (entry->FileName[0] == 0x00)
         return entry;
      // Move to the next Root Directory Entry
      entry = entry + 1;
   }
   // A free Root Directory Entry was not found
   return 0x0;
}
static unsigned short FindNextFreeFATEntry()
{
   unsigned short Cluster = 1;
   unsigned short result = 1;
   while (result > 0)
   {
      Cluster++;
      // Calculate the offset into the FAT table
      unsigned int fatOffset =
         (Cluster / 2) + Cluster;
      unsigned long *offset =
         FAT_BUFFER + fatOffset;
      // Read the entry from the FAT
      unsigned short val = *offset;
      if (Cluster & 0x0001)
      {
         // Odd Cluster
         result = val >> 4; // Highest 12 Bits
      }
      else
      {
         // Even Cluster
         result = val & 0x0FFF; // Lowest 12 Bits
      }
   }
   return Cluster;
} 

struct FileDescriptor
{
   unsigned char FileName[11];
   unsigned char Extension[3];
   unsigned long FileSize;
   unsigned long 
     CurrentFileOffset;
   char FileMode[2];
};
typedef struct FileDescriptor 
   FileDescriptor; 

static unsigned long HashFileName(
      unsigned char *FileName)
{
   int hash = 0;
   int length = strlen(FileName);
   // To store 'P'.
   int p = 1;
   // For taking modulo.
   int m = 1000000007;
   for (int i = 0; i < length; i++)
   {
      hash += (FileName[i] - 'a') * p;
      hash = hash % m;
      p *= 41;
   }
   return hash;
} 

unsigned long OpenFile(unsigned char *FileName, 
      unsigned char *Extension, char *FileMode)
{
   char pid[10] = "";
   // Construct the full file name
   char fullFileName[15];
   strcpy(fullFileName, FileName);
   strcat(fullFileName, Extension);
   // Find the Root Directory Entry for the
   // given program name
   RootDirectoryEntry *entry = 
      FindRootDirectoryEntry(fullFileName);
   // Check, if the requested file was found in the 
   // FAT12 file system partition
   if ((entry == 0x0) &&
         (strcmp(FileMode, "w") == 0))
   {
      // If the requested file was not found in the 
      // "write" mode, we just create a new empty 
      // file
      CreateFile(FileName, Extension);
   }
   else if ((entry == 0x0) &&
         (strcmp(FileMode, "r") == 0))
   {
      // If the requested file was not found in the 
      // "write" mode, we return a NULL value for 
      // the file handle
      return 0;
   }
   else if ((entry == 0x0) &&
         (strcmp(FileMode, "a") == 0))
   {
      // If the requested file was not found in the 
      // "append" mode, we just create a new 
      // empty file
      CreateFile(FileName, Extension);
   }
   else if ((entry != 0x0) &&
         (strcmp(FileMode, "w") == 0))
   {
      // If the requested file exists in the "write" 
      // mode, its content must be truncated.
      // Therefore, we delete and recreate the file
      DeleteFile(FileName, Extension);
      CreateFile(FileName, Extension);
   }
   // The PID of the current running task is 
   // concatenated to the file name
   // to make it unique across multiple running 
   // tasks.
   // Otherwise we would have a hash collision if 
   // the same file is opened across
   // multiple running tasks.
   tolower(fullFileName);
   ltoa(GetTaskState()->PID, 10, pid);
   strcat(fullFileName, pid);
   // Calculate a hash value for the given
   // file name
   unsigned long hashValue = 
      HashFileName(fullFileName);
   // Create a new FileDescriptor and store it in 
   // a system-wide Kernel list
   FileDescriptor *descriptor = (FileDescriptor *)
      malloc(sizeof(FileDescriptor));
   strcpy(descriptor->FileName, FileName);
   strcpy(descriptor->Extension, Extension);
   descriptor->FileSize = entry->FileSize;
   descriptor->CurrentFileOffset = 0;
   strcpy((char *)&descriptor->FileMode, 
      FileMode);
   AddEntryToList(FileDescriptorList,
      descriptor, hashValue);
   // If the requested file exists in the "append" 
   // mode, we set the FileOffset to the end of 
   // the file
   if (strcmp(FileMode, "a") == 0)
      descriptor->CurrentFileOffset =
         descriptor->FileSize;
   // Return the key of the newly added 
   // FileDescriptor
   return hashValue;
} 

int CloseFile(unsigned long FileHandle)
{
   // Find the file which needs to be closed
   ListEntry *entry = 
      GetEntryFromList(
         FileDescriptorList, FileHandle);
   if (entry != 0x0)
   {
      // Close the file by removing it from the list
      RemoveEntryFromList(
         FileDescriptorList, entry);
      return 0;
   }
   else
      return -1;
} 

// Allocate a file buffer
unsigned char *file_buffer =
   (unsigned char *)malloc(BYTES_PER_SECTOR);
// Calculate from the current file position the 
// cluster and the offset within that cluster
unsigned long cluster = 
   descriptor->CurrentFileOffset / 
   BYTES_PER_SECTOR;
unsigned long offsetWithinCluster = 
   descriptor->CurrentFileOffset – 
   (cluster * BYTES_PER_SECTOR);
unsigned short currentFatSector = 
   entry->FirstCluster;
// Loop until we reach the cluster that we want 
// to write to. If necessary, new clusters will be 
// created and added for the file.
for (int i = 0; i < cluster; i++)
{
   // Read the next Cluster from the FAT table
   unsigned short nextFatSector = 
      FATRead(currentFatSector);
   // The next cluster is the last one in the chain
   if (nextFatSector >= EOF)
   {
      // Allocate a new cluster for the file
      unsigned short newFatSector = 
         AllocateNewClusterToFile(
         currentFatSector);
      // Set the current sector
      currentFatSector = newFatSector;
   }
   else
   {
      // Set the current sector
      currentFatSector = nextFatSector;
   }
}
// When the data is stored across the last 
// boundary of the current sector, we have 
// allocate an additional cluster to the file
if ((offsetWithinCluster + Length >= 
      BYTES_PER_SECTOR) && (descriptor->FileSize 
      < descriptor->CurrentFileOffset + Length))
{
   // Allocate a new cluster for the file
   AllocateNewClusterToFile(currentFatSector);
}
// Calculate the following disk sector
unsigned short fatSectorFollowing = 
   FATRead(currentFatSector);
// Read the specific sector from disk
ReadSectors((unsigned char *)file_buffer, 
   currentFatSector + DATA_AREA_BEGINNING, 1);
// Read the following logical sector, when the data is stored across 2 disk sectors
if (offsetWithinCluster + Length >= 
      BYTES_PER_SECTOR)
{
   ReadSectors((unsigned char *)(file_buffer + 
      BYTES_PER_SECTOR), 
      fatSectorFollowing + 
      DATA_AREA_BEGINNING, 1);
} 

static unsigned short AllocateNewClusterToFile(
      unsigned short CurrentFATSector)
{
   // Allocate a new cluster for the file
   unsigned short newFatSector = 
      FindNextFreeFATEntry();
   FATWrite(CurrentFATSector, newFatSector);
   FATWrite(newFatSector, 0xFFF);
   // Zero-initialize the new cluster and write it 
   // to disk
   unsigned char *emptyContent = 
      (unsigned char *)
      malloc(BYTES_PER_SECTOR);
   memset(emptyContent, 0x00, 
      BYTES_PER_SECTOR);
   WriteSectors((unsigned int *)emptyContent, 
      newFatSector + DATA_AREA_BEGINNING, 1);
   // Release the block of memory
   free(emptyContent);
   // Return the new allocated FAT sector
   return newFatSector; 

static void FATWrite(
      unsigned short Cluster,
      unsigned short Value)
{
   // Calculate the offset into the FAT table
   unsigned int fatOffset = (Cluster / 2) + Cluster;
   if (Cluster % 2 == 0)
   {
      // Even Cluster
      FAT_BUFFER[fatOffset + 0] = (0xFF & Value);
      FAT_BUFFER[fatOffset + 1] =
         ((0xF0 & (FAT_BUFFER[fatOffset + 1])) | 
         (0x0F & (Value >> 8)));
   }
   else
   {
      // Odd Cluster
      FAT_BUFFER[fatOffset + 0] =
         ((0x0F & (FAT_BUFFER[fatOffset + 0])) | 
         ((0x0F & Value) << 4));
      FAT_BUFFER[fatOffset + 1] =
         ((0xFF) & (Value >> 4));
   }
} 

// Copy the requested data into the destination 
// disk sector
memcpy(file_buffer + offsetWithinCluster, 
   Buffer, Length);
// Write the specific sector to disk
WriteSectors((unsigned int *)file_buffer, 
   currentFatSector + DATA_AREA_BEGINNING, 1);
// Write the following logical sector, when the 
// data is stored across 2 disk sectors
if (offsetWithinCluster + Length >= 
      BYTES_PER_SECTOR)
{
   WriteSectors((unsigned int *)
      (file_buffer + BYTES_PER_SECTOR), 
      fatSectorFollowing + 
      DATA_AREA_BEGINNING, 1);
}
// Release the file buffer
free(file_buffer);
// Set the last Access and Write Date
SetLastAccessDate(entry);
// Set the current file position within
// the FileDescriptor
descriptor->CurrentFileOffset += Length;
// Check if the file size has changed
if (descriptor->CurrentFileOffset > 
      entry->FileSize)
{
   // Change the data in the RootDirectory
   entry->FileSize =
      descriptor->CurrentFileOffset;
   descriptor->FileSize =
      descriptor->CurrentFileOffset;
}
// Write the RootDirectory and the FAT
// tables back to disk
WriteRootDirectoryAndFAT(); 

// Allocate a file buffer
unsigned char *file_buffer = 
   (unsigned char *)malloc(BYTES_PER_SECTOR);
// Calculate from the current file position the 
// cluster and the offset within that cluster
unsigned long cluster =
   descriptor->CurrentFileOffset / BYTES_PER_SECTOR;
unsigned long offsetWithinCluster = 
   descriptor->CurrentFileOffset - 
   (cluster * BYTES_PER_SECTOR);
unsigned short fatSector = entry->FirstCluster;
// Loop until we reach the cluster that
// we want to read
for (int i = 0; i < cluster; i++)
{
   // Read the next Cluster from the FAT table
   fatSector = FATRead(fatSector);
}
// Calculate the following disk sector
unsigned short fatSectorFollowing = 
   FATRead(fatSector);
// Check for the EndOfFile condition
if (descriptor->CurrentFileOffset + Length > 
      descriptor->FileSize)
{
   Length = descriptor->
      FileSize – descriptor->CurrentFileOffset;
}
// Read the specific sector from disk
ReadSectors((unsigned char *)file_buffer, 
   fatSector + DATA_AREA_BEGINNING, 1);
// We also read the following sector, when the 
// requested data is stored across 2 disk sectors
if (offsetWithinCluster + Length > BYTES_PER_SECTOR)
{
   ReadSectors((unsigned char *)file_buffer + 
      BYTES_PER_SECTOR, 
      fatSectorFollowing + 
      DATA_AREA_BEGINNING, 1);
}
// Copy the requested data into the
// destination buffer
memcpy(Buffer, file_buffer + 
   offsetWithinCluster, Length);
// Set the current file position within
// the FileDescriptor
descriptor->CurrentFileOffset += Length;
// Release the file buffer 

int EndOfFile(unsigned long FileHandle)
{
   // Find the file from which we want to check 
   // the EndOfFile condition
   ListEntry *entry = 
      GetEntryFromList(FileDescriptorList, 
      FileHandle);
   FileDescriptor *descriptor = 
      (FileDescriptor *)entry->Payload;
   if (descriptor->CurrentFileOffset == 
      descriptor->FileSize)
      return 1;
   else
      return 0;
} 

unsigned char buffer[512] = "";
// Open both files
unsigned long fileHandleSource = 
   OpenFile("BIGFILE ", "TXT", "r");
unsigned long fileHandleTarget = 
   OpenFile("TARGET  ", "TXT", "w");
// Check if the source file was opened
if (fileHandleSource == 0)
   printf("The source file could not be 
   opened.\n");
// Check if the target file was opened
if (fileHandleSource == 0)
   printf("The target file could not be opened or 
   created.\n");
if ((fileHandleSource != 0) &&
      (fileHandleTarget != 0))
{
   // Copy the source file to the target file
   while (!EndOfFile(fileHandleSource))
   {
      ReadFile(fileHandleSource,
         (unsigned char *)&buffer, 512);
      WriteFile(fileHandleTarget,
         (unsigned char *)&buffer, 512);
   }
   // Close both file handles
   CloseFile(fileHandleSource);
   CloseFile(fileHandleTarget);
   printf("File copied.\n");
} 

int SeekFile(unsigned long FileHandle,
   unsigned long NewFileOffset)
{
   // Find the file from which we want to read
   ListEntry *entry = 
      GetEntryFromList(FileDescriptorList, 
      FileHandle);
   FileDescriptor *descriptor = 
      (FileDescriptor *)entry->Payload;
   if (descriptor != 0x0)
   {
      descriptor->CurrentFileOffset = 
         NewFileOffset;
      return 0;
   }
   else
      return -1;
}