static void dissect_request_resolve(tvbuff_t *tvb, int offset, proto_tree *tree) { /* dissect the request resolve structure */ /* display a string with a length, characters encoding */ /* they are displayed under a tree with the name in Label variable */ /* return the length of the string and the length byte */ proto_tree *name_tree; proto_item *ti; int length = tvb_get_guint8( tvb, offset); if ( tree){ ti = proto_tree_add_text(tree, tvb, offset, length + 1, "Host Name: %.*s", length, tvb_get_string( wmem_packet_scope(), tvb, offset + 18, length)); name_tree = proto_item_add_subtree(ti, ett_msproxy_name); proto_tree_add_text( name_tree, tvb, offset, 1, "Length: %d", length); ++offset; offset += 17; proto_tree_add_text( name_tree, tvb, offset, length, "String: %s", tvb_get_string( wmem_packet_scope(), tvb, offset, length)); } }
static void rtpproxy_add_notify_addr(proto_tree *rtpproxy_tree, tvbuff_t *tvb, guint begin, guint end) { gint offset = 0; gint tmp = 0; gboolean ipv6 = FALSE; proto_item *ti; /* Check for at least one colon */ offset = tvb_find_guint8(tvb, begin, end, ':'); if(offset != -1) { /* Find if it's the latest colon (not in case of a IPv6) */ while((tmp = tvb_find_guint8(tvb, offset+1, end, ':')) != -1) { ipv6 = TRUE; offset = tmp; } /* We have ip:port */ if(ipv6) proto_tree_add_item(rtpproxy_tree, hf_rtpproxy_notify_ipv6, tvb, begin, offset - begin, ENC_ASCII | ENC_NA); else proto_tree_add_item(rtpproxy_tree, hf_rtpproxy_notify_ipv4, tvb, begin, offset - begin, ENC_ASCII | ENC_NA); proto_tree_add_uint(rtpproxy_tree, hf_rtpproxy_notify_port, tvb, offset+1, end - (offset+1), (guint16) g_ascii_strtoull((gchar*)tvb_get_string(wmem_packet_scope(), tvb, offset+1, end - (offset+1)), NULL, 10)); } else { /* Only port is supplied */ ti = proto_tree_add_item(rtpproxy_tree, hf_rtpproxy_notify_ipv4, tvb, begin, 0, ENC_ASCII | ENC_NA); proto_item_append_text(ti, "<skipped>"); PROTO_ITEM_SET_GENERATED(ti); proto_tree_add_uint(rtpproxy_tree, hf_rtpproxy_notify_port, tvb, begin, end - begin, (guint16) g_ascii_strtoull((gchar*)tvb_get_string(wmem_packet_scope(), tvb, begin, end - begin), NULL, 10)); } }
static void dissect_user_info_2(tvbuff_t *tvb, int offset, proto_tree *tree) { /* decode the user, application, computer name */ int length; if ( tree) { length = tvb_strnlen( tvb, offset, 255); if (length == -1) return; proto_tree_add_text( tree, tvb, offset, length + 1, "User name: %.*s", length, tvb_get_string( wmem_packet_scope(), tvb, offset, length)); offset += length + 2; length = tvb_strnlen( tvb, offset, 255); if (length == -1) return; proto_tree_add_text( tree, tvb, offset, length + 1, "Application name: %.*s", length, tvb_get_string( wmem_packet_scope(), tvb, offset, length)); offset += length + 1; length = tvb_strnlen( tvb, offset, 255); if (length == -1) return; proto_tree_add_text( tree, tvb, offset, length + 1, "Client computer name: %.*s", length, tvb_get_string( wmem_packet_scope(), tvb, offset, length)); } }
static void dissect_icp_payload(tvbuff_t *tvb, int offset, proto_tree *pload_tree, guint8 opcode) { gint stringlength; guint16 objectlength; switch(opcode) { case CODE_ICP_OP_QUERY: /* 4 byte requester host address */ proto_tree_add_text(pload_tree, tvb,offset,4, "Requester Host Address %s", tvb_ip_to_str(tvb, offset)); offset += 4; /* null terminated URL */ stringlength = tvb_strsize(tvb, offset); proto_tree_add_text(pload_tree, tvb, offset, stringlength, "URL: %s", tvb_get_string(wmem_packet_scope(), tvb, offset, stringlength)); break; case CODE_ICP_OP_SECHO: case CODE_ICP_OP_DECHO: case CODE_ICP_OP_HIT: case CODE_ICP_OP_MISS: case CODE_ICP_OP_ERR: case CODE_ICP_OP_MISS_NOFETCH: case CODE_ICP_OP_DENIED: stringlength = tvb_strsize(tvb, offset); proto_tree_add_text(pload_tree, tvb, offset, stringlength, "URL: %s", tvb_get_string(wmem_packet_scope(), tvb, offset, stringlength)); break; case CODE_ICP_OP_HIT_OBJ: /* null terminated URL */ stringlength = tvb_strsize(tvb, offset); proto_tree_add_text(pload_tree, tvb, offset, stringlength, "URL: %s", tvb_get_string(wmem_packet_scope(), tvb, offset, stringlength)); offset += stringlength; /* 2 byte object size */ /* object data not recommended by standard*/ objectlength=tvb_get_ntohs(tvb, offset); proto_tree_add_text(pload_tree, tvb,offset,2,"Object length: %u", objectlength); offset += 2; /* object data not recommended by standard*/ proto_tree_add_text(pload_tree, tvb,offset,objectlength,"Object data"); if (objectlength > tvb_reported_length_remaining(tvb, offset)) { proto_tree_add_text(pload_tree, tvb,offset,0, "Packet is fragmented, rest of object is in next udp packet"); } break; default: break; } }
static int rs_misc_dissect_login_get_info_rqst (tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep) { guint32 key_size; const char *key_t1 = NULL; offset = dissect_ndr_uint32 (tvb, offset, pinfo, tree, drep, hf_rs_misc_login_get_info_rqst_var, NULL); offset = dissect_ndr_uint32 (tvb, offset, pinfo, tree, drep, hf_rs_misc_login_get_info_rqst_key_size, &key_size); if (key_size){ /* Not able to yet decipher the OTHER versions of this call just yet. */ proto_tree_add_item (tree, hf_rs_misc_login_get_info_rqst_key_t, tvb, offset, key_size, ENC_ASCII|ENC_NA); key_t1 = tvb_get_string(wmem_packet_scope(), tvb, offset, key_size); offset += key_size; if (check_col(pinfo->cinfo, COL_INFO)) { col_append_fstr(pinfo->cinfo, COL_INFO, "rs_login_get_info Request for: %s ", key_t1); } } else { col_append_str(pinfo->cinfo, COL_INFO, "rs_login_get_info Request (other)"); } return offset; }
static int add_text_item(tvbuff_t *tvb, proto_tree *tree, int offset, int hf) { guint16 length; /* heuristic rule, string should start w/ valid character(s) */ if (! tvb_get_guint8(tvb, offset + 2)) return 0; length = tvb_get_ntohs(tvb, offset); if (length) { /* the string length must not exceed the packet length */ if (length > tvb_reported_length_remaining(tvb, offset + 2)) return 0; /* add string length only if preferences is set */ if (global_sametime_show_length) proto_tree_add_item(tree, hf_sametime_field_length, tvb, offset, 2, ENC_BIG_ENDIAN); /* add string */ proto_tree_add_string(tree, hf, tvb, offset + 2, length, tvb_get_string(tvb, offset + 2, length)); } return 2 + length; }
void dissect_umts_cell_broadcast_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { guint8 sms_encoding; guint32 offset = 0; guint32 len; proto_item *cbs_item = NULL, *cbs_item2 = NULL; proto_tree *cbs_tree = NULL, *cbs_subtree = NULL; guint msg_len; tvbuff_t * cbs_msg_tvb = NULL; len = tvb_length(tvb); col_append_str(pinfo->cinfo, COL_PROTOCOL, " Cell Broadcast"); col_append_str(pinfo->cinfo, COL_INFO, " (CBS Message)"); cbs_item = proto_tree_add_protocol_format(proto_tree_get_root(tree), proto_cell_broadcast, tvb, 0, len, "Cell Broadcast"); cbs_tree = proto_item_add_subtree(cbs_item, ett_cbs_msg); sms_encoding = dissect_cbs_data_coding_scheme(tvb, pinfo, cbs_tree, 0); offset++; cbs_msg_tvb = dissect_cbs_data(sms_encoding, tvb, cbs_tree, pinfo, offset ); msg_len = tvb_length(cbs_msg_tvb); cbs_item2 = proto_tree_add_text(cbs_tree, tvb, offset, -1, "Cell Broadcast Message Contents (length: %d)", msg_len); cbs_subtree = proto_item_add_subtree(cbs_item2, ett_cbs_msg); proto_tree_add_text(cbs_subtree, cbs_msg_tvb , 0, tvb_length(cbs_msg_tvb), "%s", tvb_get_string(wmem_packet_scope(), cbs_msg_tvb, 0, msg_len)); }
/* -------------------------- */ static int time_stamp(tvbuff_t *tvb, proto_tree *nasdaq_itch_tree, int id, int offset, int size) { if (nasdaq_itch_tree) { guint32 ms, val; const char *display = ""; const char *str_value = tvb_get_string(wmem_packet_scope(), tvb, offset, size); ms = val = (guint32)strtoul(str_value, NULL, 10); switch (size) { case 3: display = wmem_strdup_printf(wmem_packet_scope(), " %03u" , val); break; case 5: ms = val *1000; case 8: /* 0 86 400 000 */ display = wmem_strdup_printf(wmem_packet_scope(), " %u (%02u:%02u:%02u.%03u)", val, ms/3600000, (ms % 3600000)/60000, (ms % 60000)/1000, ms %1000); break; } proto_tree_add_uint_format_value(nasdaq_itch_tree, id, tvb, offset, size, val, "%s", display); } return offset + size; }
static void dissect_hpfeeds_info_pdu(tvbuff_t *tvb, proto_tree *tree, guint offset) { guint8 len = 0; proto_item *ti = NULL; proto_tree *data_subtree = NULL; guint8 *strptr = NULL; len = tvb_get_guint8(tvb, offset); /* don't move the offset yet as we need to get data after this operation */ strptr = tvb_get_string(wmem_packet_scope(), tvb, offset + 1, len); ti = proto_tree_add_text(tree, tvb, offset, -1, "Broker: %s", strptr); data_subtree = proto_item_add_subtree(ti, ett_hpfeeds); proto_tree_add_item(data_subtree, hf_hpfeeds_server_len, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; proto_tree_add_item(data_subtree, hf_hpfeeds_server, tvb, offset, len, ENC_BIG_ENDIAN); offset += len; proto_tree_add_item(data_subtree, hf_hpfeeds_nonce, tvb, offset, -1, ENC_BIG_ENDIAN); }
static int display_address(tvbuff_t *tvb, int offset, proto_tree *tree) { /* decode and display the v5 address, return offset of next byte */ int a_type = tvb_get_guint8(tvb, offset); proto_tree_add_item( tree, hf_socks_address_type, tvb, offset, 1, ENC_NA); offset += 1; switch (a_type) { case 1: /* IPv4 address */ proto_tree_add_item( tree, hf_socks_ip_dst, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case 3: /* domain name address */ { guint8 len; gchar* str; len = tvb_get_guint8(tvb, offset); str = tvb_get_string(wmem_packet_scope(), tvb, offset+1, len); proto_tree_add_string(tree, hf_socks_remote_name, tvb, offset, len+1, str); offset += (len+1); } break; case 4: /* IPv6 address */ proto_tree_add_item( tree, hf_socks_ip6_dst, tvb, offset, 16, ENC_NA); offset += 16; break; } return offset; }
static int dissect_ppcap_payload_type(tvbuff_t *tvb, proto_tree * ppcap_tree1, int offset, guint16 msg_len, payload_type_type *payload_type) { char *string; string = tvb_get_string(wmem_packet_scope(), tvb, offset, msg_len); if (strcmp(string,"mtp3") == 0) { *payload_type = PPCAP_MTP3; }else if (strcmp(string,"tcap") == 0) { *payload_type = PPCAP_TCAP; }else if (strcmp(string,"bssap") == 0) { *payload_type = PPCAP_BSSAP; }else if (strcmp(string,"ranap") == 0) { *payload_type = PPCAP_RANAP; }else if (strcmp(string,"h248") == 0) { *payload_type = PPCAP_H248; }else if (strcmp(string,"sip") == 0) { *payload_type = PPCAP_SIP; }else if (strcmp(string,"sccp") == 0) { *payload_type = PPCAP_SCCP; } proto_tree_add_item(ppcap_tree1, hf_ppcap_payload_type, tvb, offset, msg_len, ENC_BIG_ENDIAN|ENC_ASCII); if (msg_len%4) msg_len = msg_len+(4-(msg_len%4)); offset += msg_len; return offset; }
static gboolean get_packet_length(tvbuff_t *tvb, int offset, guint16 *length) { guint8 *lenstr; lenstr = tvb_get_string(wmem_packet_scope(), tvb, offset, 4); return (sscanf(lenstr, "%hx", length) == 1); }
static int dissect_sec_rgy_pname_t (tvbuff_t * tvb, int offset, packet_info * pinfo, proto_tree * parent_tree, dcerpc_info *di, guint8 * drep) { proto_item *item = NULL; proto_tree *tree = NULL; int old_offset = offset; #define sec_rgy_pname_t_size 257 /* dissect sec_rgy_pname const signed32 sec_rgy_pname_t_size = 257; * Include final '\0' * typedef [string] char sec_rgy_pname_t[sec_rgy_pname_t_size]; */ guint32 string_size; if (di->conformant_run) { return offset; } if (parent_tree) { item = proto_tree_add_text (parent_tree, tvb, offset, -1, "sec_rgy_pname_t"); tree = proto_item_add_subtree (item, ett_sec_rgy_pname_t); } offset = dissect_ndr_uint32 (tvb, offset, pinfo, tree, di, drep, hf_sec_rgy_pname_t_size, &string_size); col_append_fstr (pinfo->cinfo, COL_INFO, " String_size:%u", string_size); if (string_size < sec_rgy_pname_t_size) { /* proto_tree_add_string(tree, id, tvb, start, length, value_ptr); */ proto_tree_add_item (tree, hf_sec_rgy_pname_t_principalName_string, tvb, offset, string_size, ENC_ASCII|ENC_NA); if (string_size > 1) { col_append_fstr (pinfo->cinfo, COL_INFO, " Principal:%s", tvb_get_string(wmem_packet_scope(), tvb, offset, string_size)); } offset += string_size; } else { col_append_fstr (pinfo->cinfo, COL_INFO, " :FIXME!: Invalid string length of %u", string_size); } proto_item_set_len (item, offset - old_offset); return offset; }
/* -------------------------- */ static int stock(tvbuff_t *tvb, packet_info *pinfo, proto_tree *nasdaq_itch_tree, int offset) { char *stock_p = tvb_get_string(wmem_packet_scope(), tvb, offset, 6); proto_tree_add_item(nasdaq_itch_tree, hf_nasdaq_itch_stock, tvb, offset, 6, ENC_ASCII|ENC_NA); col_append_fstr(pinfo->cinfo, COL_INFO, "<%s> ", stock_p); return offset + 6; }
/* ---------------------------------------------- */ static int fix_header_len(tvbuff_t *tvb, int offset) { int base_offset, ctrla_offset; char *value; int size; fix_parameter *tag; base_offset = offset; /* get at least the fix version: 8=FIX.x.x */ if (fix_marker(tvb, offset) != 0) { return fix_next_header(tvb, offset); } /* begin string */ ctrla_offset = tvb_find_guint8(tvb, offset, -1, 0x01); if (ctrla_offset == -1) { /* it should be there, (minimum size is big enough) * if not maybe it's not really * a FIX packet but it's too late to bail out. */ return fix_next_header(tvb, offset +MARKER_LEN) +MARKER_LEN; } offset = ctrla_offset + 1; /* msg length */ if (!(tag = fix_param(tvb, offset)) || tvb_strneql(tvb, offset, "9=", 2)) { /* not a tag or not the BodyLength tag, give up */ return fix_next_header(tvb, offset); } value = tvb_get_string(wmem_packet_scope(), tvb, tag->value_offset, tag->value_len); /* Fix version, msg type, length and checksum aren't in body length. * If the packet is big enough find the checksum */ size = atoi(value) +tag->ctrla_offset - base_offset +1; if (tvb_length_remaining(tvb, base_offset) > size +4) { /* 10= should be there */ offset = base_offset +size; if (tvb_strneql(tvb, offset, "10=", 3) != 0) { /* No? bogus packet, try to find the next header */ return fix_next_header(tvb, base_offset +MARKER_LEN) +MARKER_LEN; } ctrla_offset = tvb_find_guint8(tvb, offset, -1, 0x01); if (ctrla_offset == -1) { /* assume checksum is 7 bytes 10=xxx\01 */ return size+7; } return size +ctrla_offset -offset +1; } else { } /* assume checksum is 7 bytes 10=xxx\01 */ return size +7; }
/* ---------------------- */ static int order_ref_number(tvbuff_t *tvb, packet_info *pinfo, proto_tree *nasdaq_itch_tree, int offset) { const char *str_value = tvb_get_string(wmem_packet_scope(), tvb, offset, 9); guint32 value = (guint32)strtoul(str_value, NULL, 10); proto_tree_add_uint(nasdaq_itch_tree, hf_nasdaq_itch_order_reference, tvb, offset, 9, value); col_append_fstr(pinfo->cinfo, COL_INFO, "%u ", value); return offset + 9; }
static tvbuff_t * base64_decode(packet_info *pinfo, tvbuff_t *b64_tvb, char *name) { char *data; tvbuff_t *tvb; data = tvb_get_string(wmem_packet_scope(), b64_tvb, 0, tvb_length(b64_tvb)); tvb = base64_to_tvb(b64_tvb, data); add_new_data_source(pinfo, tvb, name); return tvb; }
static gint xdmcp_add_string(proto_tree *tree, gint hf, tvbuff_t *tvb, gint offset) { char *str; guint len; len = tvb_get_ntohs(tvb, offset); str = tvb_get_string(wmem_packet_scope(), tvb, offset+2, len); proto_tree_add_string(tree, hf, tvb, offset, len+2, str); return len+2; }
void isis_dissect_ip_authentication_clv(tvbuff_t *tvb, proto_tree *tree, int offset, int length) { if ( !tree ) return; /* nothing to do! */ if ( length != 0 ) { proto_tree_add_text ( tree, tvb, offset, length, "IP Authentication: %.*s", length, tvb_get_string(wmem_packet_scope(), tvb, offset, length) ); } }
/* -------------------------- */ static int price(tvbuff_t *tvb, packet_info *pinfo, proto_tree *nasdaq_itch_tree, int id, int offset, int big) { gint size = (big) ? 19 : 10; const char *str_value = tvb_get_string(wmem_packet_scope(), tvb, offset, size); gdouble value = guint64_to_gdouble(g_ascii_strtoull(str_value, NULL, 10))/((big)?1000000.0:10000.0); proto_tree_add_double(nasdaq_itch_tree, id, tvb, offset, size, value); col_append_fstr(pinfo->cinfo, COL_INFO, "price %g ", value); return offset + size; }
/* -------------------------- */ static int number_of_shares(tvbuff_t *tvb, packet_info *pinfo, proto_tree *nasdaq_itch_tree, int id, int offset, int big) { gint size = (big) ? 10 : 6; const char *str_value = tvb_get_string(wmem_packet_scope(), tvb, offset, size); guint32 value = (guint32)strtoul(str_value, NULL, 10); proto_tree_add_uint(nasdaq_itch_tree, id, tvb, offset, size, value); col_append_fstr(pinfo->cinfo, COL_INFO, "qty %u ", value); return offset + size; }
tvbuff_t * dissect_cbs_data(guint8 sms_encoding, tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo, guint16 offset ) { tvbuff_t * tvb_out = NULL; int length = tvb_length(tvb) - offset; gchar *utf8_text = NULL, *utf8_out; guint8 * input_string; GIConv cd; GError *l_conv_error = NULL; switch(sms_encoding){ case SMS_ENCODING_7BIT: case SMS_ENCODING_7BIT_LANG: utf8_text = tvb_get_ts_23_038_7bits_string(wmem_packet_scope(), tvb, offset<<3, (length*8)/7); utf8_out = g_strdup(utf8_text); tvb_out = tvb_new_child_real_data(tvb, utf8_out, (guint)strlen(utf8_out), (guint)strlen(utf8_out)); tvb_set_free_cb(tvb_out, g_free); add_new_data_source(pinfo, tvb_out, "unpacked 7 bit data"); break; case SMS_ENCODING_8BIT: tvb_out = tvb_new_subset(tvb, offset, length, length); break; case SMS_ENCODING_UCS2: case SMS_ENCODING_UCS2_LANG: input_string = tvb_get_string(wmem_packet_scope(), tvb, offset, length); if ((cd = g_iconv_open("UTF-8","UCS-2BE")) != (GIConv) -1) { utf8_text = g_convert_with_iconv(input_string, length, cd, NULL, NULL, &l_conv_error); if(!l_conv_error) { tvb_out = tvb_new_subset(tvb, offset, length, length); } else proto_tree_add_text(tree, tvb, offset, length, "CBS String: g_convert_with_iconv FAILED"); g_free(utf8_text); g_iconv_close(cd); } else { proto_tree_add_text(tree, tvb, offset, length, "CBS String: g_iconv_open FAILED contact wireshark"); } break; default: proto_tree_add_text(tree, tvb, offset, length, "Unhandled encoding %d of CBS String", sms_encoding); break; } return tvb_out; }
static void dissect_hpfeeds_publish_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint offset) { guint8 len = 0; guint8 *strptr = NULL; gint8 channel = CH_EINVAL; tvbuff_t *json_tvb = NULL; len = tvb_get_guint8(tvb, offset); proto_tree_add_item(tree, hf_hpfeeds_ident_len, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; proto_tree_add_item(tree, hf_hpfeeds_ident, tvb, offset, len, ENC_BIG_ENDIAN); offset += len; len = tvb_get_guint8(tvb, offset); proto_tree_add_item(tree, hf_hpfeeds_chan_len, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; /* get the channel name as ephemeral string just to make an attempt * in order to decode more payload if channel is "well known" */ strptr = tvb_get_string(wmem_packet_scope(), tvb, offset, len); proto_tree_add_item(tree, hf_hpfeeds_channel, tvb, offset, len, ENC_BIG_ENDIAN); offset += len; channel = str_to_val(strptr, chan_vals, CH_EINVAL); pinfo->private_data = strptr; switch (channel) { case CH_DIONAEA_CAPTURE: case CH_DIONAEA_DCE: case CH_DIONAEA_SHELLCODE: case CH_DIONAEA_UINQUE: case CH_DIONAEA_CONNECTIONS: case CH_KIPPO_SESSIONS: case CH_GLASTOPF_EVENTS: case CH_GEOLOC_EVENTS: json_tvb = tvb_new_subset(tvb, offset, -1, -1); call_dissector(json_hdl, json_tvb, pinfo, tree); break; default: proto_tree_add_item(tree, hf_hpfeeds_payload, tvb, offset, -1, ENC_NA); break; } }
/* Info String */ static void dissect_m2tp_info_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item) { guint16 length, info_string_length; const char *info_string; if (parameter_tree) { length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET); info_string_length = length - PARAMETER_HEADER_LENGTH; info_string = tvb_get_string(wmem_packet_scope(), parameter_tvb, INFO_STRING_OFFSET, info_string_length); proto_tree_add_string(parameter_tree, hf_m2tp_info_string, parameter_tvb, INFO_STRING_OFFSET, info_string_length, info_string); proto_item_set_text(parameter_item, "Info String (%.*s)", info_string_length, info_string); } }
WSLUA_METHOD TvbRange_string(lua_State* L) { /* Obtain a string from a TvbRange */ TvbRange tvbr = checkTvbRange(L,1); if ( !(tvbr && tvbr->tvb)) return 0; if (tvbr->tvb->expired) { luaL_error(L,"expired tvb"); return 0; } lua_pushlstring(L, (gchar*)tvb_get_string(wmem_packet_scope(),tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len), tvbr->len ); WSLUA_RETURN(1); /* The string */ }
static int display_application_name(tvbuff_t *tvb, int offset, proto_tree *tree) { /* display the application name in the proto tree. */ /* NOTE: this routine assumes that the tree pointer is valid (not NULL) */ int length; length = tvb_strnlen( tvb, offset, 255); proto_tree_add_text( tree, tvb, offset, length, "Application: %.*s", length, tvb_get_string( wmem_packet_scope(), tvb, offset, length)); return length; }
/* Main dissection function. */ static void dissect_sipfrag(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { proto_tree *sipfrag_tree; proto_item *ti; gint offset = 0; gint next_offset; int linelen; char *string; gint lines = 0; /* Append this protocol name rather than replace. */ col_append_str(pinfo->cinfo, COL_PROTOCOL, "/sipfrag"); /* Add mention of this protocol to info column */ col_append_str(pinfo->cinfo, COL_INFO, ", with Sipfrag"); /* Create sipfrag tree. */ ti = proto_tree_add_item(tree, proto_sipfrag, tvb, offset, -1, ENC_NA); sipfrag_tree = proto_item_add_subtree(ti, ett_sipfrag); /* Show the sipfrag message a line at a time. */ while (tvb_offset_exists(tvb, offset)) { /* Find the end of the line. */ linelen = tvb_find_line_end_unquoted(tvb, offset, -1, &next_offset); /* For now, add all lines as unparsed strings */ /* Extract & add the string. */ string = (char*)tvb_get_string(wmem_packet_scope(), tvb, offset, linelen); proto_tree_add_string_format(sipfrag_tree, hf_sipfrag_line, tvb, offset, linelen, string, "%s", string); lines++; /* Show first line in info column */ if (lines == 1) { col_append_fstr(pinfo->cinfo, COL_INFO, "(%s", string); } /* Move onto next line. */ offset = next_offset; } /* Close off summary of sipfrag in info column */ col_append_str(pinfo->cinfo, COL_INFO, (lines > 1) ? "...)" : ")"); }
void isis_dissect_hostname_clv(tvbuff_t *tvb, proto_tree *tree, int offset, int length, int tree_id) { if ( !tree ) return; /* nothing to do! */ if ( length == 0 ) { proto_tree_add_text ( tree, tvb, offset, length, "Hostname: --none--" ); } else { const char* value = tvb_get_string(wmem_packet_scope(), tvb, offset, length); proto_tree_add_string_format ( tree, tree_id, tvb, offset, length, value, "Hostname: %.*s", length, value); } }
static int dissect_bencoded_string(tvbuff_t *tvb, packet_info _U_*pinfo, proto_tree *tree, guint offset, const char **result, gboolean tohex, const char *label ) { guint string_len; string_len = bencoded_string_length(tvb, &offset); /* fill the return data */ if( tohex ) *result = tvb_bytes_to_ep_str(tvb, offset, string_len ); else *result = tvb_get_string( wmem_packet_scope(), tvb, offset, string_len ); proto_tree_add_string_format( tree, hf_bencoded_string, tvb, offset, string_len, *result, "%s: %s", label, *result ); offset += string_len; return offset; }
static void dissect_xtp_diag(tvbuff_t *tvb, proto_tree *tree, guint32 offset) { guint32 len = tvb_length_remaining(tvb, offset); guint32 start = offset; proto_item *ti; proto_tree *xtp_subtree; struct xtp_diag diag[1]; guint32 msg_len; ti = proto_tree_add_text(tree, tvb, offset, len, "Diagnostic Segment"); xtp_subtree = proto_item_add_subtree(ti, ett_xtp_diag); if (len < XTP_DIAG_PKT_HEADER_LEN) { proto_item_append_text(ti, ", bogus length (%u, must be at least %u)", len, XTP_DIAG_PKT_HEADER_LEN); return; } /** parse **/ /* code(4) */ diag->code = tvb_get_ntohl(tvb, offset); offset += 4; /* val(4) */ diag->val = tvb_get_ntohl(tvb, offset); offset += 4; /* message(n) */ msg_len = tvb_length_remaining(tvb, offset); diag->msg = tvb_get_string(NULL, tvb, offset, msg_len); /** display **/ offset = start; /* code(4) */ proto_tree_add_uint(xtp_subtree, hf_xtp_diag_code, tvb, offset, 4, diag->code); offset += 4; /* val(4) */ proto_tree_add_uint(xtp_subtree, hf_xtp_diag_val, tvb, offset, 4, diag->val); offset += 4; /* message(4) */ proto_tree_add_string(xtp_subtree, hf_xtp_diag_msg, tvb, offset, msg_len, diag->msg); g_free(diag->msg); return; }