[PATCH -v3 1/6] Partial dump of ATT PDUs

[PATCH -v3 1/6] Partial dump of ATT PDUs

[Andre Dieb Martins]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 6617 bytes --]

Starts implementing dumping for ATT/GATT pdus.
---
 Makefile.am     |    1 +
 parser/att.c    |  161 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 parser/l2cap.c  |    7 +++
 parser/parser.h |    2 +
 src/hcidump.c   |    1 +
 5 files changed, 172 insertions(+), 0 deletions(-)
 create mode 100644 parser/att.c

diff --git a/Makefile.am b/Makefile.am
index e39ae1e..99dd422 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -5,6 +5,7 @@ parser_sources =  parser/parser.h parser/parser.c \
 					parser/lmp.c \
 					parser/hci.c \
 					parser/l2cap.c \
+					parser/att.c \
 					parser/sdp.h parser/sdp.c \
 					parser/rfcomm.h parser/rfcomm.c \
 					parser/bnep.c \
diff --git a/parser/att.c b/parser/att.c
new file mode 100644
index 0000000..eb0d00b
--- /dev/null
+++ b/parser/att.c
@@ -0,0 +1,161 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2011  André Dieb Martins <andre.dieb@gmail.com>
+ *
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <sys/types.h>
+#include <netinet/in.h>
+
+#include "parser.h"
+
+/* Attribute Protocol Opcodes */
+#define ATT_OP_ERROR			0x01
+#define ATT_OP_MTU_REQ			0x02
+#define ATT_OP_MTU_RESP			0x03
+#define ATT_OP_FIND_INFO_REQ		0x04
+#define ATT_OP_FIND_INFO_RESP		0x05
+#define ATT_OP_FIND_BY_TYPE_REQ		0x06
+#define ATT_OP_FIND_BY_TYPE_RESP	0x07
+#define ATT_OP_READ_BY_TYPE_REQ		0x08
+#define ATT_OP_READ_BY_TYPE_RESP	0x09
+#define ATT_OP_READ_REQ			0x0A
+#define ATT_OP_READ_RESP		0x0B
+#define ATT_OP_READ_BLOB_REQ		0x0C
+#define ATT_OP_READ_BLOB_RESP		0x0D
+#define ATT_OP_READ_MULTI_REQ		0x0E
+#define ATT_OP_READ_MULTI_RESP		0x0F
+#define ATT_OP_READ_BY_GROUP_REQ	0x10
+#define ATT_OP_READ_BY_GROUP_RESP	0x11
+#define ATT_OP_WRITE_REQ		0x12
+#define ATT_OP_WRITE_RESP		0x13
+#define ATT_OP_WRITE_CMD		0x52
+#define ATT_OP_PREP_WRITE_REQ		0x16
+#define ATT_OP_PREP_WRITE_RESP		0x17
+#define ATT_OP_EXEC_WRITE_REQ		0x18
+#define ATT_OP_EXEC_WRITE_RESP		0x19
+#define ATT_OP_HANDLE_NOTIFY		0x1B
+#define ATT_OP_HANDLE_IND		0x1D
+#define ATT_OP_HANDLE_CNF		0x1E
+#define ATT_OP_SIGNED_WRITE_CMD		0xD2
+
+
+/* Attribute Protocol Opcodes */
+static const char *attop2str(uint8_t op)
+{
+	switch (op) {
+	case ATT_OP_ERROR:
+		return "Error";
+	case ATT_OP_MTU_REQ:
+		return "MTU req";
+	case ATT_OP_MTU_RESP:
+		return "MTU resp";
+	case ATT_OP_FIND_INFO_REQ:
+		return "Find Information req";
+	case ATT_OP_FIND_INFO_RESP:
+		return "Find Information resp";
+	case ATT_OP_FIND_BY_TYPE_REQ:
+		return "Find By Type req";
+	case ATT_OP_FIND_BY_TYPE_RESP:
+		return "Find By Type resp";
+	case ATT_OP_READ_BY_TYPE_REQ:
+		return "Read By Type req";
+	case ATT_OP_READ_BY_TYPE_RESP:
+		return "Read By Type resp";
+	case ATT_OP_READ_REQ:
+		return "Read req";
+	case ATT_OP_READ_RESP:
+		return "Read resp";
+	case ATT_OP_READ_BLOB_REQ:
+		return "Read Blob req";
+	case ATT_OP_READ_BLOB_RESP:
+		return "Read Blob resp";
+	case ATT_OP_READ_MULTI_REQ:
+		return "Read Multi req";
+	case ATT_OP_READ_MULTI_RESP:
+		return "Read Multi resp";
+	case ATT_OP_READ_BY_GROUP_REQ:
+		return "Read By Group req";
+	case ATT_OP_READ_BY_GROUP_RESP:
+		return "Read By Group resp";
+	case ATT_OP_WRITE_REQ:
+		return "Write req";
+	case ATT_OP_WRITE_RESP:
+		return "Write resp";
+	case ATT_OP_WRITE_CMD:
+		return "Write cmd";
+	case ATT_OP_PREP_WRITE_REQ:
+		return "Prepare Write req";
+	case ATT_OP_PREP_WRITE_RESP:
+		return "Prepare Write resp";
+	case ATT_OP_EXEC_WRITE_REQ:
+		return "Exec Write req";
+	case ATT_OP_EXEC_WRITE_RESP:
+		return "Exec Write resp";
+	case ATT_OP_HANDLE_NOTIFY:
+		return "Handle notify";
+	case ATT_OP_HANDLE_IND:
+		return "Handle indicate";
+	case ATT_OP_HANDLE_CNF:
+		return "Handle CNF";
+	case ATT_OP_SIGNED_WRITE_CMD:
+		return "Signed Write Cmd";
+	default:
+		return "Unknown";
+	}
+}
+
+static void att_handle_notify_dump(int level, struct frame *frm)
+{
+	uint16_t handle = btohs(htons(get_u16(frm)));
+
+	p_indent(level, frm);
+	printf("handle 0x%2.2x\n", handle);
+}
+
+void att_dump(int level, struct frame *frm)
+{
+	uint8_t op;
+
+	op = get_u8(frm);
+
+	p_indent(level, frm);
+	printf("ATT: %s (0x%.2x)\n", attop2str(op), op);
+
+	switch (op) {
+		case ATT_OP_HANDLE_NOTIFY:
+			att_handle_notify_dump(level + 1, frm);
+			break;
+
+		default:
+			raw_dump(level, frm);
+			break;
+	}
+}
diff --git a/parser/l2cap.c b/parser/l2cap.c
index 5c5371f..963468c 100644
--- a/parser/l2cap.c
+++ b/parser/l2cap.c
@@ -898,6 +898,13 @@ static void l2cap_parse(int level, struct frame *frm)
 				raw_dump(level + 1, frm);
 			break;
 
