gap.hpp

Go to the documentation of this file.

/* SPDX-License-Identifier: Apache-2.0 */
/* Copyright 2017-2019 Peter A. Bigot */
 
#ifndef PABIGOT_BLE_GAP_HPP
#define PABIGOT_BLE_GAP_HPP
#pragma once
 
#include <pabigot/ble.hpp>
#include <pabigot/byteorder.hpp>
 
namespace pabigot {
namespace ble {
 
namespace gap {
 
static constexpr size_t ASR_DATA_SIZE{31};
 
enum pdu_type_e : uint8_t
{
  PT_ADV_IND = 0x00,
  PT_ADV_DIRECT_IND = 0x01,
  PT_ADV_NONCONN_IND = 0x02,
  PT_SCAN_REQ = 0x03,           // also AUX_SCAN_REQ
  PT_SCAN_RESP = 0x04,
  PT_CONNECT_IND = 0x05,        // also AUX_CONNECT_REQ
  PT_ADV_SCAN_IND = 0x06,
  PT_ADV_EXT_IND = 0x07,        // also AUX_{ADV,SYNC,CHAIN}_IND, AUX_SCAN_RSP
  PT_AUX_CONNECT_RSP = 0x08,
};
 
enum adv_event_type_e : uint8_t
{
  ET_ADV_IND = 0x00,
  ET_ADV_DIRECT_IND = 0x01,
  ET_ADV_SCAN_IND = 0x02,
  ET_ADV_NONCONN_IND = 0x03,
  ET_SCAN_RSP = 0x04,
 
  ET_INVALID = 0x80,
};
 
enum flags_data_type_e : uint8_t
{
  FDT_LE_LIMITED = 0x01,
  FDT_LE_GENERAL = 0x02,
  FDT_BREDR_NOTSUP = 0x04,
  FDT_BREDRLE_CTRL = 0x08,
  FDT_BREDRLE_HOST = 0x10,
 
  FDT_LE_NON_DISCOVERABLE = FDT_BREDR_NOTSUP,
  FDT_LE_LIMITED_DISCOVERABLE = FDT_BREDR_NOTSUP | FDT_LE_LIMITED,
  FDT_LE_GENERAL_DISCOVERABLE = FDT_BREDR_NOTSUP | FDT_LE_GENERAL,
};
 
enum data_type_e : uint8_t
{
  DT_FLAGS = 0x01,
  DT_UUID16_INCOMPLETE = 0x02,
  DT_UUID16_COMPLETE = 0x03,
  DT_UUID32_INCOMPLETE = 0x04,
  DT_UUID32_COMPLETE = 0x05,
  DT_UUID128_INCOMPLETE = 0x06,
  DT_UUID128_COMPLETE = 0x07,
  DT_SHORTENED_LOCAL_NAME = 0x08,
  DT_COMPLETE_LOCAL_NAME = 0x09,
  DT_TX_POWER_LEVEL = 0x0A,
  DT_CLASS_OF_DEVICE = 0x0D,
  DT_SIMPLE_PAIRING_HASH_C192 = 0x0E,
  DT_SIMPLE_PAIRING_RANDOMIZER_R192 = 0x0F,
  DT_DEVICE_ID = 0x10,
  DT_SECURITY_MANAGER_OOB_FLAGS = 0x11,
  DT_SLAVE_CONNECTION_INTERVAL_RANGE = 0x12,
  DT_SERVICE_SOLICITATION_UUID16 = 0x14,
  DT_SERVICE_SOLICITATION_UUID128 = 0x15,
  DT_SERVICE_DATA_UUID16 = 0x16,
  DT_PUBLIC_TARGET_ADDRESS = 0x17,
  DT_RANDOM_TARGET_ADDRESS = 0x18,
  DT_APPEARANCE = 0x19,
  DT_ADVERTISING_INTERVAL = 0x1A,
  DT_LE_BLUETOOTH_DEVICE_ADDR = 0x1B,
  DT_LE_ROLE = 0x1C,
  DT_SIMPLE_PAIRING_HASH_C256 = 0x1D,
  DT_SIMPLE_PAIRING_RANDOMIZER_R256 = 0x1E,
  DT_SERVICE_SOLICITATION_UUID32 = 0x1F,
  DT_SERVICE_DATA_UUID32 = 0x20,
  DT_SERVICE_DATA_UUID128 = 0x21,
  DT_LE_SECURE_CONN_CONFIRM_VALUE = 0x22,
  DT_LE_SECURE_CONN_RANDOM_VALUE = 0x23,
  DT_URI = 0x24,
  DT_INDOOR_POSITIONING = 0x25,
  DT_TRANSPORT_DISCOVERY_DATA = 0x26,
  DT_LE_SUPPORTED_FEATURES = 0x27,
  DT_CHANNEL_MAP_UPDATE_INDICATION = 0x28,
  DT_PB_ADV = 0x29,
  DT_MESH_MESSAGE = 0x2A,
  DT_MESH_BEACON = 0x2B,
  DT_3D_INFORMATION_DATA = 0x3D,
  DT_MANUFACTURER_SPECIFIC_DATA = 0xFF,
};
 
class adv_data : public byteorder::octets_helper
{
protected:
  using super = byteorder::octets_helper;
 
  class store_helper
  {
  private:
    friend class adv_data;
 
    adv_data& owner;
    uint8_t* sp;
 
