Fixx

1 files changed, 597 insertions, 576 deletions

diff --git a/dev/kernel/src/FS/NeFS+FileSystemParser.cc b/dev/kernel/src/FS/NeFS+FileSystemParser.cc
index 152d9fc2..18595e9f 100644
--- a/dev/kernel/src/FS/NeFS+FileSystemParser.cc
+++ b/dev/kernel/src/FS/NeFS+FileSystemParser.cc
@@ -53,25 +53,25 @@ Kernel::SizeT drv_std_get_size();
 ///                                /Path1/readme.rtf
 /***********************************************************************************/
 static inline bool is_valid_size(SizeT size, SizeT max_size) {
-    return size > 0 && size <= max_size;
+  return size > 0 && size <= max_size;
 }
 
 static inline bool is_valid_lba(Lba lba, DriveTrait& drive) {
-    NEFS_ROOT_PARTITION_BLOCK part_block;
-    drive.fPacket.fPacketLba     = kNeFSRootCatalogStartAddress;
-    drive.fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
-    drive.fPacket.fPacketContent = const_cast<VoidPtr>(&part_block);
-    drive.fInput(drive.fPacket);
+  NEFS_ROOT_PARTITION_BLOCK part_block;
+  drive.fPacket.fPacketLba     = kNeFSRootCatalogStartAddress;
+  drive.fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
+  drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(&part_block);
+  drive.fInput(drive.fPacket);
 
-    if (!drive.fPacket.fPacketGood) {
-        return false;
-    }
+  if (!drive.fPacket.fPacketGood) {
+    return false;
+  }
 
-    // Compute the maximum LBA (DiskSize / sector size)
-    SizeT sectorSize = drive.fSectorSz;
-    Lba    maxLba    = part_block.DiskSize / sectorSize;
+  // Compute the maximum LBA (DiskSize / sector size)
+  SizeT sectorSize = drive.fSectorSz;
+  Lba   maxLba     = part_block.DiskSize / sectorSize;
 
-    return (lba >= part_block.StartCatalog) && (lba < maxLba);
+  return (lba >= part_block.StartCatalog) && (lba < maxLba);
 }
 
 STATIC MountpointInterface kMountpoint;
