osmith
/
wireshark
forked from osmocom/wireshark
1
0
Fork 0
Code Pull Requests Releases Wiki Activity

EVERYTHING IN THE BUILDBOT IS GOING TO BE RED!!! Sorry! 

I've done more than a day to change the timestamp resolution from microseconds to nanoseconds. As I really don't want to loose those changes, I'm going to check in the changes I've done so far. Hopefully someone else will give me a helping hand with the things left ...

What's done: I've changed the timestamp resolution from usec to nsec in almost any place in the sources. I've changed parts of the implementation in nstime.s/.h and a lot of places elsewhere.

As I don't understand the editcap source (well, I'm maybe just too tired right now), hopefully someone else might be able to fix this soon.

Doing all those changes, we get native nanosecond timestamp resolution in Ethereal. After fixing all the remaining issues, I'll take a look how to display this in a convenient way...

As I've also changed the wiretap timestamp resolution from usec to nsec we might want to change the wiretap version number...

svn path=/trunk/; revision=15520
daniel/osmux
Ulf Lamping 2005-08-24 21:31:56 +00:00
parent ef81f7d060
commit 6f43fbb2f0
88 changed files with 462 additions and 610 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
capinfos.c
View File

@ -83,9 +83,9 @@ typedef struct _capture_info {
} capture_info;
static double
secs_usecs(guint32 s, guint32 us)
secs_nsecs(const struct wtap_nstime * nstime)
{
return (us / 1000000.0) + (double)s;
return (nstime->nsecs / 1000000000.0) + (double)nstime->secs;
}
static void
@ -131,7 +131,7 @@ process_cap_file(wtap *wth, const char *filename)
/* Tally up data that we need to parse through the file to find */
while (wtap_read(wth, &err, &err_info, &data_offset)) {
phdr = wtap_phdr(wth);
cur_time = secs_usecs(phdr->ts.tv_sec, phdr->ts.tv_usec);
cur_time = secs_nsecs(&phdr->ts);
if(packet==0) {
start_time = cur_time;
stop_time = cur_time;

5
cfile.h
View File

@ -55,8 +55,7 @@ typedef struct _capture_file {
int marked_count; /* Number of marked frames */
gboolean drops_known; /* TRUE if we know how many packets were dropped */
guint32 drops; /* Dropped packets */
guint32 esec; /* Elapsed seconds */
guint32 eusec; /* Elapsed microseconds */
nstime_t elapsed_time;/* Elapsed time (see: tsaccur below!) */
gboolean has_snap; /* TRUE if maximum capture packet length is known */
int snap; /* Maximum captured packet length */
wtap *wth; /* Wiretap session */
@ -83,6 +82,8 @@ typedef struct _capture_file {
epan_dissect_t *edt; /* Protocol dissection for currently selected packet */
field_info *finfo_selected; /* Field info for currently selected field */
struct ph_stats_s* pstats; /* accumulated stats (reset on redisplay in GUI)*/
int tsprecision; /* timestamp precision
(WTAP_FILE_TSPREC_USEC or WTAP_FILE_TSPREC_NSEC) */
} capture_file;
void init_cap_file(capture_file *);

12
epan/column-utils.c
View File

@ -473,7 +473,7 @@ col_set_abs_date_time(frame_data *fd, column_info *cinfo, int col)
struct tm *tmp;
time_t then;
then = fd->abs_secs;
then = fd->abs_ts.secs;
tmp = localtime(&then);
if (tmp != NULL) {
g_snprintf(cinfo->col_buf[col], COL_MAX_LEN,
@ -484,7 +484,7 @@ col_set_abs_date_time(frame_data *fd, column_info *cinfo, int col)
tmp->tm_hour,
tmp->tm_min,
tmp->tm_sec,
(long)fd->abs_usecs);
(long)fd->abs_ts.nsecs / 1000); /* XXX - this has to be improved */
} else {
cinfo->col_buf[col][0] = '\0';
}
@ -497,7 +497,7 @@ static void
col_set_rel_time(frame_data *fd, column_info *cinfo, int col)
{
display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
fd->rel_secs, fd->rel_usecs, USECS);
fd->rel_ts.secs, fd->rel_ts.nsecs / 1000, USECS); /* XXX - this has to be improved */
cinfo->col_data[col] = cinfo->col_buf[col];
strcpy(cinfo->col_expr[col],"frame.time_relative");
strcpy(cinfo->col_expr_val[col],cinfo->col_buf[col]);
@ -507,7 +507,7 @@ static void
col_set_delta_time(frame_data *fd, column_info *cinfo, int col)
{
display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
fd->del_secs, fd->del_usecs, USECS);
fd->del_ts.secs, fd->del_ts.nsecs / 1000, USECS);
cinfo->col_data[col] = cinfo->col_buf[col];
strcpy(cinfo->col_expr[col],"frame.time_delta");
strcpy(cinfo->col_expr_val[col],cinfo->col_buf[col]);
@ -521,14 +521,14 @@ col_set_abs_time(frame_data *fd, column_info *cinfo, int col)
struct tm *tmp;
time_t then;
then = fd->abs_secs;
then = fd->abs_ts.secs;
tmp = localtime(&then);
if (tmp != NULL) {
g_snprintf(cinfo->col_buf[col], COL_MAX_LEN, "%02d:%02d:%02d.%06ld",
tmp->tm_hour,
tmp->tm_min,
tmp->tm_sec,
(long)fd->abs_usecs);
(long)fd->abs_ts.nsecs / 1000); /* XXX - this has to be improved */
} else {
cinfo->col_buf[col][0] = '\0';
}

11
epan/dissectors/packet-afp.c
View File

@ -4010,7 +4010,7 @@ dissect_afp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
afp_request_key request_key, *new_request_key;
afp_request_val *request_val;
guint8 afp_command;
nstime_t t, deltat;
nstime_t delta_ts;
int len = tvb_reported_length_remaining(tvb,0);
gint col_info = check_col(pinfo->cinfo, COL_INFO);
@ -4044,8 +4044,7 @@ dissect_afp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
request_val->command = afp_command;
request_val->frame_req = pinfo->fd->num;
request_val->frame_res = 0;
request_val->req_time.secs=pinfo->fd->abs_secs;
request_val->req_time.nsecs=pinfo->fd->abs_usecs*1000;
request_val->req_time=pinfo->fd->abs_ts;
g_hash_table_insert(afp_request_hash, new_request_key,
request_val);
@ -4248,11 +4247,9 @@ dissect_afp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
ti = proto_tree_add_uint(afp_tree, hf_afp_response_to,
tvb, 0, 0, request_val->frame_req);
PROTO_ITEM_SET_GENERATED(ti);
t.secs = pinfo->fd->abs_secs;
t.nsecs = pinfo->fd->abs_usecs*1000;
get_timedelta(&deltat, &t, &request_val->req_time);
nstime_delta(&delta_ts, &pinfo->fd->abs_ts, &request_val->req_time);
ti = proto_tree_add_time(afp_tree, hf_afp_time, tvb,
0, 0, &deltat);
0, 0, &delta_ts);
PROTO_ITEM_SET_GENERATED(ti);
}

