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