gtk/dcerpc_stat.c

   1 /* dcerpc_stat.c
   2  * dcerpc_stat   2002 Ronnie Sahlberg
   3  *
   4  * $Id$
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23  */
  24
  25 /* This module provides rpc call/reply SRT statistics to Wireshark,
  26  * and displays them graphically.
  27  * It is only used by Wireshark and not tshark
  28  *
  29  * It serves as an example on how to use the tap api.
  30  */
  31
  32 #ifdef HAVE_CONFIG_H
  33 # include "config.h"
  34 #endif
  35
  36 #include <stdio.h>
  37 #include <string.h>
  38
  39 #include <gtk/gtk.h>
  40
  41 #include <epan/packet_info.h>
  42 #include <epan/epan.h>
  43 #include <epan/stat_cmd_args.h>
  44 #include <epan/tap.h>
  45 #include <epan/dissectors/packet-dcerpc.h>
  46
  47 #include "../stat_menu.h"
  48 #include "../simple_dialog.h"
  49
  50 #include "gtk/gui_stat_menu.h"
  51 #include "gtk/dlg_utils.h"
  52 #include "gtk/gui_utils.h"
  53 #include "gtk/filter_dlg.h"
  54 #include "gtk/stock_icons.h"
  55 #include "gtk/service_response_time_table.h"
  56 #include "gtk/gtkglobals.h"
  57 #include "gtk/main.h"
  58 #include "gtk/filter_autocomplete.h"
  59
  60 #include "gtk/old-gtk-compat.h"
  61
  62 /* used to keep track of the statistics for an entire program interface */
  63 typedef struct _dcerpcstat_t {
  64         GtkWidget *win;
  65         srt_stat_table srt_table;
  66         const char *prog;
  67         e_uuid_t uuid;
  68         guint16 ver;
  69         int num_procedures;
  70 } dcerpcstat_t;
  71
  72
  73 static gboolean
  74 uuid_equal(e_uuid_t *uuid1, e_uuid_t *uuid2)
  75 {
  76         if( (uuid1->Data1    != uuid2->Data1)
  77           ||(uuid1->Data2    != uuid2->Data2)
  78           ||(uuid1->Data3    != uuid2->Data3)
  79           ||(uuid1->Data4[0] != uuid2->Data4[0])
  80           ||(uuid1->Data4[1] != uuid2->Data4[1])
  81           ||(uuid1->Data4[2] != uuid2->Data4[2])
  82           ||(uuid1->Data4[3] != uuid2->Data4[3])
  83           ||(uuid1->Data4[4] != uuid2->Data4[4])
  84           ||(uuid1->Data4[5] != uuid2->Data4[5])
  85           ||(uuid1->Data4[6] != uuid2->Data4[6])
  86           ||(uuid1->Data4[7] != uuid2->Data4[7]) ){
  87                 return FALSE;
  88         }
  89         return TRUE;
  90 }
  91
  92 static char *
  93 dcerpcstat_gen_title(dcerpcstat_t *rs)
  94 {
  95         char *title;
  96
  97         title = g_strdup_printf("DCE-RPC Service Response Time statistics for %s major version %u: %s", rs->prog, rs->ver, cf_get_display_name(&cfile));
  98         return title;
  99 }
 100
 101 static void
 102 dcerpcstat_set_title(dcerpcstat_t *rs)
 103 {
 104         char *title;
 105
 106         title = dcerpcstat_gen_title(rs);
 107         gtk_window_set_title(GTK_WINDOW(rs->win), title);
 108         g_free(title);
 109 }
 110
 111 static void
 112 dcerpcstat_reset(void *rs_arg)
 113 {
 114         dcerpcstat_t *rs = rs_arg;
 115
 116         reset_srt_table_data(&rs->srt_table);
 117         dcerpcstat_set_title(rs);
 118 }
 119
 120
 121 static gboolean
 122 dcerpcstat_packet(void *rs_arg, packet_info *pinfo, epan_dissect_t *edt _U_, const void *ri_arg)
 123 {
 124         dcerpcstat_t *rs = rs_arg;
 125         const dcerpc_info *ri = ri_arg;
 126
 127         if(!ri->call_data){
 128                 return FALSE;
 129         }
 130         if(!ri->call_data->req_frame){
 131                 /* we have not seen the request so we don't know the delta*/
 132                 return FALSE;
 133         }
 134         if(ri->call_data->opnum >= rs->num_procedures){
 135                 /* don't handle this since its outside of known table */
 136                 return FALSE;
 137         }
 138
 139         /* we are only interested in reply packets */
 140         if(ri->ptype != PDU_RESP){
 141                 return FALSE;
 142         }
 143
 144         /* we are only interested in certain program/versions */
 145         if( (!uuid_equal( (&ri->call_data->uuid), (&rs->uuid)))
 146           ||(ri->call_data->ver != rs->ver)){
 147                 return FALSE;
 148         }
 149
 150
 151         add_srt_table_data(&rs->srt_table, ri->call_data->opnum, &ri->call_data->req_time, pinfo);
 152
 153
 154         return TRUE;
 155 }
 156
 157 static void
 158 dcerpcstat_draw(void *rs_arg)
 159 {
 160         dcerpcstat_t *rs = rs_arg;
 161
 162         draw_srt_table_data(&rs->srt_table);
 163 }
 164
 165
 166 /* since the gtk2 implementation of tap is multithreaded we must protect
 167  * remove_tap_listener() from modifying the list while draw_tap_listener()
 168  * is running.  the other protected block is in main.c
 169  *
 170  * there should not be any other critical regions in gtk2
 171  */
 172 static void
 173 win_destroy_cb(GtkWindow *win _U_, gpointer data)
 174 {
 175         dcerpcstat_t *rs = (dcerpcstat_t *)data;
 176
 177         protect_thread_critical_region();
 178         remove_tap_listener(rs);
 179         unprotect_thread_critical_region();
 180
 181         free_srt_table_data(&rs->srt_table);
 182         g_free(rs);
 183 }
 184
 185
 186
 187 /* When called, this function will create a new instance of gtk-dcerpcstat.
 188  */
 189 static void
 190 gtk_dcerpcstat_init(const char *optarg, void* userdata _U_)
 191 {
 192         dcerpcstat_t *rs;
 193         guint32 i, max_procs;
 194         char *title_string;
 195         char *filter_string;
 196         GtkWidget *vbox;
 197         GtkWidget *stat_label;
 198         GtkWidget *filter_label;
 199         GtkWidget *bbox;
 200         GtkWidget *close_bt;
 201         dcerpc_sub_dissector *procs;
 202         e_uuid_t uuid;
 203         guint d1,d2,d3,d40,d41,d42,d43,d44,d45,d46,d47;
 204         int major, minor;
 205         guint16 ver;
 206         int pos = 0;
 207         const char *filter = NULL;
 208         GString *error_string;
 209         int hf_opnum;
 210
 211         /*
 212          * XXX - DCE RPC statistics are maintained only by major version,
 213          * not by major and minor version, so the minor version number is
 214          * ignored.
 215          *
 216          * Should we just stop supporting minor version numbers here?
 217          * Or should we allow it to be omitted?  Or should we keep
 218          * separate statistics for different minor version numbers,
 219          * and allow the minor version number to be omitted, and
 220          * report aggregate statistics for all minor version numbers
 221          * if it's omitted?
 222          */
 223         if(sscanf(
 224                    optarg,
 225                    "dcerpc,srt,%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x,%d.%d,%n",
 226                    &d1,&d2,&d3,&d40,&d41,&d42,&d43,&d44,&d45,&d46,&d47,&major,&minor,&pos)
 227            == 13) {
 228                 uuid.Data1    = d1;
 229                 uuid.Data2    = d2;
 230                 uuid.Data3    = d3;
 231                 uuid.Data4[0] = d40;
 232                 uuid.Data4[1] = d41;
 233                 uuid.Data4[2] = d42;
 234                 uuid.Data4[3] = d43;
 235                 uuid.Data4[4] = d44;
 236                 uuid.Data4[5] = d45;
 237                 uuid.Data4[6] = d46;
 238                 uuid.Data4[7] = d47;
 239                 if(pos) {
 240                         filter = optarg+pos;
 241                 } else {
 242                         filter = NULL;
 243                 }
 244         } else {
 245                 fprintf(stderr, "wireshark: invalid \"-z dcerpc,srt,<uuid>,<major version>.<minor version>[,<filter>]\" argument\n");
 246                 exit(1);
 247         }
 248         if ((major < 0) || (major > 65535)) {
 249                 fprintf(stderr,"wireshark: dcerpcstat_init() Major version number %d is invalid - must be positive and <= 65535\n", major);
 250                 exit(1);
 251         }
 252         if ((minor < 0) || (minor > 65535)) {
 253                 fprintf(stderr,"wireshark: dcerpcstat_init() Minor version number %d is invalid - must be positive and <= 65535\n", minor);
 254                 exit(1);
 255         }
 256         ver = major;
 257
 258         rs = g_malloc(sizeof(dcerpcstat_t));
 259         rs->prog = dcerpc_get_proto_name(&uuid, ver);
 260         if(!rs->prog){
 261                 g_free(rs);
 262                 fprintf(stderr,
 263                         "wireshark: dcerpcstat_init() Protocol with uuid:%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x v%u not supported\n",
 264                         uuid.Data1,uuid.Data2,uuid.Data3,uuid.Data4[0],uuid.Data4[1],uuid.Data4[2],uuid.Data4[3],uuid.Data4[4],uuid.Data4[5],uuid.Data4[6],uuid.Data4[7],ver);
 265                 exit(1);
 266         }
 267         hf_opnum = dcerpc_get_proto_hf_opnum(&uuid, ver);
 268         procs    = dcerpc_get_proto_sub_dissector(&uuid, ver);
 269         rs->uuid = uuid;
 270         rs->ver  = ver;
 271
 272         rs->win  = dlg_window_new("dcerpc-stat");  /* transient_for top_level */
 273         gtk_window_set_destroy_with_parent(GTK_WINDOW(rs->win), TRUE);
 274
 275         dcerpcstat_set_title(rs);
 276         gtk_window_set_default_size(GTK_WINDOW(rs->win), 550, 400);
 277
 278         vbox = gtk_vbox_new(FALSE, 3);
 279         gtk_container_add(GTK_CONTAINER(rs->win), vbox);
 280         gtk_container_set_border_width(GTK_CONTAINER(vbox), 12);
 281
 282         title_string = dcerpcstat_gen_title(rs);
 283         stat_label   = gtk_label_new(title_string);
 284         g_free(title_string);
 285         gtk_box_pack_start(GTK_BOX(vbox), stat_label, FALSE, FALSE, 0);
 286
 287         filter_string = g_strdup_printf("Filter: %s",filter ? filter : "");
 288         filter_label  = gtk_label_new(filter_string);
 289         g_free(filter_string);
 290         gtk_label_set_line_wrap(GTK_LABEL(filter_label), TRUE);
 291         gtk_box_pack_start(GTK_BOX(vbox), filter_label, FALSE, FALSE, 0);
 292
 293         for(i=0,max_procs=0;procs[i].name;i++){
 294                 if(procs[i].num>max_procs){
 295                         max_procs = procs[i].num;
 296                 }
 297         }
 298         rs->num_procedures = max_procs+1;
 299
 300         /* We must display TOP LEVEL Widget before calling init_srt_table() */
 301         gtk_widget_show_all(rs->win);
 302
 303         if(hf_opnum != -1){
 304                 init_srt_table(&rs->srt_table, max_procs+1, vbox, proto_registrar_get_nth(hf_opnum)->abbrev);
 305         } else {
 306                 init_srt_table(&rs->srt_table, max_procs+1, vbox, NULL);
 307         }
 308
 309         for(i=0;i<(max_procs+1);i++){
 310                 int j;
 311                 const char *proc_name;
 312
 313                 proc_name = "unknown";
 314                 for(j=0;procs[j].name;j++){
 315                         if (procs[j].num == i){
 316                                 proc_name = procs[j].name;
 317                         }
 318                 }
 319
 320                 init_srt_table_row(&rs->srt_table, i, proc_name);
 321         }
 322
 323
 324         error_string = register_tap_listener("dcerpc", rs, filter, 0, dcerpcstat_reset, dcerpcstat_packet, dcerpcstat_draw);
 325         if(error_string){
 326                 /* error, we failed to attach to the tap. clean up */
 327                 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
 328                 g_string_free(error_string, TRUE);
 329                 free_srt_table_data(&rs->srt_table);
 330                 g_free(rs);
 331                 return;
 332         }
 333
 334         /* Button row. */
 335         bbox = dlg_button_row_new(GTK_STOCK_CLOSE, NULL);
 336         gtk_box_pack_end(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
 337
 338         close_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLOSE);
 339         window_set_cancel_button(rs->win, close_bt, window_cancel_button_cb);
 340
 341         g_signal_connect(rs->win, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
 342         g_signal_connect(rs->win, "destroy",      G_CALLBACK(win_destroy_cb), rs);
 343
 344         gtk_widget_show_all(rs->win);
 345         window_present(rs->win);
 346
 347         cf_retap_packets(&cfile);
 348         gdk_window_raise(gtk_widget_get_window(rs->win));
 349 }
 350
 351
 352
 353 static e_uuid_t          *dcerpc_uuid_program;
 354 static guint16            dcerpc_version;
 355 static GtkWidget         *dlg = NULL;
 356 static GtkWidget         *filter_entry;
 357 static dcerpc_uuid_key   *current_uuid_key;
 358 static dcerpc_uuid_value *current_uuid_value;
 359 static dcerpc_uuid_key   *new_uuid_key;
 360 static dcerpc_uuid_value *new_uuid_value;
 361
 362 static void
 363 dcerpcstat_start_button_clicked(GtkWidget *item _U_, gpointer data _U_)
 364 {
 365         GString *str;
 366         const char *filter;
 367
 368         if (dcerpc_uuid_program == NULL) {
 369                 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Please select a program");
 370                 return;
 371         }
 372         str = g_string_new("dcerpc,srt");
 373         g_string_append_printf(str,
 374             ",%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x,%u.%u",
 375             dcerpc_uuid_program->Data1, dcerpc_uuid_program->Data2,
 376             dcerpc_uuid_program->Data3,
 377             dcerpc_uuid_program->Data4[0], dcerpc_uuid_program->Data4[1],
 378             dcerpc_uuid_program->Data4[2], dcerpc_uuid_program->Data4[3],
 379             dcerpc_uuid_program->Data4[4], dcerpc_uuid_program->Data4[5],
 380             dcerpc_uuid_program->Data4[6], dcerpc_uuid_program->Data4[7],
 381             dcerpc_version, 0);
 382         filter = gtk_entry_get_text(GTK_ENTRY(filter_entry));
 383         if(filter[0] != 0){
 384                 g_string_append_printf(str, ",%s", filter);
 385         }
 386
 387         gtk_dcerpcstat_init(str->str,NULL);
 388         g_string_free(str, TRUE);
 389 }
 390
 391
 392 static void
 393 dcerpcstat_version_select(GtkWidget *vers_combo_box, gpointer user_data _U_)
 394 {
 395         dcerpc_uuid_key *k;
 396
 397         if (! ws_combo_box_get_active_pointer(GTK_COMBO_BOX(vers_combo_box), (gpointer)&k)) {
 398                 g_assert_not_reached();  /* Programming error: somehow no active item */
 399         }
 400
 401         dcerpc_version = k->ver;
 402 }
 403
 404 static void
 405 dcerpcstat_find_vers(gpointer *key, gpointer *value _U_, gpointer user_data)
 406 {
 407         dcerpc_uuid_key *k = (dcerpc_uuid_key *)key;
 408         GtkWidget       *vers_combo_box = user_data;
 409         char vs[5];
 410
 411         if(!uuid_equal(&(k->uuid), dcerpc_uuid_program)){
 412                 return;
 413         }
 414         g_snprintf(vs, sizeof(vs), "%u", k->ver);
 415         ws_combo_box_append_text_and_pointer(GTK_COMBO_BOX(vers_combo_box), vs, k);
 416 }
 417
 418 static void
 419 dcerpcstat_program_select(GtkWidget *prog_combo_box, gpointer user_data)
 420 {
 421         dcerpc_uuid_key *k;
 422         GtkWidget *vers_combo_box;
 423
 424         vers_combo_box = user_data;
 425
 426         if (! ws_combo_box_get_active_pointer(GTK_COMBO_BOX(prog_combo_box), (gpointer)&k)) {
 427                 g_assert_not_reached();  /* Programming error: somehow no active item */
 428         }
 429
 430         g_signal_handlers_disconnect_by_func(vers_combo_box, G_CALLBACK(dcerpcstat_version_select), NULL );
 431         ws_combo_box_clear_text_and_pointer(GTK_COMBO_BOX(vers_combo_box));
 432
 433         g_assert((k != NULL) && "dcerpc_stat: invalid selection"); /* Somehow selected top level ?? */
 434         dcerpc_uuid_program = &(k->uuid);
 435
 436         /* re-create version menu */
 437         g_signal_handlers_disconnect_by_func(vers_combo_box, G_CALLBACK(dcerpcstat_version_select), NULL );
 438         ws_combo_box_clear_text_and_pointer(GTK_COMBO_BOX(vers_combo_box));
 439
 440         g_hash_table_foreach(dcerpc_uuids, (GHFunc)dcerpcstat_find_vers, vers_combo_box);
 441
 442         g_signal_connect(vers_combo_box, "changed", G_CALLBACK(dcerpcstat_version_select), NULL);
 443         ws_combo_box_set_active(GTK_COMBO_BOX(vers_combo_box), 0); /* default: triggers dcerpcstat_version_select callback */
 444
 445 }
 446
 447 static GtkTreeIter
 448 dcerpcstat_add_program_to_menu(dcerpc_uuid_key *k, dcerpc_uuid_value *v, GtkWidget *prog_combo_box, int program_item_index)
 449 {
 450         static GtkTreeIter iter;
 451         char str[64];
 452
 453         switch(program_item_index%15){
 454         case 0:
 455                 g_snprintf(str,sizeof(str),"%s ...",v->name);
 456                 iter = ws_combo_box_append_text_and_pointer_full(
 457                         GTK_COMBO_BOX(prog_combo_box), NULL, str, NULL, FALSE); /* top-level entries are insensitive */
 458                 break;
 459
 460         default:
 461                 break;
 462         }
 463
 464         return ws_combo_box_append_text_and_pointer_full(
 465                 GTK_COMBO_BOX(prog_combo_box), &iter, v->name, k, TRUE);
 466 }
 467
 468 static void
 469 dcerpcstat_find_next_program(gpointer *key, gpointer *value, gpointer *user_data _U_)
 470 {
 471         dcerpc_uuid_key   *k = (dcerpc_uuid_key *)key;
 472         dcerpc_uuid_value *v = (dcerpc_uuid_value *)value;
 473
 474         /* first time called, just set new_uuid to this one */
 475         if((current_uuid_key==NULL) && (new_uuid_key==NULL)){
 476                 new_uuid_key   = k;
 477                 new_uuid_value = v;
 478                 return;
 479         }
 480
 481         /* if we haven't got a current one yet, just check the new
 482            and scan for the first one alphabetically  */
 483         if(current_uuid_key==NULL){
 484                 if(strcmp(new_uuid_value->name, v->name)>0){
 485                         new_uuid_key   = k;
 486                         new_uuid_value = v;
 487                         return;
 488                 }
 489                 return;
 490         }
 491
 492         /* searching for the next one we are only interested in those
 493            that sorts alphabetically after the current one */
 494         if(strcmp(current_uuid_value->name, v->name) >= 0){
 495                 /* this one doesnt so just skip it */
 496                 return;
 497         }
 498
 499         /* is it the first potential new entry? */
 500         if(new_uuid_key==NULL){
 501                 new_uuid_key   = k;
 502                 new_uuid_value = v;
 503                 return;
 504         }
 505
 506         /* does it sort before the current new one? */
 507         if(strcmp(new_uuid_value->name, v->name) > 0){
 508                 new_uuid_key   = k;
 509                 new_uuid_value = v;
 510                 return;
 511         }
 512
 513         return;
 514 }
 515
 516
 517 static void
 518 dlg_destroy_cb(GtkWidget *w _U_, gpointer user_data _U_)
 519 {
 520         dlg = NULL;
 521 }
 522
 523
 524 #ifdef MAIN_MENU_USE_UIMANAGER
 525 void gtk_dcerpcstat_cb(GtkAction *action _U_, gpointer user_data _U_)
 526 #else
 527 static void
 528 gtk_dcerpcstat_cb(GtkWidget *w _U_, gpointer d _U_)
 529 #endif
 530 {
 531         GtkWidget       *dlg_box;
 532         GtkWidget       *prog_box,   *prog_label, *prog_combo_box;
 533         GtkWidget       *vers_label, *vers_combo_box;
 534         GtkWidget       *filter_box, *filter_bt;
 535         GtkWidget       *bbox, *start_button, *cancel_button;
 536         GtkCellRenderer *cell_renderer;
 537 #if 0
 538         GtkTreeIter      program_first_item_iter;
 539 #endif
 540         const char      *filter;
 541         int              program_item_index = 0;
 542
 543         static construct_args_t args = {
 544           "Service Response Time Statistics Filter",
 545           FALSE,
 546           FALSE,
 547           FALSE
 548         };
 549
 550         /* if the window is already open, bring it to front and
 551            un-minimize it, as necessary */
 552         if(dlg){
 553                 reactivate_window(dlg);
 554                 return;
 555         }
 556
 557         dlg = dlg_window_new("Wireshark: Compute DCE-RPC SRT statistics");
 558         gtk_window_set_default_size(GTK_WINDOW(dlg), 400, -1);
 559
 560         dlg_box = gtk_vbox_new(FALSE, 10);
 561         gtk_container_set_border_width(GTK_CONTAINER(dlg_box), 10);
 562         gtk_container_add(GTK_CONTAINER(dlg), dlg_box);
 563         gtk_widget_show(dlg_box);
 564
 565         /* Program box */
 566         prog_box = gtk_hbox_new(FALSE, 3);
 567
 568         /* Program label */
 569         gtk_container_set_border_width(GTK_CONTAINER(prog_box), 10);
 570         prog_label = gtk_label_new("Program:");
 571         gtk_box_pack_start(GTK_BOX(prog_box), prog_label, FALSE, FALSE, 0);
 572         gtk_widget_show(prog_label);
 573
 574         /* Program menu */
 575         dcerpc_uuid_program = NULL;   /* default: no program selected */
 576
 577         /* The "program combo box" is implemented with a two-level tree.
 578            Each top-level of the tree has (up to) 15 selectable "program name"
 579            children and shows the name of the first child of that entry
 580            as "child_name ...". Each of the top-level entries can be expanded
 581            (to show the children) but is "insensitive": ie: cannot be selected.
 582            (dcerpcstat_add_program_to_menu() does the actual work to add entries
 583             to the combo box).
 584             XXX: A simpler alternative might be to just do away with all the two-level
 585                  complexity and just use a standard ws_combo_box... even though the
 586                  list of "program names" is quite large.
 587             XXX: The gtkrc file distributed with Windows Wireshark has the
 588                  "appears-as-list" GtkComboBox style property set to 1 and thus
 589                  on Windows the entries for this combo box will appear as a tree-view.
 590                  The default is 0(FALSE). In this case the the combo box entries will
 591                  display as a menu with sub-menus.
 592                  A possibility would be to set "appears-as-list" to 0  just for this
 593                  particular combo box on Windows so that the entries will appear as a
 594                  menu even on Windows).
 595         */
 596         prog_combo_box = ws_combo_box_new_text_and_pointer_full(&cell_renderer);
 597         {
 598                 /* XXX: Hack So that the top-level insensitive entries don't show
 599                         as "grayed out"; The "foreground normal" color is used instead.
 600                         This may not really be necessary but seems better to me.
 601                 */
 602 #if GTK_CHECK_VERSION(3,0,0)
 603                 GtkStyleContext *context;
 604                 GdkRGBA                 *new_rgba_fg_color;
 605                 context = gtk_widget_get_style_context (prog_combo_box);
 606                 gtk_style_context_get (context, GTK_STATE_NORMAL,
 607                                  "color", &new_rgba_fg_color,
 608                                   NULL);
 609
 610                 g_object_set(cell_renderer,
 611                              "foreground-rgba", &new_rgba_fg_color,
 612                              "foreground-set", TRUE,
 613                              NULL);
 614
 615 #else
 616                 GtkStyle *s;
 617                 s = gtk_widget_get_style(prog_combo_box);
 618                 g_object_set(cell_renderer,
 619                              "foreground-gdk", &(s->fg[GTK_STATE_NORMAL]),
 620                              "foreground-set", TRUE,
 621                              NULL);
 622 #endif
 623         }
 624
 625         current_uuid_key   = NULL;
 626         current_uuid_value = NULL;
 627         do {
 628                 new_uuid_key   = NULL;
 629                 new_uuid_value = NULL;
 630                 g_hash_table_foreach(dcerpc_uuids, (GHFunc)dcerpcstat_find_next_program, NULL);
 631                 if(new_uuid_key){
 632 #if 0
 633                         GtkTreeIter tmp_iter;
 634                         tmp_iter = dcerpcstat_add_program_to_menu(new_uuid_key, new_uuid_value,
 635                                                                   prog_combo_box, program_item_index);
 636                         if (program_item_index == 0)
 637                                 program_first_item_iter = tmp_iter;
 638 #else
 639                         dcerpcstat_add_program_to_menu(new_uuid_key, new_uuid_value,
 640                                                         prog_combo_box, program_item_index);
 641 #endif
 642                         program_item_index += 1;
 643                 }
 644                 current_uuid_key   = new_uuid_key;
 645                 current_uuid_value = new_uuid_value;
 646         } while(new_uuid_key != NULL);
 647         gtk_box_pack_start(GTK_BOX(prog_box), prog_combo_box, TRUE, TRUE, 0);
 648         gtk_widget_show(prog_combo_box);
 649
 650         /* Version label */
 651         gtk_container_set_border_width(GTK_CONTAINER(prog_box), 10);
 652         vers_label = gtk_label_new("Version:");
 653         gtk_box_pack_start(GTK_BOX(prog_box), vers_label, FALSE, FALSE, 0);
 654         gtk_widget_show(vers_label);
 655
 656         /* Version combo-box */
 657         /* Note: version combo box rows set when dcerpcstat_program_select() callback invoked */
 658         vers_combo_box = ws_combo_box_new_text_and_pointer();
 659         gtk_box_pack_start(GTK_BOX(prog_box), vers_combo_box, TRUE, TRUE, 0);
 660         gtk_widget_show(vers_combo_box);
 661
 662         g_signal_connect(prog_combo_box, "changed", G_CALLBACK(dcerpcstat_program_select), vers_combo_box);
 663 #if 0 /* Don't select an active entry given the way the drop down treeview appears if a default (active) entry is set */
 664         ws_combo_box_set_active_iter(GTK_COMBO_BOX(prog_combo_box), &program_first_item_iter); /* triggers callback */
 665 #endif
 666         gtk_box_pack_start(GTK_BOX(dlg_box), prog_box, TRUE, TRUE, 0);
 667         gtk_widget_show(prog_box);
 668
 669         /* Filter box */
 670         filter_box = gtk_hbox_new(FALSE, 3);
 671
 672         /* Filter label */
 673         filter_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_DISPLAY_FILTER_ENTRY);
 674         g_signal_connect(filter_bt, "clicked", G_CALLBACK(display_filter_construct_cb), &args);
 675         gtk_box_pack_start(GTK_BOX(filter_box), filter_bt, FALSE, FALSE, 0);
 676         gtk_widget_show(filter_bt);
 677
 678         /* Filter entry */
 679         filter_entry = gtk_entry_new();
 680         g_signal_connect(filter_entry, "changed", G_CALLBACK(filter_te_syntax_check_cb), NULL);
 681         g_object_set_data(G_OBJECT(filter_box), E_FILT_AUTOCOMP_PTR_KEY, NULL);
 682         g_signal_connect(filter_entry, "key-press-event", G_CALLBACK (filter_string_te_key_pressed_cb), NULL);
 683         g_signal_connect(dlg, "key-press-event", G_CALLBACK (filter_parent_dlg_key_pressed_cb), NULL);
 684         gtk_box_pack_start(GTK_BOX(filter_box), filter_entry, TRUE, TRUE, 0);
 685         filter = gtk_entry_get_text(GTK_ENTRY(main_display_filter_widget));
 686         if(filter){
 687                 gtk_entry_set_text(GTK_ENTRY(filter_entry), filter);
 688         } else {
 689                 colorize_filter_te_as_empty(filter_entry);
 690         }
 691         gtk_widget_show(filter_entry);
 692
 693         gtk_box_pack_start(GTK_BOX(dlg_box), filter_box, TRUE, TRUE, 0);
 694         gtk_widget_show(filter_box);
 695
 696         g_object_set_data(G_OBJECT(filter_bt), E_FILT_TE_PTR_KEY, filter_entry);
 697
 698         /* button box */
 699         bbox = dlg_button_row_new(WIRESHARK_STOCK_CREATE_STAT, GTK_STOCK_CANCEL, NULL);
 700         gtk_box_pack_start(GTK_BOX(dlg_box), bbox, FALSE, FALSE, 0);
 701         gtk_widget_show(bbox);
 702
 703         start_button = g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_CREATE_STAT);
 704         g_signal_connect_swapped(start_button, "clicked",
 705                                  G_CALLBACK(dcerpcstat_start_button_clicked), NULL);
 706
 707         cancel_button = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL);
 708         window_set_cancel_button(dlg, cancel_button, window_cancel_button_cb);
 709
 710         g_signal_connect(dlg, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
 711         g_signal_connect(dlg, "destroy", G_CALLBACK(dlg_destroy_cb), NULL);
 712
 713         /* Catch the "activate" signal on the filter text entry, so that
 714            if the user types Return there, we act as if the "Create Stat"
 715            button had been selected, as happens if Return is typed if some
 716            widget that *doesn't* handle the Return key has the input
 717            focus. */
 718         dlg_set_activate(filter_entry, start_button);
 719
 720         gtk_widget_grab_default(start_button );
 721
 722         /* Give the initial focus to the "Filter" entry box. */
 723         gtk_widget_grab_focus(filter_entry);
 724
 725         gtk_widget_show_all(dlg);
 726         window_present(dlg);
 727 }
 728
 729 void
 730 register_tap_listener_gtkdcerpcstat(void)
 731 {
 732         register_stat_cmd_arg("dcerpc,srt,", gtk_dcerpcstat_init,NULL);
 733
 734 #ifdef MAIN_MENU_USE_UIMANAGER
 735 #else
 736         register_stat_menu_item("DCE-RPC...", REGISTER_STAT_GROUP_RESPONSE_TIME,
 737             gtk_dcerpcstat_cb, NULL, NULL, NULL);
 738 #endif
 739 }