ui/gtk/expert_comp_dlg.c

   1 /* expert_comp_dlg.c
   2  * expert_comp_dlg   2005 Greg Morris
   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
  25 #include <string.h>
  26
  27 #include <gtk/gtk.h>
  28
  29 #include <epan/packet_info.h>
  30 #include <epan/prefs.h>
  31 #include <epan/tap.h>
  32 #include <epan/stat_tap_ui.h>
  33
  34 #include <epan/stat_groups.h>
  35
  36 #include "ui/simple_dialog.h"
  37
  38 #include "ui/gtk/gui_utils.h"
  39 #include "ui/gtk/dlg_utils.h"
  40 #include "ui/gtk/expert_comp_table.h"
  41 #include "ui/gtk/gui_stat_menu.h"
  42 #include "ui/gtk/help_dlg.h"
  43 #include "ui/gtk/expert_comp_dlg.h"
  44 #include "ui/gtk/stock_icons.h"
  45 #include "ui/gtk/main.h"
  46 #include "ui/gtk/expert_indicators.h"
  47 #include "ui/gtk/packet_panes.h"
  48 #include "ui/gtk/old-gtk-compat.h"
  49 #include "ui/gtk/edit_packet_comment_dlg.h"
  50 #include "ui/gtk/capture_comment_icons.h"
  51 #include "ui/gtk/gtkglobals.h"
  52
  53 void register_tap_listener_expert_comp(void);
  54
  55 enum
  56 {
  57     NO_COLUMN_C_TABLE,
  58     SUMMARY_COLUMN_C_TABLE,
  59     FOREGROUND_COLOR_COL_C_TABLE,
  60     BACKGROUND_COLOR_COL_C_TABLE,
  61     N_COLUMNS_COMMENT_TBL
  62 };
  63
  64 enum
  65 {
  66     NO_COLUMN,
  67     SEVERITY_COLUMN,
  68     GROUP_COLUMN,
  69     PROTOCOL_COLUMN,
  70     SUMMARY_COLUMN,
  71     FOREGROUND_COLOR_COL,
  72     BACKGROUND_COLOR_COL,
  73     N_COLUMNS
  74 };
  75
  76 /* used to keep track of the statistics for an entire program interface */
  77 typedef struct _expert_comp_dlg_t {
  78     GtkWidget *win;
  79     GtkWidget *pkt_comments_label;
  80     GtkWidget *chat_label;
  81     GtkWidget *note_label;
  82     GtkWidget *warn_label;
  83     GtkWidget *error_label;
  84     GtkWidget *all_label;
  85     error_equiv_table chat_table;
  86     error_equiv_table note_table;
  87     error_equiv_table warn_table;
  88     error_equiv_table error_table;
  89     expert_tapdata_t *etd; /* details tab info similar to error_equiv_table for others */
  90     guint32 pkt_comments_events;
  91     guint32 disp_events;
  92     guint32 chat_events;
  93     guint32 note_events;
  94     guint32 warn_events;
  95     guint32 error_events;
  96     gboolean use_dfilter;
  97 } expert_comp_dlg_t;
  98
  99 struct expert_tapdata_s {
 100     GtkWidget   *win;
 101     GtkWidget   *scrolled_window;
 102     GtkTreeView *tree_view;
 103     GtkWidget   *scrolled_window_comments;
 104     GtkTreeView *tree_view_comments;
 105     GtkWidget   *label;
 106     guint32     pkt_comments_events;
 107     guint32     disp_events;
 108     guint32     chat_events;
 109     guint32     note_events;
 110     guint32     warn_events;
 111     guint32     error_events;
 112     int         severity_report_level;
 113
 114     GArray      *ei_array;      /* expert info items */
 115     guint       first;
 116     guint       last;
 117     GStringChunk *text;  /* summary text */
 118 };
 119
 120 static GtkWidget  *expert_comp_dlg_w = NULL;
 121
 122 static void
 123 select_row_cb(GtkTreeSelection *selection, gpointer *user_data _U_)
 124 {
 125     /*guint num = GPOINTER_TO_UINT(gtk_clist_get_row_data(clist, row));*/
 126
 127     /*cf_goto_frame(&cfile, num);*/
 128
 129     GtkTreeIter iter;
 130     GtkTreeModel *model;
 131     guint fnumber;
 132
 133     if (selection==NULL)
 134         return;
 135
 136     if (gtk_tree_selection_get_selected (selection, &model, &iter)){
 137         gtk_tree_model_get (model, &iter, NO_COLUMN, &fnumber, -1);
 138         cf_goto_frame(&cfile, fnumber);
 139     }
 140
 141 }
 142
 143 static void
 144 expert_comp_select_filter_cb(GtkWidget *widget, gpointer callback_data, guint callback_action _U_)
 145 {
 146     expert_comp_dlg_t *ss = (expert_comp_dlg_t *)callback_data;
 147     const char *filter;
 148     GString *error_string;
 149
 150     ss->use_dfilter = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (widget));
 151     if (ss->use_dfilter) {
 152         filter = gtk_entry_get_text(GTK_ENTRY(main_display_filter_widget));
 153     } else {
 154         filter = NULL;
 155     }
 156     error_string = set_tap_dfilter (ss, filter);
 157     if (error_string) {
 158         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
 159         g_string_free(error_string, TRUE);
 160         return;
 161     }
 162     error_string = set_tap_dfilter (ss->etd, filter);
 163     if (error_string) {
 164         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
 165         g_string_free(error_string, TRUE);
 166         return;
 167     }
 168
 169     cf_retap_packets(&cfile);
 170 }
 171
 172 /* reset of display only, e.g. for filtering */
 173 static void expert_dlg_display_reset(expert_tapdata_t * etd)
 174 {
 175     etd->disp_events = 0;
 176     gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(etd->tree_view))));
 177     gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(etd->tree_view_comments))));
 178
 179     gtk_window_set_title(GTK_WINDOW(etd->win), "Wireshark: ? Expert Infos");
 180     if(etd->label) {
 181         gtk_label_set_text(GTK_LABEL(etd->label), "Please wait ...");
 182     }
 183 }
 184
 185 /* complete reset, e.g. capture file closed */
 186 static void
 187 expert_dlg_reset(void *tapdata)
 188 {
 189     expert_tapdata_t * etd = (expert_tapdata_t *)tapdata;
 190
 191     etd->chat_events = 0;
 192     etd->note_events = 0;
 193     etd->warn_events = 0;
 194     etd->error_events = 0;
 195     etd->pkt_comments_events = 0;
 196     etd->last = 0;
 197     etd->first = 0;
 198     /* g_string_chunk_clear() is introduced in glib 2.14 */
 199     g_string_chunk_free(etd->text);
 200     etd->text = g_string_chunk_new(100);
 201     g_array_set_size(etd->ei_array, 0);
 202
 203     expert_dlg_display_reset(etd);
 204 }
 205
 206 static int
 207 expert_dlg_packet(void *tapdata, packet_info *pinfo _U_, epan_dissect_t *edt _U_, const void *pointer)
 208 {
 209     expert_info_t    *ei;
 210     expert_tapdata_t *etd = (expert_tapdata_t *)tapdata;
 211
 212     g_array_append_val(etd->ei_array, *(expert_info_t *)pointer);
 213     etd->last = etd->ei_array->len;
 214     ei = &g_array_index(etd->ei_array, expert_info_t, etd->last -1); /* ugly */
 215     ei->protocol = g_string_chunk_insert_const(etd->text, ei->protocol);
 216     ei->summary = g_string_chunk_insert_const(etd->text, ei->summary);
 217
 218     switch(ei->severity) {
 219     case(PI_COMMENT):
 220         etd->pkt_comments_events++;
 221         break;
 222     case(PI_CHAT):
 223         etd->chat_events++;
 224         break;
 225     case(PI_NOTE):
 226         etd->note_events++;
 227         break;
 228     case(PI_WARN):
 229         etd->warn_events++;
 230         break;
 231     case(PI_ERROR):
 232         etd->error_events++;
 233         break;
 234     default:
 235         g_assert_not_reached();
 236     }
 237     if(ei->severity < etd->severity_report_level) {
 238         return 0; /* draw not required */
 239     } else {
 240         return 1; /* draw required */
 241     }
 242 }
 243 static void
 244 error_set_title(expert_comp_dlg_t *ss)
 245 {
 246     set_window_title(ss->win, "Expert Info");
 247 }
 248
 249 static void
 250 error_reset(void *pss)
 251 {
 252     expert_comp_dlg_t *ss=(expert_comp_dlg_t *)pss;
 253     gchar *buf;
 254
 255     ss->error_events = 0;
 256     ss->warn_events = 0;
 257     ss->note_events = 0;
 258     ss->chat_events = 0;
 259     ss->disp_events = 0;
 260     ss->use_dfilter = FALSE;
 261     ss->pkt_comments_events = 0;
 262
 263     reset_error_table_data(&ss->error_table);
 264     buf = g_strdup_printf("Errors: %u (0)", ss->error_table.num_procs);
 265     gtk_label_set_text( GTK_LABEL(ss->error_label), buf);
 266     g_free(buf);
 267
 268     reset_error_table_data(&ss->warn_table);
 269     buf = g_strdup_printf("Warnings: %u (0)", ss->warn_table.num_procs);
 270     gtk_label_set_text( GTK_LABEL(ss->warn_label), buf);
 271     g_free(buf);
 272
 273     reset_error_table_data(&ss->note_table);
 274     buf = g_strdup_printf("Notes: %u (0)", ss->note_table.num_procs);
 275     gtk_label_set_text( GTK_LABEL(ss->note_label), buf);
 276     g_free(buf);
 277
 278     reset_error_table_data(&ss->chat_table);
 279     buf = g_strdup_printf("Chats: %u (0)", ss->chat_table.num_procs);
 280     gtk_label_set_text( GTK_LABEL(ss->chat_label), buf);
 281     g_free(buf);
 282
 283     gtk_label_set_text( GTK_LABEL(ss->all_label), "Details: 0");
 284
 285     gtk_label_set_text( GTK_LABEL(ss->pkt_comments_label), "Packet comments: 0");
 286
 287     error_set_title(ss);
 288 }
 289
 290 static gboolean
 291 error_packet(void *pss, packet_info *pinfo _U_, epan_dissect_t *edt _U_, const void *prv)
 292 {
 293     expert_comp_dlg_t *ss=(expert_comp_dlg_t *)pss;
 294     const expert_info_t *error_pkt=(const expert_info_t *)prv;
 295
 296     /* if return value is 0 then no error */
 297     if(error_pkt==NULL){
 298         return FALSE;
 299     }
 300
 301     switch (error_pkt->severity) {
 302     case PI_ERROR:
 303         ss->disp_events++;
 304         ss->error_events++;
 305         init_error_table_row(&ss->error_table, error_pkt);
 306         break;
 307     case PI_WARN:
 308         ss->disp_events++;
 309         ss->warn_events++;
 310         init_error_table_row(&ss->warn_table, error_pkt);
 311         break;
 312     case PI_NOTE:
 313         ss->disp_events++;
 314         ss->note_events++;
 315         init_error_table_row(&ss->note_table, error_pkt);
 316         break;
 317     case PI_CHAT:
 318         ss->disp_events++;
 319         ss->chat_events++;
 320         init_error_table_row(&ss->chat_table, error_pkt);
 321         break;
 322     case PI_COMMENT:
 323         ss->disp_events++; /* Count ? */
 324         ss->pkt_comments_events++;
 325         break;
 326     default:
 327         return FALSE; /* Don't draw */
 328     }
 329     return TRUE; /* Draw */
 330 }
 331
 332 static void
 333 expert_comp_draw(void *data)
 334 {
 335     gchar *buf;
 336
 337     expert_comp_dlg_t *ss=(expert_comp_dlg_t *)data;
 338
 339     buf = g_strdup_printf("Errors: %u (%u)", ss->error_table.num_procs, ss->error_events);
 340     gtk_label_set_text( GTK_LABEL(ss->error_label), buf);
 341     g_free(buf);
 342
 343     buf = g_strdup_printf("Warnings: %u (%u)", ss->warn_table.num_procs, ss->warn_events);
 344     gtk_label_set_text( GTK_LABEL(ss->warn_label), buf);
 345     g_free(buf);
 346
 347     buf = g_strdup_printf("Notes: %u (%u)", ss->note_table.num_procs, ss->note_events);
 348     gtk_label_set_text( GTK_LABEL(ss->note_label), buf);
 349     g_free(buf);
 350
 351     buf = g_strdup_printf("Chats: %u (%u)", ss->chat_table.num_procs, ss->chat_events);
 352     gtk_label_set_text( GTK_LABEL(ss->chat_label), buf);
 353     g_free(buf);
 354
 355     buf = g_strdup_printf("Details: %u", ss->disp_events);
 356     gtk_label_set_text( GTK_LABEL(ss->all_label), buf);
 357     g_free(buf);
 358
 359     buf = g_strdup_printf("Packet Comments: %u", ss->pkt_comments_events);
 360     gtk_label_set_text( GTK_LABEL(ss->pkt_comments_label), buf);
 361     g_free(buf);
 362
 363 }
 364
 365 static void
 366 win_destroy_cb(GtkWindow *win _U_, gpointer data)
 367 {
 368     expert_comp_dlg_t *ss=(expert_comp_dlg_t *)data;
 369
 370     remove_tap_listener(ss);
 371
 372     if (expert_comp_dlg_w != NULL) {
 373         window_destroy(expert_comp_dlg_w);
 374         expert_comp_dlg_w = NULL;
 375     }
 376
 377     free_error_table_data(&ss->error_table);
 378     free_error_table_data(&ss->warn_table);
 379     free_error_table_data(&ss->note_table);
 380     free_error_table_data(&ss->chat_table);
 381     g_free(ss);
 382
 383 }
 384
 385 static void
 386 expert_dlg_destroy_cb(GtkWindow *win _U_, gpointer data)
 387 {
 388     expert_tapdata_t *etd=(expert_tapdata_t *)data;
 389
 390     remove_tap_listener(etd);
 391
 392     /*free_srt_table_data(&etd->afp_srt_table);*/
 393     g_array_free(etd->ei_array, TRUE);
 394     g_string_chunk_free(etd->text);
 395     g_free(etd);
 396 }
 397
 398 static expert_tapdata_t * expert_dlg_new_table(void)
 399 {
 400     expert_tapdata_t * etd;
 401     etd=(expert_tapdata_t *)g_malloc0(sizeof(expert_tapdata_t));
 402
 403     etd->ei_array = g_array_sized_new(FALSE, FALSE, sizeof(expert_info_t), 1000);
 404     etd->text = g_string_chunk_new(100);
 405     etd->severity_report_level = PI_COMMENT;
 406     return etd;
 407 }
 408
 409 static void
 410 comments_row_double_click_cb(GtkTreeView *treeview _U_, GtkTreePath *path _U_,
 411                              GtkTreeViewColumn *col _U_, gpointer userdata _U_)
 412 {
 413     edit_packet_comment_dlg(NULL, NULL);
 414 }
 415
 416 static void
 417 expert_dlg_init_comments_table(expert_tapdata_t * etd, GtkWidget *vbox)
 418 {
 419     GtkListStore *store;
 420     GtkWidget *tree;
 421     GtkTreeViewColumn *column;
 422     GtkCellRenderer *renderer;
 423     GtkTreeSortable *sortable;
 424     GtkTreeSelection  *selection;
 425
 426     /* Create the store */
 427     store = gtk_list_store_new(N_COLUMNS_COMMENT_TBL,        /* Total number of columns */
 428                                G_TYPE_UINT,      /* No                      */
 429                                G_TYPE_POINTER,   /* Summary                 */
 430                                G_TYPE_STRING,    /* Foreground              */
 431                                G_TYPE_STRING);   /* Background              */
 432
 433     /* Create a view */
 434     tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
 435     etd->tree_view_comments = GTK_TREE_VIEW(tree);
 436     sortable = GTK_TREE_SORTABLE(store);
 437
 438     /* Speed up the list display */
 439     gtk_tree_view_set_fixed_height_mode(etd->tree_view_comments, TRUE);
 440
 441     /* Setup the sortable columns */
 442     gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW (tree), FALSE);
 443
 444     /* The view now holds a reference.  We can get rid of our own reference */
 445     g_object_unref (G_OBJECT (store));
 446
 447     /* Let the font be the default one to have the same look as the rest of the tabs
 448      * Bug https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=4388
 449      * gtk_widget_modify_font(GTK_WIDGET (etd->tree_view), user_font_get_regular());
 450      */
 451
 452     /* Create a cell renderer */
 453     renderer = gtk_cell_renderer_text_new ();
 454     g_object_set(renderer, "ypad", 0, NULL);
 455     g_object_set(renderer, "xalign", 1.0, NULL);
 456
 457     /* Create the first column, associating the "text" attribute of the
 458      * cell_renderer to the first column of the model */
 459     /* No */
 460     column = gtk_tree_view_column_new_with_attributes ("No", renderer,
 461         "text", NO_COLUMN_C_TABLE,
 462         "foreground", FOREGROUND_COLOR_COL_C_TABLE,
 463         "background", BACKGROUND_COLOR_COL_C_TABLE,
 464         NULL);
 465     gtk_tree_view_column_set_sort_column_id(column, NO_COLUMN_C_TABLE);
 466     gtk_tree_view_column_set_resizable(column, TRUE);
 467     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 468     gtk_tree_view_column_set_min_width(column, 40);
 469     gtk_tree_view_append_column (etd->tree_view_comments, column);
 470
 471
 472     /* Summary. */
 473     renderer = gtk_cell_renderer_text_new ();
 474     g_object_set(renderer, "ypad", 0, NULL);
 475     column = gtk_tree_view_column_new_with_attributes ("Summary", renderer,
 476         "foreground", FOREGROUND_COLOR_COL_C_TABLE,
 477         "background", BACKGROUND_COLOR_COL_C_TABLE,
 478         NULL);
 479     gtk_tree_view_column_set_cell_data_func(column, renderer, str_ptr_data_func,
 480         GINT_TO_POINTER(SUMMARY_COLUMN_C_TABLE), NULL);
 481
 482     gtk_tree_sortable_set_sort_func(sortable, SUMMARY_COLUMN, str_ptr_sort_func,
 483         GINT_TO_POINTER(SUMMARY_COLUMN_C_TABLE), NULL);
 484
 485     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 486     gtk_tree_view_column_set_min_width(column, 90);
 487     gtk_tree_view_column_set_sort_column_id(column, SUMMARY_COLUMN_C_TABLE);
 488     gtk_tree_view_column_set_resizable(column, TRUE);
 489     gtk_tree_view_append_column (etd->tree_view_comments, column);
 490
 491     gtk_tree_view_set_search_column (etd->tree_view_comments, SUMMARY_COLUMN_C_TABLE); /* Allow searching the summary */
 492     gtk_tree_view_set_reorderable (etd->tree_view_comments, TRUE);   /* Allow user to reorder data with drag n drop */
 493
 494     /* Now enable the sorting of each column */
 495     gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(etd->tree_view_comments), TRUE);
 496     gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(etd->tree_view_comments), TRUE);
 497
 498     /* Setup the selection handler */
 499     selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(etd->tree_view_comments));
 500     gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
 501
 502     g_signal_connect (G_OBJECT (selection), "changed", /* select_row */
 503                   G_CALLBACK (select_row_cb),
 504                   NULL);
 505
 506     g_signal_connect(tree, "row-activated",
 507                      G_CALLBACK(comments_row_double_click_cb), NULL);
 508
 509     etd->scrolled_window_comments=scrolled_window_new(NULL, NULL);
 510     gtk_container_add(GTK_CONTAINER(etd->scrolled_window_comments), GTK_WIDGET (etd->tree_view_comments));
 511
 512     gtk_box_pack_start(GTK_BOX(vbox), etd->scrolled_window_comments, TRUE, TRUE, 0);
 513 }
 514
 515 static void
 516 expert_dlg_init_table(expert_tapdata_t * etd, GtkWidget *vbox)
 517 {
 518     GtkListStore *store;
 519     GtkWidget *tree;
 520     GtkTreeViewColumn *column;
 521     GtkCellRenderer *renderer;
 522     GtkTreeSortable *sortable;
 523     GtkTreeSelection  *selection;
 524
 525     /* Create the store */
 526     store = gtk_list_store_new(N_COLUMNS,        /* Total number of columns */
 527                                G_TYPE_UINT,      /* No                      */
 528                                G_TYPE_POINTER,   /* Severity                */
 529                                G_TYPE_POINTER,   /* Group                   */
 530                                G_TYPE_POINTER,   /* Protocol                */
 531                                G_TYPE_POINTER,   /* Summary                 */
 532                                G_TYPE_STRING,    /* Foreground              */
 533                                G_TYPE_STRING);   /* Background              */
 534
 535     /* Create a view */
 536     tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
 537     etd->tree_view = GTK_TREE_VIEW(tree);
 538     sortable = GTK_TREE_SORTABLE(store);
 539
 540     /* Speed up the list display */
 541     gtk_tree_view_set_fixed_height_mode(etd->tree_view, TRUE);
 542
 543     /* Setup the sortable columns */
 544     gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW (tree), FALSE);
 545
 546     /* The view now holds a reference.  We can get rid of our own reference */
 547     g_object_unref (G_OBJECT (store));
 548
 549     /* Let the font be the default one to have the same look as the rest of the tabs
 550      * Bug https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=4388
 551      * gtk_widget_modify_font(GTK_WIDGET (etd->tree_view), user_font_get_regular());
 552      */
 553
 554     /* Create a cell renderer */
 555     renderer = gtk_cell_renderer_text_new ();
 556     g_object_set(renderer, "ypad", 0, NULL);
 557     g_object_set(renderer, "xalign", 1.0, NULL);
 558
 559     /* Create the first column, associating the "text" attribute of the
 560      * cell_renderer to the first column of the model */
 561     /* No */
 562     column = gtk_tree_view_column_new_with_attributes ("No", renderer,
 563         "text", NO_COLUMN,
 564         "foreground", FOREGROUND_COLOR_COL,
 565         "background", BACKGROUND_COLOR_COL,
 566         NULL);
 567     gtk_tree_view_column_set_sort_column_id(column, NO_COLUMN);
 568     gtk_tree_view_column_set_resizable(column, TRUE);
 569     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 570     gtk_tree_view_column_set_min_width(column, 40);
 571     gtk_tree_view_append_column (etd->tree_view, column);
 572
 573     /* Severity */
 574     renderer = gtk_cell_renderer_text_new ();
 575     g_object_set(renderer, "ypad", 0, NULL);
 576
 577     column = gtk_tree_view_column_new_with_attributes ("Severity", renderer,
 578         "foreground", FOREGROUND_COLOR_COL,
 579         "background", BACKGROUND_COLOR_COL,
 580         NULL);
 581
 582     gtk_tree_view_column_set_cell_data_func(column, renderer, str_ptr_data_func,
 583         GINT_TO_POINTER(SEVERITY_COLUMN), NULL);
 584
 585     gtk_tree_sortable_set_sort_func(sortable, SEVERITY_COLUMN, str_ptr_sort_func,
 586         GINT_TO_POINTER(SEVERITY_COLUMN), NULL);
 587
 588     gtk_tree_view_column_set_sort_column_id(column, SEVERITY_COLUMN);
 589     gtk_tree_view_column_set_resizable(column, TRUE);
 590     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 591     gtk_tree_view_column_set_min_width(column, 80);
 592     /* Add the column to the view. */
 593     gtk_tree_view_append_column (etd->tree_view, column);
 594
 595     /* Group */
 596     renderer = gtk_cell_renderer_text_new ();
 597     g_object_set(renderer, "ypad", 0, NULL);
 598     column = gtk_tree_view_column_new_with_attributes ("Group", renderer,
 599         "foreground", FOREGROUND_COLOR_COL,
 600         "background", BACKGROUND_COLOR_COL,
 601         NULL);
 602
 603     gtk_tree_view_column_set_cell_data_func(column, renderer, str_ptr_data_func,
 604         GINT_TO_POINTER(GROUP_COLUMN), NULL);
 605
 606     gtk_tree_sortable_set_sort_func(sortable, GROUP_COLUMN, str_ptr_sort_func,
 607         GINT_TO_POINTER(GROUP_COLUMN), NULL);
 608
 609     gtk_tree_view_column_set_sort_column_id(column, GROUP_COLUMN);
 610     gtk_tree_view_column_set_resizable(column, TRUE);
 611     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 612     gtk_tree_view_column_set_min_width(column, 80);
 613     /* Add the column to the view. */
 614     gtk_tree_view_append_column (etd->tree_view, column);
 615
 616     /* Protocol. */
 617     renderer = gtk_cell_renderer_text_new ();
 618     g_object_set(renderer, "ypad", 0, NULL);
 619     column = gtk_tree_view_column_new_with_attributes ("Protocol", renderer,
 620         "foreground", FOREGROUND_COLOR_COL,
 621         "background", BACKGROUND_COLOR_COL,
 622         NULL);
 623     gtk_tree_view_column_set_cell_data_func(column, renderer, str_ptr_data_func,
 624         GINT_TO_POINTER(PROTOCOL_COLUMN), NULL);
 625
 626     gtk_tree_sortable_set_sort_func(sortable, PROTOCOL_COLUMN, str_ptr_sort_func,
 627         GINT_TO_POINTER(PROTOCOL_COLUMN), NULL);
 628
 629     gtk_tree_view_column_set_sort_column_id(column, PROTOCOL_COLUMN);
 630     gtk_tree_view_column_set_resizable(column, TRUE);
 631     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 632     gtk_tree_view_column_set_min_width(column, 80);
 633     gtk_tree_view_append_column (etd->tree_view, column);
 634
 635     /* Summary. */
 636     renderer = gtk_cell_renderer_text_new ();
 637     g_object_set(renderer, "ypad", 0, NULL);
 638     column = gtk_tree_view_column_new_with_attributes ("Summary", renderer,
 639         "foreground", FOREGROUND_COLOR_COL,
 640         "background", BACKGROUND_COLOR_COL,
 641         NULL);
 642     gtk_tree_view_column_set_cell_data_func(column, renderer, str_ptr_data_func,
 643         GINT_TO_POINTER(SUMMARY_COLUMN), NULL);
 644
 645     gtk_tree_sortable_set_sort_func(sortable, SUMMARY_COLUMN, str_ptr_sort_func,
 646         GINT_TO_POINTER(SUMMARY_COLUMN), NULL);
 647
 648     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 649     gtk_tree_view_column_set_min_width(column, 90);
 650     gtk_tree_view_column_set_sort_column_id(column, SUMMARY_COLUMN);
 651     gtk_tree_view_column_set_resizable(column, TRUE);
 652     gtk_tree_view_append_column (etd->tree_view, column);
 653
 654     gtk_tree_view_set_search_column (etd->tree_view, SUMMARY_COLUMN); /* Allow searching the summary */
 655     gtk_tree_view_set_reorderable (etd->tree_view, TRUE);   /* Allow user to reorder data with drag n drop */
 656
 657     /* Now enable the sorting of each column */
 658     gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(etd->tree_view), TRUE);
 659     gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(etd->tree_view), TRUE);
 660
 661     /* Setup the selection handler */
 662     selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(etd->tree_view));
 663     gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
 664
 665     g_signal_connect (G_OBJECT (selection), "changed", /* select_row */
 666                   G_CALLBACK (select_row_cb),
 667                   NULL);
 668
 669     etd->scrolled_window=scrolled_window_new(NULL, NULL);
 670     gtk_container_add(GTK_CONTAINER(etd->scrolled_window), GTK_WIDGET (etd->tree_view));
 671
 672     gtk_box_pack_start(GTK_BOX(vbox), etd->scrolled_window, TRUE, TRUE, 0);
 673 }
 674
 675 static void
 676 expert_dlg_draw(void *data)
 677 {
 678     expert_tapdata_t *etd = (expert_tapdata_t *)data;
 679     expert_info_t *ei;
 680     gchar *title;
 681     const char *entries[2];   /**< column entries */
 682     GtkListStore *list_store, *comments_list_store;
 683     GtkTreeIter iter;
 684     gchar *color_str = NULL;
 685     guint packet_no = 0;
 686     const gchar *group_str;
 687     const gchar *severity_str;
 688
 689
 690     if(etd->label) {
 691         if(etd->last - etd->first) {
 692             title = g_strdup_printf("Adding: %u new messages",etd->last - etd->first);
 693             gtk_label_set_text(GTK_LABEL(etd->label), title);
 694             g_free(title);
 695         }
 696     }
 697
 698     list_store = GTK_LIST_STORE(gtk_tree_view_get_model(etd->tree_view)); /* Get store */
 699     comments_list_store = GTK_LIST_STORE(gtk_tree_view_get_model(etd->tree_view_comments));
 700
 701     /* append new events (remove from new list, append to displayed list and clist) */
 702     while(etd->first < etd->last){
 703         ei = &g_array_index(etd->ei_array, expert_info_t, etd->first);
 704         etd->first++;
 705
 706         if(ei->severity < etd->severity_report_level) {
 707             continue;
 708         }
 709         etd->disp_events++;
 710
 711         /* packet number */
 712         if(ei->packet_num) {
 713             packet_no = ei->packet_num;
 714         }
 715
 716         /*  try_val_to_str return a static string or NULL
 717             severity */
 718         severity_str = try_val_to_str(ei->severity, expert_severity_vals);
 719         /* group */
 720         group_str = try_val_to_str(ei->group, expert_group_vals);
 721
 722         /* protocol */
 723         if(ei->protocol) {
 724             entries[0] = ei->protocol;
 725         } else {
 726             entries[0] = "-";
 727         }
 728
 729         /* summary */
 730         entries[1] = ei->summary;
 731
 732         /* set rows background color depending on severity */
 733         switch(ei->severity) {
 734         case(PI_COMMENT):
 735             color_str = expert_color_comment_str;
 736             gtk_list_store_insert_with_values(comments_list_store , &iter, G_MAXINT,
 737                 NO_COLUMN_C_TABLE, packet_no,
 738                 SUMMARY_COLUMN_C_TABLE, entries[1],
 739                 FOREGROUND_COLOR_COL_C_TABLE, expert_color_foreground_str,
 740                 BACKGROUND_COLOR_COL_C_TABLE, color_str,
 741                 -1);
 742             break;
 743         case(PI_CHAT):
 744             color_str = expert_color_chat_str;
 745             break;
 746         case(PI_NOTE):
 747             color_str = expert_color_note_str;
 748             break;
 749         case(PI_WARN):
 750             color_str = expert_color_warn_str;
 751             break;
 752         case(PI_ERROR):
 753             color_str = expert_color_error_str;
 754             break;
 755         default:
 756             g_assert_not_reached();
 757         }
 758
 759
 760         /* Creates a new row at position. iter will be changed to point to this new row.
 761          * If position is larger than the number of rows on the list, then the new row will be appended to the list.
 762          * The row will be filled with the values given to this function.
 763          * :
 764          * should generally be preferred when inserting rows in a sorted list store.
 765          */
 766         gtk_list_store_insert_with_values( list_store , &iter, G_MAXINT,
 767                     NO_COLUMN, packet_no,
 768                     SEVERITY_COLUMN, severity_str,
 769                     GROUP_COLUMN, group_str,
 770                     PROTOCOL_COLUMN, entries[0],
 771                     SUMMARY_COLUMN, entries[1],
 772                     FOREGROUND_COLOR_COL, expert_color_foreground_str,
 773                     BACKGROUND_COLOR_COL, color_str,
 774                     -1);
 775     }
 776
 777     if(etd->label) {
 778         title = g_strdup_printf("Errors: %u Warnings: %u Notes: %u Chats: %u, Packet comments: %u",
 779                                 etd->error_events, etd->warn_events,
 780                                 etd->note_events, etd->chat_events, etd->pkt_comments_events);
 781         gtk_label_set_text(GTK_LABEL(etd->label), title);
 782         g_free(title);
 783     }
 784
 785     title = g_strdup_printf("Wireshark: %u Expert Info%s",
 786                             etd->disp_events,
 787                             plurality(etd->disp_events, "", "s"));
 788     gtk_window_set_title(GTK_WINDOW(etd->win), title);
 789     g_free(title);
 790 }
 791
 792 static void
 793 expert_comp_init(const char *opt_arg _U_, void* userdata _U_)
 794 {
 795     expert_comp_dlg_t *ss;
 796     GString *error_string;
 797     GtkWidget *temp_page, *details_page, *comments_page;
 798     GtkWidget *main_nb;
 799     GtkWidget *vbox;
 800     GtkWidget *hbox;
 801     GtkWidget *image;
 802     GtkWidget *bbox;
 803     GtkWidget *close_bt;
 804     GtkWidget *help_bt;
 805     GtkWidget *filter_cb;
 806
 807     ss = (expert_comp_dlg_t *)g_malloc(sizeof(expert_comp_dlg_t));
 808
 809     ss->pkt_comments_events = 0;
 810     ss->disp_events = 0;
 811     ss->chat_events = 0;
 812     ss->note_events = 0;
 813     ss->warn_events = 0;
 814     ss->error_events = 0;
 815
 816     expert_comp_dlg_w = ss->win = dlg_window_new_with_geom("Expert Info",
 817         NULL, GTK_WIN_POS_CENTER_ON_PARENT);  /* transient_for top_level */
 818     gtk_window_set_destroy_with_parent (GTK_WINDOW(ss->win), TRUE);
 819     gtk_window_set_default_size(GTK_WINDOW(ss->win), 700, 300);
 820
 821     error_set_title(ss);
 822
 823     vbox = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE);
 824     gtk_container_add(GTK_CONTAINER(ss->win), vbox);
 825     gtk_container_set_border_width(GTK_CONTAINER(vbox), 12);
 826
 827     main_nb = gtk_notebook_new();
 828     gtk_box_pack_start(GTK_BOX(vbox), main_nb, TRUE, TRUE, 0);
 829
 830     /* We must display TOP LEVEL Widget before calling init_table() */
 831     gtk_widget_show_all(ss->win);
 832
 833     /* Errors */
 834     temp_page = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 6, FALSE);
 835     ss->error_label = gtk_label_new("Errors: 0/y");
 836     gtk_widget_show(ss->error_label);
 837     hbox = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
 838     if ( prefs.gui_expert_composite_eyecandy ) {
 839         image = pixbuf_to_widget(expert_error_pb_data);
 840         gtk_widget_show(image);
 841         gtk_box_pack_start(GTK_BOX(hbox), image, TRUE, TRUE, 0);
 842     }
 843     gtk_box_pack_start(GTK_BOX(hbox), ss->error_label, TRUE, TRUE, 0);
 844     gtk_notebook_append_page(GTK_NOTEBOOK(main_nb), temp_page, hbox);
 845     init_error_table(&ss->error_table, 0, temp_page);
 846
 847     /* Warnings */
 848     temp_page = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 6, FALSE);
 849     ss->warn_label = gtk_label_new("Warnings: 0/y");
 850     gtk_widget_show(ss->warn_label);
 851     hbox = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
 852     if ( prefs.gui_expert_composite_eyecandy ) {
 853         image = pixbuf_to_widget(expert_warn_pb_data);
 854         gtk_widget_show(image);
 855         gtk_box_pack_start(GTK_BOX(hbox), image, TRUE, TRUE, 0);
 856
 857     }
 858     gtk_box_pack_start(GTK_BOX(hbox), ss->warn_label, TRUE, TRUE, 0);
 859     gtk_notebook_append_page(GTK_NOTEBOOK(main_nb), temp_page, hbox);
 860     init_error_table(&ss->warn_table, 0, temp_page);
 861
 862     /* Notes */
 863     temp_page = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 6, FALSE);
 864     ss->note_label = gtk_label_new("Notes: 0/y");
 865     gtk_widget_show(ss->note_label);
 866     hbox = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
 867     if ( prefs.gui_expert_composite_eyecandy ) {
 868         image = pixbuf_to_widget(expert_note_pb_data);
 869         gtk_widget_show(image);
 870         gtk_box_pack_start(GTK_BOX(hbox), image, TRUE, TRUE, 0);
 871     }
 872     gtk_box_pack_start(GTK_BOX(hbox), ss->note_label, TRUE, TRUE, 0);
 873     gtk_notebook_append_page(GTK_NOTEBOOK(main_nb), temp_page, hbox);
 874     init_error_table(&ss->note_table, 0, temp_page);
 875
 876     /* Chat */
 877     temp_page = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 6, FALSE);
 878     ss->chat_label = gtk_label_new("Chats: 0/y");
 879     gtk_widget_show(ss->chat_label);
 880     hbox = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
 881     if ( prefs.gui_expert_composite_eyecandy ) {
 882         image = pixbuf_to_widget(expert_chat_pb_data);
 883         gtk_widget_show(image);
 884         gtk_box_pack_start(GTK_BOX(hbox), image, TRUE, TRUE, 0);
 885     }
 886     gtk_box_pack_start(GTK_BOX(hbox), ss->chat_label, TRUE, TRUE, 0);
 887     gtk_notebook_append_page(GTK_NOTEBOOK(main_nb), temp_page, hbox);
 888     init_error_table(&ss->chat_table, 0, temp_page);
 889
 890     /* Details */
 891     details_page = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 6, FALSE);
 892     ss->all_label = gtk_label_new("Details: 0/y");
 893     gtk_widget_show(ss->all_label);
 894     hbox = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
 895     if ( prefs.gui_expert_composite_eyecandy ) {
 896         image = pixbuf_to_widget(capture_comment_disabled_pb_data);
 897         gtk_widget_show(image);
 898         gtk_box_pack_start(GTK_BOX(hbox), image, TRUE, TRUE, 0);
 899     }
 900     gtk_box_pack_start(GTK_BOX(hbox), ss->all_label, TRUE, TRUE, 0);
 901     gtk_notebook_append_page(GTK_NOTEBOOK(main_nb), details_page, hbox);
 902
 903     /* Packet comments */
 904     comments_page = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 6, FALSE);
 905     ss->pkt_comments_label = gtk_label_new("Packet Comments: 0/y");
 906     gtk_widget_show(ss->pkt_comments_label);
 907     hbox = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
 908     if ( prefs.gui_expert_composite_eyecandy ) {
 909         image = pixbuf_to_widget(capture_comment_update_pb_data);
 910         gtk_widget_show(image);
 911         gtk_box_pack_start(GTK_BOX(hbox), image, TRUE, TRUE, 0);
 912     }
 913     gtk_box_pack_start(GTK_BOX(hbox), ss->pkt_comments_label, TRUE, TRUE, 0);
 914     gtk_notebook_append_page(GTK_NOTEBOOK(main_nb), comments_page, hbox);
 915
 916     ss->etd = expert_dlg_new_table();
 917     ss->etd->label=gtk_label_new("Please wait ...");
 918     gtk_misc_set_alignment(GTK_MISC(ss->etd->label), 0.0f, 0.5f);
 919
 920     ss->etd->win=ss->win;
 921     expert_dlg_init_table(ss->etd, details_page);
 922     expert_dlg_init_comments_table(ss->etd, comments_page);
 923
 924     /* Add tap listener functions for expert details, From expert_dlg.c*/
 925     error_string=register_tap_listener("expert", ss->etd, NULL,
 926                                        TL_REQUIRES_NOTHING,
 927                                        expert_dlg_reset,
 928                                        expert_dlg_packet,
 929                                        expert_dlg_draw);
 930     if(error_string){
 931         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
 932         g_string_free(error_string, TRUE);
 933         g_free(ss->etd);
 934         return;
 935     }
 936
 937     g_signal_connect(ss->etd->win, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
 938     g_signal_connect(ss->etd->win, "destroy", G_CALLBACK(expert_dlg_destroy_cb), ss->etd);
 939
 940     /* Register the tap listener */
 941
 942     error_string=register_tap_listener("expert", ss, NULL,
 943         TL_REQUIRES_NOTHING, error_reset, error_packet, expert_comp_draw);
 944     if(error_string){
 945         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
 946         g_string_free(error_string, TRUE);
 947         g_free(ss);
 948         return;
 949     }
 950
 951     hbox = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DLG_UNRELATED_SPACING, FALSE);
 952     gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 953
 954     filter_cb = gtk_check_button_new_with_mnemonic("Limit to display filter");
 955     gtk_box_pack_start(GTK_BOX(hbox), filter_cb, FALSE, FALSE, 0);
 956     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(filter_cb), FALSE);
 957     gtk_widget_set_tooltip_text(filter_cb, "Limit the expert infos to packets matching the current display filter.");
 958     g_signal_connect(filter_cb, "toggled", G_CALLBACK(expert_comp_select_filter_cb), ss);
 959
 960     /* Button row. */
 961     bbox = dlg_button_row_new(GTK_STOCK_CLOSE, GTK_STOCK_HELP, NULL);
 962     gtk_box_pack_end(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
 963
 964     close_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLOSE);
 965     window_set_cancel_button(ss->win, close_bt, window_cancel_button_cb);
 966
 967     help_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP);
 968     g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb), (gpointer)HELP_EXPERT_INFO_DIALOG);
 969     gtk_widget_set_tooltip_text (help_bt, "Show topic specific help");
 970
 971     g_signal_connect(ss->win, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
 972     g_signal_connect(ss->win, "destroy", G_CALLBACK(win_destroy_cb), ss);
 973
 974     gtk_widget_show_all(ss->win);
 975     window_present(ss->win);
 976
 977     /*
 978      * At least at present, the only information the tap listener appears
 979      * to care about is available regardless of whether the protocol tree
 980      * is being built, so we don't appear to need to have the protocol
 981      * tree built.
 982      *
 983      * This means we can use cf_retap_packets(), even though it will only
 984      * build the protocol tree if at least one tap has a filter in place.
 985      * cf_retap_packets() is faster than cf_redissect_packets(), as it
 986      * assumes we didn't change anything that would cause any packets to
 987      * dissect differently, and thus doesn't redo the packet display.
 988      */
 989     cf_retap_packets(&cfile);
 990
 991     /* This will bring up the progress bar
 992      * Put our window back in front
 993      */
 994     gdk_window_raise(gtk_widget_get_window(ss->win));
 995     /* Set the label text */
 996     expert_comp_draw(ss);
 997 }
 998
 999 void
1000 expert_comp_dlg_launch(void)
1001 {
1002     if (expert_comp_dlg_w) {
1003         reactivate_window(expert_comp_dlg_w);
1004     } else {
1005         expert_comp_init("", NULL);
1006     }
1007 }
1008
1009 static stat_tap_ui expert_comp_ui = {
1010     REGISTER_STAT_GROUP_GENERIC,
1011     NULL,
1012     "expert_comp",
1013     expert_comp_init,
1014     -1,
1015     0,
1016     NULL
1017 };
1018
1019 void
1020 register_tap_listener_expert_comp(void)
1021 {
1022     register_stat_tap_ui(&expert_comp_ui, NULL);
1023 }
1024
1025 void
1026 expert_comp_packet_comment_updated(void)
1027 {
1028     if (expert_comp_dlg_w)
1029         cf_retap_packets(&cfile);
1030 }