diff --git a/lib/bluetooth.h b/lib/bluetooth.h
index 0fcf412..e6171ce 100644
--- a/lib/bluetooth.h
+++ b/lib/bluetooth.h
const char *bt_compidtostr(int id);
typedef struct {
+ uint8_t data[3];
+} uint24_t;
+
+typedef struct {
uint8_t data[16];
} uint128_t;
diff --git a/monitor/att.c b/monitor/att.c
index de27ee4..b39ac5a 100644
--- a/monitor/att.c
+++ b/monitor/att.c
print_ccc_value(frame);
}
+static bool print_codec(const struct l2cap_frame *frame)
+{
+ uint8_t codec_id;
+ uint16_t codec_cid, codec_vid;
+
+ if (!l2cap_frame_get_u8((void *)frame, &codec_id)) {
+ print_text(COLOR_ERROR, "Codec: invalid size");
+ return false;
+ }
+
+ packet_print_codec_id(" Codec", codec_id);
+
+ if (!l2cap_frame_get_le16((void *)frame, &codec_cid)) {
+ print_text(COLOR_ERROR, "Codec Company ID: invalid size");
+ return false;
+ }
+
+ if (!l2cap_frame_get_le16((void *)frame, &codec_vid)) {
+ print_text(COLOR_ERROR, "Codec Vendor ID: invalid size");
+ return false;
+ }
+
+ if (codec_id == 0xff) {
+ print_field(" Codec Company ID: %s (0x%04x)",
+ bt_compidtostr(codec_cid),
+ codec_cid);
+ print_field(" Codec Vendor ID: 0x%04x", codec_vid);
+ }
+
+ return true;
+}
+
static void print_pac(const struct l2cap_frame *frame)
{
uint8_t num = 0, i;
print_field(" Number of PAC(s): %u", num);
for (i = 0; i < num; i++) {
- uint8_t codec_id;
- uint16_t codec_cid, codec_vid;
struct bt_hci_lv_data *cc;
struct bt_hci_lv_data *meta;
print_field(" PAC #%u:", i);
- if (!l2cap_frame_get_u8((void *)frame, &codec_id)) {
- print_text(COLOR_ERROR, "Codec: invalid size");
- goto done;
- }
-
- packet_print_codec_id(" Codec", codec_id);
-
- if (!l2cap_frame_get_le16((void *)frame, &codec_cid)) {
- print_text(COLOR_ERROR,
- "Codec Company ID: invalid size");
- goto done;
- }
-
- if (!l2cap_frame_get_le16((void *)frame, &codec_vid)) {
- print_text(COLOR_ERROR,
- "Codec Vendor ID: invalid size");
+ if (!print_codec(frame))
goto done;
- }
-
- if (codec_id == 0xff) {
- print_field(" Codec Company ID: %s (0x%04x)",
- bt_compidtostr(codec_cid),
- codec_cid);
- print_field(" Codec Vendor ID: 0x%04x", codec_vid);
- }
cc = l2cap_frame_pull((void *)frame, frame, sizeof(*cc));
if (!cc) {
print_pac(frame);
}
+static void print_prefer_framing(uint8_t value)
+{
+ switch (value) {
+ case 0x00:
+ print_field(" Framing: Unframed ISOAL PDUs supported "
+ "(0x%2.2x)", value);
+ return;
+ case 0x01:
+ print_field(" Framing: Unframed ISOAL PDUs not supported "
+ "(0x%2.2x)", value);
+ return;
+ default:
+ print_field(" Framing: Reserved (0x%2.2x)", value);
+ }
+}
+
+static const struct bitfield_data prefer_phy_table[] = {
+ { 0, "LE 1M PHY preffered (0x01)" },
+ { 1, "LE 2M PHY preffered (0x02)" },
+ { 2, "LE Codec PHY preffered (0x04)" },
+ { }
+};
+
+static void print_prefer_phy(uint8_t phy)
+{
+ uint8_t mask;
+
+ mask = print_bitfield(4, phy, prefer_phy_table);
+ if (mask)
+ print_text(COLOR_WHITE_BG, " Unknown fields (0x%2.2x)",
+ mask);
+}
+
+static void print_ase_config(const struct l2cap_frame *frame)
+{
+ uint8_t framing, phy, rtn;
+ uint16_t latency;
+ uint32_t pd_min, pd_max, ppd_min, ppd_max;
+ struct bt_hci_lv_data *cc;
+
+ if (!l2cap_frame_get_u8((void *)frame, &framing)) {
+ print_text(COLOR_ERROR, "Framing: invalid size");
+ return;
+ }
+
+ print_prefer_framing(framing);
+
+ if (!l2cap_frame_get_u8((void *)frame, &phy)) {
+ print_text(COLOR_ERROR, "PHY: invalid size");
+ return;
+ }
+
+ print_prefer_phy(phy);
+
+ if (!l2cap_frame_get_u8((void *)frame, &rtn)) {
+ print_text(COLOR_ERROR, "RTN: invalid size");
+ return;
+ }
+
+ print_field(" RTN: %u", rtn);
+
+ if (!l2cap_frame_get_le16((void *)frame, &latency)) {
+ print_text(COLOR_ERROR, "RTN: invalid size");
+ return;
+ }
+
+ print_field(" Max Transport Latency: %u ms", latency);
+
+ if (!l2cap_frame_get_le24((void *)frame, &pd_min)) {
+ print_text(COLOR_ERROR, "Presentation Delay Min: invalid size");
+ return;
+ }
+
+ print_field(" Presentation Delay Min: %u us", pd_min);
+
+ if (!l2cap_frame_get_le24((void *)frame, &pd_max)) {
+ print_text(COLOR_ERROR, "Presentation Delay Max: invalid size");
+ return;
+ }
+
+ print_field(" Presentation Delay Max: %u us", pd_max);
+
+ if (!l2cap_frame_get_le24((void *)frame, &ppd_min)) {
+ print_text(COLOR_ERROR,
+ "Preferred Presentation Delay Min: invalid size");
+ return;
+ }
+
+ print_field(" Preferred Presentation Delay Min: %u us", ppd_min);
+
+ if (!l2cap_frame_get_le24((void *)frame, &ppd_max)) {
+ print_text(COLOR_ERROR,
+ "Preferred Presentation Delay Max: invalid size");
+ return;
+ }
+
+ print_field(" Preferred Presentation Delay Max: %u us", ppd_max);
+
+ if (!print_codec(frame))
+ return;
+
+ cc = l2cap_frame_pull((void *)frame, frame, sizeof(*cc));
+ if (!cc) {
+ print_text(COLOR_ERROR,
+ "Codec Specific Configuration: invalid size");
+ return;
+ }
+
+ if (!l2cap_frame_pull((void *)frame, frame, cc->len)) {
+ print_text(COLOR_ERROR,
+ "Codec Specific Configuration: invalid size");
+ return;
+ }
+
+ packet_print_ltv(" Codec Specific Configuration", cc->data, cc->len);
+}
+
+static void print_framing(uint8_t value)
+{
+ switch (value) {
+ case 0x00:
+ print_field(" Framing: Unframed (0x%2.2x)", value);
+ break;
+ case 0x01:
+ print_field(" Framing: Framed (0x%2.2x)", value);
+ break;
+ default:
+ print_field(" Framing: Reserved (0x%2.2x)", value);
+ }
+}
+
+static const struct bitfield_data phy_table[] = {
+ { 0, "LE 1M PHY (0x01)" },
+ { 1, "LE 2M PHY (0x02)" },
+ { 2, "LE Codec PHY (0x04)" },
+ { }
+};
+
+static void print_phy(uint8_t phy)
+{
+ uint8_t mask;
+
+ mask = print_bitfield(4, phy, phy_table);
+ if (mask)
+ print_text(COLOR_WHITE_BG, " Unknown fields (0x%2.2x)",
+ mask);
+}
+
+static void print_ase_qos(const struct l2cap_frame *frame)
+{
+ uint8_t framing, phy, rtn;
+ uint16_t sdu, latency;
+ uint32_t interval, pd;
+
+ if (!l2cap_frame_print_u8((void *)frame, " CIG ID"))
+ return;
+
+ if (!l2cap_frame_print_u8((void *)frame, " CIS ID"))
+ return;
+
+ if (!l2cap_frame_get_le24((void *)frame, &interval)) {
+ print_text(COLOR_ERROR, "SDU Interval: invalid size");
+ return;
+ }
+
+ print_field(" SDU Interval: %u us", interval);
+
+ if (!l2cap_frame_get_u8((void *)frame, &framing)) {
+ print_text(COLOR_ERROR, "Framing: invalid size");
+ return;
+ }
+
+ print_framing(framing);
+
+ if (!l2cap_frame_get_u8((void *)frame, &phy)) {
+ print_text(COLOR_ERROR, "PHY: invalid size");
+ return;
+ }
+
+ print_phy(phy);
+
+ if (!l2cap_frame_get_le16((void *)frame, &sdu)) {
+ print_text(COLOR_ERROR, "Max SDU: invalid size");
+ return;
+ }
+
+ print_field(" Max SDU: %u", sdu);
+
+ if (!l2cap_frame_get_u8((void *)frame, &rtn)) {
+ print_text(COLOR_ERROR, "RTN: invalid size");
+ return;
+ }
+
+ print_field(" RTN: %u", rtn);
+
+ if (!l2cap_frame_get_le16((void *)frame, &latency)) {
+ print_text(COLOR_ERROR, "Max Transport Latency: invalid size");
+ return;
+ }
+
+ print_field(" Max Transport Latency: %u", sdu);
+
+ if (!l2cap_frame_get_le24((void *)frame, &pd)) {
+ print_text(COLOR_ERROR, "Presentation Delay: invalid size");
+ return;
+ }
+
+ print_field(" Presentation Delay: %u us", pd);
+}
+
+static void print_ase_metadata(const struct l2cap_frame *frame)
+{
+ struct bt_hci_lv_data *meta;
+
+ if (!l2cap_frame_print_u8((void *)frame, " CIG ID"))
+ return;
+
+ if (!l2cap_frame_print_u8((void *)frame, " CIS ID"))
+ return;
+
+ meta = l2cap_frame_pull((void *)frame, frame, sizeof(*meta));
+ if (!meta) {
+ print_text(COLOR_ERROR, "Metadata: invalid size");
+ return;
+ }
+
+ if (!l2cap_frame_pull((void *)frame, frame, meta->len)) {
+ print_text(COLOR_ERROR, "Metadata: invalid size");
+ return;
+ }
+
+ packet_print_ltv(" Metadata", meta->data, meta->len);
+}
+
+static void print_ase_status(const struct l2cap_frame *frame)
+{
+ uint8_t id, state;
+
+ if (!l2cap_frame_get_u8((void *)frame, &id)) {
+ print_text(COLOR_ERROR, "ASE ID: invalid size");
+ goto done;
+ }
+
+ print_field(" ASE ID: %u", id);
+
+ if (!l2cap_frame_get_u8((void *)frame, &state)) {
+ print_text(COLOR_ERROR, "ASE State: invalid size");
+ goto done;
+ }
+
+ switch (state) {
+ /* ASE_State = 0x00 (Idle) */
+ case 0x00:
+ print_field(" State: Idle (0x00)");
+ break;
+ /* ASE_State = 0x01 (Codec Configured) */
+ case 0x01:
+ print_field(" State: Codec Configured (0x01)");
+ print_ase_config(frame);
+ break;
+ /* ASE_State = 0x02 (QoS Configured) */
+ case 0x02:
+ print_field(" State: QoS Configured (0x02)");
+ print_ase_qos(frame);
+ break;
+ /* ASE_Status = 0x03 (Enabling) */
+ case 0x03:
+ print_field(" State: Enabling (0x03)");
+ print_ase_metadata(frame);
+ break;
+ /* ASE_Status = 0x04 (Streaming) */
+ case 0x04:
+ print_field(" State: Streaming (0x04)");
+ print_ase_metadata(frame);
+ break;
+ /* ASE_Status = 0x05 (Disabling) */
+ case 0x05:
+ print_field(" State: Disabling (0x05)");
+ print_ase_metadata(frame);
+ break;
+ /* ASE_Status = 0x06 (Releasing) */
+ case 0x06:
+ print_field(" State: Releasing (0x06)");
+ break;
+ default:
+ print_field(" State: Reserved (0x%2.2x)", state);
+ break;
+ }
+
+done:
+ if (frame->size)
+ print_hex_field(" Data", frame->data, frame->size);
+}
+
+static void ase_read(const struct l2cap_frame *frame)
+{
+ print_ase_status(frame);
+}
+
+static void ase_notify(const struct l2cap_frame *frame)
+{
+ print_ase_status(frame);
+}
+
#define GATT_HANDLER(_uuid, _read, _write, _notify) \
{ \
.uuid = { \
void (*notify)(const struct l2cap_frame *frame);
} gatt_handlers[] = {
GATT_HANDLER(0x2902, ccc_read, ccc_write, NULL),
+ GATT_HANDLER(0x2bc4, ase_read, NULL, ase_notify),
+ GATT_HANDLER(0x2bc5, ase_read, NULL, ase_notify),
GATT_HANDLER(0x2bc9, pac_read, NULL, pac_notify),
GATT_HANDLER(0x2bcb, pac_read, NULL, pac_notify),
};
diff --git a/monitor/l2cap.h b/monitor/l2cap.h
index c33d4c5..00a8ffb 100644
--- a/monitor/l2cap.h
+++ b/monitor/l2cap.h
return true;
}
+static inline bool l2cap_frame_print_u8(struct l2cap_frame *frame,
+ const char *label)
+{
+ uint8_t u8;
+
+ if (!l2cap_frame_get_u8(frame, &u8)) {
+ print_text(COLOR_ERROR, "%s: invalid size", label);
+ return false;
+ }
+
+ print_field("%s: 0x%2.2x", label, u8);
+
+ return true;
+}
+
static inline bool l2cap_frame_get_be16(struct l2cap_frame *frame,
uint16_t *value)
{
return true;
}
+static inline bool l2cap_frame_print_be16(struct l2cap_frame *frame,
+ const char *label)
+{
+ uint16_t u16;
+
+ if (!l2cap_frame_get_be16(frame, &u16)) {
+ print_text(COLOR_ERROR, "%s: invalid size", label);
+ return false;
+ }
+
+ print_field("%s: 0x%4.4x", label, u16);
+
+ return true;
+}
+
static inline bool l2cap_frame_get_le16(struct l2cap_frame *frame,
uint16_t *value)
{
return true;
}
+static inline bool l2cap_frame_print_le16(struct l2cap_frame *frame,
+ const char *label)
+{
+ uint16_t u16;
+
+ if (!l2cap_frame_get_le16(frame, &u16)) {
+ print_text(COLOR_ERROR, "%s: invalid size", label);
+ return false;
+ }
+
+ print_field("%s: 0x%4.4x", label, u16);
+
+ return true;
+}
+
+static inline bool l2cap_frame_get_be24(struct l2cap_frame *frame,
+ uint32_t *value)
+{
+ if (frame->size < sizeof(uint24_t))
+ return false;
+
+ if (value)
+ *value = get_be24(frame->data);
+
+ l2cap_frame_pull(frame, frame, sizeof(uint24_t));
+
+ return true;
+}
+
+static inline bool l2cap_frame_print_be24(struct l2cap_frame *frame,
+ const char *label)
+{
+ uint32_t u24;
+
+ if (!l2cap_frame_get_be24(frame, &u24)) {
+ print_text(COLOR_ERROR, "%s: invalid size", label);
+ return false;
+ }
+
+ print_field("%s: 0x%6.6x", label, u24);
+
+ return true;
+}
+
+static inline bool l2cap_frame_get_le24(struct l2cap_frame *frame,
+ uint32_t *value)
+{
+ if (frame->size < sizeof(uint24_t))
+ return false;
+
+ if (value)
+ *value = get_le24(frame->data);
+
+ l2cap_frame_pull(frame, frame, sizeof(uint24_t));
+
+ return true;
+}
+
+static inline bool l2cap_frame_print_le24(struct l2cap_frame *frame,
+ const char *label)
+{
+ uint32_t u24;
+
+ if (!l2cap_frame_get_le24(frame, &u24)) {
+ print_text(COLOR_ERROR, "%s: invalid size", label);
+ return false;
+ }
+
+ print_field("%s: 0x%6.6x", label, u24);
+
+ return true;
+}
+
static inline bool l2cap_frame_get_be32(struct l2cap_frame *frame,
uint32_t *value)
{
return true;
}
+static inline bool l2cap_frame_print_be32(struct l2cap_frame *frame,
+ const char *label)
+{
+ uint32_t u32;
+
+ if (!l2cap_frame_get_be32(frame, &u32)) {
+ print_text(COLOR_ERROR, "%s: invalid size", label);
+ return false;
+ }
+
+ print_field("%s: 0x%8.8x", label, u32);
+
+ return true;
+}
+
static inline bool l2cap_frame_get_le32(struct l2cap_frame *frame,
uint32_t *value)
{
return true;
}
+static inline bool l2cap_frame_print_le32(struct l2cap_frame *frame,
+ const char *label)
+{
+ uint32_t u32;
+
+ if (!l2cap_frame_get_le32(frame, &u32)) {
+ print_text(COLOR_ERROR, "%s: invalid size", label);
+ return false;
+ }
+
+ print_field("%s: 0x%8.8x", label, u32);
+
+ return true;
+}
+
static inline bool l2cap_frame_get_be64(struct l2cap_frame *frame,
uint64_t *value)
{
return true;
}
+static inline bool l2cap_frame_print_be64(struct l2cap_frame *frame,
+ const char *label)
+{
+ uint64_t u64;
+
+ if (!l2cap_frame_get_be64(frame, &u64)) {
+ print_text(COLOR_ERROR, "%s: invalid size", label);
+ return false;
+ }
+
+ print_field("%s: 0x%zx", label, u64);
+
+ return true;
+}
+
static inline bool l2cap_frame_get_le64(struct l2cap_frame *frame,
uint64_t *value)
{
return true;
}
+static inline bool l2cap_frame_print_le64(struct l2cap_frame *frame,
+ const char *label)
+{
+ uint64_t u64;
+
+ if (!l2cap_frame_get_le64(frame, &u64)) {
+ print_text(COLOR_ERROR, "%s: invalid size", label);
+ return false;
+ }
+
+ print_field("%s: 0x%zx", label, u64);
+
+ return true;
+}
+
static inline bool l2cap_frame_get_be128(struct l2cap_frame *frame,
uint64_t *lvalue, uint64_t *rvalue)
{