/* time_shift_dlg.c * Routines for "Time Shift" window * Submitted by Edwin Groothuis * * $Id$ * * Wireshark - Network traffic analyzer * By Gerald Combs * Copyright 1998 Gerald Combs * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #include #include #include #include #include #include #include #include #include #include "../globals.h" #include "ui/alert_box.h" #include "ui/simple_dialog.h" #include "ui/main_statusbar.h" #include "ui/ui_util.h" #include "ui/gtk/gui_utils.h" #include "ui/gtk/time_shift_dlg.h" #include "ui/gtk/dlg_utils.h" #include "ui/gtk/stock_icons.h" #include "ui/gtk/prefs_dlg.h" #include "ui/gtk/keys.h" #include "ui/gtk/help_dlg.h" /* Capture callback data keys */ #define E_TIMESHIFT_SELECT "timeshift_select" #define E_TIMESHIFT_OFFSET_KEY "timeshift_offset_te" #define E_SETTIME_SELECT "settime_select" #define E_SETTIME_TIME_KEY "settime_time_te" #define E_SETTIME_PACKETNUMBER_KEY "settime_packetnumber_te" #define E_ADJTIME_SELECT "adjtime_select" #define E_ADJTIME_TIME1_KEY "adjtime_time1_te" #define E_ADJTIME_PACKETNUMBER1_KEY "adjtime_packetnumber1_te" #define E_ADJTIME_TIME2_KEY "adjtime_time2_te" #define E_ADJTIME_PACKETNUMBER2_KEY "adjtime_packetnumber2_te" #define E_UNDO_SELECT "undo_select" #define E_UNDO_SHIFT_KEY "undo_shift_cb" static void time_shift_apply_cb(GtkWidget *ok_bt, GtkWindow *parent_w); static void time_shift_close_cb(GtkWidget *close_bt, gpointer parent_w); static void time_shift_frame_destroy_cb(GtkWidget *win, gpointer user_data); static void error_message(const gchar *msg); #define SHIFT_POS 0 #define SHIFT_NEG 1 #define SHIFT_SETTOZERO 1 #define SHIFT_KEEPOFFSET 0 static void modify_time_init(frame_data *fd); static void modify_time_perform(frame_data *fd, int neg, nstime_t *offset, int settozero); /* * Keep a static pointer to the current "Time Shift" window, if any, so * that if somebody tries to do "Time Shift" while there's already a * "Time Shift" window up, we just pop up the existing one, rather than * creating a new one. */ static GtkWidget *time_shift_frame_w; void time_shift_cb(GtkWidget *w _U_, gpointer d _U_) { GtkWidget *main_vb, *main_hb, *label, *types_frame, *types_vb, *timeshift_offset_hb, *timeshift_offset_text_box, *settime_time_hb, *settime_packetnumber_text_box, *settime_time_text_box, *adjtime_offset_hb, *adjtime_packetnumber1_text_box, *adjtime_packetnumber2_text_box, *adjtime_time1_text_box, *adjtime_time2_text_box, *undo_offset_hb, *undo_type_hb, *timeshift_rb, *settime_rb, *adjtime_rb, *undo_rb, *bbox, *apply_bt, *close_bt, *help_bt; if (time_shift_frame_w != NULL) { /* There's already a "Time Shift" dialog box; reactivate it. */ reactivate_window(time_shift_frame_w); return; } time_shift_frame_w = dlg_window_new("Wireshark: Time Shift"); /* Container for each row of widgets */ main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5); gtk_container_add(GTK_CONTAINER(time_shift_frame_w), main_vb); gtk_widget_show(main_vb); /* * Shift All Packets frame */ main_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_container_add(GTK_CONTAINER(main_vb), main_hb); gtk_widget_show(main_hb); types_frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(main_hb), types_frame, TRUE, TRUE, 0); gtk_widget_show(types_frame); types_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE); gtk_container_set_border_width(GTK_CONTAINER(types_vb), 3); gtk_container_add(GTK_CONTAINER(types_frame), types_vb); gtk_widget_show(types_vb); /* Radio button row */ timeshift_offset_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_box_pack_start(GTK_BOX(types_vb), timeshift_offset_hb, FALSE, FALSE, 0); gtk_widget_show(timeshift_offset_hb); timeshift_rb = gtk_radio_button_new_with_label (NULL, "Shift all packets"); gtk_box_pack_start(GTK_BOX(timeshift_offset_hb), timeshift_rb, TRUE, TRUE, 0); gtk_widget_show(timeshift_rb); gtk_widget_set_tooltip_text(timeshift_rb, "Shift the time on the frames."); /* Time Shift entry row */ timeshift_offset_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_box_pack_start(GTK_BOX(types_vb), timeshift_offset_hb, FALSE, FALSE, 0); gtk_widget_show(timeshift_offset_hb); label = gtk_label_new("Time offset in the format [+-][[hh:]mm:]ss[.ddd]"); gtk_box_pack_start(GTK_BOX(timeshift_offset_hb), label, FALSE, FALSE, 0); gtk_widget_show(label); timeshift_offset_text_box = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(timeshift_offset_hb), timeshift_offset_text_box, TRUE, TRUE, 0); gtk_widget_show(timeshift_offset_text_box); gtk_widget_set_tooltip_text(timeshift_offset_text_box, "Enter the time to shift here. The format is " "[+-][[hh:]mm:]ss.[.ddddddddd]."); /* * Set Packet Number to Time frame */ main_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_container_add(GTK_CONTAINER(main_vb), main_hb); gtk_widget_show(main_hb); types_frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(main_hb), types_frame, TRUE, TRUE, 0); gtk_widget_show(types_frame); types_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE); gtk_container_set_border_width(GTK_CONTAINER(types_vb), 3); gtk_container_add(GTK_CONTAINER(types_frame), types_vb); gtk_widget_show(types_vb); /* time shift type row */ settime_time_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_box_pack_start(GTK_BOX(types_vb), settime_time_hb, FALSE, FALSE, 0); gtk_widget_show(settime_time_hb); settime_rb = gtk_radio_button_new_with_label(gtk_radio_button_get_group( GTK_RADIO_BUTTON(timeshift_rb)), "Set packet to time"); gtk_box_pack_start(GTK_BOX(settime_time_hb), settime_rb, TRUE, TRUE, 0); gtk_widget_show(settime_rb); gtk_widget_set_tooltip_text(settime_rb, "Set the time of a certain frame and adjust the rest of the frames " "automatically."); settime_time_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_box_pack_start(GTK_BOX(types_vb), settime_time_hb, FALSE, FALSE, 0); gtk_widget_show(settime_time_hb); label = gtk_label_new("Packet number"); gtk_box_pack_start(GTK_BOX(settime_time_hb), label, FALSE, FALSE, 0); gtk_widget_show(label); settime_packetnumber_text_box = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(settime_time_hb), settime_packetnumber_text_box, TRUE, TRUE, 0); gtk_entry_set_text(GTK_ENTRY(settime_packetnumber_text_box), ""); gtk_widget_show(settime_packetnumber_text_box); gtk_widget_set_tooltip_text(settime_packetnumber_text_box, "The frame which will be set to the time."); /* time shift row */ settime_time_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_box_pack_start(GTK_BOX(types_vb), settime_time_hb, FALSE, FALSE, 0); gtk_widget_show(settime_time_hb); label = gtk_label_new("Set packet to time [YYYY-MM-DD] hh:mm:ss[.ddd]"); gtk_box_pack_start(GTK_BOX(settime_time_hb), label, FALSE, FALSE, 0); gtk_widget_show(label); settime_time_text_box = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(settime_time_hb), settime_time_text_box, TRUE, TRUE, 0); gtk_widget_show(settime_time_text_box); gtk_widget_set_tooltip_text(settime_time_text_box, "The time for the frame in the format of [YYYY-MM-DD] " "hh:mm:ss[.ddddddddd]"); /* * Set two Packet Numbers to Time frame and extrapolate */ main_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_container_add(GTK_CONTAINER(main_vb), main_hb); gtk_widget_show(main_hb); types_frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(main_hb), types_frame, TRUE, TRUE, 0); gtk_widget_show(types_frame); types_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE); gtk_container_set_border_width(GTK_CONTAINER(types_vb), 3); gtk_container_add(GTK_CONTAINER(types_frame), types_vb); gtk_widget_show(types_vb); /* packet number row 1 */ adjtime_offset_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_box_pack_start(GTK_BOX(types_vb), adjtime_offset_hb, FALSE, FALSE, 0); gtk_widget_show(adjtime_offset_hb); adjtime_rb = gtk_radio_button_new_with_label(gtk_radio_button_get_group( GTK_RADIO_BUTTON(timeshift_rb)), "Set packets to time and extrapolate"); gtk_box_pack_start(GTK_BOX(adjtime_offset_hb), adjtime_rb, TRUE, TRUE, 0); gtk_widget_show(adjtime_rb); gtk_widget_set_tooltip_text(adjtime_rb, "Set the time of two frames and adjust the rest of the frames " "automatically."); adjtime_offset_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_box_pack_start(GTK_BOX(types_vb), adjtime_offset_hb, FALSE, FALSE, 0); gtk_widget_show(adjtime_offset_hb); label = gtk_label_new("Packet number"); gtk_box_pack_start(GTK_BOX(adjtime_offset_hb), label, FALSE, FALSE, 0); gtk_widget_show(label); adjtime_packetnumber1_text_box = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(adjtime_offset_hb), adjtime_packetnumber1_text_box, TRUE, TRUE, 0); gtk_entry_set_text(GTK_ENTRY(adjtime_packetnumber1_text_box), ""); gtk_widget_show(adjtime_packetnumber1_text_box); gtk_widget_set_tooltip_text(adjtime_packetnumber1_text_box, "The frame which will be set to the time."); /* time shift row */ adjtime_offset_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_box_pack_start(GTK_BOX(types_vb), adjtime_offset_hb, FALSE, FALSE, 0); gtk_widget_show(adjtime_offset_hb); label = gtk_label_new("Set packet to time [YYYY-MM-DD] hh:mm:ss[.ddd]"); gtk_box_pack_start(GTK_BOX(adjtime_offset_hb), label, FALSE, FALSE, 0); gtk_widget_show(label); adjtime_time1_text_box = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(adjtime_offset_hb), adjtime_time1_text_box, TRUE, TRUE, 0); gtk_entry_set_text(GTK_ENTRY(adjtime_time1_text_box), ""); gtk_widget_show(adjtime_time1_text_box); gtk_widget_set_tooltip_text(adjtime_time1_text_box, "The time for the frame in the format of [YYYY-MM-DD] " "hh:mm:ss[.ddddddddd]"); /* packet number row 2 */ adjtime_offset_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_box_pack_start(GTK_BOX(types_vb), adjtime_offset_hb, FALSE, FALSE, 0); gtk_widget_show(adjtime_offset_hb); label = gtk_label_new("Packet number"); gtk_box_pack_start(GTK_BOX(adjtime_offset_hb), label, FALSE, FALSE, 0); gtk_widget_show(label); adjtime_packetnumber2_text_box = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(adjtime_offset_hb), adjtime_packetnumber2_text_box, TRUE, TRUE, 0); gtk_entry_set_text(GTK_ENTRY(adjtime_packetnumber2_text_box), ""); gtk_widget_show(adjtime_packetnumber2_text_box); gtk_widget_set_tooltip_text(adjtime_packetnumber2_text_box, "The frame which will be set to the time."); /* time shift row */ adjtime_offset_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_box_pack_start(GTK_BOX(types_vb), adjtime_offset_hb, FALSE, FALSE, 0); gtk_widget_show(adjtime_offset_hb); label = gtk_label_new("Set packet to time [YYYY-MM-DD] hh:mm:ss[.ddd]"); gtk_box_pack_start(GTK_BOX(adjtime_offset_hb), label, FALSE, FALSE, 0); gtk_widget_show(label); adjtime_time2_text_box = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(adjtime_offset_hb), adjtime_time2_text_box, TRUE, TRUE, 0); gtk_entry_set_text(GTK_ENTRY(adjtime_time2_text_box), ""); gtk_widget_show(adjtime_time2_text_box); gtk_widget_set_tooltip_text(adjtime_time2_text_box, "The time for the frame in the format of [YYYY-MM-DD] " "hh:mm:ss[.ddddddddd]"); /* * Undo all shifts */ main_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_container_add(GTK_CONTAINER(main_vb), main_hb); gtk_widget_show(main_hb); types_frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(main_hb), types_frame, TRUE, TRUE, 0); gtk_widget_show(types_frame); types_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE); gtk_container_set_border_width(GTK_CONTAINER(types_vb), 3); gtk_container_add(GTK_CONTAINER(types_frame), types_vb); gtk_widget_show(types_vb); /* time shift type row */ undo_type_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_container_add(GTK_CONTAINER(types_vb), undo_type_hb); gtk_widget_show(undo_type_hb); /* time shift row */ undo_offset_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_box_pack_start(GTK_BOX(types_vb), undo_offset_hb, FALSE, FALSE, 0); gtk_widget_show(undo_offset_hb); undo_rb = gtk_radio_button_new_with_label(gtk_radio_button_get_group( GTK_RADIO_BUTTON(timeshift_rb)), "Undo all shifts"); gtk_box_pack_start(GTK_BOX(undo_offset_hb), undo_rb, TRUE, TRUE, 0); gtk_widget_show(undo_rb); gtk_widget_set_tooltip_text(undo_rb, "Undo all the Time Shift offsets on the frames."); /* * Button row */ bbox = dlg_button_row_new(GTK_STOCK_APPLY, GTK_STOCK_CLOSE, GTK_STOCK_HELP, NULL); gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 0); gtk_widget_show(bbox); apply_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_APPLY); g_signal_connect(apply_bt, "clicked", G_CALLBACK(time_shift_apply_cb), time_shift_frame_w); gtk_widget_set_tooltip_text(apply_bt, "Apply the Time Shift options to the frame data."); close_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLOSE); g_signal_connect(close_bt, "clicked", G_CALLBACK(time_shift_close_cb), time_shift_frame_w); gtk_widget_set_tooltip_text(close_bt, "Close this dialogbox."); help_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP); g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb), (gpointer)HELP_TIME_SHIFT_DIALOG); gtk_widget_set_tooltip_text(help_bt, "Help on how the Time Shift feature works."); /* Link everything together */ g_object_set_data(G_OBJECT(time_shift_frame_w), E_TIMESHIFT_SELECT, timeshift_rb); g_object_set_data(G_OBJECT(time_shift_frame_w), E_TIMESHIFT_OFFSET_KEY, timeshift_offset_text_box); g_object_set_data(G_OBJECT(time_shift_frame_w), E_SETTIME_SELECT, settime_rb); g_object_set_data(G_OBJECT(time_shift_frame_w), E_SETTIME_TIME_KEY, settime_time_text_box); g_object_set_data(G_OBJECT(time_shift_frame_w), E_SETTIME_PACKETNUMBER_KEY, settime_packetnumber_text_box); g_object_set_data(G_OBJECT(time_shift_frame_w), E_ADJTIME_SELECT, adjtime_rb); g_object_set_data(G_OBJECT(time_shift_frame_w), E_ADJTIME_TIME1_KEY, adjtime_time1_text_box); g_object_set_data(G_OBJECT(time_shift_frame_w), E_ADJTIME_PACKETNUMBER1_KEY, adjtime_packetnumber1_text_box); g_object_set_data(G_OBJECT(time_shift_frame_w), E_ADJTIME_TIME2_KEY, adjtime_time2_text_box); g_object_set_data(G_OBJECT(time_shift_frame_w), E_ADJTIME_PACKETNUMBER2_KEY, adjtime_packetnumber2_text_box); g_object_set_data(G_OBJECT(time_shift_frame_w), E_UNDO_SELECT, undo_rb); dlg_set_activate(timeshift_offset_text_box, apply_bt); /* Give the initial focus to the "offset" entry box. */ gtk_widget_grab_focus(timeshift_offset_text_box); g_signal_connect(time_shift_frame_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL); g_signal_connect(time_shift_frame_w, "destroy", G_CALLBACK(time_shift_frame_destroy_cb), NULL); gtk_widget_show(time_shift_frame_w); window_present(time_shift_frame_w); } static void error_message(const gchar *msg) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", msg); } static int action_timeshift(GtkWindow *parent_w); static void action_settime(GtkWindow *parent_w); static void action_adjtime(GtkWindow *parent_w); static void action_undo(GtkWindow *parent_w); static void time_shift_apply_cb(GtkWidget *ok_bt _U_, GtkWindow *parent_w) { GtkWidget *flag_rb; if (cfile.state == FILE_CLOSED) { /* Nothing to do here */ return; } if (cfile.state == FILE_READ_IN_PROGRESS) { error_message("The Time Shift functions are not available on live captures."); return; } flag_rb = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w), E_TIMESHIFT_SELECT); if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(flag_rb)) == TRUE) { action_timeshift(parent_w); return; } flag_rb = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w), E_SETTIME_SELECT); if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(flag_rb)) == TRUE) { action_settime(parent_w); return; } flag_rb = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w), E_ADJTIME_SELECT); if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(flag_rb)) == TRUE) { action_adjtime(parent_w); return; } flag_rb = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w), E_UNDO_SELECT); if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(flag_rb)) == TRUE) { action_undo(parent_w); return; } } #define CHECK_YEARS(Y) \ if (Y < 1970) { \ error_message("years must be larger than 1970"); \ return(1); \ } #define CHECK_MONTHS(M) \ if (M < 1 || M > 12) { \ error_message("months must be between [1..12]"); \ return(1); \ } #define CHECK_DAYS(D) \ if (D < 1 || D > 31) { \ error_message("days must be between [1..31]"); \ return(1); \ } #define CHECK_HOURS(h) \ if (h < 0 || h > 23) { \ error_message("hours must be between [0..23]"); \ return(1); \ } #define CHECK_HOUR(h) \ if (h < 0) { \ error_message("negative hours, you have have specified more than " \ "one minus character?"); \ return(1); \ } \ offset_float += h * 3600 #define CHECK_MINUTE(m) \ if (m < 0 || m > 59) { \ error_message("minutes must be between [0..59]"); \ return(1); \ } \ offset_float += m * 60 #define CHECK_SECOND(s) \ if (s < 0 || s > 59) { \ error_message("seconds must be between [0..59]"); \ return(1); \ } \ offset_float += s #define CHECK_SEC_DEC(f) \ if (f < 0) { \ error_message("fractional seconds must be > 0"); \ return(1); \ } \ offset_float += f static int action_timeshift(GtkWindow *parent_w) { GtkWidget *offset_te; const gchar *offset_text; gchar *poffset_text; nstime_t offset; long double offset_float = 0; guint32 i; frame_data *fd; int neg; int h, m; long double f; /* * The following offset types are allowed: * -?((hh:)mm:)ss(.decimals)? * * Since Wireshark doesn't support regular expressions (please prove me * wrong :-) we will have to figure it out ourselves in the * following order: * * 1. hh:mm:ss.decimals * 2. mm:ss.decimals * 3. ss.decimals * */ offset_te = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w), E_TIMESHIFT_OFFSET_KEY); offset_text = gtk_entry_get_text(GTK_ENTRY(offset_te)); poffset_text = (gchar *)offset_text; /* strip whitespace */ while (isspace(poffset_text[0])) ++poffset_text; /* check for minus sign */ neg = FALSE; if (poffset_text[0] == '-') { neg = TRUE; poffset_text++; } /* check for empty string */ if (poffset_text[0] == '\0') return(1); h = m = 0; f = 0.0; if (sscanf(poffset_text, "%d:%d:%Lf", &h, &m, &f) == 3) { /* printf("%%d:%%d:%%d.%%d\n"); */ CHECK_HOUR(h); CHECK_MINUTE(m); CHECK_SEC_DEC(f); } else if (sscanf(poffset_text, "%d:%Lf", &m, &f) == 2) { /* printf("%%d:%%d.%%d\n"); */ CHECK_MINUTE(m); CHECK_SEC_DEC(f); } else if (sscanf(poffset_text, "%Lf", &f) == 1) { /* printf("%%d.%%d\n"); */ CHECK_SEC_DEC(f); } else { error_message("Could not parse the time: Expected ((hh:)mm:)ss.(dec)."); return(1); } if (offset_float == 0) return(1); nstime_set_zero(&offset); offset.secs = (time_t)floorl(offset_float); offset_float -= offset.secs; offset.nsecs = (int)(offset_float * 1000000000); if ((fd = frame_data_sequence_find(cfile.frames, 1)) == NULL) return(1); /* Shouldn't happen */ modify_time_init(fd); for (i = 1; i <= cfile.count; i++) { if ((fd = frame_data_sequence_find(cfile.frames, i)) == NULL) continue; /* Shouldn't happen */ modify_time_perform(fd, neg, &offset, SHIFT_KEEPOFFSET); } new_packet_list_queue_draw(); return(0); } static int timestring2nstime(const gchar *ts, nstime_t *packettime, nstime_t *nstime) { gchar *pts; int h, m, Y, M, D; long double f; struct tm tm, *tmptm; time_t tt; long double offset_float = 0; /* * The following time format is allowed: * [YYYY-MM-DD] hh:mm:ss(.decimals)? * * Since Wireshark doesn't support regular expressions (please prove me * wrong :-) we will have to figure it out ourselves in the * following order: * * 1. YYYY-MM-DD hh:mm:ss.decimals * 2. hh:mm:ss.decimals * */ pts = (gchar *)ts; /* strip whitespace */ while (isspace(pts[0])) ++pts; /* check for empty string */ if (pts[0] == '\0') return(1); if (sscanf(pts, "%d-%d-%d %d:%d:%Lf", &Y, &M, &D, &h, &m, &f) == 6) { /* printf("%%d-%%d-%%d %%d:%%d:%%f\n"); */ CHECK_YEARS(Y); CHECK_MONTHS(M); CHECK_DAYS(D); CHECK_HOURS(h); CHECK_MINUTE(m); CHECK_SEC_DEC(f); } else if (sscanf(pts, "%d:%d:%Lf", &h, &m, &f) == 3) { /* printf("%%d:%%d:%%f\n"); */ Y = M = D = 0; CHECK_HOUR(h); CHECK_MINUTE(m); CHECK_SEC_DEC(f); } else { error_message("Could not parse the time: Expected (YYYY-MM-DD) " "hh:mm:ss(.dec)"); return(1); } /* Convert the time entered in an epoch offset */ tmptm = localtime(&(packettime->secs)); if (tmptm) { tm = *tmptm; } else { memset (&tm, 0, sizeof (tm)); } if (Y != 0) { tm.tm_year = Y - 1900; tm.tm_mon = M - 1; tm.tm_mday = D; } tm.tm_hour = h; tm.tm_min = m; tm.tm_sec = (int)floorl(f); tt = mktime(&tm); if (tt == -1) { error_message("mktime went wrong. Was the time invalid?"); return(1); } nstime->secs = tt; f -= tm.tm_sec; nstime->nsecs = (int)(f * 1000000000); return(0); } static void action_settime(GtkWindow *parent_w) { GtkWidget *packetnumber_te; const gchar *packetnumber_text; long packetnumber; GtkWidget *time_te; const gchar *time_text; nstime_t settime, difftime, packettime; frame_data *fd, *packetfd; guint32 i; packetnumber_te = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w), E_SETTIME_PACKETNUMBER_KEY); packetnumber_text = gtk_entry_get_text(GTK_ENTRY(packetnumber_te)); packetnumber = strtol((char *)packetnumber_text, NULL, 10); time_te = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w), E_SETTIME_TIME_KEY); time_text = gtk_entry_get_text(GTK_ENTRY(time_te)); /* * Get a copy of the real time (abs_ts - shift_offset) do we can find out the * difference between the specified time and the original packet */ if ((packetfd = frame_data_sequence_find(cfile.frames, packetnumber)) == NULL) return; nstime_delta(&packettime, &(packetfd->abs_ts), &(packetfd->shift_offset)); if (timestring2nstime(time_text, &packettime, &settime) != 0) return; /* Calculate difference between packet time and requested time */ nstime_delta(&difftime, &settime, &packettime); /* Up to here nothing is changed */ if ((fd = frame_data_sequence_find(cfile.frames, 1)) == NULL) return; /* Shouldn't happen */ modify_time_init(fd); /* Set everything back to the original time */ for (i = 1; i <= cfile.count; i++) { if ((fd = frame_data_sequence_find(cfile.frames, i)) == NULL) continue; /* Shouldn't happen */ modify_time_perform(fd, SHIFT_POS, &difftime, SHIFT_SETTOZERO); } new_packet_list_queue_draw(); } /* * If the line between (OT1, NT1) and (OT2, NT2) is a straight line * and (OT3, NT3) is on that line, * then (NT2 - NT1) / (OT2 - OT2) = (NT3 - NT1) / (OT3 - OT1) and * then (OT3 - OT1) * (NT2 - NT1) / (OT2 - OT2) = (NT3 - NT1) and * then NT1 + (OT3 - OT1) * (NT2 - NT1) / (OT2 - OT2) = NT3 and * then NT3 = NT1 + (OT3 - OT1) * (NT2 - NT1) / (OT2 - OT2) and * thus NT3 = NT1 + (OT3 - OT1) * (NT2 - NT1) / (OT2 - OT1) * or NT3 = NT1 + (OT3 - OT1) * ( deltaNT12 / deltaOT12) * * All the things you come up when waiting for the train to come... */ static void calcNT3(nstime_t *OT1, nstime_t *OT3, nstime_t *NT1, nstime_t *NT3, nstime_t *deltaOT, nstime_t *deltaNT) { long double fnt, fot, f, secs, nsecs; fnt = (long double)deltaNT->secs + (deltaNT->nsecs / 1000000000.0L); fot = (long double)deltaOT->secs + (deltaOT->nsecs / 1000000000.0L); f = fnt / fot; nstime_copy(NT3, OT3); nstime_subtract(NT3, OT1); secs = f * (long double)NT3->secs; nsecs = f * (long double)NT3->nsecs; nsecs += (secs - floorl(secs)) * 1000000000.0L; while (nsecs > 1000000000L) { secs += 1; nsecs -= 1000000000L; } while (nsecs < 0) { secs -= 1; nsecs += 1000000000L; } NT3->secs = (time_t)secs; NT3->nsecs = (int)nsecs; nstime_add(NT3, NT1); } static void action_adjtime(GtkWindow *parent_w _U_) { GtkWidget *packetnumber_te; const gchar *packetnumber_text; long packetnumber1, packetnumber2; GtkWidget *time_te; const gchar *time1_text, *time2_text; nstime_t nt1, nt2, ot1, ot2, nt3; nstime_t dnt, dot, d3t; frame_data *fd, *packet1fd, *packet2fd; guint32 i; packetnumber_te = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w), E_ADJTIME_PACKETNUMBER1_KEY); packetnumber_text = gtk_entry_get_text(GTK_ENTRY(packetnumber_te)); packetnumber1 = strtol((char *)packetnumber_text, NULL, 10); packetnumber_te = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w), E_ADJTIME_PACKETNUMBER2_KEY); packetnumber_text = gtk_entry_get_text(GTK_ENTRY(packetnumber_te)); packetnumber2 = strtol((char *)packetnumber_text, NULL, 10); /* * The following time format is allowed: * [YYYY-MM-DD] hh:mm:ss(.decimals)? * * Since Wireshark doesn't support regular expressions (please prove me * wrong :-) we will have to figure it out ourselves in the * following order: * * 1. YYYY-MM-DD hh:mm:ss.decimals * 2. hh:mm:ss.decimals * */ time_te = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w), E_ADJTIME_TIME1_KEY); time1_text = gtk_entry_get_text(GTK_ENTRY(time_te)); time_te = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w), E_ADJTIME_TIME2_KEY); time2_text = gtk_entry_get_text(GTK_ENTRY(time_te)); /* * Get a copy of the real time (abs_ts - shift_offset) do we can find out the * difference between the specified time and the original packet */ if ((packet1fd = frame_data_sequence_find(cfile.frames, packetnumber1)) == NULL) return; nstime_copy(&ot1, &(packet1fd->abs_ts)); nstime_subtract(&ot1, &(packet1fd->shift_offset)); if (timestring2nstime(time1_text, &ot1, &nt1) != 0) return; /* * Get a copy of the real time (abs_ts - shift_offset) do we can find out the * difference between the specified time and the original packet */ if ((packet2fd = frame_data_sequence_find(cfile.frames, packetnumber2)) == NULL) return; nstime_copy(&ot2, &(packet2fd->abs_ts)); nstime_subtract(&ot2, &(packet2fd->shift_offset)); if (timestring2nstime(time2_text, &ot2, &nt2) != 0) return; nstime_copy(&dot, &ot2); nstime_subtract(&dot, &ot1); nstime_copy(&dnt, &nt2); nstime_subtract(&dnt, &nt1); /* Up to here nothing is changed */ if ((fd = frame_data_sequence_find(cfile.frames, 1)) == NULL) return; /* Shouldn't happen */ modify_time_init(fd); for (i = 1; i <= cfile.count; i++) { if ((fd = frame_data_sequence_find(cfile.frames, i)) == NULL) continue; /* Shouldn't happen */ /* Set everything back to the original time */ nstime_subtract(&(fd->abs_ts), &(fd->shift_offset)); nstime_set_zero(&(fd->shift_offset)); /* Add the difference to each packet */ calcNT3(&ot1, &(fd->abs_ts), &nt1, &nt3, &dot, &dnt); nstime_copy(&d3t, &nt3); nstime_subtract(&d3t, &(fd->abs_ts)); modify_time_perform(fd, SHIFT_POS, &d3t, SHIFT_SETTOZERO); } new_packet_list_queue_draw(); } static void action_undo(GtkWindow *parent_w _U_) { guint32 i; frame_data *fd; nstime_t nulltime; nulltime.secs = nulltime.nsecs = 0; if ((fd = frame_data_sequence_find(cfile.frames, 1)) == NULL) return; /* Shouldn't happen */ modify_time_init(fd); for (i = 1; i <= cfile.count; i++) { if ((fd = frame_data_sequence_find(cfile.frames, i)) == NULL) continue; /* Shouldn't happen */ modify_time_perform(fd, SHIFT_NEG, &nulltime, SHIFT_SETTOZERO); } new_packet_list_queue_draw(); } static void time_shift_close_cb(GtkWidget *close_bt _U_, gpointer parent_w _U_) { gtk_grab_remove(GTK_WIDGET(parent_w)); window_destroy(GTK_WIDGET(parent_w)); } static void time_shift_frame_destroy_cb(GtkWidget *win _U_, gpointer user_data _U_) { /* Note that we no longer have a "Time Shift" dialog box. */ time_shift_frame_w = NULL; } static void modify_time_init(frame_data *fd) { modify_time_perform(fd, SHIFT_NEG, NULL, SHIFT_KEEPOFFSET); } static void modify_time_perform(frame_data *fd, int neg, nstime_t *offset, int settozero) { static frame_data *first_packet = NULL; static frame_data *lastdisplayed_packet = NULL; static frame_data *prevcaptured_packet = NULL; static nstime_t nulltime; /* Only for initializing */ if (offset == NULL) { first_packet = fd; lastdisplayed_packet = NULL; prevcaptured_packet = NULL; nulltime.secs = nulltime.nsecs = 0; return; } if (first_packet == NULL) { fprintf(stderr, "modify_time_perform: not initialized?\n"); return; } /* The actual shift */ if (settozero == SHIFT_SETTOZERO) { nstime_subtract(&(fd->abs_ts), &(fd->shift_offset)); nstime_copy(&(fd->shift_offset), &nulltime); } if (neg == SHIFT_POS) { nstime_add(&(fd->abs_ts), offset); nstime_add(&(fd->shift_offset), offset); } else if (neg == SHIFT_NEG) { nstime_subtract(&(fd->abs_ts), offset); nstime_subtract(&(fd->shift_offset), offset); } else { fprintf(stderr, "modify_time_perform: neg = %d?\n", neg); } /* * rel_ts - Relative timestamp to first packet * del_dis_ts - Delta timestamp to previous displayed frame * del_cap_ts - Delta timestamp to previous captured frame */ if (first_packet != NULL) { nstime_copy(&(fd->rel_ts), &(fd->abs_ts)); nstime_subtract(&(fd->rel_ts), &(first_packet->abs_ts)); } else nstime_copy(&(fd->rel_ts), &nulltime); if (prevcaptured_packet != NULL) { nstime_copy(&(fd->del_cap_ts), &(fd->abs_ts)); nstime_subtract(&(fd->del_cap_ts), &(prevcaptured_packet->abs_ts)); } else nstime_copy(&(fd->del_cap_ts), &nulltime); if (lastdisplayed_packet != NULL) { nstime_copy(&(fd->del_dis_ts), &(fd->abs_ts)); nstime_subtract(&(fd->del_dis_ts), &(lastdisplayed_packet->abs_ts)); } else nstime_copy(&(fd->del_dis_ts), &nulltime); prevcaptured_packet = fd; if (fd->flags.passed_dfilter) lastdisplayed_packet = fd; }