    store_helper (adv_data& owner_,
                  uint8_t tag,
                  size_type count) :
      owner{owner_},
      sp{owner.bp_}
    {
      // Increase span to cover the type tag.
      auto span = count + sizeof(tag);
      auto span_octet = static_cast<uint8_t>(span);
 
      // Valid requires representable span and available space
      if ((span_octet == span)
          && owner.can_advance(sizeof(*sp) + span)) {
        // Store the expected length and the tag
        owner.append(span_octet);
        owner.append(tag);
      } else {
        sp = nullptr;
        owner.invalidate();
      }
    }
  public:
    explicit operator bool() const noexcept
    {
      return sp;
    }
 
    ~store_helper ()
    {
      /* If the owner is valid, construction succeeded, and the pointer
       * advanced past where it was left in construction, then we can and
       * should update length to match the used region. */
      if (owner.valid()
          && sp
          && ((sp + 2U) != owner.bp_)) {
        /* Length is anything past the length octet.  Invalidate if the span
         * doesn't fit in an octet. */
        auto span = owner.bp_ - sp - 1U;
        if (static_cast<uint8_t>(span) == span) {
          *sp = span;
        } else {
          owner.invalidate();
        }
      }
    }
  };
 
  template <typename uuid_type>
  void store_uuids (uint8_t dt,
                    const uuid_type* begin,
                    const uuid_type* end);
 
public:
  adv_data (uint8_t* begin,
            uint8_t* end) :
    super{begin, end}
  { }
 
  template <size_t count>
  adv_data (std::array<uint8_t, count>& src) :
    super{src.begin(), src.end()}
  { }
 
  const uint8_t* data () const noexcept
  {
    return static_cast<const uint8_t *>(begin());
  }
 
  [[nodiscard]] store_helper start_store (uint8_t tag,
                                          size_type count)
  {
    return {*this, tag, count};
  }
 
  void set_Flags (unsigned int flags);
 
  void set_ShortenedLocalName (const char* name,
                               ptrdiff_t count = -1);
 
  void set_CompleteLocalName (const char* name,
                              ptrdiff_t count = -1);
 
  void set_TXPowerLevel (int8_t txPower);
 
  template <typename uuid_type>
  void set_CompleteListServiceUUID (const uuid_type& uuid)
  {
    return set_CompleteListServiceUUID(&uuid, 1 + &uuid);
  }
 
  template <typename uuid_type>
  void set_CompleteListServiceUUID (const uuid_type* begin,
                                    const uuid_type* end);
 
  template <typename uuid_type>
  void set_IncompleteListServiceUUID (const uuid_type& uuid)
  {
    return set_IncompleteListServiceUUID(&uuid, 1 + &uuid);
  }
 
  template <typename uuid_type>
  void set_IncompleteListServiceUUID (const uuid_type* begin,
                                      const uuid_type* end);
 
  template <typename uuid_type>
  void set_ListServiceSolicitationUUID (const uuid_type& uuid)
  {
    return set_ListServiceSolicitationUUID(&uuid, 1 + &uuid);
  }
 
  template <typename uuid_type>
  void set_ListServiceSolicitationUUID (const uuid_type* begin,
                                        const uuid_type* end);
 
  template <typename uuid_type>
  uint8_t* set_ServiceData (const uuid_type& uuid,
                            const uint8_t* begin,
                            const uint8_t* end);
 
  template <typename uuid_type,
            std::size_t len>
  uint8_t* set_ServiceData (const uuid_type& uuid,
                            const std::array<uint8_t, len>& data)
  {
    return set_ServiceData(uuid, data.begin(), data.end());
  }
 
  template <typename uuid_type>
  uint8_t* set_ServiceData (const uuid_type& uuid,
                            const void* buf,
                            size_t count)
  {
    auto ptr = static_cast<const uint8_t*>(buf);
    return set_ServiceData(uuid, ptr, ptr + count);
  }
 
  void set_AdvertisingInterval (uint16_t advInterval);
 
  void set_SlaveConnectionIntervalRange (uint16_t connIntervalMin,
                                         uint16_t connIntervalMax);
 
  void* set_ManufacturerSpecificData (uint16_t companyID,
                                      size_t span);
};
 
template <>
void adv_data::set_CompleteListServiceUUID (const uuid16_type* begin,
                                            const uuid16_type* end);
template <>
void adv_data::set_CompleteListServiceUUID (const uuid32_type* begin,
                                            const uuid32_type* end);
template <>
void adv_data::set_CompleteListServiceUUID (const uuid128_type* begin,
                                            const uuid128_type* end);
template <>
void adv_data::set_IncompleteListServiceUUID (const uuid16_type* begin,
                                              const uuid16_type* end);
template <>
void adv_data::set_IncompleteListServiceUUID (const uuid32_type* begin,
                                              const uuid32_type* end);
template <>
void adv_data::set_IncompleteListServiceUUID (const uuid128_type* begin,
                                              const uuid128_type* end);
template <>
void adv_data::set_ListServiceSolicitationUUID (const uuid16_type* begin,
                                                const uuid16_type* end);
template <>
void adv_data::set_ListServiceSolicitationUUID (const uuid32_type* begin,
                                                const uuid32_type* end);
template <>
void adv_data::set_ListServiceSolicitationUUID (const uuid128_type* begin,
                                                const uuid128_type* end);
template <>
uint8_t*
adv_data::set_ServiceData (const uuid16_type& uuid,
                           const uint8_t* begin,
                           const uint8_t* end);
template <>
uint8_t*
adv_data::set_ServiceData (const uuid32_type& uuid,
                           const uint8_t* begin,
                           const uint8_t* end);
template <>
uint8_t*
adv_data::set_ServiceData (const uuid128_type& uuid,
                           const uint8_t* begin,
                           const uint8_t* end);
} // ns gap
} // ns ble
} // ns pabigot
 
#endif /* PABIGOT_BLE_GAP_HPP */