+		case 0x1f:
+			if (!p_filter(FILT_ATT))
+				att_dump(level, frm);
+			else
+				raw_dump(level + 1, frm);
+			break;
+
 		default:
 			proto = get_proto(frm->handle, psm, 0);
 
diff --git a/parser/parser.h b/parser/parser.h
index 973ab22..f093b6b 100644
--- a/parser/parser.h
+++ b/parser/parser.h
@@ -77,6 +77,7 @@ struct frame {
 #define FILT_HCRP	0x0200
 #define FILT_AVDTP	0x0400
 #define FILT_AVCTP	0x0800
+#define FILT_ATT 	0x1000
 
 #define FILT_OBEX	0x00010000
 #define FILT_CAPI	0x00020000
@@ -229,6 +230,7 @@ void hidp_dump(int level, struct frame *frm);
 void hcrp_dump(int level, struct frame *frm);
 void avdtp_dump(int level, struct frame *frm);
 void avctp_dump(int level, struct frame *frm);
+void att_dump(int level, struct frame *frm);
 
 void obex_dump(int level, struct frame *frm);
 void capi_dump(int level, struct frame *frm);
diff --git a/src/hcidump.c b/src/hcidump.c
index b344489..af086c7 100644
--- a/src/hcidump.c
+++ b/src/hcidump.c
@@ -824,6 +824,7 @@ static struct {
 	{ "cmtp",	FILT_CMTP	},
 	{ "hidp",	FILT_HIDP	},
 	{ "hcrp",	FILT_HCRP	},
+	{ "att",	FILT_ATT	},
 	{ "avdtp",	FILT_AVDTP	},
 	{ "avctp",	FILT_AVCTP	},
 	{ "obex",	FILT_OBEX	},
-- 
1.7.1

[PATCH -v3 2/6] Add ATT MTU req/resp and notify value

[Andre Dieb Martins]

---
 parser/att.c |   29 +++++++++++++++++++++++++++++
 1 files changed, 29 insertions(+), 0 deletions(-)

diff --git a/parser/att.c b/parser/att.c
index eb0d00b..261dfe6 100644
--- a/parser/att.c
+++ b/parser/att.c
@@ -132,12 +132,35 @@ static const char *attop2str(uint8_t op)
 	}
 }
 
