A update

drivers/fs/duckfs.c

@@ -0,0 +1,220 @@
+#include <stdbool.h>
+
+#include <string.h>
+#include <stdlib.h>
+#include <drivers/ide.h>
+
+#include <fs/duckfs.h>
+
+
+static uint16_t duckfs_initialized = 0;
+
+static duckfs_file_header_t duckfs_root;
+
+const char* duckfs_versions[18] = { DFS_VERSION_0, DFS_VERSION_1, DFS_VERSION_2, DFS_VERSION_3, DFS_VERSION_4 };
+
+int32_t duckfs_init(int16_t drive)
+{
+  char duckfs_header_block[512];
+  if (ide_read48(drive, 0xA, 1, duckfs_header_block) != 0)
+  {
+    printf("[ DEBUG ] Disk read error on drive #%i\n", drive);
+    return -1;
+  }
+  
+  duckfs_superblock_t* superblock = (duckfs_superblock_t*)duckfs_header_block;
+  /*
+  if (superblock->duckfs_magic != (int32_t) DFS_MAGIC)
+  {
+    return  -2;
+  }
+  
+  bool compliant = false;
+  for (int16_t i = 0; i < 5; ++i)
+  {
+    if (strcmp(superblock->duckfs_version_string, duckfs_versions[i]) == 0)
+    {
+      compliant = true;
+    }
+  }
+  
+  if (compliant == false)
+  {
+    return -3;
+  }*/
+
+  memset(&duckfs_root, 0, sizeof(duckfs_root));
+  
+  strncpy(duckfs_root.filename, "/", DFS_MAX_FILENAME_LEN);
+  strncpy(duckfs_root.permissions, "RW", sizeof(duckfs_root.permissions));
+  
+  duckfs_root.num_sectors = -1;
+  duckfs_root.type = DFS_FILE_DIRECTORY;
+  duckfs_root.next = NULL;
+  duckfs_root.prev = NULL;
+  duckfs_root.contents = NULL;
+  duckfs_root.lba_start = 0;
+  duckfs_root.lba_end = 0;
+  
+  duckfs_root.contents = malloc(sizeof(duckfs_file_header_t) * DFS_MAX_FILES);
+  if (!duckfs_root.contents) {
+    printf("Memory allocation failed for duckfs_root.contents\n");
+    return -4;
+  }
+
+  for (int32_t i = 0; i < DFS_MAX_FILES; i++) {
+    duckfs_root.contents[i].type = DFS_FILE_UNUSED;
+  }
+
+
+  duckfs_initialized = 1;
+  return 0;
+}
+
+
+void duckfs_format(int16_t drive)
+{
+  /* Nothing to do, DuckFS does not require formatting. */
+}
+
+int32_t duckfs_makedir(const char* filename, const char* perms)
+{
+  duckfs_file_header_t* dir = malloc(sizeof(duckfs_file_header_t));
+  if (!dir)
+  {
+    return -1;
+  }
+
+  if (strlen(perms) < 3)
+  {
+    return -2;
+  }
+
+  char p[3] = { "." };
+  p[0] = perms[0];
+  p[1] = perms[1];
+  p[2] = perms[2];
+  
+  char filen[DFS_MAX_FILENAME_LEN + 1];
+  char perma[3];
+  
+  strcpy(filen, filename);
+  
+  
+  strcpy(perma, perms);
+  
+  strncpy(dir->filename, filen, sizeof(dir->filename) - 1);
+  dir->filename[sizeof(dir->filename) - 1] = '\0';
+
+  strncpy(dir->permissions, p, sizeof(dir->permissions));
+
+  dir->type = DFS_FILE_DIRECTORY;
+  dir->contents = malloc(sizeof(duckfs_file_header_t) * DFS_MAX_FILES);
+  
+  if (!dir->contents) {
+    free(dir);
+    return -1;
+  }
+
+  for (int i = 0; i < DFS_MAX_FILES; i++) {
+    dir->contents[i].type = DFS_FILE_UNUSED;
+  }
+  
+  return 0;
+}
+
+void duckfs_free_directory(duckfs_file_header_t* dir)
+{
+  if (!dir || dir->type != DFS_FILE_DIRECTORY || !dir->contents)
+  {
+    return;
+  }
+
+  for (int i = 0; i < DFS_MAX_FILES; i++) {
+    duckfs_file_header_t* entry = &dir->contents[i];
+
+    if (entry->type == DFS_FILE_UNUSED)
+    {
+      continue;
+    }
+
+    if (entry->type == DFS_FILE_DIRECTORY) {
+      duckfs_free_directory(entry);
+    }
+  }
+
+  free(dir->contents); 
+  dir->contents = NULL;
+}
+
+
+bool duckfs_add_entry(duckfs_file_header_t* dir, duckfs_file_header_t* entry)
+{
+  if (dir->type != DFS_FILE_DIRECTORY || !dir->contents)
+  {
+    return false;
+  }
+
+  for (int i = 0; i < DFS_MAX_FILES; i++) {
+    if (dir->contents[i].type == DFS_FILE_UNUSED) {
+      dir->contents[i] = *entry;
+      return true;
+    }
+  }
+  return false; /* Directory full */
+}
+
+duckfs_file_header_t duckfs_create_entry(const char* name, const char* perms, const char* type)
+{
+  duckfs_file_header_t entry = {0};
+  
+  strncpy(entry.filename, name, DFS_MAX_FILENAME_LEN);
+  strncpy(entry.permissions, perms, sizeof(entry.permissions) - 1);
+  
+  int16_t itype = DFS_FILE_UNUSED;
+  
+  if (strcmp(type, "text") == 0)
+  {
+    itype = DFS_FILE_TEXT;
+  }
+  else if (strcmp(type, "bin") == 0)
+  {
+    itype = DFS_FILE_BINARY;
+  }
+  else if (strcmp(type, "dir") == 0)
+  {
+    itype = DFS_FILE_BINARY;
+  }
+  else
+  {
+    duckfs_file_header_t vvvv = { .type = DFS_FILE_ERROR };
+    return vvvv;
+  }
+  
+  entry.num_sectors = 0;
+  entry.type = itype;
+  entry.next = NULL;
+  entry.prev = NULL;
+  entry.contents = NULL;
+  entry.lba_start = 0;
+  entry.lba_end = 0;
+
+  if (itype == DFS_FILE_DIRECTORY)
+  {
+    entry.contents = malloc(sizeof(duckfs_file_header_t) * DFS_MAX_FILES);
+    if (entry.contents)
+    {
+      for (int i = 0; i < DFS_MAX_FILES; i++)
+      {
+          entry.contents[i].type = DFS_FILE_UNUSED;
+      }
+    }
+  }
+
+  return entry;
+}
+
+duckfs_file_header_t duckfs_makefile(const char* filename, const char* perms, duckfs_file_header_t parent)
+{
+  
+}