* in the 8 octets case.
*/
if (len > 4){
- ansi_tcap_private.TransactionID_str = tvb_bytes_to_str(next_tvb, 4,len-4);
+ ansi_tcap_private.TransactionID_str = tvb_bytes_to_ep_str(next_tvb, 4,len-4);
}else{
- ansi_tcap_private.TransactionID_str = tvb_bytes_to_str(next_tvb, 0,len);
+ ansi_tcap_private.TransactionID_str = tvb_bytes_to_ep_str(next_tvb, 0,len);
}
}
switch(len) {
proto_tree_add_uint(tree, hf_c1222_auth_len, tvb, *offset, 1, auth_len);
*offset += 1;
if (*length >= auth_len) {
- auth_req = tvb_bytes_to_str(tvb, *offset, auth_len);
+ auth_req = tvb_bytes_to_ep_str(tvb, *offset, auth_len);
proto_tree_add_item(tree, hf_c1222_auth_data, tvb, *offset, auth_len, ENC_NA);
*offset += auth_len;
*length -= auth_len + 1;
if (curr_info.term->len) {
curr_info.term->buffer = (guint8 *)tvb_memdup(wmem_packet_scope(),new_tvb,0,curr_info.term->len);
- curr_info.term->str = bytes_to_str(curr_info.term->buffer,curr_info.term->len);
+ curr_info.term->str = bytes_to_ep_str(curr_info.term->buffer,curr_info.term->len);
}
curr_info.term = gcp_cmd_add_term(curr_info.msg, curr_info.trx, curr_info.cmd, curr_info.term, wild_term, keep_persistent_data);
/* not ascii or NULL character so do string as hex string */
proto_tree_add_text(tree, tvb, offset, len,"%s: 0x%s",
(proto_registrar_get_nth(hf_index))->name,
- tvb_bytes_to_str(tvb, 0, len));
+ tvb_bytes_to_ep_str(tvb, 0, len));
return len;
};
};
proto_tree_add_uint(tree, hf_q932_nd, tvb, offset - (length - remain), length - remain, value);
if (remain > 0) {
- proto_tree_add_text(tree, tvb, offset - remain, remain, "ASN.1 Encoded Data Structure(NOT IMPLEMENTED): %s", tvb_bytes_to_str(tvb, offset - remain, remain));
+ proto_tree_add_text(tree, tvb, offset - remain, remain, "ASN.1 Encoded Data Structure(NOT IMPLEMENTED): %s", tvb_bytes_to_ep_str(tvb, offset - remain, remain));
}
}
guint8* bytes = (guint8 *)tvb_memdup(wmem_packet_scope(),imsi_tvb,0,len);
actx->pinfo->sccp_info->data.co.assoc->calling_party =
- wmem_strdup_printf(wmem_file_scope(), "IMSI: %%s", bytes_to_str(bytes, len) );
+ wmem_strdup_printf(wmem_file_scope(), "IMSI: %%s", bytes_to_ep_str(bytes, len) );
}
digit_str = unpack_digits(imsi_tvb, 0);
proto_tree_add_string(tree, hf_ranap_imsi_digits, imsi_tvb, 0, -1, digit_str);
/* 12-byte AgentID w/ 8-byte trailer */
if (len_remain==8) {
proto_tree_add_text(tree, tvb, offset, 8, "AgentID Trailer: 0x%s",
- tvb_bytes_to_str(tvb, offset, 8));
+ tvb_bytes_to_ep_str(tvb, offset, 8));
offset+=8;
len_remain-=8;
} else {
if (primary_part){
if(value_len < 8){
col_append_fstr(actx->pinfo->cinfo, COL_INFO, "[%s]",
- tvb_bytes_to_str(value_tvb,0,value_len));
+ tvb_bytes_to_ep_str(value_tvb,0,value_len));
}
else {
col_append_fstr(actx->pinfo->cinfo, COL_INFO, "[%s...]",
- tvb_bytes_to_str(value_tvb,0,7));
+ tvb_bytes_to_ep_str(value_tvb,0,7));
}
}
tp = g_new(hashether_t, 1);
memcpy(tp->addr, addr, sizeof(tp->addr));
tp->status = HASHETHER_STATUS_UNRESOLVED;
- g_strlcpy(tp->hexaddr, bytestring_to_str(addr, sizeof(tp->addr), ':'), sizeof(tp->hexaddr));
+ g_strlcpy(tp->hexaddr, bytestring_to_ep_str(addr, sizeof(tp->addr), ':'), sizeof(tp->hexaddr));
tp->resolved_name[0] = '\0';
if (resolve)
const gchar *
ether_to_str(const guint8 *ad)
{
- return bytestring_to_str(ad, 6, ':');
+ return bytestring_to_ep_str(ad, 6, ':');
}
const gchar *
tvb_ether_to_str(tvbuff_t *tvb, const gint offset)
{
- return bytestring_to_str(tvb_get_ptr(tvb, offset, 6), 6, ':');
+ return bytestring_to_ep_str(tvb_get_ptr(tvb, offset, 6), 6, ':');
}
/*
}
else {
buf = ep_strdup_printf("%s.%s", get_ipxnet_name(net),
- bytestring_to_str(ad, 6, '\0'));
+ bytestring_to_ep_str(ad, 6, '\0'));
}
return buf;
}
const gchar *
fc_to_str(const guint8 *ad)
{
- return bytestring_to_str (ad, 3, '.');
+ return bytestring_to_ep_str (ad, 3, '.');
}
const gchar *
tvb_fc_to_str(tvbuff_t *tvb, const gint offset)
{
- return bytestring_to_str (tvb_get_ptr(tvb, offset, 3), 3, '.');
+ return bytestring_to_ep_str (tvb_get_ptr(tvb, offset, 3), 3, '.');
}
/* FC Network Header Network Address Authority Identifiers */
const gchar *
ax25_to_str(const guint8 *ad)
{
- return bytestring_to_str(ad, 7, ':');
+ return bytestring_to_ep_str(ad, 7, ':');
}
/* XXX FIXME
dk->type = AIRPDCAP_KEY_TYPE_WEP;
/* XXX - The current key handling code in the GUI requires
* no separators and lower case */
- dk->key = g_string_new(bytes_to_str(key_ba->data, key_ba->len));
+ dk->key = g_string_new(bytes_to_ep_str(key_ba->data, key_ba->len));
g_string_ascii_down(dk->key);
dk->bits = key_ba->len * 8;
dk->ssid = NULL;
#endif
#endif
-#define DEBUG_DUMP(x,y,z) g_warning("%s: %s", x, bytes_to_str(y, (z)))
+#define DEBUG_DUMP(x,y,z) g_warning("%s: %s", x, bytes_to_ep_str(y, (z)))
#else /* !defined _DEBUG */
of address). */
return tvb_ether_to_str(tvb, offset);
}
- return tvb_bytes_to_str(tvb, offset, ad_len);
+ return tvb_bytes_to_ep_str(tvb, offset, ad_len);
}
static gchar *
/* Appletalk address. */
return tvb_atalkid_to_str(tvb, offset);
}
- return tvb_bytes_to_str(tvb, offset, ad_len);
+ return tvb_bytes_to_ep_str(tvb, offset, ad_len);
}
/* Offsets of fields within an AARP packet. */
return NULL;
}
- msg_info->dest_nsap = tvb_bytes_to_str(tvb,offset,20);
+ msg_info->dest_nsap = tvb_bytes_to_ep_str(tvb,offset,20);
proto_tree_add_item(tree, hf_alcap_dnsea, tvb, offset, 20, ENC_NA);
dissect_nsap(tvb, offset,20, tree);
return NULL;
}
- msg_info->orig_nsap = tvb_bytes_to_str(tvb,offset,20);
+ msg_info->orig_nsap = tvb_bytes_to_ep_str(tvb,offset,20);
proto_tree_add_item(tree, hf_alcap_onsea, tvb, offset, 20, ENC_NA);
dissect_nsap(tvb, offset,20, tree);
guint offset, guint bound _U_, guint length,
const char **value)
{
- *value = tvb_bytes_to_str(tvb, offset, length);
+ *value = tvb_bytes_to_ep_str(tvb, offset, length);
return length;
}
return length;
}
AMQP_INCREMENT(offset, length, bound);
- *value = tvb_bytes_to_str(tvb, offset, bin_length);
+ *value = tvb_bytes_to_ep_str(tvb, offset, bin_length);
AMQP_INCREMENT(offset, bin_length, bound);
return (bin_length + length);
}
* in the 8 octets case.
*/
if (len > 4){
- ansi_tcap_private.TransactionID_str = tvb_bytes_to_str(next_tvb, 4,len-4);
+ ansi_tcap_private.TransactionID_str = tvb_bytes_to_ep_str(next_tvb, 4,len-4);
}else{
- ansi_tcap_private.TransactionID_str = tvb_bytes_to_str(next_tvb, 0,len);
+ ansi_tcap_private.TransactionID_str = tvb_bytes_to_ep_str(next_tvb, 0,len);
}
}
switch(len) {
if (tree) {
ti = proto_tree_add_protocol_format(tree, proto_ap1394, tvb, 0, 18,
"Apple IP-over-IEEE 1394, Src: %s, Dst: %s",
- bytes_to_str(src_addr, 8), bytes_to_str(dst_addr, 8));
+ bytes_to_ep_str(src_addr, 8), bytes_to_ep_str(dst_addr, 8));
fh_tree = proto_item_add_subtree(ti, ett_ap1394);
proto_tree_add_bytes(fh_tree, hf_ap1394_dst, tvb, 0, 8, dst_addr);
proto_tree_add_bytes(fh_tree, hf_ap1394_src, tvb, 8, 8, src_addr);
address). */
return tvb_ether_to_str(tvb, offset);
}
- return tvb_bytes_to_str(tvb, offset, ad_len);
+ return tvb_bytes_to_ep_str(tvb, offset, ad_len);
}
static const gchar *
return get_ax25_name(ad);
/*return ax25_to_str(ad);*/
}
- return bytes_to_str(ad, ad_len);
+ return bytes_to_ep_str(ad, ad_len);
}
#define MAX_E164_STR_LEN 20
*
* XXX - break down into subcomponents.
*/
- return bytes_to_str(ad, ad_len);
+ return bytes_to_ep_str(ad, ad_len);
}
}
*
* XXX - break down into subcomponents?
*/
- return bytes_to_str(ad, ad_len);
+ return bytes_to_ep_str(ad, ad_len);
}
const value_string arp_hrd_vals[] = {
tvb_get_ntohs(tvb, offset + 1));
proto_tree_add_text(tree, tvb, offset + 3, 10,
"High Order DSP: %s",
- tvb_bytes_to_str(tvb, offset + 3, 10));
+ tvb_bytes_to_ep_str(tvb, offset + 3, 10));
proto_tree_add_text(tree, tvb, offset + 13, 6,
"End System Identifier: %s",
- tvb_bytes_to_str(tvb, offset + 13, 6));
+ tvb_bytes_to_ep_str(tvb, offset + 13, 6));
proto_tree_add_text(tree, tvb, offset + 19, 1,
"Selector: 0x%02X", tvb_get_guint8(tvb, offset + 19));
break;
tvb_get_ntohs(tvb, offset + 1));
proto_tree_add_text(tree, tvb, offset + 3, 10,
"High Order DSP: %s",
- tvb_bytes_to_str(tvb, offset + 3, 10));
+ tvb_bytes_to_ep_str(tvb, offset + 3, 10));
proto_tree_add_text(tree, tvb, offset + 13, 6,
"End System Identifier: %s",
- tvb_bytes_to_str(tvb, offset + 13, 6));
+ tvb_bytes_to_ep_str(tvb, offset + 13, 6));
proto_tree_add_text(tree, tvb, offset + 19, 1,
"Selector: 0x%02X", tvb_get_guint8(tvb, offset + 19));
break;
proto_tree_add_text(tree, tvb, offset + 0, 9,
"E.164 ISDN%s: %s",
(afi == 0xC3) ? " (group)" : "",
- tvb_bytes_to_str(tvb, offset + 1, 8));
+ tvb_bytes_to_ep_str(tvb, offset + 1, 8));
proto_tree_add_text(tree, tvb, offset + 9, 4,
"High Order DSP: %s",
- tvb_bytes_to_str(tvb, offset + 3, 10));
+ tvb_bytes_to_ep_str(tvb, offset + 3, 10));
proto_tree_add_text(tree, tvb, offset + 13, 6,
"End System Identifier: %s",
- tvb_bytes_to_str(tvb, offset + 13, 6));
+ tvb_bytes_to_ep_str(tvb, offset + 13, 6));
proto_tree_add_text(tree, tvb, offset + 19, 1,
"Selector: 0x%02X", tvb_get_guint8(tvb, offset + 19));
break;
"Unknown AFI: 0x%02X", afi);
proto_tree_add_text(tree, tvb, offset + 1, len - 1,
"Rest of address: %s",
- tvb_bytes_to_str(tvb, offset + 1, len - 1));
+ tvb_bytes_to_ep_str(tvb, offset + 1, len - 1));
break;
}
}
offset += fTagHeader(tvb, pinfo, offset, &tag_no, &tag_info, &lvt);
if (lvt > 0) {
- tmp = tvb_bytes_to_str(tvb, offset, lvt);
+ tmp = tvb_bytes_to_ep_str(tvb, offset, lvt);
ti = proto_tree_add_text(tree, tvb, offset, lvt, "%s %s", label, tmp);
offset += lvt;
}
proto_tree_add_uint(tree, hf_bacapp_tag_PORT, tvb, offset+16, 2, port);
} else { /* we have 1 Byte MS/TP Address or anything else interpreted as an address */
- tmp = tvb_bytes_to_str(tvb, offset, lvt);
+ tmp = tvb_bytes_to_ep_str(tvb, offset, lvt);
ti = proto_tree_add_text(tree, tvb, offset, lvt, "%s", tmp);
}
}
offset ++;
proto_tree_add_text(bacnet_tree, tvb, offset,
bacnet_pinfolen, "Port Info: %s",
- tvb_bytes_to_str(tvb, offset, bacnet_pinfolen));
+ tvb_bytes_to_ep_str(tvb, offset, bacnet_pinfolen));
offset += bacnet_pinfolen;
}
}
if (bitstring[byteno]) {
expert_add_info_format(
actx->pinfo, item, &ei_ber_bits_unknown,
- "Unknown bit(s): 0x%s", bytes_to_str(bitstring, len));
+ "Unknown bit(s): 0x%s", bytes_to_ep_str(bitstring, len));
break;
}
}
proto_tree_add_item(auth_tree, hf_bfd_auth_seq_num, tvb, offset+4, 4, ENC_BIG_ENDIAN);
proto_tree_add_text(auth_tree, tvb, offset+8, get_bfd_checksum_len(auth_type), "Checksum: 0x%s",
- tvb_bytes_to_str(tvb, offset+8, get_bfd_checksum_len(auth_type)) );
+ tvb_bytes_to_ep_str(tvb, offset+8, get_bfd_checksum_len(auth_type)) );
}
break;
default:
case TUNNEL_SUBTLV_ENCAPSULATION:
if (encaps_tunnel_type == TUNNEL_TYPE_L2TP_OVER_IP) {
proto_tree_add_text(subtree6, tvb, q + 2, 4, "Session ID: %u", tvb_get_letohl(tvb, q + 2));
- proto_tree_add_text(subtree6, tvb, q + 6, encaps_tunnel_sublen - 4, "Cookie: %s", tvb_bytes_to_str(tvb, q + 6, encaps_tunnel_sublen - 4));
+ proto_tree_add_text(subtree6, tvb, q + 6, encaps_tunnel_sublen - 4, "Cookie: %s", tvb_bytes_to_ep_str(tvb, q + 6, encaps_tunnel_sublen - 4));
} else if (encaps_tunnel_type == TUNNEL_TYPE_GRE) {
proto_tree_add_text(subtree6, tvb, q + 2, encaps_tunnel_sublen, "GRE key: %x", tvb_get_letohl(tvb, q + 2));
}
val_to_str_ext_const( enterprise, &sminmpec_values_ext, "Unknown"),
enterprise);
if (optlen > 6) {
- buf = tvb_bytes_to_str(tvb, optoff + 6, optlen - 11);
+ buf = tvb_bytes_to_ep_str(tvb, optoff + 6, optlen - 11);
proto_tree_add_text(v_tree, tvb, optoff + 6,
optlen - 11, "identifier: %s", buf);
}
/* fill the return data */
if( tohex )
- *result = tvb_bytes_to_str(tvb, offset, string_len );
+ *result = tvb_bytes_to_ep_str(tvb, offset, string_len );
else
*result = tvb_get_string( wmem_packet_scope(), tvb, offset, string_len );
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_item_append_text(node_ti, " (id: %s", tvb_bytes_to_str(tvb, offset, 20));
+ proto_item_append_text(node_ti, " (id: %s", tvb_bytes_to_ep_str(tvb, offset, 20));
proto_tree_add_item( node_tree, hf_ip, tvb, offset+20, 4, ENC_BIG_ENDIAN);
proto_item_append_text(node_ti, ", IP/Port: %s", tvb_ip_to_str(tvb, offset+20));
proto_tree_add_item( node_tree, hf_port, tvb, offset+24, 2, ENC_BIG_ENDIAN);
}
}
- return bytes_to_str(uuid->data, uuid->size);
+ return bytes_to_ep_str(uuid->data, uuid->size);
}
}
offset++;
continuation_state = (guint8 *) wmem_alloc(wmem_file_scope(), continuation_state_length);
- packet_scope_string = tvb_bytes_to_str(tvb, offset, continuation_state_length);
+ packet_scope_string = tvb_bytes_to_ep_str(tvb, offset, continuation_state_length);
memcpy(continuation_state, packet_scope_string, continuation_state_length);
if (!pinfo->fd->flags.visited) {
break;
case 0x352:
proto_tree_add_item(next_tree, hf_bpp_character_repertoires_support, tvb, offset, size, ENC_ASCII | ENC_NA);
- new_str = tvb_bytes_to_str(tvb, offset, size);
+ new_str = tvb_bytes_to_ep_str(tvb, offset, size);
wmem_strbuf_append(info_buf, new_str);
break;
case 0x354:
proto_tree_add_uint(tree, hf_c1222_auth_len, tvb, *offset, 1, auth_len);
*offset += 1;
if (*length >= auth_len) {
- auth_req = tvb_bytes_to_str(tvb, *offset, auth_len);
+ auth_req = tvb_bytes_to_ep_str(tvb, *offset, auth_len);
proto_tree_add_item(tree, hf_c1222_auth_data, tvb, *offset, auth_len, ENC_NA);
*offset += auth_len;
*length -= auth_len + 1;
col_add_fstr(pinfo->cinfo, COL_INFO, "p2p %s", function_code_str);
}
col_append_fstr(pinfo->cinfo, COL_INFO, " %s",
- tvb_bytes_to_str_punct(tvb, offset, can_data_len, ' '));
+ tvb_bytes_to_ep_str_punct(tvb, offset, can_data_len, ' '));
if (tree) {
proto_item *ti, *cob_ti, *type_ti;
proto_tree_add_item(tlv_tree, hf_cdp_tlvlength, tvb, offset + TLV_LENGTH, 2, ENC_BIG_ENDIAN);
proto_tree_add_text(tlv_tree, tvb, offset + 4,
length - 4, "System Object Identifier: %s",
- tvb_bytes_to_str(tvb, offset + 4, length - 4));
+ tvb_bytes_to_ep_str(tvb, offset + 4, length - 4));
}
offset += length;
break;
if (length != 0) {
proto_tree_add_text(address_tree, tvb, offset, length,
"Protocol: %s (truncated)",
- tvb_bytes_to_str(tvb, offset, length));
+ tvb_bytes_to_ep_str(tvb, offset, length));
}
return -1;
}
} else
nlpid = -1;
if (protocol_str == NULL)
- protocol_str = tvb_bytes_to_str(tvb, offset, protocol_length);
+ protocol_str = tvb_bytes_to_ep_str(tvb, offset, protocol_length);
proto_tree_add_text(address_tree, tvb, offset, protocol_length,
"Protocol: %s", protocol_str);
offset += protocol_length;
if (length != 0) {
proto_tree_add_text(address_tree, tvb, offset, length,
"Address: %s (truncated)",
- tvb_bytes_to_str(tvb, offset, length));
+ tvb_bytes_to_ep_str(tvb, offset, length));
}
return -1;
}
if (address_type_str == NULL)
address_type_str = "Address";
if (address_str == NULL) {
- address_str = tvb_bytes_to_str(tvb, offset, address_length);
+ address_str = tvb_bytes_to_ep_str(tvb, offset, address_length);
}
proto_item_set_text(ti, "%s: %s", address_type_str, address_str);
proto_tree_add_text(address_tree, tvb, offset, address_length, "%s: %s",
if (opt_length == 0)
str = nullstr;
else
- str = tvb_bytes_to_str_punct(tvb, offset, opt_length, ' ');
+ str = tvb_bytes_to_ep_str_punct(tvb, offset, opt_length, ' ');
proto_tree_add_item(subtree, hf, tvb, offset, opt_length, ENC_NA);
if (token_len > 0)
{
- g_strlcat(coap_token_str, tvb_bytes_to_str_punct(tvb, offset, token_len, ' '), sizeof(coap_token_str));
+ g_strlcat(coap_token_str, tvb_bytes_to_ep_str_punct(tvb, offset, token_len, ' '), sizeof(coap_token_str));
proto_tree_add_item(coap_tree, hf_coap_token,
tvb, offset, token_len, ENC_NA);
offset += token_len;
md5_append(&md_ctx, cp, bytes);
md5_finish(&md_ctx, digest);
- digest_string = bytestring_to_str(digest, 16, '\0');
+ digest_string = bytestring_to_ep_str(digest, 16, '\0');
ti = proto_tree_add_string(data_tree, &hfi_data_md5_hash, tvb, 0, 0, digest_string);
PROTO_ITEM_SET_GENERATED(ti);
}
start_offset += 12;
len = end_offset - start_offset;
- s = tvb_bytes_to_str(tvb, start_offset, len);
+ s = tvb_bytes_to_ep_str(tvb, start_offset, len);
/* Append string to upper-level proto_items */
if ((end_offset - start_offset) <= 12)
return;
- s = tvb_bytes_to_str(
+ s = tvb_bytes_to_ep_str(
tvb, start_offset + 12, (end_offset - start_offset - 12) );
/* Append string to COL_INFO */
proto_tree_add_string(ColumnsTree, hf_dect_cc_TA, tvb, offset, 1, "[Ct]");
if(ta==DECT_TA_CT0)
- wmem_strbuf_append_printf(afield_str,"C-Channel Next Data: %s",tvb_bytes_to_str(tvb, offset, 5));
+ wmem_strbuf_append_printf(afield_str,"C-Channel Next Data: %s",tvb_bytes_to_ep_str(tvb, offset, 5));
else
- wmem_strbuf_append_printf(afield_str,"C-Channel First Data: %s",tvb_bytes_to_str(tvb, offset, 5));
+ wmem_strbuf_append_printf(afield_str,"C-Channel First Data: %s",tvb_bytes_to_ep_str(tvb, offset, 5));
proto_tree_add_string(ColumnsTree, hf_dect_cc_AField, tvb, offset, 1, wmem_strbuf_get_str(afield_str));
}
/* ETSI EN 300 175-3 V2.3.0 7.2.2 */
proto_tree_add_string(ColumnsTree, hf_dect_cc_TA, tvb, offset, 1, "[Nt]");
- wmem_strbuf_append_printf(afield_str,"RFPI: %s",tvb_bytes_to_str(tvb, offset, 5));
+ wmem_strbuf_append_printf(afield_str,"RFPI: %s",tvb_bytes_to_ep_str(tvb, offset, 5));
proto_tree_add_string(ColumnsTree, hf_dect_cc_AField, tvb, offset, 1, wmem_strbuf_get_str(afield_str));
proto_tree_add_item(atailti, hf_dect_A_Tail_Nt, tvb, offset, 5, ENC_NA);
proto_tree_add_item(ATail, hf_dect_A_Tail_Qt_6_Spare, tvb, offset, 2, ENC_BIG_ENDIAN);
offset+=2;
- wmem_strbuf_append_printf(afield_str,"Multi-Frame No.: %s",tvb_bytes_to_str(tvb, offset, 3));
+ wmem_strbuf_append_printf(afield_str,"Multi-Frame No.: %s",tvb_bytes_to_ep_str(tvb, offset, 3));
proto_tree_add_string(ColumnsTree, hf_dect_cc_AField, tvb, offset, 1, wmem_strbuf_get_str(afield_str));
proto_tree_add_item(ATail, hf_dect_A_Tail_Qt_6_Mfn, tvb, offset, 3, ENC_NA);
break;
case 7: /* Escape */
/* ETSI EN 300 175-3 V2.3.0 7.2.3.8 */
- wmem_strbuf_append_printf(afield_str,"Escape Data: %s",tvb_bytes_to_str(tvb, offset, 5));
+ wmem_strbuf_append_printf(afield_str,"Escape Data: %s",tvb_bytes_to_ep_str(tvb, offset, 5));
proto_tree_add_string(ColumnsTree, hf_dect_cc_AField, tvb, offset, 1, wmem_strbuf_get_str(afield_str));
break;
case 8: /* Obsolete */
{
length = offset-start_offset;
proto_tree_add_bytes_format_value(devicenet_tree, hf_devicenet_data, tvb, offset, length,
- NULL, "%s", tvb_bytes_to_str_punct(tvb, offset, length, ' '));
+ NULL, "%s", tvb_bytes_to_ep_str_punct(tvb, offset, length, ' '));
offset += length;
}
return offset;
col_set_str(pinfo->cinfo, COL_INFO, val_to_str_const(message_id, devicenet_grp_msg1_vals, "Other Group 1 Message"));
proto_tree_add_bytes_format_value(devicenet_tree, hf_devicenet_data, tvb, offset, data_length,
- NULL, "%s", tvb_bytes_to_str_punct(tvb, offset, data_length, ' '));
+ NULL, "%s", tvb_bytes_to_ep_str_punct(tvb, offset, data_length, ' '));
}
/*
* Message group 2
case 0x4:
case 0x5:
proto_tree_add_bytes_format_value(content_tree, hf_devicenet_data, tvb, offset, data_length,
- NULL, "%s", tvb_bytes_to_str_punct(tvb, offset, data_length, ' '));
+ NULL, "%s", tvb_bytes_to_ep_str_punct(tvb, offset, data_length, ' '));
break;
case 0x6:
proto_tree_add_bytes_format_value(content_tree, hf_devicenet_data, tvb, offset, data_length,
- NULL, "%s", tvb_bytes_to_str_punct(tvb, offset, data_length, ' '));
+ NULL, "%s", tvb_bytes_to_ep_str_punct(tvb, offset, data_length, ' '));
break;
case 0x7:
if(service_rr & CIP_SC_MASK)
{
proto_tree_add_bytes_format_value(devicenet_tree, hf_devicenet_data, tvb, offset, data_length - 2,
- NULL, "%s", tvb_bytes_to_str_punct(tvb, offset, data_length - 2, ' '));
+ NULL, "%s", tvb_bytes_to_ep_str_punct(tvb, offset, data_length - 2, ' '));
}
else
{
break;
default:
proto_tree_add_bytes_format_value(content_tree, hf_devicenet_data, tvb, offset, data_length,
- NULL, "%s", tvb_bytes_to_str_punct(tvb, offset, data_length, ' '));
+ NULL, "%s", tvb_bytes_to_ep_str_punct(tvb, offset, data_length, ' '));
break;
}
}
opt_len = tlv_len;
if (tlv_len == 3) {
proto_item_append_text(ti, "%s",
- tvb_bytes_to_str_punct(tvb, sub_off, 3, ':'));
+ tvb_bytes_to_ep_str_punct(tvb, sub_off, 3, ':'));
} else if (tlv_len == 6) {
proto_item_append_text(ti, "\"%s\"", tvb_format_stringzpad(tvb, sub_off, tlv_len));
} else {
}
else {
proto_item_append_text(ti, "%s",
- tvb_bytes_to_str(tvb, sub_off, field_len));
+ tvb_bytes_to_ep_str(tvb, sub_off, field_len));
}
break;
case CL_OPTION_TLV5 :
}
else {
/*proto_item_append_text(ti, "CM MAC Address Option = %s", */
- proto_item_append_text(ti, "%s", tvb_bytes_to_str_punct(tvb, sub_off, opt_len, ':'));
- /* tvb_bytes_to_str(tvb, sub_off, opt_len)); */
+ proto_item_append_text(ti, "%s", tvb_bytes_to_ep_str_punct(tvb, sub_off, opt_len, ':'));
+ /* tvb_bytes_to_ep_str(tvb, sub_off, opt_len)); */
}
break;
case CL_EROUTER_CONTAINER_OPTION :
opt_len = tlv_len;
proto_item_append_text(ti, " %s (len=%d)",
- tvb_bytes_to_str(tvb, sub_off, opt_len), tlv_len);
+ tvb_bytes_to_ep_str(tvb, sub_off, opt_len), tlv_len);
break;
case CL_OPTION_CCC :
opt_len = tlv_len;
switch (opttype) {
case OPTION_CLIENTID:
- col_append_fstr(pinfo->cinfo, COL_INFO, "CID: %s ", tvb_bytes_to_str(tvb, off, optlen));
+ col_append_fstr(pinfo->cinfo, COL_INFO, "CID: %s ", tvb_bytes_to_ep_str(tvb, off, optlen));
/* Fall through */
case OPTION_SERVERID:
case OPTION_RELAYID:
} else if (dmp_nat_decode == NAT_DECODE_THALES) {
mts_id = dissect_thales_mts_id (tvb, offset, dmp.mts_id_length);
} else {
- mts_id = tvb_bytes_to_str (tvb, offset, dmp.mts_id_length);
+ mts_id = tvb_bytes_to_ep_str (tvb, offset, dmp.mts_id_length);
}
proto_item_append_text (dmp.mts_id_item, " (%zu bytes decompressed)", strlen (mts_id));
mts_id = format_text (mts_id, strlen (mts_id));
} else if (dmp_nat_decode == NAT_DECODE_THALES) {
ipm_id = dissect_thales_ipm_id (tvb, offset, ipm_id_length, modifier);
} else {
- ipm_id = tvb_bytes_to_str (tvb, offset, ipm_id_length);
+ ipm_id = tvb_bytes_to_ep_str (tvb, offset, ipm_id_length);
}
proto_item_append_text (tf, " (%zu bytes decompressed)", strlen (ipm_id));
ipm_id = format_text (ipm_id, strlen (ipm_id));
} else {
proto_tree_add_text(eap_tree, tvb, offset, value_size,
"EAP-MS-CHAP-v2 Response (Unknown Length): %s",
- tvb_bytes_to_str(tvb, offset, value_size));
+ tvb_bytes_to_ep_str(tvb, offset, value_size));
offset += value_size;
left -= value_size;
}
proto_tree_add_text(eap_tree, tvb, offset, left,
"EAP-MS-CHAP-v2 Data (%d byte%s): \"%s\"",
left, plurality(left, "", "s"),
- tvb_bytes_to_str(tvb, offset, left));
+ tvb_bytes_to_ep_str(tvb, offset, left));
break;
}
}
proto_tree_add_text(eap_tree, tvb, offset, count,
"EAP-LEAP Data (%d byte%s): \"%s\"",
count, plurality(count, "", "s"),
- tvb_bytes_to_str(tvb, offset, count));
+ tvb_bytes_to_ep_str(tvb, offset, count));
break;
}
}
proto_tree_add_text(eap_tree, tvb, offset, size,
"EAP Data (%d byte%s): \"%s\"",
size, plurality(size, "", "s"),
- tvb_bytes_to_str(tvb, offset, size));
+ tvb_bytes_to_ep_str(tvb, offset, size));
}
break;
/*********************************************************************
guint16 bsob_length;
bsob_length = tvb_get_guint8(tvb, offset);
- *string_value = tvb_bytes_to_str( tvb, offset + 1, bsob_length );
+ *string_value = tvb_bytes_to_ep_str( tvb, offset + 1, bsob_length );
proto_tree_add_item(tree, hf_kademlia_tag_bsob, tvb, offset + 1, bsob_length, ENC_NA);
return offset + 1 + bsob_length;
switch( type )
{
case KADEMLIA_TAGTYPE_HASH:
- proto_item_append_text( tag_node, "%s", tvb_bytes_to_str( tvb, offset, 16 ));
+ proto_item_append_text( tag_node, "%s", tvb_bytes_to_ep_str( tvb, offset, 16 ));
offset = dissect_kademlia_tag_hash( tvb, pinfo, offset, subtree );
break;
case KADEMLIA_TAGTYPE_STRING:
ti = proto_tree_add_bytes_format(cat_tree, hf_cat_tlv, tvb, pos,
len, ptr, "%s: %s",
val_to_str(tag, comp_tlv_tag_vals, "%02x"),
- (const guint8 *)tvb_bytes_to_str(tvb, pos, len));
+ (const guint8 *)tvb_bytes_to_ep_str(tvb, pos, len));
#else
ti = proto_tree_add_bytes_format(cat_tree, hf_cat_tlv, tvb, pos,
len, ptr, "%s: ",
proto_tree_add_text (tree, tvb, offset, 4,
"Logical Paths %d-%d: %s",
i*8, ((i+4)*8) - 1,
- tvb_bytes_to_str_punct (tvb, offset, 4, ':'));
+ tvb_bytes_to_ep_str_punct (tvb, offset, 4, ':'));
i += 4;
offset += 4;
}
proto_tree_add_item(subtree, hf_fip_desc_mac, desc_tvb,
2, 6, ENC_NA);
proto_item_append_text(item, "%s",
- tvb_bytes_to_str_punct(desc_tvb, 2, 6, ':'));
+ tvb_bytes_to_ep_str_punct(desc_tvb, 2, 6, ':'));
break;
case FIP_DT_MAP_OUI:
subtree = proto_item_add_subtree(item, ett_fip_dt_map);
proto_tree_add_string(subtree, hf_fip_desc_vn_wwpn,
desc_tvb, 12, 8, text);
proto_item_append_text(item, "MAC %s FC_ID %6.6x",
- tvb_bytes_to_str_punct(desc_tvb, 2, 6, ':'),
+ tvb_bytes_to_ep_str_punct(desc_tvb, 2, 6, ':'),
tvb_get_ntoh24(desc_tvb, 9));
break;
case FIP_DT_FKA:
md5_append(&md_ctx, cp, cap_len);
md5_finish(&md_ctx, digest);
- digest_string = bytestring_to_str(digest, 16, '\0');
+ digest_string = bytestring_to_ep_str(digest, 16, '\0');
ti = proto_tree_add_string(fh_tree, hf_frame_md5_hash, tvb, 0, 0, digest_string);
PROTO_ITEM_SET_GENERATED(ti);
}
proto_tree_add_text(tree,
tvb, curr_offset, len - (curr_offset - offset),
"Key: %s",
- tvb_bytes_to_str(tvb, curr_offset, len-(curr_offset-offset) ));
+ tvb_bytes_to_ep_str(tvb, curr_offset, len-(curr_offset-offset) ));
curr_offset += len - (curr_offset - offset);
{
diag_length = len - (curr_offset - offset);
proto_tree_add_text(subtree, tvb, curr_offset, diag_length,
- "Data: %s", tvb_bytes_to_str(tvb, curr_offset, diag_length));
+ "Data: %s", tvb_bytes_to_ep_str(tvb, curr_offset, diag_length));
curr_offset += diag_length;
}
item = proto_tree_add_text(tree, tvb, curr_offset, len - 1, "User-user information");
subtree = proto_item_add_subtree(item, ett_gsm_dtap_elem[DE_USER_USER]);
proto_tree_add_text(subtree, tvb, curr_offset, len - 1,
- "Data: %s", tvb_bytes_to_str(tvb, curr_offset, len - 1));
+ "Data: %s", tvb_bytes_to_ep_str(tvb, curr_offset, len - 1));
return(len);
}
switch (param) {
case 0x01:
proto_tree_add_text(tf_tree, tvb, curr_offset, pf_length, "Authorization token value: 0x%s",
- tvb_bytes_to_str(tvb, curr_offset, pf_length));
+ tvb_bytes_to_ep_str(tvb, curr_offset, pf_length));
break;
case 0x02:
default:
proto_tree_add_text(tf_tree, tvb, curr_offset, pf_length, "Parameter content: 0x%s",
- tvb_bytes_to_str(tvb, curr_offset, pf_length));
+ tvb_bytes_to_ep_str(tvb, curr_offset, pf_length));
break;
}
curr_offset += pf_length;
offset, len, NULL,
"%s: %s",
val_to_str_ext(iei, &om2k_attr_vals_ext, "0x%02x"),
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
return len;
}
break;
case 0x04: /* select by AID */
col_append_fstr(pinfo->cinfo, COL_INFO, "Application %s ",
- tvb_bytes_to_str(tvb, offset+DATA_OFFS, p3));
+ tvb_bytes_to_ep_str(tvb, offset+DATA_OFFS, p3));
proto_tree_add_item(tree, hf_aid, tvb, offset+DATA_OFFS, p3, ENC_NA);
break;
te = proto_tree_add_text(tree, tvb, offset, 29, "%s", val_to_str_ext_const(GTP_EXT_AUTH_TRI, >p_val_ext, "Unknown message"));
ext_tree_auth_tri = proto_item_add_subtree(te, ett_gtp_ies[GTP_EXT_AUTH_TRI]);
- proto_tree_add_text(ext_tree_auth_tri, tvb, offset + 1, 16, "RAND: %s", tvb_bytes_to_str(tvb, offset + 1, 16));
- proto_tree_add_text(ext_tree_auth_tri, tvb, offset + 17, 4, "SRES: %s", tvb_bytes_to_str(tvb, offset + 17, 4));
- proto_tree_add_text(ext_tree_auth_tri, tvb, offset + 21, 8, "Kc: %s", tvb_bytes_to_str(tvb, offset + 21, 8));
+ proto_tree_add_text(ext_tree_auth_tri, tvb, offset + 1, 16, "RAND: %s", tvb_bytes_to_ep_str(tvb, offset + 1, 16));
+ proto_tree_add_text(ext_tree_auth_tri, tvb, offset + 17, 4, "SRES: %s", tvb_bytes_to_ep_str(tvb, offset + 17, 4));
+ proto_tree_add_text(ext_tree_auth_tri, tvb, offset + 21, 8, "Kc: %s", tvb_bytes_to_ep_str(tvb, offset + 21, 8));
return 1 + 16 + 4 + 8;
}
te_trip = proto_tree_add_text(tree, tvb, offset + i * 28, 28, "Triplet no%x", i);
ext_tree_trip = proto_item_add_subtree(te_trip, ett_gtp_trip);
- proto_tree_add_text(ext_tree_trip, tvb, offset + i * 28, 16, "RAND: %s", tvb_bytes_to_str(tvb, offset + i * 28, 16));
- proto_tree_add_text(ext_tree_trip, tvb, offset + i * 28 + 16, 4, "SRES: %s", tvb_bytes_to_str(tvb, offset + i * 28 + 16, 4));
- proto_tree_add_text(ext_tree_trip, tvb, offset + i * 28 + 20, 8, "Kc: %s", tvb_bytes_to_str(tvb, offset + i * 28 + 20, 8));
+ proto_tree_add_text(ext_tree_trip, tvb, offset + i * 28, 16, "RAND: %s", tvb_bytes_to_ep_str(tvb, offset + i * 28, 16));
+ proto_tree_add_text(ext_tree_trip, tvb, offset + i * 28 + 16, 4, "SRES: %s", tvb_bytes_to_ep_str(tvb, offset + i * 28 + 16, 4));
+ proto_tree_add_text(ext_tree_trip, tvb, offset + i * 28 + 20, 8, "Kc: %s", tvb_bytes_to_ep_str(tvb, offset + i * 28 + 20, 8));
}
return count * 28;
ext_tree_quint = proto_item_add_subtree(te_quint, ett_gtp_quint);
- proto_tree_add_text(ext_tree_quint, tvb, offset + q_offset, 16, "RAND: %s", tvb_bytes_to_str(tvb, offset, 16));
+ proto_tree_add_text(ext_tree_quint, tvb, offset + q_offset, 16, "RAND: %s", tvb_bytes_to_ep_str(tvb, offset, 16));
q_offset = q_offset + 16;
xres_len = tvb_get_guint8(tvb, offset + q_offset);
proto_tree_add_text(ext_tree_quint, tvb, offset + q_offset, 1, "XRES length: %u", xres_len);
q_offset++;
- proto_tree_add_text(ext_tree_quint, tvb, offset + q_offset, xres_len, "XRES: %s", tvb_bytes_to_str(tvb, offset + q_offset, xres_len));
+ proto_tree_add_text(ext_tree_quint, tvb, offset + q_offset, xres_len, "XRES: %s", tvb_bytes_to_ep_str(tvb, offset + q_offset, xres_len));
q_offset = q_offset + xres_len;
- proto_tree_add_text(ext_tree_quint, tvb, offset + q_offset, 16, "Quintuplet Ciphering Key: %s", tvb_bytes_to_str(tvb, offset + q_offset, 16));
+ proto_tree_add_text(ext_tree_quint, tvb, offset + q_offset, 16, "Quintuplet Ciphering Key: %s", tvb_bytes_to_ep_str(tvb, offset + q_offset, 16));
q_offset = q_offset + 16;
- proto_tree_add_text(ext_tree_quint, tvb, offset + q_offset, 16, "Quintuplet Integrity Key: %s", tvb_bytes_to_str(tvb, offset + q_offset, 16));
+ proto_tree_add_text(ext_tree_quint, tvb, offset + q_offset, 16, "Quintuplet Integrity Key: %s", tvb_bytes_to_ep_str(tvb, offset + q_offset, 16));
q_offset = q_offset + 16;
auth_len = tvb_get_guint8(tvb, offset + q_offset);
proto_tree_add_text(ext_tree_quint, tvb, offset + q_offset, 1, "Authentication length: %u", auth_len);
q_offset++;
- proto_tree_add_text(ext_tree_quint, tvb, offset + q_offset, auth_len, "AUTH: %s", tvb_bytes_to_str(tvb, offset + q_offset, auth_len));
+ proto_tree_add_text(ext_tree_quint, tvb, offset + q_offset, auth_len, "AUTH: %s", tvb_bytes_to_ep_str(tvb, offset + q_offset, auth_len));
q_offset = q_offset + auth_len;
proto_item_set_end(te_quint, tvb, offset + q_offset);
proto_tree_add_item(ext_tree_mm, hf_gtp_security_mode, tvb, offset + 4, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(ext_tree_mm, hf_gtp_no_of_vectors, tvb, offset + 4, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(ext_tree_mm, hf_gtp_cipher_algorithm, tvb, offset + 4, 1, ENC_BIG_ENDIAN);
- proto_tree_add_text(ext_tree_mm, tvb, offset + 5, 16, "Ciphering key CK: %s", tvb_bytes_to_str(tvb, offset + 5, 16));
- proto_tree_add_text(ext_tree_mm, tvb, offset + 21, 16, "Integrity key IK: %s", tvb_bytes_to_str(tvb, offset + 21, 16));
+ proto_tree_add_text(ext_tree_mm, tvb, offset + 5, 16, "Ciphering key CK: %s", tvb_bytes_to_ep_str(tvb, offset + 5, 16));
+ proto_tree_add_text(ext_tree_mm, tvb, offset + 21, 16, "Integrity key IK: %s", tvb_bytes_to_ep_str(tvb, offset + 21, 16));
quint_len = tvb_get_ntohs(tvb, offset + 37);
proto_tree_add_text(ext_tree_mm, tvb, offset + 37, 2, "Quintuplets length: 0x%x (%u)", quint_len, quint_len);
proto_tree_add_item(ext_tree_mm, hf_gtp_no_of_vectors, tvb, offset + 4, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(ext_tree_mm, hf_gtp_cipher_algorithm, tvb, offset + 4, 1, ENC_BIG_ENDIAN);
- proto_tree_add_text(ext_tree_mm, tvb, offset + 5, 8, "Ciphering key Kc: %s", tvb_bytes_to_str(tvb, offset + 5, 8));
+ proto_tree_add_text(ext_tree_mm, tvb, offset + 5, 8, "Ciphering key Kc: %s", tvb_bytes_to_ep_str(tvb, offset + 5, 8));
offset = offset + decode_triplet(tvb, offset + 13, ext_tree_mm, count) + 13;
proto_tree_add_item(ext_tree_mm, hf_gtp_ksi, tvb, offset + 3, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(ext_tree_mm, hf_gtp_security_mode, tvb, offset + 4, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(ext_tree_mm, hf_gtp_no_of_vectors, tvb, offset + 4, 1, ENC_BIG_ENDIAN);
- proto_tree_add_text(ext_tree_mm, tvb, offset + 5, 16, "Ciphering key CK: %s", tvb_bytes_to_str(tvb, offset + 5, 16));
- proto_tree_add_text(ext_tree_mm, tvb, offset + 21, 16, "Integrity key IK: %s", tvb_bytes_to_str(tvb, offset + 21, 16));
+ proto_tree_add_text(ext_tree_mm, tvb, offset + 5, 16, "Ciphering key CK: %s", tvb_bytes_to_ep_str(tvb, offset + 5, 16));
+ proto_tree_add_text(ext_tree_mm, tvb, offset + 21, 16, "Integrity key IK: %s", tvb_bytes_to_ep_str(tvb, offset + 21, 16));
quint_len = tvb_get_ntohs(tvb, offset + 37);
proto_tree_add_text(ext_tree_mm, tvb, offset + 37, 2, "Quintuplets length: 0x%x (%u)", quint_len, quint_len);
proto_tree_add_item(ext_tree_mm, hf_gtp_no_of_vectors, tvb, offset + 4, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(ext_tree_mm, hf_gtp_cipher_algorithm, tvb, offset + 4, 1, ENC_BIG_ENDIAN);
proto_tree_add_text(ext_tree_mm, tvb, offset + 5, 8,
- "Ciphering key Kc: %s", tvb_bytes_to_str(tvb, offset + 5, 8));
+ "Ciphering key Kc: %s", tvb_bytes_to_ep_str(tvb, offset + 5, 8));
quint_len = tvb_get_ntohs(tvb, offset + 13);
proto_tree_add_text(ext_tree_mm, tvb, offset + 13, 2, "Quintuplets length: 0x%x (%u)", quint_len, quint_len);
proto_tree_add_item(ext_tree, hf_gtp_ext_length, tvb, offset, 2, ENC_BIG_ENDIAN);
offset = offset + 2;
- proto_tree_add_text(ext_tree, tvb, offset, 16, "RAND: %s", tvb_bytes_to_str(tvb, offset, 16));
+ proto_tree_add_text(ext_tree, tvb, offset, 16, "RAND: %s", tvb_bytes_to_ep_str(tvb, offset, 16));
offset = offset + 16;
xres_len = tvb_get_guint8(tvb, offset);
proto_tree_add_text(ext_tree, tvb, offset, 1, "XRES length: %u", xres_len);
offset++;
- proto_tree_add_text(ext_tree, tvb, offset, xres_len, "XRES: %s", tvb_bytes_to_str(tvb, offset, xres_len));
+ proto_tree_add_text(ext_tree, tvb, offset, xres_len, "XRES: %s", tvb_bytes_to_ep_str(tvb, offset, xres_len));
offset = offset + xres_len;
- proto_tree_add_text(ext_tree, tvb, offset, 16, "Quintuplet Ciphering Key: %s", tvb_bytes_to_str(tvb, offset, 16));
+ proto_tree_add_text(ext_tree, tvb, offset, 16, "Quintuplet Ciphering Key: %s", tvb_bytes_to_ep_str(tvb, offset, 16));
offset = offset + 16;
- proto_tree_add_text(ext_tree, tvb, offset, 16, "Quintuplet Integrity Key: %s", tvb_bytes_to_str(tvb, offset, 16));
+ proto_tree_add_text(ext_tree, tvb, offset, 16, "Quintuplet Integrity Key: %s", tvb_bytes_to_ep_str(tvb, offset, 16));
offset = offset + 16;
auth_len = tvb_get_guint8(tvb, offset);
proto_tree_add_text(ext_tree, tvb, offset, 1, "Authentication length: %u", auth_len);
offset++;
- proto_tree_add_text(ext_tree, tvb, offset, auth_len, "AUTH: %s", tvb_bytes_to_str(tvb, offset, auth_len));
+ proto_tree_add_text(ext_tree, tvb, offset, auth_len, "AUTH: %s", tvb_bytes_to_ep_str(tvb, offset, auth_len));
return (3 + length);
break;
}
- return tvb_bytes_to_str(tvb, 0, length);
+ return tvb_bytes_to_ep_str(tvb, 0, length);
}
/*
* to Target RNC Transparent Container IE defined in 3GPP TS 25.413 [9]. The Transparent container field includes the
* IE value part as it is specified in the respective specification.
*/
- proto_tree_add_text(tree, tvb, offset, length-1, "Transparent Container: %s", tvb_bytes_to_str(tvb, offset, length-1));
+ proto_tree_add_text(tree, tvb, offset, length-1, "Transparent Container: %s", tvb_bytes_to_ep_str(tvb, offset, length-1));
/*
* bssmap_old_bss_to_new_bss_info(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo);
* dissect_ranap_SourceRNC_ToTargetRNC_TransparentContainer_PDU
offset += 1;
/* Transparent Container */
- proto_tree_add_text(tree, tvb, offset, length-1, "Transparent Container: %s", tvb_bytes_to_str(tvb, offset, length-1));
+ proto_tree_add_text(tree, tvb, offset, length-1, "Transparent Container: %s", tvb_bytes_to_ep_str(tvb, offset, length-1));
}
proto_tree_add_item(tree, hf_gtpv2_eksi, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
- proto_tree_add_text(tree, tvb, offset , 16, "CKsrvcc: %s ", tvb_bytes_to_str(tvb, offset, 16));
+ proto_tree_add_text(tree, tvb, offset , 16, "CKsrvcc: %s ", tvb_bytes_to_ep_str(tvb, offset, 16));
offset += 16;
- proto_tree_add_text(tree, tvb, offset, 16, "IKsrvcc: %s ", tvb_bytes_to_str(tvb, offset, 16));
+ proto_tree_add_text(tree, tvb, offset, 16, "IKsrvcc: %s ", tvb_bytes_to_ep_str(tvb, offset, 16));
offset += 16;
/* Length of Mobile Station Classmark2 */
elm_len = tvb_get_guint8(tvb, offset);
proto_tree_add_item(tree, hf_gtpv2_len_ms_classmark2, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
- fi = proto_tree_add_text(tree, tvb, offset, elm_len, "Mobile Station Classmark2 %s", tvb_bytes_to_str(tvb, offset, elm_len));
+ fi = proto_tree_add_text(tree, tvb, offset, elm_len, "Mobile Station Classmark2 %s", tvb_bytes_to_ep_str(tvb, offset, elm_len));
ms_tree = proto_item_add_subtree(fi, ett_gtpv2_ms_mark);
de_ms_cm_2(tvb, ms_tree, pinfo, offset, elm_len, NULL, 0);
offset += elm_len;
elm_len = tvb_get_guint8(tvb, offset);
proto_tree_add_item(tree, hf_gtpv2_len_ms_classmark3, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
- fi = proto_tree_add_text(tree, tvb, offset, elm_len, "Mobile Station Classmark3 %s", tvb_bytes_to_str(tvb, offset, elm_len));
+ fi = proto_tree_add_text(tree, tvb, offset, elm_len, "Mobile Station Classmark3 %s", tvb_bytes_to_ep_str(tvb, offset, elm_len));
ms_tree = proto_item_add_subtree(fi, ett_gtpv2_ms_mark);
de_ms_cm_3(tvb, ms_tree, pinfo, offset, elm_len, NULL, 0);
offset += elm_len;
elm_len = tvb_get_guint8(tvb, offset);
proto_tree_add_item(tree, hf_gtpv2_len_supp_codec_list, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
- fi = proto_tree_add_text(tree, tvb, offset, elm_len, "Supported Codec List %s", tvb_bytes_to_str(tvb, offset, elm_len));
+ fi = proto_tree_add_text(tree, tvb, offset, elm_len, "Supported Codec List %s", tvb_bytes_to_ep_str(tvb, offset, elm_len));
ms_tree = proto_item_add_subtree(fi, ett_gtpv2_supp_codec_list);
de_sup_codec_list(tvb, ms_tree, pinfo, offset, elm_len, NULL, 0);
proto_tree_add_item(tree, hf_gtpv2_ksi, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
- proto_tree_add_text(tree, tvb, offset, 16, "CK'cs: %s", tvb_bytes_to_str(tvb, offset, 16));
+ proto_tree_add_text(tree, tvb, offset, 16, "CK'cs: %s", tvb_bytes_to_ep_str(tvb, offset, 16));
offset += 16;
- proto_tree_add_text(tree, tvb, offset, 16, "IK'cs: %s", tvb_bytes_to_str(tvb, offset, 16));
+ proto_tree_add_text(tree, tvb, offset, 16, "IK'cs: %s", tvb_bytes_to_ep_str(tvb, offset, 16));
offset += 16;
- proto_tree_add_text(tree, tvb, offset, 8, "Kc': %s", tvb_bytes_to_str(tvb, offset, 8));
+ proto_tree_add_text(tree, tvb, offset, 8, "Kc': %s", tvb_bytes_to_ep_str(tvb, offset, 8));
offset += 8;
proto_tree_add_item(tree, hf_gtpv2_cksn, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
elm_len = tvb_get_guint8(tvb, offset);
proto_tree_add_item(tree, hf_gtpv2_len_ms_classmark2, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
- fi = proto_tree_add_text(tree, tvb, offset, elm_len, "Mobile Station Classmark2 %s", tvb_bytes_to_str(tvb, offset, elm_len));
+ fi = proto_tree_add_text(tree, tvb, offset, elm_len, "Mobile Station Classmark2 %s", tvb_bytes_to_ep_str(tvb, offset, elm_len));
ms_tree = proto_item_add_subtree(fi, ett_gtpv2_ms_mark);
de_ms_cm_2(tvb, ms_tree, pinfo, offset, elm_len, NULL, 0);
offset += elm_len;
elm_len = tvb_get_guint8(tvb, offset);
proto_tree_add_item(tree, hf_gtpv2_len_ms_classmark3, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
- fi = proto_tree_add_text(tree, tvb, offset, elm_len, "Mobile Station Classmark3 %s", tvb_bytes_to_str(tvb, offset, elm_len));
+ fi = proto_tree_add_text(tree, tvb, offset, elm_len, "Mobile Station Classmark3 %s", tvb_bytes_to_ep_str(tvb, offset, elm_len));
ms_tree = proto_item_add_subtree(fi, ett_gtpv2_ms_mark);
de_ms_cm_3(tvb, ms_tree, pinfo, offset, elm_len, NULL, 0);
offset += elm_len;
elm_len = tvb_get_guint8(tvb, offset);
proto_tree_add_item(tree, hf_gtpv2_len_supp_codec_list, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
- fi = proto_tree_add_text(tree, tvb, offset, elm_len, "Supported Codec List %s", tvb_bytes_to_str(tvb, offset, elm_len));
+ fi = proto_tree_add_text(tree, tvb, offset, elm_len, "Supported Codec List %s", tvb_bytes_to_ep_str(tvb, offset, elm_len));
ms_tree = proto_item_add_subtree(fi, ett_gtpv2_supp_codec_list);
de_sup_codec_list(tvb, ms_tree, pinfo, offset, elm_len, NULL, 0);
proto_tree_add_item(tree, hf_gtpv2_teid_c, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
if (length > 4)
- proto_tree_add_text(tree, tvb, offset, length-4, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-4));
+ proto_tree_add_text(tree, tvb, offset, length-4, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-4));
proto_item_append_text(item, "%u", tvb_get_ntohl(tvb, offset-4));
}
proto_tree_add_item(tree, hf_gtpv2_sv_emind, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
if (length > 1)
- proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-1));
+ proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-1));
}
/* 6.12 Service Area Identifier */
proto_tree_add_item(tree, hf_gtpv2_f_teid_gre_key, tvb, offset, 4, ENC_BIG_ENDIAN);
proto_item_append_text(item, "%s, TEID/GRE Key: 0x%s",
val_to_str_ext_const((flags & 0x3f), >pv2_f_teid_interface_type_vals_ext, "Unknown"),
- tvb_bytes_to_str(tvb, offset, 4));
+ tvb_bytes_to_ep_str(tvb, offset, 4));
offset += 4;
if (flags & 0x80)
dissect_gtpv2_tmsi(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, proto_item *item, guint16 length, guint8 message_type _U_, guint8 instance _U_)
{
proto_tree_add_item(tree, hf_gtpv2_tmsi, tvb, 0, 4, ENC_BIG_ENDIAN);
- proto_tree_add_text(item, tvb, 0, length, "TMSI: %s", tvb_bytes_to_str(tvb, 0, 4));
+ proto_tree_add_text(item, tvb, 0, length, "TMSI: %s", tvb_bytes_to_ep_str(tvb, 0, 4));
}
/*
* 8.24 Global CN-Id
/* >CN-ID M INTEGER (0..4095) */
proto_tree_add_text(tree, tvb, offset, 2, "CN-Id: %s",
- tvb_bytes_to_str(tvb, offset, 2));
+ tvb_bytes_to_ep_str(tvb, offset, 2));
}
/*
* 8.25 S103 PDN Data Forwarding Info (S103PDF)
* Will be displayed if length of Trace Depth Length is > 0
* The list will only contains UTF8String, RAW DATA
*/
- proto_tree_add_text(tree, tvb, offset, tdl, "Trace Depth List: %s", tvb_bytes_to_str(tvb, offset, tdl));
+ proto_tree_add_text(tree, tvb, offset, tdl, "Trace Depth List: %s", tvb_bytes_to_ep_str(tvb, offset, tdl));
offset += tdl;
/* Set up subtree interfaces and put all interfaces under it */
int offset = 0;
/* 36.413 : 9.2.1.17 Paging Cause, void */
- proto_tree_add_text(tree, tvb, offset, length, "DRX parameter: %s", tvb_bytes_to_str(tvb, offset, (length )));
+ proto_tree_add_text(tree, tvb, offset, length, "DRX parameter: %s", tvb_bytes_to_ep_str(tvb, offset, (length )));
}
/*
*/
proto_tree_add_item(auth_tri_tree, hf_gtpv2_mm_context_rand, tvb, offset, 16, ENC_NA);
offset += 16;
- proto_tree_add_text(auth_tri_tree, tvb, offset, 4, "SRES': %s", tvb_bytes_to_str(tvb, offset, 4));
+ proto_tree_add_text(auth_tri_tree, tvb, offset, 4, "SRES': %s", tvb_bytes_to_ep_str(tvb, offset, 4));
offset += 4;
- proto_tree_add_text(auth_tri_tree, tvb, offset, 8, "Kc': %s", tvb_bytes_to_str(tvb, offset, 8));
+ proto_tree_add_text(auth_tri_tree, tvb, offset, 8, "Kc': %s", tvb_bytes_to_ep_str(tvb, offset, 8));
offset += 8;
}
auth_qua_tree = proto_item_add_subtree(auth_qua_item, ett_gtpv2_mm_context_auth_qua);
proto_tree_add_text(auth_qua_tree, tvb, offset, 16, "RAND: %s",
- tvb_bytes_to_str(tvb, offset, 16));
+ tvb_bytes_to_ep_str(tvb, offset, 16));
offset += 16;
tmp = tvb_get_guint8(tvb, offset++);
proto_tree_add_text(auth_qua_tree, tvb, offset, tmp, "XRES: %s",
- tvb_bytes_to_str(tvb, offset, tmp));
+ tvb_bytes_to_ep_str(tvb, offset, tmp));
offset += tmp;
tmp = tvb_get_guint8(tvb, offset++);
proto_tree_add_text(auth_qua_tree, tvb, offset, tmp, "AUTN: %s",
- tvb_bytes_to_str(tvb, offset, tmp));
+ tvb_bytes_to_ep_str(tvb, offset, tmp));
offset += tmp;
proto_tree_add_item(tree, hf_gtpv2_mm_context_kasme, tvb, offset, 32, ENC_BIG_ENDIAN);
offset += 1;
/* 8 to 15 Kc */
- proto_tree_add_text(tree, tvb, offset, 8, "Kc': %s", tvb_bytes_to_str(tvb, offset, 8));
+ proto_tree_add_text(tree, tvb, offset, 8, "Kc': %s", tvb_bytes_to_ep_str(tvb, offset, 8));
offset += 8;
/* 16 to h Authentication Triplet [0..4] */
proto_tree_add_item(flag_tree, hf_gtpv2_mm_context_used_cipher, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
/* 8 to 15 Kc */
- proto_tree_add_text(tree, tvb, offset, 8, "Kc': %s", tvb_bytes_to_str(tvb, offset, 8));
+ proto_tree_add_text(tree, tvb, offset, 8, "Kc': %s", tvb_bytes_to_ep_str(tvb, offset, 8));
offset += 8;
/*
if ( nhi )
{
proto_tree_add_text(tree, tvb, offset, 32, "NH (Next Hop): %s",
- tvb_bytes_to_str(tvb, offset, 32));
+ tvb_bytes_to_ep_str(tvb, offset, 32));
offset += 32;
proto_tree_add_text(tree, tvb, offset, 1, "NCC (Next Hop Chaining Count): %d",
/* The TMSI consists of 4 octets. It can be coded using a full hexadecimal representation. */
proto_tree_add_item(tree, hf_gtpv2_p_tmsi, tvb, offset, 4, ENC_BIG_ENDIAN);
- proto_item_append_text(item, "%s", tvb_bytes_to_str(tvb, offset, 4));
+ proto_item_append_text(item, "%s", tvb_bytes_to_ep_str(tvb, offset, 4));
}
/*
/* The P-TMSI Signature consists of 3 octets and may be allocated by the SGSN. */
proto_tree_add_item(tree, hf_gtpv2_p_tmsi_sig, tvb, offset, 3, ENC_BIG_ENDIAN);
- proto_item_append_text(item, "%s", tvb_bytes_to_str(tvb, offset, 3));
+ proto_item_append_text(item, "%s", tvb_bytes_to_ep_str(tvb, offset, 3));
}
offset += 1;
/* Packet Flow ID */
- proto_tree_add_text(tree, tvb, offset, length, "Packet Flow ID: %s", tvb_bytes_to_str(tvb, offset, length-1));
+ proto_tree_add_text(tree, tvb, offset, length, "Packet Flow ID: %s", tvb_bytes_to_ep_str(tvb, offset, length-1));
}
/*
offset += 3;
if (length > 3)
- proto_tree_add_text(tree, tvb, offset, length-3, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-3));
+ proto_tree_add_text(tree, tvb, offset, length-3, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-3));
}
/*
offset += 1;
if (length > 1)
- proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-1));
+ proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-1));
}
/*
int offset = 0;
/* Two octets OctetString. */
proto_tree_add_item(tree, hf_gtpv2_mbms_flow_id, tvb, offset, 2, ENC_NA);
- proto_item_append_text(item, " %s", tvb_bytes_to_str(tvb, offset, 2));
+ proto_item_append_text(item, " %s", tvb_bytes_to_ep_str(tvb, offset, 2));
offset += 2;
if (length > 2)
- proto_tree_add_text(tree, tvb, offset, length-2, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-2));
+ proto_tree_add_text(tree, tvb, offset, length-2, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-2));
}
/*
offset += 1;
if (length > offset)
- proto_tree_add_text(tree, tvb, offset, length-offset, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-offset));
+ proto_tree_add_text(tree, tvb, offset, length-offset, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-offset));
}
offset += 1;
if (length > 1)
- proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-1));
+ proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-1));
}
/*
proto_tree_add_item(tree, hf_gtpv2_node_features_ntsr, tvb, offset, 1, ENC_BIG_ENDIAN);
offset+=1;
if (length > 1)
- proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-1));
+ proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-1));
}
/* 8.84
proto_item_append_text(item, " %u second(s)", real_secs);
offset += 1;
if (length > 1)
- proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-1));
+ proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-1));
}
/* 8.85 Throttling */
offset += 1;
if (length > 1)
- proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-1));
+ proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-1));
}
/* 8.87 EPC Timer */
offset += 3;
if (length > offset)
- proto_tree_add_text(tree, tvb, offset, length-offset, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-offset));
+ proto_tree_add_text(tree, tvb, offset, length-offset, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-offset));
}
/*
elm_len = tvb_get_guint8(tvb, offset);
proto_tree_add_item(tree, hf_gtpv2_len_ms_classmark2, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
- ms_cm_item = proto_tree_add_text(tree, tvb, offset, elm_len, "Mobile Station Classmark 2 %s", tvb_bytes_to_str(tvb, offset, elm_len));
+ ms_cm_item = proto_tree_add_text(tree, tvb, offset, elm_len, "Mobile Station Classmark 2 %s", tvb_bytes_to_ep_str(tvb, offset, elm_len));
ms_cm_tree = proto_item_add_subtree(ms_cm_item, ett_gtpv2_ms_mark);
/* Mobile Station Classmark 2 */
de_ms_cm_2(tvb, ms_cm_tree, pinfo, offset, elm_len, NULL, 0);
elm_len = tvb_get_guint8(tvb, offset);
proto_tree_add_item(tree, hf_gtpv2_len_ms_classmark3, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
- ms_cm_item = proto_tree_add_text(tree, tvb, offset, elm_len, "Mobile Station Classmark3 %s", tvb_bytes_to_str(tvb, offset, elm_len));
+ ms_cm_item = proto_tree_add_text(tree, tvb, offset, elm_len, "Mobile Station Classmark3 %s", tvb_bytes_to_ep_str(tvb, offset, elm_len));
ms_cm_tree = proto_item_add_subtree(ms_cm_item, ett_gtpv2_ms_mark);
/* Mobile Station Classmark 3 */
de_ms_cm_3(tvb, ms_cm_tree, pinfo, offset, elm_len, NULL, 0);
elm_len = tvb_get_guint8(tvb, offset);
proto_tree_add_item(tree, hf_gtpv2_len_supp_codec_list, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
- ms_cm_item = proto_tree_add_text(tree, tvb, offset, elm_len, "Supported Codec List %s", tvb_bytes_to_str(tvb, offset, elm_len));
+ ms_cm_item = proto_tree_add_text(tree, tvb, offset, elm_len, "Supported Codec List %s", tvb_bytes_to_ep_str(tvb, offset, elm_len));
ms_cm_tree = proto_item_add_subtree(ms_cm_item, ett_gtpv2_supp_codec_list);
/* Supported Codec List */
de_sup_codec_list(tvb, ms_cm_tree, pinfo, offset, elm_len, NULL, 0);
offset += elm_len;
if (length > offset)
- proto_tree_add_text(tree, tvb, offset, length-offset, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-offset));
+ proto_tree_add_text(tree, tvb, offset, length-offset, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-offset));
}
/* 8.91 Additional flags for SRVCC */
offset += 1;
if (length > 1)
- proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-1));
+ proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-1));
}
/* 8.92 Max MBR/APN-AMBR (MMBR) */
offset += 8;
if (length > offset)
- proto_tree_add_text(tree, tvb, offset, length-offset, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-offset));
+ proto_tree_add_text(tree, tvb, offset, length-offset, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-offset));
}
/* 8.96 H(e)NB Information Reporting */
offset += 1;
if (length > 1)
- proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-1));
+ proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-1));
}
/* 8.97 IPv4 Configuration Parameters (IP4CP) */
offset += 4;
if (length > offset)
- proto_tree_add_text(tree, tvb, offset, length-offset, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-offset));
+ proto_tree_add_text(tree, tvb, offset, length-offset, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-offset));
}
/* 8.98 Change to Report Flags */
offset += 1;
if (length > 1)
- proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-1));
+ proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-1));
}
/* 8.99 Action Indication */
offset += 1;
if (length > 1)
- proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_str(tvb, offset, length-1));
+ proto_tree_add_text(tree, tvb, offset, length-1, "Spare: %s", tvb_bytes_to_ep_str(tvb, offset, length-1));
}
typedef struct _gtpv2_ie {
wmem_strbuf_append_printf(info, "%d.%d.%d.%d to %s",
tvb_get_guint8(tvb, 28), tvb_get_guint8(tvb, 29),
tvb_get_guint8(tvb, 30), tvb_get_guint8(tvb, 31),
- tvb_bytes_to_str_punct(tvb, 10, 6, ':'));
+ tvb_bytes_to_ep_str_punct(tvb, 10, 6, ':'));
}
break;
case 0x80: /* Register Read Request */
if (curr_info.term->len) {
curr_info.term->buffer = (guint8 *)tvb_memdup(wmem_packet_scope(),new_tvb,0,curr_info.term->len);
- curr_info.term->str = bytes_to_str(curr_info.term->buffer,curr_info.term->len);
+ curr_info.term->str = bytes_to_ep_str(curr_info.term->buffer,curr_info.term->len);
}
curr_info.term = gcp_cmd_add_term(curr_info.msg, curr_info.trx, curr_info.cmd, curr_info.term, wild_term, keep_persistent_data);
/* not ascii or NULL character so do string as hex string */
proto_tree_add_text(tree, tvb, offset, len,"%s: 0x%s",
(proto_registrar_get_nth(hf_index))->name,
- tvb_bytes_to_str(tvb, 0, len));
+ tvb_bytes_to_ep_str(tvb, 0, len));
return len;
};
};
dissect_ber_octet_string(implicit_p ? *((gboolean*)implicit_p) : FALSE, &asn1_ctx, tree, tvb, 0, hfid, &new_tvb);
if ( new_tvb && h248_info->term && ! h248_info->term->bir ) {
- h248_info->term->bir = wmem_strdup(wmem_file_scope(), tvb_bytes_to_str(new_tvb,0,tvb_length(new_tvb)));
+ h248_info->term->bir = wmem_strdup(wmem_file_scope(), tvb_bytes_to_ep_str(new_tvb,0,tvb_length(new_tvb)));
}
}
if (new_tvb) {
dissect_nsap(new_tvb, 0,tvb_length(new_tvb), tree);
if ( h248_info->term && ! h248_info->term->nsap) {
- h248_info->term->nsap = wmem_strdup(wmem_file_scope(), tvb_bytes_to_str(new_tvb,0,tvb_length(new_tvb)));
+ h248_info->term->nsap = wmem_strdup(wmem_file_scope(), tvb_bytes_to_ep_str(new_tvb,0,tvb_length(new_tvb)));
}
}
}
default:
proto_tree_add_item(ietree, hf_ieee80211_vs_aruba_data, tvb, offset,
tag_len, ENC_NA);
- proto_item_append_text(item, " (Data: %s)", tvb_bytes_to_str(tvb, offset, tag_len));
+ proto_item_append_text(item, " (Data: %s)", tvb_bytes_to_ep_str(tvb, offset, tag_len));
break;
}
}
pid = tvb_get_ntohs(tvb, 3);
col_add_fstr(pinfo->cinfo, COL_INFO, "OUI %s (%s), PID 0x%04X",
- bytes_to_str_punct(oui, 3, ':'),
+ bytes_to_ep_str_punct(oui, 3, ':'),
manuf ? manuf : "Unknown", pid);
proto_tree_add_uint_format_value(ieee802a_tree, hf_ieee802a_oui,
tvb, 0, 3, oui32, "%s (%s)",
- bytes_to_str_punct(oui, 3, ':'), manuf ? manuf : "Unknown");
+ bytes_to_ep_str_punct(oui, 3, ':'), manuf ? manuf : "Unknown");
/*
* Do we have information for this OUI?
/* Challenge field is the results of MD5 calculation */
proto_tree_add_text(tree, tvb, offset, msize,
"Result of MD5 calculation: 0x%s",
- bytes_to_str(message, msize));
+ bytes_to_ep_str(message, msize));
break;
case IGAP_SUBTYPE_CHALLENGE:
/* Challenge field is the challenge value */
proto_tree_add_text(tree, tvb, offset, msize,
"Challenge: 0x%s",
- bytes_to_str(message, msize));
+ bytes_to_ep_str(message, msize));
break;
case IGAP_SUBTYPE_AUTH_MESSAGE:
/* Challenge field indicates the result of the authenticaion */
1 + 2 + name_length + 2 + value_length,
"%s: %s",
tvb_format_text(tvb, offset + 1 + 2, name_length),
- tvb_bytes_to_str(tvb, offset + 1 + 2 + name_length + 2, value_length));
+ tvb_bytes_to_ep_str(tvb, offset + 1 + 2 + name_length + 2, value_length));
return proto_item_add_subtree(ti, ett_ipp_attr);
}
offset = add_value_head(tag_desc, tree, tvb, offset, name_length,
value_length, NULL);
proto_tree_add_text(tree, tvb, offset, value_length,
- "Value: %s", tvb_bytes_to_str(tvb, offset, value_length));
+ "Value: %s", tvb_bytes_to_ep_str(tvb, offset, value_length));
}
static proto_tree *
}
col_add_fstr(pinfo->cinfo, COL_INFO, "Serial number %s",
- tvb_bytes_to_str(tvb, 0, 6));
+ tvb_bytes_to_ep_str(tvb, 0, 6));
proto_tree_add_text(ser_tree, tvb, 0, 6,
- "Serial number: %s", tvb_bytes_to_str(tvb, 0, 6));
+ "Serial number: %s", tvb_bytes_to_ep_str(tvb, 0, 6));
}
/*
proto_tree_add_bytes_format_value(tree, hf_isakmp_sa_situation, tvb, offset, length,
NULL,
"%s (length is %u, should be >= 4)",
- tvb_bytes_to_str(tvb, offset, length), length);
+ tvb_bytes_to_ep_str(tvb, offset, length), length);
return;
}
sti = proto_tree_add_item(tree, hf_isakmp_sa_situation, tvb, offset, 4, ENC_NA);
dissect_x509if_Name(FALSE, tvb, offset, &asn1_ctx, tree, hf_isakmp_id_data_cert);
break;
default:
- proto_item_append_text(idit, "%s", tvb_bytes_to_str(tvb,offset,length));
+ proto_item_append_text(idit, "%s", tvb_bytes_to_ep_str(tvb,offset,length));
break;
}
}
if (tvb_memeql(tvb, offset, md, icd_len) == 0) {
proto_item_append_text(icd_item, "[correct]");
} else {
- proto_item_append_text(icd_item, "[incorrect, should be %s]", bytes_to_str(md, icd_len));
+ proto_item_append_text(icd_item, "[incorrect, should be %s]", bytes_to_ep_str(md, icd_len));
expert_add_info(pinfo, icd_item, &ei_isakmp_ikev2_integrity_checksum);
}
gcry_md_close(md_hd);
ismacryp_item = proto_tree_add_item(ismacryp_header_tree, hf_ismacryp_iv, tvb, poffset->offset_bytes, iv_length, ENC_NA);
proto_item_append_text(ismacryp_item, ": Length=%d bytes",iv_length); /* add IV info */
col_append_fstr( pinfo->cinfo, COL_INFO,
- ", IV=0x%s", tvb_bytes_to_str_punct(tvb, poffset->offset_bytes, iv_length,' '));
+ ", IV=0x%s", tvb_bytes_to_ep_str_punct(tvb, poffset->offset_bytes, iv_length,' '));
poffset->offset_bytes+=iv_length; /* add IV length to offset_bytes */
}
tvb, poffset->offset_bytes, delta_iv_length, ENC_NA);
proto_item_append_text(ismacryp_item, ": Length=%d bytes",delta_iv_length); /* add delta IV info */
col_append_fstr( pinfo->cinfo, COL_INFO,
- ", Delta IV=0x%s", tvb_bytes_to_str_punct(tvb, poffset->offset_bytes, delta_iv_length,' '));
+ ", Delta IV=0x%s", tvb_bytes_to_ep_str_punct(tvb, poffset->offset_bytes, delta_iv_length,' '));
poffset->offset_bytes+=iv_length; /* add IV length to offset_bytes */
}
/* Key Indicator */
tvb, poffset->offset_bytes, key_indicator_length, ENC_NA);
proto_item_append_text(ismacryp_item,": Length=%d bytes",key_indicator_length); /* add KI info */
col_append_fstr( pinfo->cinfo, COL_INFO,
- ", KI=0x%s", tvb_bytes_to_str_punct(tvb, poffset->offset_bytes, key_indicator_length,' '));
+ ", KI=0x%s", tvb_bytes_to_ep_str_punct(tvb, poffset->offset_bytes, key_indicator_length,' '));
poffset->offset_bytes+=key_indicator_length; /* add KI length to offset_bytes */
}
/* AU size */
}
proto_tree_add_text(parameter_tree, parameter_tvb, offset,
length, "Diagnostic: %s",
- tvb_bytes_to_str(parameter_tvb, offset, length));
+ tvb_bytes_to_ep_str(parameter_tvb, offset, length));
return;
case 2:
/*ANSI*/
}
proto_tree_add_text(parameter_tree, parameter_tvb, offset,
length, "Diagnostic: %s",
- tvb_bytes_to_str(parameter_tvb, offset, length));
+ tvb_bytes_to_ep_str(parameter_tvb, offset, length));
return;
default:
proto_tree_add_item(parameter_tree, hf_ansi_isup_coding_standard, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
switch (afi) {
case 0x35: /* IANA ICP Binary fortmat*/
proto_tree_add_text(parameter_tree, parameter_tvb, offset, 3,
- "IDP = %s", tvb_bytes_to_str(parameter_tvb, offset, 3));
+ "IDP = %s", tvb_bytes_to_ep_str(parameter_tvb, offset, 3));
proto_tree_add_uint(parameter_tree, hf_afi, parameter_tvb, offset, 1, afi);
offset = offset + 1;
proto_tree_add_uint(parameter_tree, hf_iana_icp, parameter_tvb, offset, 1, icp);
if (icp == 0) { /* IPv6 addr */
proto_tree_add_text(parameter_tree, parameter_tvb, offset + 2 , 17,
- "DSP = %s", tvb_bytes_to_str(parameter_tvb, offset + 2, 17));
+ "DSP = %s", tvb_bytes_to_ep_str(parameter_tvb, offset + 2, 17));
proto_tree_add_item(parameter_tree, hf_nsap_ipv6_addr, parameter_tvb, offset + 2,
16, ENC_NA);
else { /* IPv4 addr */
/* XXX - this is really only for ICP 1 */
proto_tree_add_text(parameter_tree, parameter_tvb, offset + 2, 17,
- "DSP = %s", tvb_bytes_to_str(parameter_tvb, offset + 2, 17));
+ "DSP = %s", tvb_bytes_to_ep_str(parameter_tvb, offset + 2, 17));
proto_tree_add_item(parameter_tree, hf_nsap_ipv4_addr, parameter_tvb, offset + 2, 4, ENC_BIG_ENDIAN);
}
case 0x45: /* E.164 ATM format */
case 0xC3: /* E.164 ATM group format */
proto_tree_add_text(parameter_tree, parameter_tvb, offset, 9,
- "IDP = %s", tvb_bytes_to_str(parameter_tvb, offset, 9));
+ "IDP = %s", tvb_bytes_to_ep_str(parameter_tvb, offset, 9));
proto_tree_add_uint(parameter_tree, hf_afi, parameter_tvb, offset, 1, afi);
proto_tree_add_text(parameter_tree, parameter_tvb, offset + 1, 8,
- "IDI = %s", tvb_bytes_to_str(parameter_tvb, offset + 1, 8));
+ "IDI = %s", tvb_bytes_to_ep_str(parameter_tvb, offset + 1, 8));
offset = offset +1;
/* Dissect country code */
cc_offset = offset;
*/
proto_tree_add_text(bat_ase_element_tree, parameter_tvb, offset, tempdata , "Network ID: %s",
- tvb_bytes_to_str(parameter_tvb, offset, tempdata));
+ tvb_bytes_to_ep_str(parameter_tvb, offset, tempdata));
offset = offset + tempdata;
} /* end if */
col_add_fstr(pinfo->cinfo, COL_INFO, "PGN: %d", pgn);
/* For now just include raw bytes */
- col_append_fstr(pinfo->cinfo, COL_INFO, " %s", tvb_bytes_to_str_punct(tvb, 0, data_length, ' '));
+ col_append_fstr(pinfo->cinfo, COL_INFO, " %s", tvb_bytes_to_ep_str_punct(tvb, 0, data_length, ' '));
ti = proto_tree_add_text(j1939_tree, tvb, 0, -1, "Message");
msg_tree = proto_item_add_subtree(ti, ett_j1939_message);
}
break;
default:
- strPtr = tvb_bytes_to_str(tvb, (offset+4), (tempLen-2));
+ strPtr = tvb_bytes_to_ep_str(tvb, (offset+4), (tempLen-2));
break;
}
break;
break;
}
- strPtr = tvb_bytes_to_str(tvb, (offset+3), (tempLen-1));
+ strPtr = tvb_bytes_to_ep_str(tvb, (offset+3), (tempLen-1));
break;
}
default: /* Reserved types */
}
break;
default:
- strPtr = tvb_bytes_to_str(tvb, (offset+4), (tempLen-2));
+ strPtr = tvb_bytes_to_ep_str(tvb, (offset+4), (tempLen-2));
break;
}
break;
{
if (tree)
proto_tree_add_text(tree, tvb, tempOffset, tempByte, "Protocol Identity: %s",
- tvb_bytes_to_str(tvb, tempOffset, tempByte));
+ tvb_bytes_to_ep_str(tvb, tempOffset, tempByte));
}
break;
len -= 1;
proto_tree_add_text(field_tree, tvb,
p, len, "Link-layer address: %s",
- tvb_bytes_to_str_punct(tvb, p, len, ':'));
+ tvb_bytes_to_ep_str_punct(tvb, p, len, ':'));
}
}
}
proto_tree_add_item(tlv_fec_tree, hf_mpls_echo_tlv_fec_rsvp_p2mp_ip_tunnel_id,
tvb, offset + 22, 2, FALSE);
proto_tree_add_text(tlv_fec_tree, tvb, offset + 24, 16, "Extended Tunnel ID: 0x%s (%s)",
- tvb_bytes_to_str(tvb, offset + 24, 16),
+ tvb_bytes_to_ep_str(tvb, offset + 24, 16),
tvb_ip6_to_str(tvb, offset + 24));
hidden_item = proto_tree_add_item(tlv_fec_tree, hf_mpls_echo_tlv_fec_rsvp_p2mp_ipv6_ext_tunnel_id,
tvb, offset + 24, 16, FALSE);
}
case 21:
case 22: /* Bytes */
- g_snprintf(buffer, (gulong) buffer_size, "%s", bytes_to_str(get_finfo_value_string(PTREE_FINFO(tree_pointer)), get_finfo_length(PTREE_FINFO(tree_pointer))));
+ g_snprintf(buffer, (gulong) buffer_size, "%s", bytes_to_ep_str(get_finfo_value_string(PTREE_FINFO(tree_pointer)), get_finfo_length(PTREE_FINFO(tree_pointer))));
break;
default: /* Dont currently handle. Only need string, integers, and bytes */
g_snprintf(buffer, (gulong) buffer_size, "Unsupported Expert Type");
if (info_type != 0) { /* Is this a string or not? */
if (info_type == 1) { /* Is this bytes? */
- byte_string = bytes_to_str(get_finfo_value_string(finfo), get_finfo_length(finfo));
+ byte_string = bytes_to_ep_str(get_finfo_value_string(finfo), get_finfo_length(finfo));
col_append_fstr(pinfo->cinfo, COL_INFO,
(const gchar*) ncp_rec->req_info_str->first_string,
byte_string);
if (info_type != 0) { /* Is this a string or not? */
if (info_type == 1)
{ /* Is this bytes? */
- byte_string = bytes_to_str(get_finfo_value_string(finfo), get_finfo_length(finfo));
+ byte_string = bytes_to_ep_str(get_finfo_value_string(finfo), get_finfo_length(finfo));
col_append_fstr(pinfo->cinfo, COL_INFO,
(const gchar*) ncp_rec->req_info_str->repeat_string,
byte_string);
tvb, offset, length, NULL,
"Type %u: Value (hex bytes): %s",
masked_type,
- tvb_bytes_to_str_punct(tvb, offset, length, ' '));
+ tvb_bytes_to_ep_str_punct(tvb, offset, length, ' '));
} else { /* v10 PEN */
ti = proto_tree_add_bytes_format_value(pdutree, hf_ipfix_enterprise_private_entry,
tvb, offset, length, NULL,
"(%s) Type %u: Value (hex bytes): %s",
pen_str ? pen_str : "(null)",
masked_type,
- tvb_bytes_to_str_punct(tvb, offset, length, ' '));
+ tvb_bytes_to_ep_str_punct(tvb, offset, length, ' '));
}
break;
hash_item = proto_tree_add_text(tree, tvb, offset+4,
hashlen + 1,
"hash path: %s",
- tvb_bytes_to_str(tvb, offset+5, hashlen));
+ tvb_bytes_to_ep_str(tvb, offset+5, hashlen));
hash_tree = proto_item_add_subtree(hash_item,
ett_nfs_fh_hp);
proto_tree_add_uint(hash_tree,
proto_tree_add_text(hash_tree, tvb, offset+5,
hashlen,
"key: %s",
- tvb_bytes_to_str(tvb, offset+5, hashlen));
+ tvb_bytes_to_ep_str(tvb, offset+5, hashlen));
}
}
}
*/
proto_tree_add_text(nhrp_tree, tvb, offset, 5,
"Protocol Type (long form): %s",
- tvb_bytes_to_str(tvb, offset, 5));
+ tvb_bytes_to_ep_str(tvb, offset, 5));
offset += 5;
}
else {
proto_tree_add_text(cie_tree, tvb, offset, cli_addr_len,
"Client NBMA Address: %s",
- tvb_bytes_to_str(tvb, offset, cli_addr_len));
+ tvb_bytes_to_ep_str(tvb, offset, cli_addr_len));
}
break;
default:
proto_tree_add_text(cie_tree, tvb, offset, cli_addr_len,
"Client NBMA Address: %s",
- tvb_bytes_to_str(tvb, offset, cli_addr_len));
+ tvb_bytes_to_ep_str(tvb, offset, cli_addr_len));
break;
}
offset += cli_addr_len;
if (cli_saddr_len) {
proto_tree_add_text(cie_tree, tvb, offset, cli_saddr_len,
"Client NBMA Sub Address: %s",
- tvb_bytes_to_str(tvb, offset, cli_saddr_len));
+ tvb_bytes_to_ep_str(tvb, offset, cli_saddr_len));
}
if (cli_prot_len) {
else {
proto_tree_add_text(cie_tree, tvb, offset, cli_prot_len,
"Client Protocol Address: %s",
- tvb_bytes_to_str(tvb, offset, cli_prot_len));
+ tvb_bytes_to_ep_str(tvb, offset, cli_prot_len));
}
offset += cli_prot_len;
}
else {
proto_tree_add_text(nhrp_tree, tvb, offset, shl,
"Source NBMA Address: %s",
- tvb_bytes_to_str(tvb, offset, shl));
+ tvb_bytes_to_ep_str(tvb, offset, shl));
}
break;
default:
proto_tree_add_text(nhrp_tree, tvb, offset, shl,
"Source NBMA Address: %s",
- tvb_bytes_to_str(tvb, offset, shl));
+ tvb_bytes_to_ep_str(tvb, offset, shl));
break;
}
offset += shl;
if (ssl) {
proto_tree_add_text(nhrp_tree, tvb, offset, ssl,
"Source NBMA Sub Address: %s",
- tvb_bytes_to_str(tvb, offset, ssl));
+ tvb_bytes_to_ep_str(tvb, offset, ssl));
offset += ssl;
}
else if (*srcLen) {
proto_tree_add_text(nhrp_tree, tvb, offset, *srcLen,
"Source Protocol Address: %s",
- tvb_bytes_to_str(tvb, offset, *srcLen));
+ tvb_bytes_to_ep_str(tvb, offset, *srcLen));
offset += *srcLen;
}
else if (dstLen) {
proto_tree_add_text(nhrp_tree, tvb, offset, dstLen,
"Destination Protocol Address: %s",
- tvb_bytes_to_str(tvb, offset, dstLen));
+ tvb_bytes_to_ep_str(tvb, offset, dstLen));
offset += dstLen;
}
if (len < (4 + srcLen)) {
ti = proto_tree_add_text(nhrp_tree, tvb, offset, len,
"Malformed Extension: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
expert_add_info_format(pinfo, ti, &ei_nhrp_ext_malformed, "Incomplete Authentication Extension");
}
else {
auth_item = proto_tree_add_text(nhrp_tree, tvb, offset, len,
"Extension Data: SPI=%u: Data=%s", tvb_get_ntohs(tvb, offset + 2),
- tvb_bytes_to_str(tvb, offset + 4, len - 4));
+ tvb_bytes_to_ep_str(tvb, offset + 4, len - 4));
auth_tree = proto_item_add_subtree(auth_item, ett_nhrp_auth_ext);
proto_tree_add_item(auth_tree, hf_nhrp_auth_ext_reserved, tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(auth_tree, hf_nhrp_auth_ext_spi, tvb, offset + 2, 2, ENC_BIG_ENDIAN);
else if (srcLen) {
proto_tree_add_text(auth_tree, tvb, offset + 4, srcLen,
"Source Address: %s",
- tvb_bytes_to_str(tvb, offset + 4, srcLen));
+ tvb_bytes_to_ep_str(tvb, offset + 4, srcLen));
}
if (len > (4 + srcLen)) {
proto_tree_add_text(auth_tree, tvb, offset + 4 + srcLen, len - (4 + srcLen),
- "Data: %s", tvb_bytes_to_str(tvb, offset + 4 + srcLen, len - (4 + srcLen)));
+ "Data: %s", tvb_bytes_to_ep_str(tvb, offset + 4 + srcLen, len - (4 + srcLen)));
}
}
break;
if (len < 3) {
ti = proto_tree_add_text(nhrp_tree, tvb, offset, len,
"Malformed Extension: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
expert_add_info_format(pinfo, ti, &ei_nhrp_ext_malformed, "Incomplete Vendor-Private Extension");
}
else {
tvb_memcpy(tvb, manuf, offset, 3);
vendor_item = proto_tree_add_text(nhrp_tree, tvb, offset, len,
"Extension Data: Vendor ID=%s, Data=%s", get_manuf_name(manuf),
- tvb_bytes_to_str(tvb, offset + 3, len - 3));
+ tvb_bytes_to_ep_str(tvb, offset + 3, len - 3));
vendor_tree = proto_item_add_subtree(vendor_item, ett_nhrp_vendor_ext);
proto_tree_add_bytes_format_value(vendor_tree, hf_nhrp_vendor_ext_id, tvb,
offset, 3, manuf, "%s", get_manuf_name(manuf));
if (len > 3) {
proto_tree_add_text(vendor_tree, tvb, offset + 3, len - 3,
- "Data: %s", tvb_bytes_to_str(tvb, offset + 3, len - 3));
+ "Data: %s", tvb_bytes_to_ep_str(tvb, offset + 3, len - 3));
}
}
break;
length,
"Key Name: %s (UTF-8 Value: %s, Unicode Value: 0x%" G_GINT64_MODIFIER "x)",
key_name,
- tvb_bytes_to_str(tvb, offset, length),
+ tvb_bytes_to_ep_str(tvb, offset, length),
unicode_value);
break;
}
if ( global_scm_udid_autoset == TRUE )
{
tempString = (char *)wmem_alloc0(wmem_packet_scope(), 128 * sizeof(char));
- g_snprintf ( tempString, 18, "%s", tvb_bytes_to_str_punct(message_tvb, OSS_FRAME_POS_DATA + frameStart1 + 1, 6, ':' ) );
+ g_snprintf ( tempString, 18, "%s", tvb_bytes_to_ep_str_punct(message_tvb, OSS_FRAME_POS_DATA + frameStart1 + 1, 6, ':' ) );
if ( memcmp ( global_scm_udid, tempString, 17 ) != 0 )
{
local_scm_udid = (char *)wmem_alloc0(wmem_file_scope(), 18 * sizeof(char));
if ( global_scm_udid_autoset == TRUE )
{
tempString = (char *)wmem_alloc0(wmem_packet_scope(), 18 * sizeof(char));
- g_snprintf ( tempString, 18, "%s", tvb_bytes_to_str_punct(message_tvb, OSS_FRAME_POS_DATA + frameStart1 + 1, 6, ':' ) );
+ g_snprintf ( tempString, 18, "%s", tvb_bytes_to_ep_str_punct(message_tvb, OSS_FRAME_POS_DATA + frameStart1 + 1, 6, ':' ) );
if ( memcmp ( global_scm_udid, tempString, 17 ) != 0 )
{
local_scm_udid = (char *)wmem_alloc0(wmem_file_scope(), 18 * sizeof(char));
if (tvb_bytes_exist(tvb, ospflen, crypto_len)) {
proto_tree_add_text(ospf_header_tree, tvb, ospflen, crypto_len,
"Auth Data: %s",
- tvb_bytes_to_str(tvb, ospflen, crypto_len));
+ tvb_bytes_to_ep_str(tvb, ospflen, crypto_len));
proto_tree_set_appendix(ospf_header_tree, tvb, ospflen, crypto_len);
}
break;
tvb_get_ntohl(tvb, offset + 4));
proto_tree_add_text(ospf_lls_tlv_tree, tvb, offset + 8, length - 4,
"Auth Data: %s",
- tvb_bytes_to_str(tvb, offset + 8, length - 4));
+ tvb_bytes_to_ep_str(tvb, offset + 8, length - 4));
break;
}
case OIF_TNA_NSAP_ADDRESS:
ti = proto_tree_add_text(tlv_tree, tvb, stlv_offset, stlv_len+4,
"%s (NSAP): %s", stlv_name,
- tvb_bytes_to_str (tvb, stlv_offset + 8, stlv_len - 4));
+ tvb_bytes_to_ep_str (tvb, stlv_offset + 8, stlv_len - 4));
stlv_tree = proto_item_add_subtree(ti, ett_ospf_lsa_oif_tna_stlv);
proto_tree_add_text(stlv_tree, tvb, stlv_offset, 2,
"TLV Type: %u: %s (NSAP)", stlv_type, stlv_name);
proto_tree_add_text(stlv_tree, tvb, stlv_offset+4, 1, "Addr Length: %u",
tvb_get_guint8 (tvb, stlv_offset+4));
proto_tree_add_text(stlv_tree, tvb, stlv_offset+8, stlv_len - 4, "TNA Addr: %s",
- tvb_bytes_to_str(tvb, stlv_offset+8, stlv_len - 4));
+ tvb_bytes_to_ep_str(tvb, stlv_offset+8, stlv_len - 4));
break;
default:
pgmhdr_opts = tvb_get_guint8(tvb, 5);
pgmhdr_cksum = tvb_get_ntohs(tvb, 6);
- gsi = tvb_bytes_to_str(tvb, 8, 6);
+ gsi = tvb_bytes_to_ep_str(tvb, 8, 6);
pgmhdr_tsdulen = tvb_get_ntohs(tvb, 14);
sqn = tvb_get_ntohl(tvb, 16);
proto_tree_add_bytes_format(fh_tree, hf_ppp_data, tvb, offset,
length, NULL, "Rejected Packet (%d byte%s): %s", length,
plurality(length, "", "s"),
- tvb_bytes_to_str(tvb, offset, length));
+ tvb_bytes_to_ep_str(tvb, offset, length));
}
break;
tvb_format_text(tvb, name_offset,
(name_size > 20) ? 20 : name_size),
(name_size > 20) ? "..." : "",
- tvb_bytes_to_str(tvb, value_offset, value_size));
+ tvb_bytes_to_ep_str(tvb, value_offset, value_size));
}
}
break;
{
guint8 *guid;
- guid = tvb_bytes_to_str(tvb, *offset, PTPIP_GUID_SIZE);
+ guid = tvb_bytes_to_ep_str(tvb, *offset, PTPIP_GUID_SIZE);
proto_tree_add_item(tree, hf_ptpIP_guid, tvb, *offset, PTPIP_GUID_SIZE, ENC_NA);
*offset += PTPIP_GUID_SIZE;
col_append_fstr(
"%s%s",
first_line ? "data: " :
" ",
- tvb_bytes_to_str(tvb,offset,sublen));
+ tvb_bytes_to_ep_str(tvb,offset,sublen));
bytes_left -= sublen;
offset += sublen;
first_line = FALSE;
len = 4;
proto_tree_add_text(tree, tvb, offset, len,
"User defined AAL information: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
return;
}
case Q2931_REJ_USER_SPECIFIC:
proto_tree_add_text(tree, tvb, offset, len,
"User specific diagnostic: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
break;
case Q2931_REJ_IE_MISSING:
default:
proto_tree_add_text(tree, tvb, offset, len,
"Diagnostic: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
break;
}
break;
default:
proto_tree_add_text(tree, tvb, offset, len,
"Diagnostics: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
}
}
if (len < 20) {
proto_tree_add_text(tree, tvb, offset, len,
"Number (too short): %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
return;
}
ti = proto_tree_add_text(tree, tvb, offset, len, "Number");
default:
proto_tree_add_text(tree, tvb, offset, len, "Number: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
break;
}
}
if (len == 0)
return;
proto_tree_add_text(tree, tvb, offset, len, "Subaddress: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
}
/*
* dump it as data and be done with it.
*/
proto_tree_add_text(ie_tree, tvb, offset + 4, len,
- "Data: %s", tvb_bytes_to_str(tvb, offset + 4, len));
+ "Data: %s", tvb_bytes_to_ep_str(tvb, offset + 4, len));
}
}
*/
proto_tree_add_text(tree, tvb, offset,
len, "Data: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
proto_tree_add_boolean(tree, hf_q931_extension_ind, tvb, offset, 1, octet);
proto_tree_add_uint(tree, hf_q931_coding_standard, tvb, offset, 1, octet);
return;
proto_tree_add_uint(tree, hf_q931_coding_standard, tvb, offset, 1, octet);
proto_tree_add_text(tree, tvb, offset,
len, "Data: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
return;
}
proto_tree_add_uint(tree, hf_q931_cause_location, tvb, offset, 1, octet);
case Q931_REJ_USER_SPECIFIC:
proto_tree_add_text(tree, tvb, offset, len,
"User specific diagnostic: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
break;
case Q931_REJ_IE_MISSING:
default:
proto_tree_add_text(tree, tvb, offset, len,
"Diagnostic: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
break;
}
break;
default:
proto_tree_add_text(tree, tvb, offset, len,
"Diagnostics: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
}
}
*/
proto_tree_add_text(tree, tvb, offset,
len, "Data: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
return;
}
proto_tree_add_text(tree, tvb, offset, 1,
*/
proto_tree_add_text(tree, tvb, offset,
len, "Data: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
return;
}
proto_tree_add_item(tree, hf_q931_channel_map, tvb, offset, 1, ENC_BIG_ENDIAN);
*/
proto_tree_add_text(tree, tvb, offset,
len, "Data: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
return;
}
proto_tree_add_text(tree, tvb, offset, 1,
return;
proto_tree_add_text(tree, tvb, offset,
len, "Network-specific facility specification: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
}
/*
if (len == 0)
return;
proto_tree_add_text(tree, tvb, offset, len, "Subaddress: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
}
/*
*/
proto_tree_add_text(tree, tvb, offset,
len, "Data: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
return;
}
if (len == 0)
default:
proto_tree_add_text(tree, tvb, offset, len, "User information: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
break;
}
}
proto_tree_add_text(ie_tree, tvb,
offset + 4, info_element_len - 1,
"User information: %s",
- tvb_bytes_to_str(tvb, offset + 4,
+ tvb_bytes_to_ep_str(tvb, offset + 4,
info_element_len - 1));
}
}
proto_tree_add_text(ie_tree, tvb,
offset + 2, info_element_len,
"Data: %s",
- tvb_bytes_to_str(tvb, offset + 2,
+ tvb_bytes_to_ep_str(tvb, offset + 2,
info_element_len));
}
break;
proto_tree_add_uint(tree, hf_q932_nd, tvb, offset - (length - remain), length - remain, value);
if (remain > 0) {
- proto_tree_add_text(tree, tvb, offset - remain, remain, "ASN.1 Encoded Data Structure(NOT IMPLEMENTED): %s", tvb_bytes_to_str(tvb, offset - remain, remain));
+ proto_tree_add_text(tree, tvb, offset - remain, remain, "ASN.1 Encoded Data Structure(NOT IMPLEMENTED): %s", tvb_bytes_to_ep_str(tvb, offset - remain, remain));
}
}
*/
proto_tree_add_text(tree, tvb, offset,
len, "Data: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
proto_tree_add_uint(tree, hf_q933_coding_standard, tvb, offset, 1, octet);
proto_tree_add_boolean(tree, hf_q933_extension_ind, tvb, offset, 1, octet);
return;
proto_tree_add_uint(tree, hf_q933_coding_standard, tvb, offset, 1, octet);
proto_tree_add_text(tree, tvb, offset,
len, "Data: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
return;
}
proto_tree_add_uint(tree, hf_q933_cause_location, tvb, offset, 1, octet);
case Q933_REJ_USER_SPECIFIC:
proto_tree_add_text(tree, tvb, offset, len,
"User specific diagnostic: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
break;
case Q933_REJ_IE_MISSING:
default:
proto_tree_add_text(tree, tvb, offset, len,
"Diagnostic: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
break;
}
break;
default:
proto_tree_add_text(tree, tvb, offset, len,
"Diagnostics: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
}
}
*/
proto_tree_add_text(tree, tvb, offset,
len, "Data: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
return;
}
proto_tree_add_text(tree, tvb, offset, 1,
if (identifier_len != 0) {
proto_tree_add_text(tree, tvb, identifier_offset,
identifier_len, "Interface identifier: %s",
- tvb_bytes_to_str(tvb, identifier_offset, identifier_len));
+ tvb_bytes_to_ep_str(tvb, identifier_offset, identifier_len));
}
}
*/
proto_tree_add_text(tree, tvb, offset,
len, "Data: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
return;
}
proto_tree_add_text(tree, tvb, offset, 1,
*/
proto_tree_add_text(tree, tvb, offset,
len, "Data: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
return;
}
proto_tree_add_text(tree, tvb, offset, 1,
return;
proto_tree_add_text(tree, tvb, offset,
len, "Network-specific facility specification: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
}
static int
if (len == 0)
return;
proto_tree_add_text(tree, tvb, offset, len, "Subaddress: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
}
/*
*/
proto_tree_add_text(tree, tvb, offset,
len, "Data: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
return;
}
default:
proto_tree_add_text(tree, tvb, offset, len, "User information: %s",
- tvb_bytes_to_str(tvb, offset, len));
+ tvb_bytes_to_ep_str(tvb, offset, len));
break;
}
}
proto_tree_add_text(ie_tree, tvb,
offset + 2, info_element_len,
"Data: %s",
- tvb_bytes_to_str(tvb, offset + 2,
+ tvb_bytes_to_ep_str(tvb, offset + 2,
info_element_len));
break;
}
chap_tree = proto_item_add_subtree(ti, ett_chap);
proto_tree_add_item(chap_tree, hf_radius_chap_ident, tvb, 0, 1, ENC_NA);
proto_tree_add_item(chap_tree, hf_radius_chap_string, tvb, 1, 16, ENC_NA);
- return (tvb_bytes_to_str(tvb, 0, len));
+ return (tvb_bytes_to_ep_str(tvb, 0, len));
}
static const gchar *dissect_framed_ip_address(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo _U_) {
void radius_octets(radius_attr_info_t* a, proto_tree* tree, packet_info *pinfo _U_, tvbuff_t* tvb, int offset, int len, proto_item* avp_item) {
proto_tree_add_item(tree, a->hf, tvb, offset, len, ENC_NA);
- proto_item_append_text(avp_item, "%s", tvb_bytes_to_str(tvb, offset, len));
+ proto_item_append_text(avp_item, "%s", tvb_bytes_to_ep_str(tvb, offset, len));
}
void radius_ipaddr(radius_attr_info_t* a, proto_tree* tree, packet_info *pinfo _U_, tvbuff_t* tvb, int offset, int len, proto_item* avp_item) {
*/
void radius_abinary(radius_attr_info_t* a, proto_tree* tree, packet_info *pinfo _U_, tvbuff_t* tvb, int offset, int len, proto_item* avp_item) {
proto_tree_add_item(tree, a->hf, tvb, offset, len, ENC_NA);
- proto_item_append_text(avp_item, "%s", tvb_bytes_to_str(tvb, offset, len));
+ proto_item_append_text(avp_item, "%s", tvb_bytes_to_ep_str(tvb, offset, len));
}
void radius_ether(radius_attr_info_t* a, proto_tree* tree, packet_info *pinfo _U_, tvbuff_t* tvb, int offset, int len, proto_item* avp_item) {
void radius_ifid(radius_attr_info_t* a, proto_tree* tree, packet_info *pinfo _U_, tvbuff_t* tvb, int offset, int len, proto_item* avp_item) {
proto_tree_add_item(tree, a->hf, tvb, offset, len, ENC_NA);
- proto_item_append_text(avp_item, "%s", tvb_bytes_to_str(tvb, offset, len));
+ proto_item_append_text(avp_item, "%s", tvb_bytes_to_ep_str(tvb, offset, len));
}
static void add_tlv_to_tree(proto_tree* tlv_tree, proto_item* tlv_item, packet_info* pinfo, tvbuff_t* tvb, radius_attr_info_t* dictionary_entry, guint32 tlv_length, guint32 offset) {
guint8* bytes = (guint8 *)tvb_memdup(wmem_packet_scope(),imsi_tvb,0,len);
actx->pinfo->sccp_info->data.co.assoc->calling_party =
- wmem_strdup_printf(wmem_file_scope(), "IMSI: %s", bytes_to_str(bytes, len) );
+ wmem_strdup_printf(wmem_file_scope(), "IMSI: %s", bytes_to_ep_str(bytes, len) );
}
digit_str = unpack_digits(imsi_tvb, 0);
proto_tree_add_string(tree, hf_ranap_imsi_digits, imsi_tvb, 0, -1, digit_str);
rip_authentication_tree = proto_item_add_subtree(ti, ett_auth_vec );
proto_tree_add_text( rip_authentication_tree, tvb, offset-4+digest_off+4,
MD5_AUTH_DATA_LEN, "Authentication Data: %s",
- tvb_bytes_to_str_punct(tvb, offset-4+digest_off+4,
+ tvb_bytes_to_ep_str_punct(tvb, offset-4+digest_off+4,
MD5_AUTH_DATA_LEN, ' '));
break;
}
if (toi_size <= 8)
col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "TOI: %" G_GINT64_MODIFIER "u", toi);
else
- col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "TOI: 0x%s", tvb_bytes_to_str(tvb, offset, toi_size));
+ col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "TOI: 0x%s", tvb_bytes_to_ep_str(tvb, offset, toi_size));
offset += toi_size;
}
proto_tree_add_text(rsvp_ifid_subtree, tvb, offset + tlv_off + 4,
tlv_len - 4,
"Data: %s",
- tvb_bytes_to_str_punct(tvb, offset + tlv_off + 4, tlv_len - 4, ' '));
+ tvb_bytes_to_ep_str_punct(tvb, offset + tlv_off + 4, tlv_len - 4, ' '));
break;
}
padding = (4 - (tlv_len % 4)) % 4;
if (padding != 0)
proto_tree_add_text(rsvp_ifid_subtree, tvb, offset + tlv_off + tlv_len, padding, "Padding: %s",
- tvb_bytes_to_str_punct(tvb, offset + tlv_off + tlv_len, padding, ' '));
+ tvb_bytes_to_ep_str_punct(tvb, offset + tlv_off + tlv_len, padding, ' '));
tlv_off += tlv_len + padding;
}
}
proto_tree_add_item(rsvp_integ_flags_tree, hf_rsvp_integrity_flags_handshake,
tvb, offset2, 1, ENC_BIG_ENDIAN);
proto_tree_add_text(rsvp_object_tree, tvb, offset2+2, 6,
- "Key Identifier: %s", tvb_bytes_to_str(tvb, offset2+2, 6));
+ "Key Identifier: %s", tvb_bytes_to_ep_str(tvb, offset2+2, 6));
proto_tree_add_text(rsvp_object_tree, tvb, offset2+8, 8,
"Sequence Number: %" G_GINT64_MODIFIER "u", tvb_get_ntoh64(tvb, offset2+8));
proto_tree_add_text(rsvp_object_tree, tvb, offset2+16, obj_length - 20,
- "Hash: %s", tvb_bytes_to_str(tvb, offset2+16, obj_length - 20));
+ "Hash: %s", tvb_bytes_to_ep_str(tvb, offset2+16, obj_length - 20));
}
/*------------------------------------------------------------------------------
"Node ID: %s", tvb_ip_to_str(tvb, offset+12));
proto_item_append_text(ti, "Node ID: %s", tvb_ip_to_str(tvb, offset+12));
proto_tree_add_text(rsvp_object_tree, tvb, offset+8, 16,
- "Padding: %s", tvb_bytes_to_str_punct(tvb, offset+16, 8, ' '));
+ "Padding: %s", tvb_bytes_to_ep_str_punct(tvb, offset+16, 8, ' '));
break;
default:
proto_tree_add_text(rsvp_lsp_tunnel_if_id_subtree, tvb, offset+tlv_off+8, 8,
"Sub Interface/Connection ID: %" G_GINT64_MODIFIER "u (0x%s)",
tvb_get_ntoh64(tvb, offset+tlv_off+8),
- tvb_bytes_to_str(tvb, offset+tlv_off+8, 8));
+ tvb_bytes_to_ep_str(tvb, offset+tlv_off+8, 8));
proto_tree_add_text(rsvp_lsp_tunnel_if_id_subtree, tvb, offset+tlv_off+16, 4,
"SC PC ID: %s",
tvb_ip_to_str(tvb, offset+tlv_off+16));
case 0x7F:
offset4 = offset3 + len;
- str = tvb_bytes_to_str(tvb, offset3, len);
+ str = tvb_bytes_to_ep_str(tvb, offset3, len);
proto_tree_add_text(rsvp_object_tree, tvb, offset3, len,
"Source Transport Network addr: %s", str);
break;
proto_item_append_text(ti, "Src: %s. ", str);
proto_tree_add_text(rsvp_object_tree, tvb, offset4, 8, "Local Identifier: %s",
- tvb_bytes_to_str(tvb, offset4, 8));
- proto_item_append_text(ti, "Local ID: %s. ", tvb_bytes_to_str(tvb, offset4, 8));
+ tvb_bytes_to_ep_str(tvb, offset4, 8));
+ proto_item_append_text(ti, "Local ID: %s. ", tvb_bytes_to_ep_str(tvb, offset4, 8));
break;
default:
iValueOffset += iValueLength;
iByteArrayValue = (guint8 *)tvb_memdup(wmem_packet_scope(), tvb, iValueOffset, iArrayLength);
proto_tree_add_bytes(val_tree, hf_amf_bytearray, tvb, iValueOffset, iArrayLength, iByteArrayValue);
- proto_item_append_text(ti, " %s", bytes_to_str(iByteArrayValue, iArrayLength));
+ proto_item_append_text(ti, " %s", bytes_to_ep_str(iByteArrayValue, iArrayLength));
if (parent_ti != NULL)
- proto_item_append_text(parent_ti, " %s", bytes_to_str(iByteArrayValue, iArrayLength));
+ proto_item_append_text(parent_ti, " %s", bytes_to_ep_str(iByteArrayValue, iArrayLength));
} else {
/* the upper 28 bits of the integer value are a object reference index */
proto_tree_add_uint(val_tree, hf_amf_object_reference, tvb, iValueOffset, iValueLength, iIntegerValue >> 1);
offset = offset + len;
}
tvb_memcpy(tvb, partial_state, offset, partial_state_len);
- partial_state_str = bytes_to_str(partial_state, partial_state_len);
+ partial_state_str = bytes_to_ep_str(partial_state, partial_state_len);
proto_tree_add_string(sigcomp_tree,hf_sigcomp_partial_state,
tvb, offset, partial_state_len, partial_state_str);
offset = offset + partial_state_len;
/* Parameter Length 2 Bytes */
plen = tvb_get_ntohs(tvb, offset+2); /* read 2 byte length value */
/* Parameter Value plen Bytes */
- pvalue_char = tvb_bytes_to_str(tvb, offset+4, plen);
+ pvalue_char = tvb_bytes_to_ep_str(tvb, offset+4, plen);
simulcrypt_item = proto_tree_add_item(simulcrypt_tree, hf_simulcrypt_parameter, tvb, offset, plen+2+2, ENC_NA );
proto_tree_add_bytes_format_value(tree, hf_index, tvb,
cptr, count, NULL,
"%s (wrong length, should be 21, is %d",
- tvb_bytes_to_str(tvb, cptr, count), count);
+ tvb_bytes_to_ep_str(tvb, cptr, count), count);
}
} else {
proto_tree_add_bytes_format_value(tree, hf_index, tvb, 0, 0,
"%s: Value is %s, type is wrong (b)",
proto_registrar_get_name((*items->hf_index == -1) ?
hf_smb_pipe_bytes_param : *items->hf_index),
- tvb_bytes_to_str(tvb, offset, count));
+ tvb_bytes_to_ep_str(tvb, offset, count));
offset += count;
items++;
} else {
"%s: Value is %s, type is wrong (g)",
proto_registrar_get_name((*items->hf_index == -1) ?
hf_smb_pipe_bytes_param : *items->hf_index),
- tvb_bytes_to_str(tvb, offset, count));
+ tvb_bytes_to_ep_str(tvb, offset, count));
offset += count;
items++;
} else {
"%s: Value is %s, type is wrong (B)",
proto_registrar_get_name((*items->hf_index == -1) ?
hf_smb_pipe_bytes_param : *items->hf_index),
- tvb_bytes_to_str(tvb, offset, count));
+ tvb_bytes_to_ep_str(tvb, offset, count));
offset += count;
items++;
} else {
"%s: Value is %s, type is wrong (b)",
proto_registrar_get_name((*items->hf_index == -1) ?
hf_smb_pipe_bytes_param : *items->hf_index),
- tvb_bytes_to_str(tvb, cptr, count));
+ tvb_bytes_to_ep_str(tvb, cptr, count));
items++;
} else {
offset = (*items->func)(tvb, offset, count,
*offset, length, ENC_NA);
}
- proto_item_append_text(sub_tree,": %s", tvb_bytes_to_str(tvb,*offset,length));
+ proto_item_append_text(sub_tree,": %s", tvb_bytes_to_ep_str(tvb,*offset,length));
(*offset) += length;
break;
}
/* 12-byte AgentID w/ 8-byte trailer */
if (len_remain==8) {
proto_tree_add_text(tree, tvb, offset, 8, "AgentID Trailer: 0x%s",
- tvb_bytes_to_str(tvb, offset, 8));
+ tvb_bytes_to_ep_str(tvb, offset, 8));
offset+=8;
len_remain-=8;
} else {
if (usm_p.authOK) {
expert = &ei_snmp_authentication_ok;
} else {
- const gchar* calc_auth_str = bytestring_to_str(calc_auth,calc_auth_len,' ');
+ const gchar* calc_auth_str = bytestring_to_ep_str(calc_auth,calc_auth_len,' ');
proto_item_append_text(authen_item, " calculated = %s", calc_auth_str);
expert = &ei_snmp_authentication_error;
}
col_add_fstr(pinfo->cinfo, COL_INFO, "%s: 0x%08x",
val_to_str(frame_type, frame_type_vals, "Unknown (0x%02x)"), can_id.id);
col_append_fstr(pinfo->cinfo, COL_INFO, " %s",
- tvb_bytes_to_str_punct(tvb, CAN_DATA_OFFSET, frame_len, ' '));
+ tvb_bytes_to_ep_str_punct(tvb, CAN_DATA_OFFSET, frame_len, ' '));
ti = proto_tree_add_item(tree, proto_can, tvb, 0, -1, ENC_NA);
can_tree = proto_item_add_subtree(ti, ett_can);
if (ret != 0) {
ssl_debug_printf( "gnutls_x509_privkey_get_key_id(ssl_pkey, 0, buf_keyid, &buf_len) - %s\n", gnutls_strerror(ret));
} else {
- ssl_debug_printf( "Private key imported: KeyID %s\n", bytes_to_str_punct(buf_keyid, (int) buf_len, ':'));
+ ssl_debug_printf( "Private key imported: KeyID %s\n", bytes_to_ep_str_punct(buf_keyid, (int) buf_len, ':'));
}
/* RSA get parameter */
if (ret < 0) { g_strlcpy(buf_keyid, "<ERROR>", 32); }
private_key->x509_cert = ssl_cert;
- ssl_debug_printf( "Certificate imported: %s <%s>, KeyID %s\n", buf_name, buf_email, bytes_to_str(buf_keyid, (int) buf_len));
+ ssl_debug_printf( "Certificate imported: %s <%s>, KeyID %s\n", buf_name, buf_email, bytes_to_ep_str(buf_keyid, (int) buf_len));
break;
case GNUTLS_BAG_PKCS8_KEY:
if (primary_part){
if(value_len < 8){
col_append_fstr(actx->pinfo->cinfo, COL_INFO, "[%s]",
- tvb_bytes_to_str(value_tvb,0,value_len));
+ tvb_bytes_to_ep_str(value_tvb,0,value_len));
}
else {
col_append_fstr(actx->pinfo->cinfo, COL_INFO, "[%s...]",
- tvb_bytes_to_str(value_tvb,0,7));
+ tvb_bytes_to_ep_str(value_tvb,0,7));
}
}
offset += TL_BYTE;
proto_tree_add_item( sub_tree, hf_vuze_dht_key_data, tvb, offset, key_len, ENC_NA );
- proto_item_append_text( ti, ": %d bytes ( %s )", key_len, tvb_bytes_to_str(tvb, offset, key_len ) );
+ proto_item_append_text( ti, ": %d bytes ( %s )", key_len, tvb_bytes_to_ep_str(tvb, offset, key_len ) );
offset += key_len;
return offset;
offset += TL_SHORT;
proto_tree_add_item(sub_tree, hf_vuze_dht_value_bytes, tvb, offset, value_bytes_count, ENC_NA);
- proto_item_append_text( ti, ": %d bytes ( %s )", value_bytes_count, tvb_bytes_to_str(tvb, offset, value_bytes_count ) );
+ proto_item_append_text( ti, ": %d bytes ( %s )", value_bytes_count, tvb_bytes_to_ep_str(tvb, offset, value_bytes_count ) );
offset += value_bytes_count;
offset = dissect_vuze_dht_contact( tvb, pinfo, sub_tree, offset );
sub_tree = proto_item_add_subtree(ti, ett_vuze_dht_network_coordinate);
proto_item_append_text( ti, ": type %d, length %d ( %s )",
- tvb_get_guint8(tvb,offset), tvb_get_guint8(tvb,offset+TL_BYTE), tvb_bytes_to_str(tvb, offset+TL_BYTE+TL_BYTE, coordinate_size ) );
+ tvb_get_guint8(tvb,offset), tvb_get_guint8(tvb,offset+TL_BYTE), tvb_bytes_to_ep_str(tvb, offset+TL_BYTE+TL_BYTE, coordinate_size ) );
proto_tree_add_item( sub_tree, hf_vuze_dht_network_coordinate_type, tvb, offset, TL_BYTE, ENC_BIG_ENDIAN );
offset += TL_BYTE;
proto_tree_add_text(element_tree, tvb,
offset, capability_val_len,
"Value: %s",
- tvb_bytes_to_str(tvb, offset,
+ tvb_bytes_to_ep_str(tvb, offset,
capability_val_len));
break;
}
} else {
hfinfo = proto_registrar_get_nth(hf);
proto_tree_add_text (tree, tvb, offset, count+1, "%s: %s",
- hfinfo->name, tvb_bytes_to_str(tvb, offset+1, count));
+ hfinfo->name, tvb_bytes_to_ep_str(tvb, offset+1, count));
}
return offset+1+count;
}
offset += 4;
val = tvb_get_ptr(tvb, offset, val_len);
- repr = bytes_to_str(val, val_len);
+ repr = bytes_to_ep_str(val, val_len);
proto_item_append_text(ti, ", Type: binary, Value: %s", repr);
offset += (val_len + 3) & ~3;
offset += 4;
val = tvb_get_ptr(tvb, offset, val_len);
- repr = bytes_to_str(val, val_len);
+ repr = bytes_to_ep_str(val, val_len);
proto_item_append_text(ti, "%s, ", repr);
offset += (val_len + 3) & ~3;
*offset += 1;
/* Retrieve "PartitionedFrame" field */
- data_frame = tvb_bytes_to_str_punct(tvb, *offset, frame_len, ':');
+ data_frame = tvb_bytes_to_ep_str_punct(tvb, *offset, frame_len, ':');
proto_tree_add_string(tree, hf_zbee_zcl_part_part_frame, tvb, *offset, frame_len, data_frame);
*offset += frame_len;
*offset += 4;
/* Retrieve 'Log Payload' field */
- log_data = tvb_bytes_to_str_punct(tvb, *offset, log_len, ':');
+ log_data = tvb_bytes_to_ep_str_punct(tvb, *offset, log_len, ':');
proto_tree_add_string(tree, hf_zbee_zcl_appl_stats_log_payload, tvb, *offset, log_len, log_data);
*offset += log_len;
}/*dissect_zcl_appl_stats_log_rsp*/
*offset += 1;
- attr_string = tvb_bytes_to_str_punct(tvb, *offset, attr_uint, ':');
+ attr_string = tvb_bytes_to_ep_str_punct(tvb, *offset, attr_uint, ':');
proto_item_append_text(tree, ", Octets: %s", attr_string);
proto_tree_add_string(tree, hf_zbee_zcl_attr_ostr, tvb, *offset, attr_uint,
attr_string);
*offset += 2;
- attr_string = tvb_bytes_to_str_punct(tvb, *offset, attr_uint, ':');
+ attr_string = tvb_bytes_to_ep_str_punct(tvb, *offset, attr_uint, ':');
proto_item_append_text(tree, ", Octets: %s", attr_string);
proto_tree_add_string(tree, hf_zbee_zcl_attr_ostr, tvb, *offset, attr_uint, attr_string);
proto_tree_add_bytes_format_value(tree, hf,
tvb, offset, length, NULL, "%s (%s)",
val_to_str_const(encoding, dvb_string_encoding_vals, "Unknown"),
- bytes_to_str_punct(
+ bytes_to_ep_str_punct(
tvb_get_ptr(tvb, offset, length), length, ' '));
}
}
D(3,("\tOid (from encoded): %s %s ",name, oid_subid2string(subids,subids_len)));
add_oid(name,OID_KIND_UNKNOWN,NULL,NULL,subids_len,subids);
} else {
- D(1,("Failed to add Oid: %s [%d]%s ",name?name:"NULL", oid_len,bytestring_to_str(oid, oid_len, ':')));
+ D(1,("Failed to add Oid: %s [%d]%s ",name?name:"NULL", oid_len,bytestring_to_ep_str(oid, oid_len, ':')));
}
}
"oid_string2encoded=[%d]%s \n"
"oid_string2subid=%s \n "
,sub2str
- ,sub2enc_len,bytestring_to_str(sub2enc, sub2enc_len, ':')
+ ,sub2enc_len,bytestring_to_ep_str(sub2enc, sub2enc_len, ':')
,enc2sub ? oid_subid2string(enc2sub,enc2sub_len) : "-"
,enc2str
- ,str2enc_len,bytestring_to_str(str2enc, str2enc_len, ':')
+ ,str2enc_len,bytestring_to_ep_str(str2enc, str2enc_len, ':')
,str2sub ? oid_subid2string(str2sub,str2sub_len) : "-"
);
}
case FT_BYTES:
bytes = (guint8 *)fvalue_get(&finfo->value);
offset_r += protoo_strlcpy(result+offset_r,
- bytes_to_str(bytes,
+ bytes_to_ep_str(bytes,
fvalue_length(&finfo->value)),
size-offset_r);
break;
case FT_ETHER:
offset_r += protoo_strlcpy(result+offset_r,
- bytes_to_str_punct((const guint8 *)fvalue_get(&finfo->value),
+ bytes_to_ep_str_punct((const guint8 *)fvalue_get(&finfo->value),
FT_ETHER_LEN, ':'),
size-offset_r);
break;
case FT_UINT_BYTES:
bytes = (guint8 *)fvalue_get(&fi->value);
label_fill(label_str, 0, hfinfo,
- (bytes) ? bytes_to_str(bytes, fvalue_length(&fi->value)) : "<MISSING>");
+ (bytes) ? bytes_to_ep_str(bytes, fvalue_length(&fi->value)) : "<MISSING>");
break;
/* Four types of integers to take care of:
if (print_level_2 ){
proto_tree_add_text(udvm_tree, message_tvb, 0, -1,
"Calculated SHA-1: %s",
- bytes_to_str(sha1_digest_buf, STATE_BUFFER_SIZE));
+ bytes_to_ep_str(sha1_digest_buf, STATE_BUFFER_SIZE));
}
current_address = next_operand_address;
sha1_update( &ctx, (guint8 *) sha1buff, state_length_buff[n] + 8);
sha1_finish( &ctx, sha1_digest_buf );
if (print_level_3 ){
- proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"SHA1 digest %s",bytes_to_str(sha1_digest_buf, STATE_BUFFER_SIZE));
+ proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"SHA1 digest %s",bytes_to_ep_str(sha1_digest_buf, STATE_BUFFER_SIZE));
}
/* begin partial state-id change cco@iptel.org */
udvm_state_create(sha1buff, sha1_digest_buf, STATE_MIN_ACCESS_LEN);
/* end partial state-id change cco@iptel.org */
proto_tree_add_text(udvm_tree,bytecode_tvb, 0, -1,"### Creating state ###");
- proto_tree_add_string(udvm_tree,hf_id, bytecode_tvb, 0, 0, bytes_to_str(sha1_digest_buf, state_minimum_access_length_buff[n]));
+ proto_tree_add_string(udvm_tree,hf_id, bytecode_tvb, 0, 0, bytes_to_ep_str(sha1_digest_buf, state_minimum_access_length_buff[n]));
n++;
*/
sip_sdp_buff = (guint8 *)g_malloc(SIP_SDP_STATE_LENGTH + 8);
- partial_state_str = bytes_to_str(sip_sdp_state_identifier, 6);
+ partial_state_str = bytes_to_ep_str(sip_sdp_state_identifier, 6);
/*
* Debug g_warning("Sigcomp init: Storing partial state =%s",partial_state_str);
presence_buff = (guint8 *)g_malloc(PRESENCE_STATE_LENGTH + 8);
- partial_state_str = bytes_to_str(presence_state_identifier, 6);
+ partial_state_str = bytes_to_ep_str(presence_state_identifier, 6);
memset(sip_sdp_buff, 0, 8);
i = 0;
partial_state[n] = buff[p_id_start + n];
n++;
}
- partial_state_str = bytes_to_str(partial_state, p_id_length);
+ partial_state_str = bytes_to_ep_str(partial_state, p_id_length);
proto_tree_add_text(tree,tvb, 0, -1,"### Accessing state ###");
proto_tree_add_string(tree,hf_id, tvb, 0, 0, partial_state_str);
partial_state[i] = state_identifier[i];
i++;
}
- partial_state_str = bytes_to_str(partial_state, p_id_length);
+ partial_state_str = bytes_to_ep_str(partial_state, p_id_length);
dummy_buff = (gchar *)g_hash_table_lookup(state_buffer_table, partial_state_str);
if ( dummy_buff == NULL ){
partial_state[i] = buff[p_id_start + i];
i++;
}
- partial_state_str = bytes_to_str(partial_state, p_id_length);
+ partial_state_str = bytes_to_ep_str(partial_state, p_id_length);
/* TODO Implement a state create counter before actually freeing states
* Hmm is it a good idea to free the buffer at all?
*/
* the resulting string is (len-1) bytes shorter)
*/
const gchar *
-bytestring_to_str(const guint8 *ad, const guint32 len, const char punct) {
+bytestring_to_ep_str(const guint8 *ad, const guint32 len, const char punct) {
gchar *buf;
size_t buflen;
if (!ad)
- REPORT_DISSECTOR_BUG("Null pointer passed to bytestring_to_str()");
+ REPORT_DISSECTOR_BUG("Null pointer passed to bytestring_to_ep_str()");
/* XXX, Old code was using int as iterator... Why len is guint32 anyway?! (darkjames) */
if ( ((int) len) < 0)
#define MAX_BYTE_STR_LEN 48
gchar *
-bytes_to_str(const guint8 *bd, int bd_len) {
+bytes_to_ep_str(const guint8 *bd, int bd_len) {
gchar *cur;
gchar *cur_ptr;
int truncated = 0;
if (!bd)
- REPORT_DISSECTOR_BUG("Null pointer passed to bytes_to_str()");
+ REPORT_DISSECTOR_BUG("Null pointer passed to bytes_to_ep_str()");
cur=(gchar *)ep_alloc(MAX_BYTE_STR_LEN+3+1);
if (bd_len <= 0) { cur[0] = '\0'; return cur; }
* punct as a bytes separator.
*/
gchar *
-bytes_to_str_punct(const guint8 *bd, int bd_len, gchar punct) {
+bytes_to_ep_str_punct(const guint8 *bd, int bd_len, gchar punct) {
gchar *cur;
gchar *cur_ptr;
int truncated = 0;
if (!punct)
- return bytes_to_str(bd, bd_len);
+ return bytes_to_ep_str(bd, bd_len);
cur=(gchar *)ep_alloc(MAX_BYTE_STR_LEN+3+1);
if (bd_len <= 0) { cur[0] = '\0'; return cur; }
* @param bd_len The length of the byte array
* @return A pointer to the formatted string
*
- * @see bytes_to_str_punct()
+ * @see bytes_to_ep_str_punct()
*/
-WS_DLL_PUBLIC gchar *bytes_to_str(const guint8 *bd, int bd_len);
+WS_DLL_PUBLIC gchar *bytes_to_ep_str(const guint8 *bd, int bd_len);
/** Turn an array of bytes into a string showing the bytes in hex,
* separated by a punctuation character.
* @param punct The punctuation character
* @return A pointer to the formatted string
*
- * @see bytes_to_str()
+ * @see bytes_to_ep_str()
*/
-WS_DLL_PUBLIC gchar *bytes_to_str_punct(const guint8 *bd, int bd_len, gchar punct);
+WS_DLL_PUBLIC gchar *bytes_to_ep_str_punct(const guint8 *bd, int bd_len, gchar punct);
-WS_DLL_PUBLIC const gchar *bytestring_to_str(const guint8 *, const guint32, const char punct);
+WS_DLL_PUBLIC const gchar *bytestring_to_ep_str(const guint8 *, const guint32, const char punct);
#ifdef __cplusplus
}
* separator.
*/
gchar *
-tvb_bytes_to_str_punct(tvbuff_t *tvb, const gint offset, const gint len, const gchar punct)
+tvb_bytes_to_ep_str_punct(tvbuff_t *tvb, const gint offset, const gint len, const gchar punct)
{
- return bytes_to_str_punct(ensure_contiguous(tvb, offset, len), len, punct);
+ return bytes_to_ep_str_punct(ensure_contiguous(tvb, offset, len), len, punct);
}
* to the string with the formatted data.
*/
gchar *
-tvb_bytes_to_str(tvbuff_t *tvb, const gint offset, const gint len)
+tvb_bytes_to_ep_str(tvbuff_t *tvb, const gint offset, const gint len)
{
- return bytes_to_str(ensure_contiguous(tvb, offset, len), len);
+ return bytes_to_ep_str(ensure_contiguous(tvb, offset, len), len);
}
/* Find a needle tvbuff within a haystack tvbuff. */
* to the string with the formatted data, with "punct" as a byte
* separator.
*/
-WS_DLL_PUBLIC gchar *tvb_bytes_to_str_punct(tvbuff_t *tvb, const gint offset,
+WS_DLL_PUBLIC gchar *tvb_bytes_to_ep_str_punct(tvbuff_t *tvb, const gint offset,
const gint len, const gchar punct);
/**
* Format a bunch of data from a tvbuff as bytes, returning a pointer
* to the string with the formatted data.
*/
-WS_DLL_PUBLIC gchar *tvb_bytes_to_str(tvbuff_t *tvb, const gint offset,
+WS_DLL_PUBLIC gchar *tvb_bytes_to_ep_str(tvbuff_t *tvb, const gint offset,
const gint len);
/**
}
len = tvb_length(tvb->ws_tvb);
- str = ep_strdup_printf("TVB(%i) : %s",len,tvb_bytes_to_str(tvb->ws_tvb,0,len));
+ str = ep_strdup_printf("TVB(%i) : %s",len,tvb_bytes_to_ep_str(tvb->ws_tvb,0,len));
lua_pushstring(L,str);
WSLUA_RETURN(1); /* The string. */
}
return 0;
}
- lua_pushstring(L,tvb_bytes_to_str(tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len));
+ lua_pushstring(L,tvb_bytes_to_ep_str(tvbr->tvb->ws_tvb,tvbr->offset,tvbr->len));
return 1;
}
const gchar *format1;
const gchar *format2;
const guint8 *p = tvb_get_ptr(tvb, offset, length);
- const gchar *s = bytestring_to_str(p, MIN(length, max_show_bytes), 0);
+ const gchar *s = bytestring_to_ep_str(p, MIN(length, max_show_bytes), 0);
if (length <= max_show_bytes)
{
{
const gchar *format;
const guint8 *p = tvb_get_ptr(tvb, offset, length);
- const gchar *s = bytestring_to_str(p, MIN(length, max_show_bytes), 0);
+ const gchar *s = bytestring_to_ep_str(p, MIN(length, max_show_bytes), 0);
if (length <= max_show_bytes)
{
const gchar *format2;
const guint8 *p = tvb_get_ptr(tvb, offset, length);
const gchar *s =
- bytestring_to_str(p, MIN(length, max_show_bytes), 0);
+ bytestring_to_ep_str(p, MIN(length, max_show_bytes), 0);
if (length <= max_show_bytes)
{
{
const gchar *format;
const guint8 *p = tvb_get_ptr(tvb, offset, length);
- const gchar *s = bytestring_to_str(p, MIN(length, max_show_bytes), 0);
+ const gchar *s = bytestring_to_ep_str(p, MIN(length, max_show_bytes), 0);
if (length <= max_show_bytes)
{
* address (for IPv6).
*/
if ((pinfo->dl_dst.type != AT_ETHER) ||
- ((g_ascii_strncasecmp("01005E", bytes_to_str((const guint8 *)pinfo->dl_dst.data, pinfo->dl_dst.len), 6) != 0) &&
- (g_ascii_strncasecmp("3333", bytes_to_str((const guint8 *)pinfo->dl_dst.data, pinfo->dl_dst.len), 4) != 0)) )
+ ((g_ascii_strncasecmp("01005E", bytes_to_ep_str((const guint8 *)pinfo->dl_dst.data, pinfo->dl_dst.len), 6) != 0) &&
+ (g_ascii_strncasecmp("3333", bytes_to_ep_str((const guint8 *)pinfo->dl_dst.data, pinfo->dl_dst.len), 4) != 0)) )
return 0;
/* check whether we already have a stream with these parameters in the list */
string_rep = str;
break;
case PT_TXTMOD_HEXBYTES: {
- string_rep = bytes_to_str((const guint8 *) str, length);
+ string_rep = bytes_to_ep_str((const guint8 *) str, length);
break;
}
default:
git.samba.org / metze / wireshark / wip.git / commitdiff