hfs_catalog.cpp

Go to the documentation of this file.

// hfs_catalog.cpp -- HFS+ catalog record body decoders.
 
#include "hfs_catalog.hpp"
#include "hfs_unicode.hpp"
 
#include <algorithm>
#include <cstring>
 
namespace hfs {
 
namespace {
 
// HFSPlusBSDInfo at offset 0x20 within both folder and file bodies
// (16 bytes):
//   __be32 ownerID
//   __be32 groupID
//   __u8   adminFlags
//   __u8   ownerFlags
//   __be16 fileMode
//   __be32 special
BSDInfo parse_bsd_info(const unsigned char* p) {
    BSDInfo b;
    b.ownerID    = be32(p + 0x00);
    b.groupID    = be32(p + 0x04);
    b.adminFlags = p[0x08];
    b.ownerFlags = p[0x09];
    b.fileMode   = be16(p + 0x0A);
    b.special    = be32(p + 0x0C);
    return b;
}
 
// FinderInfo (16 bytes) -- we only care about fileType+fileCreator
// for files. For folders the layout differs but we don't use it.
FinderInfo16 parse_finder_info(const unsigned char* p) {
    FinderInfo16 f;
    f.fileType    = be32(p + 0x00);
    f.fileCreator = be32(p + 0x04);
    f.finderFlags = be16(p + 0x08);
    return f;
}
 
} // anonymous namespace
 
bool parse_catalog_folder(const unsigned char* body, uint32_t body_len,
                           CatalogFolder& out) {
    if (body == nullptr || body_len < 86) return false;
    // Body layout (after the 2-byte recordType already consumed):
    //   0x00 __be16 flags
    //   0x02 __be32 valence
    //   0x06 __be32 folderID
    //   0x0A __be32 createDate
    //   0x0E __be32 contentModDate
    //   0x12 __be32 attributeModDate
    //   0x16 __be32 accessDate
    //   0x1A __be32 backupDate
    //   0x1E HFSPlusBSDInfo permissions (16)
    //   0x2E userInfo (16)
    //   0x3E ExtendedFolderInfo (16) -- skipped
    //   0x4E __be32 textEncoding
    //   0x52 __be32 reserved
    // Total body = 86 bytes (not 88 -- the 2 bytes of recordType are
    // separate from this "body" view).
    out = {};
    out.flags             = be16(body + 0x00);
    out.valence           = be32(body + 0x02);
    out.folderID          = be32(body + 0x06);
    out.createDate        = be32(body + 0x0A);
    out.contentModDate    = be32(body + 0x0E);
    out.attributeModDate  = be32(body + 0x12);
    out.accessDate        = be32(body + 0x16);
    out.backupDate        = be32(body + 0x1A);
    out.permissions       = parse_bsd_info(body + 0x1E);
    out.userInfo          = parse_finder_info(body + 0x2E);
    out.textEncoding      = be32(body + 0x4E);
    return true;
}
 
bool parse_catalog_file(const unsigned char* body, uint32_t body_len,
                         CatalogFile& out) {
    if (body == nullptr || body_len < 246) return false;
    // Body layout (after the 2-byte recordType):
    //   0x00 __be16 flags
    //   0x02 __be32 reserved1
    //   0x06 __be32 fileID
    //   0x0A __be32 createDate
    //   0x0E __be32 contentModDate
    //   0x12 __be32 attributeModDate
    //   0x16 __be32 accessDate
    //   0x1A __be32 backupDate
    //   0x1E permissions (16)
    //   0x2E userInfo (16)
    //   0x3E ExtendedFileInfo (16)
    //   0x4E __be32 textEncoding
    //   0x52 __be32 reserved2
    //   0x56 dataFork (80)
    //   0xA6 resourceFork (80)
    // Total body = 246 bytes.
    out = {};
    out.flags             = be16(body + 0x00);
    out.fileID            = be32(body + 0x06);
    out.createDate        = be32(body + 0x0A);
    out.contentModDate    = be32(body + 0x0E);
    out.attributeModDate  = be32(body + 0x12);
    out.accessDate        = be32(body + 0x16);
    out.backupDate        = be32(body + 0x1A);
    out.permissions       = parse_bsd_info(body + 0x1E);
    out.userInfo          = parse_finder_info(body + 0x2E);
    out.textEncoding      = be32(body + 0x4E);
    if (!parse_fork_data(body + 0x56, out.dataFork))     return false;
    if (!parse_fork_data(body + 0xA6, out.resourceFork)) return false;
    return true;
}
 
std::string catalog_name_to_host(const unsigned char* utf16be_name,
                                  uint16_t name_units) {
    // Use the unicode helper from session 1: utf16be -> utf8 + NFD->NFC
    std::string nfc = hfs::hfs_filename_to_host(utf16be_name, name_units);
    // hfs_filename_to_host already strips '/', NUL and Windows reserved chars.
    // Defensive: if the result is empty (weird file), name it "_".
    if (nfc.empty()) return "_";
    // HFS+ allows colons in names (they're path separators on classic Mac);
    // they map to '/' on the POSIX side which we already block. So '/' in
    // the user-facing name on Mac actually corresponds to ':' on disk.
    // Convert any embedded ':' -> '_' as additional safety.
    std::replace(nfc.begin(), nfc.end(), ':', '_');
    return nfc;
}
 
bool is_private_data_folder_name(const unsigned char* utf16be_name,
                                  uint16_t name_units) {
    // Folder name on disk is 4 NUL (UTF-16) units followed by
    // "HFS+ Private Data" (17 ASCII chars).
    if (name_units != kHFSPrivateDataNameLength) return false;
    // First 4 code units (8 bytes) must be all zero.
    for (int i = 0; i < 8; ++i) {
        if (utf16be_name[i] != 0) return false;
    }
    // Remaining 17 code units must be ASCII "HFS+ Private Data"
    static const char* expected = "HFS+ Private Data";
    for (int i = 0; i < 17; ++i) {
        const unsigned char hi = utf16be_name[8 + i * 2];
        const unsigned char lo = utf16be_name[8 + i * 2 + 1];
        if (hi != 0) return false;
        if (lo != static_cast<unsigned char>(expected[i])) return false;
    }
    return true;
}
 
uint32_t parse_inode_filename(const unsigned char* utf16be_name,
                               uint16_t name_units) {
    // "iNode" prefix: 5 ASCII chars + at least 1 digit
    if (name_units < 6) return 0;
    static const char* prefix = "iNode";
    for (int i = 0; i < 5; ++i) {
        const unsigned char hi = utf16be_name[i * 2];
        const unsigned char lo = utf16be_name[i * 2 + 1];
        if (hi != 0) return 0;
        if (lo != static_cast<unsigned char>(prefix[i])) return 0;
    }
    // Decode the trailing digits
    uint32_t num = 0;
    for (uint16_t i = 5; i < name_units; ++i) {
        const unsigned char hi = utf16be_name[i * 2];
        const unsigned char lo = utf16be_name[i * 2 + 1];
        if (hi != 0) return 0;
        if (lo < '0' || lo > '9') return 0;
        const uint32_t prev = num;
        num = num * 10 + (lo - '0');
        if (num < prev) return 0;  // overflow
    }
    return num;
}
 
} // namespace hfs