anonymous_namespace{partition_parser.cpp} Namespace Reference

Functions
uint32_t	le32 (const unsigned char *p)
uint64_t	le64 (const unsigned char *p)
std::string	hex2 (unsigned v)
bool	parse_gpt_table (DiskReader &reader, uint64_t header_lba, uint32_t sector_size, std::vector< ScanResult > &out, std::vector< std::string > &logs, bool is_backup)

Function Documentation

hex2()

std::string anonymous_namespace{partition_parser.cpp}::hex2

(

unsigned

v

)

Definition at line 30 of file partition_parser.cpp.

                           {
    std::ostringstream oss;
    oss << "0x" << std::hex << std::uppercase << std::setw(2) << std::setfill('0') << v;
    return oss.str();
}

References hex2().

Referenced by hex2().

le32()

uint32_t anonymous_namespace{partition_parser.cpp}::le32

(

const unsigned char *

p

)

Definition at line 12 of file partition_parser.cpp.

                                      {
    return static_cast<uint32_t>(p[0]) |
           (static_cast<uint32_t>(p[1]) << 8) |
           (static_cast<uint32_t>(p[2]) << 16) |
           (static_cast<uint32_t>(p[3]) << 24);
}

References le32().

Referenced by le32(), and parse_gpt_table().

le64()

uint64_t anonymous_namespace{partition_parser.cpp}::le64

(

const unsigned char *

p

)

Definition at line 19 of file partition_parser.cpp.

                                      {
    return static_cast<uint64_t>(p[0]) |
           (static_cast<uint64_t>(p[1]) << 8) |
           (static_cast<uint64_t>(p[2]) << 16) |
           (static_cast<uint64_t>(p[3]) << 24) |
           (static_cast<uint64_t>(p[4]) << 32) |
           (static_cast<uint64_t>(p[5]) << 40) |
           (static_cast<uint64_t>(p[6]) << 48) |
           (static_cast<uint64_t>(p[7]) << 56);
}

References le64().

Referenced by le64(), and parse_gpt_table().

parse_gpt_table()

bool anonymous_namespace{partition_parser.cpp}::parse_gpt_table	(	DiskReader &	reader,
		uint64_t	header_lba,
		uint32_t	sector_size,
		std::vector< ScanResult > &	out,
		std::vector< std::string > &	logs,
		bool	is_backup )

Definition at line 38 of file partition_parser.cpp.

                                     {
    std::array<unsigned char, 92> hdr{};
    const uint64_t header_offset = header_lba * sector_size;
 
    if (!reader.read_at(header_offset, hdr.data(), hdr.size())) {
        logs.push_back(std::string("GPT: header read failed at offset ") + std::to_string(header_offset));
        return false;
    }
 
    if (std::string(reinterpret_cast<const char*>(hdr.data()), 8) != "EFI PART") {
        if (is_backup) {
            logs.push_back(trs("GPT: backup EFI PART signature not found."));
        } else {
            logs.push_back(trs("GPT: EFI PART header not found."));
        }
        return false;
    }
 
    const uint64_t table_lba = le64(hdr.data() + 72);
    const uint32_t num_entries = le32(hdr.data() + 80);
    const uint32_t entry_size = le32(hdr.data() + 84);
 
    if (num_entries == 0 || entry_size < 128 || entry_size > 4096) {
        logs.push_back(trs("GPT: invalid partition table."));
        return false;
    }
 
    const uint64_t table_offset = table_lba * sector_size;
 
    for (uint32_t i = 0; i < num_entries; ++i) {
        std::vector<unsigned char> entry(entry_size);
        if (!reader.read_at(table_offset + static_cast<uint64_t>(i) * entry_size,
                            entry.data(), entry.size())) {
            break;
        }
 
        // Bug #21 fix: check both type GUID AND first/last LBA for empty entry
        bool type_guid_zero = true;
        for (size_t k = 0; k < 16; ++k) {
            if (entry[k] != 0) { type_guid_zero = false; break; }
        }
        const uint64_t first_lba = le64(entry.data() + 32);
        const uint64_t last_lba = le64(entry.data() + 40);
 
        if (type_guid_zero && first_lba == 0 && last_lba == 0) {
            continue;
        }
        if (last_lba < first_lba || first_lba == 0) {
            continue;
        }
 
        ScanResult r;
        r.kind = ResultKind::Partition;
        r.offset_bytes = first_lba * sector_size;
        r.size_bytes = (last_lba - first_lba + 1) * sector_size;
        r.type = is_backup ? trs("GPT partition (backup)") : trs("GPT partition");
        r.source = is_backup ? trs("GPT backup") : trs("GPT");
        r.detail = is_backup
            ? trs("GPT partition table entry (recovered from backup header)")
            : trs("GPT partition table entry");
        r.confidence = is_backup ? 0.92 : 0.98;
        out.push_back(r);
    }
 
    return true;
}

References le32(), le64(), parse_gpt_table(), Partition, DiskReader::read_at(), and trs().

Referenced by parse_gpt_table().