14
epan/dissectors/packet-afs.c
View File

@ -172,7 +172,7 @@ dissect_afs(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
int port, node, typenode, opcode;
value_string const *vals;
int offset = 0;
nstime_t ns;
nstime_t delta_ts;
void (*dissector)(tvbuff_t *tvb, struct rxinfo *rxinfo, proto_tree *tree, int offset, int opcode);
@ -226,8 +226,7 @@ dissect_afs(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
request_val -> opcode = tvb_get_ntohl(tvb, offset);
request_val -> req_num = pinfo->fd->num;
request_val -> rep_num = 0;
request_val -> req_time.secs=pinfo->fd->abs_secs;
request_val -> req_time.nsecs=pinfo->fd->abs_usecs*1000;
request_val -> req_time = pinfo->fd->abs_ts;
g_hash_table_insert(afs_request_hash, new_request_key,
request_val);
@ -370,14 +369,9 @@ dissect_afs(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
tvb, 0, 0, request_val->req_num,
"This is a reply to a request in frame %u",
request_val->req_num);
ns.secs= pinfo->fd->abs_secs-request_val->req_time.secs;
ns.nsecs=pinfo->fd->abs_usecs*1000-request_val->req_time.nsecs;
if(ns.nsecs<0){
ns.nsecs+=1000000000;
ns.secs--;
}
nstime_delta(&delta_ts, &pinfo->fd->abs_ts, &request_val->req_time);
proto_tree_add_time(afs_tree, hf_afs_time, tvb, offset, 0,
&ns);
&delta_ts);
}

14
epan/dissectors/packet-aoe.c
View File