+static void att_mtu_req_dump(int level, struct frame *frm)
+{
+	uint16_t client_rx_mtu = btohs(htons(get_u16(frm)));
+
+	p_indent(level, frm);
+	printf("client rx mtu %d\n", client_rx_mtu);
+}
+
+static void att_mtu_resp_dump(int level, struct frame *frm)
+{
+	uint16_t server_rx_mtu = btohs(htons(get_u16(frm)));
+
+	p_indent(level, frm);
+	printf("server rx mtu %d\n", server_rx_mtu);
+}
+
 static void att_handle_notify_dump(int level, struct frame *frm)
 {
 	uint16_t handle = btohs(htons(get_u16(frm)));
 
 	p_indent(level, frm);
 	printf("handle 0x%2.2x\n", handle);
+
+	p_indent(level, frm);
+	printf("value ");
+	while (frm->len > 0) {
+		printf("0x%.2x ", get_u8(frm));
+	}
+	printf("\n");
 }
 
 void att_dump(int level, struct frame *frm)
@@ -150,6 +173,12 @@ void att_dump(int level, struct frame *frm)
 	printf("ATT: %s (0x%.2x)\n", attop2str(op), op);
 
 	switch (op) {
+		case ATT_OP_MTU_REQ:
+			att_mtu_req_dump(level + 1, frm);
+			break;
+		case ATT_OP_MTU_RESP:
+			att_mtu_resp_dump(level + 1, frm);
+			break;
 		case ATT_OP_HANDLE_NOTIFY:
 			att_handle_notify_dump(level + 1, frm);
 			break;
-- 
1.7.1

[PATCH -v3 3/6] Add ATT error pdu dump

[Andre Dieb Martins]

---
 parser/att.c |   80 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 80 insertions(+), 0 deletions(-)

diff --git a/parser/att.c b/parser/att.c
index 261dfe6..3717839 100644
--- a/parser/att.c
+++ b/parser/att.c
@@ -66,6 +66,26 @@
 #define ATT_OP_HANDLE_CNF		0x1E
 #define ATT_OP_SIGNED_WRITE_CMD		0xD2
 
+/* Error codes for Error response PDU */
+#define ATT_ECODE_INVALID_HANDLE		0x01
+#define ATT_ECODE_READ_NOT_PERM			0x02
+#define ATT_ECODE_WRITE_NOT_PERM		0x03
+#define ATT_ECODE_INVALID_PDU			0x04
+#define ATT_ECODE_INSUFF_AUTHEN			0x05
+#define ATT_ECODE_REQ_NOT_SUPP			0x06
+#define ATT_ECODE_INVALID_OFFSET		0x07
+#define ATT_ECODE_INSUFF_AUTHO			0x08
+#define ATT_ECODE_PREP_QUEUE_FULL		0x09
+#define ATT_ECODE_ATTR_NOT_FOUND		0x0A
+#define ATT_ECODE_ATTR_NOT_LONG			0x0B
+#define ATT_ECODE_INSUFF_ENCR_KEY_SIZE		0x0C
+#define ATT_ECODE_INVAL_ATTR_VALUE_LEN		0x0D
+#define ATT_ECODE_UNLIKELY			0x0E
+#define ATT_ECODE_INSUFF_ENC			0x0F
+#define ATT_ECODE_UNSUPP_GRP_TYPE		0x10
+#define ATT_ECODE_INSUFF_RESOURCES		0x11
+#define ATT_ECODE_IO				0xFF
+
 
 /* Attribute Protocol Opcodes */
 static const char *attop2str(uint8_t op)
@@ -132,6 +152,63 @@ static const char *attop2str(uint8_t op)
 	}
 }
 
