| /* |
| * Copyright 2010 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| |
| /* |
| * Note that Wireshark dissectors are pure C, not C++ -- there are also |
| * restrictions on various C extensions, including things like all variables |
| * must be declared at the beginning of a block, and only initialized to |
| * scalar constants. |
| */ |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #include "BrowserChannel.h" |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include <gmodule.h> |
| #include <epan/conversation.h> |
| #include <epan/prefs.h> |
| #include <epan/packet.h> |
| |
| /* |
| * Default port to follow. |
| */ |
| #define DEFAULT_GWTCS_PORT 9997 |
| |
| /* |
| * Trim strngs at this length. |
| */ |
| #define MAX_STRING_LENGTH 100 |
| |
| /* forward reference */ |
| void proto_register_gwtcs(); |
| void proto_reg_handoff_gwtcs(); |
| |
| /* Define version if we are not building Wireshark statically */ |
| #ifndef ENABLE_STATIC |
| G_MODULE_EXPORT const gchar version[] = "0.1"; |
| #endif |
| |
| /* |
| * Data stored for a GWT-CS conversation. |
| */ |
| typedef struct _gwtcs_data { |
| address clientAddress; |
| guint32 clientPort; |
| int level; |
| } gwtcs_data; |
| |
| /* |
| * Names of packet types -- must be in order. |
| */ |
| static const value_string packetTypes[] = { |
| { MESSAGE_TYPE_INVOKE, "Invoke" }, |
| { MESSAGE_TYPE_RETURN, "Return" }, |
| { MESSAGE_TYPE_OLD_LOAD_MODULE, "Old Load Module" }, |
| { MESSAGE_TYPE_QUIT, "Quit" }, |
| { MESSAGE_TYPE_LOADJSNI, "Load JSNI" }, |
| { MESSAGE_TYPE_INVOKESPECIAL, "Invoke Special" }, |
| { MESSAGE_TYPE_FREEVALUE, "Free Value" }, |
| { MESSAGE_TYPE_FATAL_ERROR, "Fatal Error" }, |
| { MESSAGE_TYPE_CHECK_VERSIONS, "Check Versions" }, |
| { MESSAGE_TYPE_PROTOCOL_VERSION, "Protocol Version" }, |
| { MESSAGE_TYPE_CHOOSE_TRANSPORT, "Choose Transport" }, |
| { MESSAGE_TYPE_SWITCH_TRANSPORT, "Switch Transport" }, |
| { MESSAGE_TYPE_LOAD_MODULE, "Load Module" }, |
| { 0, NULL } |
| }; |
| #define MAX_PACKET_TYPE MESSAGE_TYPE_LOAD_MODULE |
| |
| |
| static const value_string valueTypes[] = { |
| {VALUE_TYPE_NULL, "null" }, |
| {VALUE_TYPE_BOOLEAN, "boolean" }, |
| {VALUE_TYPE_BYTE, "byte" }, |
| {VALUE_TYPE_CHAR, "char" }, |
| {VALUE_TYPE_SHORT, "short" }, |
| {VALUE_TYPE_INT, "int" }, |
| {VALUE_TYPE_LONG, "long" }, |
| {VALUE_TYPE_FLOAT, "float" }, |
| {VALUE_TYPE_DOUBLE, "double" }, |
| {VALUE_TYPE_STRING, "string" }, |
| {VALUE_TYPE_JAVA_OBJECT, "Java object" }, |
| {VALUE_TYPE_JS_OBJECT, "JS object" }, |
| {VALUE_TYPE_UNDEFINED, "undefined" }, |
| { 0, NULL } |
| }; |
| |
| /* |
| * InvokeSpecial types -- must be in order. |
| */ |
| static const value_string specialTypes[] = { |
| { SPECIAL_HAS_METHOD, "hasMethod" }, |
| { SPECIAL_HAS_PROPERTY, "hasProperty" }, |
| { SPECIAL_GET_PROPERTY, "getProperty" }, |
| { SPECIAL_SET_PROPERTY, "setProperty" }, |
| { 0, NULL } |
| }; |
| |
| /* |
| * Dynamically assigned protocol ID. |
| */ |
| static int proto_gwtcs = -1; |
| |
| /* |
| * Dynamically assigned subtree IDs. |
| */ |
| static gint ett_gwtcs = -1; |
| static gint ett_value = -1; |
| static gint ett_args = -1; |
| |
| /* |
| * IDs for displayed values. |
| */ |
| static int hf_gwtcs_pdu_type = -1; |
| static int hf_gwtcs_value_tag = -1; |
| static int hf_gwtcs_min_vers = -1; |
| static int hf_gwtcs_max_vers = -1; |
| static int hf_gwtcs_hosted_vers = -1; |
| static int hf_gwtcs_sel_vers = -1; |
| static int hf_gwtcs_lm_ua = -1; |
| static int hf_gwtcs_lm_tabkey = -1; |
| static int hf_gwtcs_lm_seskey = -1; |
| static int hf_gwtcs_lm_modname = -1; |
| static int hf_gwtcs_lm_url = -1; |
| static int hf_gwtcs_methname = -1; |
| static int hf_gwtcs_isexc = -1; |
| static int hf_gwtcs_dispid = -1; |
| static int hf_gwtcs_jsni = -1; |
| static int hf_gwtcs_val_hdr = -1; |
| static int hf_gwtcs_val_bool = -1; |
| static int hf_gwtcs_val_byte = -1; |
| static int hf_gwtcs_val_char = -1; |
| static int hf_gwtcs_val_short = -1; |
| static int hf_gwtcs_val_int = -1; |
| static int hf_gwtcs_val_long = -1; |
| static int hf_gwtcs_val_float = -1; |
| static int hf_gwtcs_val_double = -1; |
| static int hf_gwtcs_val_string = -1; |
| static int hf_gwtcs_val_javaobj = -1; |
| static int hf_gwtcs_val_jsobj = -1; |
| static int hf_gwtcs_val_null = -1; |
| static int hf_gwtcs_val_undef = -1; |
| static int hf_gwtcs_numargs = -1; |
| static int hf_gwtcs_spectype = -1; |
| static int hf_gwtcs_transport = -1; |
| static int hf_gwtcs_transargs = -1; |
| |
| static dissector_handle_t gwtcs_handle; |
| |
| static GMemChunk* memChunk = 0; |
| |
| #ifndef ENABLE_STATIC |
| G_MODULE_EXPORT void plugin_register(void) |
| { |
| /* register the new protocol, protocol fields, and subtrees */ |
| if (proto_gwtcs == -1) { /* execute protocol initialization only once */ |
| proto_register_gwtcs(); |
| } |
| } |
| |
| G_MODULE_EXPORT void plugin_reg_handoff(void){ |
| proto_reg_handoff_gwtcs(); |
| } |
| #endif |
| |
| /* |
| * Get a string describing a Value from the packet, and return the total length |
| * (including the tag byte). |
| * |
| * ofs - offset into the buffer of the Value's tag byte |
| * buf - buffer to write string into; on return is guaranteed to be null |
| * terminated |
| * buflen - length of buf |
| * |
| * returns the offset after the last byte of this Value |
| */ |
| static int getValue(tvbuff_t* tvb, int ofs, char* buf, int buflen) { |
| guint8 tag; |
| tag = tvb_get_guint8(tvb, ofs++); |
| int len = 0; |
| switch (tag) { |
| case VALUE_TYPE_NULL: |
| strncpy(buf, "null", buflen); |
| break; |
| case VALUE_TYPE_UNDEFINED: |
| strncpy(buf, "undef", buflen); |
| break; |
| case VALUE_TYPE_BOOLEAN: |
| { |
| guint8 val; |
| val = tvb_get_guint8(tvb, ofs); |
| len = 1; |
| strncpy(buf, val ? "true" : "false", buflen); |
| } |
| break; |
| case VALUE_TYPE_BYTE: |
| { |
| int val; |
| val = tvb_get_guint8(tvb, ofs); |
| if (val & 128) { |
| val -= 256; |
| } |
| len = 1; |
| snprintf(buf, buflen, "%d", val); |
| } |
| break; |
| case VALUE_TYPE_SHORT: |
| { |
| int val; |
| val = tvb_get_ntohs(tvb, ofs); |
| if (val & 0x8000) { |
| val -= 0x10000; |
| } |
| len = 2; |
| snprintf(buf, buflen, "%d", val); |
| } |
| break; |
| case VALUE_TYPE_CHAR: |
| { |
| int val; |
| val = tvb_get_ntohs(tvb, ofs); |
| len = 2; |
| /* show printable ASCII */ |
| if (val >= 0x20 && val < 0x7f) { |
| snprintf(buf, buflen, "%d - %c", val, val); |
| } else { |
| snprintf(buf, buflen, "%d (U+%04x)", val, val); |
| } |
| } |
| break; |
| case VALUE_TYPE_INT: |
| { |
| int val; |
| val = tvb_get_ntohl(tvb, ofs); |
| len = 4; |
| snprintf(buf, buflen, "%d", val); |
| } |
| break; |
| case VALUE_TYPE_FLOAT: |
| { |
| float val; |
| val = tvb_get_ntohieee_float(tvb, ofs); |
| len = 4; |
| snprintf(buf, buflen, "%g", val); |
| } |
| break; |
| case VALUE_TYPE_JAVA_OBJECT: |
| { |
| int val; |
| val = tvb_get_ntohl(tvb, ofs); |
| len = 4; |
| snprintf(buf, buflen, "Java Object %d", val); |
| } |
| break; |
| case VALUE_TYPE_JS_OBJECT: |
| { |
| int val; |
| val = tvb_get_ntohl(tvb, ofs); |
| len = 4; |
| snprintf(buf, buflen, "JS Object %d", val); |
| } |
| break; |
| case VALUE_TYPE_LONG: |
| { |
| guint64 val; |
| val = tvb_get_ntoh64(tvb, ofs); |
| len = 8; |
| /* no portable way to print guint64, so do it in two pieces */ |
| snprintf(buf, buflen, "0x%08x%08x", (int) ((val >> 32) & 0xFFFFFFFF), |
| (int) (val & 0xFFFFFFFF)); |
| } |
| break; |
| case VALUE_TYPE_DOUBLE: |
| { |
| double val; |
| val = tvb_get_ntohieee_double(tvb, ofs); |
| len = 8; |
| snprintf(buf, buflen, "%lg", val); |
| } |
| break; |
| case VALUE_TYPE_STRING: |
| { |
| guint8* str; |
| len = tvb_get_ntohl(tvb, ofs); |
| ofs += 4; |
| str = tvb_get_ephemeral_string(tvb, ofs, len); |
| if (len > buflen - 3 && buflen >= 6) { |
| snprintf(buf, buflen, "\"%.*s...\"", buflen - 6, (char*) str); |
| } else { |
| snprintf(buf, buflen, "\"%s\"", (char*) str); |
| } |
| } |
| break; |
| } |
| /* ensure the buffer is null-terminated */; |
| buf[buflen - 1] = 0; |
| |
| /* point to byte after this Value */ |
| return ofs + len; |
| } |
| |
| /* |
| * Show a labelled Value. |
| * |
| * hdr - name of this Value |
| * ofs - offset into buffer where the Value tag byte is located. |
| * |
| * returns the offset after the last byte of this Value |
| */ |
| static int showValue(proto_tree* tree, char* hdr, tvbuff_t* tvb, int ofs) { |
| proto_tree* subtree; |
| proto_item* ti; |
| guint8 tag; |
| int newOffset; |
| char buf[40]; |
| *buf = 0; |
| newOffset = getValue(tvb, ofs, buf, sizeof(buf)); |
| tag = tvb_get_guint8(tvb, ofs); |
| ti = proto_tree_add_string_format(tree, hf_gwtcs_val_hdr, tvb, ofs, |
| newOffset - ofs, 0, "%s: %s", hdr, buf); |
| subtree = proto_item_add_subtree(ti, ett_value); |
| proto_tree_add_item(subtree, hf_gwtcs_value_tag, tvb, ofs++, 1, FALSE); |
| switch (tag) { |
| case VALUE_TYPE_NULL: |
| proto_tree_add_item(subtree, hf_gwtcs_val_null, tvb, ofs, 0, FALSE); |
| break; |
| case VALUE_TYPE_UNDEFINED: |
| proto_tree_add_item(subtree, hf_gwtcs_val_undef, tvb, ofs, 0, FALSE); |
| break; |
| case VALUE_TYPE_BOOLEAN: |
| proto_tree_add_item(subtree, hf_gwtcs_val_bool, tvb, ofs, 1, FALSE); |
| break; |
| case VALUE_TYPE_BYTE: |
| proto_tree_add_item(subtree, hf_gwtcs_val_byte, tvb, ofs, 1, FALSE); |
| break; |
| case VALUE_TYPE_CHAR: |
| proto_tree_add_item(subtree, hf_gwtcs_val_char, tvb, ofs, 2, FALSE); |
| break; |
| case VALUE_TYPE_SHORT: |
| proto_tree_add_item(subtree, hf_gwtcs_val_short, tvb, ofs, 2, FALSE); |
| break; |
| case VALUE_TYPE_INT: |
| proto_tree_add_item(subtree, hf_gwtcs_val_int, tvb, ofs, 4, FALSE); |
| break; |
| case VALUE_TYPE_LONG: |
| proto_tree_add_item(subtree, hf_gwtcs_val_long, tvb, ofs, 8, FALSE); |
| break; |
| case VALUE_TYPE_FLOAT: |
| proto_tree_add_item(subtree, hf_gwtcs_val_float, tvb, ofs, 4, FALSE); |
| break; |
| case VALUE_TYPE_DOUBLE: |
| proto_tree_add_item(subtree, hf_gwtcs_val_double, tvb, ofs, 8, FALSE); |
| break; |
| case VALUE_TYPE_STRING: |
| proto_tree_add_item(subtree, hf_gwtcs_val_string, tvb, ofs, 4, FALSE); |
| break; |
| case VALUE_TYPE_JAVA_OBJECT: |
| proto_tree_add_item(subtree, hf_gwtcs_val_javaobj, tvb, ofs, 4, FALSE); |
| break; |
| case VALUE_TYPE_JS_OBJECT: |
| proto_tree_add_item(subtree, hf_gwtcs_val_jsobj, tvb, ofs, 4, FALSE); |
| break; |
| } |
| return newOffset; |
| } |
| |
| /* |
| * Initialize memchunk system. |
| */ |
| static void init() { |
| if (memChunk) { |
| g_mem_chunk_destroy(memChunk); |
| } |
| memChunk = g_mem_chunk_new("gwtcs data", sizeof(gwtcs_data), |
| 20 * sizeof(gwtcs_data), G_ALLOC_AND_FREE); |
| } |
| |
| /* |
| * Dissect a single packet. |
| */ |
| static int dissect_gwtcs(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) |
| { |
| guint8 packetType; |
| conversation_t* conv; |
| gwtcs_data* data = 0; |
| int isClient = 0; |
| |
| if (tvb_length(tvb) < 1) { |
| return 0; |
| } |
| |
| packetType = tvb_get_guint8(tvb, 0); |
| if (packetType > MAX_PACKET_TYPE) { |
| return 0; |
| } |
| |
| if (check_col(pinfo->cinfo, COL_PROTOCOL)) { |
| col_set_str(pinfo->cinfo, COL_PROTOCOL, "GWT-CS"); |
| } |
| |
| /* Clear the info column */ |
| if (check_col(pinfo->cinfo, COL_INFO)) { |
| col_set_str(pinfo->cinfo, COL_INFO, ""); |
| } |
| |
| /* get the conversation */ |
| conv = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst, |
| pinfo->ptype, pinfo->srcport, pinfo->destport, 0); |
| if (!conv) { |
| conv = conversation_new(pinfo->fd->num, &pinfo->src, &pinfo->dst, |
| pinfo->ptype, pinfo->srcport, pinfo->destport, 0); |
| } |
| data = (gwtcs_data*) conversation_get_proto_data(conv, proto_gwtcs); |
| if (!data) { |
| data = (gwtcs_data*) g_mem_chunk_alloc(memChunk); |
| data->clientPort = -1; |
| data->level = 0; |
| conversation_add_proto_data(conv, proto_gwtcs, data); |
| } |
| |
| if (packetType == MESSAGE_TYPE_CHECK_VERSIONS) { |
| data->clientAddress = pinfo->src; |
| data->clientPort = pinfo->srcport; |
| } |
| |
| if (data->clientPort == pinfo->srcport) { |
| isClient = 1; |
| } |
| |
| /* Set the info column */ |
| if (check_col(pinfo->cinfo,COL_INFO)) { |
| gint32 len; |
| guint8* str; |
| int i; |
| gint32 offset = 1; |
| if (data->clientPort != -1) { |
| col_add_str(pinfo->cinfo, COL_INFO, isClient ? "C->S: " : "S->C: "); |
| } |
| for (i = 0; i < data->level; ++i) { |
| col_append_str(pinfo->cinfo, COL_INFO, " "); |
| } |
| col_append_str(pinfo->cinfo, COL_INFO, packetTypes[packetType].strptr); |
| switch (packetType) { |
| case MESSAGE_TYPE_CHECK_VERSIONS: |
| { |
| int minvers, maxvers; |
| minvers = tvb_get_ntohl(tvb, offset); |
| offset += 4; |
| maxvers = tvb_get_ntohl(tvb, offset); |
| col_append_fstr(pinfo->cinfo, COL_INFO, " vers=%d-%d", minvers, |
| maxvers); |
| } |
| break; |
| case MESSAGE_TYPE_PROTOCOL_VERSION: |
| { |
| int vers; |
| vers = tvb_get_ntohl(tvb, offset); |
| col_append_fstr(pinfo->cinfo, COL_INFO, " vers=%d", vers); |
| } |
| break; |
| case MESSAGE_TYPE_LOAD_MODULE: |
| data->level++; |
| // URL |
| len = tvb_get_ntohl(tvb, offset); |
| offset += 4 + len; |
| // tab key |
| len = tvb_get_ntohl(tvb, offset); |
| offset += 4 + len; |
| // session key |
| len = tvb_get_ntohl(tvb, offset); |
| offset += 4 + len; |
| // module name |
| len = tvb_get_ntohl(tvb, offset); |
| offset += 4; |
| // clip string |
| if (len > MAX_STRING_LENGTH) { |
| len = MAX_STRING_LENGTH; |
| } |
| str = tvb_get_ephemeral_string(tvb, offset, len); |
| col_append_fstr(pinfo->cinfo, COL_INFO, " %s", str); |
| break; |
| case MESSAGE_TYPE_INVOKE: |
| data->level++; |
| if (data->clientPort == -1) { |
| break; |
| } |
| if (isClient) { |
| int dispId; |
| dispId = tvb_get_ntohl(tvb, offset); |
| offset += 4; |
| col_append_fstr(pinfo->cinfo, COL_INFO, " dispid=%d", dispId); |
| } else { |
| // module name |
| len = tvb_get_ntohl(tvb, offset); |
| offset += 4; |
| // clip string |
| if (len > MAX_STRING_LENGTH) { |
| len = MAX_STRING_LENGTH; |
| } |
| str = tvb_get_ephemeral_string(tvb, offset, len); |
| col_append_fstr(pinfo->cinfo, COL_INFO, " %s", str); |
| } |
| break; |
| case MESSAGE_TYPE_RETURN: |
| { |
| char buf[40]; |
| guint8 isexc; |
| data->level--; |
| isexc = tvb_get_guint8(tvb, 1); |
| getValue(tvb, 2, buf, sizeof(buf)); |
| col_append_fstr(pinfo->cinfo, COL_INFO, " %s%s", |
| isexc ? "** EXCEPTION ** " : "", buf); |
| } |
| break; |
| case MESSAGE_TYPE_INVOKESPECIAL: |
| { |
| guint8 specialType; |
| data->level++; |
| specialType = tvb_get_guint8(tvb, 1); |
| col_append_fstr(pinfo->cinfo, COL_INFO, " %s", |
| specialTypes[specialType].strptr); |
| } |
| break; |
| } |
| } |
| |
| /* |
| * If tree is non-null, then we want to get the detailed data. |
| */ |
| if (tree) { |
| proto_item *ti = 0; |
| proto_tree *gwtcs_tree = 0; |
| gint32 offset = 1; |
| |
| ti = proto_tree_add_item(tree, proto_gwtcs, tvb, 0 , -1, FALSE); |
| gwtcs_tree = proto_item_add_subtree(ti, ett_gwtcs); |
| proto_tree_add_item(gwtcs_tree, hf_gwtcs_pdu_type, tvb, 0, 1, FALSE); |
| switch (packetType) { |
| case MESSAGE_TYPE_CHECK_VERSIONS: |
| proto_tree_add_item(gwtcs_tree, hf_gwtcs_min_vers, tvb, 1, 4, FALSE); |
| proto_tree_add_item(gwtcs_tree, hf_gwtcs_max_vers, tvb, 5, 4, FALSE); |
| proto_tree_add_item(gwtcs_tree, hf_gwtcs_hosted_vers, tvb, 9, 4, FALSE); |
| break; |
| case MESSAGE_TYPE_PROTOCOL_VERSION: |
| proto_tree_add_item(gwtcs_tree, hf_gwtcs_sel_vers, tvb, 1, 4, FALSE); |
| break; |
| case MESSAGE_TYPE_LOAD_MODULE: |
| { |
| guint32 len; |
| len = tvb_get_ntohl(tvb, offset); |
| proto_tree_add_item(gwtcs_tree, hf_gwtcs_lm_url, tvb, offset, 4, |
| FALSE); |
| offset += 4 + len; |
| len = tvb_get_ntohl(tvb, offset); |
| proto_tree_add_item(gwtcs_tree, hf_gwtcs_lm_tabkey, tvb, offset, 4, |
| FALSE); |
| offset += 4 + len; |
| len = tvb_get_ntohl(tvb, offset); |
| proto_tree_add_item(gwtcs_tree, hf_gwtcs_lm_seskey, tvb, offset, 4, |
| FALSE); |
| offset += 4 + len; |
| len = tvb_get_ntohl(tvb, offset); |
| proto_tree_add_item(gwtcs_tree, hf_gwtcs_lm_modname, tvb, offset, 4, |
| FALSE); |
| offset += 4 + len; |
| len = tvb_get_ntohl(tvb, offset); |
| proto_tree_add_item(gwtcs_tree, hf_gwtcs_lm_ua, tvb, offset, 4, |
| FALSE); |
| offset += 4 + len; |
| } |
| break; |
| case MESSAGE_TYPE_INVOKE: |
| { |
| int numArgs, len, i; |
| proto_item* ti; |
| proto_tree* subtree; |
| if (data->clientPort == -1) { |
| proto_tree_add_text(gwtcs_tree, tvb, 1, -1, |
| "Can't decode - unknown direction"); |
| break; |
| } |
| if (isClient) { |
| proto_tree_add_item(gwtcs_tree, hf_gwtcs_dispid, tvb, offset, 4, |
| FALSE); |
| offset += 4; |
| } else { |
| // method name |
| len = tvb_get_ntohl(tvb, offset); |
| proto_tree_add_item(gwtcs_tree, hf_gwtcs_methname, tvb, offset, 4, |
| FALSE); |
| offset += 4 + len; |
| } |
| offset = showValue(gwtcs_tree, "This Value", tvb, offset); |
| numArgs = tvb_get_ntohl(tvb, offset); |
| ti = proto_tree_add_item(gwtcs_tree, hf_gwtcs_numargs, tvb, offset, 4, |
| FALSE); |
| subtree = proto_item_add_subtree(ti, ett_args); |
| offset += 4; |
| for (i = 0; i < numArgs; ++i) { |
| char argName[10]; |
| snprintf(argName, sizeof(argName), "arg%d", i); |
| offset = showValue(subtree, argName, tvb, offset); |
| } |
| } |
| break; |
| case MESSAGE_TYPE_RETURN: |
| proto_tree_add_item(gwtcs_tree, hf_gwtcs_isexc, tvb, 1, 1, FALSE); |
| showValue(gwtcs_tree, "Return Value", tvb, 2); |
| break; |
| case MESSAGE_TYPE_LOADJSNI: |
| proto_tree_add_item(gwtcs_tree, hf_gwtcs_jsni, tvb, 1, 4, FALSE); |
| break; |
| case MESSAGE_TYPE_INVOKESPECIAL: |
| { |
| int numArgs, i; |
| proto_item* ti; |
| proto_tree* subtree; |
| proto_tree_add_item(gwtcs_tree, hf_gwtcs_spectype, tvb, offset++, 1, |
| FALSE); |
| numArgs = tvb_get_ntohl(tvb, offset); |
| ti = proto_tree_add_item(gwtcs_tree, hf_gwtcs_numargs, tvb, offset, 4, |
| FALSE); |
| offset += 4; |
| subtree = proto_item_add_subtree(ti, ett_args); |
| for (i = 0; i < numArgs; ++i) { |
| char argName[10]; |
| snprintf(argName, sizeof(argName), "arg%d", i); |
| offset = showValue(subtree, argName, tvb, offset); |
| } |
| } |
| break; |
| case MESSAGE_TYPE_FREEVALUE: |
| { |
| int numArgs, i, label; |
| proto_item* ti; |
| proto_tree* subtree; |
| numArgs = tvb_get_ntohl(tvb, offset); |
| ti = proto_tree_add_item(gwtcs_tree, hf_gwtcs_numargs, tvb, offset, 4, |
| FALSE); |
| offset += 4; |
| subtree = proto_item_add_subtree(ti, ett_args); |
| label = isClient ? hf_gwtcs_val_jsobj : hf_gwtcs_val_javaobj; |
| for (i = 0; i < numArgs; ++i) { |
| proto_tree_add_item(subtree, label, tvb, offset, 4, FALSE); |
| offset += 4; |
| } |
| } |
| break; |
| case MESSAGE_TYPE_CHOOSE_TRANSPORT: |
| { |
| int numArgs, i, len; |
| proto_item* ti; |
| proto_tree* subtree; |
| numArgs = tvb_get_ntohl(tvb, offset); |
| ti = proto_tree_add_item(gwtcs_tree, hf_gwtcs_numargs, tvb, offset, 4, |
| FALSE); |
| offset += 4; |
| subtree = proto_item_add_subtree(ti, ett_args); |
| for (i = 0; i < numArgs; ++i) { |
| len = tvb_get_ntohl(tvb, offset); |
| proto_tree_add_item(subtree, hf_gwtcs_transport, tvb, offset, 4, |
| FALSE); |
| offset += 4 + len; |
| } |
| } |
| break; |
| case MESSAGE_TYPE_SWITCH_TRANSPORT: |
| { |
| int len; |
| len = tvb_get_ntohl(tvb, offset); |
| proto_tree_add_item(gwtcs_tree, hf_gwtcs_transport, tvb, offset, 4, |
| FALSE); |
| offset += 4 + len; |
| len = tvb_get_ntohl(tvb, offset); |
| proto_tree_add_item(gwtcs_tree, hf_gwtcs_transargs, tvb, offset, 4, |
| FALSE); |
| offset += 4 + len; |
| } |
| break; |
| } |
| } |
| |
| return tvb_length(tvb); |
| } |
| |
| void proto_register_gwtcs(void) |
| { |
| /* |
| * List of subtree identifiers to be allocated. |
| */ |
| static gint *ett[] = { |
| &ett_gwtcs, |
| &ett_value, |
| &ett_args, |
| }; |
| |
| /* |
| * List of display identifiers to be allocated. |
| */ |
| static hf_register_info hf[] = { |
| { |
| &hf_gwtcs_pdu_type, |
| { |
| "Packet Type", "gwtcs.type", |
| FT_UINT8, BASE_DEC, VALS(packetTypes), 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_spectype, |
| { |
| "Type", "gwtcs.spectype", |
| FT_UINT8, BASE_DEC, VALS(specialTypes), 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_value_tag, |
| { |
| "Value Tag", "gwtcs.value.tag", |
| FT_UINT8, BASE_DEC, VALS(valueTypes), 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_min_vers, |
| { |
| "Minimum version", "gwtcs.minvers", |
| FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_max_vers, |
| { |
| "Maximum version", "gwtcs.maxvers", |
| FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_hosted_vers, |
| { |
| "hosted.html version", "gwtcs.hostedvers", |
| FT_UINT_STRING, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_sel_vers, |
| { |
| "Selected version", "gwtcs.selvers", |
| FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_lm_url, |
| { |
| "URL", "gwtcs.lm.url", |
| FT_UINT_STRING, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_lm_modname, |
| { |
| "Module Name", "gwtcs.lm.modname", |
| FT_UINT_STRING, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_lm_tabkey, |
| { |
| "Tab Key", "gwtcs.lm.tabkey", |
| FT_UINT_STRING, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_lm_seskey, |
| { |
| "Session Key", "gwtcs.lm.seskey", |
| FT_UINT_STRING, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_lm_ua, |
| { |
| "User Agent", "gwtcs.lm.ua", |
| FT_UINT_STRING, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_methname, |
| { |
| "Method Name", "gwtcs.lm.methname", |
| FT_UINT_STRING, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_isexc, |
| { |
| "Is Exception", "gwtcs.isexc", |
| FT_BOOLEAN, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_dispid, |
| { |
| "Dispatch ID", "gwtcs.dispid", |
| FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_jsni, |
| { |
| "JSNI Source", "gwtcs.jsni", |
| FT_UINT_STRING, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_val_hdr, |
| { |
| "Value", "gwtcs.val.hdr", |
| FT_STRINGZ, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_numargs, |
| { |
| "# of Arguments", "gwtcs.val.numargs", |
| FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_val_null, |
| { |
| "Null Value", "gwtcs.val.null", |
| FT_NONE, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_val_undef, |
| { |
| "Undef Value", "gwtcs.val.undef", |
| FT_NONE, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_val_bool, |
| { |
| "Boolean Value", "gwtcs.val.bool", |
| FT_BOOLEAN, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_val_byte, |
| { |
| "Byte Value", "gwtcs.val.byte", |
| FT_INT8, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_val_char, |
| { |
| "Char Value", "gwtcs.val.char", |
| FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_val_short, |
| { |
| "Short Value", "gwtcs.val.short", |
| FT_INT16, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_val_int, |
| { |
| "Int Value", "gwtcs.val.int", |
| FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_val_long, |
| { |
| "Long Value", "gwtcs.val.long", |
| FT_INT64, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_val_float, |
| { |
| "Float Value", "gwtcs.val.float", |
| FT_FLOAT, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_val_double, |
| { |
| "Double Value", "gwtcs.val.double", |
| FT_DOUBLE, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_val_javaobj, |
| { |
| "Java Object Id", "gwtcs.val.javaobj", |
| FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_val_jsobj, |
| { |
| "JS Object Id", "gwtcs.val.jsobj", |
| FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_val_string, |
| { |
| "String Value", "gwtcs.val.string", |
| FT_UINT_STRING, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_transport, |
| { |
| "Transport Name", "gwtcs.transport", |
| FT_UINT_STRING, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| { |
| &hf_gwtcs_transargs, |
| { |
| "Transport Args", "gwtcs.transargs", |
| FT_UINT_STRING, BASE_DEC, NULL, 0x0, NULL, HFILL, |
| } |
| }, |
| }; |
| |
| if (proto_gwtcs == -1) |
| { |
| register_init_routine(&init); |
| proto_gwtcs = proto_register_protocol ( |
| "GWT Code Server Protocol", /* name */ |
| "GWT-CS", /* short name */ |
| "gwtcs" /* abbrev */ |
| ); |
| |
| proto_register_field_array(proto_gwtcs, hf, array_length(hf)); |
| proto_register_subtree_array(ett, array_length(ett)); |
| } |
| } |
| |
| void proto_reg_handoff_gwtcs(void) |
| { |
| static int Initialized=FALSE; |
| |
| /* register with wireshark to dissect tdp packets on port 9997 */ |
| if (!Initialized) { |
| gwtcs_handle = new_create_dissector_handle(dissect_gwtcs, proto_gwtcs); |
| dissector_add("tcp.port", DEFAULT_GWTCS_PORT, gwtcs_handle); |
| Initialized = TRUE; |
| } |
| } |
