ui/gtk/sctp_stat_dlg.c

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