+static const char * atterror2str(uint8_t err)
+{
+	switch (err) {
+	case ATT_ECODE_INVALID_HANDLE:
+		return "Invalid handle";
+	case ATT_ECODE_READ_NOT_PERM:
+		return "Read not permitted";
+	case ATT_ECODE_WRITE_NOT_PERM:
+		return "Write not permitted";
+	case ATT_ECODE_INVALID_PDU:
+		return "Invalid PDU";
+	case ATT_ECODE_INSUFF_AUTHEN:
+		return "Insufficient authentication";
+	case ATT_ECODE_REQ_NOT_SUPP:
+		return "Request not supported";
+	case ATT_ECODE_INVALID_OFFSET:
+		return "Invalid offset";
+	case ATT_ECODE_INSUFF_AUTHO:
+		return "Insufficient authorization";
+	case ATT_ECODE_PREP_QUEUE_FULL:
+		return "Prepare queue full";
+	case ATT_ECODE_ATTR_NOT_FOUND:
+		return "Attribute not found";
+	case ATT_ECODE_ATTR_NOT_LONG:
+		return "Attribute not long";
+	case ATT_ECODE_INSUFF_ENCR_KEY_SIZE:
+		return "Insufficient encryption key size";
+	case ATT_ECODE_INVAL_ATTR_VALUE_LEN:
+		return "Invalid attribute value length";
+	case ATT_ECODE_UNLIKELY:
+		return "Unlikely error";
+	case ATT_ECODE_INSUFF_ENC:
+		return "Insufficient encryption";
+	case ATT_ECODE_UNSUPP_GRP_TYPE:
+		return "Unsupported group type";
+	case ATT_ECODE_INSUFF_RESOURCES:
+		return "Insufficient resources";
+	case ATT_ECODE_IO:
+		return "Application Error";
+	default:
+		return "Reserved";
+	}
+}
+
+static void att_error_dump(int level, struct frame *frm)
+{
+	uint8_t op = get_u8(frm);
+	uint16_t handle = btohs(htons(get_u16(frm)));
+	uint8_t err = get_u8(frm);
+
+	p_indent(level, frm);
+	printf("Error: %s 0x%.2x\n", atterror2str(err), err);
+
+	p_indent(level, frm);
+	printf("opcode %d (%s) on handle 0x%2.2x\n", op, attop2str(op), handle);
+}
+
 static void att_mtu_req_dump(int level, struct frame *frm)
 {
 	uint16_t client_rx_mtu = btohs(htons(get_u16(frm)));
@@ -173,6 +250,9 @@ void att_dump(int level, struct frame *frm)
 	printf("ATT: %s (0x%.2x)\n", attop2str(op), op);
 
 	switch (op) {
+		case ATT_OP_ERROR:
+			att_error_dump(level + 1, frm);
+			break;
 		case ATT_OP_MTU_REQ:
 			att_mtu_req_dump(level + 1, frm);
 			break;
-- 
1.7.1

[PATCH -v3 4/6] Add ATT find info req/resp dump

[Andre Dieb Martins]

Adds dumping for ATT's Find Info Request and Response. Also adds a simple
name resolving for GATT common uuids (listed on Assigned Numbers).
---
 parser/att.c |  116 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 files changed, 113 insertions(+), 3 deletions(-)

diff --git a/parser/att.c b/parser/att.c
index 3717839..d8a10fc 100644
--- a/parser/att.c
+++ b/parser/att.c
@@ -36,6 +36,27 @@
 
 #include "parser.h"
 
+#define GATT_PRIM_SVC_UUID		0x2800
+#define GATT_SND_SVC_UUID		0x2801
+#define GATT_INCLUDE_UUID		0x2802
+#define GATT_CHARAC_UUID		0x2803
+
+#define GATT_CHARAC_DEVICE_NAME			0x2A00
+#define GATT_CHARAC_APPEARANCE			0x2A01
+#define GATT_CHARAC_PERIPHERAL_PRIV_FLAG	0x2A02
+#define GATT_CHARAC_RECONNECTION_ADDRESS	0x2A03
+#define GATT_CHARAC_PERIPHERAL_PREF_CONN	0x2A04
+#define GATT_CHARAC_SERVICE_CHANGED		0x2A05
+
+#define GATT_CHARAC_EXT_PROPER_UUID	0x2900
+#define GATT_CHARAC_USER_DESC_UUID	0x2901
+#define GATT_CLIENT_CHARAC_CFG_UUID	0x2902
+#define GATT_SERVER_CHARAC_CFG_UUID	0x2903
+#define GATT_CHARAC_FMT_UUID		0x2904
+#define GATT_CHARAC_AGREG_FMT_UUID	0x2905
+
+
+
 /* Attribute Protocol Opcodes */
 #define ATT_OP_ERROR			0x01
 #define ATT_OP_MTU_REQ			0x02
@@ -196,6 +217,46 @@ static const char * atterror2str(uint8_t err)
 	}
 }
 
