gtk/sctp_stat_dlg.c

   1 /*
   2  * Copyright 2004, Irene Ruengeler <i.ruengeler [AT] fh-muenster.de>
   3  *
   4  * $Id$
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #  include <config.h>
  27 #endif
  28 #include <string.h>
  29
  30 #include <gtk/gtk.h>
  31
  32 #include "epan/filesystem.h"
  33
  34 #include "../globals.h"
  35 #include "../stat_menu.h"
  36
  37 #include "gtk/gui_stat_menu.h"
  38 #include "gtk/dlg_utils.h"
  39 #include "gtk/gui_utils.h"
  40 #include "gtk/main.h"
  41 #include "gtk/sctp_stat.h"
  42 #include "gtk/gtkglobals.h"
  43
  44 static GtkWidget *sctp_stat_dlg=NULL;
  45 static GtkWidget *clist = NULL;
  46 static GList *last_list = NULL;
  47 static gchar *filter_string = NULL;
  48 static sctp_assoc_info_t* selected_stream=NULL;  /* current selection */
  49 static sctp_allassocs_info_t *sctp_assocs=NULL;
  50 static guint16 n_children=0;
  51 static GtkWidget *bt_afilter = NULL, *bt_unselect=NULL, *bt_analyse=NULL, *bt_filter=NULL;
  52 static gboolean prevent_update = FALSE, filter_applied = FALSE;
  53
  54 enum
  55 {
  56         PORT1_COLUMN,
  57         PORT2_COLUMN,
  58         PACKETS_COLUMN,
  59         CHECKSUM_TYPE_COLUMN,
  60         CHECKSUM_ERRORS_COLUMN,
  61         DATA_CHUNKS_COLUMN,
  62         DATA_BYTES_COLUMN,
  63         VTAG1_COLUMN,
  64         VTAG2_COLUMN,
  65         N_COLUMN
  66 };
  67
  68
  69 static void
  70 sctp_stat_on_select_row(GtkTreeSelection *sel, gpointer user_data _U_)
  71 {
  72         GtkTreeModel *model;
  73         GtkTreeIter iter;
  74         GList *list;
  75         sctp_assoc_info_t* assoc;
  76         gboolean stream_found=FALSE;
  77         guint32 port2, port1;
  78         guint32 checksum, data_chunks, data_bytes, packets, vtag1, vtag2;
  79
  80         if (gtk_tree_selection_get_selected (sel, &model, &iter)) {
  81                 gtk_tree_model_get(model, &iter,
  82                         PORT1_COLUMN, &port1,
  83                         PORT2_COLUMN, &port2,
  84                         PACKETS_COLUMN, &packets,
  85                         CHECKSUM_ERRORS_COLUMN, &checksum,
  86                         DATA_CHUNKS_COLUMN, &data_chunks,
  87                         DATA_BYTES_COLUMN, &data_bytes,
  88                         VTAG1_COLUMN, &vtag1,
  89                         VTAG2_COLUMN, &vtag2,
  90                         -1);
  91         } else {
  92                 /* Nothing selected */
  93                 return;
  94         }
  95
  96         list = g_list_first(sctp_assocs->assoc_info_list);
  97
  98         while (list)
  99         {
 100                 assoc = (sctp_assoc_info_t*)(list->data);
 101                 if (assoc->port1==port1 && assoc->port2==port2
 102                 && assoc->n_packets==packets && assoc->n_data_chunks==data_chunks && assoc->n_data_bytes==data_bytes
 103                 && assoc->verification_tag1==vtag1 && assoc->verification_tag2==vtag2)
 104                 {
 105                         selected_stream=assoc;
 106                         stream_found=TRUE;
 107                         break;
 108                 }
 109                 list=g_list_next(list);
 110         }
 111
 112         if (!stream_found)
 113                 selected_stream = NULL;
 114
 115         gtk_widget_set_sensitive(bt_unselect,TRUE);
 116         gtk_widget_set_sensitive(bt_analyse,TRUE);
 117         gtk_widget_set_sensitive(bt_filter,TRUE);
 118 }
 119
 120 static
 121 GtkWidget *create_list(void)
 122 {
 123         GtkListStore *list_store;
 124         GtkWidget * list;
 125         GtkTreeViewColumn *column;
 126         GtkCellRenderer *renderer;
 127         GtkTreeView *list_view;
 128         GtkTreeSelection *selection;
 129
 130         list_store = gtk_list_store_new(N_COLUMN,
 131                 G_TYPE_UINT, /* Port1*/
 132                 G_TYPE_UINT, /* Port2*/
 133                 G_TYPE_UINT, /* number of packets */
 134                 G_TYPE_STRING, /* checksum type */
 135                 G_TYPE_UINT, /* number of checksum errors */
 136                 G_TYPE_UINT, /* number of data chunks */
 137                 G_TYPE_UINT, /* number of data bytes */
 138                 G_TYPE_UINT, /* vtag1 */
 139                 G_TYPE_UINT); /* vtag2 */
 140
 141     /* Create a view */
 142     list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
 143
 144         list_view = GTK_TREE_VIEW(list);
 145
 146 #if GTK_CHECK_VERSION(2,6,0)
 147         /* Speed up the list display */
 148         gtk_tree_view_set_fixed_height_mode(list_view, TRUE);
 149 #endif
 150
 151     gtk_tree_view_set_headers_clickable(list_view, TRUE);
 152
 153     /* The view now holds a reference.  We can get rid of our own reference */
 154     g_object_unref (G_OBJECT (list_store));
 155
 156     /*
 157      * Create the first column packet, associating the "text" attribute of the
 158      * cell_renderer to the first column of the model
 159      */
 160     /* 1:st column */
 161     renderer = gtk_cell_renderer_text_new ();
 162     column = gtk_tree_view_column_new_with_attributes ("Port 1", renderer,
 163                 "text", PORT1_COLUMN,
 164                 NULL);
 165
 166         gtk_tree_view_column_set_sort_column_id(column, PORT1_COLUMN);
 167     gtk_tree_view_column_set_resizable(column, TRUE);
 168     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 169     gtk_tree_view_column_set_min_width(column, 80);
 170
 171         /* Add the column to the view. */
 172     gtk_tree_view_append_column (list_view, column);
 173
 174     /* 2:nd column... */
 175     renderer = gtk_cell_renderer_text_new ();
 176     column = gtk_tree_view_column_new_with_attributes ("Port 2", renderer,
 177                 "text", PORT2_COLUMN,
 178                 NULL);
 179     gtk_tree_view_column_set_sort_column_id(column, PORT2_COLUMN);
 180     gtk_tree_view_column_set_resizable(column, TRUE);
 181     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 182     gtk_tree_view_column_set_min_width(column, 80);
 183     gtk_tree_view_append_column (list_view, column);
 184
 185     /* 3:d column... */
 186     renderer = gtk_cell_renderer_text_new ();
 187     column = gtk_tree_view_column_new_with_attributes ("No of Packets", renderer,
 188                 "text", PACKETS_COLUMN,
 189                 NULL);
 190     gtk_tree_view_column_set_sort_column_id(column, PACKETS_COLUMN);
 191     gtk_tree_view_column_set_resizable(column, TRUE);
 192     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 193     gtk_tree_view_column_set_min_width(column, 120);
 194     gtk_tree_view_append_column (list_view, column);
 195
 196     /* 4:th column... */
 197     renderer = gtk_cell_renderer_text_new ();
 198     column = gtk_tree_view_column_new_with_attributes ("Checksum", renderer,
 199                 "text", CHECKSUM_TYPE_COLUMN,
 200                 NULL);
 201     gtk_tree_view_column_set_sort_column_id(column, CHECKSUM_TYPE_COLUMN);
 202     gtk_tree_view_column_set_resizable(column, TRUE);
 203     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 204     gtk_tree_view_column_set_min_width(column, 120);
 205     gtk_tree_view_append_column (list_view, column);
 206
 207     /* 5:th column... */
 208     renderer = gtk_cell_renderer_text_new ();
 209     column = gtk_tree_view_column_new_with_attributes ("No of Errors", renderer,
 210                 "text", CHECKSUM_ERRORS_COLUMN,
 211                 NULL);
 212     gtk_tree_view_column_set_sort_column_id(column, CHECKSUM_ERRORS_COLUMN);
 213     gtk_tree_view_column_set_resizable(column, TRUE);
 214     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 215     gtk_tree_view_column_set_min_width(column, 120);
 216     gtk_tree_view_append_column (list_view, column);
 217
 218     /* 6:th column... */
 219     renderer = gtk_cell_renderer_text_new ();
 220     column = gtk_tree_view_column_new_with_attributes ("Data Chunks", renderer,
 221                 "text", DATA_CHUNKS_COLUMN,
 222                 NULL);
 223     gtk_tree_view_column_set_sort_column_id(column, DATA_CHUNKS_COLUMN);
 224     gtk_tree_view_column_set_resizable(column, TRUE);
 225     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 226     gtk_tree_view_column_set_min_width(column, 120);
 227     gtk_tree_view_append_column (list_view, column);
 228
 229     /* 7:th column... */
 230     renderer = gtk_cell_renderer_text_new ();
 231     column = gtk_tree_view_column_new_with_attributes ("Data Bytes", renderer,
 232                 "text", DATA_BYTES_COLUMN,
 233                 NULL);
 234     gtk_tree_view_column_set_sort_column_id(column, DATA_BYTES_COLUMN);
 235     gtk_tree_view_column_set_resizable(column, TRUE);
 236     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 237     gtk_tree_view_column_set_min_width(column, 120);
 238     gtk_tree_view_append_column (list_view, column);
 239
 240     /* 8:th column... */
 241     renderer = gtk_cell_renderer_text_new ();
 242     column = gtk_tree_view_column_new_with_attributes ("VTag 1", renderer,
 243                 "text", VTAG1_COLUMN,
 244                 NULL);
 245     gtk_tree_view_column_set_sort_column_id(column, VTAG1_COLUMN);
 246     gtk_tree_view_column_set_resizable(column, TRUE);
 247     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 248     gtk_tree_view_column_set_min_width(column, 120);
 249     gtk_tree_view_append_column (list_view, column);
 250
 251
 252     /* 9:th column... */
 253     renderer = gtk_cell_renderer_text_new ();
 254     column = gtk_tree_view_column_new_with_attributes ("VTag 2", renderer,
 255                 "text", VTAG2_COLUMN,
 256                 NULL);
 257     gtk_tree_view_column_set_sort_column_id(column, VTAG2_COLUMN);
 258     gtk_tree_view_column_set_resizable(column, TRUE);
 259     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 260     gtk_tree_view_column_set_min_width(column, 120);
 261     gtk_tree_view_append_column (list_view, column);
 262
 263     /* Now enable the sorting of each column */
 264     gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(list_view), TRUE);
 265     gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(list_view), TRUE);
 266
 267         /* Setup the selection handler */
 268         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list));
 269         gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
 270         g_signal_connect(selection, "changed", G_CALLBACK(sctp_stat_on_select_row), NULL);
 271         return list;
 272 }
 273
 274 static void
 275 dlg_destroy(void)
 276 {
 277         guint32 i, j;
 278         GList *list;
 279         struct sctp_analyse *child_data;
 280
 281         j=n_children;
 282         for (i=0; i<j; i++)
 283         {
 284                 list=g_list_last(sctp_assocs->children);
 285                 child_data=(struct sctp_analyse *)list->data;
 286                 gtk_grab_remove(GTK_WIDGET(child_data->window));
 287                 gtk_widget_destroy(GTK_WIDGET(child_data->window));
 288         }
 289         g_list_free(sctp_assocs->children);
 290         sctp_assocs->children = NULL;
 291         sctp_stat_dlg = NULL;
 292         prevent_update = FALSE;
 293         filter_applied = FALSE;
 294 }
 295
 296 void
 297 decrease_analyse_childcount()
 298 {
 299         n_children--;
 300 }
 301
 302 void
 303 increase_analyse_childcount()
 304 {
 305         n_children++;
 306 }
 307
 308 void
 309 set_analyse_child(struct sctp_analyse *child)
 310 {
 311         sctp_assocs->children=g_list_append(sctp_assocs->children, child);
 312 }
 313
 314 void
 315 remove_analyse_child(struct sctp_analyse *child)
 316 {
 317         sctp_assocs->children=g_list_remove(sctp_assocs->children, child);
 318 }
 319
 320
 321
 322 static void add_to_clist(sctp_assoc_info_t* assinfo)
 323 {
 324     GtkListStore *list_store = NULL;
 325     GtkTreeIter  iter;
 326
 327     list_store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW (clist))); /* Get store */
 328
 329 #if GTK_CHECK_VERSION(2,6,0)
 330     gtk_list_store_insert_with_values( list_store , &iter, G_MAXINT,
 331 #else
 332     gtk_list_store_append  (list_store, &iter);
 333     gtk_list_store_set  (list_store, &iter,
 334 #endif
 335                 PORT1_COLUMN,                   (guint32)assinfo->port1,
 336                 PORT2_COLUMN,                   (guint32)assinfo->port2,
 337                 PACKETS_COLUMN,                 assinfo->n_packets,
 338                 CHECKSUM_TYPE_COLUMN,   assinfo->checksum_type,
 339                 CHECKSUM_ERRORS_COLUMN, assinfo->n_checksum_errors,
 340                 DATA_CHUNKS_COLUMN,             assinfo->n_data_chunks,
 341                 DATA_BYTES_COLUMN,              assinfo->n_data_bytes,
 342                 VTAG1_COLUMN,                   assinfo->verification_tag1,
 343                 VTAG2_COLUMN,                   assinfo->verification_tag2,
 344          -1);
 345 }
 346
 347 static void
 348 sctp_stat_on_unselect(GtkButton *button _U_, gpointer user_data _U_)
 349 {
 350         if (filter_string != NULL) {
 351                 g_free(filter_string);
 352                 filter_string = NULL;
 353         }
 354
 355         selected_stream = NULL;
 356         gtk_entry_set_text(GTK_ENTRY(main_display_filter_widget), "");
 357         main_filter_packets(&cfile, "", FALSE);
 358         gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(GTK_TREE_VIEW(clist)));
 359         gtk_widget_set_sensitive(bt_unselect,FALSE);
 360         gtk_widget_set_sensitive(bt_filter,FALSE);
 361         gtk_widget_set_sensitive(bt_analyse,FALSE);
 362         gtk_widget_set_sensitive(bt_afilter,FALSE);
 363         prevent_update = FALSE;
 364         filter_applied = FALSE;
 365 }
 366
 367 void sctp_stat_dlg_update(void)
 368 {
 369         GList *list;
 370
 371         list=(sctp_stat_get_info()->assoc_info_list);
 372         if (sctp_stat_dlg != NULL && !prevent_update)
 373         {
 374                 gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(clist))));
 375                 list = g_list_first(sctp_stat_get_info()->assoc_info_list);
 376
 377                 while (list)
 378                 {
 379                         add_to_clist((sctp_assoc_info_t*)(list->data));
 380                         list = g_list_next(list);
 381                 }
 382         }
 383         last_list = list;
 384 }
 385
 386
 387
 388 static void
 389 sctp_stat_on_apply_filter (GtkButton *button _U_, gpointer user_data _U_)
 390 {
 391         GList *list;
 392         sctp_assoc_info_t* assoc;
 393         guint16 port1, port2;
 394         guint32 data_chunks, data_bytes, packets, vtag1, vtag2;
 395
 396         if (filter_string != NULL)
 397         {
 398                 port1 = selected_stream->port1;
 399                 port2 = selected_stream->port2;
 400                 data_chunks = selected_stream->n_data_chunks;
 401                 data_bytes = selected_stream->n_data_bytes;
 402                 packets = selected_stream->n_packets;
 403                 vtag1 = selected_stream->verification_tag1;
 404                 vtag2 = selected_stream->verification_tag2;
 405                 main_filter_packets(&cfile, filter_string, FALSE);
 406                 list = g_list_first(sctp_assocs->assoc_info_list);
 407
 408                 while (list)
 409                 {
 410                         assoc = (sctp_assoc_info_t*)(list->data);
 411                         if (assoc->port1==port1 && assoc->port2==port2
 412                         && assoc->n_packets==packets && assoc->n_data_chunks==data_chunks && assoc->n_data_bytes==data_bytes
 413                         && assoc->verification_tag1==vtag1 && assoc->verification_tag2==vtag2)
 414                         {
 415                                 selected_stream=assoc;
 416                                 break;
 417                         }
 418                         list=g_list_next(list);
 419                 }
 420                 gtk_widget_set_sensitive(bt_afilter,FALSE);
 421                 prevent_update=TRUE;
 422                 filter_applied = TRUE;
 423         }
 424 }
 425
 426 static void
 427 sctp_stat_on_filter (GtkButton *button _U_, gpointer user_data _U_)
 428 {
 429         gchar *f_string = NULL;
 430         GList *srclist, *dstlist;
 431         gchar *str=NULL;
 432         GString *gstring=NULL;
 433         struct sockaddr_in *infosrc=NULL;
 434         struct sockaddr_in *infodst=NULL;
 435
 436         if (selected_stream==NULL) {
 437                 gtk_entry_set_text(GTK_ENTRY(main_display_filter_widget), "");
 438                 return;
 439         }
 440
 441         if (selected_stream->check_address==FALSE)
 442         {
 443                 f_string = g_strdup_printf("((sctp.srcport==%u && sctp.dstport==%u && "
 444                         "((sctp.verification_tag==0x%x && sctp.verification_tag!=0x0) || "
 445                         "(sctp.verification_tag==0x0 && sctp.initiate_tag==0x%x) || "
 446                         "(sctp.verification_tag==0x%x && (sctp.abort_t_bit==1 || "
 447                         "sctp.shutdown_complete_t_bit==1)))) ||"
 448                         "(sctp.srcport==%u && sctp.dstport==%u && ((sctp.verification_tag==0x%x "
 449                         "&& sctp.verification_tag!=0x0) || "
 450                         "(sctp.verification_tag==0x0 && sctp.initiate_tag==0x%x) ||"
 451                         "(sctp.verification_tag==0x%x && (sctp.abort_t_bit==1 ||"
 452                         " sctp.shutdown_complete_t_bit==1)))))",
 453                 selected_stream->port1,
 454                 selected_stream->port2,
 455                 selected_stream->verification_tag1,
 456                 selected_stream->initiate_tag,
 457                 selected_stream->verification_tag2,
 458                 selected_stream->port2,
 459                 selected_stream->port1,
 460                 selected_stream->verification_tag2,
 461                 selected_stream->initiate_tag,
 462                 selected_stream->verification_tag1);
 463                 filter_string = f_string;
 464         }
 465         else
 466         {
 467
 468                 srclist = g_list_first(selected_stream->addr1);
 469                 infosrc=(struct sockaddr_in *) (srclist->data);
 470                 gstring = g_string_new(g_strdup_printf("((sctp.srcport==%u && sctp.dstport==%u && (ip.src==%s",
 471                         selected_stream->port1, selected_stream->port2, ip_to_str((const guint8 *)&(infosrc->sin_addr.s_addr))));
 472                 srclist= g_list_next(srclist);
 473
 474                 while (srclist)
 475                 {
 476                         infosrc=(struct sockaddr_in *) (srclist->data);
 477                         str =g_strdup_printf("|| ip.src==%s",ip_to_str((const guint8 *)&(infosrc->sin_addr.s_addr)));
 478                         g_string_append(gstring, str);
 479                         srclist= g_list_next(srclist);
 480                 }
 481                 dstlist = g_list_first(selected_stream->addr2);
 482                 infodst=(struct sockaddr_in *) (dstlist->data);
 483                 str = g_strdup_printf(") && (ip.dst==%s",ip_to_str((const guint8 *)&(infodst->sin_addr.s_addr)));
 484                 g_string_append(gstring, str);
 485                 dstlist= g_list_next(dstlist);
 486                 while (dstlist)
 487                 {
 488                         infodst=(struct sockaddr_in *) (dstlist->data);
 489                         str =g_strdup_printf("|| ip.dst==%s",ip_to_str((const guint8 *)&(infodst->sin_addr.s_addr)));
 490                         g_string_append(gstring, str);
 491                         dstlist= g_list_next(dstlist);
 492                 }
 493                 srclist = g_list_first(selected_stream->addr1);
 494                 infosrc=(struct sockaddr_in *) (srclist->data);
 495                 str = g_strdup_printf(")) || (sctp.dstport==%u && sctp.srcport==%u && (ip.dst==%s",
 496                         selected_stream->port1, selected_stream->port2, ip_to_str((const guint8 *)&(infosrc->sin_addr.s_addr)));
 497                 g_string_append(gstring, str);
 498                 srclist= g_list_next(srclist);
 499
 500                 while (srclist)
 501                 {
 502                         infosrc=(struct sockaddr_in *) (srclist->data);
 503                         str =g_strdup_printf("|| ip.dst==%s",ip_to_str((const guint8 *)&(infosrc->sin_addr.s_addr)));
 504                         g_string_append(gstring, str);
 505                         srclist= g_list_next(srclist);
 506                 }
 507
 508                 dstlist = g_list_first(selected_stream->addr2);
 509                 infodst=(struct sockaddr_in *) (dstlist->data);
 510                 str = g_strdup_printf(") && (ip.src==%s",ip_to_str((const guint8 *)&(infodst->sin_addr.s_addr)));
 511                 g_string_append(gstring, str);
 512                 dstlist= g_list_next(dstlist);
 513                 while (dstlist)
 514                 {
 515                         infodst=(struct sockaddr_in *) (dstlist->data);
 516                         str =g_strdup_printf("|| ip.src==%s",ip_to_str((const guint8 *)&(infodst->sin_addr.s_addr)));
 517                         g_string_append(gstring, str);
 518                         dstlist= g_list_next(dstlist);
 519                 }
 520                 str = g_strdup_printf(")))");
 521                 g_string_append(gstring, str);
 522                 filter_string = gstring->str;
 523                 g_string_free(gstring,FALSE);
 524         }
 525
 526         if (filter_string != NULL) {
 527                 gtk_entry_set_text(GTK_ENTRY(main_display_filter_widget), filter_string);
 528         } else {
 529                 g_assert_not_reached();
 530         }
 531         gtk_widget_set_sensitive(bt_afilter,TRUE);
 532         gtk_widget_set_sensitive(bt_filter,FALSE);
 533         prevent_update = TRUE;
 534         filter_applied = FALSE;
 535 }
 536
 537
 538 static void
 539 sctp_stat_on_close (GtkWidget *button _U_, gpointer user_data _U_)
 540 {
 541         gtk_grab_remove(sctp_stat_dlg);
 542         gtk_widget_destroy(sctp_stat_dlg);
 543         prevent_update = FALSE;
 544         filter_applied = FALSE;
 545 }
 546
 547 static void
 548 sctp_stat_on_analyse (GtkButton *button _U_, gpointer user_data _U_)
 549 {
 550         if (selected_stream==NULL)
 551                 return;
 552         else
 553                 assoc_analyse(selected_stream);
 554         gtk_widget_set_sensitive(bt_analyse,FALSE);
 555         if (!filter_applied)
 556                 gtk_widget_set_sensitive(bt_filter,TRUE);
 557         prevent_update = TRUE;
 558 }
 559
 560
 561 static void
 562 gtk_sctpstat_dlg(void)
 563 {
 564         GtkWidget *sctp_stat_dlg_w;
 565         GtkWidget *vbox1;
 566         GtkWidget *scrolledwindow1;
 567         GtkWidget *hbuttonbox2;
 568         GtkWidget *bt_close;
 569
 570         sctp_stat_dlg_w = window_new (GTK_WINDOW_TOPLEVEL, "Wireshark: SCTP Associations");
 571         gtk_window_set_position (GTK_WINDOW (sctp_stat_dlg_w), GTK_WIN_POS_CENTER);
 572         g_signal_connect(sctp_stat_dlg_w, "destroy", G_CALLBACK(dlg_destroy), NULL);
 573
 574         /* Container for each row of widgets */
 575         vbox1 = gtk_vbox_new(FALSE, 2);
 576         gtk_container_set_border_width(GTK_CONTAINER(vbox1), 8);
 577         gtk_container_add(GTK_CONTAINER(sctp_stat_dlg_w), vbox1);
 578         gtk_widget_show(vbox1);
 579
 580         scrolledwindow1 = scrolled_window_new (NULL, NULL);
 581         gtk_widget_show (scrolledwindow1);
 582         gtk_box_pack_start (GTK_BOX (vbox1), scrolledwindow1, TRUE, TRUE, 0);
 583
 584         clist = create_list();
 585         gtk_widget_show (clist);
 586         gtk_container_add (GTK_CONTAINER (scrolledwindow1), clist);
 587         gtk_widget_set_size_request(clist, 1050, 200);
 588
 589         gtk_widget_show(sctp_stat_dlg_w);
 590
 591         hbuttonbox2 = gtk_hbutton_box_new();
 592         gtk_box_pack_start(GTK_BOX(vbox1), hbuttonbox2, FALSE, FALSE, 0);
 593         gtk_container_set_border_width(GTK_CONTAINER(hbuttonbox2), 10);
 594         gtk_button_box_set_layout(GTK_BUTTON_BOX (hbuttonbox2), GTK_BUTTONBOX_SPREAD);
 595         gtk_box_set_spacing(GTK_BOX (hbuttonbox2), 0);
 596         gtk_widget_show(hbuttonbox2);
 597
 598         bt_unselect = gtk_button_new_with_label ("Unselect");
 599         gtk_container_add (GTK_CONTAINER (hbuttonbox2), bt_unselect);
 600         gtk_widget_show (bt_unselect);
 601         gtk_widget_set_sensitive(bt_unselect,FALSE);
 602
 603         bt_filter = gtk_button_new_with_label ("Set filter");
 604         gtk_container_add (GTK_CONTAINER (hbuttonbox2), bt_filter);
 605         gtk_widget_show (bt_filter);
 606         gtk_widget_set_sensitive(bt_filter,FALSE);
 607
 608         bt_afilter = gtk_button_new_with_label ("Apply filter");
 609         gtk_container_add (GTK_CONTAINER (hbuttonbox2), bt_afilter);
 610         gtk_widget_show (bt_afilter);
 611         gtk_widget_set_sensitive(bt_afilter,FALSE);
 612
 613         bt_analyse = gtk_button_new_with_label ("Analyse");
 614         gtk_container_add (GTK_CONTAINER (hbuttonbox2), bt_analyse);
 615         gtk_widget_show (bt_analyse);
 616         gtk_widget_set_sensitive(bt_analyse,FALSE);
 617
 618         bt_close = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
 619         gtk_container_add (GTK_CONTAINER (hbuttonbox2), bt_close);
 620         GTK_WIDGET_SET_FLAGS(bt_close, GTK_CAN_DEFAULT);
 621         window_set_cancel_button( sctp_stat_dlg_w, bt_close, sctp_stat_on_close);
 622         gtk_widget_grab_focus(bt_close);
 623         gtk_widget_show (bt_close);
 624
 625         g_signal_connect(sctp_stat_dlg_w, "destroy", G_CALLBACK(dlg_destroy), NULL);
 626         g_signal_connect(bt_unselect, "clicked", G_CALLBACK(sctp_stat_on_unselect), NULL);
 627         g_signal_connect(bt_filter, "clicked", G_CALLBACK(sctp_stat_on_filter), NULL);
 628         g_signal_connect(bt_afilter, "clicked", G_CALLBACK(sctp_stat_on_apply_filter), NULL);
 629         g_signal_connect(bt_analyse, "clicked", G_CALLBACK(sctp_stat_on_analyse), NULL);
 630
 631         sctp_stat_dlg = sctp_stat_dlg_w;
 632         cf_retap_packets(&cfile);
 633         gdk_window_raise(sctp_stat_dlg_w->window);
 634
 635 }
 636
 637 static void sctp_stat_dlg_show(void)
 638 {
 639         if (sctp_stat_dlg != NULL)
 640         {
 641                 /* There's already a dialog box; reactivate it. */
 642                 reactivate_window(sctp_stat_dlg);
 643                 /* Another list since last call? */
 644                 if ((sctp_stat_get_info()->assoc_info_list) != last_list)
 645                         sctp_stat_dlg_update();
 646         }
 647         else
 648         {
 649                 /* Create and show the dialog box */
 650                 gtk_sctpstat_dlg();
 651                 sctp_stat_dlg_update();
 652         }
 653 }
 654
 655
 656 static void sctp_stat_start(GtkWidget *w _U_, gpointer data _U_)
 657 {
 658         prevent_update = FALSE;
 659         filter_applied = FALSE;
 660         sctp_assocs = g_malloc(sizeof(sctp_allassocs_info_t));
 661         sctp_assocs = (sctp_allassocs_info_t*)sctp_stat_get_info();
 662         /* Register the tap listener */
 663         if (sctp_stat_get_info()->is_registered==FALSE)
 664         register_tap_listener_sctp_stat();
 665         /*  (redissect all packets) */
 666         sctp_stat_scan();
 667
 668         /* Show the dialog box with the list of streams */
 669         sctp_stat_dlg_show();
 670 }
 671
 672 /****************************************************************************/
 673 void
 674 register_tap_listener_sctp_stat_dlg(void)
 675 {
 676         register_stat_menu_item("S_CTP/Show All Associations...", REGISTER_STAT_GROUP_TELEPHONY,
 677             sctp_stat_start, NULL, NULL, NULL);
 678 }
 679
 680
 681 GtkWidget* get_stat_dlg(void)
 682 {
 683         return sctp_stat_dlg;
 684 }