/* Parses a ts2 player list (TS2T_PLAYERLIST) and adds it to the tree */ static void ts2_parse_playerlist(tvbuff_t *tvb, proto_tree *ts2_tree) { gint32 offset; gint32 number_of_players; gint32 x; offset=0; x=0; proto_tree_add_item(ts2_tree, hf_ts2_number_of_players, tvb, offset, 4, ENC_LITTLE_ENDIAN); number_of_players = tvb_get_letohl(tvb, 0); offset+=4; while(offset<tvb_length_remaining(tvb, 0) && x<number_of_players) { proto_tree_add_item(ts2_tree, hf_ts2_player_id, tvb, offset, 4, ENC_LITTLE_ENDIAN); offset+=4; proto_tree_add_item(ts2_tree, hf_ts2_channel_id, tvb, offset, 4, ENC_LITTLE_ENDIAN); offset+=4; proto_tree_add_item(ts2_tree, hf_ts2_unknown, tvb, offset, 4, ENC_NA); offset+=4; proto_tree_add_item(ts2_tree, hf_ts2_player_status_flags, tvb, offset, 2, ENC_LITTLE_ENDIAN); ts2_add_statusflags(tvb, ts2_tree, offset); offset+=2; proto_tree_add_item(ts2_tree, hf_ts2_nick, tvb, offset, 1, ENC_ASCII|ENC_NA); offset+=30; x++; } proto_tree_add_item(ts2_tree, hf_ts2_emptyspace, tvb, offset, tvb_length_remaining(tvb, 0), ENC_NA); }
guint32 getExtensionObjectType(tvbuff_t *tvb, gint *pOffset) { gint iOffset = *pOffset; guint8 EncodingMask; guint32 Numeric = 0; EncodingMask = tvb_get_guint8(tvb, iOffset); iOffset++; switch(EncodingMask) { case 0x00: /* two byte node id */ Numeric = tvb_get_guint8(tvb, iOffset); /*iOffset+=1;*/ break; case 0x01: /* four byte node id */ iOffset+=1; Numeric = tvb_get_letohs(tvb, iOffset); break; case 0x02: /* numeric, that does not fit into four bytes */ iOffset+=4; Numeric = tvb_get_letohl(tvb, iOffset); break; case 0x03: /* string */ case 0x04: /* uri */ case 0x05: /* guid */ case 0x06: /* byte string */ /* NOT USED */ break; }; return Numeric; }
/* * get a Lilliputian signed 64 bit integer from a tvb */ WSLUA_METHOD TvbRange_le_int64(lua_State* L) { /* Get a Little Endian signed 64 bit integer from a `TvbRange`, as an `Int64` object. The range must be 1, 2, 4 or 8 octets long. */ TvbRange tvbr = checkTvbRange(L,1); if (!(tvbr && tvbr->tvb)) return 0; if (tvbr->tvb->expired) { luaL_error(L,"expired tvb"); return 0; } switch (tvbr->len) { case 1: pushInt64(L,(gint8)tvb_get_guint8(tvbr->tvb->ws_tvb,tvbr->offset)); return 1; case 2: pushInt64(L,(gint16)tvb_get_letohs(tvbr->tvb->ws_tvb,tvbr->offset)); return 1; case 4: pushInt64(L,(gint32)tvb_get_letohl(tvbr->tvb->ws_tvb,tvbr->offset)); return 1; case 8: pushInt64(L,(gint64)tvb_get_letoh64(tvbr->tvb->ws_tvb,tvbr->offset)); WSLUA_RETURN(1); /* The `Int64` object. */ default: luaL_error(L,"TvbRange:le_int64() does not handle %d byte integers",tvbr->len); return 0; } }
/** General parsing function for arrays of enums. * All arrays have one 4 byte signed integer length information, * followed by n data elements. */ void parseArrayEnum(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, fctEnumParser pParserFunction) { static const char szFieldName[] = "Array of Enum Type"; proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s", szFieldName); proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_array); int i; gint32 iLen; /* read array length */ iLen = tvb_get_letohl(tvb, *pOffset); proto_tree_add_item(subtree, hf_opcua_ArraySize, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); if (iLen > MAX_ARRAY_LEN) { proto_item *pi; pi = proto_tree_add_text(tree, tvb, *pOffset, 4, "Array length %d too large to process", iLen); PROTO_ITEM_SET_GENERATED(pi); return; } *pOffset += 4; for (i=0; i<iLen; i++) { (*pParserFunction)(subtree, tvb, pOffset); } proto_item_set_end(ti, tvb, *pOffset); }
/** General parsing function for arrays of complex types. * All arrays have one 4 byte signed integer length information, * followed by n data elements. */ void parseArrayComplex(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName, fctComplexTypeParser pParserFunction) { proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "Array of %s", szFieldName); proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_array); int i; gint32 iLen; /* read array length */ iLen = tvb_get_letohl(tvb, *pOffset); proto_tree_add_item(subtree, hf_opcua_ArraySize, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); if (iLen > MAX_ARRAY_LEN) { proto_item *pi; pi = proto_tree_add_text(tree, tvb, *pOffset, 4, "Array length %d too large to process", iLen); PROTO_ITEM_SET_GENERATED(pi); return; } *pOffset += 4; for (i=0; i<iLen; i++) { char szNum[20]; g_snprintf(szNum, 20, "[%i]", i); (*pParserFunction)(subtree, tvb, pOffset, szNum); } proto_item_set_end(ti, tvb, *pOffset); }
static void dissect_election_criterion(tvbuff_t *tvb, proto_tree *parent_tree, int offset) { proto_tree *tree = NULL; proto_item *item = NULL; guint32 criterion; criterion = tvb_get_letohl(tvb, offset); if (parent_tree) { item = proto_tree_add_uint(parent_tree, hf_election_criteria, tvb, offset, 4, criterion); tree = proto_item_add_subtree(item, ett_browse_election_criteria); } /* election desire */ dissect_election_criterion_desire(tvb, tree, offset); offset += 1; /* browser protocol major version */ proto_tree_add_item(tree, hf_proto_major, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset += 1; /* browser protocol minor version */ proto_tree_add_item(tree, hf_proto_minor, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset += 1; /* election os */ dissect_election_criterion_os(tvb, tree, offset); }
void parseByteString(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, int hfIndex) { char *szValue; int iOffset = *pOffset; gint32 iLen = tvb_get_letohl(tvb, iOffset); iOffset += 4; if (iLen == -1) { proto_item *item = proto_tree_add_item(tree, hfIndex, tvb, *pOffset, 0, ENC_NA); proto_item_append_text(item, "[OpcUa Null ByteString]"); proto_item_set_end(item, tvb, *pOffset + 4); } else if (iLen == 0) { proto_item *item = proto_tree_add_item(tree, hfIndex, tvb, *pOffset, 0, ENC_NA); proto_item_append_text(item, "[OpcUa Empty ByteString]"); proto_item_set_end(item, tvb, *pOffset + 4); } else if (iLen > 0) { proto_tree_add_item(tree, hfIndex, tvb, iOffset, iLen, ENC_NA); iOffset += iLen; /* eat the whole bytestring */ } else { proto_item *item = proto_tree_add_item(tree, hfIndex, tvb, *pOffset, 0, ENC_NA); szValue = wmem_strdup_printf(wmem_packet_scope(), "[Invalid ByteString] Invalid length: %d", iLen); proto_item_append_text(item, "%s", szValue); proto_item_set_end(item, tvb, *pOffset + 4); } *pOffset = iOffset; }
static int dissect_mongo_reply(tvbuff_t *tvb, guint offset, proto_tree *tree) { proto_item *ti; proto_tree *flags_tree; gint i, number_returned; ti = proto_tree_add_item(tree, hf_mongo_reply_flags, tvb, offset, 4, ENC_NA); flags_tree = proto_item_add_subtree(ti, ett_mongo_flags); proto_tree_add_item(flags_tree, hf_mongo_reply_flags_cursornotfound, tvb, offset, 4, ENC_LITTLE_ENDIAN); proto_tree_add_item(flags_tree, hf_mongo_reply_flags_queryfailure, tvb, offset, 4, ENC_LITTLE_ENDIAN); proto_tree_add_item(flags_tree, hf_mongo_reply_flags_sharedconfigstale, tvb, offset, 4, ENC_LITTLE_ENDIAN); proto_tree_add_item(flags_tree, hf_mongo_reply_flags_awaitcapable, tvb, offset, 4, ENC_LITTLE_ENDIAN); offset += 4; proto_tree_add_item(tree, hf_mongo_cursor_id, tvb, offset, 8, ENC_LITTLE_ENDIAN); offset += 8; proto_tree_add_item(tree, hf_mongo_starting_from, tvb, offset, 4, ENC_LITTLE_ENDIAN); offset += 4; proto_tree_add_item(tree, hf_mongo_number_returned, tvb, offset, 4, ENC_LITTLE_ENDIAN); number_returned = tvb_get_letohl(tvb, offset); offset += 4; for (i=1; i <= number_returned; i++) { offset += dissect_bson_document(tvb, offset, tree, hf_mongo_documents); } return offset; }
/* this tree keeps track of CONTROL request/responses */ static emem_tree_t *ctdb_controls=NULL; typedef struct _ctdb_control_t { guint32 opcode; guint32 request_in; guint32 response_in; nstime_t req_time; } ctdb_control_t; #define CTDB_REQ_CALL 0 #define CTDB_REPLY_CALL 1 #define CTDB_REQ_DMASTER 2 #define CTDB_REPLY_DMASTER 3 #define CTDB_REPLY_ERROR 4 #define CTDB_REQ_MESSAGE 5 #define CTDB_REQ_CONTROL 7 #define CTDB_REPLY_CONTROL 8 #define CTDB_REQ_KEEPALIVE 9 static const value_string ctdb_opcodes[] = { {CTDB_REQ_CALL, "REQ_CALL"}, {CTDB_REPLY_CALL, "REPLY_CALL"}, {CTDB_REQ_DMASTER, "REQ_DMASTER"}, {CTDB_REPLY_DMASTER, "REPLY_DMASTER"}, {CTDB_REPLY_ERROR, "REPLY_ERROR"}, {CTDB_REQ_MESSAGE, "REQ_MESSAGE"}, {CTDB_REQ_CONTROL, "REQ_CONTROL"}, {CTDB_REPLY_CONTROL, "REPLY_CONTROL"}, {CTDB_REQ_KEEPALIVE, "REQ_KEEPALIVE"}, {0,NULL} }; #define CTDB_CONTROL_PROCESS_EXISTS 0 #define CTDB_CONTROL_STATISTICS 1 #define CTDB_CONTROL_CONFIG 2 #define CTDB_CONTROL_PING 3 #define CTDB_CONTROL_GETDBPATH 4 #define CTDB_CONTROL_GETVNNMAP 5 #define CTDB_CONTROL_SETVNNMAP 6 #define CTDB_CONTROL_GET_DEBUG 7 #define CTDB_CONTROL_SET_DEBUG 8 #define CTDB_CONTROL_GET_DBMAP 9 #define CTDB_CONTROL_GET_NODEMAP 10 #define CTDB_CONTROL_SET_DMASTER 11 #define CTDB_CONTROL_CLEAR_DB 12 #define CTDB_CONTROL_PULL_DB 13 #define CTDB_CONTROL_PUSH_DB 14 #define CTDB_CONTROL_GET_RECMODE 15 #define CTDB_CONTROL_SET_RECMODE 16 #define CTDB_CONTROL_STATISTICS_RESET 17 #define CTDB_CONTROL_DB_ATTACH 18 #define CTDB_CONTROL_SET_CALL 19 #define CTDB_CONTROL_TRAVERSE_START 20 #define CTDB_CONTROL_TRAVERSE_ALL 21 #define CTDB_CONTROL_TRAVERSE_DATA 22 #define CTDB_CONTROL_REGISTER_SRVID 23 #define CTDB_CONTROL_DEREGISTER_SRVID 24 #define CTDB_CONTROL_GET_DBNAME 25 #define CTDB_CONTROL_ENABLE_SEQNUM 26 #define CTDB_CONTROL_UPDATE_SEQNUM 27 #define CTDB_CONTROL_SET_SEQNUM_FREQUENCY 28 #define CTDB_CONTROL_DUMP_MEMORY 29 #define CTDB_CONTROL_GET_PID 30 #define CTDB_CONTROL_GET_RECMASTER 31 #define CTDB_CONTROL_SET_RECMASTER 32 #define CTDB_CONTROL_FREEZE 33 #define CTDB_CONTROL_THAW 34 #define CTDB_CONTROL_GET_VNN 35 #define CTDB_CONTROL_SHUTDOWN 36 #define CTDB_CONTROL_GET_MONMODE 37 #define CTDB_CONTROL_SET_MONMODE 38 #define CTDB_CONTROL_MAX_RSN 39 #define CTDB_CONTROL_SET_RSN_NONEMPTY 40 #define CTDB_CONTROL_DELETE_LOW_RSN 41 #define CTDB_CONTROL_TAKEOVER_IP 42 #define CTDB_CONTROL_RELEASE_IP 43 #define CTDB_CONTROL_TCP_CLIENT 44 #define CTDB_CONTROL_TCP_ADD 45 #define CTDB_CONTROL_TCP_REMOVE 46 #define CTDB_CONTROL_STARTUP 47 #define CTDB_CONTROL_SET_TUNABLE 48 #define CTDB_CONTROL_GET_TUNABLE 49 #define CTDB_CONTROL_LIST_TUNABLES 50 #define CTDB_CONTROL_GET_PUBLIC_IPS 51 #define CTDB_CONTROL_MODIFY_FLAGS 52 #define CTDB_CONTROL_GET_ALL_TUNABLES 53 #define CTDB_CONTROL_KILL_TCP 54 #define CTDB_CONTROL_GET_TCP_TICKLE_LIST 55 #define CTDB_CONTROL_SET_TCP_TICKLE_LIST 56 #define CTDB_CONTROL_REGISTER_SERVER_ID 57 #define CTDB_CONTROL_UNREGISTER_SERVER_ID 58 #define CTDB_CONTROL_CHECK_SERVER_ID 59 #define CTDB_CONTROL_GET_SERVER_ID_LIST 60 #define CTDB_CONTROL_DB_ATTACH_PERSISTENT 61 #define CTDB_CONTROL_PERSISTENT_STORE 62 #define CTDB_CONTROL_UPDATE_RECORD 63 static const value_string ctrl_opcode_vals[] = { {CTDB_CONTROL_PROCESS_EXISTS, "PROCESS_EXISTS"}, {CTDB_CONTROL_STATISTICS, "STATISTICS"}, {CTDB_CONTROL_CONFIG, "CONFIG"}, {CTDB_CONTROL_PING, "PING"}, {CTDB_CONTROL_GETDBPATH, "GETDBPATH"}, {CTDB_CONTROL_GETVNNMAP, "GETVNNMAP"}, {CTDB_CONTROL_SETVNNMAP, "SETVNNMAP"}, {CTDB_CONTROL_GET_DEBUG, "GET_DEBUG"}, {CTDB_CONTROL_SET_DEBUG, "SET_DEBUG"}, {CTDB_CONTROL_GET_DBMAP, "GET_DBMAP"}, {CTDB_CONTROL_GET_NODEMAP, "GET_NODEMAP"}, {CTDB_CONTROL_SET_DMASTER, "SET_DMASTER"}, {CTDB_CONTROL_CLEAR_DB, "CLEAR_DB"}, {CTDB_CONTROL_PULL_DB, "PULL_DB"}, {CTDB_CONTROL_PUSH_DB, "PUSH_DB"}, {CTDB_CONTROL_GET_RECMODE, "GET_RECMODE"}, {CTDB_CONTROL_SET_RECMODE, "SET_RECMODE"}, {CTDB_CONTROL_STATISTICS_RESET, "STATISTICS_RESET"}, {CTDB_CONTROL_DB_ATTACH, "DB_ATTACH"}, {CTDB_CONTROL_SET_CALL, "SET_CALL"}, {CTDB_CONTROL_TRAVERSE_START, "TRAVERSE_START"}, {CTDB_CONTROL_TRAVERSE_ALL, "TRAVERSE_ALL"}, {CTDB_CONTROL_TRAVERSE_DATA, "TRAVERSE_DATA"}, {CTDB_CONTROL_REGISTER_SRVID, "REGISTER_SRVID"}, {CTDB_CONTROL_DEREGISTER_SRVID, "DEREGISTER_SRVID"}, {CTDB_CONTROL_GET_DBNAME, "GET_DBNAME"}, {CTDB_CONTROL_ENABLE_SEQNUM, "ENABLE_SEQNUM"}, {CTDB_CONTROL_UPDATE_SEQNUM, "UPDATE_SEQNUM"}, {CTDB_CONTROL_SET_SEQNUM_FREQUENCY, "SET_SEQNUM_FREQUENCY"}, {CTDB_CONTROL_DUMP_MEMORY, "DUMP_MEMORY"}, {CTDB_CONTROL_GET_PID, "GET_PID"}, {CTDB_CONTROL_GET_RECMASTER, "GET_RECMASTER"}, {CTDB_CONTROL_SET_RECMASTER, "SET_RECMASTER"}, {CTDB_CONTROL_FREEZE, "FREEZE"}, {CTDB_CONTROL_THAW, "THAW"}, {CTDB_CONTROL_GET_VNN, "GET_VNN"}, {CTDB_CONTROL_SHUTDOWN, "SHUTDOWN"}, {CTDB_CONTROL_GET_MONMODE, "GET_MONMODE"}, {CTDB_CONTROL_SET_MONMODE, "SET_MONMODE"}, {CTDB_CONTROL_MAX_RSN, "MAX_RSN"}, {CTDB_CONTROL_SET_RSN_NONEMPTY, "SET_RSN_NONEMPTY"}, {CTDB_CONTROL_DELETE_LOW_RSN, "DELETE_LOW_RSN"}, {CTDB_CONTROL_TAKEOVER_IP, "TAKEOVER_IP"}, {CTDB_CONTROL_RELEASE_IP, "RELEASE_IP"}, {CTDB_CONTROL_TCP_CLIENT, "TCP_CLIENT"}, {CTDB_CONTROL_TCP_ADD, "TCP_ADD"}, {CTDB_CONTROL_TCP_REMOVE, "TCP_REMOVE"}, {CTDB_CONTROL_STARTUP, "STARTUP"}, {CTDB_CONTROL_SET_TUNABLE, "SET_TUNABLE"}, {CTDB_CONTROL_GET_TUNABLE, "GET_TUNABLE"}, {CTDB_CONTROL_LIST_TUNABLES, "LIST_TUNABLES"}, {CTDB_CONTROL_GET_PUBLIC_IPS, "GET_PUBLIC_IPS"}, {CTDB_CONTROL_MODIFY_FLAGS, "MODIFY_FLAGS"}, {CTDB_CONTROL_GET_ALL_TUNABLES, "GET_ALL_TUNABLES"}, {CTDB_CONTROL_KILL_TCP, "KILL_TCP"}, {CTDB_CONTROL_GET_TCP_TICKLE_LIST, "GET_TCP_TICKLE_LIST"}, {CTDB_CONTROL_SET_TCP_TICKLE_LIST, "SET_TCP_TICKLE_LIST"}, {CTDB_CONTROL_REGISTER_SERVER_ID, "REGISTER_SERVER_ID"}, {CTDB_CONTROL_UNREGISTER_SERVER_ID, "UNREGISTER_SERVER_ID"}, {CTDB_CONTROL_CHECK_SERVER_ID, "CHECK_SERVER_ID"}, {CTDB_CONTROL_GET_SERVER_ID_LIST, "GET_SERVER_ID_LIST"}, {CTDB_CONTROL_DB_ATTACH_PERSISTENT, "DB_ATTACH_PERSISTENT"}, {CTDB_CONTROL_PERSISTENT_STORE, "PERSISTENT_STORE"}, {CTDB_CONTROL_UPDATE_RECORD, "UPDATE_RECORD"}, {0, NULL} }; static int dissect_control_get_recmaster_reply(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb, int offset, guint32 status, int endianess _U_) { proto_tree_add_uint(tree, hf_ctdb_recmaster, tvb, 0, 0, status); col_append_fstr(pinfo->cinfo, COL_INFO, " RecMaster:%d", status); return offset; } static const value_string recmode_vals[] = { {0,"NORMAL"}, {1,"RECOVERY ACTIVE"}, {0,NULL} }; static int dissect_control_get_recmode_reply(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb, int offset, guint32 status, int endianess _U_) { proto_tree_add_uint(tree, hf_ctdb_recmode, tvb, 0, 0, status); col_append_fstr(pinfo->cinfo, COL_INFO, " RecMode:%s", val_to_str(status, recmode_vals, "Unknown:%d")); return offset; } #define CTDB_MAX_NODES 500 /* Arbitrary. */ static int dissect_control_get_nodemap_reply(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb, int offset, guint32 status _U_, int endianess) { guint32 num_nodes; proto_item *item; /* num nodes */ item = proto_tree_add_item(tree, hf_ctdb_num_nodes, tvb, offset, 4, endianess); if(endianess){ num_nodes=tvb_get_letohl(tvb, offset); } else { num_nodes=tvb_get_ntohl(tvb, offset); } offset+=4; if (num_nodes > CTDB_MAX_NODES) { expert_add_info_format(pinfo, item, PI_UNDECODED, PI_WARN, "Too many nodes (%u). Stopping dissection.", num_nodes); THROW(ReportedBoundsError); } while(num_nodes--){ /* vnn */ proto_tree_add_item(tree, hf_ctdb_vnn, tvb, offset, 4, endianess); offset+=4; /* node flags */ proto_tree_add_item(tree, hf_ctdb_node_flags, tvb, offset, 4, endianess); offset+=4; /* here comes a sockaddr_in but we only store ipv4 addresses in it */ proto_tree_add_item(tree, hf_ctdb_node_ip, tvb, offset+4, 4, ENC_BIG_ENDIAN); offset+=16; } return offset; }
static int dissect_dtpt_wstring(tvbuff_t *tvb, guint offset, proto_tree *tree, int hfindex) { guint32 wstring_length; guint32 wstring_size; char *wstring_data = NULL; guint32 wstring_padding = 0; wstring_length = tvb_get_letohl(tvb, offset); wstring_data = tvb_get_string_enc(wmem_packet_scope(), tvb, offset+4, wstring_length, ENC_UTF_16|ENC_LITTLE_ENDIAN); wstring_size = wstring_length; if (wstring_size%4) { wstring_padding = (4-wstring_size%4); wstring_size += wstring_padding; } if (tree) { proto_item *dtpt_wstring_item; proto_tree *dtpt_wstring_tree; dtpt_wstring_item = proto_tree_add_string(tree, hfindex, tvb, offset+0, 4+wstring_size, wstring_data); dtpt_wstring_tree = proto_item_add_subtree(dtpt_wstring_item, ett_dtpt_wstring); if (dtpt_wstring_tree) { proto_tree_add_uint(dtpt_wstring_tree, hf_dtpt_wstring_length, tvb, offset+0, 4, wstring_length); if (wstring_length) proto_tree_add_string(dtpt_wstring_tree, hf_dtpt_wstring_data, tvb, offset+4, wstring_length, wstring_data); if (wstring_padding) proto_tree_add_item(dtpt_wstring_tree, hf_dtpt_padding, tvb, offset+4+wstring_length,wstring_padding, ENC_NA); } } offset += 4+wstring_size; return offset; }
static void dissect_nsimulator(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { guint32 signature; tvbuff_t *payload_tvb; proto_item *ns_tree = NULL; proto_item *ns_subtree = NULL; if (tvb_captured_length(tvb) > 4) { signature = tvb_get_letohl(tvb, 0); if ( signature == 0xFF77DE02 || signature == 0xFF77DE82 ) { col_set_str(pinfo->cinfo, COL_PROTOCOL, "Network Simulator"); if (tree) { ns_tree = proto_tree_add_item(tree, proto_nsimulator, tvb, 0, 4, ENC_NA); ns_subtree = proto_item_add_subtree(ns_tree, ett_nsimulator); proto_tree_add_item(ns_subtree, hf_nsimulator_dir, tvb, 0, sizeof(guint8), ENC_LITTLE_ENDIAN); proto_tree_add_item(ns_subtree, hf_nsimulator_sig, tvb, 1, 3 * sizeof(guint8), ENC_LITTLE_ENDIAN); } payload_tvb = tvb_new_subset(tvb, 4, -1, tvb_reported_length(tvb) - 4); TRY { call_dissector(wpan_handle, payload_tvb, pinfo, tree); } CATCH_ALL { show_exception(payload_tvb, pinfo, tree, EXCEPT_CODE, GET_MESSAGE); } ENDTRY; } else {
static int dissect_account_control(tvbuff_t *tvb, proto_tree *tree, int offset) { /* display the Allowable Account control bits */ proto_item *ti = NULL; proto_tree *flags_tree = NULL; guint32 flags; flags = tvb_get_letohl(tvb, offset); if (tree) { ti = proto_tree_add_text(tree, tvb, offset, 4, "Account control = 0x%04x", flags); flags_tree = proto_item_add_subtree(ti, ett_smb_account_flags); } proto_tree_add_boolean(flags_tree, hf_flags_autolock, tvb, offset, 4, flags); proto_tree_add_boolean(flags_tree, hf_flags_expire, tvb, offset, 4, flags); proto_tree_add_boolean(flags_tree, hf_flags_server_trust, tvb, offset, 4, flags); proto_tree_add_boolean(flags_tree, hf_flags_workstation_trust, tvb, offset, 4, flags); proto_tree_add_boolean(flags_tree, hf_flags_interdomain_trust, tvb, offset, 4, flags); proto_tree_add_boolean(flags_tree, hf_flags_mns_user, tvb, offset, 4, flags); proto_tree_add_boolean(flags_tree, hf_flags_normal_user, tvb, offset, 4, flags); proto_tree_add_boolean(flags_tree, hf_flags_temp_dup_user, tvb, offset, 4, flags); proto_tree_add_boolean(flags_tree, hf_flags_password_required, tvb, offset, 4, flags); proto_tree_add_boolean(flags_tree, hf_flags_homedir_required, tvb, offset, 4, flags); proto_tree_add_boolean(flags_tree, hf_flags_enabled, tvb, offset, 4, flags); offset += 4; return offset; }
/* * get a Lilliputian unsigned integer from a tvb */ WSLUA_METHOD TvbRange_le_uint(lua_State* L) { /* Get a Little Endian unsigned integer from a TvbRange. The range must be 1, 2, 3 or 4 octets long. */ TvbRange tvbr = checkTvbRange(L,1); if (!(tvbr && tvbr->tvb)) return 0; if (tvbr->tvb->expired) { luaL_error(L,"expired tvb"); return 0; } switch (tvbr->len) { case 1: /* XXX unsigned anyway */ lua_pushnumber(L,(lua_Number)(guint)tvb_get_guint8(tvbr->tvb->ws_tvb,tvbr->offset)); return 1; case 2: lua_pushnumber(L,tvb_get_letohs(tvbr->tvb->ws_tvb,tvbr->offset)); return 1; case 3: lua_pushnumber(L,tvb_get_letoh24(tvbr->tvb->ws_tvb,tvbr->offset)); return 1; case 4: lua_pushnumber(L,tvb_get_letohl(tvbr->tvb->ws_tvb,tvbr->offset)); WSLUA_RETURN(1); /* The unsigned integer value */ default: luaL_error(L,"TvbRange:le_uint() does not handle %d byte integers",tvbr->len); return 0; } }
static int dissect_yami_data(tvbuff_t *tvb, gboolean data, proto_tree *tree, int offset) { const int orig_offset = offset; proto_tree *yami_data_tree; proto_item *ti; guint32 count; guint i; ti = proto_tree_add_item(tree, (data) ? hf_yami_message_data : hf_yami_message_hdr, tvb, offset, 0, ENC_NA); yami_data_tree = proto_item_add_subtree(ti, (data) ? ett_yami_msg_data : ett_yami_msg_hdr); count = tvb_get_letohl(tvb, offset); proto_tree_add_item(yami_data_tree, hf_yami_params_count, tvb, offset, 4, ENC_LITTLE_ENDIAN); offset += 4; proto_item_append_text(ti, ", %u parameters: ", count); for (i = 0; i < count; i++) { offset = dissect_yami_parameter(tvb, yami_data_tree, offset, ti); /* smth went wrong */ if (offset == -1) return -1; } proto_item_set_len(ti, offset - orig_offset); return offset; }
/* * Check if a packet is in order and if it is set its fragmentation details into the passed pointers. * Returns TRUE if the packet is fragmented. * Must be run sequentially * */ static gboolean ts2_standard_find_fragments(tvbuff_t *tvb, guint32 *last_inorder_frame, guint32 *frag_size, guint32 *frag_num, gboolean *outoforder) { guint32 frag_count; gboolean ret; frag_count=tvb_get_letohs(tvb, 18); ret=FALSE; *outoforder=FALSE; /* if last_inorder_frame is zero, then this is the first reliable packet */ if(*last_inorder_frame==0) { *last_inorder_frame=tvb_get_letohl(tvb, 12); *frag_size=tvb_get_letohs(tvb, 18); *frag_num=0; if(*frag_size>0) ret=TRUE; else ret=FALSE; } /* This packet is in order */ else if(*last_inorder_frame==tvb_get_letohl(tvb, 12)-1) { if(*frag_size>0) { *frag_num=*frag_size-frag_count; if(frag_count==0) { *frag_size=0; } ret=TRUE; } else { *frag_size=tvb_get_letohs(tvb, 18); *frag_num=*frag_size-frag_count; if(*frag_size>0) ret=TRUE; else ret=FALSE; } *last_inorder_frame=tvb_get_letohl(tvb, 12); } else /* out of order */ *outoforder=TRUE; return ret; }
static guint32 corosync_totemsrp_get_guint32(tvbuff_t* tvb, gint offset, const guint encoding) { if (encoding == ENC_LITTLE_ENDIAN) return tvb_get_letohl(tvb, offset); return tvb_get_ntohl(tvb, offset); }
static guint32 tvb_get_enctohl(tvbuff_t *tvb, int offset, guint encoding) { if (encoding == ENC_BIG_ENDIAN) return tvb_get_ntohl(tvb, offset); else return tvb_get_letohl(tvb, offset); }
/* dissect a bt dht values list from tvb, start at offset. it's like "l6:....6:....e" */ static int dissect_bt_dht_values(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint offset, char **result, char *label ) { proto_item *ti; proto_tree *sub_tree; proto_item *value_ti; proto_tree *value_tree; address addr; guint peer_index; guint string_len_start; guint string_len; guint16 port; ti = proto_tree_add_item( tree, hf_bt_dht_peers, tvb, offset, 0, ENC_NA ); sub_tree = proto_item_add_subtree( ti, ett_bt_dht_peers); peer_index = 0; /* we has confirmed that the first byte is 'l' */ offset += 1; /* dissect bt-dht values */ while( tvb_get_guint8(tvb,offset)!='e' ) { string_len_start = offset; while( tvb_get_guint8(tvb,offset) != ':' ) offset += 1; string_len = atoi( tvb_get_ephemeral_string(tvb,string_len_start,offset-string_len_start) ); /* skip the ':' */ offset += 1; /* 4 bytes ip, 2 bytes port */ for( ; string_len>=6; string_len-=6, offset+=6 ) { peer_index += 1; SET_ADDRESS( &addr, AT_IPv4, 4, tvb_get_ptr( tvb, offset, 4) ); port = tvb_get_letohl( tvb, offset+4 ); value_ti = proto_tree_add_none_format( sub_tree, hf_bt_dht_peer, tvb, offset, 6, "%d\t%s:%u", peer_index, ep_address_to_str( &addr ), port ); value_tree = proto_item_add_subtree( value_ti, ett_bt_dht_peers); proto_tree_add_item( value_tree, hf_ip, tvb, offset, 4, ENC_BIG_ENDIAN); proto_tree_add_item( value_tree, hf_port, tvb, offset+4, 2, ENC_BIG_ENDIAN); } /* truncated data */ if( string_len>0 ) { proto_tree_add_item( tree, hf_truncated_data, tvb, offset, string_len, ENC_NA ); offset += string_len; } } proto_item_set_text( ti, "%s: %d peers", label, peer_index ); col_append_fstr( pinfo->cinfo, COL_INFO, "reply=%d peers ", peer_index ); *result = ep_strdup_printf("%d peers", peer_index); return offset; }
static guint32 tvb_get_guint32_endian(tvbuff_t *a_tvb, gint a_iOffset, gboolean a_bLittleEndian) { guint32 iResult; if (a_bLittleEndian) iResult = tvb_get_letohl(a_tvb, a_iOffset); else iResult = tvb_get_ntohl(a_tvb, a_iOffset); return iResult; }
static void dissect_event_counter(tvbuff_t *tvb, proto_tree *tree) { guint32 aa; aa = tvb_get_letohl(tvb, get_header_length()); if (aa != adv_aa) { proto_tree_add_item(tree, hf_nordic_ble_event_counter, tvb, get_ec_index(), 2, ENC_LITTLE_ENDIAN); } }
/* Calculates a CRC32 checksum from the tvb zeroing out four bytes at the offset and checks it with the given crc32 and adds the result to the tree * Returns true if the calculated CRC32 matches the passed CRC32. * */ static gboolean ts2_add_checked_crc32(proto_tree *tree, int hf_item, tvbuff_t *tvb, guint16 offset, guint32 icrc32 ) { guint8 *zero; guint32 ocrc32; zero = ep_alloc0(4); ocrc32 = crc32_ccitt_tvb(tvb, offset); ocrc32 = crc32_ccitt_seed(zero, 4, 0xffffffff-ocrc32); ocrc32 = crc32_ccitt_tvb_offset_seed(tvb, offset+4, tvb_reported_length_remaining(tvb, offset+4), 0xffffffff-ocrc32); if(icrc32==ocrc32) { proto_tree_add_uint_format(tree, hf_item, tvb, offset, 4, tvb_get_letohl(tvb, 16), "crc32: 0x%04x [correct]", tvb_get_letohl(tvb, offset)); return TRUE; } else { proto_tree_add_uint_format(tree, hf_item, tvb, offset, 4, tvb_get_letohl(tvb,16), "crc32: 0x%04x [incorrect, should be 0x%04x]", tvb_get_letohl(tvb, offset),ocrc32); return FALSE; } }
static gboolean is_rrac_command_stream(tvbuff_t *tvb, int offset) { guint16 maybe_command = tvb_get_letohs(tvb, offset); if (maybe_command >= 0x65 && maybe_command <= 0x70) return TRUE; #if 0 if (tvb_get_letohl(tvb, offset) == 0xffffffff || tvb_length_remaining(tvb, offset) >= 14) { guint32 test_value = tvb_get_letohl(tvb, offset + 4); if (test_value >= 10000 && test_value <= 10050) { return TRUE; } } #endif return FALSE; }
static int dissect_bt_dht_nodes(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint offset, char **result, char *label ) { proto_item *ti; proto_tree *sub_tree; proto_item *node_ti; proto_tree *node_tree; guint node_index; guint string_len_start; guint string_len; address addr; guint16 port; guint8 *id; ti = proto_tree_add_item( tree, hf_bt_dht_nodes, tvb, offset, 0, ENC_NA ); sub_tree = proto_item_add_subtree( ti, ett_bt_dht_nodes); node_index = 0; string_len_start = offset; while( tvb_get_guint8(tvb,offset) != ':' ) offset += 1; string_len = atoi( tvb_get_ephemeral_string(tvb,string_len_start,offset-string_len_start) ); /* skip the ':' */ offset += 1; /* 20 bytes id, 4 bytes ip, 2 bytes port */ for( ; string_len>=26; string_len-=26, offset+=26 ) { node_index += 1; id = tvb_bytes_to_str(tvb, offset, 20 ); SET_ADDRESS( &addr, AT_IPv4, 4, tvb_get_ptr( tvb, offset, 4) ); port = tvb_get_letohl( tvb, offset+24 ); node_ti = proto_tree_add_none_format( sub_tree, hf_bt_dht_node, tvb, offset, 26, "%d\t%s %s:%u", node_index, id, ep_address_to_str( &addr ), port ); node_tree = proto_item_add_subtree( node_ti, ett_bt_dht_peers); proto_tree_add_item( node_tree, hf_bt_dht_id, tvb, offset, 20, ENC_NA); proto_tree_add_item( node_tree, hf_ip, tvb, offset+20, 4, ENC_BIG_ENDIAN); proto_tree_add_item( node_tree, hf_port, tvb, offset+24, 2, ENC_BIG_ENDIAN); } if( string_len>0 ) { proto_tree_add_item( tree, hf_truncated_data, tvb, offset, string_len, ENC_NA ); offset += string_len; } proto_item_set_text( ti, "%s: %d nodes", label, node_index ); col_append_fstr( pinfo->cinfo, COL_INFO, "reply=%d nodes ", node_index ); *result = ep_strdup_printf("%d", node_index); return offset; }
static void dissect_aoe_v1(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { guint8 flags, cmd; guint32 tag; proto_item *flags_item=NULL; proto_tree *flags_tree=NULL; /* read and dissect the flags */ flags=tvb_get_guint8(tvb, 0)&0x0f; if(tree){ flags_item=proto_tree_add_text(tree, tvb, 0, 1, "Flags:"); flags_tree=proto_item_add_subtree(flags_item, ett_aoe_flags); } proto_tree_add_item(flags_tree, hf_aoe_flags_response, tvb, 0, 1, ENC_BIG_ENDIAN); proto_tree_add_item(flags_tree, hf_aoe_flags_error, tvb, 0, 1, ENC_BIG_ENDIAN); if(flags_item){ proto_item_append_text(flags_item,(flags&AOE_FLAGS_RESPONSE)?" Response":" Request"); if(flags&AOE_FLAGS_ERROR){ proto_item_append_text(flags_item, " Error"); } } /* error */ if(flags&AOE_FLAGS_ERROR){ proto_tree_add_item(tree, hf_aoe_error, tvb, 1, 1, ENC_BIG_ENDIAN); col_append_fstr(pinfo->cinfo, COL_INFO, "Error:%s ", val_to_str(tvb_get_guint8(tvb, 1), error_vals, "Unknown error<%d>")); } /* major/minor address */ proto_tree_add_item(tree, hf_aoe_major, tvb, 2, 2, ENC_BIG_ENDIAN); proto_tree_add_item(tree, hf_aoe_minor, tvb, 4, 1, ENC_BIG_ENDIAN); /* command */ cmd=tvb_get_guint8(tvb, 5); proto_tree_add_item(tree, hf_aoe_cmd, tvb, 5, 1, ENC_BIG_ENDIAN); col_append_fstr(pinfo->cinfo, COL_INFO, "%s %s", val_to_str(cmd, cmd_vals, "Unknown command<%d>"), (flags&AOE_FLAGS_RESPONSE)?"Response":"Request"); /* tag */ tag=tvb_get_letohl(tvb, 6); proto_tree_add_item(tree, hf_aoe_tag, tvb, 6, 4, ENC_BIG_ENDIAN); switch(cmd){ case AOE_CMD_ISSUE_ATA_COMMAND: dissect_ata_pdu(pinfo, tree, tvb, 10, flags&AOE_FLAGS_RESPONSE, tag); break; case AOE_CMD_QUERY_CONFIG_INFO: break; } }
static gint dissect_ros_message_header(tvbuff_t *tvb, proto_tree *root_tree, packet_info *pinfo, gint offset) { proto_item *ti; proto_tree *sub_tree; gint consumed_len = 0; guint32 frame_id_len; guint32 seq; guint header_len; frame_id_len = tvb_get_letohl(tvb, offset + consumed_len + SIZE_OF_LENGTH_FIELD + SIZE_OF_LENGTH_STAMP); header_len = SIZE_OF_LENGTH_FIELD + SIZE_OF_LENGTH_STAMP + SIZE_OF_LENGTH_FIELD + frame_id_len; /** Header */ ti = proto_tree_add_item(root_tree, hf_tcpros_message_header, tvb, offset + consumed_len, header_len, ENC_NA); sub_tree = proto_item_add_subtree(ti, ett_tcpros); /** Sequence number */ proto_tree_add_item(sub_tree, hf_tcpros_message_header_seq, tvb, offset + consumed_len, SIZE_OF_LENGTH_FIELD, ENC_LITTLE_ENDIAN); seq = tvb_get_letohl(tvb, offset + consumed_len); consumed_len += SIZE_OF_LENGTH_FIELD; col_append_fstr(pinfo->cinfo, COL_INFO, "Seq: %d ", seq); /** Timestamp */ consumed_len += dissect_ros_message_header_stamp(tvb, sub_tree, pinfo, offset + consumed_len); /** Frame ID */ ti = proto_tree_add_item(sub_tree, hf_tcpros_message_header_frame, tvb, offset + consumed_len, SIZE_OF_LENGTH_FIELD, ENC_UTF_8|ENC_LITTLE_ENDIAN); sub_tree = proto_item_add_subtree(ti, ett_tcpros); proto_tree_add_item(sub_tree, hf_tcpros_message_header_frame_length, tvb, offset + consumed_len, SIZE_OF_LENGTH_FIELD, ENC_LITTLE_ENDIAN); consumed_len += SIZE_OF_LENGTH_FIELD; proto_tree_add_item(sub_tree, hf_tcpros_message_header_frame_value, tvb, offset + consumed_len, frame_id_len, ENC_UTF_8|ENC_NA); col_append_fstr(pinfo->cinfo, COL_INFO, "Frame: '%s' ", tvb_get_string_enc(wmem_packet_scope(), tvb, offset + consumed_len, frame_id_len, ENC_UTF_8) ); consumed_len += frame_id_len; return consumed_len; }
static gint dissect_counted_values(tvbuff_t *tvb, gint offset, int hf_id, packet_info *pinfo, proto_tree *tree, gboolean single, gboolean unicode, guint encoding) { proto_item *item; guint32 length, count, i; count = tvb_get_letohl(tvb, offset); proto_tree_add_item(tree, hf_tnef_values_count, tvb, offset, 4, ENC_LITTLE_ENDIAN); if(count > 1) { if(single) { item = proto_tree_add_expert_format(tree, pinfo, &ei_tnef_expect_single_item, tvb, offset, 4, "Expecting a single item but found %d", count); tree = proto_item_add_subtree(item, ett_tnef_counted_items); } } offset += 4; for(i = 0; i < count; i++) { length = tvb_get_letohl(tvb, offset); proto_tree_add_item(tree, hf_tnef_value_length, tvb, offset, 4, ENC_LITTLE_ENDIAN); offset += 4; if (unicode) { char *unicode_str = tvb_get_unicode_string(wmem_packet_scope(), tvb, offset, length, ENC_LITTLE_ENDIAN); proto_tree_add_string(tree, hf_id, tvb, offset, length, unicode_str); } else { proto_tree_add_item(tree, hf_id, tvb, offset, length, encoding); } offset += length; /* XXX: may be padding ? */ } return offset; }
static void dissect_UDPR3(tvbuff_t *tvb, packet_info *pinfo, proto_tree *adwin_tree, proto_tree *adwin_debug_tree) { guint32 i, seq_num; /* Get the transaction identifier */ seq_num = tvb_get_letohl(tvb, 0); adwin_request_response_handling(tvb, pinfo, adwin_tree, seq_num, ADWIN_RESPONSE); if (! adwin_tree) return; SET_PACKET_TYPE(adwin_tree, APT_UDPR3); ADWIN_ADD_LE(adwin_tree, packet_index, 0, 4); ADWIN_ADD_LE(adwin_tree, packet_no, 4, 4); if (! global_adwin_dissect_data) { proto_tree_add_text(adwin_debug_tree, tvb, 8, 350 * 4, "Data"); return; } for (i = 0; i < 350; i++) { proto_item *item; guint32 offset = 8 + i * sizeof(guint32); gint32 value = tvb_get_letohl(tvb, offset); void * fvalue = &value; proto_tree_add_text(adwin_debug_tree, tvb, offset, 4, "Data[%3d]: %10d - %10f - 0x%08x", i, value, *(float*)fvalue, value); item = ADWIN_ADD_LE(adwin_debug_tree, data_int, offset, 4); PROTO_ITEM_SET_HIDDEN(item); item = ADWIN_ADD_LE(adwin_debug_tree, data_float, offset, 4); PROTO_ITEM_SET_HIDDEN(item); item = ADWIN_ADD_LE(adwin_debug_tree, data_hex, offset, 4); PROTO_ITEM_SET_HIDDEN(item); } }
static int dissect_bson_document(tvbuff_t *tvb, guint offset, proto_tree *tree, int hf_mongo_document) { gint32 document_length; proto_item *ti; proto_tree *doc_tree; document_length = tvb_get_letohl(tvb, offset); /* TODO Implement BSON spec to correctly see BSON document type and not in Bytes format... */ ti = proto_tree_add_item(tree, hf_mongo_document, tvb, offset+4, document_length-4, ENC_NA); doc_tree = proto_item_add_subtree(ti, ett_mongo_doc); proto_tree_add_item(doc_tree, hf_mongo_document_length, tvb, offset, 4, ENC_LITTLE_ENDIAN); return document_length; }
static void dissect_ble_delta_time(tvbuff_t *tvb, proto_tree *tree) { static guint8 previous_ble_packet_length = 0; guint32 delta_time, delta_time_ss; /* end - start */ delta_time = (guint32)tvb_get_letohl(tvb, get_td_index()); proto_tree_add_item(tree, hf_nordic_ble_delta_time, tvb, get_td_index(), 4, ENC_LITTLE_ENDIAN); /* start - start */ delta_time_ss = get_metadata_transfer_time() + (get_us_per_byte() * previous_ble_packet_length) + delta_time; proto_tree_add_uint(tree, hf_nordic_ble_delta_time_ss, tvb, get_td_index(), 4, delta_time_ss); previous_ble_packet_length = tvb_get_guint8(tvb, get_packet_length_index()); }
static int dissect_dtpt_guid(tvbuff_t *tvb, guint offset, proto_tree *tree, int hfindex) { guint32 guid_length; guid_length = tvb_get_letohl(tvb, offset); if (tree) { e_guid_t guid; proto_item *dtpt_guid_item = NULL; proto_tree *dtpt_guid_tree = NULL; const gchar *guid_name = NULL; if (guid_length) { tvb_get_guid(tvb, offset+4, &guid, ENC_LITTLE_ENDIAN); } else { memset(&guid, 0, sizeof(guid)); } dtpt_guid_item = proto_tree_add_guid(tree, hfindex, tvb, offset, 4 + guid_length, &guid); if (dtpt_guid_item) { guid_name = guids_get_guid_name(&guid); if (guid_name != NULL) proto_item_set_text(dtpt_guid_item, "%s: %s (%s)", proto_registrar_get_name(hfindex), guid_name, guid_to_str(&guid)); dtpt_guid_tree = proto_item_add_subtree(dtpt_guid_item, ett_dtpt_guid); } if (dtpt_guid_tree) { proto_item *dtpt_guid_data_item = NULL; proto_tree_add_uint(dtpt_guid_tree, hf_dtpt_guid_length, tvb, offset, 4, guid_length); if (guid_length) { dtpt_guid_data_item = proto_tree_add_guid(dtpt_guid_tree, hf_dtpt_guid_data, tvb, offset+4, guid_length, &guid); if (guid_name != NULL && dtpt_guid_data_item != NULL) { proto_item_set_text(dtpt_guid_data_item, "%s: %s (%s)", proto_registrar_get_name(hf_dtpt_guid_data), guid_name, guid_to_str(&guid)); } } } } offset+=4; offset+=guid_length; return offset; }