+static const char *uuid2str(uint16_t uuid)
+{
+	switch (uuid) {
+	case GATT_PRIM_SVC_UUID:
+		return "GATT Primary Service";
+	case GATT_SND_SVC_UUID:
+		return "GATT Secondary Service";
+	case GATT_INCLUDE_UUID:
+		return "GATT Include";
+	case GATT_CHARAC_UUID:
+		return "GATT Characteristic";
+	case GATT_CHARAC_DEVICE_NAME:
+		return "GATT(type) Device Name";
+	case GATT_CHARAC_APPEARANCE:
+		return "GATT(type) Appearance";
+	case GATT_CHARAC_PERIPHERAL_PRIV_FLAG:
+		return "GATT(type) Peripheral Privacy Flag";
+	case GATT_CHARAC_RECONNECTION_ADDRESS:
+		return "GATT(type) Characteristic Reconnection Address";
+	case GATT_CHARAC_PERIPHERAL_PREF_CONN:
+		return "GATT(type) Characteristic Preferred Connection Parameters";
+	case GATT_CHARAC_SERVICE_CHANGED:
+		return "GATT(type) Characteristic Service Changed";
+	case GATT_CHARAC_EXT_PROPER_UUID:
+		return "GATT(desc) Characteristic Extended Properties";
+	case GATT_CHARAC_USER_DESC_UUID:
+		return "GATT(desc) User Description";
+	case GATT_CLIENT_CHARAC_CFG_UUID:
+		return "GATT(desc) Client Characteristic Configuration";
+	case GATT_SERVER_CHARAC_CFG_UUID:
+		return "GATT(desc) Server Characteristic Configuration";
+	case GATT_CHARAC_FMT_UUID:
+		return "GATT(desc) Format";
+	case GATT_CHARAC_AGREG_FMT_UUID:
+		return "GATT(desc) Aggregate Format";
+	default:
+		return "Unknown";
+	}
+}
+
 static void att_error_dump(int level, struct frame *frm)
 {
 	uint8_t op = get_u8(frm);
@@ -203,10 +264,10 @@ static void att_error_dump(int level, struct frame *frm)
 	uint8_t err = get_u8(frm);
 
 	p_indent(level, frm);
-	printf("Error: %s 0x%.2x\n", atterror2str(err), err);
+	printf("Error: %s (%d)\n", atterror2str(err), err);
 
 	p_indent(level, frm);
-	printf("opcode %d (%s) on handle 0x%2.2x\n", op, attop2str(op), handle);
+	printf("%s (0x%.2x) on handle 0x%2.2x\n", attop2str(op), op, handle);
 }
 
 static void att_mtu_req_dump(int level, struct frame *frm)