@@ -82,69 +82,69 @@ STATIC MountpointInterface kMountpoint;
 /// @return the fork
 /***********************************************************************************/
 _Output BOOL NeFileSystemParser::CreateFork(_Input NEFS_FORK_STRUCT& the_fork) {
-    if (the_fork.ForkName[0] == 0 || the_fork.CatalogName[0] == 0 || the_fork.DataSize == 0) {
-        return NO;
-    }
+  if (the_fork.ForkName[0] == 0 || the_fork.CatalogName[0] == 0 || the_fork.DataSize == 0) {
+    return NO;
+  }
 
-    auto catalog = this->GetCatalog(the_fork.CatalogName);
-    if (!catalog) return NO;
+  auto catalog = this->GetCatalog(the_fork.CatalogName);
+  if (!catalog) return NO;
 
-    Lba lba = catalog->DataFork;
-    if (lba < kNeFSCatalogStartAddress) {
-        delete catalog;
-        return NO;
-    }
+  Lba lba = catalog->DataFork;
+  if (lba < kNeFSCatalogStartAddress) {
+    delete catalog;
+    return NO;
+  }
 
-    auto& drv = kMountpoint.A();
-    Lba  lba_prev = lba;
-    NEFS_FORK_STRUCT prev_fork{};
-    NEFS_FORK_STRUCT cur_fork{};
+  auto&            drv      = kMountpoint.A();
+  Lba              lba_prev = lba;
+  NEFS_FORK_STRUCT prev_fork{};
+  NEFS_FORK_STRUCT cur_fork{};
 
-    while (true) {
-        drv.fPacket.fPacketLba     = lba;
-        drv.fPacket.fPacketSize    = sizeof(NEFS_FORK_STRUCT);
-        drv.fPacket.fPacketContent = const_cast<VoidPtr>(&cur_fork);
-        drv.fInput(drv.fPacket);
-        if (!drv.fPacket.fPacketGood) {
-            delete catalog;
-            return NO;
-        }
+  while (true) {
+    drv.fPacket.fPacketLba     = lba;
+    drv.fPacket.fPacketSize    = sizeof(NEFS_FORK_STRUCT);
+    drv.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(&cur_fork);
+    drv.fInput(drv.fPacket);
+    if (!drv.fPacket.fPacketGood) {
+      delete catalog;
+      return NO;
+    }
 
-        if (cur_fork.Flags & kNeFSFlagCreated) {
-            if (KStringBuilder::Equals(cur_fork.ForkName, the_fork.ForkName) &&
-                KStringBuilder::Equals(cur_fork.CatalogName, the_fork.CatalogName)) {
-                break;
-            }
-            lba_prev   = lba;
-            lba        = cur_fork.NextSibling;
-            prev_fork  = cur_fork;
-        } else {
-            if (lba >= kNeFSCatalogStartAddress) {
-                prev_fork.NextSibling     = lba;
-                drv.fPacket.fPacketLba     = lba_prev;
-                drv.fPacket.fPacketSize    = sizeof(NEFS_FORK_STRUCT);
-                drv.fPacket.fPacketContent = const_cast<VoidPtr>(&prev_fork);
-                drv.fOutput(drv.fPacket);
-            }
-            break;
-        }
+    if (cur_fork.Flags & kNeFSFlagCreated) {
+      if (KStringBuilder::Equals(cur_fork.ForkName, the_fork.ForkName) &&
+          KStringBuilder::Equals(cur_fork.CatalogName, the_fork.CatalogName)) {
+        break;
+      }
+      lba_prev  = lba;
+      lba       = cur_fork.NextSibling;
+      prev_fork = cur_fork;
+    } else {
+      if (lba >= kNeFSCatalogStartAddress) {
+        prev_fork.NextSibling      = lba;
+        drv.fPacket.fPacketLba     = lba_prev;
+        drv.fPacket.fPacketSize    = sizeof(NEFS_FORK_STRUCT);
+        drv.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(&prev_fork);
+        drv.fOutput(drv.fPacket);
+      }
+      break;
     }
+  }
 
-    SizeT sectorCount           = (the_fork.DataSize + kNeFSSectorSz - 1) / kNeFSSectorSz;
-    the_fork.DataOffset         = lba + 1;
-    the_fork.PreviousSibling    = lba_prev;
-    the_fork.NextSibling        = lba + 1 + sectorCount;
-    the_fork.Flags |= kNeFSFlagCreated;
+  SizeT sectorCount        = (the_fork.DataSize + kNeFSSectorSz - 1) / kNeFSSectorSz;
+  the_fork.DataOffset      = lba + 1;
+  the_fork.PreviousSibling = lba_prev;
+  the_fork.NextSibling     = lba + 1 + sectorCount;
+  the_fork.Flags |= kNeFSFlagCreated;
 
-    drv.fPacket.fPacketLba     = lba;
-    drv.fPacket.fPacketSize    = sizeof(NEFS_FORK_STRUCT);
-    drv.fPacket.fPacketContent = const_cast<VoidPtr>(&the_fork);
-    drv.fOutput(drv.fPacket);
+  drv.fPacket.fPacketLba     = lba;
+  drv.fPacket.fPacketSize    = sizeof(NEFS_FORK_STRUCT);
+  drv.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(&the_fork);
+  drv.fOutput(drv.fPacket);
 
-    fs_ifs_write(&kMountpoint, drv, MountpointInterface::kDriveIndexA);
+  fs_ifs_write(&kMountpoint, drv, MountpointInterface::kDriveIndexA);
 
-    delete catalog;
-    return YES;
+  delete catalog;
+  return YES;
 }
 
 /***********************************************************************************/
@@ -156,39 +156,48 @@ _Output BOOL NeFileSystemParser::CreateFork(_Input NEFS_FORK_STRUCT& the_fork) {
 _Output NEFS_FORK_STRUCT* NeFileSystemParser::FindFork(_Input NEFS_CATALOG_STRUCT* catalog,
                                                        _Input const Char* name,
                                                        _Input Boolean     is_data) {
-    if (!catalog || !name) return nullptr;
-
-    auto& drive = kMountpoint.A();
-    Lba lba     = is_data ? catalog->DataFork : catalog->ResourceFork;
-    NEFS_FORK_STRUCT local_buf{};
-
-    while (lba >= kNeFSCatalogStartAddress) {
-        drive.fPacket.fPacketLba     = lba;
-        drive.fPacket.fPacketSize    = sizeof(NEFS_FORK_STRUCT);
-        drive.fPacket.fPacketContent = const_cast<VoidPtr>(&local_buf);
-        rt_copy_memory((VoidPtr)"fs/nefs-packet", drive.fPacket.fPacketMime, 16);
-
-        if (auto res = fs_ifs_read(&kMountpoint, drive, this->mDriveIndex); res) {
-            switch (res) {
-              case 1: err_global_get() = kErrorDiskReadOnly;  break;
-              case 2: err_global_get() = kErrorDiskIsFull;    break;
-              case 3: err_global_get() = kErrorNoSuchDisk;    break;
-              default: break;
-            }
-            return nullptr;
-        }
-
-        if (KStringBuilder::Equals(local_buf.ForkName, name) &&
-            KStringBuilder::Equals(local_buf.CatalogName, catalog->Name)) {
-            auto result = new NEFS_FORK_STRUCT();
-            rt_copy_memory(&local_buf, result, sizeof(NEFS_FORK_STRUCT));
-            return result;
-        }
+  if (!catalog || !name) return nullptr;
+
+  auto&            drive = kMountpoint.A();
+  Lba              lba   = is_data ? catalog->DataFork : catalog->ResourceFork;
+  NEFS_FORK_STRUCT local_buf{};
+
+  while (lba >= kNeFSCatalogStartAddress) {
+    drive.fPacket.fPacketLba     = lba;
+    drive.fPacket.fPacketSize    = sizeof(NEFS_FORK_STRUCT);
+    drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(&local_buf);
+
+    rt_copy_memory((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
+                   rt_string_len("fs/nefs-packet"));
+
+    if (auto res = fs_ifs_read(&kMountpoint, drive, this->mDriveIndex); res) {
+      switch (res) {
+        case 1:
+          err_global_get() = kErrorDiskReadOnly;
+          break;
+        case 2:
+          err_global_get() = kErrorDiskIsFull;
+          break;
+        case 3:
+          err_global_get() = kErrorNoSuchDisk;
+          break;
+        default:
+          break;
+      }
+      return nullptr;
+    }
 
-        lba = local_buf.NextSibling;
+    if (KStringBuilder::Equals(local_buf.ForkName, name) &&
+        KStringBuilder::Equals(local_buf.CatalogName, catalog->Name)) {
+      auto result = new NEFS_FORK_STRUCT();
+      rt_copy_memory(&local_buf, result, sizeof(NEFS_FORK_STRUCT));
+      return result;
     }
 
-    return nullptr;
+    lba = local_buf.NextSibling;
+  }
+
+  return nullptr;
 }
 
 /***********************************************************************************/
@@ -198,7 +207,7 @@ _Output NEFS_FORK_STRUCT* NeFileSystemParser::FindFork(_Input NEFS_CATALOG_STRUC
 /// @return catalog pointer.
 /***********************************************************************************/
 _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char* name) {
-    return this->CreateCatalog(name, 0, kNeFSCatalogKindFile);
+  return this->CreateCatalog(name, 0, kNeFSCatalogKindFile);
 }
 
 /***********************************************************************************/
@@ -211,183 +220,183 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char
 _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char* name,
                                                                _Input const Int32& flags,
                                                                _Input const Int32& kind) {
-    kout << "CreateCatalog(*...*)\r";
+  kout << "CreateCatalog(*...*)\r";
 
-    if (!name) return nullptr;
-    SizeT nameLen = rt_string_len(name);
-    if (nameLen == 0) return nullptr;
+  if (!name) return nullptr;
+  SizeT nameLen = rt_string_len(name);
+  if (nameLen == 0) return nullptr;
 
-    Lba out_lba = 0UL;
+  Lba out_lba = 0UL;
 
-    kout << "Checking for path separator...\r";
+  kout << "Checking for path separator...\r";
 
-    /// a directory should have a slash in the end.
-    if (kind == kNeFSCatalogKindDir &&
-        name[nameLen - 1] != NeFileSystemHelper::Separator())
-        return nullptr;
+  /// a directory should have a slash in the end.
+  if (kind == kNeFSCatalogKindDir && name[nameLen - 1] != NeFileSystemHelper::Separator())
+    return nullptr;
 
-    /// a file shouldn't have a slash in the end.
-    if (kind != kNeFSCatalogKindDir &&
-        name[nameLen - 1] == NeFileSystemHelper::Separator())
-        return nullptr;
+  /// a file shouldn't have a slash in the end.
+  if (kind != kNeFSCatalogKindDir && name[nameLen - 1] == NeFileSystemHelper::Separator())
+    return nullptr;
 
-    NEFS_CATALOG_STRUCT* catalog_copy = this->FindCatalog(name, out_lba);
+  NEFS_CATALOG_STRUCT* catalog_copy = this->FindCatalog(name, out_lba);
 
-    if (catalog_copy) {
-        kout << "Catalog already exists: " << name << ".\r";
-        err_global_get() = kErrorFileExists;
-        delete catalog_copy;
-        catalog_copy = nullptr;
-        return nullptr;
-    }
+  if (catalog_copy) {
+    kout << "Catalog already exists: " << name << ".\r";
+    err_global_get() = kErrorFileExists;
+    delete catalog_copy;
+    catalog_copy = nullptr;
+    return nullptr;
+  }
 
-    Char* parent_name = (Char*) mm_alloc_ptr(nameLen + 1, Yes, No);
-    rt_copy_memory(name, parent_name, nameLen + 1);
+  Char* parent_name = (Char*) mm_alloc_ptr(nameLen + 1, Yes, No);
+  rt_copy_memory(const_cast<Char*>(name), parent_name, nameLen + 1);
 
-    if (nameLen < 2) {
-        mm_free_ptr(parent_name);
-        err_global_get() = kErrorFileNotFound;
-        return nullptr;
-    }
+  if (nameLen < 2) {
+    mm_free_ptr(parent_name);
+    err_global_get() = kErrorFileNotFound;
+    return nullptr;
+  }
+
+  SizeT index_reverse_copy = nameLen - 1;
+  if (parent_name[index_reverse_copy] == NeFileSystemHelper::Separator()) {
+    parent_name[index_reverse_copy] = 0;
+    --index_reverse_copy;
+  }
+  while (index_reverse_copy > 0 &&
+         parent_name[index_reverse_copy] != NeFileSystemHelper::Separator()) {
+    parent_name[index_reverse_copy] = 0;
+    --index_reverse_copy;
+  }
+  if (index_reverse_copy == 0 && parent_name[0] != NeFileSystemHelper::Separator()) {
+    mm_free_ptr(parent_name);
+    err_global_get() = kErrorFileNotFound;
+    return nullptr;
+  }
 
-    SizeT index_reverse_copy = nameLen - 1;
-    if (parent_name[index_reverse_copy] == NeFileSystemHelper::Separator()) {
-        parent_name[index_reverse_copy] = 0;
-        --index_reverse_copy;
-    }
-    while (index_reverse_copy > 0 && parent_name[index_reverse_copy] != NeFileSystemHelper::Separator()) {
-        parent_name[index_reverse_copy] = 0;
-        --index_reverse_copy;
-    }
-    if (index_reverse_copy == 0 && parent_name[0] != NeFileSystemHelper::Separator()) {
-        mm_free_ptr(parent_name);
-        err_global_get() = kErrorFileNotFound;
-        return nullptr;
-    }
+  NEFS_CATALOG_STRUCT* catalog = this->FindCatalog(parent_name, out_lba);
+  mm_free_ptr(parent_name);
 
-    NEFS_CATALOG_STRUCT* catalog = this->FindCatalog(parent_name, out_lba);
-    mm_free_ptr(parent_name);
+  auto& drive = kMountpoint.A();
+  if (catalog && catalog->Kind == kNeFSCatalogKindFile) {
+    kout << "Parent is a file.\r";
+    delete catalog;
+    return nullptr;
+  } else if (!catalog) {
+    Char part_block[sizeof(NEFS_ROOT_PARTITION_BLOCK)] = {0};
+    drive.fPacket.fPacketContent                       = reinterpret_cast<VoidPtr>(part_block);
+    drive.fPacket.fPacketSize                          = sizeof(NEFS_ROOT_PARTITION_BLOCK);
+    drive.fPacket.fPacketLba                           = kNeFSRootCatalogStartAddress;
+    drive.fInput(drive.fPacket);
 
-    auto& drive = kMountpoint.A();
-    if (catalog && catalog->Kind == kNeFSCatalogKindFile) {
-        kout << "Parent is a file.\r";
-        delete catalog;
-        return nullptr;
-    } else if (!catalog) {
-        Char part_block[sizeof(NEFS_ROOT_PARTITION_BLOCK)] = {0};
-        drive.fPacket.fPacketContent = const_cast<VoidPtr>(part_block);
-        drive.fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
-        drive.fPacket.fPacketLba     = kNeFSRootCatalogStartAddress;
-        drive.fInput(drive.fPacket);
-
-        NEFS_ROOT_PARTITION_BLOCK* blk_nefs = (NEFS_ROOT_PARTITION_BLOCK*) part_block;
-        out_lba = blk_nefs->StartCatalog;
-    }
+    NEFS_ROOT_PARTITION_BLOCK* blk_nefs = (NEFS_ROOT_PARTITION_BLOCK*) part_block;
+    out_lba                             = blk_nefs->StartCatalog;
+  }
 
-    if (drive.fPacket.fPacketReadOnly) {
-        delete catalog;
-        return nullptr;
-    }
+  if (drive.fPacket.fPacketReadOnly) {
+    delete catalog;
+    return nullptr;
+  }
+
+  NEFS_CATALOG_STRUCT* child_catalog = new NEFS_CATALOG_STRUCT();
+  child_catalog->Checksum            = 0;
+  child_catalog->ResourceForkSize    = 0UL;
+  child_catalog->DataForkSize        = 0UL;
+  child_catalog->CatalogFlags        = kNeFSStatusUnlocked;
+  child_catalog->NextSibling         = out_lba;
+  child_catalog->PrevSibling         = out_lba;
+  child_catalog->Kind                = kind;
+  child_catalog->Flags |= kNeFSFlagCreated;
+  child_catalog->CatalogFlags = flags;
+
+  SizeT i = nameLen;
+  --i;
+  if (kind == kNeFSCatalogKindDir) --i;
+  while (name[i] != '/') --i;
+  rt_copy_memory((VoidPtr) (name + i), (VoidPtr) child_catalog->Name, rt_string_len(name) - i);
+
+  NEFS_CATALOG_STRUCT temporary_catalog{};
+  Lba                 start_free = out_lba;
+
+  rt_copy_memory((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
+                 rt_string_len("fs/nefs-packet"));
+
+  Char buf_part_block[sizeof(NEFS_ROOT_PARTITION_BLOCK)] = {0};
+  drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(buf_part_block);
+  drive.fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
+  drive.fPacket.fPacketLba     = kNeFSRootCatalogStartAddress;
+  drive.fInput(drive.fPacket);
+
+  NEFS_ROOT_PARTITION_BLOCK* part_block = (NEFS_ROOT_PARTITION_BLOCK*) buf_part_block;
+  drive.fPacket.fPacketContent          = reinterpret_cast<VoidPtr>(&temporary_catalog);
+  drive.fPacket.fPacketSize             = sizeof(NEFS_CATALOG_STRUCT);
+  drive.fPacket.fPacketLba              = start_free;
+  drive.fInput(drive.fPacket);
+
+  if (part_block->FreeCatalog < 1) {
+    delete child_catalog;
+    delete catalog;
+    return nullptr;
+  }
 
-    NEFS_CATALOG_STRUCT* child_catalog = new NEFS_CATALOG_STRUCT();
-    child_catalog->Checksum         = 0;
-    child_catalog->ResourceForkSize = 0UL;
-    child_catalog->DataForkSize     = 0UL;
-    child_catalog->CatalogFlags     = kNeFSStatusUnlocked;
-    child_catalog->NextSibling      = out_lba;
-    child_catalog->PrevSibling      = out_lba;
-    child_catalog->Kind             = kind;
-    child_catalog->Flags |= kNeFSFlagCreated;
-    child_catalog->CatalogFlags = flags;
-
-    SizeT i = nameLen;
-    --i;
-    if (kind == kNeFSCatalogKindDir) --i;
-    while (name[i] != '/') --i;
-    rt_copy_memory((VoidPtr)(name + i), (VoidPtr)child_catalog->Name, rt_string_len(name) - i);
-
-    NEFS_CATALOG_STRUCT temporary_catalog{};
-    Lba start_free = out_lba;
-
-    rt_copy_memory((VoidPtr)"fs/nefs-packet", drive.fPacket.fPacketMime, rt_string_len("fs/nefs-packet"));
-
-    Char buf_part_block[sizeof(NEFS_ROOT_PARTITION_BLOCK)] = {0};
-    drive.fPacket.fPacketContent = const_cast<VoidPtr>(buf_part_block);
-    drive.fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
-    drive.fPacket.fPacketLba     = kNeFSRootCatalogStartAddress;
-    drive.fInput(drive.fPacket);
+  kout << "Start finding catalog to allocate or empty space...\r";
 
-    NEFS_ROOT_PARTITION_BLOCK* part_block = (NEFS_ROOT_PARTITION_BLOCK*) buf_part_block;
-    drive.fPacket.fPacketContent = const_cast<VoidPtr>(&temporary_catalog);
+  SizeT catalogSectors = (sizeof(NEFS_CATALOG_STRUCT) + drive.fSectorSz - 1) / drive.fSectorSz;
+  while (start_free < part_block->StartCatalog + (part_block->CatalogCount * catalogSectors)) {
+    drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(&temporary_catalog);
     drive.fPacket.fPacketSize    = sizeof(NEFS_CATALOG_STRUCT);
     drive.fPacket.fPacketLba     = start_free;
     drive.fInput(drive.fPacket);
 
-    if (part_block->FreeCatalog < 1) {
-        delete child_catalog;
-        delete catalog;
-        return nullptr;
+    if ((temporary_catalog.Flags & kNeFSFlagCreated) == 0) {
+      child_catalog->NextSibling = start_free + catalogSectors;
+
+      NEFS_CATALOG_STRUCT placeholder{};
+      drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(&placeholder);
+      drive.fPacket.fPacketSize    = sizeof(NEFS_CATALOG_STRUCT);
+      drive.fPacket.fPacketLba     = start_free;
+      drive.fOutput(drive.fPacket);
+
+      child_catalog->DataFork     = part_block->DiskSize - start_free;
+      child_catalog->ResourceFork = child_catalog->DataFork;
+
+      drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(child_catalog);
+      drive.fPacket.fPacketSize    = sizeof(NEFS_CATALOG_STRUCT);
+      drive.fPacket.fPacketLba     = start_free;
+      drive.fOutput(drive.fPacket);
+
+      drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(buf_part_block);
+      drive.fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
+      drive.fPacket.fPacketLba     = kNeFSRootCatalogStartAddress;
+      drive.fInput(drive.fPacket);
+
+      part_block->FreeSectors -= catalogSectors;
+      part_block->CatalogCount += 1;
+      part_block->FreeCatalog -= 1;
+
+      drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(part_block);
+      drive.fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
+      drive.fPacket.fPacketLba     = kNeFSRootCatalogStartAddress;
+      drive.fOutput(drive.fPacket);
+
+      delete catalog;
+      NEFS_CATALOG_STRUCT* found_catalog = new NEFS_CATALOG_STRUCT();
+      rt_copy_memory(&temporary_catalog, found_catalog, sizeof(NEFS_CATALOG_STRUCT));
+
+      delete child_catalog;
+      return found_catalog;
+    } else if ((temporary_catalog.Flags & kNeFSFlagCreated) &&
+               KStringBuilder::Equals(temporary_catalog.Name, name)) {
+      rt_copy_memory(&temporary_catalog, child_catalog, sizeof(NEFS_CATALOG_STRUCT));
+      delete catalog;
+      return child_catalog;
     }
 
-    kout << "Start finding catalog to allocate or empty space...\r";
-
-    SizeT catalogSectors = (sizeof(NEFS_CATALOG_STRUCT) + drive.fSectorSz - 1) / drive.fSectorSz;
-    while (start_free < part_block->StartCatalog + (part_block->CatalogCount * catalogSectors)) {
-        drive.fPacket.fPacketContent = const_cast<VoidPtr>(&temporary_catalog);
-        drive.fPacket.fPacketSize    = sizeof(NEFS_CATALOG_STRUCT);
-        drive.fPacket.fPacketLba     = start_free;
-        drive.fInput(drive.fPacket);
-
-        if ((temporary_catalog.Flags & kNeFSFlagCreated) == 0) {
-            child_catalog->NextSibling = start_free + catalogSectors;
-
-            NEFS_CATALOG_STRUCT placeholder{};
-            drive.fPacket.fPacketContent = const_cast<VoidPtr>(&placeholder);
-            drive.fPacket.fPacketSize    = sizeof(NEFS_CATALOG_STRUCT);
-            drive.fPacket.fPacketLba     = start_free;
-            drive.fOutput(drive.fPacket);
-
-            child_catalog->DataFork     = part_block->DiskSize - start_free;
-            child_catalog->ResourceFork = child_catalog->DataFork;
-
-            drive.fPacket.fPacketContent = const_cast<VoidPtr>(child_catalog);
-            drive.fPacket.fPacketSize    = sizeof(NEFS_CATALOG_STRUCT);
-            drive.fPacket.fPacketLba     = start_free;
-            drive.fOutput(drive.fPacket);
-
-            drive.fPacket.fPacketContent = const_cast<VoidPtr>(buf_part_block);
-            drive.fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
-            drive.fPacket.fPacketLba     = kNeFSRootCatalogStartAddress;
-            drive.fInput(drive.fPacket);
-
-            part_block->FreeSectors -= catalogSectors;
-            part_block->CatalogCount += 1;
-            part_block->FreeCatalog -= 1;
-
-            drive.fPacket.fPacketContent = const_cast<VoidPtr>(part_block);
-            drive.fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
-            drive.fPacket.fPacketLba     = kNeFSRootCatalogStartAddress;
-            drive.fOutput(drive.fPacket);
-
-            delete catalog;
-            NEFS_CATALOG_STRUCT* found_catalog = new NEFS_CATALOG_STRUCT();
-            rt_copy_memory(&temporary_catalog, found_catalog, sizeof(NEFS_CATALOG_STRUCT));
-
-            delete child_catalog;
-            return found_catalog;
-        } else if ((temporary_catalog.Flags & kNeFSFlagCreated) &&
-                   KStringBuilder::Equals(temporary_catalog.Name, name)) {
-            rt_copy_memory(&temporary_catalog, child_catalog, sizeof(NEFS_CATALOG_STRUCT));
-            delete catalog;
-            return child_catalog;
-        }
-
-        start_free += catalogSectors;
-    }
+    start_free += catalogSectors;
+  }
 
-    delete child_catalog;
-    delete catalog;
-    return nullptr;
+  delete child_catalog;
+  delete catalog;
+  return nullptr;
 }
 
 /***********************************************************************************/
@@ -397,63 +406,65 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char
 /***********************************************************************************/
 bool NeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input const Int32 flags,
                                 const Char* part_name) {
-    if (!part_name || *part_name == 0) return false;
-    NE_UNUSED(flags);
-
-    // verify disk.
-    drive->fVerify(drive->fPacket);
-    rt_copy_memory((VoidPtr)"fs/nefs-packet", drive->fPacket.fPacketMime, rt_string_len("fs/nefs-packet"));
-    if (!drive->fPacket.fPacketGood) {
-        err_global_get() = kErrorDiskIsCorrupted;
-        return false;
-    }
-
-    Char fs_buf[sizeof(NEFS_ROOT_PARTITION_BLOCK)] = {0};
-    Lba start = drive->fLbaStart;
-
-    drive->fPacket.fPacketContent = const_cast<VoidPtr>(fs_buf);
-    drive->fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
-    drive->fPacket.fPacketLba     = start;
-    drive->fInput(drive->fPacket);
-
-    NEFS_ROOT_PARTITION_BLOCK* part_block = (NEFS_ROOT_PARTITION_BLOCK*) fs_buf;
-    if (rt_string_cmp(kNeFSIdent, part_block->Ident, kNeFSIdentLen) == 0) return true;
-
-    const auto kNeFSUntitledHD = part_name;
-    rt_copy_memory((VoidPtr)kNeFSIdent, (VoidPtr)part_block->Ident, kNeFSIdentLen);
-    rt_copy_memory((VoidPtr)kNeFSUntitledHD, (VoidPtr)part_block->PartitionName, rt_string_len(kNeFSUntitledHD));
-
-    SizeT sectorCount    = drv_std_get_sector_count();
-    SizeT sectorSize     = drive->fSectorSz;
-    SizeT totalBytes     = sectorCount * sectorSize;
-    SizeT catalogEntries = totalBytes / sizeof(NEFS_CATALOG_STRUCT);
-    SizeT catalogSectors = (sizeof(NEFS_CATALOG_STRUCT) + sectorSize - 1) / sectorSize;
-
-    part_block->Version      = kNeFSVersionInteger;
-    part_block->Kind         = kNeFSPartitionTypeStandard;
-    part_block->StartCatalog = start + catalogSectors;
-    part_block->Flags        = 0UL;
-    part_block->CatalogCount = catalogEntries;
-    part_block->FreeCatalog  = catalogEntries - 1;
-    part_block->SectorCount  = sectorCount;
-    part_block->DiskSize     = totalBytes;
-    part_block->SectorSize   = sectorSize;
-    part_block->FreeSectors  = sectorCount - catalogSectors;
-
-    drive->fPacket.fPacketContent = const_cast<VoidPtr>(fs_buf);
-    drive->fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
-    drive->fPacket.fPacketLba     = start;
-    drive->fOutput(drive->fPacket);
-
-    (Void)(kout << "Drive kind: " << drive->fProtocol() << kendl);
-    (Void)(kout << "Partition name: " << part_block->PartitionName << kendl);
-    (Void)(kout << "Start catalog: " << hex_number(part_block->StartCatalog) << kendl);
-    (Void)(kout << "Number of catalogs: " << hex_number(part_block->CatalogCount) << kendl);
-    (Void)(kout << "Free catalog: " << hex_number(part_block->FreeCatalog) << kendl);
-    (Void)(kout << "Free sectors: " << hex_number(part_block->FreeSectors) << kendl);
-    (Void)(kout << "Sector size: " << hex_number(part_block->SectorSize) << kendl);
-
-    return true;
+  if (!part_name || *part_name == 0) return false;
+  NE_UNUSED(flags);
+
+  // verify disk.
+  drive->fVerify(drive->fPacket);
+  rt_copy_memory((VoidPtr) "fs/nefs-packet", drive->fPacket.fPacketMime,
+                 rt_string_len("fs/nefs-packet"));
+  if (!drive->fPacket.fPacketGood) {
+    err_global_get() = kErrorDiskIsCorrupted;
+    return false;
+  }
+
+  Char fs_buf[sizeof(NEFS_ROOT_PARTITION_BLOCK)] = {0};
+  Lba  start                                     = drive->fLbaStart;
+
+  drive->fPacket.fPacketContent = reinterpret_cast<VoidPtr>(fs_buf);
+  drive->fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
+  drive->fPacket.fPacketLba     = start;
+  drive->fInput(drive->fPacket);
+
+  NEFS_ROOT_PARTITION_BLOCK* part_block = (NEFS_ROOT_PARTITION_BLOCK*) fs_buf;
+  if (rt_string_cmp(kNeFSIdent, part_block->Ident, kNeFSIdentLen) == 0) return true;
+
+  const auto kNeFSUntitledHD = part_name;
+  rt_copy_memory((VoidPtr) kNeFSIdent, (VoidPtr) part_block->Ident, kNeFSIdentLen);
+  rt_copy_memory((VoidPtr) kNeFSUntitledHD, (VoidPtr) part_block->PartitionName,
+                 rt_string_len(kNeFSUntitledHD));
+
+  SizeT sectorCount    = drv_std_get_sector_count();
+  SizeT sectorSize     = drive->fSectorSz;
+  SizeT totalBytes     = sectorCount * sectorSize;
+  SizeT catalogEntries = totalBytes / sizeof(NEFS_CATALOG_STRUCT);
+  SizeT catalogSectors = (sizeof(NEFS_CATALOG_STRUCT) + sectorSize - 1) / sectorSize;
+
+  part_block->Version      = kNeFSVersionInteger;
+  part_block->Kind         = kNeFSPartitionTypeStandard;
+  part_block->StartCatalog = start + catalogSectors;
+  part_block->Flags        = 0UL;
+  part_block->CatalogCount = catalogEntries;
+  part_block->FreeCatalog  = catalogEntries - 1;
+  part_block->SectorCount  = sectorCount;
+  part_block->DiskSize     = totalBytes;
+  part_block->SectorSize   = sectorSize;
+  part_block->FreeSectors  = sectorCount - catalogSectors;
+
+  drive->fPacket.fPacketContent = reinterpret_cast<VoidPtr>(fs_buf);
+  drive->fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
+  drive->fPacket.fPacketLba     = start;
+  drive->fOutput(drive->fPacket);
+
+  (Void)(kout << "Drive kind: " << drive->fProtocol() << kendl);
+  (Void)(kout << "Partition name: " << part_block->PartitionName << kendl);
+  (Void)(kout << "Start catalog: " << hex_number(part_block->StartCatalog) << kendl);
+  (Void)(kout << "Number of catalogs: " << hex_number(part_block->CatalogCount) << kendl);
+  (Void)(kout << "Free catalog: " << hex_number(part_block->FreeCatalog) << kendl);
+  (Void)(kout << "Free sectors: " << hex_number(part_block->FreeSectors) << kendl);
+  (Void)(kout << "Sector size: " << hex_number(part_block->SectorSize) << kendl);
+
+  return true;
 }
 
 /***********************************************************************************/
@@ -462,91 +473,95 @@ bool NeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input const I
 /// @param data the data.
 /// @return if the catalog wrote the contents successfully.
 /***********************************************************************************/
-bool NeFileSystemParser::WriteCatalog(_Input const Char* catalog_name,
-                                      Bool is_rsrc_fork,
-                                      _Input VoidPtr data,
-                                      _Input SizeT size_of_data,
+bool NeFileSystemParser::WriteCatalog(_Input const Char* catalog_name, Bool is_rsrc_fork,
+                                      _Input VoidPtr data, _Input SizeT size_of_data,
                                       _Input const Char* fork_name) {
-    if (size_of_data < 1) return NO;
-
-    auto catalog = this->GetCatalog(catalog_name);
-    if (!catalog) {
-        kout << "NeFS: WriteCatalog failed to find catalog: " << catalog_name << "\n";
-        return false;
-    }
+  if (size_of_data < 1) return NO;
 
-    SizeT maxSize = is_rsrc_fork ? catalog->ResourceForkSize : catalog->DataForkSize;
-    if (!is_valid_size(size_of_data, maxSize)) {
-        kout << "NeFS: WriteCatalog called with invalid size: " << size_of_data << "\n";
-        delete catalog;
-        return false;
-    }
+  auto catalog = this->GetCatalog(catalog_name);
+  if (!catalog) {
+    kout << "NeFS: WriteCatalog failed to find catalog: " << catalog_name << "\n";
+    return false;
+  }
 
-    Lba startFork = is_rsrc_fork ? catalog->ResourceFork : catalog->DataFork;
-    auto& drive = kMountpoint.A();
+  SizeT maxSize = is_rsrc_fork ? catalog->ResourceForkSize : catalog->DataForkSize;
 
-    if (!is_valid_lba(startFork, drive)) {
-        kout << "NeFS: WriteCatalog called with invalid LBA: " << startFork << "\n";
-        delete catalog;
-        return false;
-    }
+  if (!is_valid_size(size_of_data, maxSize)) {
+    (Void)(kout << "NeFS: WriteCatalog called with invalid size: " << hex_number(size_of_data));
+    kout << "\n";
 
-    NEFS_ROOT_PARTITION_BLOCK part_block;
-    drive.fPacket.fPacketLba     = kNeFSRootCatalogStartAddress;
-    drive.fPacket.fPacketSize    = sizeof(part_block);
-    drive.fPacket.fPacketContent = const_cast<VoidPtr>(&part_block);
-    drive.fInput(drive.fPacket);
-
-    auto buf = new UInt8[size_of_data];
-    rt_set_memory(buf, 0, size_of_data);
-    rt_copy_memory(data, buf, size_of_data);
-    rt_copy_memory((VoidPtr)"fs/nefs-packet", drive.fPacket.fPacketMime, rt_string_len("fs/nefs-packet"));
+    delete catalog;
+    return false;
+  }
 
-    NEFS_FORK_STRUCT* fork_data_input = new NEFS_FORK_STRUCT();
-    NEFS_FORK_STRUCT  prev_fork{};
+  Lba   startFork = is_rsrc_fork ? catalog->ResourceFork : catalog->DataFork;
+  auto& drive     = kMountpoint.A();
 
-    while (startFork >= part_block.StartCatalog && drive.fPacket.fPacketGood) {
-        drive.fPacket.fPacketContent = const_cast<VoidPtr>(fork_data_input);
-        drive.fPacket.fPacketSize    = sizeof(NEFS_FORK_STRUCT);
-        drive.fPacket.fPacketLba     = startFork;
-        drive.fInput(drive.fPacket);
+  if (!is_valid_lba(startFork, drive)) {
+    (Void)(kout << "NeFS: WriteCatalog called with invalid LBA: " << hex_number(startFork));
+    kout << "\n";
 
-        if (!drive.fPacket.fPacketGood) {
-            break;
-        }
+    delete catalog;
+    return false;
+  }
+
+  NEFS_ROOT_PARTITION_BLOCK part_block;
+  drive.fPacket.fPacketLba     = kNeFSRootCatalogStartAddress;
+  drive.fPacket.fPacketSize    = sizeof(part_block);
+  drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(&part_block);
+  drive.fInput(drive.fPacket);
+
+  auto buf = new UInt8[size_of_data];
+  rt_set_memory(buf, 0, size_of_data);
+  rt_copy_memory(data, buf, size_of_data);
+  rt_copy_memory((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
+                 rt_string_len("fs/nefs-packet"));
+
+  NEFS_FORK_STRUCT* fork_data_input = new NEFS_FORK_STRUCT();
+  NEFS_FORK_STRUCT  prev_fork{};
+
+  while (startFork >= part_block.StartCatalog && drive.fPacket.fPacketGood) {
+    drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(fork_data_input);
+    drive.fPacket.fPacketSize    = sizeof(NEFS_FORK_STRUCT);
+    drive.fPacket.fPacketLba     = startFork;
+    drive.fInput(drive.fPacket);
 
-        if ((fork_data_input->Flags & kNeFSFlagCreated) &&
-            KStringBuilder::Equals(fork_data_input->ForkName, fork_name) &&
-            KStringBuilder::Equals(fork_data_input->CatalogName, catalog_name) &&
-            fork_data_input->DataSize == size_of_data) {
-            SizeT bytes_left = size_of_data;
-            SizeT offset     = 0;
-            Lba   base_lba   = fork_data_input->DataOffset;
-
-            while (bytes_left > 0) {
-                SizeT chunk = (bytes_left > kNeFSSectorSz) ? kNeFSSectorSz : bytes_left;
-                drive.fPacket.fPacketContent = const_cast<VoidPtr>(buf + offset);
-                drive.fPacket.fPacketSize    = chunk;
-                drive.fPacket.fPacketLba     = base_lba + (offset / kNeFSSectorSz);
-                drive.fOutput(drive.fPacket);
-                offset     += chunk;
-                bytes_left -= chunk;
-            }
-
-            delete fork_data_input;
-            delete[] buf;
-            delete catalog;
-            return true;
-        }
+    if (!drive.fPacket.fPacketGood) {
+      break;
+    }
 
-        prev_fork = *fork_data_input;
-        startFork = fork_data_input->NextSibling;
+    if ((fork_data_input->Flags & kNeFSFlagCreated) &&
+        KStringBuilder::Equals(fork_data_input->ForkName, fork_name) &&
+        KStringBuilder::Equals(fork_data_input->CatalogName, catalog_name) &&
+        fork_data_input->DataSize == size_of_data) {
+      SizeT bytes_left = size_of_data;
+      SizeT offset     = 0;
+      Lba   base_lba   = fork_data_input->DataOffset;
+
+      while (bytes_left > 0) {
+        SizeT chunk                  = (bytes_left > kNeFSSectorSz) ? kNeFSSectorSz : bytes_left;
+        drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(buf + offset);
+        drive.fPacket.fPacketSize    = chunk;
+        drive.fPacket.fPacketLba     = base_lba + (offset / kNeFSSectorSz);
+        drive.fOutput(drive.fPacket);
+        offset += chunk;
+        bytes_left -= chunk;
+      }
+
+      delete fork_data_input;
+      delete[] buf;
+      delete catalog;
+      return true;
     }
 
-    delete fork_data_input;
-    delete[] buf;
-    delete catalog;
-    return false;
+    prev_fork = *fork_data_input;
+    startFork = fork_data_input->NextSibling;
+  }
+
+  delete fork_data_input;
+  delete[] buf;
+  delete catalog;
+  return false;
 }
 
 /***********************************************************************************/
@@ -555,79 +570,82 @@ bool NeFileSystemParser::WriteCatalog(_Input const Char* catalog_name,
 /// @return the newly found catalog.
 /***********************************************************************************/
 _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::FindCatalog(_Input const Char* catalog_name,
-                                                             Lba& out_lba,
-                                                             Bool search_hidden,
+                                                             Lba& out_lba, Bool search_hidden,
                                                              Bool local_search) {
-    if (!catalog_name || *catalog_name == 0) return nullptr;
-
-    NEFS_ROOT_PARTITION_BLOCK part{};
-    auto& drive = kMountpoint.A();
-
-    rt_copy_memory((VoidPtr)"fs/nefs-packet", drive.fPacket.fPacketMime, rt_string_len("fs/nefs-packet"));
-    drive.fPacket.fPacketContent = const_cast<VoidPtr>(&part);
-    drive.fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
-    drive.fPacket.fPacketLba     = kNeFSRootCatalogStartAddress;
-    drive.fInput(drive.fPacket);
-
-    auto start_catalog_lba = kNeFSCatalogStartAddress;
-
-    // Helper lambda to scan from a given LBA
-    auto scan_from = [&](Lba lba_start, Bool allow_hidden) -> NEFS_CATALOG_STRUCT* {
-        Lba cursor = lba_start;
-        NEFS_CATALOG_STRUCT tmp{};
-        while (cursor >= part.StartCatalog && drive.fPacket.fPacketGood) {
-            drive.fPacket.fPacketLba     = cursor;
-            drive.fPacket.fPacketContent = const_cast<VoidPtr>(&tmp);
-            drive.fPacket.fPacketSize    = sizeof(NEFS_CATALOG_STRUCT);
-            drive.fInput(drive.fPacket);
-
-            if (KStringBuilder::Equals(tmp.Name, catalog_name + (rt_string_len(catalog_name) - rt_string_len(tmp.Name)))) {
-                if (tmp.Status == kNeFSStatusLocked && !allow_hidden) {
-                    err_global_get() = kErrorFileLocked;
-                    return nullptr;
-                }
-                if (!(tmp.Flags & kNeFSFlagCreated)) {
-                    err_global_get() = kErrorFileNotFound;
-                    return nullptr;
-                }
-                NEFS_CATALOG_STRUCT* catalog_ptr = new NEFS_CATALOG_STRUCT();
-                rt_copy_memory(&tmp, catalog_ptr, sizeof(NEFS_CATALOG_STRUCT));
-                out_lba = cursor;
-                return catalog_ptr;
-            }
-            cursor = tmp.NextSibling;
-        }
-        return nullptr;
-    };
-
-    if (!KStringBuilder::Equals(catalog_name, NeFileSystemHelper::Root()) && local_search) {
-        Char parent_name[kNeFSCatalogNameLen] = {0};
-        SizeT nameLen = rt_string_len(catalog_name);
-        rt_copy_memory(catalog_name, parent_name, nameLen + 1);
-
-        SizeT indexReverseCopy = nameLen - 1;
-        if (parent_name[indexReverseCopy] == NeFileSystemHelper::Separator()) {
-            parent_name[indexReverseCopy] = 0;
-            --indexReverseCopy;
+  if (!catalog_name || *catalog_name == 0) return nullptr;
+
+  NEFS_ROOT_PARTITION_BLOCK part{};
+  auto&                     drive = kMountpoint.A();
+
+  rt_copy_memory((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
+                 rt_string_len("fs/nefs-packet"));
+  drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(&part);
+  drive.fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
+  drive.fPacket.fPacketLba     = kNeFSRootCatalogStartAddress;
+  drive.fInput(drive.fPacket);
+
+  auto start_catalog_lba = kNeFSCatalogStartAddress;
+
+  // Helper lambda to scan from a given LBA
+  auto scan_from = [&](Lba lba_start, Bool allow_hidden) -> NEFS_CATALOG_STRUCT* {
+    Lba                 cursor = lba_start;
+    NEFS_CATALOG_STRUCT tmp{};
+    while (cursor >= part.StartCatalog && drive.fPacket.fPacketGood) {
+      drive.fPacket.fPacketLba     = cursor;
+      drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(&tmp);
+      drive.fPacket.fPacketSize    = sizeof(NEFS_CATALOG_STRUCT);
+      drive.fInput(drive.fPacket);
+
+      if (KStringBuilder::Equals(
+              tmp.Name, catalog_name + (rt_string_len(catalog_name) - rt_string_len(tmp.Name)))) {
+        if (tmp.Status == kNeFSStatusLocked && !allow_hidden) {
+          err_global_get() = kErrorFileLocked;
+          return nullptr;
         }
-        while (indexReverseCopy > 0 && parent_name[indexReverseCopy] != NeFileSystemHelper::Separator()) {
-            parent_name[indexReverseCopy] = 0;
-            --indexReverseCopy;
-        }
-        if (indexReverseCopy == 0 && parent_name[0] != NeFileSystemHelper::Separator()) {
-            return nullptr;
+        if (!(tmp.Flags & kNeFSFlagCreated)) {
+          err_global_get() = kErrorFileNotFound;
+          return nullptr;
         }
+        NEFS_CATALOG_STRUCT* catalog_ptr = new NEFS_CATALOG_STRUCT();
+        rt_copy_memory(&tmp, catalog_ptr, sizeof(NEFS_CATALOG_STRUCT));
+        out_lba = cursor;
+        return catalog_ptr;
+      }
+      cursor = tmp.NextSibling;
+    }
+    return nullptr;
+  };
 
-        NEFS_CATALOG_STRUCT* parent_catalog = this->FindCatalog(parent_name, out_lba, search_hidden, NO);
-        if (parent_catalog) {
-            start_catalog_lba = parent_catalog->NextSibling;
-            delete parent_catalog;
-            NEFS_CATALOG_STRUCT* found = scan_from(start_catalog_lba, search_hidden);
-            if (found) return found;
-        }
+  if (!KStringBuilder::Equals(catalog_name, NeFileSystemHelper::Root()) && local_search) {
+    Char  parent_name[kNeFSCatalogNameLen] = {0};
+    SizeT nameLen                          = rt_string_len(catalog_name);
+    rt_copy_memory(const_cast<Char*>(catalog_name), parent_name, nameLen + 1);
+
+    SizeT indexReverseCopy = nameLen - 1;
+    if (parent_name[indexReverseCopy] == NeFileSystemHelper::Separator()) {
+      parent_name[indexReverseCopy] = 0;
+      --indexReverseCopy;
+    }
+    while (indexReverseCopy > 0 &&
+           parent_name[indexReverseCopy] != NeFileSystemHelper::Separator()) {
+      parent_name[indexReverseCopy] = 0;
+      --indexReverseCopy;
     }
+    if (indexReverseCopy == 0 && parent_name[0] != NeFileSystemHelper::Separator()) {
+      return nullptr;
+    }
+
+    NEFS_CATALOG_STRUCT* parent_catalog =
+        this->FindCatalog(parent_name, out_lba, search_hidden, NO);
+    if (parent_catalog) {
+      start_catalog_lba = parent_catalog->NextSibling;
+      delete parent_catalog;
+      NEFS_CATALOG_STRUCT* found = scan_from(start_catalog_lba, search_hidden);
+      if (found) return found;
+    }
+  }
 
-    return scan_from(part.StartCatalog, search_hidden);
+  return scan_from(part.StartCatalog, search_hidden);
 }
 
 /***********************************************************************************/
@@ -636,8 +654,8 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::FindCatalog(_Input const Char*
 /// @return
 /***********************************************************************************/
 _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::GetCatalog(_Input const Char* name) {
-    Lba unused = 0;
-    return this->FindCatalog(name, unused, YES, YES);
+  Lba unused = 0;
+  return this->FindCatalog(name, unused, YES, YES);
 }
 
 /***********************************************************************************/
@@ -646,10 +664,10 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::GetCatalog(_Input const Char* n
 /// @return
 /***********************************************************************************/
 _Output Boolean NeFileSystemParser::CloseCatalog(_Input _Output NEFS_CATALOG_STRUCT* catalog) {
-    if (!catalog) return false;
-    delete catalog;
-    catalog = nullptr;
-    return true;
+  if (!catalog) return false;
+  delete catalog;
+  catalog = nullptr;
+  return true;
 }
 
 /***********************************************************************************/
@@ -658,86 +676,87 @@ _Output Boolean NeFileSystemParser::CloseCatalog(_Input _Output NEFS_CATALOG_STR
 /// @return if the catalog was removed or not.
 /***********************************************************************************/
 _Output Boolean NeFileSystemParser::RemoveCatalog(_Input const Char* catalog_name) {
-    if (!catalog_name || KStringBuilder::Equals(catalog_name, NeFileSystemHelper::Root())) {
-        err_global_get() = kErrorInternal;
-        return false;
-    }
+  if (!catalog_name || KStringBuilder::Equals(catalog_name, NeFileSystemHelper::Root())) {
+    err_global_get() = kErrorInternal;
+    return false;
+  }
+
+  Lba  out_lba = 0;
+  auto catalog = this->FindCatalog(catalog_name, out_lba, YES, YES);
+  if (!catalog) return false;
+
+  auto&            drive = kMountpoint.A();
+  NEFS_FORK_STRUCT fork_buf{};
+  Lba              fork_lba = catalog->DataFork;
+  while (fork_lba >= kNeFSCatalogStartAddress) {
+    drive.fPacket.fPacketLba     = fork_lba;
+    drive.fPacket.fPacketSize    = sizeof(fork_buf);
+    drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(&fork_buf);
+    drive.fInput(drive.fPacket);
 
-    Lba out_lba = 0;
-    auto catalog = this->FindCatalog(catalog_name, out_lba, YES, YES);
-    if (!catalog) return false;
-
-    auto& drive = kMountpoint.A();
-    NEFS_FORK_STRUCT fork_buf{};
-    Lba fork_lba = catalog->DataFork;
-    while (fork_lba >= kNeFSCatalogStartAddress) {
-        drive.fPacket.fPacketLba     = fork_lba;
-        drive.fPacket.fPacketSize    = sizeof(fork_buf);
-        drive.fPacket.fPacketContent = const_cast<VoidPtr>(&fork_buf);
-        drive.fInput(drive.fPacket);
-
-        fork_buf.Flags &= (~kNeFSFlagCreated);
-        fork_buf.Flags |= kNeFSFlagDeleted;
-
-        drive.fPacket.fPacketContent = const_cast<VoidPtr>(&fork_buf);
-        drive.fPacket.fPacketSize    = sizeof(fork_buf);
-        drive.fPacket.fPacketLba     = fork_lba;
-        drive.fOutput(drive.fPacket);
+    fork_buf.Flags &= (~kNeFSFlagCreated);
+    fork_buf.Flags |= kNeFSFlagDeleted;
 
-        fork_lba = fork_buf.NextSibling;
-    }
+    drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(&fork_buf);
+    drive.fPacket.fPacketSize    = sizeof(fork_buf);
+    drive.fPacket.fPacketLba     = fork_lba;
+    drive.fOutput(drive.fPacket);
 
-    fork_lba = catalog->ResourceFork;
-    while (fork_lba >= kNeFSCatalogStartAddress) {
-        drive.fPacket.fPacketLba     = fork_lba;
-        drive.fPacket.fPacketSize    = sizeof(fork_buf);
-        drive.fPacket.fPacketContent = const_cast<VoidPtr>(&fork_buf);
-        drive.fInput(drive.fPacket);
+    fork_lba = fork_buf.NextSibling;
+  }
 
-        fork_buf.Flags &= (~kNeFSFlagCreated);
-        fork_buf.Flags |= kNeFSFlagDeleted;
+  fork_lba = catalog->ResourceFork;
+  while (fork_lba >= kNeFSCatalogStartAddress) {
+    drive.fPacket.fPacketLba     = fork_lba;
+    drive.fPacket.fPacketSize    = sizeof(fork_buf);
+    drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(&fork_buf);
+    drive.fInput(drive.fPacket);
 
-        drive.fPacket.fPacketContent = const_cast<VoidPtr>(&fork_buf);
-        drive.fPacket.fPacketSize    = sizeof(fork_buf);
-        drive.fPacket.fPacketLba     = fork_lba;
-        drive.fOutput(drive.fPacket);
+    fork_buf.Flags &= (~kNeFSFlagCreated);
+    fork_buf.Flags |= kNeFSFlagDeleted;
 
-        fork_lba = fork_buf.NextSibling;
-    }
+    drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(&fork_buf);
+    drive.fPacket.fPacketSize    = sizeof(fork_buf);
+    drive.fPacket.fPacketLba     = fork_lba;
+    drive.fOutput(drive.fPacket);
 
-    if (out_lba >= kNeFSCatalogStartAddress || (catalog->Flags & kNeFSFlagCreated)) {
-        catalog->Flags &= (~kNeFSFlagCreated);
-        catalog->Flags |= kNeFSFlagDeleted;
+    fork_lba = fork_buf.NextSibling;
+  }
 
-        rt_copy_memory((VoidPtr)"fs/nefs-packet", drive.fPacket.fPacketMime, rt_string_len("fs/nefs-packet"));
-        drive.fPacket.fPacketLba     = out_lba;
-        drive.fPacket.fPacketSize    = sizeof(NEFS_CATALOG_STRUCT);
-        drive.fPacket.fPacketContent = const_cast<VoidPtr>(catalog);
-        drive.fOutput(drive.fPacket);
+  if (out_lba >= kNeFSCatalogStartAddress || (catalog->Flags & kNeFSFlagCreated)) {
+    catalog->Flags &= (~kNeFSFlagCreated);
+    catalog->Flags |= kNeFSFlagDeleted;
 
-        Char partitionBlockBuf[sizeof(NEFS_ROOT_PARTITION_BLOCK)] = {0};
-        drive.fPacket.fPacketLba     = kNeFSRootCatalogStartAddress;
-        drive.fPacket.fPacketContent = const_cast<VoidPtr>(partitionBlockBuf);
-        drive.fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
-        drive.fInput(drive.fPacket);
+    rt_copy_memory((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
+                   rt_string_len("fs/nefs-packet"));
+    drive.fPacket.fPacketLba     = out_lba;
+    drive.fPacket.fPacketSize    = sizeof(NEFS_CATALOG_STRUCT);
+    drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(catalog);
+    drive.fOutput(drive.fPacket);
 
-        NEFS_ROOT_PARTITION_BLOCK* part_block = (NEFS_ROOT_PARTITION_BLOCK*)partitionBlockBuf;
-        if (part_block->CatalogCount > 0) --part_block->CatalogCount;
-        ++part_block->FreeSectors;
+    Char partitionBlockBuf[sizeof(NEFS_ROOT_PARTITION_BLOCK)] = {0};
+    drive.fPacket.fPacketLba                                  = kNeFSRootCatalogStartAddress;
+    drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(partitionBlockBuf);
+    drive.fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
+    drive.fInput(drive.fPacket);
 
-        drive.fPacket.fPacketContent = const_cast<VoidPtr>(part_block);
-        drive.fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
-        drive.fPacket.fPacketLba     = kNeFSRootCatalogStartAddress;
-        drive.fOutput(drive.fPacket);
+    NEFS_ROOT_PARTITION_BLOCK* part_block = (NEFS_ROOT_PARTITION_BLOCK*) partitionBlockBuf;
+    if (part_block->CatalogCount > 0) --part_block->CatalogCount;
+    ++part_block->FreeSectors;
 
-        delete catalog;
-        catalog = nullptr;
-        return true;
-    }
+    drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(part_block);
+    drive.fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
+    drive.fPacket.fPacketLba     = kNeFSRootCatalogStartAddress;
+    drive.fOutput(drive.fPacket);
 
     delete catalog;
     catalog = nullptr;
-    return false;
+    return true;
+  }
+
+  delete catalog;
+  catalog = nullptr;
+  return false;
 }
 
 /// ***************************************************************** ///
@@ -751,55 +770,57 @@ _Output Boolean NeFileSystemParser::RemoveCatalog(_Input const Char* catalog_nam
 /// @return
 /***********************************************************************************/
 VoidPtr NeFileSystemParser::ReadCatalog(_Input _Output NEFS_CATALOG_STRUCT* catalog,
-                                        _Input Bool is_rsrc_fork,
-                                        _Input SizeT dataSz,
-                                        _Input const Char* forkName)
-{
-    if (!catalog) {
-        err_global_get() = kErrorInvalidData;
-        return nullptr;
-    }
-    // Validate size against fork size
-    SizeT maxSize = is_rsrc_fork ? catalog->ResourceForkSize : catalog->DataForkSize;
-    if (!is_valid_size(dataSz, maxSize)) {
-        kout << "NeFS: ReadCatalog called with invalid size: " << dataSz << "\n";
-        return nullptr;
-    }
-
-    Lba dataForkLba = is_rsrc_fork ? catalog->ResourceFork : catalog->DataFork;
-    auto& drive = kMountpoint.A();
-    if (!is_valid_lba(dataForkLba, drive)) {
-        kout << "NeFS: ReadCatalog called with invalid LBA: " << dataForkLba << "\n";
-        return nullptr;
-    }
+                                        _Input Bool is_rsrc_fork, _Input SizeT dataSz,
+                                        _Input const Char* forkName) {
+  if (!catalog) {
+    err_global_get() = kErrorInvalidData;
+    return nullptr;
+  }
+  // Validate size against fork size
+  SizeT maxSize = is_rsrc_fork ? catalog->ResourceForkSize : catalog->DataForkSize;
+  if (!is_valid_size(dataSz, maxSize)) {
+    kout << "NeFS: ReadCatalog called with invalid size: ";
+    hex_number(dataSz);
+    kout << "\n";
+    return nullptr;
+  }
+
+  Lba   dataForkLba = is_rsrc_fork ? catalog->ResourceFork : catalog->DataFork;
+  auto& drive       = kMountpoint.A();
+  if (!is_valid_lba(dataForkLba, drive)) {
+    kout << "NeFS: ReadCatalog called with invalid LBA: ";
+    hex_number(dataForkLba);
+    kout << "\n";
+    return nullptr;
+  }
 
-    auto* fs_buf = new NEFS_FORK_STRUCT();
-    rt_copy_memory((VoidPtr)"fs/nefs-packet", drive.fPacket.fPacketMime, 16);
+  auto* fs_buf = new NEFS_FORK_STRUCT();
+  rt_copy_memory((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
+                 rt_string_len("fs/nefs-packet"));
 
-    NEFS_FORK_STRUCT* fs_fork_data = nullptr;
-    while (dataForkLba >= kNeFSCatalogStartAddress) {
-        drive.fPacket.fPacketLba     = dataForkLba;
-        drive.fPacket.fPacketSize    = sizeof(NEFS_FORK_STRUCT);
-        drive.fPacket.fPacketContent = const_cast<VoidPtr>(fs_buf);
-        drive.fInput(drive.fPacket);
+  NEFS_FORK_STRUCT* fs_fork_data = nullptr;
+  while (dataForkLba >= kNeFSCatalogStartAddress) {
+    drive.fPacket.fPacketLba     = dataForkLba;
+    drive.fPacket.fPacketSize    = sizeof(NEFS_FORK_STRUCT);
+    drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(fs_buf);
+    drive.fInput(drive.fPacket);
 
-        fs_fork_data = fs_buf;
-        (Void)(kout << "ForkName: " << fs_fork_data->ForkName << kendl);
-        (Void)(kout << "CatalogName: " << fs_fork_data->CatalogName << kendl);
+    fs_fork_data = fs_buf;
+    (Void)(kout << "ForkName: " << fs_fork_data->ForkName << kendl);
+    (Void)(kout << "CatalogName: " << fs_fork_data->CatalogName << kendl);
 
-        if (KStringBuilder::Equals(forkName, fs_fork_data->ForkName) &&
-            KStringBuilder::Equals(catalog->Name, fs_fork_data->CatalogName))
-        {
-            break;
-        }
-        dataForkLba = fs_fork_data->NextSibling;
+    if (KStringBuilder::Equals(forkName, fs_fork_data->ForkName) &&
+        KStringBuilder::Equals(catalog->Name, fs_fork_data->CatalogName)) {
+      break;
     }
+    dataForkLba = fs_fork_data->NextSibling;
+  }
 
-    if (dataForkLba < kNeFSCatalogStartAddress) {
-        delete fs_buf;
-        return nullptr;
-    }
-    return fs_fork_data;
+  if (dataForkLba < kNeFSCatalogStartAddress) {
+    delete fs_buf;
+    return nullptr;
+  }
+  return fs_fork_data;
 }
 
 /***********************************************************************************/
@@ -809,10 +830,10 @@ VoidPtr NeFileSystemParser::ReadCatalog(_Input _Output NEFS_CATALOG_STRUCT* cata
 /// @return if the seeking was successful.
 /***********************************************************************************/
 bool NeFileSystemParser::Seek(_Input _Output NEFS_CATALOG_STRUCT* catalog, SizeT off) {
-    NE_UNUSED(catalog);
-    NE_UNUSED(off);
-    err_global_get() = kErrorUnimplemented;
-    return false;
+  NE_UNUSED(catalog);
+  NE_UNUSED(off);
+  err_global_get() = kErrorUnimplemented;
+  return false;
 }
 
 /***********************************************************************************/
@@ -821,9 +842,9 @@ bool NeFileSystemParser::Seek(_Input _Output NEFS_CATALOG_STRUCT* catalog, SizeT
 /// @return The position on the file.
 /***********************************************************************************/
 SizeT NeFileSystemParser::Tell(_Input _Output NEFS_CATALOG_STRUCT* catalog) {
-    NE_UNUSED(catalog);
-    err_global_get() = kErrorUnimplemented;
-    return 0;
+  NE_UNUSED(catalog);
+  err_global_get() = kErrorUnimplemented;
+  return 0;
 }
 
 namespace Kernel::NeFS {
@@ -831,12 +852,12 @@ namespace Kernel::NeFS {
 /// @brief Construct NeFS drives.
 /***********************************************************************************/
 Boolean fs_init_nefs(Void) noexcept {
-    kout << "Creating HeFS disk...\r";
-    kMountpoint.A() = io_construct_main_drive();
-    if (kMountpoint.A().fPacket.fPacketReadOnly == YES)
-        ke_panic(RUNTIME_CHECK_FILESYSTEM, "Main disk cannot be mounted.");
-    NeFileSystemParser parser;
-    return parser.Format(&kMountpoint.A(), 0, kNeFSVolumeName);
+  kout << "Creating HeFS disk...\r";
+  kMountpoint.A() = io_construct_main_drive();
+  if (kMountpoint.A().fPacket.fPacketReadOnly == YES)
+    ke_panic(RUNTIME_CHECK_FILESYSTEM, "Main disk cannot be mounted.");
+  NeFileSystemParser parser;
+  return parser.Format(&kMountpoint.A(), 0, kNeFSVolumeName);
 }
 }  // namespace Kernel::NeFS