ISO9660FileSystem.cpp 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639
  1. /*
  2. * Copyright (c) 2021, sin-ack <sin-ack@protonmail.com>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include "ISO9660FileSystem.h"
  7. #include <AK/CharacterTypes.h>
  8. #include <AK/Endian.h>
  9. #include <AK/HashFunctions.h>
  10. #include <AK/OwnPtr.h>
  11. #include <AK/StringHash.h>
  12. #include <AK/StringView.h>
  13. #include <Kernel/Debug.h>
  14. #include <Kernel/FileSystem/BlockBasedFileSystem.h>
  15. #include <Kernel/Forward.h>
  16. #include <Kernel/KBuffer.h>
  17. #include <Kernel/Library/LockRefPtr.h>
  18. #include <Kernel/Library/NonnullLockRefPtr.h>
  19. #include <Kernel/UnixTypes.h>
  20. #include <Kernel/UserOrKernelBuffer.h>
  21. namespace Kernel {
  22. // NOTE: According to the spec, logical blocks 0 to 15 are system use.
  23. constexpr u32 first_data_area_block = 16;
  24. constexpr u32 logical_sector_size = 2048;
  25. constexpr u32 max_cached_directory_entries = 128;
  26. struct DirectoryState {
  27. LockRefPtr<ISO9660FS::DirectoryEntry> entry;
  28. u32 offset { 0 };
  29. };
  30. class ISO9660DirectoryIterator {
  31. public:
  32. ISO9660DirectoryIterator(ISO9660FS& fs, ISO::DirectoryRecordHeader const& header)
  33. : m_fs(fs)
  34. , m_current_header(&header)
  35. {
  36. // FIXME: Panic or alternative method?
  37. (void)read_directory_contents();
  38. get_header();
  39. }
  40. ISO::DirectoryRecordHeader const* operator*() { return m_current_header; }
  41. // Recurses into subdirectories. May fail.
  42. ErrorOr<bool> next()
  43. {
  44. if (done())
  45. return false;
  46. dbgln_if(ISO9660_VERY_DEBUG, "next(): Called");
  47. if (has_flag(m_current_header->file_flags, ISO::FileFlags::Directory)) {
  48. dbgln_if(ISO9660_VERY_DEBUG, "next(): Recursing");
  49. {
  50. TRY(m_directory_stack.try_append(move(m_current_directory)));
  51. }
  52. dbgln_if(ISO9660_VERY_DEBUG, "next(): Pushed into directory stack");
  53. TRY(read_directory_contents());
  54. dbgln_if(ISO9660_VERY_DEBUG, "next(): Read directory contents");
  55. m_current_directory.offset = 0;
  56. get_header();
  57. if (m_current_header->length == 0) {
  58. // We have found an empty directory, let's continue with the
  59. // next one.
  60. if (!go_up())
  61. return false;
  62. } else {
  63. // We cannot skip here, as this is the first record in this
  64. // extent.
  65. return true;
  66. }
  67. }
  68. return skip();
  69. }
  70. // Skips to the directory in the list, returns whether there was a next one.
  71. // No allocation here, cannot fail.
  72. bool skip()
  73. {
  74. VERIFY(m_current_directory.entry);
  75. if (m_current_directory.offset >= m_current_directory.entry->length) {
  76. dbgln_if(ISO9660_VERY_DEBUG, "skip(): Was at last item already");
  77. return false;
  78. }
  79. m_current_directory.offset += m_current_header->length;
  80. get_header();
  81. if (m_current_header->length == 0) {
  82. // According to ECMA 119, if a logical block contains directory
  83. // records, then the leftover bytes in the logical block are
  84. // all zeros. So if our directory header has a length of 0,
  85. // we're probably looking at padding.
  86. //
  87. // Of course, this doesn't mean we're done; it only means that there
  88. // are no more directory entries in *this* logical block. If we
  89. // have at least one more logical block of data length to go, we
  90. // need to snap to the next logical block, because directory records
  91. // cannot span multiple logical blocks.
  92. u32 remaining_bytes = m_current_directory.entry->length - m_current_directory.offset;
  93. if (remaining_bytes > m_fs.logical_block_size()) {
  94. m_current_directory.offset += remaining_bytes % m_fs.logical_block_size();
  95. get_header();
  96. dbgln_if(ISO9660_VERY_DEBUG, "skip(): Snapped to next logical block (succeeded)");
  97. return true;
  98. }
  99. dbgln_if(ISO9660_VERY_DEBUG, "skip(): Was at the last logical block, at padding now (offset {}, data length {})", m_current_directory.entry->length, m_current_directory.offset);
  100. return false;
  101. }
  102. dbgln_if(ISO9660_VERY_DEBUG, "skip(): Skipped to next item");
  103. return true;
  104. }
  105. bool go_up()
  106. {
  107. if (m_directory_stack.is_empty()) {
  108. dbgln_if(ISO9660_VERY_DEBUG, "go_up(): Empty directory stack");
  109. return false;
  110. }
  111. m_current_directory = m_directory_stack.take_last();
  112. get_header();
  113. dbgln_if(ISO9660_VERY_DEBUG, "go_up(): Went up a directory");
  114. return true;
  115. }
  116. bool done() const
  117. {
  118. VERIFY(m_current_directory.entry);
  119. auto result = m_directory_stack.is_empty() && m_current_directory.offset >= m_current_directory.entry->length;
  120. dbgln_if(ISO9660_VERY_DEBUG, "done(): {}", result);
  121. return result;
  122. }
  123. private:
  124. ErrorOr<void> read_directory_contents()
  125. {
  126. m_current_directory.entry = TRY(m_fs.directory_entry_for_record({}, m_current_header));
  127. return {};
  128. }
  129. void get_header()
  130. {
  131. VERIFY(m_current_directory.entry);
  132. if (!m_current_directory.entry->blocks)
  133. return;
  134. m_current_header = reinterpret_cast<ISO::DirectoryRecordHeader const*>(m_current_directory.entry->blocks->data() + m_current_directory.offset);
  135. }
  136. ISO9660FS& m_fs;
  137. DirectoryState m_current_directory;
  138. ISO::DirectoryRecordHeader const* m_current_header { nullptr };
  139. Vector<DirectoryState> m_directory_stack;
  140. };
  141. ErrorOr<NonnullLockRefPtr<FileSystem>> ISO9660FS::try_create(OpenFileDescription& description)
  142. {
  143. return TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) ISO9660FS(description)));
  144. }
  145. ISO9660FS::ISO9660FS(OpenFileDescription& description)
  146. : BlockBasedFileSystem(description)
  147. {
  148. set_block_size(logical_sector_size);
  149. m_logical_block_size = logical_sector_size;
  150. }
  151. ISO9660FS::~ISO9660FS() = default;
  152. ErrorOr<void> ISO9660FS::initialize()
  153. {
  154. TRY(BlockBasedFileSystem::initialize());
  155. TRY(parse_volume_set());
  156. TRY(create_root_inode());
  157. return {};
  158. }
  159. Inode& ISO9660FS::root_inode()
  160. {
  161. VERIFY(!m_root_inode.is_null());
  162. return *m_root_inode;
  163. }
  164. unsigned ISO9660FS::total_block_count() const
  165. {
  166. return LittleEndian { m_primary_volume->volume_space_size.little };
  167. }
  168. unsigned ISO9660FS::total_inode_count() const
  169. {
  170. if (!m_cached_inode_count) {
  171. auto result = calculate_inode_count();
  172. if (result.is_error()) {
  173. // FIXME: This should be able to return a ErrorOr<void>.
  174. return 0;
  175. }
  176. }
  177. return m_cached_inode_count;
  178. }
  179. u8 ISO9660FS::internal_file_type_to_directory_entry_type(DirectoryEntryView const& entry) const
  180. {
  181. if (has_flag(static_cast<ISO::FileFlags>(entry.file_type), ISO::FileFlags::Directory)) {
  182. return DT_DIR;
  183. }
  184. return DT_REG;
  185. }
  186. ErrorOr<void> ISO9660FS::parse_volume_set()
  187. {
  188. VERIFY(!m_primary_volume);
  189. auto block = TRY(KBuffer::try_create_with_size("ISO9660FS: Temporary volume descriptor storage"sv, m_logical_block_size, Memory::Region::Access::Read | Memory::Region::Access::Write));
  190. auto block_buffer = UserOrKernelBuffer::for_kernel_buffer(block->data());
  191. auto current_block_index = first_data_area_block;
  192. while (true) {
  193. auto result = raw_read(BlockIndex { current_block_index }, block_buffer);
  194. if (result.is_error()) {
  195. dbgln_if(ISO9660_DEBUG, "Failed to read volume descriptor from ISO file: {}", result.error());
  196. return result;
  197. }
  198. auto const* header = reinterpret_cast<ISO::VolumeDescriptorHeader const*>(block->data());
  199. if (StringView { header->identifier, 5 } != "CD001"sv) {
  200. dbgln_if(ISO9660_DEBUG, "Header magic at volume descriptor {} is not valid", current_block_index - first_data_area_block);
  201. return EIO;
  202. }
  203. switch (header->type) {
  204. case ISO::VolumeDescriptorType::PrimaryVolumeDescriptor: {
  205. auto const* primary_volume = reinterpret_cast<ISO::PrimaryVolumeDescriptor const*>(header);
  206. m_primary_volume = adopt_own_if_nonnull(new ISO::PrimaryVolumeDescriptor(*primary_volume));
  207. break;
  208. }
  209. case ISO::VolumeDescriptorType::BootRecord:
  210. case ISO::VolumeDescriptorType::SupplementaryOrEnhancedVolumeDescriptor:
  211. case ISO::VolumeDescriptorType::VolumePartitionDescriptor: {
  212. break;
  213. }
  214. case ISO::VolumeDescriptorType::VolumeDescriptorSetTerminator: {
  215. goto all_headers_read;
  216. }
  217. default:
  218. dbgln_if(ISO9660_DEBUG, "Unexpected volume descriptor type {} in volume set", static_cast<u8>(header->type));
  219. return EIO;
  220. }
  221. current_block_index++;
  222. }
  223. all_headers_read:
  224. if (!m_primary_volume) {
  225. dbgln_if(ISO9660_DEBUG, "Could not find primary volume");
  226. return EIO;
  227. }
  228. m_logical_block_size = LittleEndian { m_primary_volume->logical_block_size.little };
  229. return {};
  230. }
  231. ErrorOr<void> ISO9660FS::create_root_inode()
  232. {
  233. if (!m_primary_volume) {
  234. dbgln_if(ISO9660_DEBUG, "Primary volume doesn't exist, can't create root inode");
  235. return EIO;
  236. }
  237. m_root_inode = TRY(ISO9660Inode::try_create_from_directory_record(*this, m_primary_volume->root_directory_record_header, {}));
  238. return {};
  239. }
  240. ErrorOr<void> ISO9660FS::calculate_inode_count() const
  241. {
  242. if (!m_primary_volume) {
  243. dbgln_if(ISO9660_DEBUG, "Primary volume doesn't exist, can't calculate inode count");
  244. return EIO;
  245. }
  246. size_t inode_count = 1;
  247. TRY(visit_directory_record(m_primary_volume->root_directory_record_header, [&](ISO::DirectoryRecordHeader const* header) {
  248. if (header == nullptr) {
  249. return RecursionDecision::Continue;
  250. }
  251. inode_count += 1;
  252. if (has_flag(header->file_flags, ISO::FileFlags::Directory)) {
  253. if (header->file_identifier_length == 1) {
  254. auto file_identifier = reinterpret_cast<u8 const*>(header + 1);
  255. if (file_identifier[0] == '\0' || file_identifier[0] == '\1') {
  256. return RecursionDecision::Continue;
  257. }
  258. }
  259. return RecursionDecision::Recurse;
  260. }
  261. return RecursionDecision::Continue;
  262. }));
  263. m_cached_inode_count = inode_count;
  264. return {};
  265. }
  266. ErrorOr<void> ISO9660FS::visit_directory_record(ISO::DirectoryRecordHeader const& record, Function<ErrorOr<RecursionDecision>(ISO::DirectoryRecordHeader const*)> const& visitor) const
  267. {
  268. if (!has_flag(record.file_flags, ISO::FileFlags::Directory)) {
  269. return {};
  270. }
  271. ISO9660DirectoryIterator iterator { const_cast<ISO9660FS&>(*this), record };
  272. while (!iterator.done()) {
  273. auto decision = TRY(visitor(*iterator));
  274. switch (decision) {
  275. case RecursionDecision::Recurse: {
  276. auto has_moved = TRY(iterator.next());
  277. if (!has_moved) {
  278. // If next() hasn't moved then we have read through all the
  279. // directories, and can exit.
  280. return {};
  281. }
  282. continue;
  283. }
  284. case RecursionDecision::Continue: {
  285. while (!iterator.done()) {
  286. if (iterator.skip())
  287. break;
  288. if (!iterator.go_up())
  289. return {};
  290. }
  291. continue;
  292. }
  293. case RecursionDecision::Break:
  294. return {};
  295. }
  296. }
  297. return {};
  298. }
  299. ErrorOr<NonnullLockRefPtr<ISO9660FS::DirectoryEntry>> ISO9660FS::directory_entry_for_record(Badge<ISO9660DirectoryIterator>, ISO::DirectoryRecordHeader const* record)
  300. {
  301. u32 extent_location = LittleEndian { record->extent_location.little };
  302. u32 data_length = LittleEndian { record->data_length.little };
  303. auto key = calculate_directory_entry_cache_key(*record);
  304. auto it = m_directory_entry_cache.find(key);
  305. if (it != m_directory_entry_cache.end()) {
  306. dbgln_if(ISO9660_DEBUG, "Cache hit for dirent @ {}", extent_location);
  307. return it->value;
  308. }
  309. dbgln_if(ISO9660_DEBUG, "Cache miss for dirent @ {} :^(", extent_location);
  310. if (m_directory_entry_cache.size() == max_cached_directory_entries) {
  311. // FIXME: A smarter algorithm would probably be nicer.
  312. m_directory_entry_cache.remove(m_directory_entry_cache.begin());
  313. }
  314. if (!(data_length % logical_block_size() == 0)) {
  315. dbgln_if(ISO9660_DEBUG, "Found a directory with non-logical block size aligned data length!");
  316. return EIO;
  317. }
  318. auto blocks = TRY(KBuffer::try_create_with_size("ISO9660FS: Directory traversal buffer"sv, data_length, Memory::Region::Access::Read | Memory::Region::Access::Write));
  319. auto blocks_buffer = UserOrKernelBuffer::for_kernel_buffer(blocks->data());
  320. TRY(raw_read_blocks(BlockBasedFileSystem::BlockIndex { extent_location }, data_length / logical_block_size(), blocks_buffer));
  321. auto entry = TRY(DirectoryEntry::try_create(extent_location, data_length, move(blocks)));
  322. m_directory_entry_cache.set(key, entry);
  323. dbgln_if(ISO9660_DEBUG, "Cached dirent @ {}", extent_location);
  324. return entry;
  325. }
  326. u32 ISO9660FS::calculate_directory_entry_cache_key(ISO::DirectoryRecordHeader const& record)
  327. {
  328. return LittleEndian { record.extent_location.little };
  329. }
  330. ErrorOr<size_t> ISO9660Inode::read_bytes_locked(off_t offset, size_t size, UserOrKernelBuffer& buffer, OpenFileDescription*) const
  331. {
  332. VERIFY(m_inode_lock.is_locked());
  333. u32 data_length = LittleEndian { m_record.data_length.little };
  334. u32 extent_location = LittleEndian { m_record.extent_location.little };
  335. if (static_cast<u64>(offset) >= data_length)
  336. return 0;
  337. auto block = TRY(KBuffer::try_create_with_size("ISO9660FS: Inode read buffer"sv, fs().m_logical_block_size));
  338. auto block_buffer = UserOrKernelBuffer::for_kernel_buffer(block->data());
  339. size_t total_bytes = min(size, data_length - offset);
  340. size_t nread = 0;
  341. size_t blocks_already_read = offset / fs().m_logical_block_size;
  342. size_t initial_offset = offset % fs().m_logical_block_size;
  343. auto current_block_index = BlockBasedFileSystem::BlockIndex { extent_location + blocks_already_read };
  344. while (nread != total_bytes) {
  345. size_t bytes_to_read = min(total_bytes - nread, fs().logical_block_size() - initial_offset);
  346. auto buffer_offset = buffer.offset(nread);
  347. dbgln_if(ISO9660_VERY_DEBUG, "ISO9660Inode::read_bytes: Reading {} bytes into buffer offset {}/{}, logical block index: {}", bytes_to_read, nread, total_bytes, current_block_index.value());
  348. TRY(const_cast<ISO9660FS&>(fs()).raw_read(current_block_index, block_buffer));
  349. TRY(buffer_offset.write(block->data() + initial_offset, bytes_to_read));
  350. nread += bytes_to_read;
  351. initial_offset = 0;
  352. current_block_index = BlockBasedFileSystem::BlockIndex { current_block_index.value() + 1 };
  353. }
  354. return nread;
  355. }
  356. InodeMetadata ISO9660Inode::metadata() const
  357. {
  358. return m_metadata;
  359. }
  360. ErrorOr<void> ISO9660Inode::traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)> visitor) const
  361. {
  362. Array<u8, max_file_identifier_length> file_identifier_buffer;
  363. ErrorOr<void> result;
  364. return fs().visit_directory_record(m_record, [&](ISO::DirectoryRecordHeader const* record) {
  365. StringView filename = get_normalized_filename(*record, file_identifier_buffer);
  366. dbgln_if(ISO9660_VERY_DEBUG, "traverse_as_directory(): Found {}", filename);
  367. InodeIdentifier id { fsid(), get_inode_index(*record, filename) };
  368. auto entry = FileSystem::DirectoryEntryView(filename, id, static_cast<u8>(record->file_flags));
  369. result = visitor(entry);
  370. if (result.is_error())
  371. return RecursionDecision::Break;
  372. return RecursionDecision::Continue;
  373. });
  374. }
  375. ErrorOr<NonnullLockRefPtr<Inode>> ISO9660Inode::lookup(StringView name)
  376. {
  377. LockRefPtr<Inode> inode;
  378. Array<u8, max_file_identifier_length> file_identifier_buffer;
  379. TRY(fs().visit_directory_record(m_record, [&](ISO::DirectoryRecordHeader const* record) {
  380. StringView filename = get_normalized_filename(*record, file_identifier_buffer);
  381. if (filename == name) {
  382. auto maybe_inode = ISO9660Inode::try_create_from_directory_record(fs(), *record, filename);
  383. if (maybe_inode.is_error()) {
  384. // FIXME: The Inode API does not handle allocation failures very
  385. // well... we can't return a ErrorOr from here. It
  386. // would be nice if we could return a ErrorOr<void>(Or) from
  387. // any place where allocation may happen.
  388. dbgln("Could not allocate inode for lookup!");
  389. } else {
  390. inode = maybe_inode.release_value();
  391. }
  392. return RecursionDecision::Break;
  393. }
  394. return RecursionDecision::Continue;
  395. }));
  396. if (!inode)
  397. return ENOENT;
  398. return inode.release_nonnull();
  399. }
  400. ErrorOr<void> ISO9660Inode::flush_metadata()
  401. {
  402. return {};
  403. }
  404. ErrorOr<size_t> ISO9660Inode::write_bytes_locked(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*)
  405. {
  406. return EROFS;
  407. }
  408. ErrorOr<NonnullLockRefPtr<Inode>> ISO9660Inode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
  409. {
  410. return EROFS;
  411. }
  412. ErrorOr<void> ISO9660Inode::add_child(Inode&, StringView, mode_t)
  413. {
  414. return EROFS;
  415. }
  416. ErrorOr<void> ISO9660Inode::remove_child(StringView)
  417. {
  418. return EROFS;
  419. }
  420. ErrorOr<void> ISO9660Inode::chmod(mode_t)
  421. {
  422. return EROFS;
  423. }
  424. ErrorOr<void> ISO9660Inode::chown(UserID, GroupID)
  425. {
  426. return EROFS;
  427. }
  428. ErrorOr<void> ISO9660Inode::truncate(u64)
  429. {
  430. return EROFS;
  431. }
  432. ErrorOr<void> ISO9660Inode::update_timestamps(Optional<time_t>, Optional<time_t>, Optional<time_t>)
  433. {
  434. return EROFS;
  435. }
  436. ISO9660Inode::ISO9660Inode(ISO9660FS& fs, ISO::DirectoryRecordHeader const& record, StringView name)
  437. : Inode(fs, get_inode_index(record, name))
  438. , m_record(record)
  439. {
  440. dbgln_if(ISO9660_VERY_DEBUG, "Creating inode #{}", index());
  441. create_metadata();
  442. }
  443. ISO9660Inode::~ISO9660Inode() = default;
  444. ErrorOr<NonnullLockRefPtr<ISO9660Inode>> ISO9660Inode::try_create_from_directory_record(ISO9660FS& fs, ISO::DirectoryRecordHeader const& record, StringView name)
  445. {
  446. return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ISO9660Inode(fs, record, name));
  447. }
  448. void ISO9660Inode::create_metadata()
  449. {
  450. u32 data_length = LittleEndian { m_record.data_length.little };
  451. bool is_directory = has_flag(m_record.file_flags, ISO::FileFlags::Directory);
  452. time_t recorded_at = parse_numerical_date_time(m_record.recording_date_and_time);
  453. m_metadata = {
  454. .inode = identifier(),
  455. .size = data_length,
  456. .mode = static_cast<mode_t>((is_directory ? S_IFDIR : S_IFREG) | (is_directory ? 0555 : 0444)),
  457. .uid = 0,
  458. .gid = 0,
  459. .link_count = 1,
  460. .atime = recorded_at,
  461. .ctime = recorded_at,
  462. .mtime = recorded_at,
  463. .dtime = 0,
  464. .block_count = 0,
  465. .block_size = 0,
  466. .major_device = 0,
  467. .minor_device = 0,
  468. };
  469. }
  470. time_t ISO9660Inode::parse_numerical_date_time(ISO::NumericalDateAndTime const& date)
  471. {
  472. i32 year_offset = date.years_since_1900 - 70;
  473. return (year_offset * 60 * 60 * 24 * 30 * 12)
  474. + (date.month * 60 * 60 * 24 * 30)
  475. + (date.day * 60 * 60 * 24)
  476. + (date.hour * 60 * 60)
  477. + (date.minute * 60)
  478. + date.second;
  479. }
  480. StringView ISO9660Inode::get_normalized_filename(ISO::DirectoryRecordHeader const& record, Bytes buffer)
  481. {
  482. auto const* file_identifier = reinterpret_cast<u8 const*>(&record + 1);
  483. auto filename = StringView { file_identifier, record.file_identifier_length };
  484. if (filename.length() == 1) {
  485. if (filename[0] == '\0') {
  486. filename = "."sv;
  487. }
  488. if (filename[0] == '\1') {
  489. filename = ".."sv;
  490. }
  491. }
  492. if (!has_flag(record.file_flags, ISO::FileFlags::Directory)) {
  493. // FIXME: We currently strip the file version from the filename,
  494. // but that may be used later down the line if the file actually
  495. // has multiple versions on the disk.
  496. Optional<size_t> semicolon = filename.find(';');
  497. if (semicolon.has_value()) {
  498. filename = filename.substring_view(0, semicolon.value());
  499. }
  500. if (filename[filename.length() - 1] == '.') {
  501. filename = filename.substring_view(0, filename.length() - 1);
  502. }
  503. }
  504. if (filename.length() > buffer.size()) {
  505. // FIXME: Rock Ridge allows filenames up to 255 characters, so we should
  506. // probably support that instead of truncating.
  507. filename = filename.substring_view(0, buffer.size());
  508. }
  509. for (size_t i = 0; i < filename.length(); i++) {
  510. buffer[i] = to_ascii_lowercase(filename[i]);
  511. }
  512. return { buffer.data(), filename.length() };
  513. }
  514. InodeIndex ISO9660Inode::get_inode_index(ISO::DirectoryRecordHeader const& record, StringView name)
  515. {
  516. if (name.is_null()) {
  517. // NOTE: This is the index of the root inode.
  518. return 1;
  519. }
  520. return { pair_int_hash(LittleEndian { record.extent_location.little }, string_hash(name.characters_without_null_termination(), name.length())) };
  521. }
  522. }