@ -242,8 +242,7 @@ dissect_ata_pdu(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb, int offset,
ata_info->request_frame=pinfo->fd->num;
ata_info->response_frame=0;
ata_info->cmd=tvb_get_guint8(tvb, offset+3);
ata_info->req_time.secs=pinfo->fd->abs_secs;
ata_info->req_time.nsecs=pinfo->fd->abs_usecs*1000;
ata_info->req_time=pinfo->fd->abs_ts;
tmp_ata_info=g_hash_table_lookup(ata_cmd_unmatched, ata_info);
if(tmp_ata_info){
@ -273,16 +272,11 @@ dissect_ata_pdu(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb, int offset,
if(ata_info){
if(response){
if(ata_info->request_frame){
nstime_t ns;
nstime_t delta_ts;
tmp_item=proto_tree_add_uint(tree, hf_aoe_response_to, tvb, 0, 0, ata_info->request_frame);
PROTO_ITEM_SET_GENERATED(tmp_item);
ns.secs= pinfo->fd->abs_secs-ata_info->req_time.secs;
ns.nsecs=pinfo->fd->abs_usecs*1000-ata_info->req_time.nsecs;
if(ns.nsecs<0){
ns.nsecs+=1000000000;
ns.secs--;
}
tmp_item=proto_tree_add_time(tree, hf_aoe_time, tvb, offset, 0, &ns);
nstime_delta(&delta_ts, &pinfo->fd->abs_ts, &ata_info->req_time);
tmp_item=proto_tree_add_time(tree, hf_aoe_time, tvb, offset, 0, &delta_ts);
PROTO_ITEM_SET_GENERATED(tmp_item);
}
} else {

50
epan/dissectors/packet-dcerpc.c
View File

@ -3371,8 +3371,7 @@ dissect_dcerpc_cn_rqst (tvbuff_t *tvb, gint offset, packet_info *pinfo,
call_value->ver = bind_value->ver;
call_value->opnum = opnum;
call_value->req_frame=pinfo->fd->num;
call_value->req_time.secs=pinfo->fd->abs_secs;
call_value->req_time.nsecs=pinfo->fd->abs_usecs*1000;
call_value->req_time=pinfo->fd->abs_ts;
call_value->rep_frame=0;
call_value->max_ptr=0;
call_value->private_data = NULL;
@ -3513,20 +3512,15 @@ dissect_dcerpc_cn_resp (tvbuff_t *tvb, gint offset, packet_info *pinfo,
proto_tree_add_uint (dcerpc_tree, hf_dcerpc_opnum, tvb, 0, 0, value->opnum);
if(value->req_frame!=0){
nstime_t ns;
nstime_t delta_ts;
pi = proto_tree_add_uint(dcerpc_tree, hf_dcerpc_request_in,
tvb, 0, 0, value->req_frame);
PROTO_ITEM_SET_GENERATED(pi);
if(parent_pi != NULL) {
proto_item_append_text(parent_pi, ", [Req: #%u]", value->req_frame);
}
ns.secs= pinfo->fd->abs_secs-value->req_time.secs;
ns.nsecs=pinfo->fd->abs_usecs*1000-value->req_time.nsecs;
if(ns.nsecs<0){
ns.nsecs+=1000000000;
ns.secs--;
}
pi = proto_tree_add_time(dcerpc_tree, hf_dcerpc_time, tvb, offset, 0, &ns);
nstime_delta(&delta_ts, &pinfo->fd->abs_ts, &value->req_time);
pi = proto_tree_add_time(dcerpc_tree, hf_dcerpc_time, tvb, offset, 0, &delta_ts);
PROTO_ITEM_SET_GENERATED(pi);
}
@ -3636,7 +3630,7 @@ dissect_dcerpc_cn_fault (tvbuff_t *tvb, gint offset, packet_info *pinfo,
proto_tree_add_uint (dcerpc_tree, hf_dcerpc_opnum, tvb, 0, 0, value->opnum);
if(value->req_frame!=0){
nstime_t ns;
nstime_t delta_ts;
pi = proto_tree_add_uint(dcerpc_tree, hf_dcerpc_request_in,
tvb, 0, 0, value->req_frame);
PROTO_ITEM_SET_GENERATED(pi);
@ -3644,13 +3638,8 @@ dissect_dcerpc_cn_fault (tvbuff_t *tvb, gint offset, packet_info *pinfo,
if(parent_pi != NULL) {
proto_item_append_text(parent_pi, ", [Req: #%u]", value->req_frame);
}
ns.secs= pinfo->fd->abs_secs-value->req_time.secs;
ns.nsecs=pinfo->fd->abs_usecs*1000-value->req_time.nsecs;
if(ns.nsecs<0){
ns.nsecs+=1000000000;
ns.secs--;
}
pi = proto_tree_add_time(dcerpc_tree, hf_dcerpc_time, tvb, offset, 0, &ns);
nstime_delta(&delta_ts, &pinfo->fd->abs_ts, &value->req_time);
pi = proto_tree_add_time(dcerpc_tree, hf_dcerpc_time, tvb, offset, 0, &delta_ts);
PROTO_ITEM_SET_GENERATED(pi);
}
@ -4477,8 +4466,7 @@ dissect_dcerpc_dg_rqst (tvbuff_t *tvb, int offset, packet_info *pinfo,
call_value->ver = hdr->if_ver;
call_value->opnum = hdr->opnum;
call_value->req_frame=pinfo->fd->num;
call_value->req_time.secs=pinfo->fd->abs_secs;
call_value->req_time.nsecs=pinfo->fd->abs_usecs*1000;
call_value->req_time=pinfo->fd->abs_ts;
call_value->rep_frame=0;
call_value->max_ptr=0;
call_value->private_data = NULL;
@ -4573,7 +4561,7 @@ dissect_dcerpc_dg_resp (tvbuff_t *tvb, int offset, packet_info *pinfo,
di->call_data = value;
if(value->req_frame!=0){
nstime_t ns;
nstime_t delta_ts;
pi = proto_tree_add_uint(dcerpc_tree, hf_dcerpc_request_in,
tvb, 0, 0, value->req_frame);
PROTO_ITEM_SET_GENERATED(pi);
@ -4581,13 +4569,8 @@ dissect_dcerpc_dg_resp (tvbuff_t *tvb, int offset, packet_info *pinfo,
if(parent_pi != NULL) {
proto_item_append_text(parent_pi, ", [Req: #%u]", value->req_frame);
}
ns.secs= pinfo->fd->abs_secs-value->req_time.secs;
ns.nsecs=pinfo->fd->abs_usecs*1000-value->req_time.nsecs;
if(ns.nsecs<0){
ns.nsecs+=1000000000;
ns.secs--;
}
pi = proto_tree_add_time(dcerpc_tree, hf_dcerpc_time, tvb, offset, 0, &ns);
nstime_delta(&delta_ts, &pinfo->fd->abs_ts, &value->req_time);
pi = proto_tree_add_time(dcerpc_tree, hf_dcerpc_time, tvb, offset, 0, &delta_ts);
PROTO_ITEM_SET_GENERATED(pi);
}
dissect_dcerpc_dg_stub (tvb, offset, pinfo, dcerpc_tree, tree, hdr, di);
@ -4609,7 +4592,7 @@ dissect_dcerpc_dg_ping_ack (tvbuff_t *tvb, int offset, packet_info *pinfo,
if((call_value=g_hash_table_lookup(dcerpc_dg_calls, &call_key))){
proto_item *pi;
nstime_t ns;
nstime_t delta_ts;
pi = proto_tree_add_uint(dcerpc_tree, hf_dcerpc_request_in,
tvb, 0, 0, call_value->req_frame);
@ -4622,13 +4605,8 @@ dissect_dcerpc_dg_ping_ack (tvbuff_t *tvb, int offset, packet_info *pinfo,
if (check_col (pinfo->cinfo, COL_INFO))
col_append_fstr(pinfo->cinfo, COL_INFO, " [req: #%u]", call_value->req_frame);
ns.secs= pinfo->fd->abs_secs-call_value->req_time.secs;
ns.nsecs=pinfo->fd->abs_usecs*1000-call_value->req_time.nsecs;
if(ns.nsecs<0){
ns.nsecs+=1000000000;
ns.secs--;
}
pi = proto_tree_add_time(dcerpc_tree, hf_dcerpc_time, tvb, offset, 0, &ns);
nstime_delta(&delta_ts, &pinfo->fd->abs_ts, &call_value->req_time);
pi = proto_tree_add_time(dcerpc_tree, hf_dcerpc_time, tvb, offset, 0, &delta_ts);
PROTO_ITEM_SET_GENERATED(pi);
/* }*/
}

14
epan/dissectors/packet-fc.c
View File

@ -860,8 +860,7 @@ dissect_fc_helper (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean
COPY_ADDRESS(&old_fced->s_id, &fchdr.s_id);
COPY_ADDRESS(&old_fced->d_id, &fchdr.d_id);
old_fced->first_exchange_frame=pinfo->fd->num;
old_fced->fc_time.nsecs = pinfo->fd->abs_usecs*1000;
old_fced->fc_time.secs = pinfo->fd->abs_secs;
old_fced->fc_time = pinfo->fd->abs_ts;
g_hash_table_insert(fc_exchange_unmatched, old_fced, old_fced);
fc_ex=old_fced;
} else {
@ -901,15 +900,10 @@ dissect_fc_helper (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean
proto_tree_add_uint(fc_tree, hf_fc_exchange_last_frame, tvb, 0, 0, fc_ex->last_exchange_frame);
}
if(fchdr.fctl&FC_FCTL_EXCHANGE_LAST){
nstime_t delta_time;
nstime_t delta_ts;
proto_tree_add_uint(fc_tree, hf_fc_exchange_first_frame, tvb, 0, 0, fc_ex->first_exchange_frame);
delta_time.secs = pinfo->fd->abs_secs - fc_ex->fc_time.secs;
delta_time.nsecs = pinfo->fd->abs_usecs*1000 - fc_ex->fc_time.nsecs;
if (delta_time.nsecs<0){
delta_time.nsecs+=1000000000;
delta_time.secs--;
}
proto_tree_add_time(ti, hf_fc_time, tvb, 0, 0, &delta_time);
nstime_delta(&delta_ts, &pinfo->fd->abs_ts, &fc_ex->fc_time);
proto_tree_add_time(ti, hf_fc_time, tvb, 0, 0, &delta_ts);
}
}
fchdr.fced=fc_ex;

19
epan/dissectors/packet-fcp.c
View File

@ -84,8 +84,7 @@ typedef struct _fcp_conv_key {
typedef struct _fcp_conv_data {
guint32 fcp_dl;
gint32 fcp_lun;
guint32 abs_secs;
guint32 abs_usecs;
nstime_t abs_ts;
} fcp_conv_data_t;
GHashTable *fcp_req_hash = NULL;
@ -276,8 +275,7 @@ dissect_fcp_cmnd (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
* req.
*/
cdata->fcp_dl = tvb_get_ntohl (tvb, offset+12+16+add_len);
cdata->abs_usecs = pinfo->fd->abs_usecs;
cdata->abs_secs = pinfo->fd->abs_secs;
cdata->abs_ts = pinfo->fd->abs_ts;
}
else {
req_key = se_alloc (sizeof(fcp_conv_key_t));
@ -285,8 +283,7 @@ dissect_fcp_cmnd (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
cdata = se_alloc (sizeof(fcp_conv_data_t));
cdata->fcp_dl = tvb_get_ntohl (tvb, offset+12+16+add_len);
cdata->abs_usecs = pinfo->fd->abs_usecs;
cdata->abs_secs = pinfo->fd->abs_secs;
cdata->abs_ts = pinfo->fd->abs_ts;
g_hash_table_insert (fcp_req_hash, req_key, cdata);
}
@ -434,8 +431,9 @@ dissect_fcp_rsp (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
proto_tree_add_uint_hidden (fcp_tree, hf_fcp_type, tvb, offset, 0, 0);
if (cdata) {
del_usecs = (pinfo->fd->abs_secs - cdata->abs_secs)* 1000000 +
(pinfo->fd->abs_usecs - cdata->abs_usecs);
/* XXX - this is ugly and should be replaced by a "standard way" */
del_usecs = (pinfo->fd->abs_ts.secs - cdata->abs_ts.secs)* 1000000 +
(pinfo->fd->abs_ts.nsecs - cdata->abs_ts.nsecs) / 1000;
if (del_usecs > 1000)
proto_tree_add_text (fcp_tree, tvb, offset, 0,
"Cmd Response Time: %d msecs",
@ -538,8 +536,9 @@ dissect_fcp_xfer_rdy (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
proto_tree_add_uint_hidden (fcp_tree, hf_fcp_type, tvb, offset, 0, 0);
if (cdata) {
del_usecs = (pinfo->fd->abs_secs - cdata->abs_secs)* 1000000 +
(pinfo->fd->abs_usecs - cdata->abs_usecs);
/* XXX - this is ugly and should be replaced by a "standard way" */
del_usecs = (pinfo->fd->abs_ts.secs - cdata->abs_ts.secs)* 1000000 +
(pinfo->fd->abs_ts.nsecs - cdata->abs_ts.nsecs) / 1000;
if (del_usecs > 1000)
proto_tree_add_text (fcp_tree, tvb, offset, 0,
"Cmd Response Time: %d msecs",

9
epan/dissectors/packet-frame.c
View File

@ -167,21 +167,18 @@ dissect_frame(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree)
proto_tree_add_item(fh_tree, hf_frame_ref_time, tvb, 0, 0, FALSE);
}
ts.secs = pinfo->fd->abs_secs;
ts.nsecs = pinfo->fd->abs_usecs*1000;
ts = pinfo->fd->abs_ts;
proto_tree_add_time(fh_tree, hf_frame_arrival_time, tvb,
0, 0, &ts);
ts.secs = pinfo->fd->del_secs;
ts.nsecs = pinfo->fd->del_usecs*1000;
ts = pinfo->fd->del_ts;
item = proto_tree_add_time(fh_tree, hf_frame_time_delta, tvb,
0, 0, &ts);
PROTO_ITEM_SET_GENERATED(item);
ts.secs = pinfo->fd->rel_secs;
ts.nsecs = pinfo->fd->rel_usecs*1000;
ts = pinfo->fd->rel_ts;
item = proto_tree_add_time(fh_tree, hf_frame_time_relative, tvb,
0, 0, &ts);

14
epan/dissectors/packet-h225.c
View File

@ -12732,9 +12732,9 @@ static void ras_call_matching(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tre
/* if end of list is reached, exit loop and decide if request is duplicate or not. */
if (h225ras_call->next_call == NULL) {
if ( (pinfo->fd->num > h225ras_call->rsp_num && h225ras_call->rsp_num != 0
&& pinfo->fd->abs_secs > (guint) (h225ras_call->req_time.secs + THRESHOLD_REPEATED_RESPONDED_CALL) )
&& pinfo->fd->abs_ts.secs > (h225ras_call->req_time.secs + THRESHOLD_REPEATED_RESPONDED_CALL) )
||(pinfo->fd->num > h225ras_call->req_num && h225ras_call->rsp_num == 0
&& pinfo->fd->abs_secs > (guint) (h225ras_call->req_time.secs + THRESHOLD_REPEATED_NOT_RESPONDED_CALL) ) )
&& pinfo->fd->abs_ts.secs > (h225ras_call->req_time.secs + THRESHOLD_REPEATED_NOT_RESPONDED_CALL) ) )
{
/* if last request has been responded
and this request appears after last response (has bigger frame number)
@ -12830,14 +12830,8 @@ static void ras_call_matching(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tre
PROTO_ITEM_SET_GENERATED(ti);
/* Calculate RAS Service Response Time */
delta.secs= pinfo->fd->abs_secs-h225ras_call->req_time.secs;
delta.nsecs=pinfo->fd->abs_usecs*1000-h225ras_call->req_time.nsecs;
if(delta.nsecs<0){
delta.nsecs+=1000000000;
delta.secs--;
}
pi->delta_time.secs = delta.secs; /* give it to tap */
pi->delta_time.nsecs = delta.nsecs;
nstime_delta(&delta, &pinfo->fd->abs_ts, &h225ras_call->req_time);
pi->delta_time = delta; /* give it to tap */
/* display Ras Service Response Time and make it filterable */
ti = proto_tree_add_time(tree, hf_h225_ras_deltatime, tvb, 0, 0, &(pi->delta_time));

12
epan/dissectors/packet-iax2.c
View File

@ -817,8 +817,7 @@ static iax_call_data *iax_new_call( packet_info *pinfo,
call -> n_forward_circuit_ids = 0;
call -> n_reverse_circuit_ids = 0;
call -> subdissector = NULL;
call -> start_time.secs = pinfo->fd->abs_secs;
call -> start_time.nsecs = (pinfo->fd->abs_usecs-1000) * 1000;
call -> start_time = pinfo->fd->abs_ts;
iax2_new_circuit_for_call(circuit_id,pinfo->fd->num,call,FALSE);
@ -1308,11 +1307,11 @@ static void iax2_add_ts_fields(packet_info * pinfo, proto_tree * iax2_tree, iax_
if(iax_packet->abstime.secs == -1) {
time_t start_secs = iax_packet->call_data->start_time.secs;
guint32 abs_secs = start_secs + longts/1000;
gint32 abs_secs = start_secs + longts/1000;
/* deal with short timestamps by assuming that packets are never more than
* 16 seconds late */
while(abs_secs < pinfo->fd->abs_secs - 16) {
while(abs_secs < pinfo->fd->abs_ts.secs - 16) {
longts += 32768;
abs_secs = start_secs + longts/1000;
}
@ -1328,9 +1327,8 @@ static void iax2_add_ts_fields(packet_info * pinfo, proto_tree * iax2_tree, iax_
item = proto_tree_add_time(iax2_tree, hf_iax2_absts, NULL, 0, 0, &iax_packet->abstime);
PROTO_ITEM_SET_GENERATED(item);
ts.secs = pinfo->fd->abs_secs;
ts.nsecs = pinfo->fd->abs_usecs * 1000;
get_timedelta(&ts, &ts, &iax_packet->abstime);
ts = pinfo->fd->abs_ts;
nstime_delta(&ts, &ts, &iax_packet->abstime);
item = proto_tree_add_time(iax2_tree, hf_iax2_lateness, NULL, 0, 0, &ts);
PROTO_ITEM_SET_GENERATED(item);

19
epan/dissectors/packet-iscsi.c
View File

@ -964,8 +964,7 @@ dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint off
cdata->data_in_frame=0;
cdata->data_out_frame=0;
cdata->response_frame=0;
cdata->req_time.nsecs = pinfo->fd->abs_usecs*1000;
cdata->req_time.secs = pinfo->fd->abs_secs;
cdata->req_time = pinfo->fd->abs_ts;
g_hash_table_insert (iscsi_req_unmatched, cdata, cdata);
} else {
@ -1608,14 +1607,8 @@ dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint off
if (cdata->request_frame){
nstime_t delta_time;
proto_tree_add_uint(ti, hf_iscsi_request_frame, tvb, 0, 0, cdata->request_frame);
delta_time.secs = pinfo->fd->abs_secs - cdata->req_time.secs;
delta_time.nsecs = pinfo->fd->abs_usecs*1000 - cdata->req_time.nsecs;
if (delta_time.nsecs<0){
delta_time.nsecs+=1000000000;
delta_time.secs--;
}
nstime_delta(&delta_time, &pinfo->fd->abs_ts, &cdata->req_time);
proto_tree_add_time(ti, hf_iscsi_time, tvb, 0, 0, &delta_time);
}
if (cdata->data_in_frame)
proto_tree_add_uint(ti, hf_iscsi_data_in_frame, tvb, 0, 0, cdata->data_in_frame);
@ -1634,14 +1627,8 @@ dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint off
if (cdata->request_frame){
nstime_t delta_time;
proto_tree_add_uint(ti, hf_iscsi_request_frame, tvb, 0, 0, cdata->request_frame);
delta_time.secs = pinfo->fd->abs_secs - cdata->req_time.secs;
delta_time.nsecs = pinfo->fd->abs_usecs*1000 - cdata->req_time.nsecs;
if (delta_time.nsecs<0){
delta_time.nsecs+=1000000000;
delta_time.secs--;
}
nstime_delta(&delta_time, &pinfo->fd->abs_ts, &cdata->req_time);
proto_tree_add_time(ti, hf_iscsi_time, tvb, 0, 0, &delta_time);
}
}
if (cdata->data_out_frame)

10
epan/dissectors/packet-ldap.c
View File

@ -2026,8 +2026,7 @@ ldap_match_call_response(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, ld
}
lcrp->messageId=messageId;
lcrp->req_frame=pinfo->fd->num;
lcrp->req_time.secs=pinfo->fd->abs_secs;
lcrp->req_time.nsecs=pinfo->fd->abs_usecs*1000;
lcrp->req_time=pinfo->fd->abs_ts;
lcrp->rep_frame=0;
lcrp->protocolOpTag=protocolOpTag;
lcrp->is_request=TRUE;
@ -2097,12 +2096,7 @@ ldap_match_call_response(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, ld
} else {
nstime_t ns;
proto_tree_add_uint(tree, hf_ldap_response_to, tvb, 0, 0, lcrp->req_frame);
ns.secs=pinfo->fd->abs_secs-lcrp->req_time.secs;
ns.nsecs=pinfo->fd->abs_usecs*1000-lcrp->req_time.nsecs;
if(ns.nsecs<0){
ns.nsecs+=1000000000;
ns.secs--;
}
nstime_delta(&ns, &pinfo->fd->abs_ts, &lcrp->req_time);
proto_tree_add_time(tree, hf_ldap_time, tvb, 0, 0, &ns);
}
return lcrp;

17
epan/dissectors/packet-ncp2222.inc
View File

@ -4521,8 +4521,7 @@ dissect_ncp_request(tvbuff_t *tvb, packet_info *pinfo,
}
request_value = ncp_hash_insert(conversation, sequence, ncp_rec);
request_value->req_frame_num = pinfo->fd->num;
request_value->req_frame_time.secs=pinfo->fd->abs_secs;
request_value->req_frame_time.nsecs=pinfo->fd->abs_usecs*1000;
request_value->req_frame_time=pinfo->fd->abs_ts;
/* If this is the first time we're examining the packet,
* check to see if this NCP type uses a "request condition".
@ -4896,14 +4895,8 @@ dissect_ncp_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree_add_uint(ncp_tree, hf_ncp_req_frame_num, tvb, 0, 0,
request_value->req_frame_num);
ns.secs=pinfo->fd->abs_secs-request_value->req_frame_time.secs;
ns.nsecs=pinfo->fd->abs_usecs*1000-request_value->req_frame_time.nsecs;
if(ns.nsecs<0){
ns.nsecs+=1000000000;
ns.secs--;
}
nstime_delta(&ns, &pinfo->fd->abs_ts, &request_value->req_frame_time);
proto_tree_add_time(ncp_tree, hf_ncp_req_frame_time, tvb, 0, 0, &ns);
}
/* Put the func (and maybe subfunc) from the request packet
@ -8296,8 +8289,7 @@ dissect_nds_request(tvbuff_t *tvb, packet_info *pinfo,
if (!pinfo->fd->flags.visited) {
request_value = ncp_hash_insert(conversation, sequence, ncp_rec);
request_value->req_frame_num = pinfo->fd->num;
request_value->req_frame_time.secs=pinfo->fd->abs_secs;
request_value->req_frame_time.nsecs=pinfo->fd->abs_usecs*1000;
request_value->req_frame_time=pinfo->fd->abs_ts;
/* If this is the first time we're examining the packet,
* check to see if this NCP type uses a "request condition".
@ -8576,8 +8568,7 @@ dissect_ping_req(tvbuff_t *tvb, packet_info *pinfo,
request_value = ncp_hash_insert(conversation, sequence, ncp_rec);
request_value->req_frame_num = pinfo->fd->num;
request_value->req_frame_time.secs=pinfo->fd->abs_secs;
request_value->req_frame_time.nsecs=pinfo->fd->abs_usecs*1000;
request_value->req_frame_time=pinfo->fd->abs_ts;
/* If this is the first time we're examining the packet,
* check to see if this NCP type uses a "request condition".

11
epan/dissectors/packet-nlm.c
View File

@ -208,14 +208,8 @@ nlm_print_msgres_reply(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb)
if(md){
nstime_t ns;
proto_tree_add_uint(tree, hf_nlm_request_in, tvb, 0, 0, md->req_frame);
ns.secs= pinfo->fd->abs_secs-md->ns.secs;
ns.nsecs=pinfo->fd->abs_usecs*1000-md->ns.nsecs;
if(ns.nsecs<0){
ns.nsecs+=1000000000;
ns.secs--;
}
nstime_delta(&ns, &pinfo->fd->abs_ts, &md->ns);
proto_tree_add_time(tree, hf_nlm_time, tvb, 0, 0, &ns);
}
}
@ -300,8 +294,7 @@ nlm_register_unmatched_msg(packet_info *pinfo, tvbuff_t *tvb, int offset)
/* allocate and build the unmatched structure for this request */
umd=g_malloc(sizeof(nlm_msg_res_unmatched_data));
umd->req_frame=pinfo->fd->num;
umd->ns.secs=pinfo->fd->abs_secs;
umd->ns.nsecs=pinfo->fd->abs_usecs*1000;
umd->ns=pinfo->fd->abs_ts;
umd->cookie_len=tvb_get_ntohl(tvb, offset);
umd->cookie=tvb_memdup(tvb, offset+4, umd->cookie_len);

16
epan/dissectors/packet-rlogin.c
View File

@ -74,8 +74,7 @@ typedef struct {
#define DONE 2
#define BAD 2
static guint32 last_abs_sec = 0;
static guint32 last_abs_usec= 0;
static nstime_t last_abs_ts = { 0, 0 };
static void
rlogin_init(void)
@ -83,9 +82,7 @@ rlogin_init(void)
/* Routine to initialize rlogin protocol before each capture or filter pass. */
last_abs_sec = 0;
last_abs_usec= 0;
nstime_set_zero(&last_abs_ts);
}
@ -110,13 +107,12 @@ rlogin_state_machine( rlogin_hash_entry_t *hash_info, tvbuff_t *tvb,
return;
/* test timestamp */
if (( last_abs_sec > pinfo->fd->abs_secs) ||
(( last_abs_sec == pinfo->fd->abs_secs) &&
( last_abs_usec >= pinfo->fd->abs_usecs)))
if (( last_abs_ts.secs > pinfo->fd->abs_ts.secs) ||
(( last_abs_ts.secs == pinfo->fd->abs_ts.secs) &&
( last_abs_ts.nsecs >= pinfo->fd->abs_ts.nsecs)))
return;
last_abs_sec = pinfo->fd->abs_secs; /* save timestamp */
last_abs_usec = pinfo->fd->abs_usecs;
last_abs_ts = pinfo->fd->abs_ts; /* save timestamp */
length = tvb_length(tvb);
if ( length == 0) /* exit if no data */

13
epan/dissectors/packet-rpc.c
View File

@ -1871,8 +1871,7 @@ dissect_rpc_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
rpc_call->gss_proc = 0;
rpc_call->gss_svc = 0;
rpc_call->proc_info = value;
rpc_call->req_time.secs=pinfo->fd->abs_secs;
rpc_call->req_time.nsecs=pinfo->fd->abs_usecs*1000;
rpc_call->req_time = pinfo->fd->abs_ts;
/* store it */
g_hash_table_insert(rpc_calls, new_rpc_call_key, rpc_call);
@ -2167,8 +2166,7 @@ dissect_rpc_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
rpc_call->gss_proc = gss_proc;
rpc_call->gss_svc = gss_svc;
rpc_call->proc_info = value;
rpc_call->req_time.secs=pinfo->fd->abs_secs;
rpc_call->req_time.nsecs=pinfo->fd->abs_usecs*1000;
rpc_call->req_time = pinfo->fd->abs_ts;
/* store it */
g_hash_table_insert(rpc_calls, new_rpc_call_key,
@ -2289,12 +2287,7 @@ dissect_rpc_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
tvb, 0, 0, rpc_call->req_num,
"This is a reply to a request in frame %u",
rpc_call->req_num);
ns.secs= pinfo->fd->abs_secs-rpc_call->req_time.secs;
ns.nsecs=pinfo->fd->abs_usecs*1000-rpc_call->req_time.nsecs;
if(ns.nsecs<0){
ns.nsecs+=1000000000;
ns.secs--;
}
nstime_delta(&ns, &pinfo->fd->abs_ts, &rpc_call->req_time);
proto_tree_add_time(rpc_tree, hf_rpc_time, tvb, offset, 0,
&ns);

14
epan/dissectors/packet-rtcp.c
View File

@ -1551,8 +1551,7 @@ static void remember_outgoing_sr(packet_info *pinfo, long lsr)
/* Update conversation data */
p_conv_data->last_received_set = TRUE;
p_conv_data->last_received_frame_number = pinfo->fd->num;
p_conv_data->last_received_time_secs = pinfo->fd->abs_secs;
p_conv_data->last_received_time_usecs = pinfo->fd->abs_usecs;
p_conv_data->last_received_timestamp = pinfo->fd->abs_ts;
p_conv_data->last_received_ts = lsr;
@ -1576,8 +1575,7 @@ static void remember_outgoing_sr(packet_info *pinfo, long lsr)
/* Copy current conversation data into packet info */
p_packet_data->last_received_set = TRUE;
p_packet_data->last_received_frame_number = p_conv_data->last_received_frame_number;
p_packet_data->last_received_time_secs = p_conv_data->last_received_time_secs;
p_packet_data->last_received_time_usecs = p_conv_data->last_received_time_usecs;
p_packet_data->last_received_timestamp = p_conv_data->last_received_timestamp;
}
@ -1656,13 +1654,13 @@ static void calculate_roundtrip_delay(tvbuff_t *tvb, packet_info *pinfo,
{
/* Look at time of since original packet was sent */
gint seconds_between_packets =
pinfo->fd->abs_secs - p_conv_data->last_received_time_secs;
gint useconds_between_packets =
pinfo->fd->abs_usecs - p_conv_data->last_received_time_usecs;
pinfo->fd->abs_ts.secs - p_conv_data->last_received_timestamp.secs;
gint nseconds_between_packets =
pinfo->fd->abs_ts.nsecs - p_conv_data->last_received_timestamp.nsecs;
gint total_gap = ((seconds_between_packets*1000000) +
useconds_between_packets) / 1000;
nseconds_between_packets) / 1000000;
gint delay = total_gap - (int)(((double)dlsr/(double)65536) * 1000.0);
/* No useful calculation can be done if dlsr not set... */

3
epan/dissectors/packet-rtcp.h
View File

@ -41,8 +41,7 @@ struct _rtcp_conversation_info
/* Info used for roundtrip calculations */
guchar last_received_set;
guint32 last_received_frame_number;
guint32 last_received_time_secs;
guint32 last_received_time_usecs;
nstime_t last_received_timestamp;
guint32 last_received_ts;
/* Stored result of calculation (ms) */

8
epan/dissectors/packet-smb.c
View File

@ -15012,8 +15012,7 @@ dissect_smb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree)
sip = se_alloc(sizeof(smb_saved_info_t));
sip->frame_req = pinfo->fd->num;
sip->frame_res = 0;
sip->req_time.secs=pinfo->fd->abs_secs;
sip->req_time.nsecs=pinfo->fd->abs_usecs*1000;
sip->req_time = pinfo->fd->abs_ts;
sip->flags = 0;
if(g_hash_table_lookup(si->ct->tid_service, GUINT_TO_POINTER(si->tid))
== (void *)TID_IPC) {
@ -15063,9 +15062,8 @@ dissect_smb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree)
if (sip->frame_req != 0) {
tmp_item=proto_tree_add_uint(htree, hf_smb_response_to, tvb, 0, 0, sip->frame_req);
PROTO_ITEM_SET_GENERATED(tmp_item);
t.secs = pinfo->fd->abs_secs;
t.nsecs = pinfo->fd->abs_usecs*1000;
get_timedelta(&deltat, &t, &sip->req_time);
t = pinfo->fd->abs_ts;
nstime_delta(&deltat, &t, &sip->req_time);
tmp_item=proto_tree_add_time(htree, hf_smb_time, tvb,
0, 0, &deltat);
PROTO_ITEM_SET_GENERATED(tmp_item);

68
epan/dissectors/packet-tcp.c
View File

@ -430,8 +430,7 @@ scan_for_next_pdu(tvbuff_t *tvb, proto_tree *tcp_tree, packet_info *pinfo, int o
*/
if(seq>tnp->seq && nxtseq<=tnp->nxtpdu){
tnp->last_frame=pinfo->fd->num;
tnp->last_frame_time.secs=pinfo->fd->abs_secs;
tnp->last_frame_time.nsecs=pinfo->fd->abs_usecs*1000;
tnp->last_frame_time=pinfo->fd->abs_ts;
g_hash_table_insert(tcp_pdu_skipping_table,
GINT_TO_POINTER(pinfo->fd->num), (void *)tnp);
print_pdu_tracking_data(pinfo, tvb, tcp_tree, tnp);
@ -456,16 +455,10 @@ scan_for_next_pdu(tvbuff_t *tvb, proto_tree *tcp_tree, packet_info *pinfo, int o
item=proto_tree_add_uint(tcp_tree, hf_tcp_pdu_last_frame, tvb, 0, 0, tnp->last_frame);
PROTO_ITEM_SET_GENERATED(item);
ns.secs =tnp->last_frame_time.secs-pinfo->fd->abs_secs;
ns.nsecs=tnp->last_frame_time.nsecs-pinfo->fd->abs_usecs*1000;
if(ns.nsecs<0){
ns.nsecs+=1000000000;
ns.secs--;
}
nstime_delta(&ns, &tnp->last_frame_time, &pinfo->fd->abs_ts);
item = proto_tree_add_time(tcp_tree, hf_tcp_pdu_time,
tvb, 0, 0, &ns);
PROTO_ITEM_SET_GENERATED(item);
}
/* check if this is a segment in the middle of a pdu */
@ -502,8 +495,7 @@ pdu_store_sequencenumber_of_next_pdu(packet_info *pinfo, guint32 seq, guint32 nx
tnp->seq=seq;
tnp->first_frame=pinfo->fd->num;
tnp->last_frame=pinfo->fd->num;
tnp->last_frame_time.secs=pinfo->fd->abs_secs;
tnp->last_frame_time.nsecs=pinfo->fd->abs_usecs*1000;
tnp->last_frame_time=pinfo->fd->abs_ts;
/* check direction and get pdu start list */
direction=CMP_ADDRESS(&pinfo->src, &pinfo->dst);
@ -673,14 +665,12 @@ tcp_analyze_sequence_number(packet_info *pinfo, guint32 seq, guint32 ack, guint3
if(!ack2_frame){
ack2_frame=pinfo->fd->num;
ack2=ack;
ack2_time->secs=pinfo->fd->abs_secs;
ack2_time->nsecs=pinfo->fd->abs_usecs*1000;
*ack2_time=pinfo->fd->abs_ts;
num2_acks=0;
} else if(GT_SEQ(ack, ack2)){
ack2_frame=pinfo->fd->num;
ack2=ack;
ack2_time->secs=pinfo->fd->abs_secs;
ack2_time->nsecs=pinfo->fd->abs_usecs*1000;
*ack2_time=pinfo->fd->abs_ts;
num2_acks=0;
}
}
@ -729,8 +719,7 @@ printf(" Frame:%d seq:%d nseq:%d time:%d.%09d ack:%d:%d\n",u->frame,u->seq,u->n
num2_acks=0;
ual1->seq=seq;
ual1->nextseq=seq+1;
ual1->ts.secs=pinfo->fd->abs_secs;
ual1->ts.nsecs=pinfo->fd->abs_usecs*1000;
ual1->ts=pinfo->fd->abs_ts;
ual1->window=window;
ual1->flags=0;
if(tcp_relative_seq){
@ -754,8 +743,7 @@ printf(" Frame:%d seq:%d nseq:%d time:%d.%09d ack:%d:%d\n",u->frame,u->seq,u->n
ual1->frame=pinfo->fd->num;
ual1->seq=seq;
ual1->nextseq=seq+seglen;
ual1->ts.secs=pinfo->fd->abs_secs;
ual1->ts.nsecs=pinfo->fd->abs_usecs*1000;
ual1->ts=pinfo->fd->abs_ts;
ual1->window=window;
ual1->flags=0;
if(tcp_relative_seq){
@ -781,8 +769,7 @@ printf(" Frame:%d seq:%d nseq:%d time:%d.%09d ack:%d:%d\n",u->frame,u->seq,u->n
ual->frame=pinfo->fd->num;
ual->seq=seq;
ual->nextseq=seq+seglen;
ual->ts.secs=pinfo->fd->abs_secs;
ual->ts.nsecs=pinfo->fd->abs_usecs*1000;
ual->ts=pinfo->fd->abs_ts;
ual->window=window;
ual->flags=0;
ual1=ual;
@ -840,8 +827,8 @@ printf(" Frame:%d seq:%d nseq:%d time:%d.%09d ack:%d:%d\n",u->frame,u->seq,u->n
if( (num1_acks>=4) && (seq==ack1) ){
guint32 t;
t=(pinfo->fd->abs_secs-ack1_time->secs)*1000000000;
t=t+(pinfo->fd->abs_usecs*1000)-ack1_time->nsecs;
t=(pinfo->fd->abs_ts.secs-ack1_time->secs)*1000000000;
t=t+(pinfo->fd->abs_ts.nsecs)-ack1_time->nsecs;
if(t<10000000){
/* has to be a retransmission then */
struct tcp_acked *ta;
@ -888,15 +875,15 @@ printf(" Frame:%d seq:%d nseq:%d time:%d.%09d ack:%d:%d\n",u->frame,u->seq,u->n
}
}
if(ntu){
if(pinfo->fd->abs_secs>(guint32)(ntu->ts.secs+2)){
if(pinfo->fd->abs_ts.secs > ntu->ts.secs+2){
outoforder=FALSE;
} else if((pinfo->fd->abs_secs+2)<(guint32)ntu->ts.secs){
} else if(pinfo->fd->abs_ts.secs+2 < ntu->ts.secs){
outoforder=FALSE;
} else {
guint32 t;
t=(ntu->ts.secs-pinfo->fd->abs_secs)*1000000000;
t=t+ntu->ts.nsecs-(pinfo->fd->abs_usecs*1000);
t=(ntu->ts.secs-pinfo->fd->abs_ts.secs)*1000000000;
t=t+ntu->ts.nsecs-(pinfo->fd->abs_ts.nsecs);
if(t>4000000){
outoforder=FALSE;
@ -952,12 +939,7 @@ printf(" Frame:%d seq:%d nseq:%d time:%d.%09d ack:%d:%d\n",u->frame,u->seq,u->n
* segment with an equal or lower sequence
* number.
*/
ta->rto_ts.secs=pinfo->fd->abs_secs-ntu->ts.secs;
ta->rto_ts.nsecs=pinfo->fd->abs_usecs*1000-ntu->ts.nsecs;
if(ta->rto_ts.nsecs<0){
ta->rto_ts.nsecs+=1000000000;
ta->rto_ts.secs--;
}
nstime_delta(&ta->rto_ts, &pinfo->fd->abs_ts, &ntu->ts);
ta->rto_frame=ntu->frame;
} else {
/* we didnt see any previous packet so we
@ -974,8 +956,7 @@ printf(" Frame:%d seq:%d nseq:%d time:%d.%09d ack:%d:%d\n",u->frame,u->seq,u->n
if(GT_SEQ((seq+seglen), ual1->nextseq)){
ual1->nextseq=seq+seglen;
ual1->frame=pinfo->fd->num;
ual1->ts.secs=pinfo->fd->abs_secs;
ual1->ts.nsecs=pinfo->fd->abs_usecs*1000;
ual1->ts=pinfo->fd->abs_ts;
}
}
goto seq_finished;
@ -987,8 +968,7 @@ printf(" Frame:%d seq:%d nseq:%d time:%d.%09d ack:%d:%d\n",u->frame,u->seq,u->n
ual->frame=pinfo->fd->num;
ual->seq=seq;
ual->nextseq=seq+seglen;
ual->ts.secs=pinfo->fd->abs_secs;
ual->ts.nsecs=pinfo->fd->abs_usecs*1000;
ual->ts=pinfo->fd->abs_ts;
ual->window=window;
ual->flags=0;
ual1=ual;
@ -1043,12 +1023,7 @@ seq_finished:
ta=tcp_analyze_get_acked_struct(pinfo->fd->num, TRUE);
ta->frame_acked=ual2->frame;
ta->ts.secs=pinfo->fd->abs_secs-ual2->ts.secs;
ta->ts.nsecs=pinfo->fd->abs_usecs*1000-ual2->ts.nsecs;
if(ta->ts.nsecs<0){
ta->ts.nsecs+=1000000000;
ta->ts.secs--;
}
nstime_delta(&ta->ts, &pinfo->fd->abs_ts, &ual2->ts);
/* its all been ACKed so we dont need to keep them anymore */
for(ual=ual2;ual2;ual2=ual){
@ -1076,12 +1051,7 @@ seq_finished:
ta=tcp_analyze_get_acked_struct(pinfo->fd->num, TRUE);
ta->frame_acked=ackedual->frame;
ta->ts.secs=pinfo->fd->abs_secs-ackedual->ts.secs;
ta->ts.nsecs=pinfo->fd->abs_usecs*1000-ackedual->ts.nsecs;
if(ta->ts.nsecs<0){
ta->ts.nsecs+=1000000000;
ta->ts.secs--;
}
nstime_delta(&ta->ts, &pinfo->fd->abs_ts, &ackedual->ts);
/* just delete all ACKed segments */
tmpual=ual->next;

10
epan/frame_data.h
View File

@ -27,6 +27,7 @@
#include "column_info.h"
#include "tvbuff.h"
#include <epan/nstime.h>
#if 0
/* Defined in color.h */
@ -51,12 +52,9 @@ typedef struct _frame_data {
guint32 pkt_len; /* Packet length */
guint32 cap_len; /* Amount actually captured */
guint32 cum_bytes; /* Cumulative bytes into the capture */
gint32 rel_secs; /* Relative seconds (yes, it can be negative) */
gint32 rel_usecs; /* Relative microseconds (yes, it can be negative) */
guint32 abs_secs; /* Absolute seconds */
guint32 abs_usecs; /* Absolute microseconds */
gint32 del_secs; /* Delta seconds (yes, it can be negative) */
gint32 del_usecs; /* Delta microseconds (yes, it can be negative) */
nstime_t abs_ts; /* Absolute timestamp */
nstime_t rel_ts; /* Relative timestamp (yes, it can be negative) */
nstime_t del_ts; /* Delta timestamp (yes, it can be negative) */
long file_off; /* File offset */
int lnk_t; /* Per-packet encapsulation/data-link type */
struct {

6
epan/h225-persistentdata.c
View File

@ -95,8 +95,7 @@ h225ras_call_t * new_h225ras_call(h225ras_call_info_key *h225ras_call_key, packe
h225ras_call->requestSeqNum = h225ras_call_key->reqSeqNum;
h225ras_call->responded = FALSE;
h225ras_call->next_call = NULL;
h225ras_call->req_time.secs=pinfo->fd->abs_secs;
h225ras_call->req_time.nsecs=pinfo->fd->abs_usecs*1000;
h225ras_call->req_time=pinfo->fd->abs_ts;
memcpy(h225ras_call->guid, guid,16);
/* store it */
g_hash_table_insert(ras_calls[category], new_h225ras_call_key, h225ras_call);
@ -119,8 +118,7 @@ h225ras_call_t * append_h225ras_call(h225ras_call_t *prev_call, packet_info *pin
h225ras_call->requestSeqNum = prev_call->requestSeqNum;
h225ras_call->responded = FALSE;
h225ras_call->next_call = NULL;
h225ras_call->req_time.secs=pinfo->fd->abs_secs;
h225ras_call->req_time.nsecs=pinfo->fd->abs_usecs*1000;
h225ras_call->req_time=pinfo->fd->abs_ts;
memcpy(h225ras_call->guid, guid,16);
prev_call->next_call = h225ras_call;

7
epan/libethereal.def
View File

@ -307,8 +307,6 @@ get_plugins_pers_dir
get_systemfile_dir
get_tcp_port
get_tempfile_path
get_timedelta
get_timesum
get_timestamp_setting
get_udp_port
gsm_a_bssmap_msg_strings DATA
@ -351,7 +349,12 @@ mtp3_addr_to_str_buf
mtp3_service_indicator_code_short_vals DATA
new_create_dissector_handle
new_register_dissector
nstime_delta
nstime_is_zero
nstime_set_zero
nstime_sum
nstime_to_msec
nstime_to_sec
nt_cmd_vals DATA
num_tap_filters DATA
num_tree_types DATA

37
epan/nstime.c
View File

@ -25,6 +25,7 @@
*
*/
#include <glib.h>
#include "nstime.h"
/* this is #defined so that we can clearly see that we have the right number of
@ -32,12 +33,30 @@
changing ;) */
#define NS_PER_S 1000000000
/* set the given nstime_t to zero */
void nstime_set_zero(nstime_t *nstime)
{
nstime->secs = 0;
nstime->nsecs = 0;
}
/* is the given nstime_t currently zero? */
gboolean nstime_is_zero(nstime_t *nstime)
{
if(nstime->secs == 0 && nstime->nsecs