1 /*
2 *
3 * BlueZ - Bluetooth protocol stack for Linux
4 *
5 * Copyright (C) 2011 André Dieb Martins <andre.dieb@gmail.com>
6 *
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21 *
22 */
23
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27
28 #include <stdio.h>
29 #include <errno.h>
30 #include <unistd.h>
31 #include <stdlib.h>
32 #include <string.h>
33
34 #include <sys/types.h>
35 #include <netinet/in.h>
36
37 #include "parser.h"
38
39 #define GATT_PRIM_SVC_UUID 0x2800
40 #define GATT_SND_SVC_UUID 0x2801
41 #define GATT_INCLUDE_UUID 0x2802
42 #define GATT_CHARAC_UUID 0x2803
43
44 #define GATT_CHARAC_DEVICE_NAME 0x2A00
45 #define GATT_CHARAC_APPEARANCE 0x2A01
46 #define GATT_CHARAC_PERIPHERAL_PRIV_FLAG 0x2A02
47 #define GATT_CHARAC_RECONNECTION_ADDRESS 0x2A03
48 #define GATT_CHARAC_PERIPHERAL_PREF_CONN 0x2A04
49 #define GATT_CHARAC_SERVICE_CHANGED 0x2A05
50
51 #define GATT_CHARAC_EXT_PROPER_UUID 0x2900
52 #define GATT_CHARAC_USER_DESC_UUID 0x2901
53 #define GATT_CLIENT_CHARAC_CFG_UUID 0x2902
54 #define GATT_SERVER_CHARAC_CFG_UUID 0x2903
55 #define GATT_CHARAC_FMT_UUID 0x2904
56 #define GATT_CHARAC_AGREG_FMT_UUID 0x2905
57
58
59
60 /* Attribute Protocol Opcodes */
61 #define ATT_OP_ERROR 0x01
62 #define ATT_OP_MTU_REQ 0x02
63 #define ATT_OP_MTU_RESP 0x03
64 #define ATT_OP_FIND_INFO_REQ 0x04
65 #define ATT_OP_FIND_INFO_RESP 0x05
66 #define ATT_OP_FIND_BY_TYPE_REQ 0x06
67 #define ATT_OP_FIND_BY_TYPE_RESP 0x07
68 #define ATT_OP_READ_BY_TYPE_REQ 0x08
69 #define ATT_OP_READ_BY_TYPE_RESP 0x09
70 #define ATT_OP_READ_REQ 0x0A
71 #define ATT_OP_READ_RESP 0x0B
72 #define ATT_OP_READ_BLOB_REQ 0x0C
73 #define ATT_OP_READ_BLOB_RESP 0x0D
74 #define ATT_OP_READ_MULTI_REQ 0x0E
75 #define ATT_OP_READ_MULTI_RESP 0x0F
76 #define ATT_OP_READ_BY_GROUP_REQ 0x10
77 #define ATT_OP_READ_BY_GROUP_RESP 0x11
78 #define ATT_OP_WRITE_REQ 0x12
79 #define ATT_OP_WRITE_RESP 0x13
80 #define ATT_OP_WRITE_CMD 0x52
81 #define ATT_OP_PREP_WRITE_REQ 0x16
82 #define ATT_OP_PREP_WRITE_RESP 0x17
83 #define ATT_OP_EXEC_WRITE_REQ 0x18
84 #define ATT_OP_EXEC_WRITE_RESP 0x19
85 #define ATT_OP_HANDLE_NOTIFY 0x1B
86 #define ATT_OP_HANDLE_IND 0x1D
87 #define ATT_OP_HANDLE_CNF 0x1E
88 #define ATT_OP_SIGNED_WRITE_CMD 0xD2
89
90 /* Error codes for Error response PDU */
91 #define ATT_ECODE_INVALID_HANDLE 0x01
92 #define ATT_ECODE_READ_NOT_PERM 0x02
93 #define ATT_ECODE_WRITE_NOT_PERM 0x03
94 #define ATT_ECODE_INVALID_PDU 0x04
95 #define ATT_ECODE_INSUFF_AUTHEN 0x05
96 #define ATT_ECODE_REQ_NOT_SUPP 0x06
97 #define ATT_ECODE_INVALID_OFFSET 0x07
98 #define ATT_ECODE_INSUFF_AUTHO 0x08
99 #define ATT_ECODE_PREP_QUEUE_FULL 0x09
100 #define ATT_ECODE_ATTR_NOT_FOUND 0x0A
101 #define ATT_ECODE_ATTR_NOT_LONG 0x0B
102 #define ATT_ECODE_INSUFF_ENCR_KEY_SIZE 0x0C
103 #define ATT_ECODE_INVAL_ATTR_VALUE_LEN 0x0D
104 #define ATT_ECODE_UNLIKELY 0x0E
105 #define ATT_ECODE_INSUFF_ENC 0x0F
106 #define ATT_ECODE_UNSUPP_GRP_TYPE 0x10
107 #define ATT_ECODE_INSUFF_RESOURCES 0x11
108 #define ATT_ECODE_IO 0xFF
109
110
111 /* Attribute Protocol Opcodes */
attop2str(uint8_t op)112 static const char *attop2str(uint8_t op)
113 {
114 switch (op) {
115 case ATT_OP_ERROR:
116 return "Error";
117 case ATT_OP_MTU_REQ:
118 return "MTU req";
119 case ATT_OP_MTU_RESP:
120 return "MTU resp";
121 case ATT_OP_FIND_INFO_REQ:
122 return "Find Information req";
123 case ATT_OP_FIND_INFO_RESP:
124 return "Find Information resp";
125 case ATT_OP_FIND_BY_TYPE_REQ:
126 return "Find By Type req";
127 case ATT_OP_FIND_BY_TYPE_RESP:
128 return "Find By Type resp";
129 case ATT_OP_READ_BY_TYPE_REQ:
130 return "Read By Type req";
131 case ATT_OP_READ_BY_TYPE_RESP:
132 return "Read By Type resp";
133 case ATT_OP_READ_REQ:
134 return "Read req";
135 case ATT_OP_READ_RESP:
136 return "Read resp";
137 case ATT_OP_READ_BLOB_REQ:
138 return "Read Blob req";
139 case ATT_OP_READ_BLOB_RESP:
140 return "Read Blob resp";
141 case ATT_OP_READ_MULTI_REQ:
142 return "Read Multi req";
143 case ATT_OP_READ_MULTI_RESP:
144 return "Read Multi resp";
145 case ATT_OP_READ_BY_GROUP_REQ:
146 return "Read By Group req";
147 case ATT_OP_READ_BY_GROUP_RESP:
148 return "Read By Group resp";
149 case ATT_OP_WRITE_REQ:
150 return "Write req";
151 case ATT_OP_WRITE_RESP:
152 return "Write resp";
153 case ATT_OP_WRITE_CMD:
154 return "Write cmd";
155 case ATT_OP_PREP_WRITE_REQ:
156 return "Prepare Write req";
157 case ATT_OP_PREP_WRITE_RESP:
158 return "Prepare Write resp";
159 case ATT_OP_EXEC_WRITE_REQ:
160 return "Exec Write req";
161 case ATT_OP_EXEC_WRITE_RESP:
162 return "Exec Write resp";
163 case ATT_OP_HANDLE_NOTIFY:
164 return "Handle notify";
165 case ATT_OP_HANDLE_IND:
166 return "Handle indicate";
167 case ATT_OP_HANDLE_CNF:
168 return "Handle CNF";
169 case ATT_OP_SIGNED_WRITE_CMD:
170 return "Signed Write Cmd";
171 default:
172 return "Unknown";
173 }
174 }
175
atterror2str(uint8_t err)176 static const char * atterror2str(uint8_t err)
177 {
178 switch (err) {
179 case ATT_ECODE_INVALID_HANDLE:
180 return "Invalid handle";
181 case ATT_ECODE_READ_NOT_PERM:
182 return "Read not permitted";
183 case ATT_ECODE_WRITE_NOT_PERM:
184 return "Write not permitted";
185 case ATT_ECODE_INVALID_PDU:
186 return "Invalid PDU";
187 case ATT_ECODE_INSUFF_AUTHEN:
188 return "Insufficient authentication";
189 case ATT_ECODE_REQ_NOT_SUPP:
190 return "Request not supported";
191 case ATT_ECODE_INVALID_OFFSET:
192 return "Invalid offset";
193 case ATT_ECODE_INSUFF_AUTHO:
194 return "Insufficient authorization";
195 case ATT_ECODE_PREP_QUEUE_FULL:
196 return "Prepare queue full";
197 case ATT_ECODE_ATTR_NOT_FOUND:
198 return "Attribute not found";
199 case ATT_ECODE_ATTR_NOT_LONG:
200 return "Attribute not long";
201 case ATT_ECODE_INSUFF_ENCR_KEY_SIZE:
202 return "Insufficient encryption key size";
203 case ATT_ECODE_INVAL_ATTR_VALUE_LEN:
204 return "Invalid attribute value length";
205 case ATT_ECODE_UNLIKELY:
206 return "Unlikely error";
207 case ATT_ECODE_INSUFF_ENC:
208 return "Insufficient encryption";
209 case ATT_ECODE_UNSUPP_GRP_TYPE:
210 return "Unsupported group type";
211 case ATT_ECODE_INSUFF_RESOURCES:
212 return "Insufficient resources";
213 case ATT_ECODE_IO:
214 return "Application Error";
215 default:
216 return "Reserved";
217 }
218 }
219
uuid2str(uint16_t uuid)220 static const char *uuid2str(uint16_t uuid)
221 {
222 switch (uuid) {
223 case GATT_PRIM_SVC_UUID:
224 return "GATT Primary Service";
225 case GATT_SND_SVC_UUID:
226 return "GATT Secondary Service";
227 case GATT_INCLUDE_UUID:
228 return "GATT Include";
229 case GATT_CHARAC_UUID:
230 return "GATT Characteristic";
231 case GATT_CHARAC_DEVICE_NAME:
232 return "GATT(type) Device Name";
233 case GATT_CHARAC_APPEARANCE:
234 return "GATT(type) Appearance";
235 case GATT_CHARAC_PERIPHERAL_PRIV_FLAG:
236 return "GATT(type) Peripheral Privacy Flag";
237 case GATT_CHARAC_RECONNECTION_ADDRESS:
238 return "GATT(type) Characteristic Reconnection Address";
239 case GATT_CHARAC_PERIPHERAL_PREF_CONN:
240 return "GATT(type) Characteristic Preferred Connection Parameters";
241 case GATT_CHARAC_SERVICE_CHANGED:
242 return "GATT(type) Characteristic Service Changed";
243 case GATT_CHARAC_EXT_PROPER_UUID:
244 return "GATT(desc) Characteristic Extended Properties";
245 case GATT_CHARAC_USER_DESC_UUID:
246 return "GATT(desc) User Description";
247 case GATT_CLIENT_CHARAC_CFG_UUID:
248 return "GATT(desc) Client Characteristic Configuration";
249 case GATT_SERVER_CHARAC_CFG_UUID:
250 return "GATT(desc) Server Characteristic Configuration";
251 case GATT_CHARAC_FMT_UUID:
252 return "GATT(desc) Format";
253 case GATT_CHARAC_AGREG_FMT_UUID:
254 return "GATT(desc) Aggregate Format";
255 default:
256 return "Unknown";
257 }
258 }
259
att_error_dump(int level,struct frame * frm)260 static void att_error_dump(int level, struct frame *frm)
261 {
262 uint8_t op = get_u8(frm);
263 uint16_t handle = btohs(htons(get_u16(frm)));
264 uint8_t err = get_u8(frm);
265
266 p_indent(level, frm);
267 printf("Error: %s (%d)\n", atterror2str(err), err);
268
269 p_indent(level, frm);
270 printf("%s (0x%.2x) on handle 0x%2.2x\n", attop2str(op), op, handle);
271 }
272
att_mtu_req_dump(int level,struct frame * frm)273 static void att_mtu_req_dump(int level, struct frame *frm)
274 {
275 uint16_t client_rx_mtu = btohs(htons(get_u16(frm)));
276
277 p_indent(level, frm);
278 printf("client rx mtu %d\n", client_rx_mtu);
279 }
280
att_mtu_resp_dump(int level,struct frame * frm)281 static void att_mtu_resp_dump(int level, struct frame *frm)
282 {
283 uint16_t server_rx_mtu = btohs(htons(get_u16(frm)));
284
285 p_indent(level, frm);
286 printf("server rx mtu %d\n", server_rx_mtu);
287 }
288
att_find_info_req_dump(int level,struct frame * frm)289 static void att_find_info_req_dump(int level, struct frame *frm)
290 {
291 uint16_t start = btohs(htons(get_u16(frm)));
292 uint16_t end = btohs(htons(get_u16(frm)));
293
294 p_indent(level, frm);
295 printf("start 0x%2.2x, end 0x%2.2x\n", start, end);
296 }
297
att_find_info_resp_dump(int level,struct frame * frm)298 static void att_find_info_resp_dump(int level, struct frame *frm)
299 {
300 uint8_t fmt = get_u8(frm);
301
302 p_indent(level, frm);
303
304 if (fmt == 0x01) {
305 printf("format: uuid-16\n");
306
307 while (frm->len > 0) {
308 uint16_t handle = btohs(htons(get_u16(frm)));
309 uint16_t uuid = btohs(htons(get_u16(frm)));
310 p_indent(level + 1, frm);
311 printf("handle 0x%2.2x, uuid 0x%2.2x (%s)\n", handle, uuid,
312 uuid2str(uuid));
313 }
314 } else {
315 printf("format: uuid-128\n");
316
317 while (frm->len > 0) {
318 uint16_t handle = btohs(htons(get_u16(frm)));
319 int i;
320
321 p_indent(level + 1, frm);
322 printf("handle 0x%2.2x, uuid ", handle);
323 for (i = 0; i < 16; i++) {
324 printf("%02x", get_u8(frm));
325 if (i == 3 || i == 5 || i == 7 || i == 9)
326 printf("-");
327 }
328 printf("\n");
329 }
330 }
331 }
332
att_find_by_type_req_dump(int level,struct frame * frm)333 static void att_find_by_type_req_dump(int level, struct frame *frm)
334 {
335 uint16_t start = btohs(htons(get_u16(frm)));
336 uint16_t end = btohs(htons(get_u16(frm)));
337 uint16_t uuid = btohs(htons(get_u16(frm)));
338
339 p_indent(level, frm);
340 printf("start 0x%4.4x, end 0x%4.4x, uuid 0x%4.4x\n", start, end, uuid);
341
342 p_indent(level, frm);
343 printf("value");
344 while (frm->len > 0)
345 printf(" 0x%2.2x", get_u8(frm));
346 printf("\n");
347 }
348
att_find_by_type_resp_dump(int level,struct frame * frm)349 static void att_find_by_type_resp_dump(int level, struct frame *frm)
350 {
351 while (frm->len > 0) {
352 uint16_t uuid = btohs(htons(get_u16(frm)));
353 uint16_t end = btohs(htons(get_u16(frm)));
354
355 p_indent(level, frm);
356 printf("Found attr 0x%4.4x, group end handle 0x%4.4x\n",
357 uuid, end);
358 }
359 }
360
att_read_by_type_req_dump(int level,struct frame * frm)361 static void att_read_by_type_req_dump(int level, struct frame *frm)
362 {
363 uint16_t start = btohs(htons(get_u16(frm)));
364 uint16_t end = btohs(htons(get_u16(frm)));
365 int i;
366
367 p_indent(level, frm);
368 printf("start 0x%4.4x, end 0x%4.4x\n", start, end);
369
370 p_indent(level, frm);
371 if (frm->len == 2) {
372 printf("type-uuid 0x%4.4x\n", btohs(htons(get_u16(frm))));
373 } else if (frm->len == 16) {
374 printf("type-uuid ");
375 for (i = 0; i < 16; i++) {
376 printf("%02x", get_u8(frm));
377 if (i == 3 || i == 5 || i == 7 || i == 9)
378 printf("-");
379 }
380 printf("\n");
381 } else {
382 printf("malformed uuid (expected 2 or 16 octets)\n");
383 p_indent(level, frm);
384 raw_dump(level, frm);
385 }
386 }
387
att_read_by_type_resp_dump(int level,struct frame * frm)388 static void att_read_by_type_resp_dump(int level, struct frame *frm)
389 {
390 uint8_t length = get_u8(frm);
391
392 p_indent(level, frm);
393 printf("length: %d\n", length);
394
395 while (frm->len > 0) {
396 uint16_t handle = btohs(htons(get_u16(frm)));
397 int val_len = length - 2;
398 int i;
399
400 p_indent(level + 1, frm);
401 printf("handle 0x%2.2x, value ", handle);
402 for (i = 0; i < val_len; i++) {
403 printf("0x%.2x ", get_u8(frm));
404 }
405 printf("\n");
406 }
407 }
408
att_read_req_dump(int level,struct frame * frm)409 static void att_read_req_dump(int level, struct frame *frm)
410 {
411 uint16_t handle = btohs(htons(get_u16(frm)));
412
413 p_indent(level, frm);
414 printf("handle 0x%2.2x\n", handle);
415 }
416
att_read_blob_req_dump(int level,struct frame * frm)417 static void att_read_blob_req_dump(int level, struct frame *frm)
418 {
419 uint16_t handle = btohs(htons(get_u16(frm)));
420 uint16_t offset = btohs(htons(get_u16(frm)));
421
422 p_indent(level, frm);
423 printf("handle 0x%4.4x offset 0x%4.4x\n", handle, offset);
424 }
425
att_read_blob_resp_dump(int level,struct frame * frm)426 static void att_read_blob_resp_dump(int level, struct frame *frm)
427 {
428 p_indent(level, frm);
429 printf("value");
430
431 while (frm->len > 0)
432 printf(" 0x%2.2x", get_u8(frm));
433 printf("\n");
434 }
435
att_read_multi_req_dump(int level,struct frame * frm)436 static void att_read_multi_req_dump(int level, struct frame *frm)
437 {
438 p_indent(level, frm);
439 printf("Handles\n");
440
441 while (frm->len > 0) {
442 p_indent(level, frm);
443 printf("handle 0x%4.4x\n", btohs(htons(get_u16(frm))));
444 }
445 }
446
att_read_multi_resp_dump(int level,struct frame * frm)447 static void att_read_multi_resp_dump(int level, struct frame *frm)
448 {
449 p_indent(level, frm);
450 printf("values");
451
452 while (frm->len > 0)
453 printf(" 0x%2.2x", get_u8(frm));
454 printf("\n");
455 }
456
att_read_by_group_resp_dump(int level,struct frame * frm)457 static void att_read_by_group_resp_dump(int level, struct frame *frm)
458 {
459 uint8_t length = get_u8(frm);
460
461 while (frm->len > 0) {
462 uint16_t attr_handle = btohs(htons(get_u16(frm)));
463 uint16_t end_grp_handle = btohs(htons(get_u16(frm)));
464 uint8_t remaining = length - 4;
465
466 p_indent(level, frm);
467 printf("attr handle 0x%4.4x, end group handle 0x%4.4x\n",
468 attr_handle, end_grp_handle);
469
470 p_indent(level, frm);
471 printf("value");
472 while (remaining > 0) {
473 printf(" 0x%2.2x", get_u8(frm));
474 }
475 printf("\n");
476 }
477 }
478
att_write_req_dump(int level,struct frame * frm)479 static void att_write_req_dump(int level, struct frame *frm)
480 {
481 uint16_t handle = btohs(htons(get_u16(frm)));
482
483 p_indent(level, frm);
484 printf("handle 0x%4.4x value ", handle);
485
486 while (frm->len > 0)
487 printf(" 0x%2.2x", get_u8(frm));
488 printf("\n");
489 }
490
att_signed_write_dump(int level,struct frame * frm)491 static void att_signed_write_dump(int level, struct frame *frm)
492 {
493 uint16_t handle = btohs(htons(get_u16(frm)));
494 int value_len = frm->len - 12; /* handle:2 already accounted, sig: 12 */
495
496 p_indent(level, frm);
497 printf("handle 0x%4.4x value ", handle);
498
499 while (value_len--)
500 printf(" 0x%2.2x", get_u8(frm));
501 printf("\n");
502
503 p_indent(level, frm);
504 printf("auth signature ");
505 while (frm->len > 0)
506 printf(" 0x%2.2x", get_u8(frm));
507 printf("\n");
508 }
509
att_prep_write_dump(int level,struct frame * frm)510 static void att_prep_write_dump(int level, struct frame *frm)
511 {
512 uint16_t handle = btohs(htons(get_u16(frm)));
513 uint16_t val_offset = btohs(htons(get_u16(frm)));
514
515 p_indent(level, frm);
516 printf("attr handle 0x%4.4x, value offset 0x%4.4x\n", handle,
517 val_offset);
518
519 p_indent(level, frm);
520 printf("part attr value ");
521 while (frm->len > 0)
522 printf(" 0x%2.2x", get_u8(frm));
523 printf("\n");
524 }
525
att_exec_write_req_dump(int level,struct frame * frm)526 static void att_exec_write_req_dump(int level, struct frame *frm)
527 {
528 uint8_t flags = get_u8(frm);
529
530 p_indent(level, frm);
531 if (flags == 0x00)
532 printf("cancel all prepared writes ");
533 else
534 printf("immediatelly write all pending prepared values ");
535
536 printf("(0x%2.2x)\n", flags);
537 }
538
att_handle_notify_dump(int level,struct frame * frm)539 static void att_handle_notify_dump(int level, struct frame *frm)
540 {
541 uint16_t handle = btohs(htons(get_u16(frm)));
542
543 p_indent(level, frm);
544 printf("handle 0x%4.4x\n", handle);
545
546 p_indent(level, frm);
547 printf("value ");
548 while (frm->len > 0)
549 printf("0x%.2x ", get_u8(frm));
550 printf("\n");
551 }
552
att_dump(int level,struct frame * frm)553 void att_dump(int level, struct frame *frm)
554 {
555 uint8_t op;
556
557 op = get_u8(frm);
558
559 p_indent(level, frm);
560 printf("ATT: %s (0x%.2x)\n", attop2str(op), op);
561
562 switch (op) {
563 case ATT_OP_ERROR:
564 att_error_dump(level + 1, frm);
565 break;
566 case ATT_OP_MTU_REQ:
567 att_mtu_req_dump(level + 1, frm);
568 break;
569 case ATT_OP_MTU_RESP:
570 att_mtu_resp_dump(level + 1, frm);
571 break;
572 case ATT_OP_FIND_INFO_REQ:
573 att_find_info_req_dump(level + 1, frm);
574 break;
575 case ATT_OP_FIND_INFO_RESP:
576 att_find_info_resp_dump(level + 1, frm);
577 break;
578 case ATT_OP_FIND_BY_TYPE_REQ:
579 att_find_by_type_req_dump(level + 1, frm);
580 break;
581 case ATT_OP_FIND_BY_TYPE_RESP:
582 att_find_by_type_resp_dump(level + 1, frm);
583 break;
584 case ATT_OP_READ_BY_TYPE_REQ:
585 case ATT_OP_READ_BY_GROUP_REQ: /* exact same parsing */
586 att_read_by_type_req_dump(level + 1, frm);
587 break;
588 case ATT_OP_READ_BY_TYPE_RESP:
589 att_read_by_type_resp_dump(level + 1, frm);
590 break;
591 case ATT_OP_READ_REQ:
592 att_read_req_dump(level + 1, frm);
593 break;
594 case ATT_OP_READ_RESP:
595 raw_dump(level + 1, frm);
596 break;
597 case ATT_OP_READ_BLOB_REQ:
598 att_read_blob_req_dump(level + 1, frm);
599 break;
600 case ATT_OP_READ_BLOB_RESP:
601 att_read_blob_resp_dump(level + 1, frm);
602 break;
603 case ATT_OP_READ_MULTI_REQ:
604 att_read_multi_req_dump(level + 1, frm);
605 break;
606 case ATT_OP_READ_MULTI_RESP:
607 att_read_multi_resp_dump(level + 1, frm);
608 break;
609 case ATT_OP_READ_BY_GROUP_RESP:
610 att_read_by_group_resp_dump(level + 1, frm);
611 break;
612 case ATT_OP_WRITE_REQ:
613 case ATT_OP_WRITE_CMD:
614 att_write_req_dump(level + 1, frm);
615 break;
616 case ATT_OP_SIGNED_WRITE_CMD:
617 att_signed_write_dump(level + 1, frm);
618 break;
619 case ATT_OP_PREP_WRITE_REQ:
620 case ATT_OP_PREP_WRITE_RESP:
621 att_prep_write_dump(level + 1, frm);
622 break;
623 case ATT_OP_EXEC_WRITE_REQ:
624 att_exec_write_req_dump(level + 1, frm);
625 break;
626 case ATT_OP_HANDLE_NOTIFY:
627 att_handle_notify_dump(level + 1, frm);
628 break;
629 default:
630 raw_dump(level, frm);
631 break;
632 }
633 }
634