diff options
Diffstat (limited to 'epan/dissectors/packet-adb_service.c')
| -rw-r--r-- | epan/dissectors/packet-adb_service.c | 845 |
1 files changed, 845 insertions, 0 deletions
diff --git a/epan/dissectors/packet-adb_service.c b/epan/dissectors/packet-adb_service.c new file mode 100644 index 0000000000..e1afb16eb5 --- /dev/null +++ b/epan/dissectors/packet-adb_service.c @@ -0,0 +1,845 @@ +/* packet-adb_service.c + * Routines for Android Debug Bridge Services + * + * 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" + +static int proto_adb_service = -1; + +static int hf_service = -1; +static int hf_fragment = -1; +static int hf_data = -1; +static int hf_hex_ascii_length = -1; +static int hf_length = -1; +static int hf_version = -1; +static int hf_hex_ascii_version = -1; +static int hf_framebuffer_version = -1; +static int hf_framebuffer_depth = -1; +static int hf_framebuffer_size = -1; +static int hf_framebuffer_width = -1; +static int hf_framebuffer_height = -1; +static int hf_framebuffer_red_offset = -1; +static int hf_framebuffer_red_length = -1; +static int hf_framebuffer_blue_offset = -1; +static int hf_framebuffer_blue_length = -1; +static int hf_framebuffer_green_offset = -1; +static int hf_framebuffer_green_length = -1; +static int hf_framebuffer_alpha_offset = -1; +static int hf_framebuffer_alpha_length = -1; +static int hf_framebuffer_pixel = -1; +static int hf_framebuffer_red_5 = -1; +static int hf_framebuffer_green_6 = -1; +static int hf_framebuffer_blue_5 = -1; +static int hf_framebuffer_red = -1; +static int hf_framebuffer_green = -1; +static int hf_framebuffer_blue = -1; +static int hf_framebuffer_alpha = -1; +static int hf_framebuffer_unused = -1; +static int hf_devices = -1; +static int hf_stdin = -1; +static int hf_stdout = -1; +static int hf_pids = -1; +static int hf_result = -1; +static int hf_sync_id = -1; +static int hf_sync_length = -1; +static int hf_sync_mode = -1; +static int hf_sync_size = -1; +static int hf_sync_time = -1; +static int hf_sync_unused = -1; +static int hf_sync_data = -1; + +static expert_field ei_incomplete_message = EI_INIT; + +static gint ett_adb_service = -1; +static gint ett_length = -1; +static gint ett_version = -1; +static gint ett_pixel = -1; +static gint ett_data = -1; + +static dissector_handle_t adb_service_handle; +static dissector_handle_t logcat_handle; + +static gboolean pref_dissect_more_detail_framebuffer = FALSE; + +static wmem_tree_t *fragments = NULL; +static wmem_tree_t *framebuffer_infos = NULL; +static wmem_tree_t *continuation_infos = NULL; + +typedef struct _framebuffer_data_t { + guint32 data_in; + guint32 current_size; + guint32 completed_in_frame; + + guint32 size; + guint32 red_offset; + guint32 red_length; + guint32 green_offset; + guint32 green_length; + guint32 blue_offset; + guint32 blue_length; + guint32 alpha_offset; + guint32 alpha_length; +} framebuffer_data_t; + +typedef struct _fragment_t { + gint64 reassembled_in_frame; + gint length; + guint8 *data; +} fragment_t; + +typedef struct _continuation_data_t { + guint32 length_in_frame; + guint32 completed_in_frame; + gint length; +} continuation_data_t; + +void proto_register_adb_service(void); +void proto_reg_handoff_adb_service(void); + +gint +dissect_ascii_uint32(proto_tree *tree, gint hf_hex_ascii, gint ett_hex_ascii, + gint hf_value, tvbuff_t *tvb, gint offset, guint32 *value) +{ + proto_item *sub_item; + proto_tree *sub_tree; + guint8 hex_ascii[5]; + + DISSECTOR_ASSERT(value); + + tvb_memcpy(tvb, hex_ascii, offset, 4); + hex_ascii[4]='\0'; + + sub_item = proto_tree_add_item(tree, hf_hex_ascii, tvb, offset, 4, ENC_NA | ENC_ASCII); + sub_tree = proto_item_add_subtree(sub_item, ett_hex_ascii); + + *value = (guint32) g_ascii_strtoull(hex_ascii, NULL, 16); + + proto_tree_add_uint(sub_tree, hf_value, tvb, offset, 4, *value); + offset += 4; + + return offset; +} + +static gint +dissect_adb_service(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data) +{ + proto_item *main_item; + proto_tree *main_tree; + proto_item *sub_item; + proto_tree *sub_tree; + gint offset = 0; + adb_service_data_t *adb_service_data = (adb_service_data_t *) data; + const guint8 *service; + wmem_tree_key_t key[5]; + wmem_tree_t *subtree; + guint32 i_key; + + main_item = proto_tree_add_item(tree, proto_adb_service, tvb, offset, -1, ENC_NA); + main_tree = proto_item_add_subtree(main_item, ett_adb_service); + + DISSECTOR_ASSERT(adb_service_data); + + service = adb_service_data->service; + + sub_item = proto_tree_add_string(main_tree, hf_service, tvb, offset, 0, service); + PROTO_ITEM_SET_GENERATED(sub_item); + + if (g_strcmp0(service, "host:version") == 0) { + guint32 version; + guint32 data_length; + continuation_data_t *continuation_data; + + DISSECTOR_ASSERT_HINT(adb_service_data->session_key_length + 1 <= sizeof(key) / sizeof(key[0]), "Tree session key is too small"); + for (i_key = 0; i_key < adb_service_data->session_key_length; i_key += 1) { + key[i_key].length = 1; + key[i_key].key = &adb_service_data->session_key[i_key]; + } + key[i_key].length = 0; + key[i_key].key = NULL; + + subtree = (wmem_tree_t *) wmem_tree_lookup32_array(continuation_infos, key); + continuation_data = (subtree) ? (continuation_data_t *) wmem_tree_lookup32_le(subtree, pinfo->fd->num) : NULL; + if (continuation_data && continuation_data->completed_in_frame < pinfo->fd->num) + continuation_data = NULL; + + if (!continuation_data || (continuation_data && continuation_data->length_in_frame == pinfo->fd->num)) + offset = dissect_ascii_uint32(main_tree, hf_hex_ascii_length, ett_length, hf_length, tvb, offset, &data_length); + + if (!pinfo->fd->flags.visited && !continuation_data && tvb_reported_length_remaining(tvb, offset) < 4) { + key[i_key].length = 1; + key[i_key++].key = &pinfo->fd->num; + key[i_key].length = 0; + key[i_key].key = NULL; + + continuation_data = wmem_new(wmem_file_scope(), continuation_data_t); + continuation_data->length_in_frame = pinfo->fd->num; + continuation_data->completed_in_frame = G_MAXUINT32; + continuation_data->length = data_length; + + wmem_tree_insert32_array(continuation_infos, key, continuation_data); + continuation_data = NULL; + } + + if (tvb_reported_length_remaining(tvb, offset) >= 4 || + (continuation_data && continuation_data->completed_in_frame == pinfo->fd->num)) { + if (!pinfo->fd->flags.visited && continuation_data) { + continuation_data->completed_in_frame = pinfo->fd->num; + } + offset = dissect_ascii_uint32(main_tree, hf_hex_ascii_version, ett_version, hf_version, tvb, offset, &version); + + col_append_fstr(pinfo->cinfo, COL_INFO, " Version=%u", version); + } + + } else if (g_strcmp0(service, "host:devices") == 0 || + g_strcmp0(service, "host:devices-l") == 0 || + g_strcmp0(service, "host:track-devices") == 0) { + guint32 data_length; + + offset = dissect_ascii_uint32(main_tree, hf_hex_ascii_length, ett_length, hf_length, tvb, offset, &data_length); + + sub_item = proto_tree_add_item(main_tree, hf_devices, tvb, offset, -1, ENC_NA | ENC_ASCII); + if ((gint64) data_length < tvb_reported_length_remaining(tvb, offset)) { + expert_add_info(pinfo, sub_item, &ei_incomplete_message); + } + } else if (g_strcmp0(service, "host:get-state") == 0 || + g_strcmp0(service, "host:get-serialno") == 0 || + g_strcmp0(service, "host:get-devpath") == 0 || + g_str_has_prefix(service, "connect:") || + g_str_has_prefix(service, "disconnect:")) { + guint32 data_length; + + offset = dissect_ascii_uint32(main_tree, hf_hex_ascii_length, ett_length, hf_length, tvb, offset, &data_length); + + sub_item = proto_tree_add_item(main_tree, hf_result, tvb, offset, -1, ENC_NA | ENC_ASCII); + if ((gint64) data_length < tvb_reported_length_remaining(tvb, offset)) { + expert_add_info(pinfo, sub_item, &ei_incomplete_message); + } + } else if (g_str_has_prefix(service, "framebuffer:")) { + framebuffer_data_t *framebuffer_data = NULL; + + DISSECTOR_ASSERT_HINT(adb_service_data->session_key_length + 1 <= sizeof(key) / sizeof(key[0]), "Tree session key is too small"); + for (i_key = 0; i_key < adb_service_data->session_key_length; i_key += 1) { + key[i_key].length = 1; + key[i_key].key = &adb_service_data->session_key[i_key]; + } + key[i_key].length = 0; + key[i_key].key = NULL; + + subtree = (wmem_tree_t *) wmem_tree_lookup32_array(framebuffer_infos, key); + framebuffer_data = (subtree) ? (framebuffer_data_t *) wmem_tree_lookup32_le(subtree, pinfo->fd->num) : NULL; + if (framebuffer_data && framebuffer_data->completed_in_frame < pinfo->fd->num) + framebuffer_data = NULL; + + if (!pinfo->fd->flags.visited && !framebuffer_data) { + key[i_key].length = 1; + key[i_key++].key = &pinfo->fd->num; + key[i_key].length = 0; + key[i_key].key = NULL; + + framebuffer_data = wmem_new(wmem_file_scope(), framebuffer_data_t); + framebuffer_data->data_in = pinfo->fd->num; + framebuffer_data->current_size = 0; + framebuffer_data->completed_in_frame = G_MAXUINT32; + framebuffer_data->size = tvb_get_letohl(tvb, offset + 4 * 2); + framebuffer_data->red_offset = tvb_get_letohl(tvb, offset + 4 * 5); + framebuffer_data->red_length = tvb_get_letohl(tvb, offset + 4 * 6); + framebuffer_data->green_offset = tvb_get_letohl(tvb, offset + 4 * 7); + framebuffer_data->green_length = tvb_get_letohl(tvb, offset + 4 * 8); + framebuffer_data->blue_offset = tvb_get_letohl(tvb, offset + 4 * 9); + framebuffer_data->blue_length = tvb_get_letohl(tvb, offset + 4 * 10); + framebuffer_data->alpha_offset = tvb_get_letohl(tvb, offset + 4 * 11); + framebuffer_data->alpha_length = tvb_get_letohl(tvb, offset + 4 * 12); + + wmem_tree_insert32_array(framebuffer_infos, key, framebuffer_data); + } + + if (framebuffer_data && framebuffer_data->data_in == pinfo->fd->num) { + proto_tree_add_item(main_tree, hf_framebuffer_version, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + + proto_tree_add_item(main_tree, hf_framebuffer_depth, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + + proto_tree_add_item(main_tree, hf_framebuffer_size, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + + proto_tree_add_item(main_tree, hf_framebuffer_width, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + + proto_tree_add_item(main_tree, hf_framebuffer_height, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + + proto_tree_add_item(main_tree, hf_framebuffer_red_offset, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + + proto_tree_add_item(main_tree, hf_framebuffer_red_length, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + + proto_tree_add_item(main_tree, hf_framebuffer_blue_offset, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + + proto_tree_add_item(main_tree, hf_framebuffer_blue_length, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + + proto_tree_add_item(main_tree, hf_framebuffer_green_offset, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + + proto_tree_add_item(main_tree, hf_framebuffer_green_length, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + + proto_tree_add_item(main_tree, hf_framebuffer_alpha_offset, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + + proto_tree_add_item(main_tree, hf_framebuffer_alpha_length, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + } + + if (tvb_reported_length_remaining(tvb, offset) > 0) { + sub_item = proto_tree_add_item(main_tree, hf_data, tvb, offset, -1, ENC_NA); + sub_tree = proto_item_add_subtree(sub_item, ett_data); + + if (!pinfo->fd->flags.visited && framebuffer_data) { + framebuffer_data->current_size += tvb_captured_length_remaining(tvb, offset); + if (framebuffer_data->current_size >= framebuffer_data->size) + framebuffer_data->completed_in_frame = pinfo->fd->num; + } + + if (pref_dissect_more_detail_framebuffer) { + proto_item *pixel_item; + proto_tree *pixel_tree; + + if (framebuffer_data && + framebuffer_data->red_length == 5 && + framebuffer_data->green_length == 6 && + framebuffer_data->blue_length == 5 && + framebuffer_data->red_offset == 11 && + framebuffer_data->green_offset == 5 && + framebuffer_data->blue_offset == 0) { + while (tvb_reported_length_remaining(tvb, offset) > 0) { + if (tvb_reported_length_remaining(tvb, offset) < 2) { + proto_tree_add_item(main_tree, hf_fragment, tvb, offset, -1, ENC_NA); + offset += 1; + } + + pixel_item = proto_tree_add_item(sub_tree, hf_framebuffer_pixel, tvb, offset, 2, ENC_NA); + pixel_tree = proto_item_add_subtree(pixel_item, ett_pixel); + + proto_tree_add_item(pixel_tree, hf_framebuffer_blue_5, tvb, offset, 2, ENC_LITTLE_ENDIAN); + proto_tree_add_item(pixel_tree, hf_framebuffer_green_6, tvb, offset, 2, ENC_LITTLE_ENDIAN); + proto_tree_add_item(pixel_tree, hf_framebuffer_red_5, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + } + } else if (framebuffer_data && + framebuffer_data->red_length == 8 && + framebuffer_data->green_length == 8 && + framebuffer_data->blue_length == 8 && + (framebuffer_data->alpha_length == 0 || + framebuffer_data->alpha_length == 8)) { + while (tvb_reported_length_remaining(tvb, offset) > 0) { + if (tvb_reported_length_remaining(tvb, offset) < 3 || (tvb_reported_length_remaining(tvb, offset) < 4 && framebuffer_data->alpha_offset > 0)) { + proto_tree_add_item(main_tree, hf_fragment, tvb, offset, -1, ENC_NA); + offset = tvb_captured_length(tvb); + break; + } + + pixel_item = proto_tree_add_item(sub_tree, hf_framebuffer_pixel, tvb, offset, 3, ENC_NA); + pixel_tree = proto_item_add_subtree(pixel_item, ett_pixel); + + proto_tree_add_item(pixel_tree, hf_framebuffer_red, tvb, offset + framebuffer_data->red_offset / 8, 1, ENC_NA); + proto_tree_add_item(pixel_tree, hf_framebuffer_green, tvb, offset + framebuffer_data->green_offset / 8, 1, ENC_NA); + proto_tree_add_item(pixel_tree, hf_framebuffer_blue, tvb, offset + framebuffer_data->blue_offset / 8, 1, ENC_NA); + + if (framebuffer_data->alpha_offset > 0) { + if (framebuffer_data->alpha_length == 0) + proto_tree_add_item(pixel_tree, hf_framebuffer_unused, tvb, offset + framebuffer_data->alpha_offset / 8, 1, ENC_NA); + else + proto_tree_add_item(pixel_tree, hf_framebuffer_alpha, tvb, offset + framebuffer_data->alpha_offset / 8, 1, ENC_NA); + offset += 1; + proto_item_set_len(pixel_item, 4); + } + offset += 3; + } + } else { + offset = tvb_captured_length(tvb); + } + } else { + offset = tvb_captured_length(tvb); + } + } + } else if (g_strcmp0(service, "track-jdwp") == 0) { + guint32 data_length; + + offset = dissect_ascii_uint32(main_tree, hf_hex_ascii_length, ett_length, hf_length, tvb, offset, &data_length); + + if (tvb_reported_length_remaining(tvb, offset) > 0) { + sub_item = proto_tree_add_item(main_tree, hf_pids, tvb, offset, -1, ENC_NA | ENC_ASCII); + if ((gint64) data_length < tvb_reported_length_remaining(tvb, offset)) { + expert_add_info(pinfo, sub_item, &ei_incomplete_message); + } + } + offset = tvb_captured_length(tvb); + } else if ((g_strcmp0(service, "shell:export ANDROID_LOG_TAGS=\"\" ; exec logcat -B") == 0) || + (g_strcmp0(service, "shell:logcat -B") == 0)) { + tvbuff_t *next_tvb; + tvbuff_t *new_tvb; + guint8 *buffer = NULL; + gint size = 0; + gint i_offset = offset; + gint old_offset; + gint i_char = 0; + guint8 c1; + guint8 c2 = '\0'; + guint16 payload_length; + guint16 try_header_size; + gint logcat_length = 0; + fragment_t *fragment; + + DISSECTOR_ASSERT_HINT(adb_service_data->session_key_length + 1 <= sizeof(key) / sizeof(key[0]), "Tree session key is too small"); + for (i_key = 0; i_key < adb_service_data->session_key_length; i_key += 1) { + key[i_key].length = 1; + key[i_key].key = &adb_service_data->session_key[i_key]; + } + key[i_key].length = 0; + key[i_key].key = NULL; + + subtree = (wmem_tree_t *) wmem_tree_lookup32_array(fragments, key); + fragment = (subtree) ? (fragment_t *) wmem_tree_lookup32_le(subtree, pinfo->fd->num - 1) : NULL; + if (fragment) { + if (!pinfo->fd->flags.visited && fragment->reassembled_in_frame == -1) + fragment->reassembled_in_frame = pinfo->fd->num; + + if (fragment->reassembled_in_frame == pinfo->fd->num) { + size += fragment->length; + i_char += fragment->length; + } + } + + size += tvb_reported_length_remaining(tvb, i_offset); + if (size > 0) { + buffer = (guint8 *) wmem_alloc(pinfo->pool, size); + if (fragment && i_char > 0) + memcpy(buffer, fragment->data, i_char); + + if (i_char >= 1 && buffer[i_char - 1] == '\r' && tvb_get_guint8(tvb, i_offset) == '\n') { + buffer[i_char - 1] = '\n'; + i_offset += 1; + } + + c1 = tvb_get_guint8(tvb, i_offset); + i_offset += 1; + old_offset = i_offset; + + while (tvb_reported_length_remaining(tvb, i_offset) > 0) { + c2 = tvb_get_guint8(tvb, i_offset); + + if (c1 == '\r' && c2 == '\n') { + buffer[i_char] = c2; + if (tvb_reported_length_remaining(tvb, i_offset) > 1) { + c1 = tvb_get_guint8(tvb, i_offset + 1); + i_offset += 2; + i_char += 1; + } else { + i_offset += 1; + } + + continue; + } + + buffer[i_char] = c1; + c1 = c2; + i_char += 1; + i_offset += 1; + } + + if (tvb_reported_length_remaining(tvb, old_offset) == 0) { + buffer[i_char] = c1; + i_char += 1; + } else if (tvb_reported_length_remaining(tvb, old_offset) > 0) { + buffer[i_char] = c2; + i_char += 1; + } + + next_tvb = tvb_new_child_real_data(tvb, buffer, i_char, i_char); + add_new_data_source(pinfo, next_tvb, "Logcat"); + + i_offset = 0; + while (tvb_reported_length_remaining(next_tvb, i_offset) > 0) { + if (tvb_reported_length_remaining(next_tvb, i_offset) >= 4) { + payload_length = tvb_get_letohs(next_tvb, i_offset); + try_header_size = tvb_get_letohs(next_tvb, i_offset + 2); + + if (try_header_size == 0 || try_header_size != 24) + logcat_length = payload_length + 20; + else + logcat_length = payload_length + 24; + } + + if (tvb_reported_length_remaining(next_tvb, i_offset) >= 4 && tvb_reported_length_remaining(next_tvb, i_offset) >= logcat_length) { + new_tvb = tvb_new_subset_length(next_tvb, i_offset, logcat_length); + + call_dissector(logcat_handle, new_tvb, pinfo, main_tree); + i_offset += logcat_length; + } else { + + if (!pinfo->fd->flags.visited) { + DISSECTOR_ASSERT_HINT(adb_service_data->session_key_length + 2 <= sizeof(key) / sizeof(key[0]), "Tree session key is too small"); + for (i_key = 0; i_key < adb_service_data->session_key_length; i_key += 1) { + key[i_key].length = 1; + key[i_key].key = &adb_service_data->session_key[i_key]; + } + key[i_key].length = 1; + key[i_key++].key = &pinfo->fd->num; + key[i_key].length = 0; + key[i_key].key = NULL; + + fragment = wmem_new(wmem_file_scope(), fragment_t); + + fragment->length = tvb_captured_length_remaining(next_tvb, i_offset); + fragment->data = (guint8 *) wmem_alloc(wmem_file_scope(), fragment->length); + tvb_memcpy(next_tvb, fragment->data, i_offset, fragment->length); + fragment->reassembled_in_frame = -1; + + wmem_tree_insert32_array(fragments, key, fragment); + } + + proto_tree_add_item(main_tree, hf_fragment, next_tvb, i_offset, -1, ENC_NA); + i_offset = tvb_captured_length(next_tvb); + } + } + } + + offset = tvb_captured_length(tvb); + } else if (g_str_has_prefix(service, "shell:")) { + if (adb_service_data->direction == P2P_DIR_SENT) { + proto_tree_add_item(main_tree, hf_stdin, tvb, offset, -1, ENC_NA | ENC_ASCII); + col_append_fstr(pinfo->cinfo, COL_INFO, " Stdin=<%s>", tvb_format_text_wsp(tvb, offset, tvb_captured_length_remaining(tvb, offset))); + + } else { + proto_tree_add_item(main_tree, hf_stdout, tvb, offset, -1, ENC_NA | ENC_ASCII); + col_append_fstr(pinfo->cinfo, COL_INFO, " Stdout=<%s>", tvb_format_text_wsp(tvb, offset, tvb_captured_length_remaining(tvb, offset))); + } + offset = tvb_captured_length(tvb); + } else if (g_str_has_prefix(service, "jdwp:")) { +/* TODO */ + proto_tree_add_item(main_tree, hf_data, tvb, offset, -1, ENC_NA); + offset = tvb_captured_length(tvb); + } else if (g_str_has_prefix(service, "sync:")) { +/* TODO */ + proto_tree_add_item(main_tree, hf_data, tvb, offset, -1, ENC_NA); + offset = tvb_captured_length(tvb); + } else if (g_strcmp0(service, "host:list-forward") == 0 || + g_str_has_prefix(service, "root:") || + g_str_has_prefix(service, "remount:") || + g_str_has_prefix(service, "tcpip:") || + g_str_has_prefix(service, "usb:")) { + if (tvb_reported_length_remaining(tvb, offset)) { + proto_tree_add_item(main_tree, hf_result, tvb, offset, -1, ENC_NA | ENC_ASCII); + col_append_fstr(pinfo->cinfo, COL_INFO, " Result=<%s>", tvb_format_text_wsp(tvb, offset, tvb_captured_length_remaining(tvb, offset))); + + offset = tvb_captured_length(tvb); + } + } else { + proto_tree_add_item(main_tree, hf_data, tvb, offset, -1, ENC_NA); + offset = tvb_captured_length(tvb); + } + + return offset; +} + + +void +proto_register_adb_service(void) +{ + module_t *module; + expert_module_t *expert_module; + + static hf_register_info hf[] = { + { &hf_service, + { "Service", "adb_service.service", + FT_STRING, STR_ASCII, NULL, 0x00, + NULL, HFILL } + }, + { &hf_fragment, + { "Fragment", "adb_service.fragment", + FT_NONE, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_data, + { "Data", "adb_service.data", + FT_BYTES, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_hex_ascii_length, + { "Hex ASCII String Length", "adb_service.hex_ascii_length", + FT_STRING, STR_ASCII, NULL, 0x00, + NULL, HFILL } + }, + { &hf_length, + { "Length", "adb_service.length", + FT_UINT32, BASE_DEC_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_version, + { "Version", "adb_service.framebuffer.version", + FT_UINT32, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_hex_ascii_version, + { "Hex ASCII String Version", "adb_service.hex_ascii_version", + FT_STRING, STR_ASCII, NULL, 0x00, + NULL, HFILL } + }, + { &hf_version, + { "Version", "adb_service.version", + FT_UINT32, BASE_DEC_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_depth, + { "Depth", "adb_service.framebuffer.depth", + FT_UINT32, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_size, + { "Size", "adb_service.framebuffer.size", + FT_UINT32, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_width, + { "Width", "adb_service.framebuffer.width", + FT_UINT32, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_height, + { "Height", "adb_service.framebuffer.height", + FT_UINT32, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_red_offset, + { "Red Offset", "adb_service.framebuffer.red_offset", + FT_UINT32, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_red_length, + { "Red Length", "adb_service.framebuffer.red_length", + FT_UINT32, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_blue_offset, + { "Blue Offset", "adb_service.framebuffer.blue_offset", + FT_UINT32, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_blue_length, + { "Blue Length", "adb_service.framebuffer.blue_length", + FT_UINT32, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_green_offset, + { "Green Offset", "adb_service.framebuffer.green_offset", + FT_UINT32, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_green_length, + { "Green Length", "adb_service.framebuffer.green_length", + FT_UINT32, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_alpha_offset, + { "Alpha Offset", "adb_service.framebuffer.alpha_offset", + FT_UINT32, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_alpha_length, + { "Alpha Length", "adb_service.framebuffer.alpha_length", + FT_UINT32, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_pixel, + { "Pixel", "adb_service.framebuffer.pixel", + FT_NONE, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_blue_5, + { "Blue", "adb_service.framebuffer.pixel.blue", + FT_UINT16, BASE_DEC, NULL, 0xF800, + NULL, HFILL } + }, + { &hf_framebuffer_green_6, + { "Green", "adb_service.framebuffer.pixel.green", + FT_UINT16, BASE_DEC, NULL, 0x07E0, + NULL, HFILL } + }, + { &hf_framebuffer_red_5, + { "Red", "adb_service.framebuffer.pixel.red", + FT_UINT16, BASE_DEC, NULL, 0x001F, + NULL, HFILL } + }, + { &hf_framebuffer_blue, + { "Blue", "adb_service.framebuffer.pixel.blue", + FT_UINT8, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_green, + { "Green", "adb_service.framebuffer.pixel.green", + FT_UINT8, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_red, + { "Red", "adb_service.framebuffer.pixel.red", + FT_UINT8, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_alpha, + { "Alpha", "adb_service.framebuffer.pixel.alpha", + FT_UINT8, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_framebuffer_unused, + { "Unused", "adb_service.framebuffer.pixel.unused", + FT_UINT8, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_devices, + { "Devices", "adb_service.devices", + FT_STRING, STR_ASCII, NULL, 0x00, + NULL, HFILL } + }, + { &hf_stdin, + { "Stdin", "adb_service.stdin", + FT_STRING, STR_ASCII, NULL, 0x00, + NULL, HFILL } + }, + { &hf_stdout, + { "Stdout", "adb_service.stdout", + FT_STRING, STR_ASCII, NULL, 0x00, + NULL, HFILL } + }, + { &hf_result, + { "Result", "adb_service.result", + FT_STRING, STR_ASCII, NULL, 0x00, + NULL, HFILL } + }, + { &hf_pids, + { "PIDs", "adb_service.pids", + FT_STRING, STR_ASCII, NULL, 0x00, + NULL, HFILL } + }, + { &hf_sync_id, + { "Id", "adb_service.sync.id", + FT_STRING, STR_ASCII, NULL, 0x00, + NULL, HFILL } + }, + { &hf_sync_length, + { "Length", "adb_service.sync.length", + FT_UINT32, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_sync_mode, + { "Mode", "adb_service.sync.mode", + FT_UINT32, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_sync_size, + { "Size", "adb_service.sync.size", + FT_UINT32, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_sync_time, + { "Last Modification Time", "adb_service.sync.time", + FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x00, + NULL, HFILL } + }, + { &hf_sync_unused, + { "Unused", "adb_service.sync.unused", + FT_BYTES, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_sync_data, + { "Sync Data", "adb_service.sync.data", + FT_BYTES, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + }; + + static gint *ett[] = { + &ett_adb_service, + &ett_length, + &ett_version, + &ett_pixel, + &ett_data + }; + + static ei_register_info ei[] = { + { &ei_incomplete_message, { "adb_service.expert.incomplete_message", PI_PROTOCOL, PI_WARN, "Incomplete message", EXPFILL }}, + }; + + fragments = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); + framebuffer_infos = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); + continuation_infos = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); + + proto_adb_service = proto_register_protocol("Android Debug Bridge Service", "ADB Service", "adb_service"); + adb_service_handle = new_register_dissector("adb_service", dissect_adb_service, proto_adb_service); + + proto_register_field_array(proto_adb_service, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + expert_module = expert_register_protocol(proto_adb_service); + expert_register_field_array(expert_module, ei, array_length(ei)); + + module = prefs_register_protocol(proto_adb_service, NULL); + prefs_register_static_text_preference(module, "version", + "ADB Service protocol version is compatibile pior to: adb 1.0.31", + "Version of protocol supported by this dissector."); + + prefs_register_bool_preference(module, "framebuffer_more_details", + "Dissect more detail for framebuffer service", + "Dissect more detail for framebuffer service", + &pref_dissect_more_detail_framebuffer); +} + + +void +proto_reg_handoff_adb_service(void) +{ + logcat_handle = find_dissector("logcat"); +} + +/* + * 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: + */ |