@@ -225,6 +286,50 @@ static void att_mtu_resp_dump(int level, struct frame *frm)
 	printf("server rx mtu %d\n", server_rx_mtu);
 }
 
+static void att_find_info_req_dump(int level, struct frame *frm)
+{
+	uint16_t start = btohs(htons(get_u16(frm)));
+	uint16_t end = btohs(htons(get_u16(frm)));
+
+	p_indent(level, frm);
+	printf("start 0x%2.2x, end 0x%2.2x\n", start, end);
+}
+
+static void att_find_info_resp_dump(int level, struct frame *frm)
+{
+	uint8_t fmt = get_u8(frm);
+
+	p_indent(level, frm);
+
+	if (fmt == 0x01) {
+		printf("format: uuid-16\n");
+
+		while (frm->len > 0) {
+			uint16_t handle = btohs(htons(get_u16(frm)));
+			uint16_t uuid = btohs(htons(get_u16(frm)));
+			p_indent(level + 1, frm);
+			printf("handle 0x%2.2x, uuid 0x%2.2x (%s)\n", handle, uuid,
+					uuid2str(uuid));
+		}
+	} else {
+		printf("format: uuid-128\n");
+
+		while (frm->len > 0) {
+			uint16_t handle = btohs(htons(get_u16(frm)));
+			int i;
+
+			p_indent(level + 1, frm);
+			printf("handle 0x%2.2x, uuid ", handle);
+			for (i = 0; i < 16; i++) {
+				printf("%02x", get_u8(frm));
+				if (i == 3 || i == 5 || i == 7 || i == 9)
+					printf("-");
+			}
+			printf("\n");
+		}
+	}
+}
+
 static void att_handle_notify_dump(int level, struct frame *frm)
 {
 	uint16_t handle = btohs(htons(get_u16(frm)));
@@ -259,10 +364,15 @@ void att_dump(int level, struct frame *frm)
 		case ATT_OP_MTU_RESP:
 			att_mtu_resp_dump(level + 1, frm);
 			break;
+		case ATT_OP_FIND_INFO_REQ:
+			att_find_info_req_dump(level + 1, frm);
+			break;
+		case ATT_OP_FIND_INFO_RESP:
+			att_find_info_resp_dump(level + 1, frm);
+			break;
 		case ATT_OP_HANDLE_NOTIFY:
 			att_handle_notify_dump(level + 1, frm);
 			break;
-
 		default:
 			raw_dump(level, frm);
 			break;
-- 
1.7.1

[PATCH -v3 5/6] Add ATT dump for read req/resp

[Andre Dieb Martins]

---
 parser/att.c |   14 ++++++++++++++
 1 files changed, 14 insertions(+), 0 deletions(-)

diff --git a/parser/att.c b/parser/att.c
index d8a10fc..887cdac 100644
--- a/parser/att.c
+++ b/parser/att.c
@@ -330,6 +330,14 @@ static void att_find_info_resp_dump(int level, struct frame *frm)
 	}
 }
 
