address.hpp

#ifndef BLUETOE_LINK_LAYER_ADDRESS_HPP
#define BLUETOE_LINK_LAYER_ADDRESS_HPP
 
#include <cstdint>
#include <initializer_list>
#include <iosfwd>
 
namespace bluetoe {
namespace link_layer {
 
    class random_device_address;
 
    class address
    {
    public:
        address();
 
        explicit address( const std::initializer_list< std::uint8_t >& initial_values );
 
        explicit address( const std::uint8_t* initial_values );
 
        static random_device_address generate_static_random_address( std::uint32_t seed );
 
        template < typename HashFunc >
        static random_device_address generate_resolvable_private_address( const std::uint8_t* irk, std::uint32_t random, HashFunc hash_func );
 
        std::ostream& print( std::ostream& ) const;
 
        std::uint8_t msb() const;
 
        bool operator==( const address& rhs ) const;
 
        bool operator!=( const address& rhs ) const;
 
        typedef std::uint8_t const * const_iterator;
 
        const_iterator begin() const;
 
        const_iterator end() const;
    private:
        static std::uint32_t create_prand( std::uint32_t rand );
 
        static constexpr std::size_t address_size_in_bytes = 6;
        std::uint8_t value_[ address_size_in_bytes ];
 
        // this type is not intended for polymorphic use; not implemented
        void operator delete  ( void* ptr );
        void operator delete[]( void* ptr );
    };
 
    std::ostream& operator<<( std::ostream& out, const address& a );
 
    class device_address : public address
    {
    public:
        device_address();
 
        bool is_random() const
        {
            return is_random_;
        }
 
        bool is_public() const
        {
            return !is_random_;
        }
 
        bool is_static() const
        {
            return ( *( end() - 1 ) & 0xC0 ) == 0xC0;
        }
 
        bool is_private() const
        {
            const auto v = *( end() - 1 ) & 0xC0;
            return v == 0x40 || v == 0x00;
        }
 
        bool is_resolvable() const
        {
            return ( *( end() - 1 ) & 0xC0 ) == 0x40;
        }
 
        bool is_random_resolvable() const
        {
            return is_random() && is_resolvable();
        }
 
        using address::operator==;
        using address::operator!=;
 
        bool operator==( const device_address& rhs ) const;
 
        bool operator!=( const device_address& rhs ) const;
 
        device_address( const std::initializer_list< std::uint8_t >& initial_values, bool is_random )
            : address( initial_values )
            , is_random_( is_random )
        {}
 
        device_address( const std::uint8_t* initial_values, bool is_random )
            : address( initial_values )
            , is_random_( is_random )
        {}
 
    protected:
        explicit device_address( bool is_random )
            : address()
            , is_random_( is_random )
        {}
 
    private:
        bool is_random_;
    };
 
    std::ostream& operator<<( std::ostream& out, const device_address& a );
 
    class public_device_address : public device_address
    {
    public:
        public_device_address() : device_address( false ) {}
 
        explicit public_device_address( const std::initializer_list< std::uint8_t >& initial_values )
            : device_address( initial_values, false ) {}
 
        explicit public_device_address( const std::uint8_t* initial_values )
            : device_address( initial_values, false ) {}
    };
 
    class random_device_address : public device_address
    {
    public:
        random_device_address() : device_address( true ) {}
 
        explicit random_device_address( const std::initializer_list< std::uint8_t >& initial_values )
            : device_address( initial_values, true ) {}
 
        explicit random_device_address( const std::uint8_t* initial_values )
            : device_address( initial_values, true ) {}
    };
 
    template < typename HashFunc >
    random_device_address address::generate_resolvable_private_address( const std::uint8_t* irk, std::uint32_t random, HashFunc hash_func )
    {
        const std::uint32_t prand = create_prand( random );
        const std::uint32_t hash = hash_func( irk, prand );
 
        std::uint8_t initial_values[ address_size_in_bytes ] = {
            static_cast<uint8_t>( prand >> 16 ),
            static_cast<uint8_t>( prand >> 8 ),
            static_cast<uint8_t>( prand ),
            static_cast<uint8_t>( hash >> 16 ),
            static_cast<uint8_t>( hash >> 8 ),
            static_cast<uint8_t>( hash ) };
 
        return random_device_address( initial_values );
    }
 
}
 
}
 
#endif