scheduled_radio.hpp

#ifndef BLUETOE_LINK_LAYER_SCHEDULED_RADIO_HPP
#define BLUETOE_LINK_LAYER_SCHEDULED_RADIO_HPP
 
#include <cstdint>
#include <buffer.hpp>
#include <address.hpp>
#include <ll_data_pdu_buffer.hpp>
 
namespace bluetoe {
namespace link_layer {
 
    class delta_time;
    class write_buffer;
    class read_buffer;
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename CallBack >
    class scheduled_radio : public ll_data_pdu_buffer< TransmitSize, ReceiveSize, scheduled_radio< TransmitSize, ReceiveSize, CallBack > >
    {
    public:
        scheduled_radio();
 
        void schedule_advertisment(
            unsigned                                    channel,
            const bluetoe::link_layer::write_buffer&    advertising_data,
            const bluetoe::link_layer::write_buffer&    response_data,
            bluetoe::link_layer::delta_time             when,
            const bluetoe::link_layer::read_buffer&     receive );
 
        bluetoe::link_layer::delta_time schedule_connection_event(
            unsigned                                    channel,
            bluetoe::link_layer::delta_time             start_receive,
            bluetoe::link_layer::delta_time             end_receive,
            bluetoe::link_layer::delta_time             connection_interval );
 
        std::pair< bool, bluetoe::link_layer::delta_time > disarm_connection_event();
 
        bool schedule_synchronized_user_timer(
            bluetoe::link_layer::delta_time timeout,
            bluetoe::link_layer::delta_time max_cb_runtime );
 
        bool cancel_synchronized_user_timer();
 
        void set_access_address_and_crc_init( std::uint32_t access_address, std::uint32_t crc_init );
 
        std::uint32_t static_random_address_seed() const;
 
        void run();
 
        void wake_up();
 
        void request_event_cancelation();
 
        class lock_guard;
 
        static constexpr std::size_t radio_maximum_white_list_entries = 4;
 
        bool radio_add_to_white_list( const device_address& addr );
 
        bool radio_remove_from_white_list( const device_address& addr );
 
        bool radio_is_in_white_list( const device_address& addr ) const;
 
        std::size_t radio_white_list_free_size() const;
 
        void radio_clear_white_list();
 
        void connection_request_filter( bool b );
 
        bool connection_request_filter() const;
 
        void radio_scan_request_filter( bool b );
 
        bool radio_scan_request_filter() const;
 
        bool radio_is_connection_request_in_filter( const device_address& addr ) const;
 
        bool radio_is_scan_request_in_filter( const device_address& addr ) const;
 
        void radio_set_phy( details::phy_ll_encoding receiving_encoding, details::phy_ll_encoding transmiting_c_encoding );
 
        static constexpr std::size_t radio_package_overhead = 0;
 
        static constexpr bool hardware_supports_encryption = false;
 
        static constexpr bool hardware_supports_2mbit = true;
 
        static constexpr bool hardware_supports_synchronized_user_timer = true;
    };
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename CallBack >
    class scheduled_radio_with_encryption : public scheduled_radio< TransmitSize, ReceiveSize, CallBack >
    {
    public:
        static constexpr bool hardware_supports_lesc_pairing = false;
 
        static constexpr bool hardware_supports_legacy_pairing = true;
 
        static constexpr bool hardware_supports_encryption = hardware_supports_lesc_pairing || hardware_supports_legacy_pairing;
 
        bluetoe::details::uint128_t create_srand();
 
        bluetoe::details::longterm_key_t create_long_term_key();
 
        bluetoe::details::uint128_t c1(
            const bluetoe::details::uint128_t& temp_key,
            const bluetoe::details::uint128_t& rand,
            const bluetoe::details::uint128_t& p1,
            const bluetoe::details::uint128_t& p2 ) const;
 
        bluetoe::details::uint128_t s1(
            const bluetoe::details::uint128_t& temp_key,
            const bluetoe::details::uint128_t& prand,
            const bluetoe::details::uint128_t& crand );
 
        std::pair< std::uint64_t, std::uint32_t > setup_encryption( bluetoe::details::uint128_t key, std::uint64_t skdm, std::uint32_t ivm );
 
        bool is_valid_public_key( const std::uint8_t* public_key ) const;
 
        std::pair< bluetoe::details::ecdh_public_key_t, bluetoe::details::ecdh_private_key_t > generate_keys();
 
        bluetoe::details::uint128_t select_random_nonce();
 
        bluetoe::details::ecdh_shared_secret_t p256( const std::uint8_t* private_key, const std::uint8_t* public_key );
 
        bluetoe::details::uint128_t f4( const std::uint8_t* u, const std::uint8_t* v, const std::array< std::uint8_t, 16 >& k, std::uint8_t z );
 
        std::pair< bluetoe::details::uint128_t, bluetoe::details::uint128_t > f5(
            const bluetoe::details::ecdh_shared_secret_t dh_key,
            const bluetoe::details::uint128_t& nonce_central,
            const bluetoe::details::uint128_t& nonce_periperal,
            const bluetoe::link_layer::device_address& addr_controller,
            const bluetoe::link_layer::device_address& addr_peripheral );
 
        bluetoe::details::uint128_t f6(
            const bluetoe::details::uint128_t& key,
            const bluetoe::details::uint128_t& n1,
            const bluetoe::details::uint128_t& n2,
            const bluetoe::details::uint128_t& r,
            const bluetoe::details::io_capabilities_t& io_caps,
            const bluetoe::link_layer::device_address& addr_controller,
            const bluetoe::link_layer::device_address& addr_peripheral );
 
        std::uint32_t g2(
            const std::uint8_t*                 u,
            const std::uint8_t*                 v,
            const bluetoe::details::uint128_t&  x,
            const bluetoe::details::uint128_t&  y );
 
        bluetoe::details::uint128_t create_passkey();
 
        void start_receive_encrypted();
 
        void start_transmit_encrypted();
 
        void stop_receive_encrypted();
 
        void stop_transmit_encrypted();
    };
 
    struct pdu_layout {
        static std::uint16_t header( const read_buffer& pdu );
 
        static std::uint16_t header( const write_buffer& pdu );
 
        static std::uint16_t header( const std::uint8_t* pdu );
 
        static void header( const read_buffer& pdu, std::uint16_t header_value );
 
        static void header( std::uint8_t* pdu, std::uint16_t header_value );
 
        static std::pair< std::uint8_t*, std::uint8_t* > body( const read_buffer& pdu );
 
        static std::pair< const std::uint8_t*, const std::uint8_t* > body( const write_buffer& pdu );
 
        static constexpr std::size_t data_channel_pdu_memory_size( std::size_t payload_size );
    };
}
 
}
 
#endif // include guard