From 8b86ba2a1c0b229df94322c5fc6ee723efc4d717 Mon Sep 17 00:00:00 2001 From: 0xf00sec <159052166+0xf00sec@users.noreply.github.com> Date: Wed, 4 Jun 2025 10:52:54 +0000 Subject: Fix mParser --- dev/kernel/src/FS/NeFS+FileMgr.cc | 256 ++++++++++++++++++++++++-------------- 1 file changed, 160 insertions(+), 96 deletions(-) (limited to 'dev/kernel/src/FS') diff --git a/dev/kernel/src/FS/NeFS+FileMgr.cc b/dev/kernel/src/FS/NeFS+FileMgr.cc index 978a43a8..d02f93da 100644 --- a/dev/kernel/src/FS/NeFS+FileMgr.cc +++ b/dev/kernel/src/FS/NeFS+FileMgr.cc @@ -16,78 +16,94 @@ namespace Kernel { /// @brief C++ constructor NeFileSystemMgr::NeFileSystemMgr() { - NeFileSystemParser* mParser = new NeFileSystemParser(); - MUST_PASS(mParser); + mParser = new NeFileSystemParser(); + MUST_PASS(mParser); - kout << "We are done allocating NeFileSystemParser...\r"; + kout << "We are done allocating NeFileSystemParser...\n"; } NeFileSystemMgr::~NeFileSystemMgr() { - if (mParser) { - kout << "Destroying NeFileSystemParser...\r"; - mm_delete_class(&mParser); - } + if (mParser) { + kout << "Destroying NeFileSystemParser...\n"; + delete mParser; + mParser = nullptr; + } } /// @brief Removes a node from the filesystem. /// @param path The filename /// @return If it was deleted or not. bool NeFileSystemMgr::Remove(_Input const Char* path) { - if (path == nullptr || *path == 0) return false; - - return mParser->RemoveCatalog(path); + if (path == nullptr || *path == 0) { + kout << "NeFS: Remove called with null or empty path\n"; + return false; + } + return mParser->RemoveCatalog(path); } /// @brief Creates a node with the specified. /// @param path The filename path. /// @return The Node pointer. NodePtr NeFileSystemMgr::Create(_Input const Char* path) { - return rtl_node_cast(mParser->CreateCatalog(path)); + if (!path || *path == 0) { + kout << "NeFS: Create called with null or empty path\n"; + return nullptr; + } + return rtl_node_cast(mParser->CreateCatalog(path)); } -/// @brief Creates a node with is a directory. +/// @brief Creates a node which is a directory. /// @param path The filename path. /// @return The Node pointer. NodePtr NeFileSystemMgr::CreateDirectory(const Char* path) { - return rtl_node_cast(mParser->CreateCatalog(path, 0, kNeFSCatalogKindDir)); + if (!path || *path == 0) { + kout << "NeFS: CreateDirectory called with null or empty path\n"; + return nullptr; + } + return rtl_node_cast(mParser->CreateCatalog(path, 0, kNeFSCatalogKindDir)); } -/// @brief Creates a node with is a alias. +/// @brief Creates a node which is an alias. /// @param path The filename path. /// @return The Node pointer. NodePtr NeFileSystemMgr::CreateAlias(const Char* path) { - return rtl_node_cast(mParser->CreateCatalog(path, 0, kNeFSCatalogKindAlias)); + if (!path || *path == 0) { + kout << "NeFS: CreateAlias called with null or empty path\n"; + return nullptr; + } + return rtl_node_cast(mParser->CreateCatalog(path, 0, kNeFSCatalogKindAlias)); } -/// @brief Creates a node with is a page file. -/// @param path The filename path. -/// @return The Node pointer. NodePtr NeFileSystemMgr::CreateSwapFile(const Char* path) { - return rtl_node_cast(mParser->CreateCatalog(path, 0, kNeFSCatalogKindPage)); + if (!path || *path == 0) { + kout << "NeFS: CreateSwapFile called with null or empty path\n"; + return nullptr; + } + return rtl_node_cast(mParser->CreateCatalog(path, 0, kNeFSCatalogKindPage)); } /// @brief Gets the root directory. /// @return const Char* NeFileSystemHelper::Root() { - return kNeFSRoot; + return kNeFSRoot; } /// @brief Gets the up-dir directory. /// @return const Char* NeFileSystemHelper::UpDir() { - return kNeFSUpDir; + return kNeFSUpDir; } /// @brief Gets the separator character. /// @return Char NeFileSystemHelper::Separator() { - return kNeFSSeparator; + return kNeFSSeparator; } /// @brief Gets the metafile character. /// @return Char NeFileSystemHelper::MetaFile() { - return kNeFSMetaFilePrefix; + return kNeFSMetaFilePrefix; } /// @brief Opens a new file. @@ -95,109 +111,157 @@ Char NeFileSystemHelper::MetaFile() { /// @param r /// @return _Output NodePtr NeFileSystemMgr::Open(_Input const Char* path, _Input const Char* r) { - if (!path || *path == 0) return nullptr; - - if (!r || *r == 0) return nullptr; - - auto catalog = mParser->GetCatalog(path); - - return rtl_node_cast(catalog); + if (!path || *path == 0) { + kout << "NeFS: Open called with null or empty path\n"; + return nullptr; + } + if (!r || *r == 0) { + kout << "NeFS: Open called with null or empty mode string\n"; + return nullptr; + } + auto catalog = mParser->GetCatalog(path); + if (!catalog) { + kout << "NeFS: Open could not find catalog for path\n"; + return nullptr; + } + return rtl_node_cast(catalog); } -/// @brief Writes to a catalog's fork. -/// @param node the node ptr. -/// @param data the data. -/// @param flags the size. -/// @return Void NeFileSystemMgr::Write(_Input NodePtr node, _Input VoidPtr data, _Input Int32 flags, _Input SizeT size) { - if (!node) return; - if (!size) return; - - constexpr auto kDataForkName = kNeFSDataFork; - this->Write(kDataForkName, node, data, flags, size); + if (!is_valid_nefs_catalog(node)) { + kout << "NeFS: Write called with invalid node pointer\n"; + return; + } + if (!data) { + kout << "NeFS: Write called with null data pointer\n"; + return; + } + if (!size || size > kNeFSForkSize) { + kout << "NeFS: Write called with invalid size: " << size << "\n"; + return; + } + constexpr auto kDataForkName = kNeFSDataFork; + this->Write(kDataForkName, node, data, flags, size); } -/// @brief Read from filesystem fork. -/// @param node the catalog node. -/// @param flags the flags with it. -/// @param sz the size to read. -/// @return _Output VoidPtr NeFileSystemMgr::Read(_Input NodePtr node, _Input Int32 flags, _Input SizeT size) { - if (!node) return nullptr; - if (!size) return nullptr; - - constexpr auto kDataForkName = kNeFSDataFork; - return this->Read(kDataForkName, node, flags, size); + if (!is_valid_nefs_catalog(node)) { + kout << "NeFS: Read called with invalid node pointer\n"; + return nullptr; + } + if (!size || size > kNeFSForkSize) { + kout << "NeFS: Read called with invalid size: " << size << "\n"; + return nullptr; + } + constexpr auto kDataForkName = kNeFSDataFork; + return this->Read(kDataForkName, node, flags, size); } Void NeFileSystemMgr::Write(_Input const Char* name, _Input NodePtr node, _Input VoidPtr data, _Input Int32 flags, _Input SizeT size) { - if (!size || size > kNeFSForkSize) return; - - if (!data) return; - - NE_UNUSED(flags); - - if ((reinterpret_cast(node))->Kind == kNeFSCatalogKindFile) - mParser->WriteCatalog(reinterpret_cast(node)->Name, - (flags & kFileFlagRsrc ? true : false), data, size, name); + if (!is_valid_nefs_catalog(node)) { + kout << "NeFS: Write(fork) called with invalid node pointer\n"; + return; + } + if (!name || *name == 0) { + kout << "NeFS: Write(fork) called with null or empty fork name\n"; + return; + } + if (!data) { + kout << "NeFS: Write(fork) called with null data pointer\n"; + return; + } + if (!size || size > kNeFSForkSize) { + kout << "NeFS: Write(fork) called with invalid size: " << size << "\n"; + return; + } + NE_UNUSED(flags); + auto cat = reinterpret_cast(node); + if (cat->Kind == kNeFSCatalogKindFile) { + mParser->WriteCatalog(cat->Name, + (flags & kFileFlagRsrc ? true : false), + data, + size, + name); + } } _Output VoidPtr NeFileSystemMgr::Read(_Input const Char* name, _Input NodePtr node, _Input Int32 flags, _Input SizeT sz) { - if (sz > kNeFSForkSize) return nullptr; - - if (!sz) return nullptr; - - NE_UNUSED(flags); - - if ((reinterpret_cast(node))->Kind == kNeFSCatalogKindFile) - return mParser->ReadCatalog(reinterpret_cast(node), - (flags & kFileFlagRsrc ? true : false), sz, name); - - return nullptr; + if (!is_valid_nefs_catalog(node)) { + kout << "NeFS: Read(fork) called with invalid node pointer\n"; + return nullptr; + } + if (!name || *name == 0) { + kout << "NeFS: Read(fork) called with null or empty fork name\n"; + return nullptr; + } + if (!sz || sz > kNeFSForkSize) { + kout << "NeFS: Read(fork) called with invalid size: " << sz << "\n"; + return nullptr; + } + NE_UNUSED(flags); + auto cat = reinterpret_cast(node); + if (cat->Kind == kNeFSCatalogKindFile) { + return mParser->ReadCatalog(cat, + (flags & kFileFlagRsrc ? true : false), + sz, + name); + } + return nullptr; } -/// @brief Seek from Catalog. -/// @param node -/// @param off -/// @retval true always returns false, this is unimplemented. -/// @retval false always returns this, it is unimplemented. - _Output Bool NeFileSystemMgr::Seek(NodePtr node, SizeT off) { - if (!node || off == 0) return false; - - return mParser->Seek(reinterpret_cast(node), off); + if (!is_valid_nefs_catalog(node)) { + kout << "NeFS: Seek called with invalid node pointer\n"; + return false; + } + // Allow off == 0 + return mParser->Seek(reinterpret_cast(node), off); } -/// @brief Tell where the catalog is. +/// @brief Tell current offset within catalog. /// @param node -/// @retval true always returns false, this is unimplemented. -/// @retval false always returns this, it is unimplemented. - +/// @return kFileMgrNPos if invalid, else current offset. _Output SizeT NeFileSystemMgr::Tell(NodePtr node) { - if (!node) return kFileMgrNPos; - - return mParser->Tell(reinterpret_cast(node)); + if (!is_valid_nefs_catalog(node)) { + kout << "NeFS: Tell called with invalid node pointer\n"; + return kFileMgrNPos; + } + return mParser->Tell(reinterpret_cast(node)); } -/// @brief Rewinds the catalog. +/// @brief Rewinds the catalog /// @param node -/// @retval true always returns false, this is unimplemented. -/// @retval false always returns this, it is unimplemented. - +/// @return False if invalid, nah? calls Seek(node, 0). _Output Bool NeFileSystemMgr::Rewind(NodePtr node) { - if (!node) return false; - - return this->Seek(node, 0); + if (!is_valid_nefs_catalog(node)) { + kout << "NeFS: Rewind called with invalid node pointer\n"; + return false; + } + return this->Seek(node, 0); } -/// @brief Returns the filesystem parser. -/// @return the Filesystem parser class. _Output NeFileSystemParser* NeFileSystemMgr::GetParser() noexcept { - return mParser; + return mParser; } + +static inline bool is_valid_nefs_catalog(NodePtr node) { + if (!node) return false; + auto cat = reinterpret_cast(node); + if (cat->Kind < 0 || cat->Kind > 3) return false; + bool null_found = false; + for (int i = 0; i < kNeFSCatalogNameLen; ++i) { + if (cat->Name[i] == 0) { + null_found = true; + break; + } + } + if (!null_found) return false; + return true; +} + } // namespace Kernel #endif // ifdef __FSKIT_INCLUDES_NEFS__ -- cgit v1.2.3 From f64668b1cca66565df06f59e1e68381ecbfef217 Mon Sep 17 00:00:00 2001 From: 0xf00sec <159052166+0xf00sec@users.noreply.github.com> Date: Wed, 4 Jun 2025 12:25:03 +0000 Subject: F* Macros --- dev/kernel/src/FS/NeFS+FileMgr.cc | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) (limited to 'dev/kernel/src/FS') diff --git a/dev/kernel/src/FS/NeFS+FileMgr.cc b/dev/kernel/src/FS/NeFS+FileMgr.cc index d02f93da..fffb1e80 100644 --- a/dev/kernel/src/FS/NeFS+FileMgr.cc +++ b/dev/kernel/src/FS/NeFS+FileMgr.cc @@ -250,13 +250,18 @@ _Output NeFileSystemParser* NeFileSystemMgr::GetParser() noexcept { static inline bool is_valid_nefs_catalog(NodePtr node) { if (!node) return false; auto cat = reinterpret_cast(node); - if (cat->Kind < 0 || cat->Kind > 3) return false; + switch (cat->Kind) { + case kNeFSCatalogKindFile: + case kNeFSCatalogKindDir: + case kNeFSCatalogKindAlias: + case kNeFSCatalogKindPage: + break; + default: + return false; + } bool null_found = false; for (int i = 0; i < kNeFSCatalogNameLen; ++i) { - if (cat->Name[i] == 0) { - null_found = true; - break; - } + if (cat->Name[i] == 0) { null_found = true; break; } } if (!null_found) return false; return true; -- cgit v1.2.3 From b5add3bcf5580a2b2384f414b2df7350f4ded786 Mon Sep 17 00:00:00 2001 From: Amlal El Mahrouss Date: Wed, 4 Jun 2025 14:37:38 +0200 Subject: fix: Fix #37 compilation errors and warnings. Signed-off-by: Amlal El Mahrouss --- dev/kernel/src/FS/NeFS+FileMgr.cc | 311 +++++++++++++++++++------------------- tooling/fsck.hefs.cc | 2 + 2 files changed, 159 insertions(+), 154 deletions(-) (limited to 'dev/kernel/src/FS') diff --git a/dev/kernel/src/FS/NeFS+FileMgr.cc b/dev/kernel/src/FS/NeFS+FileMgr.cc index fffb1e80..2fcfa2bb 100644 --- a/dev/kernel/src/FS/NeFS+FileMgr.cc +++ b/dev/kernel/src/FS/NeFS+FileMgr.cc @@ -14,96 +14,98 @@ /// BUGS: 0 namespace Kernel { +static inline bool is_valid_nefs_catalog(NodePtr node); + /// @brief C++ constructor NeFileSystemMgr::NeFileSystemMgr() { - mParser = new NeFileSystemParser(); - MUST_PASS(mParser); + mParser = new NeFileSystemParser(); + MUST_PASS(mParser); - kout << "We are done allocating NeFileSystemParser...\n"; + kout << "We are done allocating NeFileSystemParser...\n"; } NeFileSystemMgr::~NeFileSystemMgr() { - if (mParser) { - kout << "Destroying NeFileSystemParser...\n"; - delete mParser; - mParser = nullptr; - } + if (mParser) { + kout << "Destroying NeFileSystemParser...\n"; + delete mParser; + mParser = nullptr; + } } /// @brief Removes a node from the filesystem. /// @param path The filename /// @return If it was deleted or not. bool NeFileSystemMgr::Remove(_Input const Char* path) { - if (path == nullptr || *path == 0) { - kout << "NeFS: Remove called with null or empty path\n"; - return false; - } - return mParser->RemoveCatalog(path); + if (path == nullptr || *path == 0) { + kout << "NeFS: Remove called with null or empty path\n"; + return false; + } + return mParser->RemoveCatalog(path); } /// @brief Creates a node with the specified. /// @param path The filename path. /// @return The Node pointer. NodePtr NeFileSystemMgr::Create(_Input const Char* path) { - if (!path || *path == 0) { - kout << "NeFS: Create called with null or empty path\n"; - return nullptr; - } - return rtl_node_cast(mParser->CreateCatalog(path)); + if (!path || *path == 0) { + kout << "NeFS: Create called with null or empty path\n"; + return nullptr; + } + return rtl_node_cast(mParser->CreateCatalog(path)); } /// @brief Creates a node which is a directory. /// @param path The filename path. /// @return The Node pointer. NodePtr NeFileSystemMgr::CreateDirectory(const Char* path) { - if (!path || *path == 0) { - kout << "NeFS: CreateDirectory called with null or empty path\n"; - return nullptr; - } - return rtl_node_cast(mParser->CreateCatalog(path, 0, kNeFSCatalogKindDir)); + if (!path || *path == 0) { + kout << "NeFS: CreateDirectory called with null or empty path\n"; + return nullptr; + } + return rtl_node_cast(mParser->CreateCatalog(path, 0, kNeFSCatalogKindDir)); } /// @brief Creates a node which is an alias. /// @param path The filename path. /// @return The Node pointer. NodePtr NeFileSystemMgr::CreateAlias(const Char* path) { - if (!path || *path == 0) { - kout << "NeFS: CreateAlias called with null or empty path\n"; - return nullptr; - } - return rtl_node_cast(mParser->CreateCatalog(path, 0, kNeFSCatalogKindAlias)); + if (!path || *path == 0) { + kout << "NeFS: CreateAlias called with null or empty path\n"; + return nullptr; + } + return rtl_node_cast(mParser->CreateCatalog(path, 0, kNeFSCatalogKindAlias)); } NodePtr NeFileSystemMgr::CreateSwapFile(const Char* path) { - if (!path || *path == 0) { - kout << "NeFS: CreateSwapFile called with null or empty path\n"; - return nullptr; - } - return rtl_node_cast(mParser->CreateCatalog(path, 0, kNeFSCatalogKindPage)); + if (!path || *path == 0) { + kout << "NeFS: CreateSwapFile called with null or empty path\n"; + return nullptr; + } + return rtl_node_cast(mParser->CreateCatalog(path, 0, kNeFSCatalogKindPage)); } /// @brief Gets the root directory. /// @return const Char* NeFileSystemHelper::Root() { - return kNeFSRoot; + return kNeFSRoot; } /// @brief Gets the up-dir directory. /// @return const Char* NeFileSystemHelper::UpDir() { - return kNeFSUpDir; + return kNeFSUpDir; } /// @brief Gets the separator character. /// @return Char NeFileSystemHelper::Separator() { - return kNeFSSeparator; + return kNeFSSeparator; } /// @brief Gets the metafile character. /// @return Char NeFileSystemHelper::MetaFile() { - return kNeFSMetaFilePrefix; + return kNeFSMetaFilePrefix; } /// @brief Opens a new file. @@ -111,160 +113,161 @@ Char NeFileSystemHelper::MetaFile() { /// @param r /// @return _Output NodePtr NeFileSystemMgr::Open(_Input const Char* path, _Input const Char* r) { - if (!path || *path == 0) { - kout << "NeFS: Open called with null or empty path\n"; - return nullptr; - } - if (!r || *r == 0) { - kout << "NeFS: Open called with null or empty mode string\n"; - return nullptr; - } - auto catalog = mParser->GetCatalog(path); - if (!catalog) { - kout << "NeFS: Open could not find catalog for path\n"; - return nullptr; - } - return rtl_node_cast(catalog); + if (!path || *path == 0) { + kout << "NeFS: Open called with null or empty path\n"; + return nullptr; + } + if (!r || *r == 0) { + kout << "NeFS: Open called with null or empty mode string\n"; + return nullptr; + } + auto catalog = mParser->GetCatalog(path); + if (!catalog) { + kout << "NeFS: Open could not find catalog for path\n"; + return nullptr; + } + return rtl_node_cast(catalog); } Void NeFileSystemMgr::Write(_Input NodePtr node, _Input VoidPtr data, _Input Int32 flags, _Input SizeT size) { - if (!is_valid_nefs_catalog(node)) { - kout << "NeFS: Write called with invalid node pointer\n"; - return; - } - if (!data) { - kout << "NeFS: Write called with null data pointer\n"; - return; - } - if (!size || size > kNeFSForkSize) { - kout << "NeFS: Write called with invalid size: " << size << "\n"; - return; - } - constexpr auto kDataForkName = kNeFSDataFork; - this->Write(kDataForkName, node, data, flags, size); + if (!is_valid_nefs_catalog(node)) { + kout << "NeFS: Write called with invalid node pointer\n"; + return; + } + if (!data) { + kout << "NeFS: Write called with null data pointer\n"; + return; + } + if (!size || size > kNeFSForkSize) { + (Void)(kout << "NeFS: Write called with invalid size: " << hex_number(size)); + kout << "\n"; + return; + } + constexpr auto kDataForkName = kNeFSDataFork; + this->Write(kDataForkName, node, data, flags, size); } _Output VoidPtr NeFileSystemMgr::Read(_Input NodePtr node, _Input Int32 flags, _Input SizeT size) { - if (!is_valid_nefs_catalog(node)) { - kout << "NeFS: Read called with invalid node pointer\n"; - return nullptr; - } - if (!size || size > kNeFSForkSize) { - kout << "NeFS: Read called with invalid size: " << size << "\n"; - return nullptr; - } - constexpr auto kDataForkName = kNeFSDataFork; - return this->Read(kDataForkName, node, flags, size); + if (!is_valid_nefs_catalog(node)) { + kout << "NeFS: Read called with invalid node pointer\n"; + return nullptr; + } + if (!size || size > kNeFSForkSize) { + (Void)(kout << "NeFS: Write called with invalid size: " << hex_number(size)); + kout << "\n"; + return nullptr; + } + constexpr auto kDataForkName = kNeFSDataFork; + return this->Read(kDataForkName, node, flags, size); } Void NeFileSystemMgr::Write(_Input const Char* name, _Input NodePtr node, _Input VoidPtr data, _Input Int32 flags, _Input SizeT size) { - if (!is_valid_nefs_catalog(node)) { - kout << "NeFS: Write(fork) called with invalid node pointer\n"; - return; - } - if (!name || *name == 0) { - kout << "NeFS: Write(fork) called with null or empty fork name\n"; - return; - } - if (!data) { - kout << "NeFS: Write(fork) called with null data pointer\n"; - return; - } - if (!size || size > kNeFSForkSize) { - kout << "NeFS: Write(fork) called with invalid size: " << size << "\n"; - return; - } - NE_UNUSED(flags); - auto cat = reinterpret_cast(node); - if (cat->Kind == kNeFSCatalogKindFile) { - mParser->WriteCatalog(cat->Name, - (flags & kFileFlagRsrc ? true : false), - data, - size, - name); - } + if (!is_valid_nefs_catalog(node)) { + kout << "NeFS: Write(fork) called with invalid node pointer\n"; + return; + } + if (!name || *name == 0) { + kout << "NeFS: Write(fork) called with null or empty fork name\n"; + return; + } + if (!data) { + kout << "NeFS: Write(fork) called with null data pointer\n"; + return; + } + if (!size || size > kNeFSForkSize) { + (Void)(kout << "NeFS: Write called with invalid size: " << hex_number(size)); + kout << "\n"; + return; + } + NE_UNUSED(flags); + auto cat = reinterpret_cast(node); + if (cat->Kind == kNeFSCatalogKindFile) { + mParser->WriteCatalog(cat->Name, (flags & kFileFlagRsrc ? true : false), data, size, name); + } } _Output VoidPtr NeFileSystemMgr::Read(_Input const Char* name, _Input NodePtr node, _Input Int32 flags, _Input SizeT sz) { - if (!is_valid_nefs_catalog(node)) { - kout << "NeFS: Read(fork) called with invalid node pointer\n"; - return nullptr; - } - if (!name || *name == 0) { - kout << "NeFS: Read(fork) called with null or empty fork name\n"; - return nullptr; - } - if (!sz || sz > kNeFSForkSize) { - kout << "NeFS: Read(fork) called with invalid size: " << sz << "\n"; - return nullptr; - } - NE_UNUSED(flags); - auto cat = reinterpret_cast(node); - if (cat->Kind == kNeFSCatalogKindFile) { - return mParser->ReadCatalog(cat, - (flags & kFileFlagRsrc ? true : false), - sz, - name); - } + if (!is_valid_nefs_catalog(node)) { + kout << "NeFS: Read(fork) called with invalid node pointer\n"; + return nullptr; + } + if (!name || *name == 0) { + kout << "NeFS: Read(fork) called with null or empty fork name\n"; + return nullptr; + } + if (!sz || sz > kNeFSForkSize) { + (Void)(kout << "NeFS: Write called with invalid size: " << hex_number(sz)); + kout << "\n"; return nullptr; + } + NE_UNUSED(flags); + auto cat = reinterpret_cast(node); + if (cat->Kind == kNeFSCatalogKindFile) { + return mParser->ReadCatalog(cat, (flags & kFileFlagRsrc ? true : false), sz, name); + } + return nullptr; } _Output Bool NeFileSystemMgr::Seek(NodePtr node, SizeT off) { - if (!is_valid_nefs_catalog(node)) { - kout << "NeFS: Seek called with invalid node pointer\n"; - return false; - } - // Allow off == 0 - return mParser->Seek(reinterpret_cast(node), off); + if (!is_valid_nefs_catalog(node)) { + kout << "NeFS: Seek called with invalid node pointer\n"; + return false; + } + // Allow off == 0 + return mParser->Seek(reinterpret_cast(node), off); } /// @brief Tell current offset within catalog. /// @param node /// @return kFileMgrNPos if invalid, else current offset. _Output SizeT NeFileSystemMgr::Tell(NodePtr node) { - if (!is_valid_nefs_catalog(node)) { - kout << "NeFS: Tell called with invalid node pointer\n"; - return kFileMgrNPos; - } - return mParser->Tell(reinterpret_cast(node)); + if (!is_valid_nefs_catalog(node)) { + kout << "NeFS: Tell called with invalid node pointer\n"; + return kFileMgrNPos; + } + return mParser->Tell(reinterpret_cast(node)); } -/// @brief Rewinds the catalog +/// @brief Rewinds the catalog /// @param node /// @return False if invalid, nah? calls Seek(node, 0). _Output Bool NeFileSystemMgr::Rewind(NodePtr node) { - if (!is_valid_nefs_catalog(node)) { - kout << "NeFS: Rewind called with invalid node pointer\n"; - return false; - } - return this->Seek(node, 0); + if (!is_valid_nefs_catalog(node)) { + kout << "NeFS: Rewind called with invalid node pointer\n"; + return false; + } + return this->Seek(node, 0); } +/// @brief Returns the parser of NeFS. _Output NeFileSystemParser* NeFileSystemMgr::GetParser() noexcept { - return mParser; + return mParser; } static inline bool is_valid_nefs_catalog(NodePtr node) { - if (!node) return false; - auto cat = reinterpret_cast(node); - switch (cat->Kind) { - case kNeFSCatalogKindFile: - case kNeFSCatalogKindDir: - case kNeFSCatalogKindAlias: - case kNeFSCatalogKindPage: - break; - default: - return false; - } - bool null_found = false; - for (int i = 0; i < kNeFSCatalogNameLen; ++i) { - if (cat->Name[i] == 0) { null_found = true; break; } + if (!node) return false; + auto cat = reinterpret_cast(node); + switch (cat->Kind) { + case kNeFSCatalogKindFile: + case kNeFSCatalogKindDir: + case kNeFSCatalogKindAlias: + case kNeFSCatalogKindPage: + break; + default: + return false; + } + bool null_found = false; + for (int i = 0; i < kNeFSCatalogNameLen; ++i) { + if (cat->Name[i] == 0) { + null_found = true; + break; } - if (!null_found) return false; - return true; + } + if (!null_found) return false; + return true; } } // namespace Kernel diff --git a/tooling/fsck.hefs.cc b/tooling/fsck.hefs.cc index ce586b13..2898f09b 100644 --- a/tooling/fsck.hefs.cc +++ b/tooling/fsck.hefs.cc @@ -15,5 +15,7 @@ int main(int argc, char** argv) { return EXIT_FAILURE; } + (void)(argv); + return EXIT_SUCCESS; } \ No newline at end of file -- cgit v1.2.3 From 4f355d81c33e74a15d5fd01eddb3dbde508065b0 Mon Sep 17 00:00:00 2001 From: 0xf00sec <159052166+0xf00sec@users.noreply.github.com> Date: Wed, 4 Jun 2025 13:21:10 +0000 Subject: Sec: FS/Kernel filesystem & Kernel Offset/Buffer. --- dev/kernel/src/FS/NeFS+FileSystemParser.cc | 452 ++++++++++++++++------------- 1 file changed, 258 insertions(+), 194 deletions(-) (limited to 'dev/kernel/src/FS') diff --git a/dev/kernel/src/FS/NeFS+FileSystemParser.cc b/dev/kernel/src/FS/NeFS+FileSystemParser.cc index dd0a1d9a..875fe57b 100644 --- a/dev/kernel/src/FS/NeFS+FileSystemParser.cc +++ b/dev/kernel/src/FS/NeFS+FileSystemParser.cc @@ -46,11 +46,11 @@ Kernel::SizeT drv_std_get_size(); /***********************************************************************************/ /// This file implements the New extended File System. -/// New extended File System implements a flat linked-list based algortihm. -/// / -/// /Path1/ /Path2/ -/// /readme.rtf /ListContents.pef /readme.lnk <-- symlink. -/// /Path1/readme.rtf +/// New extended File System implements a flat linked-list based algortihm. +/// / +/// /Path1/ /Path2/ +/// /readme.rtf /ListContents.pef /readme.lnk <-- symlink. +/// /Path1/readme.rtf /***********************************************************************************/ STATIC MountpointInterface kMountpoint; @@ -71,14 +71,17 @@ _Output BOOL NeFileSystemParser::CreateFork(_Input NEFS_FORK_STRUCT& the_fork) { (Void)(kout << "Fork LBA: " << hex_number(lba) << kendl); - if (lba < kNeFSCatalogStartAddress) return NO; + 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; + NEFS_FORK_STRUCT prev_fork{}; + NEFS_FORK_STRUCT cur_fork{}; /// do not check for anything. Loop until we get what we want, that is a free fork zone. while (drv.fPacket.fPacketGood) { @@ -106,12 +109,11 @@ _Output BOOL NeFileSystemParser::CreateFork(_Input NEFS_FORK_STRUCT& the_fork) { /// This is a check that we have, in order to link the previous fork /// entry. if (lba >= kNeFSCatalogStartAddress) { + prev_fork.NextSibling = lba; drv.fPacket.fPacketLba = lba_prev; drv.fPacket.fPacketSize = sizeof(NEFS_FORK_STRUCT); drv.fPacket.fPacketContent = &prev_fork; - prev_fork.NextSibling = lba; - /// write to disk. drv.fOutput(drv.fPacket); } @@ -120,10 +122,14 @@ _Output BOOL NeFileSystemParser::CreateFork(_Input NEFS_FORK_STRUCT& the_fork) { } } - the_fork.Flags |= kNeFSFlagCreated; - the_fork.DataOffset = lba - sizeof(NEFS_FORK_STRUCT); + // Compute DataOffset and NextSibling properly. + // Metadata occupies exactly 1 sector at LBA 'lba' + // Data begins at lba+1 and spans ceil(DataSize/sectorSize) sectors + SizeT sectorCount = (the_fork.DataSize + kNeFSSectorSz - 1) / kNeFSSectorSz; + the_fork.DataOffset = lba + 1; the_fork.PreviousSibling = lba_prev; - the_fork.NextSibling = the_fork.DataOffset - the_fork.DataSize; + the_fork.NextSibling = lba + 1 + sectorCount; + the_fork.Flags |= kNeFSFlagCreated; drv.fPacket.fPacketLba = lba; drv.fPacket.fPacketSize = sizeof(NEFS_FORK_STRUCT); @@ -138,6 +144,7 @@ _Output BOOL NeFileSystemParser::CreateFork(_Input NEFS_FORK_STRUCT& the_fork) { (Void)(kout << "Wrote fork metadata at: " << hex_number(lba) << kendl); + delete catalog; return YES; } @@ -153,15 +160,16 @@ _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) { - auto& drive = kMountpoint.A(); - NEFS_FORK_STRUCT* the_fork = nullptr; + if (!catalog || !name) return nullptr; + auto& drive = kMountpoint.A(); Lba lba = is_data ? catalog->DataFork : catalog->ResourceFork; + NEFS_FORK_STRUCT local_buf{}; - while (lba != 0) { + while (lba >= kNeFSCatalogStartAddress) { drive.fPacket.fPacketLba = lba; drive.fPacket.fPacketSize = sizeof(NEFS_FORK_STRUCT); - drive.fPacket.fPacketContent = (VoidPtr) the_fork; + drive.fPacket.fPacketContent = &local_buf; rt_copy_memory((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime, 16); @@ -176,21 +184,23 @@ _Output NEFS_FORK_STRUCT* NeFileSystemParser::FindFork(_Input NEFS_CATALOG_STRUC case 3: err_global_get() = kErrorNoSuchDisk; break; - default: break; } return nullptr; } - if (KStringBuilder::Equals(the_fork->ForkName, name)) { - break; + if (KStringBuilder::Equals(local_buf.ForkName, name) && + KStringBuilder::Equals(local_buf.CatalogName, catalog->Name)) { + NEFS_FORK_STRUCT* result = new NEFS_FORK_STRUCT(); + rt_copy_memory(&local_buf, result, sizeof(NEFS_FORK_STRUCT)); + return result; } - lba = the_fork->NextSibling; + lba = local_buf.NextSibling; } - return the_fork; + return nullptr; } /***********************************************************************************/ @@ -215,18 +225,22 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char _Input const Int32& kind) { kout << "CreateCatalog(*...*)\r"; + if (!name) return nullptr; + SizeT nameLen = rt_string_len(name); + if (nameLen == 0) return nullptr; + Lba out_lba = 0UL; kout << "Checking for path separator...\r"; - /// a directory should have a slash in the end. + /// a dir should have a slash in the end. if (kind == kNeFSCatalogKindDir && - name[rt_string_len(name) - 1] != NeFileSystemHelper::Separator()) + name[nameLen - 1] != NeFileSystemHelper::Separator()) return nullptr; - /// a file shouldn't have a slash in the end. + /// a file shouldn't. if (kind != kNeFSCatalogKindDir && - name[rt_string_len(name) - 1] == NeFileSystemHelper::Separator()) + name[nameLen - 1] == NeFileSystemHelper::Separator()) return nullptr; NEFS_CATALOG_STRUCT* catalog_copy = this->FindCatalog(name, out_lba); @@ -241,32 +255,29 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char return nullptr; } - Char* parent_name = (Char*) mm_alloc_ptr(sizeof(Char) * rt_string_len(name), Yes, No); - - /// Locate parent catalog, to then allocate right after it. - - for (SizeT index_fill = 0; index_fill < rt_string_len(name); ++index_fill) { - parent_name[index_fill] = name[index_fill]; - } + Char* parent_name = (Char*) mm_alloc_ptr(nameLen + 1, Yes, No); + rt_copy_memory(name, parent_name, nameLen + 1); - if (*parent_name == 0) { - kout << "Parent name is NUL.\r"; + if (nameLen < 2) { + mm_free_ptr(parent_name); err_global_get() = kErrorFileNotFound; return nullptr; } - SizeT index_reverse_copy = rt_string_len(parent_name); - - // zero character it. - parent_name[--index_reverse_copy] = 0; - - // mandatory / character, zero it. - parent_name[--index_reverse_copy] = 0; - - while (parent_name[index_reverse_copy] != NeFileSystemHelper::Separator()) { + 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); @@ -292,7 +303,10 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char out_lba = blk_nefs->StartCatalog; } - if (drive.fPacket.fPacketReadOnly) return nullptr; + if (drive.fPacket.fPacketReadOnly) { + delete catalog; + return nullptr; + } NEFS_CATALOG_STRUCT* child_catalog = new NEFS_CATALOG_STRUCT(); @@ -306,7 +320,7 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char child_catalog->Flags |= kNeFSFlagCreated; child_catalog->CatalogFlags = flags; - SizeT i = rt_string_len(name); + SizeT i = nameLen; // get rid pf \0 --i; @@ -315,7 +329,7 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char while (name[i] != '/') --i; - rt_copy_memory((VoidPtr) (name + i), (VoidPtr) child_catalog->Name, rt_string_len(name)); + rt_copy_memory((VoidPtr) (name + i), (VoidPtr) child_catalog->Name, rt_string_len(name) - i); NEFS_CATALOG_STRUCT temporary_catalog{}; @@ -344,22 +358,31 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char delete child_catalog; child_catalog = nullptr; + delete catalog; return nullptr; } kout << "Start finding catalog to allocate or empty space...\r"; - while (start_free >= part_block->StartCatalog) { + SizeT catalogSectors = (sizeof(NEFS_CATALOG_STRUCT) + drive.fSectorSz - 1) / drive.fSectorSz; + // Iterate sector by sector + while (start_free < part_block->StartCatalog + (part_block->CatalogCount * catalogSectors)) { // ========================== // // Allocate catalog now... // ========================== // + drive.fPacket.fPacketContent = &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 + sizeof(NEFS_CATALOG_STRUCT); + // Write2link properly + child_catalog->NextSibling = start_free + catalogSectors; - drive.fPacket.fPacketContent = &temporary_catalog; + NEFS_CATALOG_STRUCT placeholder = {}; + drive.fPacket.fPacketContent = &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; @@ -368,21 +391,22 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char drive.fPacket.fPacketContent = child_catalog; drive.fPacket.fPacketSize = sizeof(NEFS_CATALOG_STRUCT); drive.fPacket.fPacketLba = start_free; - drive.fOutput(drive.fPacket); - // Get NeFS partition's block. - + // Update Theblock drive.fPacket.fPacketContent = buf_part_block; drive.fPacket.fPacketSize = sizeof(NEFS_ROOT_PARTITION_BLOCK); drive.fPacket.fPacketLba = kNeFSRootCatalogStartAddress; drive.fInput(drive.fPacket); - part_block->FreeSectors -= 1; + part_block->FreeSectors -= catalogSectors; part_block->CatalogCount += 1; part_block->FreeCatalog -= 1; + drive.fPacket.fPacketContent = part_block; + drive.fPacket.fPacketSize = sizeof(NEFS_ROOT_PARTITION_BLOCK); + drive.fPacket.fPacketLba = kNeFSRootCatalogStartAddress; drive.fOutput(drive.fPacket); delete catalog; @@ -391,23 +415,20 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char 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 = start_free + sizeof(NEFS_CATALOG_STRUCT); - - drive.fPacket.fPacketContent = &temporary_catalog; - drive.fPacket.fPacketSize = sizeof(NEFS_CATALOG_STRUCT); - drive.fPacket.fPacketLba = start_free; - - drive.fInput(drive.fPacket); + start_free += catalogSectors; } + delete child_catalog; delete catalog; return nullptr; } @@ -417,7 +438,7 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char /// @return If it was sucessful, see err_global_get(). bool NeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input const Int32 flags, const Char* part_name) { - if (*part_name == 0) return false; + if (!part_name || *part_name == 0) return false; NE_UNUSED(flags); @@ -455,19 +476,21 @@ bool NeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input const I rt_string_len(kNeFSUntitledHD)); SizeT sectorCount = drv_std_get_sector_count(); - SizeT diskSize = drv_std_get_size(); - - part_block->Version = kNeFSVersionInteger; + 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 + sizeof(NEFS_CATALOG_STRUCT); + part_block->StartCatalog = start + catalogSectors; part_block->Flags = 0UL; - part_block->CatalogCount = sectorCount / sizeof(NEFS_CATALOG_STRUCT); - part_block->FreeSectors = sectorCount / sizeof(NEFS_CATALOG_STRUCT) - 1; + part_block->CatalogCount = catalogEntries; + part_block->FreeCatalog = catalogEntries - 1; part_block->SectorCount = sectorCount; - part_block->DiskSize = diskSize; - part_block->SectorSize = drive->fSectorSz; - part_block->FreeCatalog = sectorCount / sizeof(NEFS_CATALOG_STRUCT) - 1; + part_block->DiskSize = totalBytes; + part_block->SectorSize = sectorSize; + part_block->FreeSectors = sectorCount - catalogSectors; drive->fPacket.fPacketContent = fs_buf; drive->fPacket.fPacketSize = sizeof(NEFS_ROOT_PARTITION_BLOCK); @@ -495,6 +518,25 @@ bool NeFileSystemParser::WriteCatalog(_Input const Char* catalog_name, Bool is_r _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 (!is_valid_size(size_of_data, is_rsrc_fork ? catalog->ResourceForkSize : catalog->DataForkSize)) { + kout << "NeFS: WriteCatalog called with invalid size: " << size_of_data << "\n"; + delete catalog; + return false; + } + auto startFork = (!is_rsrc_fork) ? catalog->DataFork : catalog->ResourceFork; + delete catalog; + + if (!is_valid_lba(startFork, drv_std_get_sector_count())) { + kout << "NeFS: WriteCatalog called with invalid LBA: " << startFork << "\n"; + return false; + } + auto buf = new UInt8[size_of_data]; rt_set_memory(buf, 0, size_of_data); @@ -505,25 +547,11 @@ bool NeFileSystemParser::WriteCatalog(_Input const Char* catalog_name, Bool is_r rt_copy_memory((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime, rt_string_len("fs/nefs-packet")); - auto catalog = this->GetCatalog(catalog_name); - - if (!catalog) { - delete[] buf; - buf = nullptr; - return NO; - } - - auto startFork = (!is_rsrc_fork) ? catalog->DataFork : catalog->ResourceFork; - - delete catalog; - catalog = nullptr; - NEFS_FORK_STRUCT* fork_data_input = new NEFS_FORK_STRUCT(); NEFS_FORK_STRUCT prev_fork{}; (Void)(kout << hex_number(startFork) << kendl); - // sanity check of the fork position as the condition to run the loop. while (startFork >= kNeFSCatalogStartAddress) { drive.fPacket.fPacketContent = fork_data_input; drive.fPacket.fPacketSize = sizeof(NEFS_FORK_STRUCT); @@ -543,27 +571,27 @@ bool NeFileSystemParser::WriteCatalog(_Input const Char* catalog_name, Bool is_r KStringBuilder::Equals(fork_data_input->ForkName, fork_name) && KStringBuilder::Equals(fork_data_input->CatalogName, catalog_name) && fork_data_input->DataSize == size_of_data) { + // ===================================================== // // Store the blob now, into chunks. // ===================================================== // - auto cnt = size_of_data / kNeFSSectorSz; - auto cnter = 0UL; - auto compute_sz = kNeFSSectorSz; + SizeT bytes_left = size_of_data; + SizeT offset = 0; + Lba base_lba = fork_data_input->DataOffset; - if (cnt < 1) break; + while (bytes_left > 0) { + SizeT chunk = (bytes_left > kNeFSSectorSz) ? kNeFSSectorSz : bytes_left; + drive.fPacket.fPacketContent = buf + offset; + drive.fPacket.fPacketSize = chunk; + drive.fPacket.fPacketLba = base_lba + (offset / kNeFSSectorSz); - while (compute_sz) { - drive.fPacket.fPacketContent = buf + (cnter * kNeFSSectorSz); - drive.fPacket.fPacketSize = compute_sz; - drive.fPacket.fPacketLba = fork_data_input->DataOffset; - - (Void)(kout << "data offset: " << hex_number(cnt * kNeFSSectorSz) << kendl); + (Void)(kout << "data offset: " << hex_number(offset) << kendl); drive.fOutput(drive.fPacket); - compute_sz /= (size_of_data / cnt); - ++cnter; + offset += chunk; + bytes_left -= chunk; } (Void)(kout << "wrote data at offset: " << hex_number(fork_data_input->DataOffset) << kendl); @@ -609,110 +637,79 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::FindCatalog(_Input const Char* auto start_catalog_lba = kNeFSCatalogStartAddress; - if (!KStringBuilder::Equals(catalog_name, NeFileSystemHelper::Root()) && local_search) { - Char parent_name[kNeFSCatalogNameLen] = {0}; - - for (SizeT indexFill = 0; indexFill < rt_string_len(catalog_name); ++indexFill) { - parent_name[indexFill] = catalog_name[indexFill]; - } - - SizeT indexReverseCopy = rt_string_len(parent_name); - - // zero character. - parent_name[--indexReverseCopy] = 0; + // 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{}; - // mandatory '/' character. - parent_name[--indexReverseCopy] = 0; + while (cursor >= part.StartCatalog && drive.fPacket.fPacketGood) { + drive.fPacket.fPacketLba = cursor; + drive.fPacket.fPacketContent = &tmp; + drive.fPacket.fPacketSize = sizeof(NEFS_CATALOG_STRUCT); - while (parent_name[indexReverseCopy] != NeFileSystemHelper::Separator()) { - parent_name[indexReverseCopy] = 0; - --indexReverseCopy; - } + drive.fInput(drive.fPacket); - NEFS_CATALOG_STRUCT* parent_catalog = this->FindCatalog(parent_name, out_lba); + 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 (parent_catalog && !KStringBuilder::Equals(parent_name, NeFileSystemHelper::Root())) { - start_catalog_lba = parent_catalog->NextSibling; + /// ignore unallocated catalog + if (!(tmp.Flags & kNeFSFlagCreated)) { + err_global_get() = kErrorFileNotFound; + return nullptr; + } - delete parent_catalog; - parent_catalog = nullptr; + (Void)(kout << "Found available catalog at: " << hex_number(cursor) << kendl); + (Void)(kout << "Found available catalog at: " << tmp.Name << kendl); - local_search = YES; - } else if (parent_catalog) { - start_catalog_lba = parent_catalog->NextSibling; + NEFS_CATALOG_STRUCT* catalog_ptr = new NEFS_CATALOG_STRUCT(); + rt_copy_memory(&tmp, catalog_ptr, sizeof(NEFS_CATALOG_STRUCT)); - local_search = YES; + out_lba = cursor; + return catalog_ptr; + } - delete parent_catalog; - parent_catalog = nullptr; - } else if (!parent_catalog) { - return nullptr; + cursor = tmp.NextSibling; } - } - - NEFS_CATALOG_STRUCT temporary_catalog{}; - - SizeT i = rt_string_len(catalog_name); - - // get rid of \0 - --i; - - if (catalog_name[i] == '/') --i; - - while (catalog_name[i] != '/') --i; - - const Char* tmp_name = (catalog_name + i); - -kNeFSSearchThroughCatalogList: - while (drive.fPacket.fPacketGood) { - drive.fPacket.fPacketLba = start_catalog_lba; - drive.fPacket.fPacketContent = &temporary_catalog; - drive.fPacket.fPacketSize = sizeof(NEFS_CATALOG_STRUCT); - - drive.fInput(drive.fPacket); - - if (KStringBuilder::Equals(tmp_name, temporary_catalog.Name)) { - if (temporary_catalog.Status == kNeFSStatusLocked && !search_hidden) { - err_global_get() = kErrorFileLocked; - - goto NeFSContinueSearch; - } - /// ignore unallocated catalog, break - if (!(temporary_catalog.Flags & kNeFSFlagCreated)) { - err_global_get() = kErrorFileNotFound; + return nullptr; + }; - goto NeFSContinueSearch; - } + if (!KStringBuilder::Equals(catalog_name, NeFileSystemHelper::Root()) && local_search) { + Char parent_name[kNeFSCatalogNameLen] = {0}; - (Void)(kout << "Found available catalog at: " << hex_number(start_catalog_lba) << kendl); - (Void)(kout << "Found available catalog at: " << temporary_catalog.Name << kendl); + SizeT nameLen = rt_string_len(catalog_name); + rt_copy_memory(catalog_name, parent_name, nameLen + 1); - NEFS_CATALOG_STRUCT* catalog_ptr = new NEFS_CATALOG_STRUCT(); - rt_copy_memory(&temporary_catalog, catalog_ptr, sizeof(NEFS_CATALOG_STRUCT)); + SizeT indexReverseCopy = nameLen - 1; - out_lba = start_catalog_lba; - return catalog_ptr; + if (parent_name[indexReverseCopy] == NeFileSystemHelper::Separator()) { + parent_name[indexReverseCopy] = 0; + --indexReverseCopy; } - NeFSContinueSearch: - start_catalog_lba = temporary_catalog.NextSibling; + while (indexReverseCopy > 0 && parent_name[indexReverseCopy] != NeFileSystemHelper::Separator()) { + parent_name[indexReverseCopy] = 0; + --indexReverseCopy; + } - if (start_catalog_lba < part.StartCatalog) break; - } + if (indexReverseCopy == 0 && parent_name[0] != NeFileSystemHelper::Separator()) { + return nullptr; + } - if (local_search) { - local_search = false; - start_catalog_lba = part.StartCatalog; + NEFS_CATALOG_STRUCT* parent_catalog = this->FindCatalog(parent_name, out_lba, search_hidden, NO); - goto kNeFSSearchThroughCatalogList; + 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; + } } - err_global_get() = kErrorFileNotFound; - - out_lba = 0UL; - - return nullptr; + return scan_from(part.StartCatalog, search_hidden); } /// @brief Get catalog from filesystem. @@ -720,7 +717,7 @@ kNeFSSearchThroughCatalogList: /// @return _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::GetCatalog(_Input const Char* name) { Lba unused = 0; - return this->FindCatalog(name, unused, YES); + return this->FindCatalog(name, unused, YES, YES); } /// @brief Closes a catalog, (frees it). @@ -745,23 +742,67 @@ _Output Boolean NeFileSystemParser::RemoveCatalog(_Input const Char* catalog_nam } Lba out_lba = 0; - auto catalog = this->FindCatalog(catalog_name, out_lba); + 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 = &fork_buf; + + drive.fInput(drive.fPacket); + + fork_buf.Flags &= (~kNeFSFlagCreated); + fork_buf.Flags |= kNeFSFlagDeleted; + + drive.fPacket.fPacketContent = &fork_buf; + drive.fPacket.fPacketSize = sizeof(fork_buf); + drive.fPacket.fPacketLba = fork_lba; + + drive.fOutput(drive.fPacket); + + fork_lba = fork_buf.NextSibling; + } + + // Free all my homies + fork_lba = catalog->ResourceFork; + while (fork_lba >= kNeFSCatalogStartAddress) { + drive.fPacket.fPacketLba = fork_lba; + drive.fPacket.fPacketSize = sizeof(fork_buf); + drive.fPacket.fPacketContent = &fork_buf; + + drive.fInput(drive.fPacket); + + fork_buf.Flags &= (~kNeFSFlagCreated); + fork_buf.Flags |= kNeFSFlagDeleted; + + drive.fPacket.fPacketContent = &fork_buf; + drive.fPacket.fPacketSize = sizeof(fork_buf); + drive.fPacket.fPacketLba = fork_lba; + + drive.fOutput(drive.fPacket); + + fork_lba = fork_buf.NextSibling; + } if (out_lba >= kNeFSCatalogStartAddress || catalog->Flags & kNeFSFlagCreated) { catalog->Flags &= (~kNeFSFlagCreated); catalog->Flags |= kNeFSFlagDeleted; - auto& drive = kMountpoint.A(); - rt_copy_memory((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime, rt_string_len("fs/nefs-packet")); - drive.fPacket.fPacketLba = out_lba; // the catalog position. + drive.fPacket.fPacketLba = out_lba; // position. drive.fPacket.fPacketSize = - sizeof(NEFS_CATALOG_STRUCT); // size of catalog. roughly the sector size. - drive.fPacket.fPacketContent = catalog; // the catalog itself. + sizeof(NEFS_CATALOG_STRUCT); // size + drive.fPacket.fPacketContent = catalog; // the cat ;) itself. - drive.fOutput(drive.fPacket); // send packet. + drive.fOutput(drive.fPacket); // send. Char partitionBlockBuf[sizeof(NEFS_ROOT_PARTITION_BLOCK)] = {0}; @@ -774,11 +815,18 @@ _Output Boolean NeFileSystemParser::RemoveCatalog(_Input const Char* catalog_nam NEFS_ROOT_PARTITION_BLOCK* part_block = reinterpret_cast(partitionBlockBuf); - --part_block->CatalogCount; + if (part_block->CatalogCount > 0) --part_block->CatalogCount; ++part_block->FreeSectors; + drive.fPacket.fPacketContent = part_block; + drive.fPacket.fPacketSize = sizeof(NEFS_ROOT_PARTITION_BLOCK); + drive.fPacket.fPacketLba = kNeFSRootCatalogStartAddress; + drive.fOutput(drive.fPacket); + delete catalog; + catalog = nullptr; + return true; } @@ -806,10 +854,17 @@ VoidPtr NeFileSystemParser::ReadCatalog(_Input _Output NEFS_CATALOG_STRUCT* cata err_global_get() = kErrorInvalidData; return nullptr; } - - NE_UNUSED(dataSz); - + // Validate size against fork size + if (!is_valid_size(dataSz, is_rsrc_fork ? catalog->ResourceForkSize : catalog->DataForkSize)) { + kout << "NeFS: ReadCatalog called with invalid size: " << dataSz << "\n"; + return nullptr; + } Lba dataForkLba = (!is_rsrc_fork) ? catalog->DataFork : catalog->ResourceFork; + // Validate LBA + if (!is_valid_lba(dataForkLba, drv_std_get_sector_count())) { + kout << "NeFS: ReadCatalog called with invalid LBA: " << dataForkLba << "\n"; + return nullptr; + } NEFS_FORK_STRUCT* fs_buf = new NEFS_FORK_STRUCT(); auto& drive = kMountpoint.A(); @@ -819,7 +874,7 @@ VoidPtr NeFileSystemParser::ReadCatalog(_Input _Output NEFS_CATALOG_STRUCT* cata NEFS_FORK_STRUCT* fs_fork_data = nullptr; - while (dataForkLba > kNeFSCatalogStartAddress) { + while (dataForkLba >= kNeFSCatalogStartAddress) { drive.fPacket.fPacketLba = dataForkLba; drive.fPacket.fPacketSize = sizeof(NEFS_FORK_STRUCT); drive.fPacket.fPacketContent = fs_buf; @@ -892,4 +947,13 @@ Boolean fs_init_nefs(Void) noexcept { } } // namespace Kernel::NeFS +static inline bool is_valid_lba(Lba lba, Lba maxLba) { + return lba >= kNeFSCatalogStartAddress && lba < maxLba; +} + +static inline bool is_valid_size(SizeT size, SizeT max_size) { + return size > 0 && size <= max_size; +} + #endif // ifdef __FSKIT_INCLUDES_NEFS__ + -- cgit v1.2.3 From 555e56e98f82fbb35881e6d15ef91e940817326e Mon Sep 17 00:00:00 2001 From: 0xf00sec <159052166+0xf00sec@users.noreply.github.com> Date: Wed, 4 Jun 2025 19:55:17 +0000 Subject: Fix --- dev/kernel/src/FS/NeFS+FileSystemParser.cc | 1256 +++++++++++++--------------- 1 file changed, 570 insertions(+), 686 deletions(-) (limited to 'dev/kernel/src/FS') diff --git a/dev/kernel/src/FS/NeFS+FileSystemParser.cc b/dev/kernel/src/FS/NeFS+FileSystemParser.cc index 875fe57b..152d9fc2 100644 --- a/dev/kernel/src/FS/NeFS+FileSystemParser.cc +++ b/dev/kernel/src/FS/NeFS+FileSystemParser.cc @@ -46,15 +46,35 @@ Kernel::SizeT drv_std_get_size(); /***********************************************************************************/ /// This file implements the New extended File System. -/// New extended File System implements a flat linked-list based algortihm. +/// New extended File System implements a flat linked-list based algorithm. /// / /// /Path1/ /Path2/ /// /readme.rtf /ListContents.pef /readme.lnk <-- symlink. /// /Path1/readme.rtf /***********************************************************************************/ +static inline bool is_valid_size(SizeT size, SizeT max_size) { + return size > 0 && size <= max_size; +} -STATIC MountpointInterface kMountpoint; +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(&part_block); + drive.fInput(drive.fPacket); + + if (!drive.fPacket.fPacketGood) { + return false; + } + + // Compute the maximum LBA (DiskSize / sector size) + SizeT sectorSize = drive.fSectorSz; + Lba maxLba = part_block.DiskSize / sectorSize; + + return (lba >= part_block.StartCatalog) && (lba < maxLba); +} +STATIC MountpointInterface kMountpoint; /***********************************************************************************/ /// @brief Creates a new fork inside the New filesystem partition. /// @param catalog it's catalog @@ -62,93 +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) { - auto catalog = this->GetCatalog(the_fork.CatalogName); + 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; Lba lba = catalog->DataFork; - - (Void)(kout << "Fork LBA: " << hex_number(lba) << kendl); - if (lba < kNeFSCatalogStartAddress) { - delete catalog; - return NO; + delete catalog; + return NO; } auto& drv = kMountpoint.A(); - - Lba lba_prev = lba; - + Lba lba_prev = lba; NEFS_FORK_STRUCT prev_fork{}; NEFS_FORK_STRUCT cur_fork{}; - /// do not check for anything. Loop until we get what we want, that is a free fork zone. - while (drv.fPacket.fPacketGood) { - drv.fPacket.fPacketLba = lba; - drv.fPacket.fPacketSize = sizeof(NEFS_FORK_STRUCT); - drv.fPacket.fPacketContent = &cur_fork; - - drv.fInput(drv.fPacket); - - (Void)(kout << "Next fork: " << hex_number(cur_fork.NextSibling) << kendl); - - if (cur_fork.Flags & kNeFSFlagCreated) { - kout << "Error: Fork does exists, not overwriting this one.\r"; - - /// sanity check. - 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 { - /// This is a check that we have, in order to link the previous fork - /// entry. - if (lba >= kNeFSCatalogStartAddress) { - prev_fork.NextSibling = lba; - drv.fPacket.fPacketLba = lba_prev; - drv.fPacket.fPacketSize = sizeof(NEFS_FORK_STRUCT); - drv.fPacket.fPacketContent = &prev_fork; - - /// write to disk. - drv.fOutput(drv.fPacket); + while (true) { + drv.fPacket.fPacketLba = lba; + drv.fPacket.fPacketSize = sizeof(NEFS_FORK_STRUCT); + drv.fPacket.fPacketContent = const_cast(&cur_fork); + drv.fInput(drv.fPacket); + if (!drv.fPacket.fPacketGood) { + delete catalog; + return NO; } - 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 = const_cast(&prev_fork); + drv.fOutput(drv.fPacket); + } + break; + } } - // Compute DataOffset and NextSibling properly. - // Metadata occupies exactly 1 sector at LBA 'lba' - // Data begins at lba+1 and spans ceil(DataSize/sectorSize) sectors - SizeT sectorCount = (the_fork.DataSize + kNeFSSectorSz - 1) / kNeFSSectorSz; - the_fork.DataOffset = lba + 1; - the_fork.PreviousSibling = lba_prev; - the_fork.NextSibling = lba + 1 + sectorCount; + 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 = &the_fork; - + drv.fPacket.fPacketContent = const_cast(&the_fork); drv.fOutput(drv.fPacket); fs_ifs_write(&kMountpoint, drv, MountpointInterface::kDriveIndexA); - /// log what we have now. - (Void)(kout << "Fork offset is at: " << hex_number(the_fork.DataOffset) << kendl); - - (Void)(kout << "Wrote fork metadata at: " << hex_number(lba) << kendl); - delete catalog; return YES; - } - - return NO; } /***********************************************************************************/ @@ -160,47 +156,39 @@ _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 = &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 (!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(&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)) { - NEFS_FORK_STRUCT* result = new NEFS_FORK_STRUCT(); - rt_copy_memory(&local_buf, result, sizeof(NEFS_FORK_STRUCT)); - return result; - } + 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; + } - lba = local_buf.NextSibling; - } + lba = local_buf.NextSibling; + } - return nullptr; + return nullptr; } /***********************************************************************************/ @@ -210,7 +198,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); } /***********************************************************************************/ @@ -223,617 +211,533 @@ _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 dir 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. - 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; + if (catalog_copy) { + kout << "Catalog already exists: " << name << ".\r"; + err_global_get() = kErrorFileExists; + delete catalog_copy; + catalog_copy = nullptr; + return nullptr; + } - delete catalog_copy; - catalog_copy = nullptr; + Char* parent_name = (Char*) mm_alloc_ptr(nameLen + 1, Yes, No); + rt_copy_memory(name, parent_name, nameLen + 1); - return nullptr; - } + if (nameLen < 2) { + mm_free_ptr(parent_name); + err_global_get() = kErrorFileNotFound; + return nullptr; + } - Char* parent_name = (Char*) mm_alloc_ptr(nameLen + 1, Yes, No); - rt_copy_memory(name, parent_name, nameLen + 1); + 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; + } - 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()) { + NEFS_CATALOG_STRUCT* catalog = this->FindCatalog(parent_name, out_lba); 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); - - auto& drive = kMountpoint.A(); - if (catalog && catalog->Kind == kNeFSCatalogKindFile) { - kout << "Parent is a file.\r"; - delete catalog; + 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(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; + } - return nullptr; - } else if (!catalog) { - Char part_block[sizeof(NEFS_ROOT_PARTITION_BLOCK)] = {0}; + if (drive.fPacket.fPacketReadOnly) { + delete catalog; + return nullptr; + } - drive.fPacket.fPacketContent = part_block; + 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(buf_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; - } - - 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; - - // get rid pf \0 - --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 = 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 = &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; - child_catalog = nullptr; - - delete catalog; - return nullptr; - } - - kout << "Start finding catalog to allocate or empty space...\r"; - - SizeT catalogSectors = (sizeof(NEFS_CATALOG_STRUCT) + drive.fSectorSz - 1) / drive.fSectorSz; - // Iterate sector by sector - while (start_free < part_block->StartCatalog + (part_block->CatalogCount * catalogSectors)) { - // ========================== // - // Allocate catalog now... - // ========================== // - drive.fPacket.fPacketContent = &temporary_catalog; + NEFS_ROOT_PARTITION_BLOCK* part_block = (NEFS_ROOT_PARTITION_BLOCK*) buf_part_block; + drive.fPacket.fPacketContent = const_cast(&temporary_catalog); drive.fPacket.fPacketSize = sizeof(NEFS_CATALOG_STRUCT); drive.fPacket.fPacketLba = start_free; drive.fInput(drive.fPacket); - if ((temporary_catalog.Flags & kNeFSFlagCreated) == 0) { - // Write2link properly - child_catalog->NextSibling = start_free + catalogSectors; - - NEFS_CATALOG_STRUCT placeholder = {}; - drive.fPacket.fPacketContent = &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 = child_catalog; - drive.fPacket.fPacketSize = sizeof(NEFS_CATALOG_STRUCT); - drive.fPacket.fPacketLba = start_free; - drive.fOutput(drive.fPacket); - - // Update Theblock - drive.fPacket.fPacketContent = 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 = part_block; - drive.fPacket.fPacketSize = sizeof(NEFS_ROOT_PARTITION_BLOCK); - drive.fPacket.fPacketLba = kNeFSRootCatalogStartAddress; - drive.fOutput(drive.fPacket); - - delete catalog; - catalog = nullptr; - - NEFS_CATALOG_STRUCT* found_catalog = new NEFS_CATALOG_STRUCT(); - rt_copy_memory(&temporary_catalog, found_catalog, sizeof(NEFS_CATALOG_STRUCT)); + if (part_block->FreeCatalog < 1) { + delete child_catalog; + delete catalog; + return nullptr; + } - 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)); + 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(&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(&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(child_catalog); + drive.fPacket.fPacketSize = sizeof(NEFS_CATALOG_STRUCT); + drive.fPacket.fPacketLba = start_free; + drive.fOutput(drive.fPacket); + + drive.fPacket.fPacketContent = const_cast(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(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; + } - 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; } +/***********************************************************************************/ /// @brief Make a EPM+NeFS drive out of the disk. /// @param drive The drive to write on. /// @return If it was sucessful, see err_global_get(). +/***********************************************************************************/ 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 disk isn't good, then error out. - if (false == 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 = 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 = fs_buf; - drive->fPacket.fPacketSize = sizeof(NEFS_ROOT_PARTITION_BLOCK); - drive->fPacket.fPacketLba = start; - - drive->fOutput(drive->fPacket); + 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; + } - (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); + Char fs_buf[sizeof(NEFS_ROOT_PARTITION_BLOCK)] = {0}; + Lba start = drive->fLbaStart; + + drive->fPacket.fPacketContent = const_cast(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(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; + return true; } +/***********************************************************************************/ /// @brief Writes the data fork into a specific catalog. /// @param catalog the catalog itself /// @param data the data. -/// @return if the catalog w rote the contents successfully. -bool NeFileSystemParser::WriteCatalog(_Input const Char* catalog_name, Bool is_rsrc_fork, - _Input VoidPtr data, _Input SizeT size_of_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, _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 (!is_valid_size(size_of_data, is_rsrc_fork ? catalog->ResourceForkSize : catalog->DataForkSize)) { - kout << "NeFS: WriteCatalog called with invalid size: " << size_of_data << "\n"; - delete catalog; - return false; - } - auto startFork = (!is_rsrc_fork) ? catalog->DataFork : catalog->ResourceFork; - delete catalog; - - if (!is_valid_lba(startFork, drv_std_get_sector_count())) { - kout << "NeFS: WriteCatalog called with invalid LBA: " << startFork << "\n"; - return false; - } - - auto buf = new UInt8[size_of_data]; - rt_set_memory(buf, 0, size_of_data); - - rt_copy_memory(data, buf, size_of_data); - - auto& drive = kMountpoint.A(); + if (size_of_data < 1) return NO; - rt_copy_memory((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime, - rt_string_len("fs/nefs-packet")); + auto catalog = this->GetCatalog(catalog_name); + if (!catalog) { + kout << "NeFS: WriteCatalog failed to find catalog: " << catalog_name << "\n"; + return false; + } - NEFS_FORK_STRUCT* fork_data_input = new NEFS_FORK_STRUCT(); - NEFS_FORK_STRUCT prev_fork{}; + 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; + } - (Void)(kout << hex_number(startFork) << kendl); + Lba startFork = is_rsrc_fork ? catalog->ResourceFork : catalog->DataFork; + auto& drive = kMountpoint.A(); - while (startFork >= kNeFSCatalogStartAddress) { - drive.fPacket.fPacketContent = fork_data_input; - drive.fPacket.fPacketSize = sizeof(NEFS_FORK_STRUCT); - drive.fPacket.fPacketLba = startFork; + if (!is_valid_lba(startFork, drive)) { + kout << "NeFS: WriteCatalog called with invalid LBA: " << startFork << "\n"; + delete catalog; + return false; + } + NEFS_ROOT_PARTITION_BLOCK part_block; + drive.fPacket.fPacketLba = kNeFSRootCatalogStartAddress; + drive.fPacket.fPacketSize = sizeof(part_block); + drive.fPacket.fPacketContent = const_cast(&part_block); drive.fInput(drive.fPacket); - (Void)(kout << hex_number(fork_data_input->DataSize) << kendl); - (Void)(kout << hex_number(size_of_data) << kendl); - (Void)(kout << hex_number(fork_data_input->Flags) << kendl); - (Void)(kout << fork_name << kendl); - (Void)(kout << fork_data_input->ForkName << kendl); - (Void)(kout << fork_data_input->CatalogName << kendl); - (Void)(kout << catalog_name << kendl); - - 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) { - - // ===================================================== // - // Store the blob now, into chunks. - // ===================================================== // - - 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 = buf + offset; - drive.fPacket.fPacketSize = chunk; - drive.fPacket.fPacketLba = base_lba + (offset / kNeFSSectorSz); - - (Void)(kout << "data offset: " << hex_number(offset) << kendl); + 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")); - drive.fOutput(drive.fPacket); + NEFS_FORK_STRUCT* fork_data_input = new NEFS_FORK_STRUCT(); + NEFS_FORK_STRUCT prev_fork{}; - offset += chunk; - bytes_left -= chunk; - } + while (startFork >= part_block.StartCatalog && drive.fPacket.fPacketGood) { + drive.fPacket.fPacketContent = const_cast(fork_data_input); + drive.fPacket.fPacketSize = sizeof(NEFS_FORK_STRUCT); + drive.fPacket.fPacketLba = startFork; + drive.fInput(drive.fPacket); - (Void)(kout << "wrote data at offset: " << hex_number(fork_data_input->DataOffset) << kendl); + if (!drive.fPacket.fPacketGood) { + break; + } - delete fork_data_input; - delete[] buf; + 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(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; + } - return true; + prev_fork = *fork_data_input; + startFork = fork_data_input->NextSibling; } - // stumble upon a fork, store it. - - prev_fork = *fork_data_input; - - startFork = fork_data_input->NextSibling; - } - - delete[] buf; - delete fork_data_input; - - return false; + delete fork_data_input; + delete[] buf; + delete catalog; + return false; } +/***********************************************************************************/ /// @brief /// @param catalog_name the 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 = ∂ - drive.fPacket.fPacketSize = sizeof(NEFS_ROOT_PARTITION_BLOCK); - drive.fPacket.fPacketLba = kNeFSRootCatalogStartAddress; - - drive.fInput(drive.fPacket); - - auto start_catalog_lba = kNeFSCatalogStartAddress; + if (!catalog_name || *catalog_name == 0) return nullptr; - // 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{}; + NEFS_ROOT_PARTITION_BLOCK part{}; + auto& drive = kMountpoint.A(); - while (cursor >= part.StartCatalog && drive.fPacket.fPacketGood) { - drive.fPacket.fPacketLba = cursor; - drive.fPacket.fPacketContent = &tmp; - drive.fPacket.fPacketSize = sizeof(NEFS_CATALOG_STRUCT); - - drive.fInput(drive.fPacket); + rt_copy_memory((VoidPtr)"fs/nefs-packet", drive.fPacket.fPacketMime, rt_string_len("fs/nefs-packet")); + drive.fPacket.fPacketContent = const_cast(&part); + drive.fPacket.fPacketSize = sizeof(NEFS_ROOT_PARTITION_BLOCK); + drive.fPacket.fPacketLba = kNeFSRootCatalogStartAddress; + 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; + 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(&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; } - - /// ignore unallocated catalog - if (!(tmp.Flags & kNeFSFlagCreated)) { - err_global_get() = kErrorFileNotFound; - return nullptr; + 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; + } + while (indexReverseCopy > 0 && parent_name[indexReverseCopy] != NeFileSystemHelper::Separator()) { + parent_name[indexReverseCopy] = 0; + --indexReverseCopy; + } + if (indexReverseCopy == 0 && parent_name[0] != NeFileSystemHelper::Separator()) { + return nullptr; } - (Void)(kout << "Found available catalog at: " << hex_number(cursor) << kendl); - (Void)(kout << "Found available catalog at: " << tmp.Name << kendl); - - 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; - } - - 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; + 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); } +/***********************************************************************************/ /// @brief Get catalog from filesystem. /// @param name the catalog's name/ /// @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); } +/***********************************************************************************/ /// @brief Closes a catalog, (frees it). /// @param catalog the catalog to close. /// @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; } +/***********************************************************************************/ /// @brief Mark catalog as removed. /// @param catalog The catalog structure. /// @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; - } - - 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 = &fork_buf; - - drive.fInput(drive.fPacket); - - fork_buf.Flags &= (~kNeFSFlagCreated); - fork_buf.Flags |= kNeFSFlagDeleted; - - drive.fPacket.fPacketContent = &fork_buf; - drive.fPacket.fPacketSize = sizeof(fork_buf); - drive.fPacket.fPacketLba = fork_lba; - - drive.fOutput(drive.fPacket); - - fork_lba = fork_buf.NextSibling; - } - - // Free all my homies - fork_lba = catalog->ResourceFork; - while (fork_lba >= kNeFSCatalogStartAddress) { - drive.fPacket.fPacketLba = fork_lba; - drive.fPacket.fPacketSize = sizeof(fork_buf); - drive.fPacket.fPacketContent = &fork_buf; - - drive.fInput(drive.fPacket); - - fork_buf.Flags &= (~kNeFSFlagCreated); - fork_buf.Flags |= kNeFSFlagDeleted; - - drive.fPacket.fPacketContent = &fork_buf; - drive.fPacket.fPacketSize = sizeof(fork_buf); - drive.fPacket.fPacketLba = fork_lba; - - drive.fOutput(drive.fPacket); + if (!catalog_name || KStringBuilder::Equals(catalog_name, NeFileSystemHelper::Root())) { + err_global_get() = kErrorInternal; + return false; + } - fork_lba = fork_buf.NextSibling; - } + 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(&fork_buf); + drive.fInput(drive.fPacket); + + fork_buf.Flags &= (~kNeFSFlagCreated); + fork_buf.Flags |= kNeFSFlagDeleted; + + drive.fPacket.fPacketContent = const_cast(&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")); + fork_lba = catalog->ResourceFork; + while (fork_lba >= kNeFSCatalogStartAddress) { + drive.fPacket.fPacketLba = fork_lba; + drive.fPacket.fPacketSize = sizeof(fork_buf); + drive.fPacket.fPacketContent = const_cast(&fork_buf); + drive.fInput(drive.fPacket); - drive.fPacket.fPacketLba = out_lba; // position. - drive.fPacket.fPacketSize = - sizeof(NEFS_CATALOG_STRUCT); // size - drive.fPacket.fPacketContent = catalog; // the cat ;) itself. + fork_buf.Flags &= (~kNeFSFlagCreated); + fork_buf.Flags |= kNeFSFlagDeleted; - drive.fOutput(drive.fPacket); // send. + drive.fPacket.fPacketContent = const_cast(&fork_buf); + drive.fPacket.fPacketSize = sizeof(fork_buf); + drive.fPacket.fPacketLba = fork_lba; + drive.fOutput(drive.fPacket); - Char partitionBlockBuf[sizeof(NEFS_ROOT_PARTITION_BLOCK)] = {0}; + fork_lba = fork_buf.NextSibling; + } - drive.fPacket.fPacketLba = kNeFSRootCatalogStartAddress; - drive.fPacket.fPacketContent = partitionBlockBuf; - drive.fPacket.fPacketSize = sizeof(NEFS_ROOT_PARTITION_BLOCK); + if (out_lba >= kNeFSCatalogStartAddress || (catalog->Flags & kNeFSFlagCreated)) { + catalog->Flags &= (~kNeFSFlagCreated); + catalog->Flags |= kNeFSFlagDeleted; - 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 = const_cast(catalog); + drive.fOutput(drive.fPacket); - NEFS_ROOT_PARTITION_BLOCK* part_block = - reinterpret_cast(partitionBlockBuf); + Char partitionBlockBuf[sizeof(NEFS_ROOT_PARTITION_BLOCK)] = {0}; + drive.fPacket.fPacketLba = kNeFSRootCatalogStartAddress; + drive.fPacket.fPacketContent = const_cast(partitionBlockBuf); + drive.fPacket.fPacketSize = sizeof(NEFS_ROOT_PARTITION_BLOCK); + drive.fInput(drive.fPacket); - if (part_block->CatalogCount > 0) --part_block->CatalogCount; - ++part_block->FreeSectors; + NEFS_ROOT_PARTITION_BLOCK* part_block = (NEFS_ROOT_PARTITION_BLOCK*)partitionBlockBuf; + if (part_block->CatalogCount > 0) --part_block->CatalogCount; + ++part_block->FreeSectors; - drive.fPacket.fPacketContent = part_block; - drive.fPacket.fPacketSize = sizeof(NEFS_ROOT_PARTITION_BLOCK); - drive.fPacket.fPacketLba = kNeFSRootCatalogStartAddress; + drive.fPacket.fPacketContent = const_cast(part_block); + drive.fPacket.fPacketSize = sizeof(NEFS_ROOT_PARTITION_BLOCK); + drive.fPacket.fPacketLba = kNeFSRootCatalogStartAddress; + drive.fOutput(drive.fPacket); - drive.fOutput(drive.fPacket); + delete catalog; + catalog = nullptr; + return true; + } delete catalog; catalog = nullptr; - - return true; - } - - delete catalog; - catalog = nullptr; - - return false; + return false; } /// ***************************************************************** /// @@ -846,59 +750,56 @@ _Output Boolean NeFileSystemParser::RemoveCatalog(_Input const Char* catalog_nam /// @param dataSz /// @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 - if (!is_valid_size(dataSz, is_rsrc_fork ? catalog->ResourceForkSize : catalog->DataForkSize)) { - kout << "NeFS: ReadCatalog called with invalid size: " << dataSz << "\n"; - return nullptr; - } - Lba dataForkLba = (!is_rsrc_fork) ? catalog->DataFork : catalog->ResourceFork; - // Validate LBA - if (!is_valid_lba(dataForkLba, drv_std_get_sector_count())) { - kout << "NeFS: ReadCatalog called with invalid LBA: " << dataForkLba << "\n"; - return nullptr; - } - - NEFS_FORK_STRUCT* fs_buf = new NEFS_FORK_STRUCT(); - auto& drive = kMountpoint.A(); - - 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 = fs_buf; - - drive.fInput(drive.fPacket); + _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; + } - fs_fork_data = fs_buf; + 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; + } - (Void)(kout << "ForkName: " << fs_fork_data->ForkName << kendl); - (Void)(kout << "CatalogName: " << fs_fork_data->CatalogName << kendl); + auto* fs_buf = new NEFS_FORK_STRUCT(); + rt_copy_memory((VoidPtr)"fs/nefs-packet", drive.fPacket.fPacketMime, 16); - if (KStringBuilder::Equals(forkName, fs_fork_data->ForkName) && - KStringBuilder::Equals(catalog->Name, fs_fork_data->CatalogName)) - break; + 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(fs_buf); + drive.fInput(drive.fPacket); - dataForkLba = fs_fork_data->NextSibling; - } + fs_fork_data = fs_buf; + (Void)(kout << "ForkName: " << fs_fork_data->ForkName << kendl); + (Void)(kout << "CatalogName: " << fs_fork_data->CatalogName << kendl); - if (dataForkLba < kNeFSCatalogStartAddress) { - delete fs_buf; - return nullptr; - } + if (KStringBuilder::Equals(forkName, fs_fork_data->ForkName) && + KStringBuilder::Equals(catalog->Name, fs_fork_data->CatalogName)) + { + break; + } + dataForkLba = fs_fork_data->NextSibling; + } - return fs_fork_data; + if (dataForkLba < kNeFSCatalogStartAddress) { + delete fs_buf; + return nullptr; + } + return fs_fork_data; } /***********************************************************************************/ @@ -907,13 +808,11 @@ VoidPtr NeFileSystemParser::ReadCatalog(_Input _Output NEFS_CATALOG_STRUCT* cata /// @param off where to seek. /// @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; } /***********************************************************************************/ @@ -921,12 +820,10 @@ bool NeFileSystemParser::Seek(_Input _Output NEFS_CATALOG_STRUCT* catalog, SizeT /// @param catalog /// @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 { @@ -934,26 +831,13 @@ 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 -static inline bool is_valid_lba(Lba lba, Lba maxLba) { - return lba >= kNeFSCatalogStartAddress && lba < maxLba; -} - -static inline bool is_valid_size(SizeT size, SizeT max_size) { - return size > 0 && size <= max_size; -} - #endif // ifdef __FSKIT_INCLUDES_NEFS__ - -- cgit v1.2.3 From f2a01afadefd3a85f1254f568d7df3b11502cd42 Mon Sep 17 00:00:00 2001 From: 0xf00sec <159052166+0xf00sec@users.noreply.github.com> Date: Wed, 4 Jun 2025 20:18:18 +0000 Subject: Fixx --- dev/kernel/src/FS/NeFS+FileSystemParser.cc | 1173 ++++++++++++++-------------- 1 file changed, 597 insertions(+), 576 deletions(-) (limited to 'dev/kernel/src/FS') 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(&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(&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(&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(&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(&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(&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(&the_fork); - drv.fOutput(drv.fPacket); + drv.fPacket.fPacketLba = lba; + drv.fPacket.fPacketSize = sizeof(NEFS_FORK_STRUCT); + drv.fPacket.fPacketContent = reinterpret_cast(&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(&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(&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(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(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(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(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(&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(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(&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(&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(&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(child_catalog); + drive.fPacket.fPacketSize = sizeof(NEFS_CATALOG_STRUCT); + drive.fPacket.fPacketLba = start_free; + drive.fOutput(drive.fPacket); + + drive.fPacket.fPacketContent = reinterpret_cast(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(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(&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(&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(child_catalog); - drive.fPacket.fPacketSize = sizeof(NEFS_CATALOG_STRUCT); - drive.fPacket.fPacketLba = start_free; - drive.fOutput(drive.fPacket); - - drive.fPacket.fPacketContent = const_cast(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(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(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(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(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(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(&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(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(&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(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(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(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(&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(&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(&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(&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(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(&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(&fork_buf); - drive.fInput(drive.fPacket); - - fork_buf.Flags &= (~kNeFSFlagCreated); - fork_buf.Flags |= kNeFSFlagDeleted; - - drive.fPacket.fPacketContent = const_cast(&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(&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(&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(&fork_buf); + drive.fInput(drive.fPacket); - drive.fPacket.fPacketContent = const_cast(&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(&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(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(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(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(partitionBlockBuf); + drive.fPacket.fPacketSize = sizeof(NEFS_ROOT_PARTITION_BLOCK); + drive.fInput(drive.fPacket); - drive.fPacket.fPacketContent = const_cast(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(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(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(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 -- cgit v1.2.3 From dbf1190718c1a5adb4b2dc56e4d6da45429bb65e Mon Sep 17 00:00:00 2001 From: Amlal El Mahrouss Date: Fri, 6 Jun 2025 21:05:55 +0200 Subject: feat: The `APM` HW protocol implementation got improvements (ARM64) fix: BootNet: be more descriptive when trying to flash from network, and it fails. Signed-off-by: Amlal El Mahrouss --- dev/boot/amd64-ci.make | 2 +- dev/boot/amd64-desktop.make | 2 +- dev/boot/modules/BootNet/BootNet.cc | 4 ++-- dev/boot/src/BootloaderRsrc.rsrc | 25 ---------------------- dev/boot/src/boot_rsrc.rsrc | 25 ++++++++++++++++++++++ dev/kernel/HALKit/AMD64/HalApplicationProcessor.cc | 2 +- dev/kernel/HALKit/ARM64/APM/APM+IO.cc | 4 ++-- dev/kernel/HALKit/ARM64/HalACPIFactoryInterface.cc | 4 ++-- dev/kernel/SwapKit/DiskSwap.h | 12 +++++------ dev/kernel/kernel_rsrc.rsrc | 4 ++-- dev/kernel/src/FS/HeFS+FileSystemParser.cc | 8 +++---- dev/modules/APM/APM.h | 8 +------ 12 files changed, 47 insertions(+), 53 deletions(-) delete mode 100644 dev/boot/src/BootloaderRsrc.rsrc create mode 100644 dev/boot/src/boot_rsrc.rsrc (limited to 'dev/kernel/src/FS') diff --git a/dev/boot/amd64-ci.make b/dev/boot/amd64-ci.make index 0715151c..f4f76a59 100644 --- a/dev/boot/amd64-ci.make +++ b/dev/boot/amd64-ci.make @@ -98,7 +98,7 @@ endif .PHONY: compile-amd64 compile-amd64: - $(WINDRES) src/BootloaderRsrc.rsrc -O coff -o BootloaderRsrc.o + $(WINDRES) src/boot_rsrc.rsrc -O coff -o boot_rsrc.o $(CC_GNU) $(NE_MODEL) $(STANDALONE_MACRO) $(FLAG_GNU) $(DEBUG) \ $(wildcard src/HEL/AMD64/*.cc) \ $(wildcard src/HEL/AMD64/*.S) \ diff --git a/dev/boot/amd64-desktop.make b/dev/boot/amd64-desktop.make index d7515367..2e487f94 100644 --- a/dev/boot/amd64-desktop.make +++ b/dev/boot/amd64-desktop.make @@ -108,7 +108,7 @@ endif .PHONY: compile-amd64 compile-amd64: - $(WINDRES) src/BootloaderRsrc.rsrc -O coff -o BootloaderRsrc.o + $(WINDRES) src/boot_rsrc.rsrc -O coff -o boot_rsrc.o $(CC_GNU) $(NE_MODEL) $(STANDALONE_MACRO) $(FLAG_GNU) $(DEBUG) \ $(wildcard src/HEL/AMD64/*.cc) \ $(wildcard src/HEL/AMD64/*.S) \ diff --git a/dev/boot/modules/BootNet/BootNet.cc b/dev/boot/modules/BootNet/BootNet.cc index ba9beef4..c91460cb 100644 --- a/dev/boot/modules/BootNet/BootNet.cc +++ b/dev/boot/modules/BootNet/BootNet.cc @@ -48,7 +48,7 @@ EXTERN_C Int32 BootNetModuleMain(Kernel::HEL::BootInfoHeader* handover) { Boot::BootThread thread(inet_out->Data); if (thread.IsValid()) { - writer.Write("BootNet: Running kernel...\r"); + writer.Write("BootNet: Running NeKernel...\r"); return thread.Start(handover, YES); } @@ -57,7 +57,7 @@ EXTERN_C Int32 BootNetModuleMain(Kernel::HEL::BootInfoHeader* handover) { constexpr auto kROMSize = 0x200; if (inet_out->Length > kROMSize) { - writer.Write("BootNet: Not within 512K.\r"); + writer.Write("BootNet: Not within 512K, won't flash EEPROM.\r"); return kEfiFail; } diff --git a/dev/boot/src/BootloaderRsrc.rsrc b/dev/boot/src/BootloaderRsrc.rsrc deleted file mode 100644 index 33bce7f7..00000000 --- a/dev/boot/src/BootloaderRsrc.rsrc +++ /dev/null @@ -1,25 +0,0 @@ -#include "../../kernel/CompilerKit/Version.h" - -1 VERSIONINFO -FILEVERSION 1,0,0,0 -PRODUCTVERSION 1,0,0,0 -BEGIN - BLOCK "StringFileInfo" - BEGIN - BLOCK "080904E4" - BEGIN - VALUE "CompanyName", "Amlal El Mahrouss" - VALUE "FileDescription", "NeKernel OS Loader." - VALUE "FileVersion", BOOTLOADER_VERSION - VALUE "InternalName", "bootz" - VALUE "LegalCopyright", "Copyright (C) 2024, Amlal El Mahrouss all rights reserved." - VALUE "OriginalFilename", "ne_bootz" - VALUE "ProductName", "bootz" - VALUE "ProductVersion", BOOTLOADER_VERSION - END - END - BLOCK "VarFileInfo" - BEGIN - VALUE "Translation", 0x809, 1252 - END -END diff --git a/dev/boot/src/boot_rsrc.rsrc b/dev/boot/src/boot_rsrc.rsrc new file mode 100644 index 00000000..fedbdee0 --- /dev/null +++ b/dev/boot/src/boot_rsrc.rsrc @@ -0,0 +1,25 @@ +#include "../../kernel/CompilerKit/Version.h" + +1 VERSIONINFO +FILEVERSION 1,0,0,0 +PRODUCTVERSION 1,0,0,0 +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "080904E4" + BEGIN + VALUE "CompanyName", "Amlal El Mahrouss" + VALUE "FileDescription", "NeKernel OS Loader." + VALUE "FileVersion", BOOTLOADER_VERSION + VALUE "InternalName", "bootz" + VALUE "LegalCopyright", "Copyright (C) 2024-2025, Amlal El Mahrouss all rights reserved." + VALUE "OriginalFilename", "ne_bootz" + VALUE "ProductName", "bootz" + VALUE "ProductVersion", BOOTLOADER_VERSION + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x809, 1252 + END +END diff --git a/dev/kernel/HALKit/AMD64/HalApplicationProcessor.cc b/dev/kernel/HALKit/AMD64/HalApplicationProcessor.cc index 24a81af9..aeaeff52 100644 --- a/dev/kernel/HALKit/AMD64/HalApplicationProcessor.cc +++ b/dev/kernel/HALKit/AMD64/HalApplicationProcessor.cc @@ -216,7 +216,7 @@ Void mp_init_cores(VoidPtr vendor_ptr) noexcept { kout << "Kind: LAPIC: OFF\r"; } } else { - kout << "Kind: UNKNOWN\r"; + kout << "Kind: UNKNOWN: OFF\r"; } entry_ptr += length; diff --git a/dev/kernel/HALKit/ARM64/APM/APM+IO.cc b/dev/kernel/HALKit/ARM64/APM/APM+IO.cc index 3df8a407..e58fb782 100644 --- a/dev/kernel/HALKit/ARM64/APM/APM+IO.cc +++ b/dev/kernel/HALKit/ARM64/APM/APM+IO.cc @@ -9,11 +9,11 @@ using namespace Kernel; -/// @brief Send APM command to it's space. +/// @brief Send APM command to it's IO space. /// @param base_dma the IO base port. /// @param cmd the command. /// @return status code. -EXTERN_C Int32 apm_send_io_command(UInt16 cmd, APMPowerCmd value) { +EXTERN_C Int32 apm_send_io_command(UInt16 cmd) { switch (cmd) { case kAPMPowerCommandReboot: { asm volatile( diff --git a/dev/kernel/HALKit/ARM64/HalACPIFactoryInterface.cc b/dev/kernel/HALKit/ARM64/HalACPIFactoryInterface.cc index dc883239..fa678494 100644 --- a/dev/kernel/HALKit/ARM64/HalACPIFactoryInterface.cc +++ b/dev/kernel/HALKit/ARM64/HalACPIFactoryInterface.cc @@ -14,13 +14,13 @@ namespace Kernel { ACPIFactoryInterface::ACPIFactoryInterface(VoidPtr rsp_ptr) : fRsdp(rsp_ptr), fEntries(0) {} BOOL ACPIFactoryInterface::Shutdown() { - apm_send_io_command(kAPMPowerCommandShutdown, 0); + apm_send_io_command(kAPMPowerCommandShutdown); return NO; } /// @brief Reboot machine in either ACPI or by triple faulting. /// @return nothing it's a reboot. Void ACPIFactoryInterface::Reboot() { - apm_send_io_command(kAPMPowerCommandReboot, 0); + apm_send_io_command(kAPMPowerCommandReboot); } } // namespace Kernel diff --git a/dev/kernel/SwapKit/DiskSwap.h b/dev/kernel/SwapKit/DiskSwap.h index 1a0536c9..674524c8 100644 --- a/dev/kernel/SwapKit/DiskSwap.h +++ b/dev/kernel/SwapKit/DiskSwap.h @@ -35,21 +35,21 @@ class DiskSwapInterface final { public: /***********************************************************************************/ /// @brief Write memory chunk onto disk. - /// @param fork_name The swap name to recognize this memory region. - /// @param fork_name_len length of fork name. + /// @param name The swap name to recognize this memory region. + /// @param name_len length of fork name. /// @param data the data packet. /// @return Whether the swap was written to disk, or not. /***********************************************************************************/ - BOOL Write(const Char* fork_name, SizeT fork_name_len, SWAP_DISK_HEADER* data); + BOOL Write(const Char* name, SizeT name_len, SWAP_DISK_HEADER* data); /***********************************************************************************/ /// @brief Read memory chunk from disk. - /// @param fork_name The swap name to recognize this memory region. - /// @param fork_name_len length of fork name. + /// @param name The swap name to recognize this memory region. + /// @param name_len length of fork name. /// @param data the data packet length. /// @return Whether the swap was fetched to disk, or not. /***********************************************************************************/ - _Output SWAP_DISK_HEADER* Read(const Char* fork_name, SizeT fork_name_len, SizeT data_len); + _Output SWAP_DISK_HEADER* Read(const Char* name, SizeT name_len, SizeT data_len); }; /// @brief Swap disk header, containing information about the held virtual memory. diff --git a/dev/kernel/kernel_rsrc.rsrc b/dev/kernel/kernel_rsrc.rsrc index 5b1cb14f..a785a311 100644 --- a/dev/kernel/kernel_rsrc.rsrc +++ b/dev/kernel/kernel_rsrc.rsrc @@ -9,9 +9,9 @@ BEGIN BLOCK "080904E4" BEGIN VALUE "CompanyName", "Amlal El Mahrouss" - VALUE "FileDescription", "NeKernel" + VALUE "FileDescription", "NeKernel" VALUE "FileVersion", KERNEL_VERSION - VALUE "InternalName", "krnl" + VALUE "InternalName", "ne_kernel" VALUE "LegalCopyright", "(c) 2024-2025 Amlal El Mahrouss, all rights reserved." VALUE "OriginalFilename", "ne_kernel" VALUE "ProductName", "NeKernel" diff --git a/dev/kernel/src/FS/HeFS+FileSystemParser.cc b/dev/kernel/src/FS/HeFS+FileSystemParser.cc index 893f43ef..bfd38f69 100644 --- a/dev/kernel/src/FS/HeFS+FileSystemParser.cc +++ b/dev/kernel/src/FS/HeFS+FileSystemParser.cc @@ -1,6 +1,6 @@ /* ------------------------------------------- - Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved. + Copyright (C) 2024-2025 Amlal El Mahrouss, all rights reserved. ------------------------------------------- */ @@ -758,8 +758,8 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c } if (drv_std_get_size() < kHeFSMinimumDiskSize) { - (Void)(kout << "HeFS recommends at least 128 GiB of free space." << kendl); - (Void)(kout << "The OS will still try to format a HeFS disk here." << kendl); + (Void)(kout << "OpenHeFS recommends at least 128 GiB of free space." << kendl); + (Void)(kout << "The OS will still try to format a HeFS disk here anyway, don't expect perfect geometry." << kendl); } HEFS_BOOT_NODE* boot = (HEFS_BOOT_NODE*) RTL_ALLOCA(sizeof(HEFS_BOOT_NODE)); @@ -1142,7 +1142,7 @@ STATIC DriveTrait kMountPoint; /// @brief Initialize the HeFS filesystem. /// @return To check its status, see err_local_get(). Boolean HeFS::fs_init_hefs(Void) noexcept { - kout << "Creating HeFS disk...\r"; + kout << "Verifying disk...\r"; kMountPoint = io_construct_main_drive(); diff --git a/dev/modules/APM/APM.h b/dev/modules/APM/APM.h index b071a770..29de5114 100644 --- a/dev/modules/APM/APM.h +++ b/dev/modules/APM/APM.h @@ -21,15 +21,9 @@ enum { kAPMPowerCommandReboot = 0x08, }; -/// @brief Send a APM command into it's own DMA space. -/// @param base_dma the DMA base address. -/// @param cmd the command. -/// @return status code. -EXTERN_C Int32 apm_send_dma_command(Ptr64 register_addr, APMPowerCmd value); - /// @brief Send a APM command into it's own IO space. /// @param base_dma the IO base port. /// @param cmd the command. /// @return status code. -EXTERN_C Int32 apm_send_io_command(UInt16 cmd, APMPowerCmd value); +EXTERN_C Int32 apm_send_io_command(UInt16 cmd); } // namespace Kernel -- cgit v1.2.3 From a5851dfaa65d15f44f52b2aed1aa0179291b46fc Mon Sep 17 00:00:00 2001 From: Amlal El Mahrouss Date: Thu, 12 Jun 2025 02:54:29 +0200 Subject: feat: libSystem, kernel: finalizing the hash and routing system of libSystem's handlers. feat: Rework TTY, and CD-ROM API too. Signed-off-by: Amlal El Mahrouss --- dev/boot/modules/BootNet/BootNet.cc | 2 +- dev/boot/src/HEL/ARM64/BootEFI.cc | 4 ++-- dev/kernel/ArchKit/ArchKit.h | 2 +- dev/kernel/FirmwareKit/CoreBoot/BootNet.h | 10 ++++---- dev/kernel/HALKit/AMD64/HalCoreInterruptHandler.cc | 28 +++++++++++----------- dev/kernel/src/FS/HeFS+FileSystemParser.cc | 5 +++- dev/libSystem/SystemKit/System.h | 10 +++++--- 7 files changed, 34 insertions(+), 27 deletions(-) (limited to 'dev/kernel/src/FS') diff --git a/dev/boot/modules/BootNet/BootNet.cc b/dev/boot/modules/BootNet/BootNet.cc index d4f8c1fc..8236dd0d 100644 --- a/dev/boot/modules/BootNet/BootNet.cc +++ b/dev/boot/modules/BootNet/BootNet.cc @@ -48,7 +48,7 @@ EXTERN_C Int32 BootNetModuleMain(Kernel::HEL::BootInfoHeader* handover) { writer.Write("BootNet: The version clashes, not good.\r"); return kEfiFail; } - + if (!inet_out->ImpliesProgram) { Boot::BootThread thread(inet_out->Data); diff --git a/dev/boot/src/HEL/ARM64/BootEFI.cc b/dev/boot/src/HEL/ARM64/BootEFI.cc index 12ace024..467cae23 100644 --- a/dev/boot/src/HEL/ARM64/BootEFI.cc +++ b/dev/boot/src/HEL/ARM64/BootEFI.cc @@ -129,8 +129,8 @@ EFI_EXTERN_C EFI_API Int32 BootloaderMain(EfiHandlePtr image_handle, EfiSystemTa kHandoverHeader->f_BitMapStart = nullptr; /* Start of bitmap. */ kHandoverHeader->f_BitMapSize = kHandoverBitMapSz; /* Size of bitmap in bytes. */ - - UInt16 trials = 5; + + UInt16 trials = 5; while (BS->AllocatePool(EfiLoaderData, kHandoverHeader->f_BitMapSize, &kHandoverHeader->f_BitMapStart) != kEfiOk) { diff --git a/dev/kernel/ArchKit/ArchKit.h b/dev/kernel/ArchKit/ArchKit.h index 09839d98..a9dca240 100644 --- a/dev/kernel/ArchKit/ArchKit.h +++ b/dev/kernel/ArchKit/ArchKit.h @@ -70,7 +70,7 @@ namespace HAL { typedef Kernel::Void (*rt_syscall_proc)(Kernel::VoidPtr); struct HAL_DISPATCH_ENTRY final { - Kernel::Int64 fHash; + Kernel::UInt64 fHash; Kernel::Bool fHooked; rt_syscall_proc fProc; diff --git a/dev/kernel/FirmwareKit/CoreBoot/BootNet.h b/dev/kernel/FirmwareKit/CoreBoot/BootNet.h index c42c98db..3ed11363 100644 --- a/dev/kernel/FirmwareKit/CoreBoot/BootNet.h +++ b/dev/kernel/FirmwareKit/CoreBoot/BootNet.h @@ -18,11 +18,11 @@ /// sent (if m_preflight = 0) /// @note Can be used to patch ROMs too (if ImpliesProgram = 1) typedef struct BOOTNET_INTERNET_HEADER { - Kernel::Char NB1; /// magic char 1 'O' - Kernel::Char NB2; /// magic char 2 'N' - Kernel::Char NB3; /// magic char 3 'E' - Kernel::Char NB4; /// magic char 4 'T' - Kernel::UInt16 Version; + Kernel::Char NB1; /// magic char 1 'O' + Kernel::Char NB2; /// magic char 2 'N' + Kernel::Char NB3; /// magic char 3 'E' + Kernel::Char NB4; /// magic char 4 'T' + Kernel::UInt16 Version; Kernel::Char Name[kBootNetNameLen]; /// example: Modjo Kernel::Int32 Length; /// the patch length. Kernel::Char Target[kBootNetNameLen]; /// the target file. diff --git a/dev/kernel/HALKit/AMD64/HalCoreInterruptHandler.cc b/dev/kernel/HALKit/AMD64/HalCoreInterruptHandler.cc index 98e1ed61..be6d0af5 100644 --- a/dev/kernel/HALKit/AMD64/HalCoreInterruptHandler.cc +++ b/dev/kernel/HALKit/AMD64/HalCoreInterruptHandler.cc @@ -127,39 +127,39 @@ EXTERN_C void idt_handle_ud(Kernel::UIntPtr rsp) { process.Leak().Signal.Status = process.Leak().Status; } -/// @brief Enter syscall from assembly. +/// @brief Enter syscall from assembly (libSystem only) /// @param stack the stack pushed from assembly routine. /// @return nothing. -EXTERN_C Kernel::Void hal_system_call_enter(Kernel::UIntPtr rcx_syscall_index, - Kernel::UIntPtr rdx_syscall_struct) { +EXTERN_C Kernel::Void hal_system_call_enter(Kernel::UIntPtr rcx_hash, + Kernel::UIntPtr rdx_syscall_arg) { hal_idt_send_eoi(50); if (!Kernel::kCurrentUser) return; - if (rcx_syscall_index < kSysCalls.Count()) { - if (kSysCalls[rcx_syscall_index].fHooked) { - if (kSysCalls[rcx_syscall_index].fProc) { - (kSysCalls[rcx_syscall_index].fProc)((Kernel::VoidPtr) rdx_syscall_struct); + for (SizeT i = 0UL; i < kMaxDispatchCallCount; ++i) { + if (kSysCalls[i].fHooked && rcx_hash == kSysCalls[i].fHash) { + if (kSysCalls[i].fProc) { + (kSysCalls[i].fProc)((Kernel::VoidPtr) rdx_syscall_arg); } } } } -/// @brief Enter Kernel call from assembly (DDK only). +/// @brief Enter Kernel call from assembly (libDDK only). /// @param stack the stack pushed from assembly routine. /// @return nothing. -EXTERN_C Kernel::Void hal_kernel_call_enter(Kernel::UIntPtr rcx_kerncall_index, - Kernel::UIntPtr rdx_kerncall_struct) { +EXTERN_C Kernel::Void hal_kernel_call_enter(Kernel::UIntPtr rcx_hash, + Kernel::UIntPtr rdx_kerncall_arg) { hal_idt_send_eoi(51); if (!Kernel::kRootUser) return; if (Kernel::kCurrentUser != Kernel::kRootUser) return; if (!Kernel::kCurrentUser->IsSuperUser()) return; - if (rcx_kerncall_index < kKernCalls.Count()) { - if (kKernCalls[rcx_kerncall_index].fHooked) { - if (kKernCalls[rcx_kerncall_index].fProc) { - (kKernCalls[rcx_kerncall_index].fProc)((Kernel::VoidPtr) rdx_kerncall_struct); + for (SizeT i = 0UL; i < kMaxDispatchCallCount; ++i) { + if (kKernCalls[i].fHooked && rcx_hash == kKernCalls[rcx_hash].fHash) { + if (kKernCalls[i].fProc) { + (kKernCalls[i].fProc)((Kernel::VoidPtr) rdx_kerncall_arg); } } } diff --git a/dev/kernel/src/FS/HeFS+FileSystemParser.cc b/dev/kernel/src/FS/HeFS+FileSystemParser.cc index bfd38f69..39f8c0a1 100644 --- a/dev/kernel/src/FS/HeFS+FileSystemParser.cc +++ b/dev/kernel/src/FS/HeFS+FileSystemParser.cc @@ -759,7 +759,10 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c if (drv_std_get_size() < kHeFSMinimumDiskSize) { (Void)(kout << "OpenHeFS recommends at least 128 GiB of free space." << kendl); - (Void)(kout << "The OS will still try to format a HeFS disk here anyway, don't expect perfect geometry." << kendl); + (Void)( + kout + << "The OS will still try to format a HeFS disk here anyway, don't expect perfect geometry." + << kendl); } HEFS_BOOT_NODE* boot = (HEFS_BOOT_NODE*) RTL_ALLOCA(sizeof(HEFS_BOOT_NODE)); diff --git a/dev/libSystem/SystemKit/System.h b/dev/libSystem/SystemKit/System.h index 91899efe..421868ae 100644 --- a/dev/libSystem/SystemKit/System.h +++ b/dev/libSystem/SystemKit/System.h @@ -309,16 +309,20 @@ IMPORT_C SInt32 PwrSendCode(_Output SInt32& code); // CD-ROM API. // ------------------------------------------------------------------------------------------ // -IMPORT_C SInt32 CdEjectDrive(_Input Char drv_letter); +#define kCDDevicePath "/devices/dvd{}" -IMPORT_C SInt32 CdOpenTray(Void); +IMPORT_C IORef CdOpenTray(Void); + +IMPORT_C SInt32 CdEjectDrive(_Input IORef cdrom); IMPORT_C SInt32 CdCloseTray(Void); // ------------------------------------------------------------------------------------------ // -// Printer API. +// TTY API. // ------------------------------------------------------------------------------------------ // +#define kPrintDevicePath "/devices/tty{}" + IMPORT_C SInt32 PrintOut(IORef file /* nullptr to direct to stdout */, const Char* fmt, ...); IMPORT_C SInt32 PrintIn(IORef file /* nullptr to direct to stdout */, const Char* fmt, ...); -- cgit v1.2.3