gtk/flow_graph.c

   1 /* flow_graph.c
   2  * $Id$
   3  * Allows to display a flow graph of the currently displayed packets
   4  *
   5  * Copyright 2004, Ericsson , Spain
   6  * By Francisco Alcoba <francisco.alcoba@ericsson.com>
   7  *
   8  * Wireshark - Network traffic analyzer
   9  * By Gerald Combs <gerald@wireshark.org>
  10  * Copyright 1998 Gerald Combs
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation,  Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 #  include <config.h>
  29 #endif
  30 #include <string.h>
  31
  32 #include <gtk/gtk.h>
  33
  34 #include <epan/epan.h>
  35 #include <epan/packet.h>
  36 #include <epan/filesystem.h>
  37 #include <epan/stat_cmd_args.h>
  38 #include <epan/to_str.h>
  39 #include <epan/tap.h>
  40 #include <epan/dissectors/packet-tcp.h>
  41 #include <epan/strutil.h>
  42
  43 #include "../stat_menu.h"
  44 #include "../simple_dialog.h"
  45
  46 #include "gtk/graph_analysis.h"
  47 #include "gtk/gui_stat_menu.h"
  48 #include "gtk/dlg_utils.h"
  49 #include "gtk/gui_utils.h"
  50 #include "gtk/stock_icons.h"
  51 #include "gtk/gtkglobals.h"
  52 #include "gtk/main.h"
  53
  54
  55
  56 #define TYPE_OF_PACKETS_DISPLAYED 0
  57 #define TYPE_OF_PACKETS_ALL 1
  58
  59 #define TYPE_OF_FLOW_GENERAL 0
  60 #define TYPE_OF_FLOW_TCP 1
  61
  62 #define NODE_ADDR_TYPE_SRCDST 0
  63 #define NODE_ADDR_TYPE_NET_SRCDST 1
  64
  65 static int type_of_packets = TYPE_OF_PACKETS_DISPLAYED;
  66 static int type_of_flow    = TYPE_OF_FLOW_GENERAL;
  67 static int node_addr_type  = NODE_ADDR_TYPE_SRCDST;
  68
  69 static int tap_identifier;
  70 static gboolean have_frame_tap_listener=FALSE;
  71 static gboolean have_tcp_tap_listener=FALSE;
  72 static graph_analysis_info_t *graph_analysis = NULL;
  73 static graph_analysis_data_t *graph_analysis_data = NULL;
  74
  75 static GtkWidget *flow_graph_dlg = NULL;
  76
  77 static GtkWidget *select_all_rb;
  78 static GtkWidget *select_displayed_rb;
  79 static GtkWidget *select_general_rb;
  80 static GtkWidget *select_tcp_rb;
  81 static GtkWidget *src_dst_rb;
  82 static GtkWidget *net_src_dst_rb;
  83
  84 /****************************************************************************/
  85 /* free up memory and initialize the pointers */
  86
  87 static void
  88 flow_graph_reset(void *ptr _U_)
  89 {
  90         graph_analysis_item_t *graph_item;
  91
  92         GList* list;
  93
  94         if (graph_analysis !=NULL){
  95
  96                 /* free the graph data items */
  97                 list = g_list_first(graph_analysis->list);
  98                 while (list)
  99                 {
 100                         graph_item = list->data;
 101                         g_free(graph_item->frame_label);
 102                         g_free(graph_item->comment);
 103                         g_free(list->data);
 104                         list = g_list_next(list);
 105                 }
 106                 g_list_free(graph_analysis->list);
 107                 graph_analysis->nconv = 0;
 108                 graph_analysis->list = NULL;
 109         }
 110 }
 111
 112 /****************************************************************************/
 113 static void
 114 flow_graph_data_init(void) {
 115         graph_analysis = g_malloc(sizeof(graph_analysis_info_t));
 116         graph_analysis->nconv = 0;
 117         graph_analysis->list = NULL;
 118 }
 119
 120
 121 /****************************************************************************/
 122 static void
 123 remove_tap_listener_flow_graph(void)
 124 {
 125         protect_thread_critical_region();
 126         remove_tap_listener(&(tap_identifier));
 127         unprotect_thread_critical_region();
 128
 129         have_frame_tap_listener=FALSE;
 130         have_tcp_tap_listener=FALSE;
 131 }
 132
 133
 134 /****************************************************************************/
 135 /* CALLBACKS                                                                */
 136 /****************************************************************************/
 137 static void
 138 flow_graph_on_destroy(GtkObject *object _U_, gpointer user_data _U_)
 139 {
 140         /* remove_tap_listeners */
 141         remove_tap_listener_flow_graph();
 142
 143         /* Clean up memory used by tap */
 144         flow_graph_reset(NULL);
 145
 146         g_assert(graph_analysis != NULL);
 147         g_assert(graph_analysis_data != NULL);
 148
 149         g_free(graph_analysis);
 150         graph_analysis = NULL;
 151
 152         g_free(graph_analysis_data);
 153         graph_analysis_data = NULL;
 154
 155         /* Note that we no longer have a "Flow Graph" dialog box. */
 156         flow_graph_dlg = NULL;
 157 }
 158
 159
 160 /****************************************************************************/
 161 static void
 162 toggle_select_all(GtkWidget *widget _U_, gpointer user_data _U_)
 163 {
 164         /* is the button now active? */
 165         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(select_all_rb))) {
 166                 type_of_packets = TYPE_OF_PACKETS_ALL;
 167         }
 168 }
 169
 170 /****************************************************************************/
 171 static void
 172 toggle_select_displayed(GtkWidget *widget _U_, gpointer user_data _U_)
 173 {
 174         /* is the button now active? */
 175         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(select_displayed_rb))) {
 176                 type_of_packets = TYPE_OF_PACKETS_DISPLAYED;
 177         }
 178 }
 179
 180 /****************************************************************************/
 181 static void
 182 toggle_select_general(GtkWidget *widget _U_, gpointer user_data _U_)
 183 {
 184         /* is the button now active? */
 185         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(select_general_rb))) {
 186                 type_of_flow = TYPE_OF_FLOW_GENERAL;
 187         }
 188 }
 189
 190 /****************************************************************************/
 191 static void
 192 toggle_select_tcp(GtkWidget *widget _U_, gpointer user_data _U_)
 193 {
 194         /* is the button now active? */
 195         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(select_tcp_rb))) {
 196                 type_of_flow = TYPE_OF_FLOW_TCP;
 197         }
 198 }
 199
 200 /****************************************************************************/
 201 static void
 202 toggle_select_srcdst(GtkWidget *widget _U_, gpointer user_data _U_)
 203 {
 204         /* is the button now active? */
 205         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(src_dst_rb))) {
 206                 node_addr_type = NODE_ADDR_TYPE_SRCDST;
 207         }
 208 }
 209
 210 /****************************************************************************/
 211 static void
 212 toggle_select_netsrcdst(GtkWidget *widget _U_, gpointer user_data _U_)
 213 {
 214         /* is the button now active? */
 215         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(net_src_dst_rb))) {
 216                 node_addr_type = NODE_ADDR_TYPE_NET_SRCDST;
 217         }
 218 }
 219
 220 /****************************************************************************/
 221 /* Add a new frame into the graph */
 222 static int
 223 flow_graph_frame_add_to_graph(packet_info *pinfo)
 224 {
 225         graph_analysis_item_t *gai;
 226         int i;
 227         gchar *protocol;
 228         gchar *colinfo;
 229
 230         protocol=NULL;
 231         colinfo=NULL;
 232
 233         if (node_addr_type == NODE_ADDR_TYPE_NET_SRCDST) {
 234                 if (pinfo->net_src.type!=AT_NONE && pinfo->net_dst.type!=AT_NONE) {
 235                         gai = g_malloc(sizeof(graph_analysis_item_t));
 236                         COPY_ADDRESS(&(gai->src_addr),&(pinfo->net_src));
 237                         COPY_ADDRESS(&(gai->dst_addr),&(pinfo->net_dst));
 238                 }
 239                 else return 0;
 240
 241         } else {
 242                 if (pinfo->src.type!=AT_NONE && pinfo->dst.type!=AT_NONE) {
 243                         gai = g_malloc(sizeof(graph_analysis_item_t));
 244                         COPY_ADDRESS(&(gai->src_addr),&(pinfo->src));
 245                         COPY_ADDRESS(&(gai->dst_addr),&(pinfo->dst));
 246                 }
 247                 else return 0;
 248         }
 249
 250         gai->frame_num = pinfo->fd->num;
 251         gai->time= nstime_to_sec(&pinfo->fd->rel_ts);
 252
 253         gai->port_src=pinfo->srcport;
 254         gai->port_dst=pinfo->destport;
 255         gai->comment=NULL;
 256         gai->frame_label=NULL;
 257
 258         /* this code doesn't make sense.
 259         g_free(gai->comment);
 260         g_free(gai->frame_label);
 261         */
 262
 263         if(pinfo->cinfo) {
 264                 if (pinfo->cinfo->col_first[COL_INFO]>=0){
 265
 266                         for (i = pinfo->cinfo->col_first[COL_INFO]; i <= pinfo->cinfo->col_last[COL_INFO]; i++) {
 267                                 if (pinfo->cinfo->fmt_matx[i][COL_INFO]) {
 268                                         colinfo = g_strdup(pinfo->cinfo->col_data[i]);
 269                                         /* break; ? or g_free(colinfo); before g_strdup() */
 270                                 }
 271                         }
 272                 }
 273
 274                 if (pinfo->cinfo->col_first[COL_PROTOCOL]>=0){
 275
 276                         for (i = pinfo->cinfo->col_first[COL_PROTOCOL]; i <= pinfo->cinfo->col_last[COL_PROTOCOL]; i++) {
 277                                 if (pinfo->cinfo->fmt_matx[i][COL_PROTOCOL]) {
 278                                         protocol = g_strdup(pinfo->cinfo->col_data[i]);
 279                                         /* break; ? or g_free(protocol); before g_strdup() */
 280                                 }
 281                         }
 282                 }
 283         }
 284
 285         if (colinfo != NULL) {
 286                 if (protocol != NULL) {
 287                         gai->frame_label = g_strdup_printf("%.19s", colinfo);
 288                         gai->comment = g_strdup_printf("%s: %s", protocol, colinfo);
 289                 } else {
 290                         gai->frame_label = g_strdup_printf("%.19s", colinfo);
 291                         gai->comment = g_strdup_printf("%s", colinfo);
 292                 }
 293         } else {
 294                 /* This will probably never happen...*/
 295                 if (protocol != NULL) {
 296                         gai->frame_label = g_strdup_printf("%.19s", protocol);
 297                         gai->comment = g_strdup_printf("%s", protocol);
 298                 }
 299         }
 300
 301         g_free(protocol);
 302         g_free(colinfo);
 303
 304         gai->line_style=1;
 305         gai->conv_num=0;
 306         gai->display=TRUE;
 307
 308         graph_analysis->list = g_list_append(graph_analysis->list, gai);
 309
 310         return 1;
 311 }
 312
 313 /****************************************************************************/
 314 /* Add a new tcp frame into the graph */
 315 static int
 316 flow_graph_tcp_add_to_graph(packet_info *pinfo, const struct tcpheader *tcph)
 317 {
 318         graph_analysis_item_t *gai;
 319         /* copied from packet-tcp */
 320         const gchar *fstr[] = {"FIN", "SYN", "RST", "PSH", "ACK", "URG", "ECN", "CWR" };
 321         guint i, bpos;
 322         gboolean flags_found = FALSE;
 323         gchar flags[64];
 324
 325         gai = g_malloc(sizeof(graph_analysis_item_t));
 326         gai->frame_num = pinfo->fd->num;
 327         gai->time= nstime_to_sec(&pinfo->fd->rel_ts);
 328         if (node_addr_type == NODE_ADDR_TYPE_NET_SRCDST) {
 329                 COPY_ADDRESS(&(gai->src_addr),&(pinfo->net_src));
 330                 COPY_ADDRESS(&(gai->dst_addr),&(pinfo->net_dst));
 331         } else {
 332                 COPY_ADDRESS(&(gai->src_addr),&(pinfo->src));
 333                 COPY_ADDRESS(&(gai->dst_addr),&(pinfo->dst));
 334         }
 335         gai->port_src=pinfo->srcport;
 336         gai->port_dst=pinfo->destport;
 337
 338         flags[0] = '\0';
 339         for (i = 0; i < 8; i++) {
 340                 bpos = 1 << i;
 341                 if (tcph->th_flags & bpos) {
 342                         if (flags_found) {
 343                                 g_strlcat(flags, ", ", sizeof(flags));
 344                         }
 345                         g_strlcat(flags, fstr[i], sizeof(flags));
 346                         flags_found = TRUE;
 347                 }
 348         }
 349         if (flags[0] == '\0') {
 350                 g_snprintf (flags, sizeof(flags), "<None>");
 351         }
 352
 353         if ((tcph->th_have_seglen)&&(tcph->th_seglen!=0)){
 354                 gai->frame_label = g_strdup_printf("%s - Len: %u",flags, tcph->th_seglen);
 355         }
 356         else{
 357                 gai->frame_label = g_strdup(flags);
 358         }
 359
 360         if (tcph->th_flags & TH_ACK)
 361                 gai->comment = g_strdup_printf("Seq = %u Ack = %u",tcph->th_seq, tcph->th_ack);
 362         else
 363                 gai->comment = g_strdup_printf("Seq = %u",tcph->th_seq);
 364
 365         gai->line_style=1;
 366         gai->conv_num=0;
 367         gai->display=TRUE;
 368
 369         graph_analysis->list = g_list_append(graph_analysis->list, gai);
 370
 371         return 1;
 372 }
 373
 374
 375
 376 /****************************************************************************/
 377 /* whenever a frame packet is seen by the tap listener */
 378 static gboolean
 379 flow_graph_frame_packet( void *ptr _U_, packet_info *pinfo, epan_dissect_t *edt _U_, const void *dummy _U_)
 380 {
 381         if ((type_of_packets == TYPE_OF_PACKETS_ALL)||(pinfo->fd->flags.passed_dfilter==1)){
 382                 flow_graph_frame_add_to_graph(pinfo);
 383         }
 384
 385         return TRUE;
 386 }
 387
 388 /****************************************************************************/
 389 /* whenever a TCP packet is seen by the tap listener */
 390 static gboolean
 391 flow_graph_tcp_packet( void *ptr _U_, packet_info *pinfo, epan_dissect_t *edt _U_, const void *tcp_info)
 392 {
 393         const struct tcpheader *tcph = tcp_info;
 394
 395         if ((type_of_packets == TYPE_OF_PACKETS_ALL)||(pinfo->fd->flags.passed_dfilter==1)){
 396                 flow_graph_tcp_add_to_graph(pinfo,tcph);
 397         }
 398
 399         return TRUE;
 400 }
 401
 402
 403 static void
 404 flow_graph_packet_draw(void *prs _U_)
 405 {
 406         return;
 407 }
 408
 409 /****************************************************************************/
 410 static void
 411 flow_graph_on_ok                    (GtkButton       *button _U_,
 412                                      gpointer         user_data)
 413 {
 414         if ((have_frame_tap_listener==TRUE)
 415                 ||(have_tcp_tap_listener==TRUE))
 416         {
 417                 /* remove_tap_listeners */
 418                 remove_tap_listener_flow_graph();
 419         }
 420
 421         /* Scan for displayed packets (retap all packets) */
 422
 423         if (type_of_flow == TYPE_OF_FLOW_GENERAL){
 424                 /* Register the tap listener */
 425
 426                 if(have_frame_tap_listener==FALSE)
 427                 {
 428                         /* don't register tap listener, if we have it already */
 429                         register_tap_listener("frame", &tap_identifier, NULL,
 430                                 TL_REQUIRES_COLUMNS,
 431                                 flow_graph_reset,
 432                                 flow_graph_frame_packet,
 433                                 flow_graph_packet_draw
 434                                 );
 435                         have_frame_tap_listener=TRUE;
 436                 }
 437
 438                 cf_retap_packets(&cfile);
 439         }
 440         else if (type_of_flow == TYPE_OF_FLOW_TCP){
 441         /* Register the tap listener */
 442
 443                 if(have_tcp_tap_listener==FALSE)
 444                 {
 445                         /* don't register tap listener, if we have it already */
 446                         register_tap_listener("tcp", &tap_identifier, NULL,
 447                                 0,
 448                                 flow_graph_reset,
 449                                 flow_graph_tcp_packet,
 450                                 flow_graph_packet_draw
 451                                 );
 452                         have_tcp_tap_listener=TRUE;
 453                 }
 454
 455                 cf_retap_packets(&cfile);
 456         }
 457
 458         if (graph_analysis_data->dlg.window != NULL){ /* if we still have a window */
 459                 graph_analysis_update(graph_analysis_data);             /* refresh it xxx */
 460         }
 461         else{
 462                 graph_analysis_data->dlg.parent_w = user_data;
 463                 graph_analysis_create(graph_analysis_data);
 464         }
 465 }
 466
 467
 468 /****************************************************************************/
 469 /* INTERFACE                                                                */
 470 /****************************************************************************/
 471
 472 static void
 473 flow_graph_dlg_create (void)
 474 {
 475         GtkWidget *flow_graph_dlg_w;
 476         GtkWidget *main_vb;
 477         GtkWidget *hbuttonbox;
 478         GtkWidget *bt_cancel, *bt_ok;
 479 #if 0
 480         GtkWidget *top_label = NULL;
 481 #endif
 482         GtkWidget *flow_type_fr, *range_fr, *range_tb, *flow_type_tb, *node_addr_fr, *node_addr_tb;
 483
 484
 485         GtkTooltips *tooltips = gtk_tooltips_new();
 486
 487         flow_graph_dlg_w = dlg_window_new("Wireshark: Flow Graph");  /* transient_for top_level */
 488         gtk_window_set_destroy_with_parent (GTK_WINDOW(flow_graph_dlg_w), TRUE);
 489
 490         gtk_window_set_default_size(GTK_WINDOW(flow_graph_dlg_w), 250, 150);
 491
 492         main_vb = gtk_vbox_new (FALSE, 0);
 493         gtk_container_add(GTK_CONTAINER(flow_graph_dlg_w), main_vb);
 494         gtk_container_set_border_width (GTK_CONTAINER (main_vb), 7);
 495
 496 #if 0
 497         top_label = gtk_label_new ("Choose packets to include in the graph");
 498         gtk_box_pack_start (GTK_BOX (main_vb), top_label, FALSE, FALSE, 8);
 499 #endif
 500
 501         gtk_widget_show(flow_graph_dlg_w);
 502
 503         /*** Packet range frame ***/
 504         range_fr = gtk_frame_new("Choose packets");
 505         gtk_box_pack_start(GTK_BOX(main_vb), range_fr, FALSE, FALSE, 5);
 506
 507         range_tb = gtk_table_new(4, 4, FALSE);
 508         gtk_container_set_border_width(GTK_CONTAINER(range_tb), 5);
 509         gtk_container_add(GTK_CONTAINER(range_fr), range_tb);
 510
 511         /* Process all packets */
 512         select_all_rb = gtk_radio_button_new_with_mnemonic_from_widget(NULL, "_All packets");
 513         gtk_tooltips_set_tip (tooltips, select_all_rb,
 514                 ("Process all packets"), NULL);
 515         g_signal_connect(select_all_rb, "toggled", G_CALLBACK(toggle_select_all), NULL);
 516         gtk_table_attach_defaults(GTK_TABLE(range_tb), select_all_rb, 0, 1, 0, 1);
 517         if (type_of_packets == TYPE_OF_PACKETS_ALL) {
 518                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(select_all_rb),TRUE);
 519         }
 520         gtk_widget_show(select_all_rb);
 521
 522         /* Process displayed packets */
 523         select_displayed_rb = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(select_all_rb),
 524                                                                              "_Displayed packets");
 525         gtk_tooltips_set_tip (tooltips, select_displayed_rb,
 526                 ("Process displayed packets"), NULL);
 527         g_signal_connect(select_displayed_rb, "toggled", G_CALLBACK(toggle_select_displayed), NULL);
 528         gtk_table_attach_defaults(GTK_TABLE(range_tb), select_displayed_rb, 0, 1, 1, 2);
 529         if (type_of_packets == TYPE_OF_PACKETS_DISPLAYED) {
 530                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(select_displayed_rb),TRUE);
 531         }
 532         gtk_widget_show(select_displayed_rb);
 533
 534         gtk_widget_show(range_tb);
 535         gtk_widget_show(range_fr);
 536
 537         /*** Flow type frame ***/
 538         flow_type_fr = gtk_frame_new("Choose flow type");
 539         gtk_box_pack_start(GTK_BOX(main_vb), flow_type_fr, FALSE, FALSE, 5);
 540
 541         flow_type_tb = gtk_table_new(4, 4, FALSE);
 542         gtk_container_set_border_width(GTK_CONTAINER(flow_type_tb), 5);
 543         gtk_container_add(GTK_CONTAINER(flow_type_fr), flow_type_tb);
 544
 545         /* General information */
 546         select_general_rb = gtk_radio_button_new_with_mnemonic_from_widget(NULL, "_General flow");
 547         gtk_tooltips_set_tip (tooltips, select_general_rb,
 548                 ("Show all packets, with general information"), NULL);
 549         g_signal_connect(select_general_rb, "toggled", G_CALLBACK(toggle_select_general), NULL);
 550         gtk_table_attach_defaults(GTK_TABLE(flow_type_tb), select_general_rb, 0, 1, 0, 1);
 551         if (type_of_flow == TYPE_OF_FLOW_GENERAL) {
 552                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(select_general_rb),TRUE);
 553         }
 554         gtk_widget_show(select_general_rb);
 555
 556         /* TCP specific information */
 557         select_tcp_rb = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(select_general_rb),
 558                                                                        "_TCP flow");
 559         gtk_tooltips_set_tip (tooltips, select_tcp_rb,
 560                 ("Show only TCP packets, with TCP specific information"), NULL);
 561         g_signal_connect(select_tcp_rb, "toggled", G_CALLBACK(toggle_select_tcp), NULL);
 562         gtk_table_attach_defaults(GTK_TABLE(flow_type_tb), select_tcp_rb, 0, 1, 1, 2);
 563         if (type_of_flow == TYPE_OF_FLOW_TCP) {
 564                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(select_tcp_rb),TRUE);
 565         }
 566         gtk_widget_show(select_tcp_rb);
 567
 568         gtk_widget_show(flow_type_tb);
 569         gtk_widget_show(flow_type_fr);
 570
 571         /*** Node address type frame ***/
 572         node_addr_fr = gtk_frame_new("Choose node address type");
 573         gtk_box_pack_start(GTK_BOX(main_vb), node_addr_fr, FALSE, FALSE, 5);
 574
 575         node_addr_tb = gtk_table_new(4, 4, FALSE);
 576         gtk_container_set_border_width(GTK_CONTAINER(node_addr_tb), 5);
 577         gtk_container_add(GTK_CONTAINER(node_addr_fr), node_addr_tb);
 578
 579         /* Source / Dest address */
 580         src_dst_rb = gtk_radio_button_new_with_mnemonic_from_widget(NULL, "_Standard source/destination addresses");
 581         gtk_tooltips_set_tip (tooltips, src_dst_rb,
 582                 ("Nodes in the diagram are identified with source and destination addresses"), NULL);
 583         g_signal_connect(src_dst_rb, "toggled", G_CALLBACK(toggle_select_srcdst), NULL);
 584         gtk_table_attach_defaults(GTK_TABLE(node_addr_tb), src_dst_rb, 0, 1, 0, 1);
 585         if (node_addr_type == NODE_ADDR_TYPE_SRCDST) {
 586                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(src_dst_rb),TRUE);
 587         }
 588         gtk_widget_show(src_dst_rb);
 589
 590         /* Network source / dest address */
 591         net_src_dst_rb = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(src_dst_rb),
 592                                                                         "_Network source/destination addresses");
 593         gtk_tooltips_set_tip (tooltips, net_src_dst_rb,
 594                 ("Nodes in the diagram are identified with network source and destination addresses"), NULL);
 595         g_signal_connect(net_src_dst_rb, "toggled", G_CALLBACK(toggle_select_netsrcdst), NULL);
 596         gtk_table_attach_defaults(GTK_TABLE(node_addr_tb), net_src_dst_rb, 0, 1, 1, 2);
 597         if (node_addr_type == NODE_ADDR_TYPE_NET_SRCDST) {
 598                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(net_src_dst_rb),TRUE);
 599         }
 600         gtk_widget_show(net_src_dst_rb);
 601
 602         gtk_widget_show(node_addr_tb);
 603         gtk_widget_show(node_addr_fr);
 604
 605         /* button row */
 606         hbuttonbox = gtk_hbutton_box_new ();
 607         gtk_box_pack_start (GTK_BOX (main_vb), hbuttonbox, FALSE, FALSE, 5);
 608         gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_SPREAD);
 609         gtk_box_set_spacing (GTK_BOX (hbuttonbox), 30);
 610
 611         bt_ok = gtk_button_new_from_stock(GTK_STOCK_OK);
 612         gtk_container_add(GTK_CONTAINER(hbuttonbox), bt_ok);
 613         gtk_tooltips_set_tip (tooltips, bt_ok, "Show the flow graph", NULL);
 614         g_signal_connect(bt_ok, "clicked", G_CALLBACK(flow_graph_on_ok), flow_graph_dlg_w);
 615         gtk_widget_show(bt_ok);
 616
 617         bt_cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
 618         gtk_container_add (GTK_CONTAINER (hbuttonbox), bt_cancel);
 619         GTK_WIDGET_SET_FLAGS(bt_cancel, GTK_CAN_DEFAULT);
 620         gtk_tooltips_set_tip (tooltips, bt_cancel, "Cancel this dialog", NULL);
 621         window_set_cancel_button(flow_graph_dlg_w, bt_cancel, window_cancel_button_cb);
 622
 623         g_signal_connect(flow_graph_dlg_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
 624         g_signal_connect(flow_graph_dlg_w, "destroy", G_CALLBACK(flow_graph_on_destroy), NULL);
 625
 626         gtk_widget_show_all(flow_graph_dlg_w);
 627         window_present(flow_graph_dlg_w);
 628
 629         flow_graph_dlg = flow_graph_dlg_w;
 630 }
 631
 632 /****************************************************************************/
 633 /* PUBLIC                                                                   */
 634 /****************************************************************************/
 635
 636 /* init function for tap */
 637 static void
 638 flow_graph_init_tap(const char *dummy _U_, void* userdata _U_)
 639 {
 640         /* The storage allocated by flow_graph_data_init() and graph_analysis_init()  */
 641         /*  will be considered to be "associated with" the flow_graph_dlg dialog box. */
 642         /* It will be freed when the flow_graph_dlg dialog box is destroyed.          */
 643         if (flow_graph_dlg != NULL) {
 644                 g_assert(graph_analysis != NULL);
 645                 g_assert(graph_analysis_data != NULL);
 646                 /* There's already a dialog box; reactivate it. */
 647                 reactivate_window(flow_graph_dlg);
 648         } else {
 649                 g_assert(graph_analysis == NULL);
 650                 g_assert(graph_analysis_data == NULL);
 651
 652                 /* initialize graph items store */
 653                 flow_graph_data_init();
 654
 655                 /* init the Graph Analysis */
 656                 graph_analysis_data = graph_analysis_init();
 657                 graph_analysis_data->graph_info = graph_analysis;
 658
 659                 flow_graph_dlg_create();
 660         }
 661 }
 662
 663
 664 /****************************************************************************/
 665 /* entry point when called via the GTK menu */
 666 static void
 667 flow_graph_launch(GtkWidget *w _U_, gpointer data _U_)
 668 {
 669         flow_graph_init_tap("",NULL);
 670 }
 671
 672 /****************************************************************************/
 673 void
 674 register_tap_listener_flow_graph(void)
 675 {
 676         register_stat_cmd_arg("flow_graph",flow_graph_init_tap,NULL);
 677         register_stat_menu_item_stock("Flo_w Graph...",
 678                                       REGISTER_STAT_GROUP_UNSORTED, WIRESHARK_STOCK_FLOW_GRAPH,
 679                                       flow_graph_launch, NULL, NULL, NULL);
 680 }
 681