// SPDX-License-Identifier: GPL-3.0-or-later #import "DiskImageEditorBackend.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include extern "C" { #include "decbpath.h" #include "os9path.h" #include "os9module.h" } namespace { constexpr size_t limit = 512 * 1024 * 1024; constexpr size_t fileLimit = 16 * 1024 * 1024; constexpr size_t sectorSize = 256; constexpr size_t rawTrackBytes = 18 * sectorSize; constexpr size_t decbVolumeBytes = 35 * rawTrackBytes; std::recursive_mutex backendMutex; using Bytes = std::vector; [[noreturn]] void fail(const std::string& message) { throw std::runtime_error(message); } uint32_t be(const Bytes& bytes, size_t offset, size_t count) { if (offset > bytes.size() || count > bytes.size() - offset) fail("The disk image contains a truncated structure."); uint32_t value = 0; for (size_t i = 0; i < count; ++i) value = (value << 8) | bytes[offset + i]; return value; } std::string lower(std::string value) { for (char& c : value) c = char(std::tolower(static_cast(c))); return value; } std::string string(NSString *value) { const char *bytes = value.UTF8String; if (!bytes) fail("This name is not valid UTF-8."); return bytes; } NSString *text(const std::string& value) { return [[NSString alloc] initWithBytes:value.data() length:value.size() encoding:NSUTF8StringEncoding] ?: @""; } std::string name(std::string value, bool decb, bool allowDots = false) { if (value.empty() || value.size() > (decb ? 12 : 29) || (!allowDots && (value == "." || value == ".."))) fail(decb ? "Use a Disk BASIC name of up to eight characters and a three-character extension." : "Use an OS-9 name of 1–29 ASCII characters."); for (unsigned char c : value) if (c < 32 || c > 126 || c == '/' || c == '\\' || c == ',' || c == ':' || c == '@') fail("The image name contains an unsupported character."); if (decb) { const auto dot = value.find('.'); if (dot == 0 || (dot != std::string::npos && (dot > 8 || dot + 1 == value.size() || value.size() - dot - 1 > 3 || value.find('.', dot + 1) != std::string::npos)) || (dot == std::string::npos && value.size() > 8)) fail("Use a Disk BASIC name of up to eight characters and a three-character extension."); for (char& c : value) c = char(std::toupper(static_cast(c))); } return value; } std::string imagePath(NSString *input, bool decb, bool rootAllowed = false) { const auto path = string(input); if (path.empty()) { if (rootAllowed) return path; fail("Select a file or directory within the image."); } if (path.size() > 1024 || path.front() == '/' || path.back() == '/') fail("Use a relative path inside the image."); std::string out; size_t start = 0, components = 0; while (start < path.size()) { const auto end = path.find('/', start); const auto part = name(path.substr(start, end == std::string::npos ? end : end - start), decb); if (++components > 32 || (decb && components > 1)) fail("The image path is too deep for this filesystem."); if (!out.empty()) out += '/'; out += part; if (end == std::string::npos) break; start = end + 1; } return out; } Bytes load(NSURL *url) { if (!url.isFileURL || [url.path containsString:@","]) fail("Choose a local private working image with no comma in its path."); const int fd = open(url.fileSystemRepresentation, O_RDONLY | O_NOFOLLOW); if (fd < 0) fail("The working disk image could not be opened."); struct stat info{}; if (fstat(fd, &info) != 0 || !S_ISREG(info.st_mode) || info.st_size < 256 || info.st_size > off_t(limit)) { close(fd); fail("Choose a regular disk image between 256 bytes and 512 MiB."); } Bytes bytes(size_t(info.st_size)); size_t offset = 0; while (offset < bytes.size()) { const ssize_t got = read(fd, bytes.data() + offset, bytes.size() - offset); if (got <= 0) { close(fd); fail("The disk image could not be read completely."); } offset += size_t(got); } uint8_t extra; const auto additional = read(fd, &extra, 1); close(fd); if (additional != 0) fail("The working image changed while it was being read."); return bytes; } struct Node { std::string path, parent, name; bool directory = false; size_t size = 0, descriptorSector = 0; unsigned type = 0, ascii = 0, attributes = 0, owner = 0, group = 0; id modified = NSNull.null; Bytes content; std::vector dataSectors; }; struct Image { Bytes bytes; bool decb = false; size_t capacity = 0, free = 0, unit = 0; std::map nodes; const Node& find(const std::string& path) const { auto found = nodes.find(lower(path)); if (found == nodes.end()) fail("The selected image entry no longer exists."); return found->second; } }; std::string padded(const Bytes& b, size_t offset, size_t size) { std::string value(reinterpret_cast(b.data() + offset), size); while (!value.empty() && value.back() == ' ') value.pop_back(); return value; } void validateDECB(Image& image) { auto& b = image.bytes; if (b.size() < decbVolumeBytes || b.size() % rawTrackBytes != 0) fail("Disk BASIC editing requires a complete 35-track raw filesystem, optionally followed by whole supplementary tracks. Other image layouts are preserved but cannot be edited here."); // Disk BASIC's 68-granule filesystem occupies only the first 35 tracks. // Supplementary tracks are opaque application data, never free granules. image.decb = true; image.unit = 2304; image.capacity = 68 * image.unit; constexpr size_t fat = (17 * 18 + 1) * 256, directory = (17 * 18 + 2) * 256; auto chain = [&](unsigned first) { std::vector result; std::set visited; unsigned current = first; for (;;) { if (current >= 68 || !visited.insert(current).second) fail("The Disk BASIC allocation chain is out of range or cyclic."); result.push_back(current); const unsigned next = b[fat + current]; if (next >= 0xc0 && next <= 0xc9) return result; if (next >= 68) fail("The Disk BASIC allocation chain has an invalid terminator."); current = next; } }; for (unsigned i = 0; i < 68; ++i) { if (b[fat + i] == 255) image.free += image.unit; else (void)chain(i); } Node root; root.directory = true; image.nodes.emplace("", root); std::set claimed; for (unsigned i = 0; i < 72; ++i) { const auto offset = directory + i * 32; if (b[offset] == 255 || b[offset] == 0) continue; Node n; n.name = padded(b, offset, 8); const auto ext = padded(b, offset + 8, 3); if (!ext.empty()) n.name += '.' + ext; n.path = name(n.name, true); n.name = n.path; n.type = b[offset + 11]; n.ascii = b[offset + 12]; if (n.type > 3 || (n.ascii != 0 && n.ascii != 255)) fail("The Disk BASIC file has unsupported type or encoding metadata."); const auto allocated = chain(b[offset + 13]); const auto last = b[fat + allocated.back()] & 0x3f; const auto lastBytes = be(b, offset + 14, 2); if (lastBytes > 256 || (last == 0 && lastBytes != 0)) fail("The Disk BASIC last-sector length is invalid."); n.size = (allocated.size() - 1) * 2304 + (last > 0 ? last - 1 : 0) * 256 + lastBytes; for (unsigned granule : allocated) { if (!claimed.insert(granule).second) fail("Two Disk BASIC files share an allocation granule."); const size_t sector = size_t(granule / 2 + (granule >= 34 ? 1 : 0)) * 18 + (granule % 2) * 9; n.content.insert(n.content.end(), b.begin() + sector * 256, b.begin() + sector * 256 + 2304); } if (n.size > n.content.size()) fail("The Disk BASIC file length exceeds its allocation."); n.content.resize(n.size); if (!image.nodes.emplace(lower(n.path), std::move(n)).second) fail("The Disk BASIC directory has duplicate names."); } } id modifiedTime(const Bytes& b, size_t offset) { const unsigned year = b[offset] + 1900, month = b[offset + 1], day = b[offset + 2], hour = b[offset + 3], minute = b[offset + 4]; if (month < 1 || month > 12 || day < 1 || day > 31 || hour > 23 || minute > 59) return NSNull.null; NSDateComponents *parts = [NSDateComponents new]; parts.year = year; parts.month = month; parts.day = day; parts.hour = hour; parts.minute = minute; NSCalendar *calendar = [[NSCalendar alloc] initWithCalendarIdentifier:NSCalendarIdentifierGregorian]; calendar.timeZone = [NSTimeZone timeZoneForSecondsFromGMT:0]; NSDate *date = [calendar dateFromComponents:parts]; return date ? @([date timeIntervalSince1970]) : NSNull.null; } void validateOS9(Image& image) { auto& b = image.bytes; const size_t sectors = be(b, 0, 3), mapBytes = be(b, 4, 2), cluster = be(b, 6, 2), rootFD = be(b, 8, 3); const auto declaredSectorSize = be(b, offsetof(lsn0_sect, dd_lsnsize), 2); const auto sectorsPerTrack = be(b, offsetof(lsn0_sect, dd_spt), 2); const bool osk = be(b, offsetof(lsn0_sect, dd_sync), 4) == 0x4372757a; const auto track0 = be(b, osk ? offsetof(lsn0_sect, dd_opt.m68k.pd_t0s) : offsetof(lsn0_sect, dd_opt.m6809.pd_t0s), 2); // The upstream raw reader uses the first byte of dd_lsnsize; historical // writers also store 1 in the low byte. Both spellings still mean 256. if (!sectors || sectors * 256 != b.size() || cluster == 0 || cluster > 256 || (cluster & (cluster - 1)) || !rootFD || rootFD >= sectors || (declaredSectorSize != 0 && declaredSectorSize != 1 && declaredSectorSize != 256) || !sectorsPerTrack || (track0 && track0 != sectorsPerTrack)) fail("The OS-9 geometry is invalid or is not a supported raw 256-byte-sector image."); const size_t clusters = (sectors + cluster - 1) / cluster, mapSectors = (mapBytes + 255) / 256; if (mapBytes < (clusters + 7) / 8 || mapBytes > b.size() - 256 || mapSectors + 1 >= sectors) fail("The OS-9 allocation bitmap is truncated."); auto allocated = [&](size_t sector) { const auto bit = sector / cluster; return (b[256 + bit / 8] & (0x80 >> (bit % 8))) != 0; }; const size_t bootStart = be(b, offsetof(lsn0_sect, dd_bt), 3), bootBytes = be(b, offsetof(lsn0_sect, dd_bsz), 2); if (bootStart) { // A zero byte length can designate the fragmented-boot descriptor. // At minimum its pointed sector must remain within allocated space. const size_t bootSectors = bootBytes ? (bootBytes + sectorSize - 1) / sectorSize : 1; if (bootStart >= sectors || bootSectors > sectors - bootStart) fail("The OS-9 boot extent is outside the volume."); for (size_t sector = bootStart; sector < bootStart + bootSectors; ++sector) if (!allocated(sector)) fail("An OS-9 boot sector is marked free in the allocation bitmap."); if (!bootBytes) { const size_t descriptor = bootStart * sectorSize; size_t allocation = 0; for (size_t i = 0; i < 48; ++i) { const size_t segment = descriptor + 16 + i * 5, start = be(b, segment, 3), count = be(b, segment + 3, 2); if (!count) { if (start) fail("The fragmented OS-9 boot segment is invalid."); continue; } if (!start || start >= sectors || count > sectors - start) fail("The fragmented OS-9 boot segment is outside the volume."); for (size_t sector = start; sector < start + count; ++sector) if (!allocated(sector)) fail("A fragmented OS-9 boot sector is marked free."); allocation += count * sectorSize; } if (be(b, descriptor + 9, 4) > allocation) fail("The fragmented OS-9 boot file is shorter than its descriptor."); } } else if (bootBytes) fail("The OS-9 boot extent has no starting sector."); image.capacity = sectors * 256; image.unit = cluster * 256; for (size_t c = 0; c < clusters; ++c) if (!allocated(c * cluster)) image.free += std::min(cluster, sectors - c * cluster) * 256; std::vector owners(sectors, 0); for (size_t s = 0; s <= mapSectors; ++s) { if (!allocated(s)) fail("OS-9 reserved sectors are marked free."); owners[s] = size_t(-1); } std::set directories, activeDirectories, claimedFDs; size_t materializedBytes = 0; std::function visit; visit = [&](size_t fd, std::string path, std::string parent, unsigned depth) { if (fd >= sectors || !fd || depth > 32 || image.nodes.size() >= 4096) fail("The OS-9 directory tree exceeds safe bounds."); const size_t offset = fd * 256; Node n; n.descriptorSector = fd; n.path = path; n.parent = parent; n.name = path.substr(path.rfind('/') == std::string::npos ? 0 : path.rfind('/') + 1); n.attributes = b[offset]; n.directory = (n.attributes & 0x80) != 0; n.owner = b[offset + 2]; n.group = b[offset + 1]; n.modified = modifiedTime(b, offset + 3); n.size = be(b, offset + 9, 4); if (n.size > b.size() || b[offset + 8] == 0) fail("The OS-9 descriptor has invalid length or link count."); if (n.size > limit * 2 - materializedBytes) fail("The OS-9 tree contains too many aliased file bytes."); const bool firstFD = claimedFDs.insert(fd).second; if (firstFD) { if (owners[fd] || !allocated(fd)) fail("The OS-9 descriptor overlaps another allocation or is marked free."); owners[fd] = fd; } std::set localSectors; for (unsigned i = 0; i < 48; ++i) { const size_t pos = offset + 16 + i * 5, start = be(b, pos, 3), count = be(b, pos + 3, 2); if (!count) { if (start) fail("The OS-9 segment has no length."); continue; } if (start == 0 || start >= sectors || count > sectors - start) fail("The OS-9 file segment is outside the image."); for (size_t s = start; s < start + count; ++s) { if (!localSectors.insert(s).second || !allocated(s) || (firstFD && owners[s])) fail("The OS-9 file allocation is cross-linked or marked free."); if (firstFD) owners[s] = fd; n.dataSectors.push_back(s); } if (count * sectorSize > limit * 2 - materializedBytes) fail("The OS-9 tree contains too many aliased allocation bytes."); materializedBytes += count * sectorSize; const size_t needed = std::min(count * sectorSize, n.size - std::min(n.size, n.content.size())); n.content.insert(n.content.end(), b.begin() + start * sectorSize, b.begin() + start * sectorSize + needed); } if (n.size > n.content.size()) fail("The OS-9 file is shorter than its descriptor claims."); n.content.resize(n.size); if (!image.nodes.emplace(lower(path), n).second) fail("The OS-9 directory contains duplicate names."); if (!n.directory) return; if (!activeDirectories.insert(fd).second || !directories.insert(fd).second || n.size % 32) fail("The OS-9 directory is cyclic or has an invalid size."); for (size_t i = 0; i < n.content.size(); i += 32) { if (n.content[i] == 0) continue; std::string child; bool terminated = false; for (size_t j = 0; j < 29; ++j) { const auto c = n.content[i + j]; child += char(c & 127); if (c & 128) { terminated = true; break; } } if (!terminated) fail("An OS-9 directory name is not terminated."); const size_t childFD = be(n.content, i + 29, 3); if (!childFD || childFD >= sectors) fail("An OS-9 directory entry points outside the image."); if (child == "." || child == "..") continue; child = name(child, false); visit(childFD, path.empty() ? child : path + '/' + child, path, depth + 1); } activeDirectories.erase(fd); }; visit(rootFD, "", "", 0); if (!image.find("").directory) fail("The OS-9 root descriptor is not a directory."); std::map clusterOwners; for (size_t sector = mapSectors + 1; sector < sectors; ++sector) { if (!owners[sector] || owners[sector] == size_t(-1)) continue; const auto prior = clusterOwners.emplace(sector / cluster, owners[sector]); if (!prior.second && prior.first->second != owners[sector]) fail("OS-9 files share an allocation cluster."); } } Image inspect(NSURL *url) { Image image; image.bytes = load(url); diskimage_format format = DISKIMAGE_UNKNOWN; if (_diskimage_identify(url.fileSystemRepresentation, &format) || format != DISKIMAGE_RAW) fail("The editor currently supports raw disk images. Other image containers are preserved but cannot be edited here."); if (image.bytes.size() % 256 == 0 && be(image.bytes, 0, 3) == image.bytes.size() / 256) validateOS9(image); else validateDECB(image); return image; } struct ByteRange { size_t offset, length; }; std::vector externalBootRanges(const Bytes& bytes, size_t filesystemBytes) { const size_t start = be(bytes, offsetof(lsn0_sect, dd_bt), 3), length = be(bytes, offsetof(lsn0_sect, dd_bsz), 2); if (!start || start < filesystemBytes / sectorSize) return {}; const size_t sectors = bytes.size() / sectorSize; auto range = [&](size_t first, size_t count) { if (!count || first >= sectors || count > sectors - first || first < filesystemBytes / sectorSize) fail("The external OS-9 boot extent is outside the hard-drive image or crosses its filesystem boundary."); return ByteRange{first * sectorSize, count * sectorSize}; }; if (length) return {range(start, (length + sectorSize - 1) / sectorSize)}; std::vector protectedRanges{range(start, 1)}; const size_t descriptor = start * sectorSize; size_t allocatedBytes = 0; if ((bytes[descriptor] & 0x80) || !bytes[descriptor + 8]) fail("The external fragmented OS-9 boot descriptor is invalid."); for (size_t i = 0; i < 48; ++i) { const size_t segment = descriptor + 16 + i * 5, first = be(bytes, segment, 3), count = be(bytes, segment + 3, 2); if (!count) { if (first) fail("The external fragmented OS-9 boot segment has no length."); continue; } protectedRanges.push_back(range(first, count)); allocatedBytes += count * sectorSize; } if (be(bytes, descriptor + 9, 4) > allocatedBytes) fail("The external fragmented OS-9 boot file is shorter than its descriptor."); return protectedRanges; } void clearExternalBootPointer(Bytes& bytes) { std::fill_n(bytes.begin() + offsetof(lsn0_sect, dd_bt), 5, 0); } struct Volume { std::string id, format, name; size_t offset, length, index; }; std::vector discover(const Bytes& bytes) { if (bytes.size() % sectorSize) fail("A raw hard-drive image must contain complete 256-byte sectors."); std::vector volumes; std::vector protectedBoot; size_t hdbStart = 0; // An RBF volume may occupy a prefix of a combined OS-9/HDB-DOS image. // Only its declared extent is inspected; no heuristic sector scanning. const size_t extent = be(bytes, 0, 3) * sectorSize; const size_t cluster = be(bytes, 6, 2); const bool rbfHeader = be(bytes, 4, 2) != 0 && cluster != 0 && cluster <= 256 && !(cluster & (cluster - 1)) && be(bytes, 8, 3) != 0; if (rbfHeader) { if (extent < 3 * sectorSize || extent > bytes.size()) fail("The OS-9 declared volume extent is outside the image."); protectedBoot = externalBootRanges(bytes, extent); Image image; image.bytes.assign(bytes.begin(), bytes.begin() + extent); if (!protectedBoot.empty()) clearExternalBootPointer(image.bytes); validateOS9(image); std::string volumeName; for (size_t i = 31; i < 63; ++i) { const auto c = bytes[i]; if (!c) break; volumeName += char(c & 127); if (c & 128) break; } volumes.push_back({"os9:0:" + std::to_string(extent), "os9", volumeName.empty() ? "OS-9 volume" : "OS-9 — " + volumeName, 0, extent, 0}); hdbStart = extent; } const size_t slots = (bytes.size() - hdbStart) / decbVolumeBytes; for (size_t index = 0; index < slots; ++index) { const size_t offset = hdbStart + index * decbVolumeBytes; bool bootOverlap = false; for (const auto& range : protectedBoot) if (offset < range.offset + range.length && range.offset < offset + decbVolumeBytes) bootOverlap = true; if (bootOverlap) continue; // bootstrap storage is never a writable BASIC disk Image image; image.bytes.assign(bytes.begin() + offset, bytes.begin() + offset + decbVolumeBytes); try { validateDECB(image); } catch (const std::exception&) { continue; } // unformatted/foreign slots remain opaque const bool hard = hdbStart != 0 || slots > 1; volumes.push_back({"decb:" + std::to_string(offset) + ":" + std::to_string(decbVolumeBytes), "decb", hard ? "HDB-DOS disk " + std::to_string(index) : "Disk BASIC", offset, decbVolumeBytes, index}); } if (volumes.empty()) fail("No supported OS-9 or Disk BASIC volume was found. Unformatted and foreign regions are preserved without modification."); return volumes; } const Volume& selected(const std::vector& volumes, NSString *identifier) { const auto id = string(identifier); for (const auto& volume : volumes) if (volume.id == id) return volume; fail("The selected volume no longer matches this image. Reopen the editor and choose it again."); } std::vector toolPath(NSURL *url, const std::string& path) { const auto full = std::string(url.fileSystemRepresentation) + ',' + path; std::vector result(full.begin(), full.end()); result.push_back(0); return result; } void check(error_code error, const char *operation) { if (error) fail(std::string(operation) + " failed (ToolShed error " + std::to_string(error) + ")."); } struct OpenPath { bool decb; decb_path_id d = nullptr; os9_path_id o = nullptr; OpenPath(bool value) : decb(value) {} ~OpenPath() { if (d) _decb_close(d); if (o) _os9_close(o); } void open(NSURL *url, const std::string& path, int mode = FAM_READ) { auto p = toolPath(url, path); if (decb) { decb_path_id opened = nullptr; check(_decb_open(&opened,p.data(),mode),"Open image file"); d = opened; } else { os9_path_id opened = nullptr; check(_os9_open(&opened,p.data(),mode),"Open image file"); o = opened; } } void close() { if (d) { const auto result = _decb_close(d); d = nullptr; check(result, "Close image file"); } if (o) { const auto result = _os9_close(o); o = nullptr; check(result, "Close image file"); } } }; NSData *readEntry(NSURL *url, const Image& image, const std::string& path) { const auto& n = image.find(path); if (n.directory) fail("Choose a file to export or inspect."); if (n.size > fileLimit) fail("Export or inspect files no larger than 16 MiB."); if (!image.decb && image.unit > sectorSize) return [NSData dataWithBytes:n.content.data() length:n.content.size()]; OpenPath file(image.decb); file.open(url, n.path); Bytes out(n.size); size_t offset = 0; while (offset < out.size()) { u_int count = u_int(out.size() - offset); const auto result = image.decb ? _decb_read(file.d, out.data() + offset, &count) : _os9_read(file.o, out.data() + offset, &count); if (count > out.size() - offset || !count || (result && result != EOS_EOF)) fail("The file could not be read completely."); offset += count; } file.close(); if (out != n.content) fail("The filesystem reader disagrees with the validated file allocation."); return [NSData dataWithBytes:out.data() length:out.size()]; } // OS-9 directory entries are 32-byte records aligned within 256-byte sectors. // Relinking them leaves every file descriptor and data allocation untouched. size_t directoryOffset(const Node& directory, size_t logical) { if (!directory.directory || logical % 32 || logical / sectorSize >= directory.dataSectors.size()) fail("The OS-9 directory entry is outside its allocation."); return directory.dataSectors[logical / sectorSize] * sectorSize + logical % sectorSize; } size_t findDirectoryEntry(const Image& image, const Node& directory, const Node& node) { for (size_t i = 0; i < directory.size; i += 32) { if (!directory.content[i]) continue; std::string entryName; for (size_t j = 0; j < 29; ++j) { const auto c = directory.content[i + j]; entryName += char(c & 127); if (c & 128) break; } if (lower(entryName) == lower(node.name) && be(directory.content, i + 29, 3) == node.descriptorSector) return directoryOffset(directory, i); } fail("The selected file's directory entry changed. Refresh and select it again."); } void putBigEndian(Bytes& bytes, size_t offset, size_t length, size_t value) { if (offset > bytes.size() || length > bytes.size() - offset || (length < sizeof(size_t) && value >> (length * 8))) fail("The OS-9 directory metadata exceeds its supported bounds."); for (size_t i = 0; i < length; ++i) { bytes[offset + length - i - 1] = uint8_t(value); value >>= 8; } } void growDirectory(Bytes& bytes, Node& directory) { const size_t sectors = bytes.size() / sectorSize; const size_t cluster = be(bytes, 6, 2); size_t freeSector = 0; for (size_t s = cluster; s + cluster <= sectors; s += cluster) if (!(bytes[sectorSize + (s / cluster) / 8] & (0x80 >> ((s / cluster) % 8)))) { freeSector = s; break; } if (!freeSector) fail("The destination directory needs another sector, but the OS-9 disk is full."); const size_t fd = directory.descriptorSector * sectorSize; size_t freeSegment = size_t(-1), lastSegment = size_t(-1); for (size_t i = 0; i < 48; ++i) { const size_t segment = fd + 16 + i * 5; if (be(bytes, segment + 3, 2)) lastSegment = segment; else if (freeSegment == size_t(-1)) freeSegment = segment; } // RBF on the 6x09 keeps a segment within one allocation-map sector // (2048 single-sector clusters). Prefer adjacent legal growth first. if (lastSegment != size_t(-1)) { const size_t start = be(bytes, lastSegment, 3), count = be(bytes, lastSegment + 3, 2), adjacent = start + count; if (count + cluster <= 65535 && adjacent + cluster <= sectors && adjacent % cluster == 0 && adjacent / cluster / 2048 == start / cluster / 2048 && !(bytes[sectorSize + (adjacent / cluster) / 8] & (0x80 >> ((adjacent / cluster) % 8)))) freeSector = adjacent; } if (lastSegment != size_t(-1) && be(bytes, lastSegment, 3) + be(bytes, lastSegment + 3, 2) == freeSector && freeSector / cluster / 2048 == be(bytes, lastSegment, 3) / cluster / 2048 && be(bytes, lastSegment + 3, 2) + cluster <= 65535) { putBigEndian(bytes, lastSegment + 3, 2, be(bytes, lastSegment + 3, 2) + cluster); } else { // Append after the last occupied segment so logical directory offsets // remain stable even when an input descriptor contains segment holes. const size_t appended = lastSegment == size_t(-1) ? fd + 16 : lastSegment + 5; // Match the retained allocator: leave its final descriptor segment // empty, although inspection accepts existing 48-segment images. if (freeSegment == size_t(-1) || appended >= fd + 16 + 47 * 5) fail("The destination directory has no room for another allocation segment."); putBigEndian(bytes, appended, 3, freeSector); putBigEndian(bytes, appended + 3, 2, cluster); } bytes[sectorSize + (freeSector / cluster) / 8] |= uint8_t(0x80 >> ((freeSector / cluster) % 8)); std::fill(bytes.begin() + freeSector * sectorSize, bytes.begin() + (freeSector + cluster) * sectorSize, 0); for (size_t s = freeSector; s < freeSector + cluster; ++s) directory.dataSectors.push_back(s); } // The retained allocator scans sector counts as bitmap bits for multi-sector // clusters. Keep those volumes on this bounded, cluster-aware transaction path // rather than passing them to allocator entry points that can overrun the map. size_t clusterSize(const Bytes& bytes) { return be(bytes, 6, 2); } void markCluster(Bytes& bytes, size_t sector, bool allocated) { const size_t bit = sector / clusterSize(bytes), byte = sectorSize + bit / 8; if (byte >= sectorSize + be(bytes, 4, 2)) fail("The OS-9 allocation bit is outside its bitmap."); const uint8_t mask = uint8_t(0x80 >> (bit % 8)); if (allocated) bytes[byte] |= mask; else bytes[byte] &= uint8_t(~mask); } size_t allocateCluster(Bytes& bytes) { const size_t cluster = clusterSize(bytes), sectors = bytes.size() / sectorSize; for (size_t sector = cluster; sector + cluster <= sectors; sector += cluster) { const size_t bit = sector / cluster; if (!(bytes[sectorSize + bit / 8] & (0x80 >> (bit % 8)))) { markCluster(bytes, sector, true); std::fill(bytes.begin() + sector * sectorSize, bytes.begin() + (sector + cluster) * sectorSize, 0); return sector; } } fail("The OS-9 volume has no free complete allocation cluster."); } void appendSegment(Bytes& bytes, Node& node, size_t start, size_t count) { const size_t descriptor = node.descriptorSector * sectorSize, cluster = clusterSize(bytes); size_t last = size_t(-1), slot = 0; for (; slot < 47; ++slot) { const size_t entry = descriptor + 16 + slot * 5; if (!be(bytes, entry + 3, 2)) break; last = entry; } if (last != size_t(-1) && be(bytes, last, 3) + be(bytes, last + 3, 2) == start && be(bytes, last + 3, 2) + count <= 65535 && be(bytes, last, 3) / cluster / 2048 == (start + count - 1) / cluster / 2048) { putBigEndian(bytes, last + 3, 2, be(bytes, last + 3, 2) + count); } else { if (slot >= 47) fail("The OS-9 file has no room for another allocation segment."); putBigEndian(bytes, descriptor + 16 + slot * 5, 3, start); putBigEndian(bytes, descriptor + 19 + slot * 5, 2, count); } for (size_t sector = start; sector < start + count; ++sector) node.dataSectors.push_back(sector); } std::array directoryEntry(const std::string& name, size_t descriptor) { std::array entry{}; std::copy(name.begin(), name.end(), entry.begin()); entry[name.size() - 1] |= 0x80; entry[29] = uint8_t(descriptor >> 16); entry[30] = uint8_t(descriptor >> 8); entry[31] = uint8_t(descriptor); return entry; } void insertEntry(Bytes& bytes, Node& parent, const std::string& name, size_t descriptor) { size_t logical = 0; while (logical < parent.content.size() && parent.content[logical]) logical += 32; if (logical == parent.content.size()) { if (logical + 32 > parent.dataSectors.size() * sectorSize) growDirectory(bytes, parent); parent.content.resize(logical + 32, 0); parent.size = parent.content.size(); putBigEndian(bytes, parent.descriptorSector * sectorSize + 9, 4, parent.size); } const auto entry = directoryEntry(name, descriptor); const size_t offset = directoryOffset(parent, logical); std::copy(entry.begin(), entry.end(), bytes.begin() + offset); std::copy(entry.begin(), entry.end(), parent.content.begin() + logical); } void deleteClusterEntry(Bytes& bytes, const Image& image, const Node& node) { const size_t entry = findDirectoryEntry(image, image.find(node.parent), node); std::fill_n(bytes.begin() + entry, 32, 0); const size_t descriptor = node.descriptorSector * sectorSize; if (--bytes[descriptor + 8]) return; const size_t cluster = clusterSize(bytes); std::set owned{node.descriptorSector / cluster}; for (const size_t sector : node.dataSectors) owned.insert(sector / cluster); const size_t mapSectors = (be(bytes, 4, 2) + sectorSize - 1) / sectorSize; for (const size_t index : owned) { if (index * cluster <= mapSectors) fail("A removed entry shares a reserved filesystem cluster."); markCluster(bytes, index * cluster, false); } } Bytes createClusterEntry(const Image& image, const Node& parentInput, const std::string& filename, const uint8_t *data, size_t length, bool directory, bool replace) { Bytes bytes = image.bytes; Node parent = parentInput; const auto path = parent.path.empty() ? filename : parent.path + '/' + filename; auto existing = image.nodes.find(lower(path)); if (existing != image.nodes.end()) { if (!replace || existing->second.directory) fail("An entry already has that name."); deleteClusterEntry(bytes, image, existing->second); const size_t offset = findDirectoryEntry(image, parent, existing->second); for (size_t logical = 0; logical < parent.content.size(); logical += 32) if (directoryOffset(parent, logical) == offset) std::fill_n(parent.content.begin() + logical, 32, 0); } const size_t cluster = clusterSize(bytes), descriptor = allocateCluster(bytes); Node node; node.descriptorSector = descriptor; node.directory = directory; const size_t base = descriptor * sectorSize; bytes[base] = directory ? 0xbf : 0x0b; bytes[base + 8] = 1; NSDateComponents *now = [[NSCalendar currentCalendar] components:NSCalendarUnitYear|NSCalendarUnitMonth|NSCalendarUnitDay|NSCalendarUnitHour|NSCalendarUnitMinute fromDate:NSDate.date]; bytes[base + 3] = uint8_t(now.year - 1900); bytes[base + 4] = uint8_t(now.month); bytes[base + 5] = uint8_t(now.day); bytes[base + 6] = uint8_t(now.hour); bytes[base + 7] = uint8_t(now.minute); std::copy_n(bytes.begin() + base + 3, 3, bytes.begin() + base + 13); if (cluster > 1) appendSegment(bytes, node, descriptor + 1, cluster - 1); Bytes directoryData; if (directory) { directoryData.resize(64); const auto dot = directoryEntry(".", descriptor), up = directoryEntry("..", parent.descriptorSector); std::copy(dot.begin(), dot.end(), directoryData.begin()); std::copy(up.begin(), up.end(), directoryData.begin() + 32); data = directoryData.data(); length = directoryData.size(); } while (node.dataSectors.size() * sectorSize < length) appendSegment(bytes, node, allocateCluster(bytes), cluster); for (size_t logical = 0; logical < length; ++logical) bytes[node.dataSectors[logical / sectorSize] * sectorSize + logical % sectorSize] = data[logical]; putBigEndian(bytes, base + 9, 4, length); insertEntry(bytes, parent, filename, descriptor); return bytes; } Bytes movedOS9Files(const Image& image, NSArray *paths, NSString *destination) { if (image.decb) fail("Moving files between folders is available only for OS-9 images."); if (paths.count == 0 || paths.count > 4096) fail("Select from one to 4096 regular files to move."); Node target = image.find(imagePath(destination, false, true)); if (!target.directory) fail("Choose an OS-9 destination folder."); struct Move { const Node *node; size_t offset; std::array entry; }; std::vector moves; std::set sources, names; for (NSString *path in paths) { if (![path isKindOfClass:NSString.class]) fail("Select valid image paths to move."); const auto& node = image.find(imagePath(path, false)); if (node.directory) fail("Move regular files only. Folders are destinations and cannot be moved."); if (!sources.insert(lower(node.path)).second) fail("A file was selected more than once. Refresh the selection."); if (lower(node.parent) == lower(target.path)) fail("The selected file is already in that folder. Choose a different destination."); const auto dest = target.path.empty() ? node.name : target.path + '/' + node.name; if (!names.insert(lower(node.name)).second || image.nodes.count(lower(dest))) fail("A destination name already exists or repeats within the selection. No files were moved; choose another folder."); const size_t offset = findDirectoryEntry(image, image.find(node.parent), node); Move move{&node, offset, {}}; std::copy_n(image.bytes.begin() + offset, 32, move.entry.begin()); moves.push_back(move); } Bytes next = image.bytes; for (const auto& move : moves) { size_t slot = 0; while (slot < target.content.size() && target.content[slot]) slot += 32; if (slot == target.content.size()) { if (slot + 32 > target.dataSectors.size() * sectorSize) growDirectory(next, target); target.content.resize(slot + 32, 0); target.size = target.content.size(); putBigEndian(next, target.descriptorSector * sectorSize + 9, 4, target.size); } const size_t offset = directoryOffset(target, slot); std::copy(move.entry.begin(), move.entry.end(), next.begin() + offset); std::copy(move.entry.begin(), move.entry.end(), target.content.begin() + slot); } // A plan is complete before any source entry is removed or any file is // written. Failure at any point leaves the caller's working image intact. for (const auto& move : moves) std::fill_n(next.begin() + move.offset, 32, 0); for (const auto& move : moves) { const size_t descriptor = move.node->descriptorSector * sectorSize; if (!std::equal(image.bytes.begin() + descriptor, image.bytes.begin() + descriptor + sectorSize, next.begin() + descriptor)) fail("A move changed a file descriptor; no changes were kept."); for (const size_t sector : move.node->dataSectors) if (!std::equal(image.bytes.begin() + sector * sectorSize, image.bytes.begin() + (sector + 1) * sectorSize, next.begin() + sector * sectorSize)) fail("A move changed file data; no changes were kept."); } return next; } void setError(NSError **error, const std::exception& value) { if (error) *error = [NSError errorWithDomain:@"VCCDiskImageEditor" code:1 userInfo:@{NSLocalizedDescriptionKey:text(value.what())}]; } void restore(NSURL *url, const Bytes& bytes) { NSError *error = nil; if (![[NSData dataWithBytes:bytes.data() length:bytes.size()] writeToURL:url options:NSDataWritingAtomic error:&error]) fail("A working-image operation failed and its private copy could not be restored. Close the editor and reopen the original image."); } template BOOL mutate(NSURL *url, Operation operation, NSError **error) { std::lock_guard lock(backendMutex); try { auto image = inspect(url); try { operation(image); const auto after = load(url); if (after.size() != image.bytes.size() || (image.decb && !std::equal(image.bytes.begin() + decbVolumeBytes, image.bytes.end(), after.begin() + decbVolumeBytes))) fail("The filesystem operation changed the image size or protected supplementary tracks. The private working image has been restored."); (void)inspect(url); } catch (...) { restore(url, image.bytes); throw; } return YES; } catch (const std::exception& value) { setError(error, value); return NO; } } NSString *attributes(unsigned bits) { NSMutableArray *items = [NSMutableArray array]; for (const auto& item : std::array,8>{{{0x80,"d"},{0x40,"s"},{1,"r"},{2,"w"},{4,"e"},{8,"pr"},{16,"pw"},{32,"pe"}}}) if (bits & item.first) [items addObject:@(item.second)]; return [items componentsJoinedByString:@" "]; } } @implementation VCCDiskImageEditorBackend + (NSArray *> *)discoverVolumesAtURL:(NSURL *)imageURL error:(NSError **)error { std::lock_guard lock(backendMutex); try { diskimage_format format = DISKIMAGE_UNKNOWN; if (_diskimage_identify(imageURL.fileSystemRepresentation, &format) || format != DISKIMAGE_RAW) fail("The editor supports raw floppy and hard-drive images; other containers are preserved without conversion."); const auto bytes = load(imageURL); const auto volumes = discover(bytes); NSMutableArray *rows = [NSMutableArray array]; for (const auto& volume : volumes) [rows addObject:@{@"id":text(volume.id), @"format":text(volume.format), @"name":text(volume.name), @"offset_bytes":@(volume.offset), @"byte_count":@(volume.length), @"index":@(volume.index)}]; return rows; } catch (const std::exception& value) { setError(error, value); return nil; } } + (BOOL)extractVolume:(NSString *)volumeID imageURL:(NSURL *)imageURL outputURL:(NSURL *)outputURL error:(NSError **)error { std::lock_guard lock(backendMutex); try { const auto bytes = load(imageURL); const auto volumes = discover(bytes); const auto volume = selected(volumes, volumeID); if ([imageURL.URLByResolvingSymlinksInPath isEqual:outputURL.URLByResolvingSymlinksInPath]) fail("Extract a volume to a separate private working file."); Bytes part(bytes.begin() + volume.offset, bytes.begin() + volume.offset + volume.length); if (volume.format == "os9" && !externalBootRanges(bytes, volume.length).empty()) clearExternalBootPointer(part); restore(outputURL, part); return YES; } catch (const std::exception& value) { setError(error, value); return NO; } } + (BOOL)replaceVolume:(NSString *)volumeID imageURL:(NSURL *)imageURL volumeURL:(NSURL *)volumeURL error:(NSError **)error { std::lock_guard lock(backendMutex); try { auto bytes = load(imageURL); const auto volumes = discover(bytes); const auto volume = selected(volumes, volumeID); const auto part = inspect(volumeURL); if (part.bytes.size() != volume.length || part.decb != (volume.format == "decb")) fail("The edited volume changed its size or filesystem type. No changes were applied."); const bool externalBoot = volume.format == "os9" && !externalBootRanges(bytes, volume.length).empty(); std::array pointer{}; if (externalBoot) std::copy_n(bytes.begin() + offsetof(lsn0_sect, dd_bt), 5, pointer.begin()); std::copy(part.bytes.begin(), part.bytes.end(), bytes.begin() + volume.offset); if (externalBoot) std::copy(pointer.begin(), pointer.end(), bytes.begin() + offsetof(lsn0_sect, dd_bt)); (void)discover(bytes); // validate the original boot pointer in its full container context restore(imageURL, bytes); return YES; } catch (const std::exception& value) { setError(error, value); return NO; } } + (NSDictionary *)inspectImageAtURL:(NSURL *)imageURL error:(NSError **)error { std::lock_guard lock(backendMutex); try { const auto image = inspect(imageURL); return @{@"format":image.decb ? @"decb" : @"os9", @"format_name":image.decb ? @"Disk BASIC" : @"OS-9 RBF", @"byte_count":@(image.bytes.size()), @"writable":@YES, @"capacity_bytes":@(image.capacity), @"used_bytes":@(image.capacity - image.free), @"free_bytes":@(image.free), @"allocation_unit_bytes":@(image.unit), @"protected_suffix_bytes":@(image.decb ? image.bytes.size() - decbVolumeBytes : 0)}; } catch (const std::exception& value) { setError(error, value); return nil; } } + (NSArray *> *)listDirectory:(NSString *)directory imageURL:(NSURL *)imageURL error:(NSError **)error { std::lock_guard lock(backendMutex); try { const auto image = inspect(imageURL); const auto path = imagePath(directory, image.decb, true); const auto& folder = image.find(path); if (!folder.directory) fail("This entry is not a directory."); NSMutableArray *rows = [NSMutableArray array]; for (const auto& pair : image.nodes) { const auto& n = pair.second; if (n.path.empty() || lower(n.parent) != lower(folder.path)) continue; NSString *type = image.decb ? @[@"BASIC program",@"BASIC data",@"Machine language",@"Text"][n.type] : n.directory ? @"Folder" : @"OS-9 file"; [rows addObject:@{@"name":text(n.name),@"path":text(n.path),@"size":@(n.size),@"is_directory":@(n.directory),@"type":type,@"file_type":image.decb ? @(n.type) : NSNull.null,@"encoding":image.decb ? (n.ascii ? @"ASCII" : @"Binary") : @"",@"ascii":@(n.ascii != 0),@"attributes":image.decb ? @"" : attributes(n.attributes),@"permissions":image.decb ? NSNull.null : @(n.attributes & 0x7f),@"owner":@(n.owner),@"group":@(n.group),@"modified":n.modified}]; } return rows; } catch (const std::exception& value) { setError(error, value); return nil; } } + (NSData *)readFile:(NSString *)path imageURL:(NSURL *)imageURL error:(NSError **)error { std::lock_guard lock(backendMutex); try { const auto image = inspect(imageURL); return readEntry(imageURL, image, imagePath(path, image.decb)); } catch (const std::exception& value) { setError(error, value); return nil; } } + (NSString *)identifyFile:(NSString *)path imageURL:(NSURL *)imageURL error:(NSError **)error { std::lock_guard lock(backendMutex); try { const auto image = inspect(imageURL); NSData *data = readEntry(imageURL, image, imagePath(path, image.decb)); const auto *begin = static_cast(data.bytes); Bytes bytes(begin, begin + data.length); NSMutableArray *modules = [NSMutableArray array]; size_t offset = 0; while (offset < bytes.size()) { const bool os9 = bytes.size() - offset >= OS9_HEADER_SIZE && be(bytes, offset, 2) == 0x87cd; const bool osk = bytes.size() - offset >= OSK_HEADER_SIZE && be(bytes, offset, 2) == 0x4afc; if (!os9 && !osk) fail("The selected file does not contain a complete supported OS-9 module."); const size_t header = os9 ? OS9_HEADER_SIZE : OSK_HEADER_SIZE, size = be(bytes, offset + (os9 ? 2 : 4), os9 ? 2 : 4), nameOffset = be(bytes, offset + (os9 ? 4 : 12), os9 ? 2 : 4); if (size < header + 3 || size > bytes.size() - offset || nameOffset >= size - 3) fail("The OS-9 module has a truncated or invalid header."); std::string moduleName; bool ended = false; for (size_t i = nameOffset; i < size - 3 && moduleName.size() < 255; ++i) { const auto c = bytes[offset + i]; if ((c & 127) < 32 || (c & 127) > 126) fail("The OS-9 module name is invalid."); moduleName += char(c & 127); if (c & 128) { ended = true; break; } } if (!ended) fail("The OS-9 module name is not terminated."); u_char crc[3] = {255,255,255}; const bool good = _os9_crc_compute(bytes.data() + offset, u_int(size), crc) != 0; [modules addObject:[NSString stringWithFormat:@"%@ module: %@\nOffset: %zu bytes\nSize: %zu bytes\nCRC: %@",os9 ? @"OS-9/6809" : @"OS-9/68K",text(moduleName),offset,size,good ? @"Valid" : @"Mismatch"]]; offset += size; } if (!modules.count) fail("The selected file is empty."); return [modules componentsJoinedByString:@"\n\n"]; } catch (const std::exception& value) { setError(error, value); return nil; } } + (BOOL)importData:(NSData *)data named:(NSString *)filename directory:(NSString *)directory imageURL:(NSURL *)imageURL fileType:(NSInteger)fileType ascii:(BOOL)ascii replace:(BOOL)replace error:(NSError **)error { return mutate(imageURL, [&](const Image& image) { if (data.length > fileLimit || fileType < 0 || fileType > 3) fail("Choose a supported file type and a file no larger than 16 MiB."); const auto dir = imagePath(directory, image.decb, true); const auto& parent = image.find(dir); if (!parent.directory) fail("The import destination is not a directory."); const auto base = name(string(filename), image.decb); const auto dest = parent.path.empty() ? base : parent.path + '/' + base; const auto existing = image.nodes.find(lower(dest)); if (existing != image.nodes.end() && (!replace || existing->second.directory)) fail(existing->second.directory ? "A directory already has that name." : "A file already has that name. Confirm replacement or use a different name."); if (data.length > image.capacity) fail("This file is larger than the disk's usable capacity."); if (!image.decb && image.unit > sectorSize) { restore(imageURL, createClusterEntry(image, parent, base, static_cast(data.bytes), data.length, false, replace)); return; } OpenPath file(image.decb); auto path = toolPath(imageURL, dest); if (image.decb) { decb_path_id opened = nullptr; check(_decb_create(&opened,path.data(),FAM_WRITE | (replace ? 0 : FAM_NOCREATE),int(fileType),ascii ? 255 : 0),"Create image file"); file.d = opened; } else { os9_path_id opened = nullptr; check(_os9_create(&opened,path.data(),FAM_WRITE | (replace ? 0 : FAM_NOCREATE),FAP_READ|FAP_WRITE|FAP_PREAD),"Create image file"); file.o = opened; } size_t offset = 0; const auto *bytes = static_cast(data.bytes); while (offset < data.length) { u_int count = u_int(data.length - offset); const auto result = image.decb ? _decb_write(file.d,const_cast(bytes + offset),&count) : _os9_write(file.o,const_cast(bytes + offset),&count); check(result,"Write image file"); if (!count || count > data.length - offset) fail("The image writer did not complete the file."); offset += count; } file.close(); }, error); } + (BOOL)makeDirectory:(NSString *)filename inDirectory:(NSString *)directory imageURL:(NSURL *)imageURL error:(NSError **)error { return mutate(imageURL, [&](const Image& image) { if (image.decb) fail("Disk BASIC images do not support folders."); const auto dir = imagePath(directory,false,true); const auto& parent = image.find(dir); if (!parent.directory) fail("The destination is not a directory."); const auto base = name(string(filename),false); const auto dest = parent.path.empty() ? base : parent.path + '/' + base; if (image.nodes.count(lower(dest))) fail("An entry already has that name."); if (image.unit > sectorSize) { restore(imageURL, createClusterEntry(image, parent, base, nullptr, 0, true, false)); return; } auto path = toolPath(imageURL,dest); check(_os9_makdir(path.data()),"Create OS-9 directory"); }, error); } + (BOOL)renameEntry:(NSString *)entry toName:(NSString *)filename imageURL:(NSURL *)imageURL error:(NSError **)error { return mutate(imageURL, [&](const Image& image) { const auto& node = image.find(imagePath(entry,image.decb)); const auto base = name(string(filename),image.decb); const auto dest = node.parent.empty() ? base : node.parent + '/' + base; if (image.nodes.count(lower(dest))) fail("An entry already has that name."); if (!image.decb && image.unit > sectorSize) { auto bytes = image.bytes; const size_t offset = findDirectoryEntry(image, image.find(node.parent), node); const auto entry = directoryEntry(base, node.descriptorSector); std::copy(entry.begin(), entry.end(), bytes.begin() + offset); restore(imageURL, bytes); return; } auto path = toolPath(imageURL,node.path); std::vector newName(base.begin(),base.end());newName.push_back(0); check(image.decb ? _decb_rename(path.data(),newName.data()) : _os9_rename(path.data(),newName.data()),"Rename image entry"); }, error); } + (BOOL)deleteEntry:(NSString *)entry directory:(BOOL)directory imageURL:(NSURL *)imageURL error:(NSError **)error { return mutate(imageURL, [&](const Image& image) { const auto& node = image.find(imagePath(entry,image.decb)); if (node.directory != bool(directory)) fail("The selected entry changed type. Refresh the directory."); if (node.directory) for (const auto& pair : image.nodes) if (!pair.second.path.empty() && lower(pair.second.parent) == lower(node.path)) fail("Delete the folder's contents before deleting the folder."); if (!image.decb && image.unit > sectorSize) { auto bytes = image.bytes; deleteClusterEntry(bytes, image, node); restore(imageURL, bytes); return; } auto path = toolPath(imageURL,node.path); check(image.decb ? _decb_kill(path.data()) : node.directory ? _os9_delete_directory(path.data()) : _os9_delete(path.data()),"Delete image entry"); }, error); } + (BOOL)moveFiles:(NSArray *)paths toDirectory:(NSString *)directory imageURL:(NSURL *)imageURL error:(NSError **)error { return mutate(imageURL, [&](const Image& image) { restore(imageURL, movedOS9Files(image, paths, directory)); }, error); } + (BOOL)setOS9MetadataForPath:(NSString *)entry imageURL:(NSURL *)imageURL ownerUser:(NSInteger)ownerUser ownerGroup:(NSInteger)ownerGroup permissions:(NSInteger)permissions error:(NSError **)error { return mutate(imageURL, [&](const Image& image) { if (image.decb) fail("Disk BASIC entries do not have OS-9 ownership or permission attributes."); if (ownerUser < 0 || ownerUser > 255 || ownerGroup < 0 || ownerGroup > 255 || permissions < 0 || permissions > 127) fail("Use owner user and group values from 0 to 255 and permission bits from 0 to 127. The directory type cannot be changed."); const auto& node = image.find(imagePath(entry, false, true)); // Host disk maintenance deliberately does not impersonate a guest UID. // A raw RBF path can repair even an entry with no guest access bits, // without changing it temporarily or bypassing host write protection. if (image.unit > sectorSize) { auto bytes = image.bytes; const size_t offset = node.descriptorSector * sectorSize; bytes[offset] = uint8_t((bytes[offset] & 0x80) | permissions); bytes[offset + 1] = uint8_t(ownerGroup); bytes[offset + 2] = uint8_t(ownerUser); restore(imageURL, bytes); return; } OpenPath raw(false); raw.open(imageURL, "@", FAM_WRITE); fd_stats descriptor{}; check(_os9_lsn_get(raw.o, int(node.descriptorSector), 0, &descriptor, sizeof(descriptor)), "Read OS-9 descriptor"); const size_t offset = node.descriptorSector * sectorSize; const auto *actual = reinterpret_cast(&descriptor); if (!std::equal(actual, actual + sizeof(descriptor), image.bytes.begin() + offset)) fail("The OS-9 descriptor changed while its metadata was being edited."); descriptor.fd_att = static_cast((descriptor.fd_att & FAP_DIR) | permissions); descriptor.fd_own[0] = static_cast(ownerGroup); descriptor.fd_own[1] = static_cast(ownerUser); check(_os9_lsn_put(raw.o, int(node.descriptorSector), 0, &descriptor, sizeof(descriptor)), "Write OS-9 metadata"); raw.close(); auto expected = image.bytes; expected[offset] = descriptor.fd_att; expected[offset + 1] = descriptor.fd_own[0]; expected[offset + 2] = descriptor.fd_own[1]; if (load(imageURL) != expected) fail("The metadata edit changed bytes outside the entry's attributes and owner. The private working image has been restored."); }, error); } @end