Android: Add ADB dissector

Previoulsy added "adb_cs" is only for adb client <-> adb daemon communication
by loopback interface (by TCP). But there is also communication between
adb daemon and device (by TCP or USB). This transport protocol is different, but
now support is done.

ADB services are shared between ADB and ADB_CS so put them into "adb_service"
dissector. There is still some services to be added.

Change-Id: I754331d3dc6ccf3c17445f5563d01cf2fe1489c7
Reviewed-on: https://code.wireshark.org/review/4651
Tested-by: Michal Labedzki <michal.labedzki@tieto.com>
Reviewed-by: Michal Labedzki <michal.labedzki@tieto.com>

1 files changed, 924 insertions, 0 deletions

diff --git a/epan/dissectors/packet-adb.c b/epan/dissectors/packet-adb.c
new file mode 100644
index 0000000000..51df9acee4
--- /dev/null
+++ b/epan/dissectors/packet-adb.c
@@ -0,0 +1,924 @@
+/* packet-adb.c
+ * Routines for Android Debug Bridge Transport Protocol
+ *
+ * Copyright 2014 Michal Labedzki for Tieto Corporation
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * 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 thehf_class
+ * 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 Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+
+#include <epan/packet.h>
+#include <epan/prefs.h>
+#include <epan/expert.h>
+#include <epan/wmem/wmem.h>
+#include <wiretap/wtap.h>
+
+#include "packet-adb_service.h"
+#include "packet-usb.h"
+
+static int proto_adb                                                       = -1;
+static int hf_command                                                      = -1;
+static int hf_argument_0                                                   = -1;
+static int hf_argument_1                                                   = -1;
+static int hf_data_length                                                  = -1;
+static int hf_data_crc32                                                   = -1;
+static int hf_magic                                                        = -1;
+static int hf_local_id                                                     = -1;
+static int hf_remote_id                                                    = -1;
+static int hf_version                                                      = -1;
+static int hf_max_data                                                     = -1;
+static int hf_zero                                                         = -1;
+static int hf_sequence                                                     = -1;
+static int hf_online                                                       = -1;
+static int hf_auth_type                                                    = -1;
+static int hf_data                                                         = -1;
+static int hf_service                                                      = -1;
+static int hf_data_fragment                                                = -1;
+static int hf_command_in_frame                                             = -1;
+static int hf_completed_in_frame                                           = -1;
+static int hf_service_start_in_frame                                       = -1;
+static int hf_close_local_in_frame                                         = -1;
+static int hf_close_remote_in_frame                                        = -1;
+static int hf_connection_info                                              = -1;
+
+static gint ett_adb                                                        = -1;
+static gint ett_adb_arg0                                                   = -1;
+static gint ett_adb_arg1                                                   = -1;
+static gint ett_adb_crc                                                    = -1;
+static gint ett_adb_magic                                                  = -1;
+
+static expert_field ei_invalid_magic                                  = EI_INIT;
+static expert_field ei_invalid_crc                                    = EI_INIT;
+
+static dissector_handle_t  adb_handle;
+static dissector_handle_t  adb_service_handle;
+
+static gint proto_tcp = -1;
+static gint proto_usb = -1;
+
+static wmem_tree_t *command_info = NULL;
+static wmem_tree_t *service_info = NULL;
+
+typedef struct service_data_t {
+    guint32  start_in_frame;
+
+    guint32  close_local_in_frame;
+    guint32  close_remote_in_frame;
+
+    guint32  local_id;
+    guint32  remote_id;
+
+    const guint8  *service;
+} service_data_t;
+
+typedef struct command_data_t {
+    guint32   command;
+
+    guint32   command_in_frame;
+    guint32   response_in_frame;
+
+    guint32   arg0;
+    guint32   arg1;
+
+    guint32   data_length;
+    guint32   crc32;
+
+    guint32   completed_in_frame;
+    guint32   reassemble_data_length;
+    guint8   *reassemble_data;
+} command_data_t;
+
+static guint32 max_in_frame = G_MAXUINT32;
+
+static const value_string command_vals[] = {
+    { 0x434e5953,  "Synchronize" },
+    { 0x45534c43,  "Close" },
+    { 0x45545257,  "Write" },
+    { 0x48545541,  "Authenticate" },
+    { 0x4e584e43,  "Connect" },
+    { 0x4e45504f,  "Open" },
+    { 0x59414b4f,  "Okay" },
+    { 0, NULL }
+};
+
+static const value_string magic_vals[] = {
+    { 0xFFFFFFFF ^ 0x434e5953,  "Synchronize" },
+    { 0xFFFFFFFF ^ 0x45534c43,  "Close" },
+    { 0xFFFFFFFF ^ 0x45545257,  "Write" },
+    { 0xFFFFFFFF ^ 0x48545541,  "Authenticate" },
+    { 0xFFFFFFFF ^ 0x4e584e43,  "Connect" },
+    { 0xFFFFFFFF ^ 0x4e45504f,  "Open" },
+    { 0xFFFFFFFF ^ 0x59414b4f,  "Okay" },
+    { 0, NULL }
+};
+
+static const value_string auth_type_vals[] = {
+    { 1,  "Token" },
+    { 2,  "Signature" },
+    { 3,  "RSA Public Key" },
+    { 0, NULL }
+};
+
+#define A_SYNC  0x434e5953
+#define A_CLSE  0x45534c43
+#define A_WRTE  0x45545257
+#define A_AUTH  0x48545541
+#define A_CNXN  0x4e584e43
+#define A_OPEN  0x4e45504f
+#define A_OKAY  0x59414b4f
+
+#define ADB_TCP_PORT  5555
+
+void proto_register_adb(void);
+void proto_reg_handoff_adb(void);
+
+static void
+save_command(guint32 cmd, guint32 arg0, guint32 arg1, guint32 data_length,
+        guint32 crc32, service_data_t *service_data, gint proto, void *data,
+        packet_info *pinfo, service_data_t **returned_service_data,
+        command_data_t **returned_command_data)
+{
+    wmem_tree_key_t  key[6];
+    guint32          interface_id;
+    guint32          bus_id;
+    guint32          device_address;
+    guint32          side_id;
+    guint32          frame_number;
+    command_data_t  *command_data;
+    wmem_tree_t     *wmem_tree;
+    gint             direction = P2P_DIR_UNKNOWN;
+    usb_conv_info_t *usb_conv_info = (usb_conv_info_t *) data;
+
+    frame_number = pinfo->fd->num;
+
+    if (pinfo->phdr->presence_flags & WTAP_HAS_INTERFACE_ID)
+        interface_id = pinfo->phdr->interface_id;
+    else
+        interface_id = 0;
+
+    if (proto == proto_usb) {
+        usb_conv_info = (usb_conv_info_t *) data;
+        DISSECTOR_ASSERT(usb_conv_info);
+
+        direction = usb_conv_info->direction;
+
+        bus_id             = usb_conv_info->bus_id;
+        device_address     = usb_conv_info->device_address;
+
+        key[0].length = 1;
+        key[0].key = &interface_id;
+        key[1].length = 1;
+        key[1].key = &bus_id;
+        key[2].length = 1;
+        key[2].key = &device_address;
+        key[3].length = 1;
+        key[3].key = &side_id;
+        key[4].length = 1;
+        key[4].key = &frame_number;
+        key[5].length = 0;
+        key[5].key = NULL;
+    } else { /* tcp */
+        if (pinfo->destport == ADB_TCP_PORT)
+            direction = P2P_DIR_SENT;
+        else
+            direction = P2P_DIR_RECV;
+
+        key[0].length = 1;
+        key[0].key = &interface_id;
+        key[1].length = 1;
+        key[2].length = 1;
+        if (direction == P2P_DIR_SENT) {
+            key[1].key = &pinfo->srcport;
+            key[2].key = &pinfo->destport;
+        } else {
+            key[1].key = &pinfo->destport;
+            key[2].key = &pinfo->srcport;
+        }
+        key[3].length = 1;
+        key[3].key = &side_id;
+        key[4].length = 1;
+        key[4].key = &frame_number;
+        key[5].length = 0;
+        key[5].key = NULL;
+    }
+
+    if (direction == P2P_DIR_SENT)
+        if (cmd == A_CLSE)
+            side_id = arg1; /* OUT: local id */
+        else
+            side_id = arg0; /* OUT: local id */
+    else
+        side_id = arg1; /* IN: remote id */
+
+    if (cmd == A_OPEN) {
+        service_data = wmem_new(wmem_file_scope(), service_data_t);
+
+        service_data->start_in_frame = pinfo->fd->num;
+        service_data->close_local_in_frame = max_in_frame;
+        service_data->close_remote_in_frame = max_in_frame;
+
+        service_data->local_id = arg0;
+        service_data->remote_id = arg1;
+
+        service_data->service = "unknown";
+
+        wmem_tree_insert32_array(service_info, key, service_data);
+    }
+
+    command_data = wmem_new(wmem_file_scope(), command_data_t);
+
+    command_data->command = cmd;
+    command_data->arg0 = arg0;
+    command_data->arg1 = arg1;
+
+    command_data->command_in_frame = pinfo->fd->num;
+    command_data->response_in_frame = max_in_frame;
+
+    command_data->crc32 = crc32;
+    command_data->data_length = data_length;
+    if (data_length == 0)
+        command_data->completed_in_frame = pinfo->fd->num;
+    else
+        command_data->completed_in_frame = max_in_frame;
+    command_data->reassemble_data_length = 0;
+    command_data->reassemble_data = (guint8 *) wmem_alloc(wmem_file_scope(), command_data->data_length);
+
+    key[3].length = 1;
+    key[3].key = &frame_number;
+    key[4].length = 0;
+    key[4].key = NULL;
+    wmem_tree_insert32_array(command_info, key, command_data);
+
+    if (direction == P2P_DIR_SENT)
+        if (command_data->command == A_CLSE)
+            side_id = command_data->arg1; /* OUT: local id */
+        else
+            side_id = command_data->arg0; /* OUT: local id */
+    else
+        side_id = command_data->arg1; /* IN: remote id */
+
+    key[3].length = 1;
+    key[3].key = &side_id;
+    key[4].length = 0;
+    key[4].key = NULL;
+
+    wmem_tree = (wmem_tree_t *) wmem_tree_lookup32_array(service_info, key);
+    if (wmem_tree) {
+        service_data = (service_data_t *) wmem_tree_lookup32_le(wmem_tree, frame_number);
+    }
+
+    if (cmd == A_OKAY) {
+        if (!service_data) {
+            if (direction == P2P_DIR_SENT)
+                side_id = command_data->arg0; /* OUT: local id */
+            else
+                side_id = command_data->arg1; /* IN: remote id */
+
+            wmem_tree = (wmem_tree_t *) wmem_tree_lookup32_array(service_info, key);
+            if (wmem_tree) {
+                service_data = (service_data_t *) wmem_tree_lookup32_le(wmem_tree, frame_number);
+            }
+        }
+
+        if  (service_data && service_data->remote_id == 0 && direction == P2P_DIR_RECV) {
+            if (direction == P2P_DIR_SENT) {
+                service_data->remote_id = arg1;
+            } else {
+                service_data->remote_id = arg0;
+            }
+
+            side_id = service_data->remote_id;
+
+            key[4].length = 1;
+            key[4].key = &frame_number;
+            key[5].length = 0;
+            key[5].key = NULL;
+
+            wmem_tree_insert32_array(service_info, key, service_data);
+        }
+    } else if (cmd == A_CLSE) {
+        if (service_data) {
+            if (direction == P2P_DIR_RECV && service_data->local_id == arg1)
+                service_data->close_local_in_frame = pinfo->fd->num;
+            else if (direction == P2P_DIR_SENT  && service_data->remote_id == arg1)
+                service_data->close_remote_in_frame = pinfo->fd->num;
+        }
+    }
+
+    DISSECTOR_ASSERT(returned_service_data && returned_command_data);
+    *returned_service_data = service_data;
+    *returned_command_data = command_data;
+}
+
+static gint
+dissect_adb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
+{
+    proto_item      *main_item;
+    proto_tree      *main_tree;
+    proto_item      *arg0_item;
+    proto_tree      *arg0_tree;
+    proto_item      *arg1_item;
+    proto_tree      *arg1_tree;
+    proto_item      *magic_item;
+    proto_item      *crc_item;
+    proto_tree      *crc_tree = NULL;
+    proto_item      *sub_item;
+    gint             offset = 0;
+    guint32          command;
+    guint32          arg0;
+    guint32          arg1;
+    guint32          data_length = 0;
+    guint32          crc32 = 0;
+    usb_conv_info_t *usb_conv_info = NULL;
+    wmem_tree_key_t  key[5];
+    guint32          interface_id;
+    guint32          bus_id;
+    guint32          device_address;
+    guint32          side_id;
+    guint32          frame_number;
+    gboolean         is_command = TRUE;
+    gboolean         is_next_fragment = FALSE;
+    gboolean         is_service = FALSE;
+    gint             proto;
+    gint             direction = P2P_DIR_UNKNOWN;
+    wmem_tree_t     *wmem_tree;
+    command_data_t  *command_data = NULL;
+    service_data_t  *service_data = NULL;
+
+    col_set_str(pinfo->cinfo, COL_PROTOCOL, "ADB");
+    col_clear(pinfo->cinfo, COL_INFO);
+
+    main_item = proto_tree_add_item(tree, proto_adb, tvb, offset, -1, ENC_NA);
+    main_tree = proto_item_add_subtree(main_item, ett_adb);
+
+    frame_number       = pinfo->fd->num;
+
+    /* XXX: Why? If interface is USB only first try is correct
+     * (and seems strange...), in other cases standard check for
+     * previous protocol is correct */
+    proto = (gint) GPOINTER_TO_INT(wmem_list_frame_data(/*wmem_list_frame_prev*/(wmem_list_tail(pinfo->layers))));
+    if (proto != proto_usb) {
+        proto = (gint) GPOINTER_TO_INT(wmem_list_frame_data(wmem_list_frame_prev(wmem_list_tail(pinfo->layers))));
+    }
+
+    if (proto == proto_usb) {
+        usb_conv_info = (usb_conv_info_t *) data;
+        DISSECTOR_ASSERT(usb_conv_info);
+
+        direction = usb_conv_info->direction;
+    } else if (proto == proto_tcp) {
+        if (pinfo->destport == ADB_TCP_PORT)
+            direction = P2P_DIR_SENT;
+        else
+            direction = P2P_DIR_RECV;
+    } else {
+        return offset;
+    }
+
+    if (pinfo->phdr->presence_flags & WTAP_HAS_INTERFACE_ID)
+        interface_id = pinfo->phdr->interface_id;
+    else
+        interface_id = 0;
+
+    if (proto == proto_usb) {
+        bus_id             = usb_conv_info->bus_id;
+        device_address     = usb_conv_info->device_address;
+
+        key[0].length = 1;
+        key[0].key = &interface_id;
+        key[1].length = 1;
+        key[1].key = &bus_id;
+        key[2].length = 1;
+        key[2].key = &device_address;
+        key[3].length = 0;
+        key[3].key = NULL;
+    } else { /* tcp */
+        key[0].length = 1;
+        key[0].key = &interface_id;
+        key[1].length = 1;
+        key[2].length = 1;
+        if (direction == P2P_DIR_SENT) {
+            key[1].key = &pinfo->srcport;
+            key[2].key = &pinfo->destport;
+        } else {
+            key[1].key = &pinfo->destport;
+            key[2].key = &pinfo->srcport;
+        }
+        key[3].length = 0;
+        key[3].key = NULL;
+    }
+
+    wmem_tree = (wmem_tree_t *) wmem_tree_lookup32_array(command_info, key);
+    if (wmem_tree) {
+        command_data = (command_data_t *) wmem_tree_lookup32_le(wmem_tree, frame_number);
+        if (command_data && command_data->completed_in_frame >= frame_number &&
+                command_data->command_in_frame <= frame_number) {
+
+            if (command_data->command_in_frame != frame_number) {
+                is_command = FALSE;
+                is_next_fragment = TRUE;
+            }
+
+            data_length = command_data->data_length;
+            crc32 = command_data->crc32;
+
+            if (direction == P2P_DIR_SENT)
+                if (command_data->command == A_CLSE)
+                    side_id = command_data->arg1; /* OUT: local id */
+                else
+                    side_id = command_data->arg0; /* OUT: local id */
+            else
+                if (command_data->command == A_OKAY) {
+                    side_id = command_data->arg1; /* IN: remote id */
+                } else
+                    side_id = command_data->arg1; /* IN: remote id */
+
+            key[3].length = 1;
+            key[3].key = &side_id;
+            key[4].length = 0;
+            key[4].key = NULL;
+
+            wmem_tree = (wmem_tree_t *) wmem_tree_lookup32_array(service_info, key);
+            if (wmem_tree) {
+                service_data = (service_data_t *) wmem_tree_lookup32_le(wmem_tree, frame_number);
+                if (service_data && command_data->command == A_OPEN) {
+                    is_service = TRUE;
+                }
+            }
+        }
+    }
+
+/* Simple heuristics to check if packet is command or data */
+    if ((command_data && command_data->completed_in_frame <= frame_number) || !command_data) {
+        if (tvb_reported_length(tvb) < 24) {
+            is_command = FALSE;
+        } else if (tvb_reported_length(tvb) >= 24) {
+            command = tvb_get_letohl(tvb, offset);
+
+            if (command != A_SYNC && command != A_CLSE && command != A_WRTE &&
+                    command != A_AUTH && command != A_CNXN && command != A_OPEN && command != A_OKAY)
+                is_command = FALSE;
+            else if (command != (0xFFFFFFFF ^ tvb_get_letohl(tvb, offset + 20)))
+                is_command = FALSE;
+
+            if (is_command) {
+                data_length = tvb_get_letohl(tvb, offset + 12);
+                crc32 = tvb_get_letohl(tvb, offset + 16);
+            }
+            if (command == A_OPEN) is_service = TRUE;
+        }
+    }
+
+    if (service_data && !(command_data->command == A_OPEN && is_next_fragment)) {
+        sub_item = proto_tree_add_string(main_tree, hf_service, tvb, offset, 0, service_data->service);
+        PROTO_ITEM_SET_GENERATED(sub_item);
+    }
+
+    if (service_data) {
+        sub_item = proto_tree_add_uint(main_tree, hf_service_start_in_frame, tvb, offset, 0, service_data->start_in_frame);
+        PROTO_ITEM_SET_GENERATED(sub_item);
+
+        if (service_data->close_local_in_frame < max_in_frame) {
+            sub_item = proto_tree_add_uint(main_tree, hf_close_local_in_frame, tvb, offset, 0, service_data->close_local_in_frame);
+            PROTO_ITEM_SET_GENERATED(sub_item);
+        }
+
+        if (service_data->close_remote_in_frame < max_in_frame) {
+            sub_item = proto_tree_add_uint(main_tree, hf_close_remote_in_frame, tvb, offset, 0, service_data->close_remote_in_frame);
+            PROTO_ITEM_SET_GENERATED(sub_item);
+        }
+    }
+
+    if (is_command) {
+        proto_tree_add_item(main_tree, hf_command, tvb, offset, 4, ENC_LITTLE_ENDIAN);
+        command = tvb_get_letohl(tvb, offset);
+        offset += 4;
+
+        col_append_str(pinfo->cinfo, COL_INFO, val_to_str_const(command, command_vals, "Unknown command"));
+
+        arg0_item = proto_tree_add_item(main_tree, hf_argument_0, tvb, offset, 4, ENC_LITTLE_ENDIAN);
+        arg0_tree = proto_item_add_subtree(arg0_item, ett_adb_arg0);
+        arg0 = tvb_get_letohl(tvb, offset);
+        offset += 4;
+
+        arg1_item = proto_tree_add_item(main_tree, hf_argument_1, tvb, offset, 4, ENC_LITTLE_ENDIAN);
+        arg1_tree = proto_item_add_subtree(arg1_item, ett_adb_arg1);
+        arg1 = tvb_get_letohl(tvb, offset);
+        offset += 4;
+
+        switch (command) {
+        case A_CNXN:
+            proto_tree_add_item(arg0_tree, hf_version, tvb, offset - 8, 4, ENC_LITTLE_ENDIAN);
+            proto_tree_add_item(arg1_tree, hf_max_data, tvb, offset - 4, 4, ENC_LITTLE_ENDIAN);
+
+            col_append_fstr(pinfo->cinfo, COL_INFO, "(version=%u.%u.%u, max_data=%u)", tvb_get_guint8(tvb, offset - 5), tvb_get_guint8(tvb, offset - 6), tvb_get_letohs(tvb, offset - 7), tvb_get_letohl(tvb, offset - 4));
+            break;
+        case A_AUTH:
+            proto_tree_add_item(arg0_tree, hf_auth_type, tvb, offset - 8, 4, ENC_LITTLE_ENDIAN);
+            proto_tree_add_item(arg1_tree, hf_zero, tvb, offset - 4, 4, ENC_LITTLE_ENDIAN);
+
+            col_append_fstr(pinfo->cinfo, COL_INFO, "(type=%s, 0)", val_to_str_const(tvb_get_letohl(tvb, offset - 8), auth_type_vals, "Unknown"));
+            break;
+        case A_OPEN:
+            proto_tree_add_item(arg0_tree, hf_local_id, tvb, offset - 8, 4, ENC_LITTLE_ENDIAN);
+            proto_tree_add_item(arg1_tree, hf_zero, tvb, offset - 4, 4, ENC_LITTLE_ENDIAN);
+
+            col_append_fstr(pinfo->cinfo, COL_INFO, "(local=%u, 0)", tvb_get_letohl(tvb, offset - 8));
+            break;
+        case A_WRTE:
+            proto_tree_add_item(arg0_tree, hf_zero, tvb, offset - 8, 4, ENC_LITTLE_ENDIAN);
+            proto_tree_add_item(arg1_tree, hf_remote_id, tvb, offset - 4, 4, ENC_LITTLE_ENDIAN);
+
+            col_append_fstr(pinfo->cinfo, COL_INFO, "(0, remote=%u)", tvb_get_letohl(tvb, offset - 4));
+            break;
+        case A_CLSE:
+        case A_OKAY:
+            proto_tree_add_item(arg0_tree, hf_local_id, tvb, offset - 8, 4, ENC_LITTLE_ENDIAN);
+            proto_tree_add_item(arg1_tree, hf_remote_id, tvb, offset - 4, 4, ENC_LITTLE_ENDIAN);
+
+            col_append_fstr(pinfo->cinfo, COL_INFO, "(local=%u, remote=%u)", tvb_get_letohl(tvb, offset - 8), tvb_get_letohl(tvb, offset - 4));
+            break;
+        case A_SYNC:
+            proto_tree_add_item(arg0_tree, hf_online, tvb, offset - 8, 4, ENC_LITTLE_ENDIAN);
+            proto_tree_add_item(arg1_tree, hf_sequence, tvb, offset - 4, 4, ENC_LITTLE_ENDIAN);
+
+            col_append_fstr(pinfo->cinfo, COL_INFO, "(online=%s, sequence=%u)", tvb_get_letohl(tvb, offset - 8) ? "Yes": "No", tvb_get_letohl(tvb, offset - 4));
+            break;
+        }
+
+        proto_tree_add_item(main_tree, hf_data_length, tvb, offset, 4, ENC_LITTLE_ENDIAN);
+        offset += 4;
+
+        if (data_length > 0)
+            col_append_fstr(pinfo->cinfo, COL_INFO, " length=%u ", data_length);
+
+        crc_item = proto_tree_add_item(main_tree, hf_data_crc32, tvb, offset, 4, ENC_LITTLE_ENDIAN);
+        crc_tree = proto_item_add_subtree(crc_item, ett_adb_crc);
+        crc32 = tvb_get_letohl(tvb, offset);
+        offset += 4;
+
+        magic_item = proto_tree_add_item(main_tree, hf_magic, tvb, offset, 4, ENC_LITTLE_ENDIAN);
+        if ((tvb_get_letohl(tvb, offset) ^ 0xFFFFFFFF) != command) {
+            proto_tree  *expert_tree;
+
+            expert_tree = proto_item_add_subtree(magic_item, ett_adb_magic);
+            proto_tree_add_expert(expert_tree, pinfo, &ei_invalid_magic, tvb, offset, 4);
+        }
+
+        if (!pinfo->fd->flags.visited)
+            save_command(command, arg0, arg1, data_length, crc32, service_data, proto, data, pinfo, &service_data, &command_data);
+        offset += 4;
+    }
+
+    if (!pinfo->fd->flags.visited && command_data) {
+            if (command_data->command_in_frame != frame_number) {
+                is_command = FALSE;
+                is_next_fragment = TRUE;
+            }
+
+            data_length = command_data->data_length;
+            crc32 = command_data->crc32;
+
+            if ((command_data->command_in_frame != frame_number && tvb_captured_length(tvb) == data_length) ||
+                (command_data->command_in_frame == frame_number && tvb_captured_length(tvb) == data_length + 24)
+            ) {
+                command_data->reassemble_data_length = command_data->data_length;
+                command_data->completed_in_frame = frame_number;
+            }
+    }
+
+    if (is_next_fragment && command_data) {
+        sub_item = proto_tree_add_uint(main_tree, hf_command_in_frame, tvb, offset, 0, command_data->command_in_frame);
+        PROTO_ITEM_SET_GENERATED(sub_item);
+
+        sub_item = proto_tree_add_uint(main_tree, hf_command, tvb, offset, 0, command_data->command);
+        PROTO_ITEM_SET_GENERATED(sub_item);
+
+        sub_item = proto_tree_add_uint(main_tree, hf_data_length, tvb, offset, 0, command_data->data_length);
+        PROTO_ITEM_SET_GENERATED(sub_item);
+
+        crc_item = proto_tree_add_uint(main_tree, hf_data_crc32, tvb, offset, 0, command_data->crc32);
+        crc_tree = proto_item_add_subtree(crc_item, ett_adb_crc);
+        PROTO_ITEM_SET_GENERATED(crc_item);
+    }
+
+    if (command_data && command_data->completed_in_frame != frame_number) {
+        sub_item = proto_tree_add_uint(main_tree, hf_completed_in_frame, tvb, offset, 0, command_data->completed_in_frame);
+        PROTO_ITEM_SET_GENERATED(sub_item);
+    }
+
+
+    if (tvb_captured_length_remaining(tvb, offset) > 0 && (!is_command || data_length > 0)) {
+        guint32 crc = 0;
+        guint32 i_offset;
+
+        if ((!pinfo->fd->flags.visited && command_data && command_data->reassemble_data_length < command_data->data_length) || data_length > (guint32) tvb_captured_length_remaining(tvb, offset)) { /* need reassemble */
+            if (!pinfo->fd->flags.visited && command_data && command_data->reassemble_data_length < command_data->data_length) {
+                tvb_memcpy(tvb, command_data->reassemble_data + command_data->reassemble_data_length, offset, tvb_captured_length_remaining(tvb, offset));
+                command_data->reassemble_data_length += tvb_captured_length_remaining(tvb, offset);
+
+                if (command_data->reassemble_data_length >= command_data->data_length)
+                    command_data->completed_in_frame = frame_number;
+            }
+
+            proto_tree_add_item(main_tree, hf_data_fragment, tvb, offset, -1, ENC_NA);
+            col_append_str(pinfo->cinfo, COL_INFO, "Data Fragment");
+            offset = tvb_captured_length(tvb);
+
+            if (service_data && command_data && command_data->reassemble_data_length >= command_data->data_length && frame_number == command_data->completed_in_frame) {
+                tvbuff_t            *next_tvb;
+                adb_service_data_t   adb_service_data;
+
+                next_tvb = tvb_new_child_real_data(tvb, command_data->reassemble_data, command_data->reassemble_data_length, command_data->reassemble_data_length);
+                add_new_data_source(pinfo, next_tvb, "ADB Reassembled Data");
+
+                adb_service_data.service = service_data->service;
+                adb_service_data.direction = direction;
+
+                adb_service_data.session_key_length = 3;
+                adb_service_data.session_key = (guint32 *) wmem_alloc(wmem_packet_scope(), adb_service_data.session_key_length * sizeof(guint32));
+                adb_service_data.session_key[0] = interface_id;
+
+                if (proto == proto_usb) {
+                    adb_service_data.session_key[1] = usb_conv_info->bus_id;
+                    adb_service_data.session_key[2] = usb_conv_info->device_address;
+                } else { /* tcp */
+                    if (direction == P2P_DIR_SENT) {
+                        adb_service_data.session_key[1] = pinfo->srcport;
+                        adb_service_data.session_key[2] = pinfo->destport;
+                    } else {
+                        adb_service_data.session_key[1] = pinfo->destport;
+                        adb_service_data.session_key[2] = pinfo->srcport;
+                    }
+                }
+
+                call_dissector_with_data(adb_service_handle, next_tvb, pinfo, tree, &adb_service_data);
+            }
+        } else { /* full message */
+            for (i_offset = 0; i_offset < data_length; ++i_offset)
+                crc += tvb_get_guint8(tvb, offset + i_offset);
+
+            if (crc32 > 0 && crc32 != crc)
+                proto_tree_add_expert(crc_tree, pinfo, &ei_invalid_crc, tvb, offset, -1);
+
+            if (is_service) {
+                proto_tree_add_item(main_tree, hf_service, tvb, offset, -1, ENC_ASCII | ENC_NA);
+                if (!pinfo->fd->flags.visited && service_data) {
+                    service_data->service = tvb_get_stringz_enc(wmem_file_scope(), tvb, offset, NULL, ENC_ASCII);
+                }
+                col_append_fstr(pinfo->cinfo, COL_INFO, "Service: %s", tvb_get_stringz_enc(wmem_packet_scope(), tvb, offset, NULL, ENC_ASCII));
+                offset = tvb_captured_length(tvb);
+            } else if (command_data && command_data->command == A_CNXN) {
+                    gchar       *info;
+                    gint         len;
+
+                info = tvb_get_stringz_enc(wmem_packet_scope(), tvb, offset, &len, ENC_ASCII);
+                col_append_fstr(pinfo->cinfo, COL_INFO, "Connection Info: %s", info);
+                proto_tree_add_item(main_tree, hf_connection_info, tvb, offset, len, ENC_ASCII | ENC_NA);
+                offset += len;
+            } else {
+                col_append_str(pinfo->cinfo, COL_INFO, "Data");
+
+                /* Decode service payload */
+                if (service_data) {
+                    tvbuff_t           *next_tvb;
+                    adb_service_data_t  adb_service_data;
+
+                    adb_service_data.service = service_data->service;
+                    adb_service_data.direction = direction;
+
+                    adb_service_data.session_key_length = 3;
+                    adb_service_data.session_key = (guint32 *) wmem_alloc(wmem_packet_scope(), adb_service_data.session_key_length * sizeof(guint32));
+                    adb_service_data.session_key[0] = interface_id;
+
+                    if (proto == proto_usb) {
+                        adb_service_data.session_key[1] = usb_conv_info->bus_id;
+                        adb_service_data.session_key[2] = usb_conv_info->device_address;
+                    } else { /* tcp */
+                        if (direction == P2P_DIR_SENT) {
+                            adb_service_data.session_key[1] = pinfo->srcport;
+                            adb_service_data.session_key[2] = pinfo->destport;
+                        } else {
+                            adb_service_data.session_key[1] = pinfo->destport;
+                            adb_service_data.session_key[2] = pinfo->srcport;
+                        }
+                    }
+
+                    next_tvb = tvb_new_subset(tvb, offset, tvb_captured_length_remaining(tvb, offset), tvb_captured_length_remaining(tvb, offset));
+                    call_dissector_with_data(adb_service_handle, next_tvb, pinfo, tree, &adb_service_data);
+
+                } else {
+                    proto_item  *data_item;
+                    gchar       *data_str;
+
+                    data_item = proto_tree_add_item(main_tree, hf_data, tvb, offset, data_length, ENC_NA);
+                    data_str = tvb_format_text(tvb, offset, data_length);
+                    proto_item_append_text(data_item, ": %s", data_str);
+                    col_append_fstr(pinfo->cinfo, COL_INFO, " Raw: %s", data_str);
+                }
+
+                offset = tvb_captured_length(tvb);
+            }
+        }
+    }
+
+    return offset;
+}
+
+void
+proto_register_adb(void)
+{
+    module_t         *module;
+    expert_module_t  *expert_module;
+
+    static hf_register_info hf[] = {
+        { &hf_command,
+            { "Command",                         "adb.command",
+            FT_UINT32, BASE_HEX, VALS(command_vals), 0x00,
+            NULL, HFILL }
+        },
+        { &hf_argument_0,
+            { "Argument 0",                      "adb.argument.0",
+            FT_UINT32, BASE_HEX, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_argument_1,
+            { "Argument 0",                      "adb.argument.1",
+            FT_UINT32, BASE_HEX, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_data_length,
+            { "Data Length",                      "adb.data_length",
+            FT_UINT32, BASE_DEC, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_data_crc32,
+            { "Data CRC32",                      "adb.data_crc32",
+            FT_UINT32, BASE_HEX, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_magic,
+            { "Magic",                           "adb.magic",
+            FT_UINT32, BASE_HEX, VALS(magic_vals), 0x00,
+            NULL, HFILL }
+        },
+        { &hf_version,
+            { "Version",                         "adb.version",
+            FT_UINT32, BASE_HEX, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_max_data,
+            { "Max Data",                        "adb.max_data",
+            FT_UINT32, BASE_DEC, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_auth_type,
+            { "Type",                            "adb.auth_type",
+            FT_UINT32, BASE_HEX, VALS(auth_type_vals), 0x00,
+            NULL, HFILL }
+        },
+        { &hf_online,
+            { "Online",                          "adb.online",
+            FT_BOOLEAN, 32, TFS(&tfs_no_yes), 0x00,
+            NULL, HFILL }
+        },
+        { &hf_sequence,
+            { "Sequence",                        "adb.sequence",
+            FT_UINT32, BASE_DEC, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_zero,
+            { "Zero",                            "adb.zero",
+            FT_UINT32, BASE_HEX, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_local_id,
+            { "Local ID",                        "adb.local_id",
+            FT_UINT32, BASE_DEC, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_remote_id,
+            { "Remote ID",                       "adb.remote_id",
+            FT_UINT32, BASE_DEC, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_data,
+            { "Data",                            "adb.data",
+            FT_NONE, BASE_NONE, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_service,
+            { "Service",                         "adb.service",
+            FT_STRING, BASE_NONE, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_data_fragment,
+            { "Data Fragment",                   "adb.data_fragment",
+            FT_NONE, BASE_NONE, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_service_start_in_frame,
+            { "Service Start in Frame",          "adb.service_start_in_frame",
+            FT_FRAMENUM, BASE_NONE, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_close_local_in_frame,
+            { "Local Service Close in Frame",    "adb.close_local_in_frame",
+            FT_FRAMENUM, BASE_NONE, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_close_remote_in_frame,
+            { "Remote Service Close in Frame",   "adb.close_remote_in_frame",
+            FT_FRAMENUM, BASE_NONE, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_command_in_frame,
+            { "Command in Frame",                "adb.command_in_frame",
+            FT_FRAMENUM, BASE_NONE, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_completed_in_frame,
+            { "Completed in Frame",              "adb.completed_in_frame",
+            FT_FRAMENUM, BASE_NONE, NULL, 0x00,
+            NULL, HFILL }
+        },
+        { &hf_connection_info,
+            { "Info",                            "adb.connection_info",
+            FT_STRINGZ, STR_ASCII, NULL, 0x00,
+            NULL, HFILL }
+        }
+    };
+
+    static gint *ett[] = {
+        &ett_adb,
+        &ett_adb_arg0,
+        &ett_adb_arg1,
+        &ett_adb_crc,
+        &ett_adb_magic
+    };
+
+    static ei_register_info ei[] = {
+        { &ei_invalid_magic,          { "adb.expert.invalid_magic", PI_PROTOCOL, PI_WARN, "Invalid Magic", EXPFILL }},
+        { &ei_invalid_crc,            { "adb.expert.crc_error", PI_PROTOCOL, PI_ERROR, "CRC32 Error", EXPFILL }},
+    };
+
+    command_info         = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
+    service_info         = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
+
+    proto_adb = proto_register_protocol("Android Debug Bridge", "ADB", "adb");
+    adb_handle = new_register_dissector("adb", dissect_adb, proto_adb);
+
+    proto_register_field_array(proto_adb, hf, array_length(hf));
+    proto_register_subtree_array(ett, array_length(ett));
+    expert_module = expert_register_protocol(proto_adb);
+    expert_register_field_array(expert_module, ei, array_length(ei));
+
+    module = prefs_register_protocol(proto_adb, NULL);
+    prefs_register_static_text_preference(module, "version",
+            "ADB protocol version is compatibile pior to: adb 1.0.31",
+            "Version of protocol supported by this dissector.");
+}
+
+void
+proto_reg_handoff_adb(void)
+{
+    adb_service_handle = find_dissector("adb_service");
+
+    dissector_add_handle("tcp.port",     adb_handle);
+    dissector_add_handle("usb.device",   adb_handle);
+    dissector_add_handle("usb.product",  adb_handle);
+    dissector_add_handle("usb.protocol", adb_handle);
+
+    proto_tcp = proto_get_id_by_filter_name("tcp");
+    proto_usb = proto_get_id_by_filter_name("usb");
+}
+
+/*
+ * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 4
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * vi: set shiftwidth=4 tabstop=8 expandtab:
+ * :indentSize=4:tabSize=8:noTabs=true:
+ */