mbr.hpp

#if !defined(__MBR_HPP__)
#define __MBR_HPP__

//
// local includes
//
#include "core/common.hpp"

struct __packed(mbr)
{
    static const uint16_t SIGNATURE = 0xaa55;

    struct __packed(entry)
    {
        enum attributes_constants
        {
            BOOTABLE = 0x80
        };

        uint8_t     attributes;             
        uint8_t     start_chs[3];           
        uint8_t     type;                   
        uint8_t     end_chs[3];             
        le_uint32_t start_lba;              
        le_uint32_t size_lba;               

        inline entry(void)
        {
            memset(this, 0, sizeof(entry));
        }

        inline entry(uint8_t type, uint32_t start_lba, uint32_t size_lba, uint8_t attributes=0)
        {
            // initialize attributes
            this->attributes=attributes;
            this->start_chs[0]=0xfe;
            this->start_chs[1]=this->start_chs[2]=0xff;
            this->type=type;
            this->end_chs[0]=0xfe;
            this->end_chs[1]=this->end_chs[2]=0xff;
            this->start_lba=start_lba;
            this->size_lba=size_lba;
        }

        inline bool is_used(void) const
        {
            // a size of 0 is definitely stupid.
            return type && size_lba;
        }

        inline bool is_valid(const uint32_t disk_size) const
        {
            // an unused entry must be valid
            return (start_lba < disk_size) && (start_lba + size_lba <= disk_size);
        }

        inline bool overlaps(const entry &other) const
        {
            const uint64_t end_lba=static_cast<uint64_t>(start_lba) + size_lba - 1,
                           other_end_lba=static_cast<uint64_t>(other.start_lba) + other.size_lba - 1;
            return (start_lba <= other_end_lba) && (other.start_lba <= end_lba);
        }
    };

    // mandated by the BIOS32 specification
    static_assert(sizeof(entry) == 16, "entry's size must be 16");

    uint8_t     boot_code[440];             
    le_uint32_t uid;                        
    le_uint16_t unknown;                    
    entry       partitions[4];              
    le_uint16_t signature;                  

    inline mbr(void)
    {
        memset(this, 0, sizeof(mbr));
    }

    inline mbr(uint32_t uid, const uint8_t *boot_code=nullptr)
    {
        // clear data structure
        memset(this, 0, sizeof(mbr));
        // initialize attributes
        if (boot_code) memcpy(this->boot_code, boot_code, sizeof(this->boot_code));
        this->uid=uid;
        this->signature=SIGNATURE;
    }

    inline bool is_valid(void) const
    {
        return signature == SIGNATURE;
    }

    inline bool is_consistent(const uint64_t disk_size) const
    {
        for (int i=0; i < 4; i++)
            if (partitions[i].is_used()) {
                if (!partitions[i].is_valid(disk_size)) return false;

                for (int j=0; j < i; j++)
                    if (partitions[j].is_used() && partitions[i].overlaps(partitions[j]))
                        return false;
            }

        return true;
    }

    inline bool matches(const mbr &other) const
    {
        return (uid == other.uid) &&
               (signature == other.signature) &&
               !memcmp(partitions, other.partitions, sizeof(partitions));
    }
};

// mandated by the BIOS32 specification
static_assert(sizeof(mbr) == 512, "mbr's size must be 512");

#endif

// ***** end of source ***** //