文件
fnos-apfs/vendor/apfs-fuse/ApfsLib/ApfsDir.cpp
T

848 行
22 KiB
C++

/*
This file is part of apfs-fuse, a read-only implementation of APFS
(Apple File System) for FUSE.
Copyright (C) 2017 Simon Gander
Apfs-fuse is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
Apfs-fuse is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with apfs-fuse. If not, see <http://www.gnu.org/licenses/>.
*/
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <cassert>
#include <cstring>
#include "ApfsDir.h"
#include "ApfsVolume.h"
#include "ApfsContainer.h"
#include "BTree.h"
#include "Util.h"
#ifndef _MSC_VER
template<size_t L>
void strcpy_s(char (&dst)[L], const char *src)
{
strncpy(dst, src, L - 1);
dst[L - 1] = 0;
}
#endif
ApfsDir::Inode::Inode()
{
obj_id = 0;
parent_id = 0;
private_id = 0;
create_time = 0;
mod_time = 0;
change_time = 0;
access_time = 0;
internal_flags = 0;
nchildren_nlink = 0;
default_protection_class = 0;
write_generation_counter = 0;
bsd_flags = 0;
owner = 0;
group = 0;
mode = 0;
uncompressed_size = 0;
snap_xid = 0;
delta_tree_oid = 0;
prev_fsize = 0;
ds_size = 0;
ds_alloced_size = 0;
ds_default_crypto_id = 0;
ds_total_bytes_written = 0;
ds_total_bytes_read = 0;
memset(fs_uuid, 0, sizeof(fs_uuid));
sparse_bytes = 0;
document_id = 0;
rdev = 0;
optional_present_flags = 0;
/*
ino = nullptr;
*/
}
ApfsDir::Inode::Inode(const ApfsDir::Inode& o)
{
obj_id = o.obj_id;
parent_id = o.parent_id;
private_id = o.private_id;
create_time = o.create_time;
mod_time = o.mod_time;
change_time = o.change_time;
access_time = o.access_time;
internal_flags = o.internal_flags;
nchildren_nlink = o.nchildren_nlink;
default_protection_class = o.default_protection_class;
write_generation_counter = o.write_generation_counter;
bsd_flags = o.bsd_flags;
owner = o.owner;
group = o.group;
mode = o.mode;
uncompressed_size = o.uncompressed_size;
snap_xid = o.snap_xid;
delta_tree_oid = o.delta_tree_oid;
prev_fsize = o.prev_fsize;
// FinderInfo
ds_size = o.ds_size;
ds_alloced_size = o.ds_alloced_size;
ds_default_crypto_id = o.ds_default_crypto_id;
ds_total_bytes_written = o.ds_total_bytes_written;
ds_total_bytes_read = o.ds_total_bytes_read;
// j_dir_stats_val_t dir_stats;
memcpy(fs_uuid, o.fs_uuid, sizeof(apfs_uuid_t));
sparse_bytes = o.sparse_bytes;
document_id = o.document_id;;
rdev = o.rdev;
name = o.name;
optional_present_flags = o.optional_present_flags;
/*
ino_val_data = o.ino_val_data;
ino = reinterpret_cast<j_inode_val_t *>(ino_val_data.data());
*/
}
ApfsDir::DirRec::DirRec()
{
parent_id = 0;
hash = 0;
file_id = 0;
date_added = 0;
sibling_id = 0;
flags = 0;
has_sibling_id = false;
}
ApfsDir::DirRec::DirRec(const ApfsDir::DirRec& o)
{
parent_id = o.parent_id;
hash = o.hash;
name = o.name;
file_id = o.file_id;
date_added = o.date_added;
sibling_id = o.sibling_id;
flags = o.flags;
has_sibling_id = o.has_sibling_id;
}
ApfsDir::ApfsDir(ApfsVolume &vol) :
m_vol(vol),
m_fs_tree(vol.fstree())
{
m_txt_fmt = vol.getTextFormat();
m_blksize = vol.getContainer().GetBlocksize();
m_blksize_sh = log2(m_blksize);
m_blksize_mask_lo = m_blksize - 1;
m_blksize_mask_hi = ~m_blksize_mask_lo;
m_tmp_blk.resize(m_blksize);
// m_bt.EnableDebugOutput();
}
ApfsDir::~ApfsDir()
{
}
bool ApfsDir::GetInode(ApfsDir::Inode& res, uint64_t inode)
{
BTreeEntry bte;
j_inode_key_t key;
bool rc;
key.hdr.obj_id_and_type = APFS_TYPE_ID(APFS_TYPE_INODE, inode);
rc = m_fs_tree.Lookup(bte, &key, sizeof(j_inode_key_t), CompareStdDirKey, this, true);
if (!rc || (bte.val == nullptr))
return false;
// const uint8_t *idata = reinterpret_cast<const uint8_t *>(bte.val);
const j_inode_val_t *obj = reinterpret_cast<const j_inode_val_t *>(bte.val);
res.obj_id = inode;
res.parent_id = obj->parent_id;
res.private_id = obj->private_id;
res.create_time = obj->create_time;
res.mod_time = obj->mod_time;
res.change_time = obj->change_time;
res.access_time = obj->access_time;
res.internal_flags = obj->internal_flags;
res.nchildren_nlink = obj->nchildren;
res.default_protection_class = obj->default_protection_class;
res.write_generation_counter = obj->write_generation_counter;
res.bsd_flags = obj->bsd_flags;
res.owner = obj->owner;
res.group = obj->group;
res.mode = obj->mode;
res.uncompressed_size = obj->uncompressed_size;
// internal_flags & 0x00200000 => pad2 = uncompressed_size ?
if (bte.val_len > sizeof(j_inode_val_t))
{
const xf_blob_t *xf_hdr = reinterpret_cast<const xf_blob_t *>(obj->xfields);
const x_field_t *xf = reinterpret_cast<const x_field_t *>(xf_hdr->xf_data);
const uint8_t *xdata = obj->xfields + sizeof(xf_blob_t) + xf_hdr->xf_num_exts * sizeof(x_field_t);
uint16_t n;
for (n = 0; n < xf_hdr->xf_num_exts; n++)
{
switch (xf[n].x_type)
{
case INO_EXT_TYPE_SNAP_XID:
assert(xf[n].x_size == sizeof(uint64_t));
res.snap_xid = bswap_le(*reinterpret_cast<const uint64_t *>(xdata));
res.optional_present_flags |= Inode::INO_HAS_SNAP_XID;
break;
case INO_EXT_TYPE_DELTRA_TREE_OID:
assert(xf[n].x_size == sizeof(uint64_t));
res.delta_tree_oid = bswap_le(*reinterpret_cast<const uint64_t *>(xdata));
res.optional_present_flags |= Inode::INO_HAS_DELTA_TREE_OID;
break;
case INO_EXT_TYPE_DOCUMENT_ID:
assert(xf[n].x_size == sizeof(uint32_t));
res.document_id = bswap_le(*reinterpret_cast<const uint32_t *>(xdata));
res.optional_present_flags |= Inode::INO_HAS_DOCUMENT_ID;
break;
case INO_EXT_TYPE_NAME:
res.name.assign(reinterpret_cast<const char *>(xdata), xf[n].x_size);
res.optional_present_flags |= Inode::INO_HAS_NAME;
break;
case INO_EXT_TYPE_PREV_FSIZE:
assert(xf[n].x_size == sizeof(uint64_t));
res.prev_fsize = bswap_le(*reinterpret_cast<const uint64_t *>(xdata));
res.optional_present_flags |= Inode::INO_HAS_PREV_FSIZE;
break;
case INO_EXT_TYPE_FINDER_INFO:
// TODO
break;
case INO_EXT_TYPE_DSTREAM:
{
assert(xf[n].x_size == sizeof(j_dstream_t));
const j_dstream_t *ds = reinterpret_cast<const j_dstream_t *>(xdata);
res.ds_size = ds->size;
res.ds_alloced_size = ds->alloced_size;
res.ds_default_crypto_id = ds->default_crypto_id;
res.ds_total_bytes_written = ds->total_bytes_written;
res.ds_total_bytes_read = ds->total_bytes_read;
res.optional_present_flags |= Inode::INO_HAS_DSTREAM;
}
break;
case INO_EXT_TYPE_DIR_STATS_KEY:
// TODO
break;
case INO_EXT_TYPE_FS_UUID:
assert(xf[n].x_size == sizeof(apfs_uuid_t));
memcpy(res.fs_uuid, xdata, sizeof(apfs_uuid_t));
res.optional_present_flags |= Inode::INO_HAS_FS_UUID;
break;
case INO_EXT_TYPE_SPARSE_BYTES:
assert(xf[n].x_size == sizeof(uint64_t));
res.sparse_bytes = bswap_le(*reinterpret_cast<const uint64_t *>(xdata));
res.optional_present_flags |= Inode::INO_HAS_SPARSE_BYTES;
break;
default:
std::cerr << "Warning: Unknown XF " << xf[n].x_type << " at inode " << inode << std::endl;
break;
}
xdata += ((xf[n].x_size + 7) & ~7);
}
}
return true;
}
bool ApfsDir::ListDirectory(std::vector<DirRec> &dir, uint64_t inode)
{
uint8_t skey_buf[0x500];
BTreeIterator it;
BTreeEntry bte;
bool rc;
uint64_t skey;
const j_key_t *k;
const j_drec_val_t *v;
skey = APFS_TYPE_ID(APFS_TYPE_DIR_REC, inode);
dir.clear();
if (m_txt_fmt & 9)
{
j_drec_hashed_key_t *key = reinterpret_cast<j_drec_hashed_key_t *>(skey_buf);
key->hdr.obj_id_and_type = skey;
key->name_len_and_hash = 0;
key->name[0] = 0;
rc = m_fs_tree.GetIterator(it, key, sizeof(j_drec_hashed_key_t), CompareStdDirKey, this);
}
else
{
j_drec_key_t *key = reinterpret_cast<j_drec_key_t *>(skey_buf);
key->hdr.obj_id_and_type = skey;
key->name_len = 0;
key->name[0] = 0;
rc = m_fs_tree.GetIterator(it, key, sizeof(j_drec_key_t), CompareStdDirKey, this);
}
if (!rc)
return false;
for (;;)
{
DirRec e;
rc = it.GetEntry(bte);
if (!rc)
break;
if (g_debug & Dbg_Dir)
{
DumpBuffer(reinterpret_cast<const uint8_t *>(bte.key), bte.key_len, "entry key");
DumpBuffer(reinterpret_cast<const uint8_t *>(bte.val), bte.val_len, "entry val");
}
k = reinterpret_cast<const j_key_t *>(bte.key);
if (k->obj_id_and_type != skey)
break;
e.parent_id = k->obj_id_and_type & OBJ_ID_MASK;
if (m_txt_fmt != 0)
{
const j_drec_hashed_key_t *hk = reinterpret_cast<const j_drec_hashed_key_t *>(bte.key);
e.hash = hk->name_len_and_hash;
e.name = reinterpret_cast<const char *>(hk->name);
}
else
{
const j_drec_key_t *rk = reinterpret_cast<const j_drec_key_t *>(bte.key);
e.hash = 0;
e.name = reinterpret_cast<const char *>(rk->name);
}
// assert(res.val_len == sizeof(APFS_Name));
v = reinterpret_cast<const j_drec_val_t *>(bte.val);
e.file_id = v->file_id;
e.date_added = v->date_added;
e.flags = v->flags;
if (bte.val_len > sizeof(j_drec_val_t))
{
const xf_blob_t *xf_hdr = reinterpret_cast<const xf_blob_t *>(v->xfields);
const x_field_t *xf = reinterpret_cast<const x_field_t *>(xf_hdr->xf_data);
const uint8_t *xdata = v->xfields + sizeof(xf_blob_t) + xf_hdr->xf_num_exts * sizeof(x_field_t);
uint16_t n;
for (n = 0; n < xf_hdr->xf_num_exts; n++)
{
switch (xf[n].x_type)
{
case DREC_EXT_TYPE_SIBLING_ID:
assert(xf[n].x_size == sizeof(uint64_t));
e.sibling_id = bswap_le(*reinterpret_cast<const uint64_t *>(xdata));
e.has_sibling_id = true;
break;
default:
std::cerr << "Warning: Unknown XF " << xf[n].x_type << " at drec " << e.file_id << std::endl;
break;
}
xdata += ((xf[n].x_size + 7) & ~7);
}
}
dir.push_back(e);
it.next();
}
return true;
}
bool ApfsDir::LookupName(ApfsDir::DirRec& res, uint64_t parent_id, const char* name)
{
bool rc;
BTreeEntry e;
uint8_t srch_key_buf[0x500];
size_t name_len = strlen(name) + 1;
if (name_len > 0x400)
return false;
res.parent_id = parent_id;
res.name = name;
if (m_txt_fmt & 9)
{
j_drec_hashed_key_t *skey = reinterpret_cast<j_drec_hashed_key_t *>(srch_key_buf);
skey->hdr.obj_id_and_type = APFS_TYPE_ID(APFS_TYPE_DIR_REC, parent_id);
skey->name_len_and_hash = HashFilename(reinterpret_cast<const uint8_t *>(name), static_cast<uint16_t>(name_len), (m_txt_fmt & APFS_INCOMPAT_CASE_INSENSITIVE) != 0);
memcpy(skey->name, name, name_len);
if (g_debug & Dbg_Dir)
{
std::cout << "Lookup hashed key: key=" << skey->hdr.obj_id_and_type << " hash=" << skey->name_len_and_hash << " name='" << reinterpret_cast<const char *>(skey->name) << "'" << std::endl;
dump_utf8(std::cout, skey->name);
}
res.hash = skey->name_len_and_hash;
rc = m_fs_tree.Lookup(e, skey, sizeof(j_drec_hashed_key_t) + (skey->name_len_and_hash & J_DREC_LEN_MASK), CompareStdDirKey, this, true);
}
else
{
j_drec_key_t *skey = reinterpret_cast<j_drec_key_t *>(srch_key_buf);
skey->hdr.obj_id_and_type = parent_id | (static_cast<uint64_t>(APFS_TYPE_DIR_REC) << OBJ_TYPE_SHIFT);
skey->name_len = static_cast<uint16_t>(name_len);
memcpy(skey->name, name, name_len);
if (g_debug & Dbg_Dir)
{
std::cout << "Lookup key: key=" << skey->hdr.obj_id_and_type << " name_len=" << skey->name_len << " name='" << reinterpret_cast<const char *>(skey->name) << "'" << std::endl;
dump_utf8(std::cout, skey->name);
}
res.hash = 0;
rc = m_fs_tree.Lookup(e, skey, sizeof(j_drec_key_t) + skey->name_len, CompareStdDirKey, this, true);
}
if (!rc)
{
if (g_debug & Dbg_Dir)
std::cout << "Lookup failed!" << std::endl;
return false;
}
const j_drec_val_t *v = reinterpret_cast<const j_drec_val_t *>(e.val);
res.file_id = v->file_id;
res.date_added = v->date_added;
// v->unk ?
// TODO: SIBLING-ID! XF!
if (g_debug & Dbg_Dir)
std::cout << "Lookup: id = " << res.file_id << std::endl;
return true;
}
bool ApfsDir::ReadFile(void* data, uint64_t inode, uint64_t offs, size_t size)
{
BTreeEntry e;
bool rc;
uint8_t *bdata = reinterpret_cast<uint8_t *>(data);
size_t cur_size;
uint64_t blk_idx;
uint64_t blk_offs;
uint64_t extent_size;
uint64_t extent_offs;
paddr_t extent_paddr;
uint64_t extent_crypto_id;
while (size > 0)
{
if (m_vol.isSealed()) {
fext_tree_key_t key;
const fext_tree_key_t *fext_key = nullptr;
const fext_tree_val_t *fext_val = nullptr;
key.private_id = inode;
key.logical_addr = offs;
rc = m_vol.fexttree().Lookup(e, &key, sizeof(key), CompareFextKey, this, false);
if (!rc) return false;
fext_key = reinterpret_cast<const fext_tree_key_t *>(e.key);
fext_val = reinterpret_cast<const fext_tree_val_t *>(e.val);
extent_offs = offs - fext_key->logical_addr;
extent_size = fext_val->len_and_flags & J_FILE_EXTENT_LEN_MASK;
extent_paddr = fext_val->phys_block_num;
extent_crypto_id = 0; /* TODO: Crypto on sealed volumes? Need later beta for that ... */
} else {
j_file_extent_key_t key;
const j_file_extent_key_t *ext_key = nullptr;
const j_file_extent_val_t *ext_val = nullptr;
key.hdr.obj_id_and_type = APFS_TYPE_ID(APFS_TYPE_FILE_EXTENT, inode);
key.logical_addr = offs;
if (g_debug & Dbg_Dir)
std::cout << "ReadFile(inode=" << inode << ",offs=" << offs << ",size=" << size << ")" << std::endl;
rc = m_fs_tree.Lookup(e, &key, sizeof(key), CompareStdDirKey, this, false);
if (!rc)
return false;
ext_key = reinterpret_cast<const j_file_extent_key_t *>(e.key);
ext_val = reinterpret_cast<const j_file_extent_val_t *>(e.val);
if (g_debug & Dbg_Dir)
{
std::cout << "FileExtent " << ext_key->hdr.obj_id_and_type << " " << ext_key->logical_addr << " => ";
std::cout << ext_val->len_and_flags << " " << ext_val->phys_block_num << " " << ext_val->crypto_id << std::endl;
}
if (ext_key->hdr.obj_id_and_type != key.hdr.obj_id_and_type)
return false;
// Remove flags from length member
extent_offs = offs - ext_key->logical_addr;
extent_size = ext_val->len_and_flags & J_FILE_EXTENT_LEN_MASK;
extent_paddr = ext_val->phys_block_num;
extent_crypto_id = ext_val->crypto_id;
}
blk_idx = extent_offs >> m_blksize_sh;
blk_offs = extent_offs & m_blksize_mask_lo;
cur_size = size;
if ((extent_offs + cur_size) > extent_size)
cur_size = extent_size - extent_offs;
if (cur_size == 0)
break;
if (extent_paddr != 0)
{
if (blk_offs == 0 && cur_size > m_blksize)
cur_size &= m_blksize_mask_hi;
if (blk_offs == 0 && (cur_size & m_blksize_mask_lo) == 0)
{
if (g_debug & Dbg_Dir)
std::cout << "Full read blk " << extent_paddr + blk_idx << " cnt " << (cur_size >> m_blksize_sh) << std::endl;
m_vol.ReadBlocks(bdata, extent_paddr + blk_idx, cur_size >> m_blksize_sh, extent_crypto_id + blk_idx);
}
else
{
if (g_debug & Dbg_Dir)
std::cout << "Partial read blk " << extent_paddr + blk_idx << " cnt 1" << std::endl;
m_vol.ReadBlocks(m_tmp_blk.data(), extent_paddr + blk_idx, 1, extent_crypto_id + blk_idx);
if (blk_offs + cur_size > m_blksize)
cur_size = m_blksize - blk_offs;
if (g_debug & Dbg_Dir)
std::cout << "Partial copy off " << blk_offs << " size " << cur_size << std::endl;
memcpy(bdata, m_tmp_blk.data() + blk_offs, cur_size);
}
}
else
memset(bdata, 0, cur_size);
bdata += cur_size;
offs += cur_size;
size -= cur_size;
// printf("ReadFile: offs=%016lX size=%016lX\n", offs, size);
}
return true;
}
bool ApfsDir::ListAttributes(std::vector<std::string>& names, uint64_t inode)
{
j_inode_key_t skey;
const j_xattr_key_t *ekey;
BTreeIterator it;
BTreeEntry res;
bool rc;
skey.hdr.obj_id_and_type = APFS_TYPE_ID(APFS_TYPE_INODE, inode);
rc = m_fs_tree.GetIterator(it, &skey, sizeof(j_inode_key_t), CompareStdDirKey, this);
if (!rc)
return false;
for (;;)
{
rc = it.GetEntry(res);
if (!rc)
break;
ekey = reinterpret_cast<const j_xattr_key_t *>(res.key);
if ((ekey->hdr.obj_id_and_type & OBJ_ID_MASK) != inode)
break;
if ((ekey->hdr.obj_id_and_type >> OBJ_TYPE_SHIFT) < APFS_TYPE_XATTR)
{
it.next();
continue;
}
if ((ekey->hdr.obj_id_and_type >> OBJ_TYPE_SHIFT) > APFS_TYPE_XATTR)
break;
names.push_back(reinterpret_cast<const char *>(ekey->name));
it.next();
}
return true;
}
bool ApfsDir::GetAttribute(std::vector<uint8_t>& data, uint64_t inode, const char* name)
{
uint8_t skey_buf[0x500];
j_xattr_key_t *skey = reinterpret_cast<j_xattr_key_t *>(skey_buf);
const j_xattr_val_t *attr;
const j_xattr_dstream_t *xstm = nullptr;
// const uint8_t *adata;
BTreeEntry res;
bool rc;
size_t name_len = strlen(name) + 1;
if (name_len > 0x400)
return false;
skey->hdr.obj_id_and_type = APFS_TYPE_ID(APFS_TYPE_XATTR, inode);
skey->name_len = static_cast<int16_t>(name_len);
memcpy(skey->name, name, skey->name_len);
rc = m_fs_tree.Lookup(res, skey, sizeof(j_xattr_key_t) + skey->name_len, CompareStdDirKey, this, true);
if (!rc)
return false;
attr = reinterpret_cast<const j_xattr_val_t *>(res.val);
// adata = reinterpret_cast<const uint8_t *>(res.val) + sizeof(APFS_Xattr_Val);
if (g_debug & Dbg_Dir)
std::cout << "GetAttribute: type=" << attr->flags << std::endl;
if (attr->flags & XATTR_DATA_STREAM)
{
// Attribute contents are stored in a file
assert(attr->xdata_len == sizeof(j_xattr_dstream_t));
xstm = reinterpret_cast<const j_xattr_dstream_t *>(attr->xdata);
if (g_debug & Dbg_Dir)
{
std::cout << "Attribute is link:" << std::endl;
std::cout << " obj_id : " << xstm->xattr_obj_id << std::endl;
std::cout << " size : " << xstm->dstream.size << std::endl;
std::cout << " alloced_size : " << xstm->dstream.alloced_size << std::endl;
std::cout << " default_crypto_id : " << xstm->dstream.default_crypto_id << std::endl;
std::cout << " total_bytes_written : " << xstm->dstream.total_bytes_written << std::endl;
std::cout << " total_bytes_read : " << xstm->dstream.total_bytes_read << std::endl;
}
data.resize(xstm->dstream.alloced_size);
ReadFile(data.data(), xstm->xattr_obj_id, 0, data.size()); // Read must be multiple of 4K ...
data.resize(xstm->dstream.size);
if (g_debug & Dbg_Dir)
{
size_t dmpsize = 0x40;
if (dmpsize > data.size())
dmpsize = data.size();
DumpBuffer(data.data(), dmpsize, "start of attribute content");
}
}
else if (attr->flags & XATTR_DATA_EMBEDDED)
{
// Attribute contents are stored in the btree
data.assign(attr->xdata, attr->xdata + attr->xdata_len);
}
return true;
}
bool ApfsDir::GetAttributeInfo(ApfsDir::XAttr& attr, uint64_t inode, const char* name)
{
uint8_t skey_buf[0x500];
j_xattr_key_t *skey = reinterpret_cast<j_xattr_key_t *>(skey_buf);
const j_xattr_val_t *xv;
const j_xattr_dstream_t *xs = nullptr;
BTreeEntry res;
bool rc;
size_t name_len = strlen(name) + 1;
if (name_len > 0x400)
return false;
skey->hdr.obj_id_and_type = APFS_TYPE_ID(APFS_TYPE_XATTR, inode);
skey->name_len = static_cast<int16_t>(name_len);
memcpy(skey->name, name, skey->name_len);
rc = m_fs_tree.Lookup(res, skey, sizeof(j_xattr_key_t) + skey->name_len, CompareStdDirKey, this, true);
if (!rc)
return false;
xv = reinterpret_cast<const j_xattr_val_t *>(res.val);
attr.flags = xv->flags;
attr.xdata_len = xv->xdata_len;
if (xv->flags & XATTR_DATA_STREAM)
{
xs = reinterpret_cast<const j_xattr_dstream_t *>(xv->xdata);
attr.xstrm = *xs;
}
return true;
}
int ApfsDir::CompareStdDirKey(const void *skey, size_t skey_len, const void *ekey, size_t ekey_len, void *context)
{
// assert(skey_len == 8);
// assert(ekey_len == 8);
(void)ekey_len;
ApfsDir *dir = reinterpret_cast<ApfsDir *>(context);
uint64_t ks = *reinterpret_cast<const le_uint64_t *>(skey);
uint64_t ke = *reinterpret_cast<const le_uint64_t *>(ekey);
// std::cout << std::hex << std::uppercase << std::setfill('0');
ks = (ks << 4) | (ks >> 60);
ke = (ke << 4) | (ke >> 60);
// std::cout << std::setw(16) << ks << " : " << std::setw(16) << ke << std::endl;
if (ke < ks)
return -1;
if (ke > ks)
return 1;
if (skey_len > 8)
{
switch (ks & 0xF)
{
case APFS_TYPE_DIR_REC:
if (dir->m_txt_fmt & 9)
{
const j_drec_hashed_key_t *s = reinterpret_cast<const j_drec_hashed_key_t *>(skey);
const j_drec_hashed_key_t *e = reinterpret_cast<const j_drec_hashed_key_t *>(ekey);
/* TODO: Is this correct? Yes. TODO check _apfs_cstrncmp. */
if ((e->name_len_and_hash & J_DREC_HASH_MASK) < (s->name_len_and_hash & J_DREC_HASH_MASK))
return -1;
if ((e->name_len_and_hash & J_DREC_HASH_MASK) > (s->name_len_and_hash & J_DREC_HASH_MASK))
return 1;
return apfs_strncmp(e->name, e->name_len_and_hash & J_DREC_LEN_MASK, s->name, s->name_len_and_hash & J_DREC_LEN_MASK);
}
else
{
const j_drec_key_t *s = reinterpret_cast<const j_drec_key_t *>(skey);
const j_drec_key_t *e = reinterpret_cast<const j_drec_key_t *>(ekey);
return apfs_strncmp(e->name, e->name_len, s->name, s->name_len);
}
break;
case APFS_TYPE_FILE_EXTENT:
{
const j_file_extent_key_t *s = reinterpret_cast<const j_file_extent_key_t *>(skey);
const j_file_extent_key_t *e = reinterpret_cast<const j_file_extent_key_t *>(ekey);
assert(skey_len == sizeof(j_file_extent_key_t));
assert(ekey_len == sizeof(j_file_extent_key_t));
if (e->logical_addr < s->logical_addr)
return -1;
if (e->logical_addr > s->logical_addr)
return 1;
}
break;
case APFS_TYPE_XATTR:
{
const j_xattr_key_t *s = reinterpret_cast<const j_xattr_key_t *>(skey);
const j_xattr_key_t *e = reinterpret_cast<const j_xattr_key_t *>(ekey);
return apfs_strncmp(e->name, e->name_len, s->name, s->name_len);
}
break;
case APFS_TYPE_FILE_INFO:
{
const j_file_info_key_t *s = reinterpret_cast<const j_file_info_key_t *>(skey);
const j_file_info_key_t *e = reinterpret_cast<const j_file_info_key_t *>(ekey);
if (e->info_and_lba < s->info_and_lba)
return -1;
if (e->info_and_lba > s->info_and_lba)
return 1;
break;
}
}
}
return 0;
}
int ApfsDir::CompareFextKey(const void* skey, size_t skey_len, const void* ekey, size_t ekey_len, void* context)
{
const fext_tree_key_t *s = reinterpret_cast<const fext_tree_key_t *>(skey);
const fext_tree_key_t *e = reinterpret_cast<const fext_tree_key_t *>(ekey);
if (e->private_id < s->private_id)
return -1;
if (e->private_id > s->private_id)
return 1;
if (e->logical_addr < s->logical_addr)
return -1;
if (e->logical_addr > s->logical_addr)
return 1;
return 0;
}