+static void att_read_req_dump(int level, struct frame *frm)
+{
+	uint16_t handle = btohs(htons(get_u16(frm)));
+
+	p_indent(level, frm);
+	printf("handle 0x%2.2x\n", handle);
+}
+
 static void att_handle_notify_dump(int level, struct frame *frm)
 {
 	uint16_t handle = btohs(htons(get_u16(frm)));
@@ -370,6 +378,12 @@ void att_dump(int level, struct frame *frm)
 		case ATT_OP_FIND_INFO_RESP:
 			att_find_info_resp_dump(level + 1, frm);
 			break;
+		case ATT_OP_READ_REQ:
+			att_read_req_dump(level + 1, frm);
+			break;
+		case ATT_OP_READ_RESP:
+			raw_dump(level + 1, frm);
+			break;
 		case ATT_OP_HANDLE_NOTIFY:
 			att_handle_notify_dump(level + 1, frm);
 			break;
-- 
1.7.1

[PATCH -v3 6/6] Add ATT read by type req/resp dump

[Andre Dieb Martins]

---
 parser/att.c |   54 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 54 insertions(+), 0 deletions(-)

diff --git a/parser/att.c b/parser/att.c
index 887cdac..a0fb135 100644
--- a/parser/att.c
+++ b/parser/att.c
@@ -330,6 +330,54 @@ static void att_find_info_resp_dump(int level, struct frame *frm)
 	}
 }
 
+static void att_read_by_type_req_dump(int level, struct frame *frm)
+{
+	uint16_t start = btohs(htons(get_u16(frm)));
+	uint16_t end = btohs(htons(get_u16(frm)));
+	int i;
+
+	p_indent(level, frm);
+	printf("start 0x%2.2x, end 0x%2.2x\n", start, end);
+
+	p_indent(level, frm);
+	if (frm->len == 2) {
+		printf("type-uuid 0x%2.2x\n", btohs(htons(get_u16(frm))));
+	} else if (frm->len == 16) {
+		printf("type-uuid ");
+		for (i = 0; i < 16; i++) {
+			printf("%02x", get_u8(frm));
+			if (i == 3 || i == 5 || i == 7 || i == 9)
+				printf("-");
+		}
+		printf("\n");
+	} else {
+		printf("malformed uuid (expected 2 or 16 octets)\n");
+		p_indent(level, frm);
+		raw_dump(level, frm);
+	}
+}
+
+static void att_read_by_type_resp_dump(int level, struct frame *frm)
+{
+	uint8_t length = get_u8(frm);
+
+	p_indent(level, frm);
+	printf("length: %d\n", length);
+
+	while (frm->len > 0) {
+		uint16_t handle = btohs(htons(get_u16(frm)));
+		int val_len = length - 2;
+		int i;
+
+		p_indent(level + 1, frm);
+		printf("handle 0x%2.2x, value ", handle);
+		for (i = 0; i < val_len; i++) {
+			printf("0x%.2x ", get_u8(frm));
+		}
+		printf("\n");
+	}
+}
+
 static void att_read_req_dump(int level, struct frame *frm)
 {
 	uint16_t handle = btohs(htons(get_u16(frm)));
@@ -378,6 +426,12 @@ void att_dump(int level, struct frame *frm)
 		case ATT_OP_FIND_INFO_RESP:
 			att_find_info_resp_dump(level + 1, frm);
 			break;
+		case ATT_OP_READ_BY_TYPE_REQ:
+			att_read_by_type_req_dump(level + 1, frm);
+			break;
+		case ATT_OP_READ_BY_TYPE_RESP:
+			att_read_by_type_resp_dump(level + 1, frm);
+			break;
 		case ATT_OP_READ_REQ:
 			att_read_req_dump(level + 1, frm);
 			break;
-- 
1.7.1

Re: [PATCH -v3 1/6] Partial dump of ATT PDUs

[Johan Hedberg]

Hi André,

On Wed, Feb 09, 2011, Andre Dieb Martins wrote:
> Starts implementing dumping for ATT/GATT pdus.
> ---
>  Makefile.am     |    1 +
>  parser/att.c    |  161 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
>  parser/l2cap.c  |    7 +++
>  parser/parser.h |    2 +
>  src/hcidump.c   |    1 +
>  5 files changed, 172 insertions(+), 0 deletions(-)
>  create mode 100644 parser/att.c

All six patches have been pushed upstream. Thanks.

Johan