buffers. Remove two unused functions.
svn path=/trunk/; revision=54250
ts.nsecs = 0;
proto_tree_add_time_format_value(tree, hf_snmp_engineid_time, tvb, offset+4, 4,
&ts, "%s",
- abs_time_secs_to_str(seconds, ABSOLUTE_TIME_LOCAL, TRUE));
+ abs_time_secs_to_ep_str(seconds, ABSOLUTE_TIME_LOCAL, TRUE));
offset+=8;
len_remain=0;
}
/* get Header (CID) 16 bytes */
tvb_get_guid(tvb, header_offset, &guid, ENC_BIG_ENDIAN);
- proto_item_append_text(ti, ", Src: %s", guid_to_str(&guid));
+ proto_item_append_text(ti, ", Src: %s", guid_to_ep_str(&guid));
/* add cid to info */
- col_add_fstr(pinfo->cinfo,COL_INFO, "CID %s", guid_to_str(&guid));
+ col_add_fstr(pinfo->cinfo,COL_INFO, "CID %s", guid_to_ep_str(&guid));
proto_tree_add_item(pdu_tree, hf_acn_cid, tvb, header_offset, 16, ENC_BIG_ENDIAN);
/*header_offset += 16;*/
/* get Header (CID) 16 bytes */
tvb_get_guid(tvb, header_offset, &guid, ENC_BIG_ENDIAN);
- proto_item_append_text(ti, ", Src: %s", guid_to_str(&guid));
+ proto_item_append_text(ti, ", Src: %s", guid_to_ep_str(&guid));
proto_tree_add_item(pdu_tree, hf_acn_cid, tvb, header_offset, 16, ENC_BIG_ENDIAN);
/*header_offset += 16;*/
offset += 4;
tmp_time.secs = tvb_get_ntohl(tvb, offset);
proto_tree_add_text(adwin_tree, tvb, offset, 4,
- "File time: %s", abs_time_to_str(&tmp_time, ABSOLUTE_TIME_LOCAL, TRUE));
+ "File time: %s", abs_time_to_ep_str(&tmp_time, ABSOLUTE_TIME_LOCAL, TRUE));
offset += 4;
tmp_time.secs = tvb_get_ntohl(tvb, offset);
proto_tree_add_text(adwin_tree, tvb, offset, 4,
- "Update time: %s", abs_time_to_str(&tmp_time, ABSOLUTE_TIME_LOCAL, TRUE));
+ "Update time: %s", abs_time_to_ep_str(&tmp_time, ABSOLUTE_TIME_LOCAL, TRUE));
offset += 4;
proto_tree_add_item(adwin_tree, hf_adwin_config_unused, tvb, offset, 128, ENC_BIG_ENDIAN);
offset += 128;
NORLEL(flags, r_uptime, tvb, offset);
proto_tree_add_uint_format(subtree, hf_resp_uptime, tvb, offset, 4, r_uptime,
- "sysUptime: %s", time_msecs_to_str(r_uptime));
+ "sysUptime: %s", time_msecs_to_ep_str(r_uptime));
proto_tree_add_item(subtree, hf_resp_error, tvb, offset + 4, 2, encoding);
proto_tree_add_item(subtree, hf_resp_index, tvb, offset + 6, 2, encoding);
offset += 8;
if (hf != NULL) {
time_s_secs = (gint32) tvb_get_ntohl(tvb, offset);
proto_tree_add_int_format_value(tree, *hf,
- tvb, offset, 4, time_s_secs, "(%ds) %s", time_s_secs, time_secs_to_str(time_s_secs));
+ tvb, offset, 4, time_s_secs, "(%ds) %s", time_s_secs, time_secs_to_ep_str(time_s_secs));
}
else if (hf_default->time_in_s_secs != NULL)
proto_tree_add_item(tree, *hf_default->time_in_s_secs, tvb, offset, 4, ENC_BIG_ENDIAN);
time_u_secs = tvb_get_ntohl(tvb, offset);
proto_tree_add_uint_format_value(tree, *hf,
tvb, offset, 4, time_u_secs, "(%us) %s", time_u_secs,
- ((time_u_secs == 0xffffffff) ? "infinity" : time_secs_to_str_unsigned(time_u_secs)));
+ ((time_u_secs == 0xffffffff) ? "infinity" : time_secs_to_ep_str_unsigned(time_u_secs)));
}
else if (hf_default->time_in_u_secs != NULL)
proto_tree_add_item(tree, *hf_default->time_in_u_secs, tvb, offset, 4, ENC_BIG_ENDIAN);
fraction = ( multiplier * ( (int)fine_time & 0xff ) ) / 256;
t.nsecs = fraction*1000000; /* msecs to nsecs */
- return abs_time_to_str(&t, ABSOLUTE_TIME_DOY_UTC, TRUE);
+ return abs_time_to_ep_str(&t, ABSOLUTE_TIME_DOY_UTC, TRUE);
}
gchar *strtime;
nstime = collectd_time_to_nstime (*ret_value);
- strtime = abs_time_to_str (&nstime, ABSOLUTE_TIME_LOCAL, /* show_zone = */ TRUE);
+ strtime = abs_time_to_ep_str (&nstime, ABSOLUTE_TIME_LOCAL, /* show_zone = */ TRUE);
pi = proto_tree_add_text (tree_root, tvb, offset, length,
"collectd %s segment: %s",
val_to_str_const (type, part_names, "UNKNOWN"),
gchar *strtime;
nstime = collectd_time_to_nstime (*ret_value);
- strtime = rel_time_to_str (&nstime);
+ strtime = rel_time_to_ep_str (&nstime);
pi = proto_tree_add_text (tree_root, tvb, offset, length,
"collectd %s segment: %s",
val_to_str_const (type, part_names, "UNKNOWN"),
iface_item = proto_tree_add_item(ctx_tree, hf_dcerpc_cn_bind_abstract_syntax, tvb, offset, 0, ENC_NA);
iface_tree = proto_item_add_subtree(iface_item, ett_dcerpc_cn_iface);
- uuid_str = guid_to_str((e_guid_t*)&if_id);
+ uuid_str = guid_to_ep_str((e_guid_t*)&if_id);
uuid_name = guids_get_uuid_name(&if_id);
if (uuid_name) {
proto_tree_add_guid_format(iface_tree, hf_dcerpc_cn_bind_if_id, tvb,
trans_item = proto_tree_add_item(ctx_tree, hf_dcerpc_cn_bind_trans_syntax, tvb, offset, 0, ENC_NA);
trans_tree = proto_item_add_subtree(trans_item, ett_dcerpc_cn_trans_syntax);
- uuid_str = guid_to_str((e_guid_t *) &trans_id);
+ uuid_str = guid_to_ep_str((e_guid_t *) &trans_id);
uuid_name = guids_get_uuid_name(&trans_id);
if (uuid_name) {
dcerpc_tvb_get_uuid(tvb, offset, hdr->drep, &trans_id);
uuid_name = guids_get_uuid_name(&trans_id);
if (! uuid_name) {
- uuid_name = guid_to_str((e_guid_t *) &trans_id);
+ uuid_name = guid_to_ep_str((e_guid_t *) &trans_id);
}
proto_tree_add_guid_format(ctx_tree, hf_dcerpc_cn_ack_trans_id, tvb,
offset, 16, (e_guid_t *) &trans_id, "Transfer Syntax: %s",
if (dcerpc_tree) {
proto_tree_add_guid_format(dcerpc_tree, hf_dcerpc_obj_id, tvb,
offset, 16, (e_guid_t *) &obj_id, "Object UUID: %s",
- guid_to_str((e_guid_t *) &obj_id));
+ guid_to_ep_str((e_guid_t *) &obj_id));
}
offset += 16;
}
if (dcerpc_tree && (memcmp(&value->object_uuid, &obj_id_null, sizeof(obj_id_null)) != 0)) {
pi = proto_tree_add_guid_format(dcerpc_tree, hf_dcerpc_obj_id, tvb,
offset, 0, (e_guid_t *) &value->object_uuid, "Object UUID: %s",
- guid_to_str((e_guid_t *) &value->object_uuid));
+ guid_to_ep_str((e_guid_t *) &value->object_uuid));
PROTO_ITEM_SET_GENERATED(pi);
}
if (tree) {
proto_tree_add_guid_format(dcerpc_tree, hf_dcerpc_obj_id, tvb,
offset, 16, (e_guid_t *) &hdr.obj_id, "Object UUID: %s",
- guid_to_str((e_guid_t *) &hdr.obj_id));
+ guid_to_ep_str((e_guid_t *) &hdr.obj_id));
}
offset += 16;
if (tree) {
- uuid_str = guid_to_str((e_guid_t*)&hdr.if_id);
+ uuid_str = guid_to_ep_str((e_guid_t*)&hdr.if_id);
uuid_name = guids_get_uuid_name(&hdr.if_id);
if (uuid_name) {
proto_tree_add_guid_format(dcerpc_tree, hf_dcerpc_dg_if_id, tvb,
if (tree) {
proto_tree_add_guid_format(dcerpc_tree, hf_dcerpc_dg_act_id, tvb,
offset, 16, (e_guid_t *) &hdr.act_id, "Activity: %s",
- guid_to_str((e_guid_t *) &hdr.act_id));
+ guid_to_ep_str((e_guid_t *) &hdr.act_id));
}
offset += 16;
timex.nsecs = 0;
proto_tree_add_time_format_value(dhcpfo_tree, hf_dhcpfo_time, tvb,
offset, 4, &timex, "%s",
- abs_time_secs_to_str(timex.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ abs_time_secs_to_ep_str(timex.secs, ABSOLUTE_TIME_LOCAL, TRUE));
}
offset += 4;
lease_expiration_time =
tvb_get_ntohl(tvb, offset);
lease_expiration_time_str =
- abs_time_secs_to_str(lease_expiration_time, ABSOLUTE_TIME_LOCAL, TRUE);
+ abs_time_secs_to_ep_str(lease_expiration_time, ABSOLUTE_TIME_LOCAL, TRUE);
proto_item_append_text(oi, ", %s",
lease_expiration_time_str);
tvb_get_ntohl(tvb, offset);
potential_expiration_time_str =
- abs_time_secs_to_str(potential_expiration_time, ABSOLUTE_TIME_LOCAL, TRUE);
+ abs_time_secs_to_ep_str(potential_expiration_time, ABSOLUTE_TIME_LOCAL, TRUE);
proto_item_append_text(oi, ", %s",
potential_expiration_time_str);
tvb_get_ntohl(tvb, offset);
grace_expiration_time_str =
- abs_time_secs_to_str(grace_expiration_time, ABSOLUTE_TIME_LOCAL, TRUE);
+ abs_time_secs_to_ep_str(grace_expiration_time, ABSOLUTE_TIME_LOCAL, TRUE);
proto_item_append_text(oi, ", %s",
grace_expiration_time_str);
client_last_transaction_time =
tvb_get_ntohl(tvb, offset);
client_last_transaction_time_str =
- abs_time_secs_to_str(client_last_transaction_time, ABSOLUTE_TIME_LOCAL, TRUE);
+ abs_time_secs_to_ep_str(client_last_transaction_time, ABSOLUTE_TIME_LOCAL, TRUE);
proto_item_append_text(oi, ", %s",
client_last_transaction_time_str);
offset, option_length,
client_last_transaction_time,
"%s",
- abs_time_secs_to_str(client_last_transaction_time, ABSOLUTE_TIME_LOCAL, TRUE));
+ abs_time_secs_to_ep_str(client_last_transaction_time, ABSOLUTE_TIME_LOCAL, TRUE));
break;
case DHCP_FO_PD_START_TIME_OF_STATE:
start_time_of_state =
tvb_get_ntohl(tvb, offset);
start_time_of_state_str =
- abs_time_secs_to_str(start_time_of_state, ABSOLUTE_TIME_LOCAL, TRUE);
+ abs_time_secs_to_ep_str(start_time_of_state, ABSOLUTE_TIME_LOCAL, TRUE);
proto_item_append_text(oi, ", %s",
start_time_of_state_str);
offset, option_length,
start_time_of_state,
"%s",
- abs_time_secs_to_str(start_time_of_state, ABSOLUTE_TIME_LOCAL, TRUE));
+ abs_time_secs_to_ep_str(start_time_of_state, ABSOLUTE_TIME_LOCAL, TRUE));
break;
case DHCP_FO_PD_SERVERSTATE:
"%s",
(subm_time & 0x7FFF) >= 0x7FF8 ?
"Reserved" :
- abs_time_secs_to_str (dmp.subm_time, ABSOLUTE_TIME_LOCAL, TRUE));
+ abs_time_secs_to_ep_str (dmp.subm_time, ABSOLUTE_TIME_LOCAL, TRUE));
field_tree = proto_item_add_subtree (tf, ett_envelope_subm_time);
proto_tree_add_item (field_tree, hf_envelope_time_diff_present, tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item (field_tree, hf_envelope_subm_time_value, tvb, offset, 2, ENC_BIG_ENDIAN);
if (secs == DMP_TIME_RESERVED) {
proto_item_append_text (tf, "Reserved (0x%2.2x)", time_diff);
} else {
- proto_item_append_text (tf, "%s", time_secs_to_str (secs));
+ proto_item_append_text (tf, "%s", time_secs_to_ep_str (secs));
}
offset += 1;
}
proto_item_append_text (tf, "Reserved (0x%2.2x)", report);
proto_item_append_text (ei, " (Reserved)");
} else {
- proto_item_append_text (tf, "%s (%s)", time_secs_to_str (secs),
- abs_time_secs_to_str (dmp.subm_time - secs, ABSOLUTE_TIME_LOCAL, TRUE));
- proto_item_append_text (ei, " (%s from submission time)", time_secs_to_str (secs));
+ proto_item_append_text (tf, "%s (%s)", time_secs_to_ep_str (secs),
+ abs_time_secs_to_ep_str (dmp.subm_time - secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ proto_item_append_text (ei, " (%s from submission time)", time_secs_to_ep_str (secs));
}
} else {
dmp.ndr = TRUE;
proto_item_append_text (tf, "Reserved (0x%2.2x)", rec_time);
proto_item_append_text (ei, " (Reserved)");
} else {
- proto_item_append_text (tf, "%s (%s)", time_secs_to_str (secs),
- abs_time_secs_to_str (dmp.subm_time - secs, ABSOLUTE_TIME_LOCAL, TRUE));
- proto_item_append_text (ei, " (%s from submission time)", time_secs_to_str (secs));
+ proto_item_append_text (tf, "%s (%s)", time_secs_to_ep_str (secs),
+ abs_time_secs_to_ep_str (dmp.subm_time - secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ proto_item_append_text (ei, " (%s from submission time)", time_secs_to_ep_str (secs));
}
offset += 1;
proto_item_append_text (tf, "Reserved (0x%2.2x)", exp_time);
proto_item_append_text (ei, " (Reserved)");
} else {
- proto_item_append_text (tf, "%s (%s)", time_secs_to_str (secs),
- abs_time_secs_to_str (dmp.subm_time + secs, ABSOLUTE_TIME_LOCAL, TRUE));
- proto_item_append_text (ei, " (%s from submission time)", time_secs_to_str (secs));
+ proto_item_append_text (tf, "%s (%s)", time_secs_to_ep_str (secs),
+ abs_time_secs_to_ep_str (dmp.subm_time + secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ proto_item_append_text (ei, " (%s from submission time)", time_secs_to_ep_str (secs));
}
offset += 1;
}
proto_item_append_text (tf, "0 minutes in the %s (%s)",
(dtg & 0x80) ? dtg_sign.true_string :
dtg_sign.false_string,
- abs_time_secs_to_str (dmp.subm_time, ABSOLUTE_TIME_LOCAL, TRUE));
+ abs_time_secs_to_ep_str (dmp.subm_time, ABSOLUTE_TIME_LOCAL, TRUE));
} else {
- proto_item_append_text (tf, "%s in the %s (%s)", time_secs_to_str(secs),
+ proto_item_append_text (tf, "%s in the %s (%s)", time_secs_to_ep_str(secs),
(dtg & 0x80) ? dtg_sign.true_string :
dtg_sign.false_string, (dtg & 0x80) ?
- abs_time_secs_to_str (dmp.subm_time + secs, ABSOLUTE_TIME_LOCAL, TRUE) :
- abs_time_secs_to_str (dmp.subm_time - secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ abs_time_secs_to_ep_str (dmp.subm_time + secs, ABSOLUTE_TIME_LOCAL, TRUE) :
+ abs_time_secs_to_ep_str (dmp.subm_time - secs, ABSOLUTE_TIME_LOCAL, TRUE));
}
offset += 1;
}
al_bit = (al_ptflags & AL_OBJ_BI_FLAG7) >> 7; /* bit shift 1xxxxxxx -> xxxxxxx1 */
proto_item_append_text(point_item, ", Value: %u, Timestamp: %s",
- al_bit, abs_time_to_str(&al_abstime, ABSOLUTE_TIME_UTC, FALSE));
+ al_bit, abs_time_to_ep_str(&al_abstime, ABSOLUTE_TIME_UTC, FALSE));
proto_item_set_len(point_item, data_pos - offset);
offset = data_pos;
al_2bit = (al_ptflags >> 6) & 3; /* bit shift 11xxxxxx -> 00000011 */
proto_item_append_text(point_item, ", Value: %u, Timestamp: %s",
- al_2bit, abs_time_to_str(&al_abstime, ABSOLUTE_TIME_UTC, FALSE));
+ al_2bit, abs_time_to_ep_str(&al_abstime, ABSOLUTE_TIME_UTC, FALSE));
proto_item_set_len(point_item, data_pos - offset);
offset = data_pos;
al_bit = (al_ptflags & AL_OBJ_BI_FLAG7) >> 7; /* bit shift 1xxxxxxx -> xxxxxxx1 */
proto_item_append_text(point_item, ", Value: %u, Timestamp: %s",
- al_bit, abs_time_to_str(&al_abstime, ABSOLUTE_TIME_UTC, FALSE));
+ al_bit, abs_time_to_ep_str(&al_abstime, ABSOLUTE_TIME_UTC, FALSE));
proto_item_set_len(point_item, data_pos - offset);
offset = data_pos;
case AL_OBJ_FDCTRC_32T:
case AL_OBJ_FDCTRC_16T:
dnp3_al_get_timestamp(&al_abstime, tvb, data_pos);
- proto_item_append_text(point_item, ", Timestamp: %s", abs_time_to_str(&al_abstime, ABSOLUTE_TIME_UTC, FALSE));
+ proto_item_append_text(point_item, ", Timestamp: %s", abs_time_to_ep_str(&al_abstime, ABSOLUTE_TIME_UTC, FALSE));
proto_tree_add_time(point_tree, hf_dnp3_al_timestamp, tvb, data_pos, 6, &al_abstime);
data_pos += 6;
break;
case AL_OBJ_AIFC_FLTT:
case AL_OBJ_AIFC_DBLT:
dnp3_al_get_timestamp(&al_abstime, tvb, data_pos);
- proto_item_append_text(point_item, ", Timestamp: %s", abs_time_to_str(&al_abstime, ABSOLUTE_TIME_UTC, FALSE));
+ proto_item_append_text(point_item, ", Timestamp: %s", abs_time_to_ep_str(&al_abstime, ABSOLUTE_TIME_UTC, FALSE));
proto_tree_add_time(point_tree, hf_dnp3_al_timestamp, tvb, data_pos, 6, &al_abstime);
data_pos += 6;
break;
case AL_OBJ_AOC_FLTT:
case AL_OBJ_AOC_DBLT:
dnp3_al_get_timestamp(&al_abstime, tvb, data_pos);
- proto_item_append_text(point_item, ", Timestamp: %s", abs_time_to_str(&al_abstime, ABSOLUTE_TIME_UTC, FALSE));
+ proto_item_append_text(point_item, ", Timestamp: %s", abs_time_to_ep_str(&al_abstime, ABSOLUTE_TIME_UTC, FALSE));
proto_tree_add_time(point_tree, hf_dnp3_al_timestamp, tvb, data_pos, 6, &al_abstime);
data_pos += 6;
break;
cur_offset += 4;
ti_soa = proto_tree_add_item(rr_tree, hf_dns_soa_refresh_interval, tvb, cur_offset, 4, ENC_BIG_ENDIAN);
- proto_item_append_text(ti_soa, " (%s)", time_secs_to_str(tvb_get_ntohl(tvb, cur_offset)));
+ proto_item_append_text(ti_soa, " (%s)", time_secs_to_ep_str(tvb_get_ntohl(tvb, cur_offset)));
cur_offset += 4;
ti_soa = proto_tree_add_item(rr_tree, hf_dns_soa_retry_interval, tvb, cur_offset, 4, ENC_BIG_ENDIAN);
- proto_item_append_text(ti_soa, " (%s)", time_secs_to_str(tvb_get_ntohl(tvb, cur_offset)));
+ proto_item_append_text(ti_soa, " (%s)", time_secs_to_ep_str(tvb_get_ntohl(tvb, cur_offset)));
cur_offset += 4;
ti_soa = proto_tree_add_item(rr_tree, hf_dns_soa_expire_limit, tvb, cur_offset, 4, ENC_BIG_ENDIAN);
- proto_item_append_text(ti_soa, " (%s)", time_secs_to_str(tvb_get_ntohl(tvb, cur_offset)));
+ proto_item_append_text(ti_soa, " (%s)", time_secs_to_ep_str(tvb_get_ntohl(tvb, cur_offset)));
cur_offset += 4;
ti_soa = proto_tree_add_item(rr_tree, hf_dns_soa_minimum_ttl, tvb, cur_offset, 4, ENC_BIG_ENDIAN);
- proto_item_append_text(ti_soa, " (%s)", time_secs_to_str(tvb_get_ntohl(tvb, cur_offset)));
+ proto_item_append_text(ti_soa, " (%s)", time_secs_to_ep_str(tvb_get_ntohl(tvb, cur_offset)));
}
break;
rr_len -= 1;
ti = proto_tree_add_item(rr_tree, hf_dns_rrsig_original_ttl, tvb, cur_offset, 4, ENC_BIG_ENDIAN);
- proto_item_append_text(ti, " (%s)", time_secs_to_str(tvb_get_ntohl(tvb, cur_offset)));
+ proto_item_append_text(ti, " (%s)", time_secs_to_ep_str(tvb_get_ntohl(tvb, cur_offset)));
cur_offset += 4;
rr_len -= 4;
guid_name = guids_get_guid_name(&guid);
if (guid_name != NULL)
proto_item_set_text(dtpt_guid_item, "%s: %s (%s)",
- proto_registrar_get_name(hfindex), guid_name, guid_to_str(&guid));
+ proto_registrar_get_name(hfindex), guid_name, guid_to_ep_str(&guid));
dtpt_guid_tree = proto_item_add_subtree(dtpt_guid_item, ett_dtpt_guid);
}
if (dtpt_guid_tree) {
if (guid_name != NULL && dtpt_guid_data_item != NULL) {
proto_item_set_text(dtpt_guid_data_item, "%s: %s (%s)",
proto_registrar_get_name(hf_dtpt_guid_data),
- guid_name, guid_to_str(&guid));
+ guid_name, guid_to_ep_str(&guid));
}
}
}
}
else {
col_append_sep_fstr(pinfo->cinfo, COL_INFO, NULL,
- "update every %s", rel_time_to_str(&resp_intv));
+ "update every %s", rel_time_to_ep_str(&resp_intv));
}
}
else if (tag==T_DATE_TIME) {
proto_tree_add_time(tree, hf_dvbci_utc_time,
tvb, offset, time_field_len, &utc_time);
col_append_sep_fstr(pinfo->cinfo, COL_INFO, ": ", "%s UTC",
- abs_time_to_str(&utc_time, ABSOLUTE_TIME_UTC, FALSE));
+ abs_time_to_ep_str(&utc_time, ABSOLUTE_TIME_UTC, FALSE));
offset += time_field_len;
if (len_field==7) {
break;
}
else {
- /* abs_time_to_str() never returns NULL */
+ /* abs_time_to_ep_str() never returns NULL */
proto_tree_add_time(tree, hf_dvbci_pin_chg_time,
tvb, offset, UTC_TIME_LEN, &utc_time);
}
/* Gluster is not very endianness friendly */
tvb_get_letohguid(tvb, offset, &gfid);
- gfid_s = guid_to_str(&gfid);
+ gfid_s = guid_to_ep_str(&gfid);
proto_item_append_text(dict_item, "%s", gfid_s);
/* this is a changelog in binary format */
} else if (value_len == 12 && !strncmp("trusted.afr.", key, 12)) {
ts.secs = seconds;
ts.nsecs = nanoseconds;
- ptime = abs_time_to_str(&ts, ABSOLUTE_TIME_UTC, TRUE);
+ ptime = abs_time_to_ep_str(&ts, ABSOLUTE_TIME_UTC, TRUE);
if(hf_index >= 0)
{
"Address entry size: %u",
addr_entry_size);
proto_tree_add_text(icmp_tree, tvb, 6, 2, "Lifetime: %s",
- time_secs_to_str(tvb_get_ntohs
+ time_secs_to_ep_str(tvb_get_ntohs
(tvb, 6)));
break;
get_best_guess_mstimeofday(tvb, 8, frame_ts);
proto_tree_add_text(icmp_tree, tvb, 8, 4,
"Originate timestamp: %s after midnight UTC",
- time_msecs_to_str(orig_ts));
+ time_msecs_to_ep_str(orig_ts));
proto_tree_add_text(icmp_tree, tvb, 12, 4,
"Receive timestamp: %s after midnight UTC",
- time_msecs_to_str
+ time_msecs_to_ep_str
(get_best_guess_mstimeofday
(tvb, 12, orig_ts)));
proto_tree_add_text(icmp_tree, tvb, 16, 4,
"Transmit timestamp: %s after midnight UTC",
- time_msecs_to_str
+ time_msecs_to_ep_str
(get_best_guess_mstimeofday
(tvb, 16, orig_ts)));
}
if (tree) {
theTime = tvb_get_letohl(tvb, offset + CMD_LOGIN_TIME);
- aTime = abs_time_secs_to_str(theTime, ABSOLUTE_TIME_LOCAL, TRUE);
+ aTime = abs_time_secs_to_ep_str(theTime, ABSOLUTE_TIME_LOCAL, TRUE);
proto_tree_add_text(subtree, tvb, offset + CMD_LOGIN_TIME, 4,
"Time: %ld = %s", (long)theTime, aTime);
port = tvb_get_letohl(tvb, offset + CMD_LOGIN_PORT);
} else if (ts <= 0x20000000) {
proto_tree_add_uint_format_value(tree, hf, tvb, offset, 4,
ts, "%s since SEL device's initialization",
- time_secs_to_str_unsigned(ts));
+ time_secs_to_ep_str_unsigned(ts));
} else {
proto_tree_add_uint_format_value(tree, hf, tvb, offset, 4,
- ts, "%s", abs_time_secs_to_str(ts, ABSOLUTE_TIME_UTC, TRUE));
+ ts, "%s", abs_time_secs_to_ep_str(ts, ABSOLUTE_TIME_UTC, TRUE));
}
}
1 + 2 + name_length + 2 + value_length,
"%s: %s",
format_text(name_val, name_length),
- abs_time_secs_to_str(tvb_get_ntohl(tvb, offset + 1 + 2 + name_length + 2),
+ abs_time_secs_to_ep_str(tvb_get_ntohl(tvb, offset + 1 + 2 + name_length + 2),
ABSOLUTE_TIME_LOCAL,
TRUE));
/*
* Format ascii representaion of time
*/
- ptr = abs_time_secs_to_str(t, ABSOLUTE_TIME_LOCAL, TRUE);
+ ptr = abs_time_secs_to_ep_str(t, ABSOLUTE_TIME_LOCAL, TRUE);
proto_tree_add_text(reqresp_tree, tvb, offset,
tokenlen, "Time: %s", ptr);
}
bits = tvb_get_bits64(sync_system_time_tvb, 0, 39, ENC_BIG_ENDIAN);
ts.secs = (time_t)(bits/100) + 315964800; /* CDMA2000 epoch is 00:00:00 (midnight) UTC on 1980-01-06 */
ts.nsecs = (int)(bits%100)*10000000;
- proto_tree_add_text(subtree, sync_system_time_tvb, 0, -1, "CDMA time: %s", abs_time_to_str(&ts, ABSOLUTE_TIME_UTC, FALSE));
- proto_tree_add_text(subtree, sync_system_time_tvb, 0, -1, "Local time: %s", abs_time_to_str(&ts, ABSOLUTE_TIME_LOCAL, TRUE));
+ proto_tree_add_text(subtree, sync_system_time_tvb, 0, -1, "CDMA time: %s", abs_time_to_ep_str(&ts, ABSOLUTE_TIME_UTC, FALSE));
+ proto_tree_add_text(subtree, sync_system_time_tvb, 0, -1, "Local time: %s", abs_time_to_ep_str(&ts, ABSOLUTE_TIME_LOCAL, TRUE));
}
return offset;
bits = tvb_get_bits64(async_system_time_tvb, 0, 49, ENC_BIG_ENDIAN);
ts.secs = (time_t)((bits*8)/1228800) + 315964800; /* CDMA2000 epoch is 00:00:00 (midnight) UTC on 1980-01-06 */
ts.nsecs = (int)(((bits%153600)*8*1000000000)/1228800);
- proto_tree_add_text(subtree, async_system_time_tvb, 0, -1, "CDMA time: %s", abs_time_to_str(&ts, ABSOLUTE_TIME_UTC, FALSE));
- proto_tree_add_text(subtree, async_system_time_tvb, 0, -1, "Local time: %s", abs_time_to_str(&ts, ABSOLUTE_TIME_LOCAL, TRUE));
+ proto_tree_add_text(subtree, async_system_time_tvb, 0, -1, "CDMA time: %s", abs_time_to_ep_str(&ts, ABSOLUTE_TIME_UTC, FALSE));
+ proto_tree_add_text(subtree, async_system_time_tvb, 0, -1, "Local time: %s", abs_time_to_ep_str(&ts, ABSOLUTE_TIME_LOCAL, TRUE));
}
return offset;
ts.secs = (time_t)(timeInfo/100)-2208988800U; /* epoch is 00:00:00 (midnight) UTC on 1900-01-01 */
ts.nsecs = (int)(timeInfo%100)*10000000;
proto_tree_add_text(subtree, tvb, old_offset>>3, (old_offset&0x07) ? 6 : 5,
- "UTC time: %s", abs_time_to_str(&ts, ABSOLUTE_TIME_UTC, FALSE));
+ "UTC time: %s", abs_time_to_ep_str(&ts, ABSOLUTE_TIME_UTC, FALSE));
proto_tree_add_text(subtree, tvb, old_offset>>3, (old_offset&0x07) ? 6 : 5,
- "Local time: %s", abs_time_to_str(&ts, ABSOLUTE_TIME_LOCAL, TRUE));
+ "Local time: %s", abs_time_to_ep_str(&ts, ABSOLUTE_TIME_LOCAL, TRUE));
return offset;
}
}
}
proto_tree_add_guid_format_value(tree, hf, tvb, *offset, 16, &uuid, "%s (%s)",
- val_to_str_const(i, mbim_service_id_vals, "Unknown"), guid_to_str(&uuid));
+ val_to_str_const(i, mbim_service_id_vals, "Unknown"), guid_to_ep_str(&uuid));
*offset += 16;
return i;
}
}
proto_tree_add_guid_format_value(tree, hf_mbim_context_type, tvb, *offset, 16, &uuid, "%s (%s)",
- val_to_str_const(i, mbim_context_type_vals, "Unknown"), guid_to_str(&uuid));
+ val_to_str_const(i, mbim_context_type_vals, "Unknown"), guid_to_ep_str(&uuid));
*offset += 16;
return i;
if(len == 4)
{
milliseconds = tvb_get_ntohl(tvb, offset);
- ptime = time_msecs_to_str(milliseconds);
+ ptime = time_msecs_to_ep_str(milliseconds);
if(hf_index >= 0)
{
ts.secs = (days + 5113) * 86400 + milliseconds / 1000;
ts.nsecs = (milliseconds % 1000) * 1000000U;
- ptime = abs_time_to_str(&ts, ABSOLUTE_TIME_UTC, TRUE);
+ ptime = abs_time_to_ep_str(&ts, ABSOLUTE_TIME_UTC, TRUE);
if(hf_index >= 0)
{
proto_tree_add_string(tree, hf_index, tvb, offset, len, ptime);
ts.secs = seconds;
ts.nsecs = nanoseconds;
- ptime = abs_time_to_str(&ts, ABSOLUTE_TIME_UTC, TRUE);
+ ptime = abs_time_to_ep_str(&ts, ABSOLUTE_TIME_UTC, TRUE);
if(hf_index >= 0)
{
&count2);
tmptime.secs = tval;
tmptime.nsecs = 0;
- strval = abs_time_to_str(&tmptime, ABSOLUTE_TIME_LOCAL,
+ strval = abs_time_to_ep_str(&tmptime, ABSOLUTE_TIME_LOCAL,
TRUE);
/* Now render the fields */
tvb_ensure_bytes_exist(tvb, offset - 1, length + count + 1);
proto_tree_add_text(rr_tree, tvb, offset, 2, "Class: %s", class_description);
offset += 2;
proto_tree_add_text(rr_tree, tvb, offset, 4, "Time to live: %s",
- time_secs_to_str(ttl));
+ time_secs_to_ep_str(ttl));
offset += 4;
proto_tree_add_text(rr_tree, tvb, offset, 2, "Data length: %u", data_len);
return rr_tree;
voffset = voffset+4;
ns.secs = tvb_get_letohl(tvb, voffset);
ns.nsecs = 0;
- proto_tree_add_time_format(nvtree, hf_nds_ds_time, tvb, voffset, 4, &ns, "Timestamp: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ proto_tree_add_time_format(nvtree, hf_nds_ds_time, tvb, voffset, 4, &ns, "Timestamp: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
voffset = voffset + 4;
rnum = tvb_get_letohs(tvb, voffset); /* replica number */
proto_tree_add_uint_format(nvtree, hf_nds_rnum, tvb, voffset,
voffset += 4; /* This is the length of the time data no need to decode, always 4 bytes */
ns.secs = tvb_get_letohl(tvb, voffset);
ns.nsecs = 0;
- proto_tree_add_time_format(nvtree, hf_nds_ds_time, tvb, voffset, 4, &ns, "Time: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ proto_tree_add_time_format(nvtree, hf_nds_ds_time, tvb, voffset, 4, &ns, "Time: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
voffset = voffset + 4;
break;
case 0x00000019: /* Typed Name */
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(nestree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Timestamp: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Timestamp: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset = ioffset + 4;
replica_num = tvb_get_letohs(tvb, ioffset); /* Replica */
proto_tree_add_item(nestree, hf_nds_replica_num, tvb, ioffset,
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(nestree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Timestamp: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Timestamp: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset = ioffset + 4;
replica_num = tvb_get_letohs(tvb, ioffset); /* Replica */
proto_tree_add_item(nestree, hf_nds_replica_num, tvb, ioffset,
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(nestree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Timestamp: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Timestamp: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset = ioffset + 4;
replica_num = tvb_get_letohs(tvb, ioffset); /* Replica */
proto_tree_add_item(nestree, hf_nds_replica_num, tvb, ioffset,
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(sub2tree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Timestamp: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Timestamp: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset = ioffset + 4;
replica_num = tvb_get_letohs(tvb, ioffset); /* Replica */
proto_tree_add_item(sub2tree, hf_nds_replica_num, tvb, ioffset,
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(it_tree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Modification Time: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Modification Time: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset = ioffset + 4;
}
if (iter_flags & DSI_MODIFICATION_TIMESTAMP) { /* Modification Timestamp */
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(it_tree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Modification Timestamp: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Modification Timestamp: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset = ioffset + 4;
replica_num = tvb_get_letohs(tvb, ioffset); /* Replica */
proto_tree_add_item(it_tree, hf_nds_replica_num, tvb, ioffset,
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(it_tree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Creation Timestamp: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Creation Timestamp: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset = ioffset + 4;
replica_num = tvb_get_letohs(tvb, ioffset); /* Replica */
proto_tree_add_item(it_tree, hf_nds_replica_num, tvb, ioffset,
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(atree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Timestamp: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Timestamp: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset = ioffset + 4;
replica_num = tvb_get_letohs(tvb, ioffset); /* Replica */
proto_tree_add_item(atree, hf_nds_replica_num, tvb, ioffset,
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(ntree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Creation Time: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Creation Time: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset = ioffset + 4;
replica_num = tvb_get_letohs(tvb, ioffset); /* Replica */
proto_tree_add_item(ntree, hf_nds_replica_num, tvb, ioffset,
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(ntree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Modification Timestamp: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Modification Timestamp: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset = ioffset + 4;
replica_num = tvb_get_letohs(tvb, ioffset); /* Replica */
proto_tree_add_item(ntree, hf_nds_replica_num, tvb, ioffset,
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(ntree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Modification Time: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Modification Time: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset = ioffset + 4;
break;
case 0x0000020: /* Modification Timestamp */
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(ntree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Modification Timestamp: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Modification Timestamp: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset = ioffset + 4;
replica_num = tvb_get_letohs(tvb, ioffset); /* Replica */
proto_tree_add_item(ntree, hf_nds_replica_num, tvb, ioffset,
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(ntree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Creation Timestamp: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Creation Timestamp: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset = ioffset + 4;
replica_num = tvb_get_letohs(tvb, ioffset); /* Replica */
proto_tree_add_item(ntree, hf_nds_replica_num, tvb, ioffset,
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(ntree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Purge Time: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Purge Time: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset = ioffset + 4;
break;
case 0x00020000: /* Dereference Base Class */
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(sub1tree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Creation Timestamp: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Creation Timestamp: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset = ioffset + 4;
replica_num = tvb_get_letohs(tvb, ioffset); /* Replica */
proto_tree_add_item(sub1tree, hf_nds_replica_num, tvb, ioffset,
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(sub1tree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Modification Timestamp: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Modification Timestamp: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset = ioffset + 4;
replica_num = tvb_get_letohs(tvb, ioffset); /* Replica */
proto_tree_add_item(sub1tree, hf_nds_replica_num, tvb, ioffset,
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(ntree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Creation Timestamp: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Creation Timestamp: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset += 4;
replica_num = tvb_get_letohs(tvb, ioffset); /* Replica */
proto_tree_add_item(ntree, hf_nds_replica_num, tvb, ioffset,
ns.secs = tvb_get_letohl(tvb, ioffset); /* Seconds */
ns.nsecs = 0;
proto_tree_add_time_format(sub2tree, hf_es_seconds, tvb, ioffset,
- 4, &ns, "Timestamp: %s", abs_time_secs_to_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
+ 4, &ns, "Timestamp: %s", abs_time_secs_to_ep_str(ns.secs, ABSOLUTE_TIME_LOCAL, TRUE));
ioffset += 4;
replica_num = tvb_get_letohs(tvb, ioffset); /* Replica */
proto_tree_add_item(sub2tree, hf_nds_replica_num, tvb, ioffset,
proto_tree_add_uint_format(tree, hf_pktc_sec_param_lifetime, tvb, offset, 4,
tvb_get_ntohl(tvb, offset), "%s: %s",
proto_registrar_get_name(hf_pktc_sec_param_lifetime),
- time_secs_to_str(tvb_get_ntohl(tvb, offset)));
+ time_secs_to_ep_str(tvb_get_ntohl(tvb, offset)));
offset+=4;
/* grace period */
time_ptr.nsecs = 0;
proto_tree_add_time(tree, a->hf, tvb, offset, len, &time_ptr);
- proto_item_append_text(avp_item, "%s", abs_time_to_str(&time_ptr, ABSOLUTE_TIME_LOCAL, TRUE));
+ proto_item_append_text(avp_item, "%s", abs_time_to_ep_str(&time_ptr, ABSOLUTE_TIME_LOCAL, TRUE));
}
/*
t.nsecs = (int)((iDoubleValue - 1000*(double)t.secs) * 1000000);
proto_tree_add_time(val_tree, hf_amf_date, tvb, iValueOffset, 8, &t);
iValueOffset += 8;
- proto_item_append_text(ti, " %s", abs_time_to_str(&t, ABSOLUTE_TIME_LOCAL, TRUE));
+ proto_item_append_text(ti, " %s", abs_time_to_ep_str(&t, ABSOLUTE_TIME_LOCAL, TRUE));
if (parent_ti != NULL)
- proto_item_append_text(parent_ti, " %s", abs_time_to_str(&t, ABSOLUTE_TIME_LOCAL, TRUE));
+ proto_item_append_text(parent_ti, " %s", abs_time_to_ep_str(&t, ABSOLUTE_TIME_LOCAL, TRUE));
/* time-zone */
iValueOffset += 2;
break;
t.nsecs = (int)((iDoubleValue - 1000*(double)t.secs) * 1000000);
proto_tree_add_time(val_tree, hf_amf_date, tvb, iValueOffset, 8, &t);
iValueOffset += 8;
- proto_item_append_text(ti, "%s", abs_time_to_str(&t, ABSOLUTE_TIME_LOCAL, TRUE));
+ proto_item_append_text(ti, "%s", abs_time_to_ep_str(&t, ABSOLUTE_TIME_LOCAL, TRUE));
if (parent_ti != NULL)
- proto_item_append_text(parent_ti, "%s", abs_time_to_str(&t, ABSOLUTE_TIME_LOCAL, TRUE));
+ proto_item_append_text(parent_ti, "%s", abs_time_to_ep_str(&t, ABSOLUTE_TIME_LOCAL, TRUE));
} else {
/* the upper 28 bits of the integer value are an object reference index */
proto_tree_add_uint(val_tree, hf_amf_object_reference, tvb, iValueOffset, iValueLength, iIntegerValue >> 1);
(*r)->framenum,
"This TSN was retransmitted in frame %u (%s seconds after this frame)",
(*r)->framenum,
- rel_time_to_secs_str(&rto));
+ rel_time_to_secs_ep_str(&rto));
PROTO_ITEM_SET_GENERATED(pi);
r = &(*r)->next;
}
proto_tree_add_item(fastser_tree, hf_selfm_fastser_unsresp_doy, tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(fastser_tree, hf_selfm_fastser_unsresp_year, tvb, offset+2, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(fastser_tree, hf_selfm_fastser_unsresp_todms, tvb, offset+4, 4, ENC_BIG_ENDIAN);
- proto_tree_add_text(fastser_tree, tvb, offset+4, 4, "Time of Day (decoded): %s", time_msecs_to_str(tod_ms));
+ proto_tree_add_text(fastser_tree, tvb, offset+4, 4, "Time of Day (decoded): %s", time_msecs_to_ep_str(tod_ms));
offset += 8;
/* Build element tree */
proto_tree_add_item(fastser_element_tree, hf_selfm_fastser_unsresp_elmt_idx, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(fastser_element_tree, hf_selfm_fastser_unsresp_elmt_ts_ofs, tvb, offset+1, 3, ENC_NA);
proto_tree_add_text(fastser_element_tree, tvb, offset+1, 3,
- "SER Element Timestamp Offset (decoded): %s", time_msecs_to_str(tod_ms + (elmt_ts_offset/1000)));
+ "SER Element Timestamp Offset (decoded): %s", time_msecs_to_ep_str(tod_ms + (elmt_ts_offset/1000)));
proto_tree_add_uint(fastser_element_tree, hf_selfm_fastser_unsresp_elmt_status, tvb, elmt_status32_ofs, 4, elmt_status);
offset += 4;
proto_tree_add_uint_format_value(tree, hf_periodicity, tvb, offset, 4,
periodicity,
"%s",
- time_msecs_to_str(periodicity));
+ time_msecs_to_ep_str(periodicity));
offset += 4;
/* server name */
proto_tree_add_uint_format_value(tree, hf_server_uptime,
tvb, offset, 4, uptime,
"%s",
- time_msecs_to_str(uptime));
+ time_msecs_to_ep_str(uptime));
offset += 4;
/* next 4 bytes must be zero */
proto_tree_add_uint_format_value(tree, hf_periodicity, tvb, offset, 2,
periodicity,
"%s",
- time_msecs_to_str(periodicity));
+ time_msecs_to_ep_str(periodicity));
offset += 2;
/* server name */
nstime.nsecs = 0;
proto_tree_add_time_format_value(tree, hf_index, tvb, offset, 4,
&nstime, "%s",
- time_secs_to_str( (gint32) nstime.secs));
+ time_secs_to_ep_str( (gint32) nstime.secs));
offset += 4;
return offset;
}
if (tzoffset < 0) {
proto_tree_add_int_format_value(tree, hf_tzoffset, tvb, offset, 2,
tzoffset, "%s east of UTC",
- time_secs_to_str(-tzoffset*60));
+ time_secs_to_ep_str(-tzoffset*60));
} else if (tzoffset > 0) {
proto_tree_add_int_format_value(tree, hf_tzoffset, tvb, offset, 2,
tzoffset, "%s west of UTC",
- time_secs_to_str(tzoffset*60));
+ time_secs_to_ep_str(tzoffset*60));
} else {
proto_tree_add_int_format_value(tree, hf_tzoffset, tvb, offset, 2,
tzoffset, "at UTC");
return buf;
}
- return time_msecs_to_str(timeout);
+ return time_msecs_to_ep_str(timeout);
}
static int
ts.nsecs = 0;
proto_tree_add_time_format_value(tree, hf_snmp_engineid_time, tvb, offset+4, 4,
&ts, "%s",
- abs_time_secs_to_str(seconds, ABSOLUTE_TIME_LOCAL, TRUE));
+ abs_time_secs_to_ep_str(seconds, ABSOLUTE_TIME_LOCAL, TRUE));
offset+=8;
len_remain=0;
}
ts.secs = seconds;
ts.nsecs = nanoseconds;
- ptime = abs_time_to_str(&ts, ABSOLUTE_TIME_UTC, TRUE);
+ ptime = abs_time_to_ep_str(&ts, ABSOLUTE_TIME_UTC, TRUE);
if(hf_index >= 0)
{
guint32 delta_seconds = tvb_get_ntohl(tvb, 0);
proto_tree_add_uint_format(time_tree, hf_time_time, tvb, 0, 4,
delta_seconds, "%s",
- abs_time_secs_to_str(delta_seconds-2208988800U, time_display_type, TRUE));
+ abs_time_secs_to_ep_str(delta_seconds-2208988800U, time_display_type, TRUE));
}
}
t.secs = (pb5_days_since_midnight_9_10_oct_1995 * 86400) + pb5_seconds + utcdiff;
t.nsecs = pb5_milliseconds*1000000; /* msecs to nsecs */
- return abs_time_to_str(&t, ABSOLUTE_TIME_DOY_UTC, TRUE);
+ return abs_time_to_ep_str(&t, ABSOLUTE_TIME_DOY_UTC, TRUE);
}
idle_secs = tvb_get_ntohl(tvb, line_offset);
proto_tree_add_uint_format(whoent_tree, hf_who_idle, tvb,
line_offset, 4, idle_secs, "Idle: %s",
- time_secs_to_str(idle_secs));
+ time_secs_to_ep_str(idle_secs));
line_offset += 4;
whoent_num++;
tvb, hdr_start, hdr_len + val_len,
"Requesting Time Of Day");
} else {
- val_str = abs_time_secs_to_str(val, ABSOLUTE_TIME_LOCAL, TRUE);
+ val_str = abs_time_secs_to_ep_str(val, ABSOLUTE_TIME_LOCAL, TRUE);
ti = proto_tree_add_string (wsp_headers,
hf_hdr_x_wap_tod,
tvb, hdr_start, hdr_len + val_len, val_str);
if (val_id <= 4) { /* Length field already parsed by macro! */ \
get_date_value(val, tvb, off, len, ok); \
if (ok) { \
- str = abs_time_secs_to_str(val, ABSOLUTE_TIME_LOCAL, TRUE); \
+ str = abs_time_secs_to_ep_str(val, ABSOLUTE_TIME_LOCAL, TRUE); \
tvb_ensure_bytes_exist(tvb, hdr_start, offset - hdr_start); \
ti = proto_tree_add_string(tree, hf_hdr_ ## underscored, \
tvb, hdr_start, offset - hdr_start, str); \
/* BEHOLD: do NOT try to free str, as \
- * abs_time_secs_to_str() returns wmem_allocated data */ \
+ * abs_time_secs_to_ep_str() returns wmem_allocated data */ \
} \
} \
wkh_4_End(hf_hdr_ ## underscored); \
if (val_id <= 4) { /* Length field already parsed by macro! */ \
get_date_value(val, tvb, off, len, ok); \
if (ok) { \
- str = abs_time_secs_to_str(val, ABSOLUTE_TIME_LOCAL, TRUE); \
+ str = abs_time_secs_to_ep_str(val, ABSOLUTE_TIME_LOCAL, TRUE); \
tvb_ensure_bytes_exist(tvb, hdr_start, offset - hdr_start); \
ti = proto_tree_add_string(tree, hf_hdr_ ## underscored, \
tvb, hdr_start, offset - hdr_start, str); \
/* BEHOLD: do NOT try to free str, as \
- * abs_time_secs_to_str() returns wmem_allocated data */ \
+ * abs_time_secs_to_ep_str() returns wmem_allocated data */ \
} \
} \
wkh_4_End(hf_hdr_ ## underscored); \
tvb, hdr_start, offset - hdr_start, \
"Requesting Time Of Day"); \
} else { \
- str = abs_time_secs_to_str(val, ABSOLUTE_TIME_LOCAL, TRUE); \
+ str = abs_time_secs_to_ep_str(val, ABSOLUTE_TIME_LOCAL, TRUE); \
tvb_ensure_bytes_exist(tvb, hdr_start, offset - hdr_start); \
ti = proto_tree_add_string(tree, hf_hdr_ ## underscored, \
tvb, hdr_start, offset - hdr_start, str); \
get_date_value(val, tvb, off, len, ok);
if (ok) { /* Valid warn-text string */
off += len;
- val_str = abs_time_secs_to_str(val, ABSOLUTE_TIME_LOCAL, TRUE);
+ val_str = abs_time_secs_to_ep_str(val, ABSOLUTE_TIME_LOCAL, TRUE);
str = wmem_strdup_printf(wmem_packet_scope(), "; date=%s", val_str);
proto_item_append_string(ti, str);
/* BEHOLD: do NOT try to free str, as \
- * abs_time_secs_to_str() returns wmem_allocated data */ \
+ * abs_time_secs_to_ep_str() returns wmem_allocated data */ \
}
}
}
g_snprintf(s, ITEM_LABEL_LENGTH, "Invalid UTC Time");
else {
value += ZBEE_ZCL_NSTIME_UTC_OFFSET;
- g_snprintf(s, ITEM_LABEL_LENGTH, "%s", abs_time_secs_to_str (value, ABSOLUTE_TIME_LOCAL, TRUE));
+ g_snprintf(s, ITEM_LABEL_LENGTH, "%s", abs_time_secs_to_ep_str (value, ABSOLUTE_TIME_LOCAL, TRUE));
}
} /* decode_zcl_appl_stats_utc_time */
g_snprintf(s, ITEM_LABEL_LENGTH, "Now");
else {
value += ZBEE_ZCL_NSTIME_UTC_OFFSET;
- g_snprintf(s, ITEM_LABEL_LENGTH, "%s", abs_time_secs_to_str (value, ABSOLUTE_TIME_LOCAL, TRUE));
+ g_snprintf(s, ITEM_LABEL_LENGTH, "%s", abs_time_secs_to_ep_str (value, ABSOLUTE_TIME_LOCAL, TRUE));
}
} /* decode_zcl_msg_start_time */
{
gchar *rep;
- rep = abs_time_to_str(&fv->value.time, ABSOLUTE_TIME_LOCAL,
+ rep = abs_time_to_ep_str(&fv->value.time, ABSOLUTE_TIME_LOCAL,
rtype == FTREPR_DISPLAY);
return (int)strlen(rep) + 2; /* 2 for opening and closing quotes */
}
absolute_val_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
{
sprintf(buf, "\"%s\"",
- abs_time_to_str(&fv->value.time, ABSOLUTE_TIME_LOCAL,
+ abs_time_to_ep_str(&fv->value.time, ABSOLUTE_TIME_LOCAL,
rtype == FTREPR_DISPLAY));
}
{
gchar *rep;
- rep = rel_time_to_secs_str(&fv->value.time);
+ rep = rel_time_to_secs_ep_str(&fv->value.time);
return (int)strlen(rep);
}
static void
relative_val_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
{
- strcpy(buf, rel_time_to_secs_str(&fv->value.time));
+ strcpy(buf, rel_time_to_secs_ep_str(&fv->value.time));
}
void
WS_DLL_PUBLIC const gchar *guids_get_guid_name(const e_guid_t *guid);
/* resolve GUID to name (or if unknown to hex string) */
-/* (if you need hex string only, use guid_to_str instead) */
+/* (if you need hex string only, use guid_to_ep_str instead) */
WS_DLL_PUBLIC const gchar* guids_resolve_guid_to_str(const e_guid_t *guid);
/* add a UUID (dcerpc_init_uuid() will call this too) */
#define guids_get_uuid_name(uuid) guids_get_guid_name((e_guid_t *) (uuid))
/* resolve UUID to name (or if unknown to hex string) */
-/* (if you need hex string only, use guid_to_str instead) */
+/* (if you need hex string only, use guid_to_ep_str instead) */
#define guids_resolve_uuid_to_str(uuid) guids_resolve_guid_to_str((e_guid_t *) (uuid))
#endif /* __GUID_UTILS_H__ */
/* Print geninfo.timestamp */
fprintf(fh,
" <field name=\"timestamp\" pos=\"0\" show=\"%s\" showname=\"Captured Time\" value=\"%d.%09d\" size=\"%u\"/>\n",
- abs_time_to_str(timestamp, ABSOLUTE_TIME_LOCAL, TRUE), (int) timestamp->secs, timestamp->nsecs, frame_finfo->length);
+ abs_time_to_ep_str(timestamp, ABSOLUTE_TIME_LOCAL, TRUE), (int) timestamp->secs, timestamp->nsecs, frame_finfo->length);
/* Print geninfo end */
fprintf(fh,
case FT_ABSOLUTE_TIME:
offset_r += protoo_strlcpy(result+offset_r,
- abs_time_to_str((const nstime_t *)fvalue_get(&finfo->value),
+ abs_time_to_ep_str((const nstime_t *)fvalue_get(&finfo->value),
(absolute_time_display_e)hfinfo->display, TRUE),
size-offset_r);
break;
case FT_RELATIVE_TIME:
offset_r += protoo_strlcpy(result+offset_r,
- rel_time_to_secs_str((const nstime_t *)fvalue_get(&finfo->value)),
+ rel_time_to_secs_ep_str((const nstime_t *)fvalue_get(&finfo->value)),
size-offset_r);
break;
case FT_GUID:
offset_r += protoo_strlcpy(result+offset_r,
- guid_to_str((e_guid_t *)fvalue_get(&finfo->value)),
+ guid_to_ep_str((e_guid_t *)fvalue_get(&finfo->value)),
size-offset_r);
break;
case FT_ABSOLUTE_TIME:
label_fill(label_str, 0, hfinfo,
- abs_time_to_str((const nstime_t *)fvalue_get(&fi->value),
+ abs_time_to_ep_str((const nstime_t *)fvalue_get(&fi->value),
(absolute_time_display_e)hfinfo->display, TRUE));
break;
case FT_RELATIVE_TIME:
g_snprintf(label_str, ITEM_LABEL_LENGTH,
"%s: %s seconds", hfinfo->name,
- rel_time_to_secs_str((const nstime_t *)fvalue_get(&fi->value)));
+ rel_time_to_secs_ep_str((const nstime_t *)fvalue_get(&fi->value)));
break;
case FT_IPXNET:
case FT_GUID:
guid = (e_guid_t *)fvalue_get(&fi->value);
- label_fill(label_str, 0, hfinfo, guid_to_str(guid));
+ label_fill(label_str, 0, hfinfo, guid_to_ep_str(guid));
break;
case FT_OID:
uint_to_str_back(bp, u);
}
-gchar *
-guint32_to_str(const guint32 u) {
- int str_len = 16; /* guint32_to_str_buf_len(u)+1; */
-
- gchar *bp = (gchar *)ep_alloc(str_len);
- guint32_to_str_buf(u, bp, str_len);
-
- return bp;
-}
-
#define PLURALIZE(n) (((n) > 1) ? "s" : "")
#define COMMA(do_it) ((do_it) ? ", " : "")
* If time is negative, add a '-' to all non-null components.
*/
static void
-time_secs_to_str_buf(gint32 time_val, const guint32 frac, const gboolean is_nsecs,
+time_secs_to_ep_str_buf(gint32 time_val, const guint32 frac, const gboolean is_nsecs,
emem_strbuf_t *buf)
{
int hours, mins, secs;
}
gchar *
-time_secs_to_str(const gint32 time_val)
+time_secs_to_ep_str(const gint32 time_val)
{
emem_strbuf_t *buf;
return buf->str;
}
- time_secs_to_str_buf(time_val, 0, FALSE, buf);
+ time_secs_to_ep_str_buf(time_val, 0, FALSE, buf);
return buf->str;
}
static void
-time_secs_to_str_buf_unsigned(guint32 time_val, const guint32 frac, const gboolean is_nsecs,
+time_secs_to_ep_str_buf_unsigned(guint32 time_val, const guint32 frac, const gboolean is_nsecs,
emem_strbuf_t *buf)
{
int hours, mins, secs;
}
gchar *
-time_secs_to_str_unsigned(const guint32 time_val)
+time_secs_to_ep_str_unsigned(const guint32 time_val)
{
emem_strbuf_t *buf;
return buf->str;
}
- time_secs_to_str_buf_unsigned(time_val, 0, FALSE, buf);
+ time_secs_to_ep_str_buf_unsigned(time_val, 0, FALSE, buf);
return buf->str;
}
gchar *
-time_msecs_to_str(gint32 time_val)
+time_msecs_to_ep_str(gint32 time_val)
{
emem_strbuf_t *buf;
int msecs;
time_val /= 1000;
}
- time_secs_to_str_buf(time_val, msecs, FALSE, buf);
+ time_secs_to_ep_str_buf(time_val, msecs, FALSE, buf);
return buf->str;
}
}
gchar *
-abs_time_to_str(const nstime_t *abs_time, const absolute_time_display_e fmt,
+abs_time_to_ep_str(const nstime_t *abs_time, const absolute_time_display_e fmt,
gboolean show_zone)
{
struct tm *tmp = NULL;
}
gchar *
-abs_time_secs_to_str(const time_t abs_time, const absolute_time_display_e fmt,
+abs_time_secs_to_ep_str(const time_t abs_time, const absolute_time_display_e fmt,
gboolean show_zone)
{
struct tm *tmp = NULL;
* Display a relative time as days/hours/minutes/seconds.
*/
gchar *
-rel_time_to_str(const nstime_t *rel_time)
+rel_time_to_ep_str(const nstime_t *rel_time)
{
emem_strbuf_t *buf;
gint32 time_val;
time_val = (gint) -rel_time->secs;
}
- time_secs_to_str_buf(time_val, nsec, TRUE, buf);
+ time_secs_to_ep_str_buf(time_val, nsec, TRUE, buf);
return buf->str;
}
* Display a relative time as seconds.
*/
gchar *
-rel_time_to_secs_str(const nstime_t *rel_time)
+rel_time_to_secs_ep_str(const nstime_t *rel_time)
{
gchar *buf;
return p;
}
-/* Generate a string describing a Boolean bitfield (a one-bit field that
- says something is either true or false). */
-const char *
-decode_boolean_bitfield(const guint32 val, const guint32 mask, const int width,
- const char *truedesc, const char *falsedesc)
-{
- char *buf;
- char *p;
-
- buf=(char *)ep_alloc(1025); /* is this a bit overkill? */
- p = decode_bitfield_value(buf, val, mask, width);
- if (val & mask)
- strcpy(p, truedesc);
- else
- strcpy(p, falsedesc);
- return buf;
-}
-
/* Generate a string describing a numeric bitfield (an N-bit field whose
value is just a number). */
const char *
*b=0;
}
-gchar* guid_to_str(const e_guid_t *guid) {
+gchar* guid_to_ep_str(const e_guid_t *guid) {
gchar *buf;
buf=(gchar *)ep_alloc(GUID_STR_LEN);
extern gchar* tvb_vines_addr_to_str(tvbuff_t *tvb, const gint offset);
WS_DLL_PUBLIC gchar* eui64_to_str(const guint64 ad);
WS_DLL_PUBLIC gchar* tvb_eui64_to_str(tvbuff_t *tvb, const gint offset, const guint encoding);
-WS_DLL_PUBLIC gchar* time_secs_to_str(const gint32 time_val);
-gchar* time_secs_to_str_unsigned(const guint32);
-WS_DLL_PUBLIC gchar* time_msecs_to_str(gint32 time_val);
-WS_DLL_PUBLIC gchar* abs_time_to_str(const nstime_t*, const absolute_time_display_e fmt,
+WS_DLL_PUBLIC gchar* time_secs_to_ep_str(const gint32 time_val);
+gchar* time_secs_to_ep_str_unsigned(const guint32);
+WS_DLL_PUBLIC gchar* time_msecs_to_ep_str(gint32 time_val);
+WS_DLL_PUBLIC gchar* abs_time_to_ep_str(const nstime_t*, const absolute_time_display_e fmt,
gboolean show_zone);
-WS_DLL_PUBLIC gchar* abs_time_secs_to_str(const time_t, const absolute_time_display_e fmt,
+WS_DLL_PUBLIC gchar* abs_time_secs_to_ep_str(const time_t, const absolute_time_display_e fmt,
gboolean show_zone);
WS_DLL_PUBLIC void display_signed_time(gchar *, int, const gint32, gint32, const to_str_time_res_t);
WS_DLL_PUBLIC void display_epoch_time(gchar *, int, const time_t, gint32, const to_str_time_res_t);
-extern gchar* guint32_to_str(const guint32 u);
extern void guint32_to_str_buf(guint32 u, gchar *buf, int buf_len);
-WS_DLL_PUBLIC gchar* rel_time_to_str(const nstime_t*);
-WS_DLL_PUBLIC gchar* rel_time_to_secs_str(const nstime_t*);
-WS_DLL_PUBLIC gchar* guid_to_str(const e_guid_t*);
+WS_DLL_PUBLIC gchar* rel_time_to_ep_str(const nstime_t*);
+WS_DLL_PUBLIC gchar* rel_time_to_secs_ep_str(const nstime_t*);
+WS_DLL_PUBLIC gchar* guid_to_ep_str(const e_guid_t*);
gchar* guid_to_str_buf(const e_guid_t*, gchar*, int);
WS_DLL_PUBLIC char *decode_bits_in_field(const guint bit_offset, const gint no_of_bits, const guint64 value);
const int width);
WS_DLL_PUBLIC char *decode_bitfield_value(char *buf, const guint32 val, const guint32 mask,
const int width);
-WS_DLL_PUBLIC const char *decode_boolean_bitfield(const guint32 val, const guint32 mask, const int width,
- const char *truedesc, const char *falsedesc);
WS_DLL_PUBLIC const char *decode_numeric_bitfield(const guint32 val, const guint32 mask, const int width,
const char *fmt);
then.secs = (guint32)floor(timestamp);
then.nsecs = (guint32) ( (timestamp-(double)(then.secs))*1000000000);
- str = abs_time_to_str(&then, ABSOLUTE_TIME_LOCAL, TRUE);
+ str = abs_time_to_ep_str(&then, ABSOLUTE_TIME_LOCAL, TRUE);
lua_pushstring(LS,str);
WSLUA_RETURN(1); /* A string with the formated date */
then.secs = (guint32)floor(timestamp);
then.nsecs = (guint32) ( (timestamp-(double)(then.secs))*1000000000);
- str = rel_time_to_str(&then);
+ str = rel_time_to_ep_str(&then);
lua_pushstring(LS,str);
WSLUA_RETURN(1); /* A string with the formated time */
sub_item = proto_tree_add_text(tree, tvb, 0, 0,
"ARUUID:%s ContrMAC:%s ContrAlRef:0x%x DevMAC:%s DevAlRef:0x%x InCR:0x%x OutCR=0x%x",
- guid_to_str((const e_guid_t*) &ar->aruuid),
+ guid_to_ep_str((const e_guid_t*) &ar->aruuid),
ether_to_str((const guint8 *)ar->controllermac), ar->controlleralarmref,
ether_to_str((const guint8 *)ar->devicemac), ar->devicealarmref,
ar->inputframeid, ar->outputframeid);
u32ARDataStart = offset;
offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, ar_tree, drep,
hf_pn_io_ar_uuid, &aruuid);
- proto_item_append_text(ar_item, "ARUUID:%s", guid_to_str((const e_guid_t*) &aruuid));
+ proto_item_append_text(ar_item, "ARUUID:%s", guid_to_ep_str((const e_guid_t*) &aruuid));
offset = dissect_dcerpc_uint16(tvb, offset, pinfo, ar_tree, drep,
hf_pn_io_ar_type, &u16ARType);
offset = dissect_ARProperties(tvb, offset, pinfo, ar_tree, item, drep);
u32ARDataStart = offset;
/*ARUUID */
offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, ar_tree, drep, hf_pn_io_ar_uuid, &aruuid);
- proto_item_append_text(ar_item, "ARUUID:%s", guid_to_str((const e_guid_t*) &aruuid));
+ proto_item_append_text(ar_item, "ARUUID:%s", guid_to_ep_str((const e_guid_t*) &aruuid));
/* CMInitiatorObjectUUID */
offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, ar_tree, drep, hf_pn_io_cminitiator_objectuuid, &uuid);
/* ParameterServerObjectUUID */
"pn_io.ar_uuid == %s || " /* ARUUID */
"(pn_io.alarm_src_endpoint == 0x%x && eth.src == %s) || " /* Alarm CR (contr -> dev) */
"(pn_io.alarm_src_endpoint == 0x%x && eth.src == %s)", /* Alarm CR (dev -> contr) */
- guid_to_str((const e_guid_t*) &ar->aruuid),
+ guid_to_ep_str((const e_guid_t*) &ar->aruuid),
ar->controlleralarmref, ether_to_str((const guint8 *)ar->controllermac),
ar->devicealarmref, ether_to_str((const guint8 *)ar->devicemac));
return buf;
"(pn_rt.frame_id == 0x%x) || (pn_rt.frame_id == 0x%x) || "
"(pn_io.alarm_src_endpoint == 0x%x && eth.src == %s) || " /* Alarm CR (contr -> dev) */
"(pn_io.alarm_src_endpoint == 0x%x && eth.src == %s)", /* Alarm CR (dev -> contr) */
- guid_to_str((const e_guid_t*) &ar->aruuid),
+ guid_to_ep_str((const e_guid_t*) &ar->aruuid),
ar->inputframeid, ar->outputframeid,
ar->controlleralarmref, ether_to_str((const guint8 *)ar->controllermac),
ar->devicealarmref, ether_to_str((const guint8 *)ar->devicemac));
"(pn_rt.frame_id == 0x%x && eth.src == %s && eth.dst == %s) || " /* Output CR && contr MAC -> dev MAC */
"(pn_io.alarm_src_endpoint == 0x%x && eth.src == %s) || " /* Alarm CR (contr -> dev) */
"(pn_io.alarm_src_endpoint == 0x%x && eth.src == %s)", /* Alarm CR (dev -> contr) */
- guid_to_str((const e_guid_t*) &ar->aruuid),
+ guid_to_ep_str((const e_guid_t*) &ar->aruuid),
ar->inputframeid, ether_to_str((const guint8 *)ar->devicemac), ether_to_str((const guint8 *)ar->controllermac),
ar->outputframeid, ether_to_str((const guint8 *)ar->controllermac), ether_to_str((const guint8 *)ar->devicemac),
ar->controlleralarmref, ether_to_str((const guint8 *)ar->controllermac),
h323info = (h323_calls_info_t *)listinfo->prot_info;
g_string_append_printf(filter_string_fwd,
"((h225.guid == %s || q931.call_ref == %x:%x || q931.call_ref == %x:%x)",
- guid_to_str(&h323info->guid[0]),
+ guid_to_ep_str(&h323info->guid[0]),
(guint8) (h323info->q931_crv & 0x00ff),
(guint8)((h323info->q931_crv & 0xff00)>>8),
(guint8) (h323info->q931_crv2 & 0x00ff),
git.samba.org / metze / wireshark / wip.git / commitdiff