gtk/expert_dlg.c

   1 /* expert_dlg.c
   2  * Display of Expert information.
   3  *
   4  * Implemented as a tap listener to the "expert" tap.
   5  *
   6  * $Id$
   7  *
   8  * Wireshark - Network traffic analyzer
   9  * By Gerald Combs <gerald@wireshark.org>
  10  * Copyright 1998 Gerald Combs
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30 #include <string.h>
  31 #include <stdlib.h>
  32 #include <stdio.h>
  33 #include <math.h>
  34
  35 #include <gtk/gtk.h>
  36
  37 #include <epan/packet.h>
  38 #include <epan/expert.h>
  39 #include <epan/emem.h>
  40 #include <epan/tap.h>
  41 #include "epan/packet_info.h"
  42 #include <epan/stat_cmd_args.h>
  43 #include <epan/prefs.h>
  44
  45 #include "../simple_dialog.h"
  46 #include "../globals.h"
  47 #include "../color.h"
  48 #include "../stat_menu.h"
  49
  50 #include "gtk/find_dlg.h"
  51 #include "gtk/color_dlg.h"
  52 #include "gtk/main.h"
  53 #include "gtk/gui_utils.h"
  54 #include "gtk/gtkglobals.h"
  55 #include "gtk/dlg_utils.h"
  56 #include "gtk/gui_stat_menu.h"
  57 #include "gtk/tap_dfilter_dlg.h"
  58 #include "gtk/color_utils.h"
  59 #include "gtk/main_proto_draw.h"
  60 #include "gtk/help_dlg.h"
  61 #include "gtk/expert_dlg.h"
  62 #include "gtk/font_utils.h"
  63
  64 static const value_string expert_severity_om_vals[] = {
  65     { PI_ERROR, "Errors only" },
  66     { PI_WARN,  "Error+Warn" },
  67     { PI_NOTE,  "Error+Warn+Note" },
  68     { PI_CHAT,  "Error+Warn+Note+Chat" },
  69     { 0, NULL }
  70 };
  71
  72 enum
  73 {
  74     NO_COLUMN,
  75     SEVERITY_COLUMN,
  76     GROUP_COLUMN,
  77     PROTOCOL_COLUMN,
  78     SUMMARY_COLUMN,
  79     FOREGROUND_COLOR_COL,
  80     BACKGROUND_COLOR_COL,
  81     N_COLUMNS
  82 };
  83
  84 /* reset of display only, e.g. for filtering */
  85 static void expert_dlg_display_reset(expert_tapdata_t * etd)
  86 {
  87     etd->disp_events = 0;
  88     gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(etd->tree_view))));
  89
  90     gtk_window_set_title(GTK_WINDOW(etd->win), "Wireshark: ? Expert Infos");
  91     if(etd->label) {
  92         gtk_label_set_text(GTK_LABEL(etd->label), "Please wait ...");
  93     }
  94 }
  95
  96
  97 /* complete reset, e.g. capture file closed */
  98 void expert_dlg_reset(void *tapdata)
  99 {
 100     expert_tapdata_t * etd = tapdata;
 101
 102     etd->chat_events = 0;
 103     etd->note_events = 0;
 104     etd->warn_events = 0;
 105     etd->error_events = 0;
 106     etd->last = 0;
 107     etd->first = 0;
 108     /* g_string_chunk_clear() is introduced in glib 2.14 */
 109     g_string_chunk_free(etd->text);
 110     etd->text = g_string_chunk_new(100);
 111     g_array_set_size(etd->ei_array, 0);
 112
 113     expert_dlg_display_reset(etd);
 114 }
 115
 116 int expert_dlg_packet(void *tapdata, packet_info *pinfo _U_, epan_dissect_t *edt _U_, const void *pointer)
 117 {
 118     expert_info_t    *ei;
 119     expert_tapdata_t *etd = tapdata;
 120
 121     g_array_append_val(etd->ei_array, *(expert_info_t *)pointer);
 122     etd->last = etd->ei_array->len;
 123     ei = &g_array_index(etd->ei_array, expert_info_t, etd->last -1); /* ugly */
 124     ei->protocol = g_string_chunk_insert_const(etd->text, ei->protocol);
 125     ei->summary = g_string_chunk_insert_const(etd->text, ei->summary);
 126
 127     switch(ei->severity) {
 128     case(PI_CHAT):
 129         etd->chat_events++;
 130         break;
 131     case(PI_NOTE):
 132         etd->note_events++;
 133         break;
 134     case(PI_WARN):
 135         etd->warn_events++;
 136         break;
 137     case(PI_ERROR):
 138         etd->error_events++;
 139         break;
 140     default:
 141         g_assert_not_reached();
 142     }
 143     if(ei->severity < etd->severity_report_level) {
 144         return 0; /* draw not required */
 145     } else {
 146         return 1; /* draw required */
 147     }
 148 }
 149
 150 void
 151 expert_dlg_draw(void *data)
 152 {
 153     expert_tapdata_t *etd = data;
 154     expert_info_t *ei;
 155     gchar *title;
 156     const char *entries[4];   /**< column entries */
 157     GtkListStore *list_store;
 158     GtkTreeIter iter;
 159     gchar *color_str;
 160     guint packet_no = 0;
 161
 162
 163     if(etd->label) {
 164         if(etd->last - etd->first) {
 165             title = g_strdup_printf("Adding: %u new messages",etd->last - etd->first);
 166             gtk_label_set_text(GTK_LABEL(etd->label), title);
 167             g_free(title);
 168         }
 169     }
 170
 171     /* append new events (remove from new list, append to displayed list and clist) */
 172     while(etd->first < etd->last){
 173         ei = &g_array_index(etd->ei_array, expert_info_t, etd->first);
 174         etd->first++;
 175
 176         if(ei->severity < etd->severity_report_level) {
 177             continue;
 178         }
 179         etd->disp_events++;
 180
 181         /* packet number */
 182         if(ei->packet_num) {
 183             packet_no = ei->packet_num;
 184         }
 185
 186         /* severity */
 187         entries[0] = val_to_str(ei->severity, expert_severity_vals, "Unknown severity (%u)");
 188
 189         /* group */
 190         entries[1] = val_to_str(ei->group, expert_group_vals, "Unknown group (%u)");
 191
 192         /* protocol */
 193         if(ei->protocol) {
 194             entries[2] = ei->protocol;
 195         } else {
 196             entries[2] = "-";
 197         }
 198
 199         /* summary */
 200         entries[3] = ei->summary;
 201
 202         /* set rows background color depending on severity */
 203         switch(ei->severity) {
 204         case(PI_CHAT):
 205             color_str = expert_color_chat_str;
 206             break;
 207         case(PI_NOTE):
 208             color_str = expert_color_note_str;
 209             break;
 210         case(PI_WARN):
 211             color_str = expert_color_warn_str;
 212             break;
 213         case(PI_ERROR):
 214             color_str = expert_color_error_str;
 215             break;
 216         default:
 217             g_assert_not_reached();
 218         }
 219
 220         list_store = GTK_LIST_STORE(gtk_tree_view_get_model(etd->tree_view)); /* Get store */
 221
 222         /* Creates a new row at position. iter will be changed to point to this new row.
 223          * If position is larger than the number of rows on the list, then the new row will be appended to the list.
 224          * The row will be filled with the values given to this function.
 225          * :
 226          * should generally be preferred when inserting rows in a sorted list store.
 227          */
 228 #if GTK_CHECK_VERSION(2,6,0)
 229         gtk_list_store_insert_with_values( list_store , &iter, G_MAXINT,
 230 #else
 231         gtk_list_store_append  (list_store, &iter);
 232         gtk_list_store_set  (list_store, &iter,
 233 #endif
 234                     NO_COLUMN, packet_no,
 235                     SEVERITY_COLUMN, entries[0],
 236                     GROUP_COLUMN, entries[1],
 237                     PROTOCOL_COLUMN, entries[2],
 238                     SUMMARY_COLUMN, entries[3],
 239                     FOREGROUND_COLOR_COL, expert_color_foreground_str,
 240                     BACKGROUND_COLOR_COL, color_str,
 241                     -1);
 242     }
 243
 244     if(etd->label) {
 245         title = g_strdup_printf("Errors: %u Warnings: %u Notes: %u Chats: %u",
 246                                 etd->error_events, etd->warn_events,
 247                                 etd->note_events, etd->chat_events);
 248         gtk_label_set_text(GTK_LABEL(etd->label), title);
 249         g_free(title);
 250     }
 251
 252     title = g_strdup_printf("Wireshark: %u Expert Info%s",
 253                             etd->disp_events,
 254                             plurality(etd->disp_events, "", "s"));
 255     gtk_window_set_title(GTK_WINDOW(etd->win), title);
 256     g_free(title);
 257 }
 258
 259 static void
 260 select_row_cb(GtkTreeSelection *selection, gpointer *user_data _U_)
 261 {
 262     /*guint num = GPOINTER_TO_UINT(gtk_clist_get_row_data(clist, row));*/
 263
 264     /*cf_goto_frame(&cfile, num);*/
 265
 266     GtkTreeIter iter;
 267     GtkTreeModel *model;
 268     guint fnumber;
 269
 270     if (selection==NULL)
 271         return;
 272
 273     if (gtk_tree_selection_get_selected (selection, &model, &iter)){
 274         gtk_tree_model_get (model, &iter, NO_COLUMN, &fnumber, -1);
 275         cf_goto_frame(&cfile, fnumber);
 276     }
 277
 278 }
 279
 280 void
 281 expert_dlg_init_table(expert_tapdata_t * etd, GtkWidget *vbox)
 282 {
 283     GtkListStore *store;
 284     GtkWidget *tree;
 285     GtkTreeViewColumn *column;
 286     GtkCellRenderer *renderer;
 287     GtkTreeSortable *sortable;
 288     GtkTreeSelection  *selection;
 289
 290     /* Create the store */
 291     store = gtk_list_store_new(N_COLUMNS,        /* Total number of columns */
 292                                G_TYPE_UINT,      /* No                   */
 293                                G_TYPE_STRING,    /* Severity           */
 294                                G_TYPE_STRING,    /* Group              */
 295                                G_TYPE_STRING,    /* Protocol           */
 296                                G_TYPE_STRING,    /* Summary            */
 297                                G_TYPE_STRING,    /* forground          */
 298                                G_TYPE_STRING);   /* Background         */
 299
 300     /* Create a view */
 301     tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
 302     etd->tree_view = GTK_TREE_VIEW(tree);
 303     sortable = GTK_TREE_SORTABLE(store);
 304
 305 #if GTK_CHECK_VERSION(2,6,0)
 306     /* Speed up the list display */
 307     gtk_tree_view_set_fixed_height_mode(etd->tree_view, TRUE);
 308 #endif
 309
 310     /* Setup the sortable columns */
 311     gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW (tree), FALSE);
 312
 313     /* The view now holds a reference.  We can get rid of our own reference */
 314     g_object_unref (G_OBJECT (store));
 315
 316     /* Create a cell renderer */
 317     renderer = gtk_cell_renderer_text_new ();
 318
 319     /* Create the first column, associating the "text" attribute of the
 320      * cell_renderer to the first column of the model */
 321     /* No */
 322     column = gtk_tree_view_column_new_with_attributes ("No", renderer,
 323         "text", NO_COLUMN,
 324         "foreground", FOREGROUND_COLOR_COL,
 325         "background", BACKGROUND_COLOR_COL,
 326         NULL);
 327     gtk_tree_view_column_set_sort_column_id(column, NO_COLUMN);
 328     gtk_tree_view_column_set_resizable(column, TRUE);
 329     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 330     gtk_tree_view_column_set_min_width(column, 80);
 331     gtk_tree_view_append_column (etd->tree_view, column);
 332
 333     /* Severity */
 334     renderer = gtk_cell_renderer_text_new ();
 335     column = gtk_tree_view_column_new_with_attributes ("Severity", renderer,
 336         "text", SEVERITY_COLUMN,
 337         "foreground", FOREGROUND_COLOR_COL,
 338         "background", BACKGROUND_COLOR_COL,
 339         NULL);
 340     gtk_tree_view_column_set_sort_column_id(column, SEVERITY_COLUMN);
 341     gtk_tree_view_column_set_resizable(column, TRUE);
 342     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 343     gtk_tree_view_column_set_min_width(column, 80);
 344     /* Add the column to the view. */
 345     gtk_tree_view_append_column (etd->tree_view, column);
 346
 347     /* Group */
 348     renderer = gtk_cell_renderer_text_new ();
 349     column = gtk_tree_view_column_new_with_attributes ("Group", renderer,
 350         "text", GROUP_COLUMN,
 351         "foreground", FOREGROUND_COLOR_COL,
 352         "background", BACKGROUND_COLOR_COL,
 353         NULL);
 354     gtk_tree_view_column_set_sort_column_id(column, GROUP_COLUMN);
 355     gtk_tree_view_column_set_resizable(column, TRUE);
 356     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 357     gtk_tree_view_column_set_min_width(column, 80);
 358     /* Add the column to the view. */
 359     gtk_tree_view_append_column (etd->tree_view, column);
 360
 361     /* Protocol. */
 362     renderer = gtk_cell_renderer_text_new ();
 363     column = gtk_tree_view_column_new_with_attributes ("Protocol", renderer,
 364         "text", PROTOCOL_COLUMN,
 365         "foreground", FOREGROUND_COLOR_COL,
 366         "background", BACKGROUND_COLOR_COL,
 367         NULL);
 368     gtk_tree_view_column_set_sort_column_id(column, PROTOCOL_COLUMN);
 369     gtk_tree_view_column_set_resizable(column, TRUE);
 370     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 371     gtk_tree_view_column_set_min_width(column, 80);
 372     gtk_tree_view_append_column (etd->tree_view, column);
 373
 374     /* Summary. */
 375     renderer = gtk_cell_renderer_text_new ();
 376     column = gtk_tree_view_column_new_with_attributes ("Summary", renderer,
 377         "text", SUMMARY_COLUMN,
 378         "foreground", FOREGROUND_COLOR_COL,
 379         "background", BACKGROUND_COLOR_COL,
 380         NULL);
 381     gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 382     gtk_tree_view_column_set_min_width(column, 90);
 383     gtk_tree_view_column_set_sort_column_id(column, SUMMARY_COLUMN);
 384     gtk_tree_view_column_set_resizable(column, TRUE);
 385     gtk_tree_view_append_column (etd->tree_view, column);
 386
 387
 388     gtk_tree_view_set_search_column (etd->tree_view, SUMMARY_COLUMN); /* Allow searching the summary */
 389     gtk_tree_view_set_reorderable (etd->tree_view, TRUE);   /* Allow user to reorder data with drag n drop */
 390
 391     /* Now enable the sorting of each column */
 392     gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(etd->tree_view), TRUE);
 393     gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(etd->tree_view), TRUE);
 394
 395     /* Setup the selection handler */
 396     selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(etd->tree_view));
 397     gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
 398
 399     g_signal_connect (G_OBJECT (selection), "changed", /* select_row */
 400                   G_CALLBACK (select_row_cb),
 401                   NULL);
 402
 403     etd->scrolled_window=scrolled_window_new(NULL, NULL);
 404     gtk_container_add(GTK_CONTAINER(etd->scrolled_window), GTK_WIDGET (etd->tree_view));
 405
 406     gtk_box_pack_start(GTK_BOX(vbox), etd->scrolled_window, TRUE, TRUE, 0);
 407 }
 408
 409
 410 void
 411 expert_dlg_destroy_cb(GtkWindow *win _U_, gpointer data)
 412 {
 413     expert_tapdata_t *etd=(expert_tapdata_t *)data;
 414
 415     protect_thread_critical_region();
 416     remove_tap_listener(etd);
 417     unprotect_thread_critical_region();
 418
 419     /*free_srt_table_data(&etd->afp_srt_table);*/
 420     g_array_free(etd->ei_array, TRUE);
 421     g_string_chunk_free(etd->text);
 422     g_free(etd);
 423 }
 424
 425
 426 static void
 427 expert_dlg_severity_cb(GtkWidget *w, gpointer data _U_)
 428 {
 429     int i;
 430     expert_tapdata_t * etd;
 431
 432     i = gtk_combo_box_get_active (GTK_COMBO_BOX(w));
 433     etd = g_object_get_data(G_OBJECT(w), "tapdata");
 434
 435     etd->severity_report_level = expert_severity_om_vals[i].value;
 436
 437     /* "move" all events from "all" back to "new" lists */
 438     protect_thread_critical_region();
 439     etd->first = 0;
 440     unprotect_thread_critical_region();
 441
 442     /* redraw table */
 443     expert_dlg_display_reset(etd);
 444     expert_dlg_draw(etd);
 445 }
 446
 447 expert_tapdata_t * expert_dlg_new_table(void)
 448 {
 449     expert_tapdata_t * etd;
 450     etd=g_malloc0(sizeof(expert_tapdata_t));
 451
 452     etd->ei_array = g_array_sized_new(FALSE, FALSE, sizeof(expert_info_t), 1000);
 453     etd->text = g_string_chunk_new(100);
 454     etd->severity_report_level = PI_CHAT;
 455     return etd;
 456 }
 457
 458 static void
 459 expert_dlg_init(const char *optarg, void* userdata _U_)
 460 {
 461     expert_tapdata_t * etd;
 462     const char *filter=NULL;
 463     GString *error_string;
 464     GtkWidget *vbox;
 465     GtkWidget *table;
 466     GtkWidget *bbox;
 467     GtkWidget *close_bt;
 468     GtkWidget *help_bt;
 469
 470     GtkWidget *severity_box;
 471     GtkWidget *severity_combo_box;
 472     GtkWidget *label;
 473     GtkTooltips *tooltips = gtk_tooltips_new();
 474     int i;
 475
 476     if(!strncmp(optarg,"afp,srt,",8)){
 477         filter=optarg+8;
 478     } else {
 479         filter=NULL;
 480     }
 481
 482     proto_draw_colors_init();
 483
 484     etd = expert_dlg_new_table();
 485     etd->win=dlg_window_new("Wireshark: Expert Info");    /* transient_for top_level */
 486     gtk_window_set_destroy_with_parent (GTK_WINDOW(etd->win), TRUE);
 487
 488     gtk_window_set_default_size(GTK_WINDOW(etd->win), 650, 600);
 489
 490     vbox=gtk_vbox_new(FALSE, 3);
 491     gtk_container_add(GTK_CONTAINER(etd->win), vbox);
 492     gtk_container_set_border_width(GTK_CONTAINER(vbox), 12);
 493
 494     table = gtk_table_new(1, 2, TRUE /* homogeneous */);
 495     gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
 496
 497     etd->label=gtk_label_new("Please wait ...");
 498     gtk_misc_set_alignment(GTK_MISC(etd->label), 0.0f, 0.5f);
 499     gtk_table_attach_defaults(GTK_TABLE(table), etd->label, 0, 1, 0, 1);
 500
 501     severity_box = gtk_hbox_new(FALSE, 0);
 502     gtk_table_attach_defaults(GTK_TABLE(table), severity_box, 1, 2, 0, 1);
 503
 504     label=gtk_label_new("Severity filter: ");
 505     gtk_box_pack_start(GTK_BOX(severity_box), label, FALSE, FALSE, 0);
 506
 507     severity_combo_box = gtk_combo_box_new_text ();
 508     for(i=0; expert_severity_om_vals[i].strptr != NULL;i++){
 509         gtk_combo_box_append_text (GTK_COMBO_BOX (severity_combo_box), expert_severity_om_vals[i].strptr);
 510         if(expert_severity_om_vals[i].value == (guint) etd->severity_report_level) {
 511             gtk_combo_box_set_active(GTK_COMBO_BOX(severity_combo_box), i);
 512         }
 513     }
 514
 515     g_object_set_data(G_OBJECT(severity_combo_box), "tapdata", etd);
 516     g_signal_connect(severity_combo_box, "changed", G_CALLBACK(expert_dlg_severity_cb), etd->win);
 517     gtk_box_pack_start(GTK_BOX(severity_box), severity_combo_box, FALSE, FALSE, 0);
 518
 519
 520     /* We must display TOP LEVEL Widget before calling init_srt_table() */
 521     gtk_widget_show_all(etd->win);
 522
 523     expert_dlg_init_table(etd, vbox);
 524     /*for(i=0;i<256;i++){
 525         init_srt_table_row(&etd->afp_srt_table, i, val_to_str(i, CommandCode_vals, "Unknown(%u)"));
 526     }*/
 527
 528     error_string=register_tap_listener("expert", etd, NULL /* fstring */,
 529         TL_REQUIRES_PROTO_TREE,
 530         expert_dlg_reset,
 531         expert_dlg_packet,
 532         expert_dlg_draw);
 533     if(error_string){
 534         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
 535         g_string_free(error_string, TRUE);
 536         g_free(etd);
 537         return;
 538     }
 539
 540     /* Button row. */
 541     bbox = dlg_button_row_new(GTK_STOCK_CLOSE, GTK_STOCK_HELP, NULL);
 542     gtk_box_pack_end(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
 543
 544     close_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLOSE);
 545     window_set_cancel_button(etd->win, close_bt, window_cancel_button_cb);
 546
 547     help_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP);
 548     g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb), (gpointer)HELP_EXPERT_INFO_DIALOG);
 549     gtk_tooltips_set_tip (tooltips, help_bt, "Show topic specific help", NULL);
 550
 551     g_signal_connect(etd->win, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
 552     g_signal_connect(etd->win, "destroy", G_CALLBACK(expert_dlg_destroy_cb), etd);
 553
 554     gtk_widget_show_all(etd->win);
 555     window_present(etd->win);
 556
 557     cf_retap_packets(&cfile);
 558
 559     /* This will bring up the progress bar
 560      * Put our window back in front
 561      */
 562     gdk_window_raise(etd->win->window);
 563     expert_dlg_draw(etd);
 564 }
 565
 566 static void
 567 expert_dlg_cb(GtkWidget *w _U_, gpointer d _U_)
 568 {
 569     expert_dlg_init("", NULL);
 570 }
 571
 572 void
 573 register_tap_listener_expert(void)
 574 {
 575     register_stat_cmd_arg("expert", expert_dlg_init,NULL);
 576
 577     register_stat_menu_item("E_xpert Info", REGISTER_ANALYZE_GROUP_UNSORTED,
 578         expert_dlg_cb, NULL, NULL, NULL);
 579 }