gtk/wlan_stat_dlg.c

   1 /* wlan_stat_dlg.c
   2  * Copyright 2008 Stig Bjørlykke <stig@bjorlykke.org>
   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
  26 #ifdef HAVE_CONFIG_H
  27 #include "config.h"
  28 #endif
  29
  30 #ifdef HAVE_SYS_TYPES_H
  31 #include <sys/types.h>
  32 #endif
  33 #include <string.h>
  34
  35 #include <gtk/gtk.h>
  36
  37 #include <epan/packet.h>
  38 #include <epan/packet_info.h>
  39 #include <epan/addr_resolv.h>
  40 #include <epan/tap.h>
  41 #include <epan/dissectors/packet-ieee80211.h>
  42 #include <epan/strutil.h>
  43
  44 #include "../register.h"
  45 #include "../simple_dialog.h"
  46 #include "../globals.h"
  47 #include "../stat_menu.h"
  48 #include "../isprint.h"
  49
  50 #include "gtk/main.h"
  51 #include "gtk/gtkglobals.h"
  52 #include "gtk/find_dlg.h"
  53 #include "gtk/color_dlg.h"
  54 #include "gtk/dlg_utils.h"
  55 #include "gtk/gui_stat_menu.h"
  56 #include "gtk/gui_utils.h"
  57 #include "gtk/help_dlg.h"
  58
  59 #include "image/clist_ascend.xpm"
  60 #include "image/clist_descend.xpm"
  61
  62 #define GTK_MENU_FUNC(a) ((GtkItemFactoryCallback)(a))
  63
  64 #define NUM_COLS 12
  65 static const gchar *titles[] = { "BSSID", "Channel", "SSID", "Beacons", "Data Packets", "Probe Req", "Probe Resp", "Auth", "Deauth", "Other", "Percent", "Protection" };
  66
  67 #define NUM_DETAIL_COLS 10
  68 static const gchar *detail_titles[] = { "Address", "Data Sent", "Data Received", "Probe Req", "Probe Resp", "Auth", "Deauth", "Other", "Percent", "Comment" };
  69
  70 typedef struct column_arrows {
  71         GtkWidget *table;
  72         GtkWidget *ascend_pm;
  73         GtkWidget *descend_pm;
  74 } column_arrows;
  75
  76 typedef struct wlan_details_ep {
  77         struct wlan_details_ep *next;
  78         address address;
  79         guint32 probe_req;
  80         guint32 probe_rsp;
  81         guint32 auth;
  82         guint32 deauth;
  83         guint32 data_sent;
  84         guint32 data_received;
  85         guint32 other;
  86         guint32 number_of_packets;
  87 } wlan_details_ep_t;
  88
  89 typedef struct wlan_ep {
  90         struct wlan_ep* next;
  91         address bssid;
  92         struct _wlan_stats stats;
  93         guint32 type[256];
  94         guint32 number_of_packets;
  95         struct wlan_details_ep *details;
  96 } wlan_ep_t;
  97
  98 static GtkWidget  *wlanstat_dlg_w = NULL;
  99
 100 /* used to keep track of the statistics for an entire program interface */
 101 typedef struct _wlan_stat_t {
 102         GtkWidget  *table;
 103         GtkWidget  *details;
 104         GtkWidget  *menu;
 105         GtkWidget  *details_menu;
 106         guint32    number_of_packets;
 107         guint32    num_entries;
 108         guint32    num_details;
 109         gboolean   resolve_names;
 110         gboolean   show_only_existing;
 111         address    selected_bssid;
 112         gboolean   selected_bssid_valid;
 113         guint8     selected_ssid_len;
 114         guchar     selected_ssid[MAX_SSID_LEN];
 115         gboolean   selected_ssid_valid;
 116         wlan_ep_t* ep_list;
 117 } wlanstat_t;
 118
 119 static void
 120 dealloc_wlan_details_ep (wlan_details_ep_t *details)
 121 {
 122         wlan_details_ep_t *tmp;
 123
 124         while (details) {
 125                 tmp = details;
 126                 details = details->next;
 127                 g_free (tmp);
 128         }
 129 }
 130
 131 static void
 132 wlanstat_reset (void *phs)
 133 {
 134         wlanstat_t* wlan_stat = (wlanstat_t *)phs;
 135         wlan_ep_t* list = wlan_stat->ep_list;
 136         wlan_ep_t* tmp = NULL;
 137
 138         if (wlanstat_dlg_w != NULL) {
 139                 char title[256];
 140                 g_snprintf (title, 255, "Wireshark: WLAN Traffic Statistics: %s",
 141                             cf_get_display_name(&cfile));
 142                 gtk_window_set_title(GTK_WINDOW(wlanstat_dlg_w), title);
 143         }
 144
 145         /* remove all entries from the clist */
 146         gtk_clist_clear (GTK_CLIST(wlan_stat->table));
 147         gtk_clist_clear (GTK_CLIST(wlan_stat->details));
 148
 149         if (!list)
 150                 return;
 151
 152         while (list) {
 153                 tmp = list;
 154                 dealloc_wlan_details_ep (tmp->details);
 155                 list = tmp->next;
 156                 g_free (tmp);
 157         }
 158
 159         wlan_stat->ep_list = NULL;
 160         wlan_stat->number_of_packets = 0;
 161 }
 162
 163 static wlan_ep_t*
 164 alloc_wlan_ep (struct _wlan_hdr *si, packet_info *pinfo _U_)
 165 {
 166         wlan_ep_t* ep;
 167
 168         if (!si)
 169                 return NULL;
 170
 171         if (!(ep = g_malloc (sizeof(wlan_ep_t))))
 172                 return NULL;
 173
 174         SE_COPY_ADDRESS (&ep->bssid, &si->bssid);
 175         ep->stats.channel = si->stats.channel;
 176         memcpy (ep->stats.ssid, si->stats.ssid, MAX_SSID_LEN);
 177         ep->stats.ssid_len = si->stats.ssid_len;
 178         g_strlcpy (ep->stats.protection, si->stats.protection, MAX_PROTECT_LEN);
 179         memset(&ep->type, 0, sizeof (int) * 256);
 180         ep->number_of_packets = 0;
 181         ep->details = NULL;
 182         ep->next = NULL;
 183
 184         return ep;
 185 }
 186
 187 static wlan_details_ep_t*
 188 alloc_wlan_details_ep (address *address)
 189 {
 190         wlan_details_ep_t* d_ep;
 191
 192         if (!address)
 193                 return NULL;
 194
 195         if (!(d_ep = g_malloc (sizeof(wlan_details_ep_t))))
 196                 return NULL;
 197
 198         SE_COPY_ADDRESS (&d_ep->address, address);
 199         d_ep->probe_req = 0;
 200         d_ep->probe_rsp = 0;
 201         d_ep->auth = 0;
 202         d_ep->deauth = 0;
 203         d_ep->data_sent = 0;
 204         d_ep->data_received = 0;
 205         d_ep->other = 0;
 206         d_ep->number_of_packets = 0;
 207         d_ep->next = NULL;
 208
 209         return d_ep;
 210 }
 211
 212 wlan_details_ep_t *
 213 get_details_ep (wlan_ep_t *te, address *address)
 214 {
 215   wlan_details_ep_t *tmp, *d_te = NULL;
 216
 217   if (!te->details) {
 218     te->details = alloc_wlan_details_ep (address);
 219     d_te = te->details;
 220   } else {
 221     for (tmp = te->details; tmp; tmp = tmp->next) {
 222       if (!CMP_ADDRESS (&tmp->address, address)) {
 223         d_te = tmp;
 224         break;
 225       }
 226     }
 227
 228     if (!d_te) {
 229       if ((d_te = alloc_wlan_details_ep (address)) != NULL) {
 230         d_te->next = te->details;
 231         te->details = d_te;
 232       }
 233     }
 234   }
 235
 236   g_assert (d_te != NULL);
 237   return d_te;
 238 }
 239
 240 static void
 241 wlanstat_packet_details (wlan_ep_t *te, guint32 type, address *address, gboolean src)
 242 {
 243         wlan_details_ep_t *d_te = get_details_ep (te, address);
 244
 245         switch (type) {
 246         case 0x04:
 247                 d_te->probe_req++;
 248                 break;
 249         case 0x05:
 250                 d_te->probe_rsp++;
 251                 break;
 252         case 0x08:
 253                 /* No counting for beacons */
 254                 break;
 255         case 0x0B:
 256                 d_te->auth++;
 257                 break;
 258         case 0x0C:
 259                 d_te->deauth++;
 260                 break;
 261         case 0x20:
 262         case 0x21:
 263         case 0x22:
 264         case 0x23:
 265         case 0x28:
 266         case 0x29:
 267         case 0x2A:
 268         case 0x2B:
 269                 if (src) {
 270                         d_te->data_sent++;
 271                 } else {
 272                         d_te->data_received++;
 273                 }
 274                 break;
 275         default:
 276                 d_te->other++;
 277                 break;
 278         }
 279
 280         if (type != 0x08) {
 281                 /* Do not count beacons in details */
 282                 d_te->number_of_packets++;
 283         }
 284 }
 285
 286 static int
 287 wlanstat_packet (void *phs, packet_info *pinfo, epan_dissect_t *edt _U_, const void *phi)
 288 {
 289
 290         wlanstat_t *hs = (wlanstat_t *)phs;
 291         wlan_ep_t *tmp = NULL, *te = NULL;
 292         struct _wlan_hdr *si = (struct _wlan_hdr *) phi;
 293
 294         if (!hs)
 295                 return (0);
 296
 297         hs->number_of_packets++;
 298         if (!hs->ep_list) {
 299                 hs->ep_list = alloc_wlan_ep (si, pinfo);
 300                 te = hs->ep_list;
 301         } else {
 302                 for (tmp = hs->ep_list; tmp; tmp = tmp->next) {
 303                         if (((si->type == 0x04) &&
 304                              (((tmp->stats.ssid_len == 0) && (si->stats.ssid_len == 0) &&
 305                                (strcmp (get_addr_name(&tmp->bssid), "Broadcast") == 0)) ||
 306                               (si->stats.ssid_len != 0 &&
 307                                (tmp->stats.ssid_len == si->stats.ssid_len) &&
 308                                (memcmp (tmp->stats.ssid, si->stats.ssid, si->stats.ssid_len) == 0)))) ||
 309                             ((si->type != 0x04) &&
 310                              (!CMP_ADDRESS (&tmp->bssid, &si->bssid)))) {
 311                                 te = tmp;
 312                                 break;
 313                         }
 314                 }
 315
 316                 if (te && si->type != 0x04 && te->type[0x04] == 0 && te->stats.ssid_len != 0) {
 317                         /*
 318                          * We have found a matching entry without Probe Requests.
 319                          * Search the rest of the entries for a corresponding entry
 320                          * matching the SSID and BSSID == Broadcast.
 321                          *
 322                          * This is because we can have a hidden SSID or Probe Request
 323                          * before we have a Beacon.
 324                          */
 325                         wlan_ep_t *prev = NULL;
 326
 327                         for (tmp = hs->ep_list; tmp; tmp = tmp->next) {
 328                                 if (te->stats.ssid_len &&
 329                                     (te->stats.ssid_len == tmp->stats.ssid_len) &&
 330                                     (memcmp (te->stats.ssid, tmp->stats.ssid, tmp->stats.ssid_len) == 0) &&
 331                                     (strcmp (get_addr_name(&tmp->bssid), "Broadcast") == 0)) {
 332                                         /*
 333                                          * Found a matching entry. Merge with the previous
 334                                          * found entry and remove from list.
 335                                          */
 336                                         te->type[0x04] += tmp->type[0x04];
 337                                         te->number_of_packets += tmp->number_of_packets;
 338
 339                                         if (tmp->details && tmp->details->next) {
 340                                                 /* Adjust received probe requests */
 341                                                 wlan_details_ep_t *d_te;
 342                                                 d_te = get_details_ep (te, &tmp->details->address);
 343                                                 d_te->probe_req += tmp->type[0x04];
 344                                                 d_te->number_of_packets += tmp->type[0x04];
 345                                                 d_te = get_details_ep (te, &tmp->details->next->address);
 346                                                 d_te->probe_req += tmp->type[0x04];
 347                                                 d_te->number_of_packets += tmp->type[0x04];
 348                                         }
 349                                         if (prev) {
 350                                                 prev->next = tmp->next;
 351                                         } else {
 352                                                 hs->ep_list = tmp->next;
 353                                         }
 354                                         dealloc_wlan_details_ep (tmp->details);
 355                                         g_free (tmp);
 356                                         break;
 357                                 }
 358                                 prev = tmp;
 359                         }
 360                 }
 361
 362                 if (!te) {
 363                         if ((te = alloc_wlan_ep (si, pinfo))) {
 364                                 te->next = hs->ep_list;
 365                                 hs->ep_list = te;
 366                         }
 367                 }
 368         }
 369
 370         if(!te)
 371                 return (0);
 372
 373         if (te->stats.channel == 0 && si->stats.channel != 0) {
 374                 te->stats.channel = si->stats.channel;
 375         }
 376         if (te->stats.ssid[0] == 0 && si->stats.ssid_len != 0) {
 377                 memcpy (te->stats.ssid, si->stats.ssid, MAX_SSID_LEN);
 378                 te->stats.ssid_len = si->stats.ssid_len;
 379         }
 380         if (te->stats.protection[0] == 0 && si->stats.protection[0] != 0) {
 381                 g_strlcpy (te->stats.protection, si->stats.protection, MAX_PROTECT_LEN);
 382         }
 383         te->type[si->type]++;
 384         te->number_of_packets++;
 385
 386         wlanstat_packet_details (te, si->type, &si->src, TRUE);  /* Register source */
 387         wlanstat_packet_details (te, si->type, &si->dst, FALSE); /* Register destination */
 388
 389         return (1);
 390 }
 391
 392 static void
 393 wlan_click_column_cb(GtkCList *clist, gint column, gpointer data)
 394 {
 395         column_arrows *col_arrows = (column_arrows *) data;
 396         int i;
 397
 398         gtk_clist_freeze(clist);
 399
 400         for (i=0; i<NUM_COLS; i++) {
 401                 gtk_widget_hide(col_arrows[i].ascend_pm);
 402                 gtk_widget_hide(col_arrows[i].descend_pm);
 403         }
 404
 405         if (column == clist->sort_column) {
 406                 if (clist->sort_type == GTK_SORT_ASCENDING) {
 407                         clist->sort_type = GTK_SORT_DESCENDING;
 408                         gtk_widget_show(col_arrows[column].descend_pm);
 409                 } else {
 410                         clist->sort_type = GTK_SORT_ASCENDING;
 411                         gtk_widget_show(col_arrows[column].ascend_pm);
 412                 }
 413         } else {
 414                 clist->sort_type = GTK_SORT_ASCENDING;
 415                 gtk_widget_show(col_arrows[column].ascend_pm);
 416                 gtk_clist_set_sort_column(clist, column);
 417         }
 418         gtk_clist_thaw(clist);
 419
 420         gtk_clist_sort(clist);
 421 }
 422
 423 static void
 424 wlan_detail_click_column_cb(GtkCList *clist, gint column, gpointer data)
 425 {
 426         column_arrows *col_arrows = (column_arrows *) data;
 427         int i;
 428
 429         gtk_clist_freeze(clist);
 430
 431         for (i=0; i<NUM_DETAIL_COLS; i++) {
 432                 gtk_widget_hide(col_arrows[i].ascend_pm);
 433                 gtk_widget_hide(col_arrows[i].descend_pm);
 434         }
 435
 436         if (column == clist->sort_column) {
 437                 if (clist->sort_type == GTK_SORT_ASCENDING) {
 438                         clist->sort_type = GTK_SORT_DESCENDING;
 439                         gtk_widget_show(col_arrows[column].descend_pm);
 440                 } else {
 441                         clist->sort_type = GTK_SORT_ASCENDING;
 442                         gtk_widget_show(col_arrows[column].ascend_pm);
 443                 }
 444         } else {
 445                 clist->sort_type = GTK_SORT_ASCENDING;
 446                 gtk_widget_show(col_arrows[column].ascend_pm);
 447                 gtk_clist_set_sort_column(clist, column);
 448         }
 449         gtk_clist_thaw(clist);
 450
 451         gtk_clist_sort(clist);
 452 }
 453
 454 static gint
 455 wlan_sort_column(GtkCList *clist, gconstpointer ptr1, gconstpointer ptr2)
 456 {
 457         char *text1 = NULL;
 458         char *text2 = NULL;
 459         int i1, i2;
 460
 461         const GtkCListRow *row1 = (const GtkCListRow *) ptr1;
 462         const GtkCListRow *row2 = (const GtkCListRow *) ptr2;
 463
 464         text1 = GTK_CELL_TEXT (row1->cell[clist->sort_column])->text;
 465         text2 = GTK_CELL_TEXT (row2->cell[clist->sort_column])->text;
 466
 467         switch(clist->sort_column){
 468         case 0:
 469         case 2:
 470         case 11:
 471                 return g_ascii_strcasecmp (text1, text2);
 472         case 1:
 473         case 3:
 474         case 4:
 475         case 5:
 476         case 6:
 477         case 7:
 478         case 8:
 479         case 9:
 480         case 10:
 481                 i1=atoi(text1);
 482                 i2=atoi(text2);
 483                 return i1-i2;
 484         }
 485         g_assert_not_reached();
 486         return 0;
 487 }
 488
 489 static gint
 490 wlan_detail_sort_column(GtkCList *clist, gconstpointer ptr1, gconstpointer ptr2)
 491 {
 492         char *text1 = NULL;
 493         char *text2 = NULL;
 494         int i1, i2;
 495
 496         const GtkCListRow *row1 = (const GtkCListRow *) ptr1;
 497         const GtkCListRow *row2 = (const GtkCListRow *) ptr2;
 498
 499         text1 = GTK_CELL_TEXT (row1->cell[clist->sort_column])->text;
 500         text2 = GTK_CELL_TEXT (row2->cell[clist->sort_column])->text;
 501
 502         switch(clist->sort_column){
 503         case 0:
 504         case 9:
 505                 return g_ascii_strcasecmp (text1, text2);
 506         case 1:
 507         case 2:
 508         case 3:
 509         case 4:
 510         case 5:
 511         case 6:
 512         case 7:
 513         case 8:
 514                 i1=atoi(&text1[(text1[0] == '(' ? 1 : 0)]);
 515                 i2=atoi(&text2[(text2[0] == '(' ? 1 : 0)]);
 516                 return i1-i2;
 517         }
 518         g_assert_not_reached();
 519         return 0;
 520 }
 521
 522 static void
 523 wlanstat_details(wlanstat_t *hs, wlan_ep_t *wlan_ep)
 524 {
 525         wlan_details_ep_t *tmp = NULL;
 526         char *str[NUM_DETAIL_COLS];
 527         gboolean broadcast, basestation;
 528         float f;
 529         int row, i=0;
 530
 531         for (i = 0; i < NUM_DETAIL_COLS; i++) {
 532                 str[i] = g_malloc (sizeof(char[256]));
 533         }
 534
 535         /* clear list before printing */
 536         gtk_clist_clear (GTK_CLIST(hs->details));
 537         gtk_clist_freeze(GTK_CLIST(hs->details));
 538         hs->num_details = 0;
 539
 540         for(tmp = wlan_ep->details; tmp; tmp=tmp->next) {
 541                 broadcast = !(strcmp (get_addr_name(&tmp->address), "Broadcast"));
 542                 basestation = !broadcast && !CMP_ADDRESS(&tmp->address, &wlan_ep->bssid);
 543
 544                 if ((wlan_ep->number_of_packets - wlan_ep->type[0x08]) > 0) {
 545                         f = (float)(((float)tmp->number_of_packets * 100.0) / (wlan_ep->number_of_packets - wlan_ep->type[0x08]));
 546                 } else {
 547                         f = 0.0;
 548                 }
 549
 550                 if (hs->resolve_names) {
 551                         g_snprintf (str[0],  sizeof(char[256]),"%s", get_addr_name(&tmp->address));
 552                 } else {
 553                         g_snprintf (str[0],  sizeof(char[256]),"%s", address_to_str(&tmp->address));
 554                 }
 555                 g_snprintf (str[1],  sizeof(char[256]),"%u", tmp->data_sent);
 556                 g_snprintf (str[2],  sizeof(char[256]),"%u", tmp->data_received);
 557                 if (broadcast) {
 558                         g_snprintf (str[3],  sizeof(char[256]),"(%u)", tmp->probe_req);
 559                 } else {
 560                         g_snprintf (str[3],  sizeof(char[256]),"%u", tmp->probe_req);
 561                 }
 562                 if (basestation) {
 563                         g_snprintf (str[4],  sizeof(char[256]),"(%u)", tmp->probe_rsp);
 564                         g_snprintf (str[5],  sizeof(char[256]),"(%u)", tmp->auth);
 565                         g_snprintf (str[6],  sizeof(char[256]),"(%u)", tmp->deauth);
 566                         g_snprintf (str[7],  sizeof(char[256]),"(%u)", tmp->other);
 567                 } else {
 568                         g_snprintf (str[4],  sizeof(char[256]),"%u", tmp->probe_rsp);
 569                         g_snprintf (str[5],  sizeof(char[256]),"%u", tmp->auth);
 570                         g_snprintf (str[6],  sizeof(char[256]),"%u", tmp->deauth);
 571                         g_snprintf (str[7],  sizeof(char[256]),"%u", tmp->other);
 572                 }
 573                 g_snprintf (str[8], sizeof(char[256]),"%.2f%%", f);
 574                 if (basestation) {
 575                         g_snprintf (str[9], sizeof(char[256]),"Base station");
 576                 } else {
 577                         g_snprintf (str[9], sizeof(char[256])," ");
 578                 }
 579                 row = gtk_clist_append (GTK_CLIST(hs->details), str);
 580                 gtk_clist_set_row_data (GTK_CLIST(hs->details), row, tmp);
 581                 hs->num_details++;
 582         }
 583
 584         gtk_clist_thaw(GTK_CLIST(hs->details));
 585         gtk_clist_sort(GTK_CLIST(hs->details));
 586         gtk_widget_show (GTK_WIDGET(hs->details));
 587 }
 588
 589 static void
 590 wlanstat_draw(void *phs)
 591 {
 592         wlanstat_t *hs = (wlanstat_t *)phs;
 593         wlan_ep_t* list = hs->ep_list, *tmp = 0;
 594         guint32 data = 0, other = 0;
 595         char *str[NUM_COLS];
 596         gboolean broadcast;
 597         float f;
 598         int row, selected_row = -1, i;
 599
 600         for (i = 0; i < NUM_COLS; i++) {
 601                 str[i] = g_malloc (sizeof(char[256]));
 602         }
 603
 604         /* clear list before printing */
 605         gtk_clist_clear (GTK_CLIST(hs->table));
 606         gtk_clist_freeze(GTK_CLIST(hs->table));
 607         hs->num_entries = 0;
 608
 609         for(tmp = list; tmp; tmp=tmp->next) {
 610                 broadcast = !(strcmp (get_addr_name(&tmp->bssid), "Broadcast"));
 611
 612                 if (hs->show_only_existing && broadcast) {
 613                         continue;
 614                 }
 615
 616                 data = tmp->type[0x20] + tmp->type[0x21] + tmp->type[0x22] + tmp->type[0x23] +
 617                   tmp->type[0x28] + tmp->type[0x29] + tmp->type[0x2A] + tmp->type[0x2B];
 618                 other = tmp->number_of_packets - data - tmp->type[0x08] - tmp->type[0x04] -
 619                   tmp->type[0x05] - tmp->type[0x0B] - tmp->type[0x0C];
 620                 f = (float)(((float)tmp->number_of_packets * 100.0) / hs->number_of_packets);
 621
 622                 if (hs->resolve_names) {
 623                         g_snprintf (str[0],  sizeof(char[256]),"%s", get_addr_name(&tmp->bssid));
 624                 } else {
 625                         g_snprintf (str[0],  sizeof(char[256]),"%s", address_to_str(&tmp->bssid));
 626                 }
 627                 if (tmp->stats.channel) {
 628                         g_snprintf (str[1],  sizeof(char[256]),"%u", tmp->stats.channel);
 629                 } else {
 630                         str[1][0] = '\0';
 631                 }
 632                 if (tmp->stats.ssid_len == 0) {
 633                         g_snprintf (str[2],  sizeof(char[256]),"<Broadcast>");
 634                 } else if (tmp->stats.ssid_len == 1 && tmp->stats.ssid[0] == 0) {
 635                         g_snprintf (str[2],  sizeof(char[256]),"<Hidden>");
 636                 } else {
 637                         g_snprintf (str[2],  sizeof(char[256]),"%s", format_text(tmp->stats.ssid, tmp->stats.ssid_len));
 638                 }
 639                 g_snprintf (str[3],  sizeof(char[256]),"%u", tmp->type[0x08]);
 640                 g_snprintf (str[4],  sizeof(char[256]),"%u", data);
 641                 g_snprintf (str[5],  sizeof(char[256]),"%u", tmp->type[0x04]);
 642                 g_snprintf (str[6],  sizeof(char[256]),"%u", tmp->type[0x05]);
 643                 g_snprintf (str[7],  sizeof(char[256]),"%u", tmp->type[0x0B]);
 644                 g_snprintf (str[8],  sizeof(char[256]),"%u", tmp->type[0x0C]);
 645                 g_snprintf (str[9],  sizeof(char[256]),"%u", other);
 646                 g_snprintf (str[10], sizeof(char[256]),"%.2f%%", f);
 647                 g_snprintf (str[11], sizeof(char[256]),"%s", tmp->stats.protection);
 648                 row = gtk_clist_append (GTK_CLIST(hs->table), str);
 649                 if ((hs->selected_ssid_valid &&
 650                      (hs->selected_ssid_len == tmp->stats.ssid_len) &&
 651                      (memcmp(hs->selected_ssid, tmp->stats.ssid, tmp->stats.ssid_len) == 0)) ||
 652                     (hs->selected_bssid_valid && !CMP_ADDRESS(&hs->selected_bssid, &tmp->bssid))) {
 653                         selected_row = row;
 654                 }
 655                 gtk_clist_set_row_data (GTK_CLIST(hs->table), row, tmp);
 656                 hs->num_entries++;
 657         }
 658
 659         if (selected_row != -1) {
 660                 wlan_ep_t *ep = gtk_clist_get_row_data (GTK_CLIST(hs->table), selected_row);
 661                 gtk_clist_select_row(GTK_CLIST(hs->table), selected_row, 0);
 662                 wlanstat_details (hs, ep);
 663         }
 664
 665         gtk_clist_thaw(GTK_CLIST(hs->table));
 666         gtk_clist_sort(GTK_CLIST(hs->table));
 667         gtk_widget_show (GTK_WIDGET(hs->table));
 668
 669 }
 670
 671 /* What to do when a list item is selected/unselected */
 672 static void
 673 wlan_select_cb(GtkWidget *w, gint row, gint col _U_, GdkEventButton *event _U_, gpointer data)
 674 {
 675         wlanstat_t *hs = (wlanstat_t *)data;
 676         wlan_ep_t *ep = gtk_clist_get_row_data (GTK_CLIST(w), row);
 677
 678         if (strcmp (get_addr_name(&ep->bssid), "Broadcast") == 0) {
 679                 memcpy (hs->selected_ssid, ep->stats.ssid, MAX_SSID_LEN);
 680                 hs->selected_ssid_len = ep->stats.ssid_len;
 681                 hs->selected_bssid_valid = FALSE;
 682                 hs->selected_ssid_valid = TRUE;
 683         } else {
 684                 SE_COPY_ADDRESS (&hs->selected_bssid, &ep->bssid);
 685                 hs->selected_bssid_valid = TRUE;
 686                 hs->selected_ssid_valid = FALSE;
 687         }
 688
 689         wlanstat_details (hs, ep);
 690 }
 691
 692 static void
 693 wlan_unselect_cb(GtkWidget *w _U_, gint row _U_, gint col _U_, GdkEventButton *event _U_, gpointer data)
 694 {
 695         wlanstat_t *hs = (wlanstat_t *)data;
 696         hs->selected_bssid_valid = FALSE;
 697         hs->selected_ssid_valid = FALSE;
 698
 699         gtk_clist_clear (GTK_CLIST(hs->details));
 700 }
 701
 702 static void
 703 wlan_resolve_toggle_dest(GtkWidget *widget, gpointer data)
 704 {
 705         wlanstat_t *hs = (wlanstat_t *)data;
 706
 707         hs->resolve_names = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (widget));
 708         gtk_clist_clear (GTK_CLIST(hs->details));
 709
 710         wlanstat_draw(hs);
 711 }
 712
 713 static void
 714 wlan_existing_toggle_dest(GtkWidget *widget, gpointer data)
 715 {
 716         wlanstat_t *hs = (wlanstat_t *)data;
 717
 718         hs->show_only_existing = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (widget));
 719         gtk_clist_clear (GTK_CLIST(hs->details));
 720
 721         wlanstat_draw(hs);
 722 }
 723
 724 static void
 725 wlan_copy_as_csv(GtkWindow *win _U_, gpointer data)
 726 {
 727         int             i,j;
 728         gchar           *table_entry;
 729         GString         *CSV_str = g_string_new("");
 730         GtkClipboard    *cb;
 731         GtkCList       *clist = GTK_CLIST(data);
 732
 733         /* Add the column headers to the CSV data */
 734         for (j=0; j<NUM_COLS; j++) {
 735                 g_string_append(CSV_str, titles[j]);
 736                 if (j != (NUM_COLS - 1))
 737                         g_string_append(CSV_str, ",");
 738         }
 739         g_string_append(CSV_str,"\n");
 740
 741         /* Add the column values to the CSV data */
 742         for (i=0; i<clist->rows; i++) {
 743                 for (j=0; j<NUM_COLS; j++) {
 744                         gtk_clist_get_text(clist,i,j,&table_entry);
 745                         g_string_append(CSV_str,table_entry);
 746                         if (j != (NUM_COLS - 1))
 747                                 g_string_append(CSV_str,",");
 748                 }
 749                 g_string_append(CSV_str,"\n");
 750         }
 751
 752         /* Now that we have the CSV data, copy it into the default clipboard */
 753         cb = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
 754         gtk_clipboard_set_text(cb, CSV_str->str, -1);
 755         g_string_free(CSV_str, TRUE);
 756 }
 757
 758 void protect_thread_critical_region (void);
 759 void unprotect_thread_critical_region (void);
 760 static void
 761 win_destroy_cb (GtkWindow *win _U_, gpointer data)
 762 {
 763         wlanstat_t *hs = (wlanstat_t *)data;
 764
 765         protect_thread_critical_region ();
 766         remove_tap_listener (hs);
 767         unprotect_thread_critical_region ();
 768
 769         if (wlanstat_dlg_w != NULL) {
 770                 window_destroy(wlanstat_dlg_w);
 771                 wlanstat_dlg_w = NULL;
 772         }
 773         wlanstat_reset (hs);
 774         g_free (hs);
 775 }
 776
 777 /* Filter actions */
 778 #define ACTION_MATCH            0
 779 #define ACTION_PREPARE          1
 780 #define ACTION_FIND_FRAME       2
 781 #define ACTION_FIND_NEXT        3
 782 #define ACTION_FIND_PREVIOUS    4
 783 #define ACTION_COLORIZE         5
 784
 785 /* Action type - says what to do with the filter */
 786 #define ACTYPE_SELECTED         0
 787 #define ACTYPE_NOT_SELECTED     1
 788 #define ACTYPE_AND_SELECTED     2
 789 #define ACTYPE_OR_SELECTED      3
 790 #define ACTYPE_AND_NOT_SELECTED 4
 791 #define ACTYPE_OR_NOT_SELECTED  5
 792
 793 /* Encoded callback arguments */
 794 #define CALLBACK_MATCH(type)            ((ACTION_MATCH<<8) | (type))
 795 #define CALLBACK_PREPARE(type)          ((ACTION_PREPARE<<8) | (type))
 796 #define CALLBACK_FIND_FRAME(type)       ((ACTION_FIND_FRAME<<8) | (type))
 797 #define CALLBACK_FIND_NEXT(type)        ((ACTION_FIND_NEXT<<8) | (type))
 798 #define CALLBACK_FIND_PREVIOUS(type)    ((ACTION_FIND_PREVIOUS<<8) | (type))
 799 #define CALLBACK_COLORIZE(type)         ((ACTION_COLORIZE<<8) | (type))
 800
 801 /* Extract components of callback argument */
 802 #define FILTER_ACTION(cb_arg)           (((cb_arg)>>8) & 0xff)
 803 #define FILTER_ACTYPE(cb_arg)           ((cb_arg) & 0xff)
 804
 805 static void
 806 wlan_apply_filter (guint callback_action, char *dirstr)
 807 {
 808         int action, type;
 809         char str[256];
 810         const char *current_filter;
 811
 812         action = FILTER_ACTION(callback_action);
 813         type = FILTER_ACTYPE(callback_action);
 814
 815
 816         current_filter=gtk_entry_get_text(GTK_ENTRY(main_display_filter_widget));
 817         switch(type){
 818         case ACTYPE_SELECTED:
 819                 g_snprintf(str, 255, "%s", dirstr);
 820                 break;
 821         case ACTYPE_NOT_SELECTED:
 822                 g_snprintf(str, 255, "!(%s)", dirstr);
 823                 break;
 824         case ACTYPE_AND_SELECTED:
 825                 if ((!current_filter) || (0 == strlen(current_filter)))
 826                         g_snprintf(str, 255, "%s", dirstr);
 827                 else
 828                         g_snprintf(str, 255, "(%s) && (%s)", current_filter, dirstr);
 829                 break;
 830         case ACTYPE_OR_SELECTED:
 831                 if ((!current_filter) || (0 == strlen(current_filter)))
 832                         g_snprintf(str, 255, "%s", dirstr);
 833                 else
 834                         g_snprintf(str, 255, "(%s) || (%s)", current_filter, dirstr);
 835                 break;
 836         case ACTYPE_AND_NOT_SELECTED:
 837                 if ((!current_filter) || (0 == strlen(current_filter)))
 838                         g_snprintf(str, 255, "!(%s)", dirstr);
 839                 else
 840                         g_snprintf(str, 255, "(%s) && !(%s)", current_filter, dirstr);
 841                 break;
 842         case ACTYPE_OR_NOT_SELECTED:
 843                 if ((!current_filter) || (0 == strlen(current_filter)))
 844                         g_snprintf(str, 255, "!(%s)", dirstr);
 845                 else
 846                         g_snprintf(str, 255, "(%s) || !(%s)", current_filter, dirstr);
 847                 break;
 848         }
 849
 850         switch(action){
 851         case ACTION_MATCH:
 852                 gtk_entry_set_text(GTK_ENTRY(main_display_filter_widget), str);
 853                 main_filter_packets(&cfile, str, FALSE);
 854                 gdk_window_raise(top_level->window);
 855                 break;
 856         case ACTION_PREPARE:
 857                 gtk_entry_set_text(GTK_ENTRY(main_display_filter_widget), str);
 858                 break;
 859         case ACTION_FIND_FRAME:
 860                 find_frame_with_filter(str);
 861                 break;
 862         case ACTION_FIND_NEXT:
 863                 find_previous_next_frame_with_filter(str, FALSE);
 864                 break;
 865         case ACTION_FIND_PREVIOUS:
 866                 find_previous_next_frame_with_filter(str, TRUE);
 867                 break;
 868         case ACTION_COLORIZE:
 869                 color_display_with_filter(str);
 870                 break;
 871         }
 872 }
 873
 874 static void
 875 wlan_select_filter_cb(GtkWidget *widget _U_, gpointer callback_data, guint callback_action)
 876 {
 877         int selection;
 878         wlanstat_t *hs=(wlanstat_t *)callback_data;
 879         char dirstr[128];
 880         wlan_ep_t *ep;
 881
 882         selection=GPOINTER_TO_INT(g_list_nth_data(GTK_CLIST(hs->table)->selection, 0));
 883         if(selection>=(int)hs->num_entries){
 884                 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "No entry selected");
 885                 return;
 886         }
 887
 888         ep = gtk_clist_get_row_data (GTK_CLIST(hs->table), selection);
 889
 890         if (strcmp (get_addr_name(&ep->bssid), "Broadcast") == 0) {
 891                 g_snprintf(dirstr, 127, "wlan_mgt.ssid==\"%s\"", format_text(ep->stats.ssid, ep->stats.ssid_len));
 892         } else {
 893                 g_snprintf(dirstr, 127, "wlan.bssid==%s", address_to_str(&ep->bssid));
 894         }
 895
 896         wlan_apply_filter (callback_action, dirstr);
 897 }
 898
 899 static void
 900 wlan_details_select_filter_cb(GtkWidget *widget _U_, gpointer callback_data, guint callback_action)
 901 {
 902         int selection;
 903         wlanstat_t *hs=(wlanstat_t *)callback_data;
 904         char dirstr[128];
 905         wlan_details_ep_t *ep;
 906
 907         selection=GPOINTER_TO_INT(g_list_nth_data(GTK_CLIST(hs->details)->selection, 0));
 908         if(selection>=(int)hs->num_details){
 909                 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "No entry selected");
 910                 return;
 911         }
 912
 913         ep = gtk_clist_get_row_data (GTK_CLIST(hs->details), selection);
 914
 915         g_snprintf(dirstr, 127, "wlan.addr==%s", address_to_str(&ep->address));
 916
 917         wlan_apply_filter (callback_action, dirstr);
 918 }
 919
 920 static gint
 921 wlan_show_popup_menu_cb(void *widg _U_, GdkEvent *event, wlanstat_t *et)
 922 {
 923         GdkEventButton *bevent = (GdkEventButton *)event;
 924         gint row;
 925         gint column;
 926
 927         /* To qoute the "Gdk Event Structures" doc:
 928          * "Normally button 1 is the left mouse button, 2 is the middle button, and 3 is the right button" */
 929         if(event->type==GDK_BUTTON_PRESS && bevent->button==3){
 930                 /* if this is a right click on one of our columns, select it and popup the context menu */
 931                 if(gtk_clist_get_selection_info(GTK_CLIST(et->table),
 932                                                 (gint) (((GdkEventButton *)event)->x),
 933                                                 (gint) (((GdkEventButton *)event)->y),
 934                                                 &row, &column)) {
 935                         gtk_clist_unselect_all(GTK_CLIST(et->table));
 936                         gtk_clist_select_row(GTK_CLIST(et->table), row, -1);
 937
 938                         gtk_menu_popup(GTK_MENU(et->menu), NULL, NULL, NULL, NULL,
 939                                        bevent->button, bevent->time);
 940                 }
 941         }
 942
 943         return FALSE;
 944 }
 945
 946 static GtkItemFactoryEntry wlan_list_menu_items[] =
 947 {
 948         /* Match */
 949         {"/Apply as Filter", NULL, NULL, 0, "<Branch>", NULL,},
 950         {"/Apply as Filter/Selected", NULL,
 951                 GTK_MENU_FUNC(wlan_select_filter_cb), CALLBACK_MATCH(ACTYPE_SELECTED), NULL, NULL,},
 952         {"/Apply as Filter/Not Selected", NULL,
 953                 GTK_MENU_FUNC(wlan_select_filter_cb), CALLBACK_MATCH(ACTYPE_NOT_SELECTED), NULL, NULL,},
 954         {"/Apply as Filter/... and Selected", NULL,
 955                 GTK_MENU_FUNC(wlan_select_filter_cb), CALLBACK_MATCH(ACTYPE_AND_SELECTED), NULL, NULL,},
 956         {"/Apply as Filter/... or Selected", NULL,
 957                 GTK_MENU_FUNC(wlan_select_filter_cb), CALLBACK_MATCH(ACTYPE_OR_SELECTED), NULL, NULL,},
 958         {"/Apply as Filter/... and not Selected", NULL,
 959                 GTK_MENU_FUNC(wlan_select_filter_cb), CALLBACK_MATCH(ACTYPE_AND_NOT_SELECTED), NULL, NULL,},
 960         {"/Apply as Filter/... or not Selected", NULL,
 961                 GTK_MENU_FUNC(wlan_select_filter_cb), CALLBACK_MATCH(ACTYPE_OR_NOT_SELECTED), NULL, NULL,},
 962
 963         /* Prepare */
 964         {"/Prepare a Filter", NULL, NULL, 0, "<Branch>", NULL,},
 965         {"/Prepare a Filter/Selected", NULL,
 966                 GTK_MENU_FUNC(wlan_select_filter_cb), CALLBACK_PREPARE(ACTYPE_SELECTED), NULL, NULL,},
 967         {"/Prepare a Filter/Not Selected", NULL,
 968                 GTK_MENU_FUNC(wlan_select_filter_cb), CALLBACK_PREPARE(ACTYPE_NOT_SELECTED), NULL, NULL,},
 969         {"/Prepare a Filter/... and Selected", NULL,
 970                 GTK_MENU_FUNC(wlan_select_filter_cb), CALLBACK_PREPARE(ACTYPE_AND_SELECTED), NULL, NULL,},
 971         {"/Prepare a Filter/... or Selected", NULL,
 972                 GTK_MENU_FUNC(wlan_select_filter_cb), CALLBACK_PREPARE(ACTYPE_OR_SELECTED), NULL, NULL,},
 973         {"/Prepare a Filter/... and not Selected", NULL,
 974                 GTK_MENU_FUNC(wlan_select_filter_cb), CALLBACK_PREPARE(ACTYPE_AND_NOT_SELECTED), NULL, NULL,},
 975         {"/Prepare a Filter/... or not Selected", NULL,
 976                 GTK_MENU_FUNC(wlan_select_filter_cb), CALLBACK_PREPARE(ACTYPE_OR_NOT_SELECTED), NULL, NULL,},
 977
 978         /* Find Frame */
 979         {"/Find Frame", NULL, NULL, 0, "<Branch>", NULL,},
 980         {"/Find Frame/Find Frame", NULL,
 981                 GTK_MENU_FUNC(wlan_select_filter_cb), CALLBACK_FIND_FRAME(ACTYPE_SELECTED), NULL, NULL,},
 982         /* Find Next */
 983         {"/Find Frame/Find Next", NULL,
 984                 GTK_MENU_FUNC(wlan_select_filter_cb), CALLBACK_FIND_NEXT(ACTYPE_SELECTED), NULL, NULL,},
 985         /* Find Previous */
 986         {"/Find Frame/Find Previous", NULL,
 987                 GTK_MENU_FUNC(wlan_select_filter_cb), CALLBACK_FIND_PREVIOUS(ACTYPE_SELECTED), NULL, NULL,},
 988         /* Colorize Host Traffic */
 989         {"/Colorize Host Traffic", NULL,
 990                 GTK_MENU_FUNC(wlan_select_filter_cb), CALLBACK_COLORIZE(ACTYPE_SELECTED), NULL, NULL,}
 991
 992 };
 993
 994 static void
 995 wlan_create_popup_menu(wlanstat_t *hs)
 996 {
 997         GtkItemFactory *item_factory;
 998
 999         item_factory = gtk_item_factory_new(GTK_TYPE_MENU, "<main>", NULL);
1000
1001         gtk_item_factory_create_items_ac(item_factory, sizeof(wlan_list_menu_items)/sizeof(wlan_list_menu_items[0]), wlan_list_menu_items, hs, 2);
1002
1003         hs->menu = gtk_item_factory_get_widget(item_factory, "<main>");
1004         g_signal_connect(hs->table, "button_press_event", G_CALLBACK(wlan_show_popup_menu_cb), hs);
1005 }
1006
1007 static gint
1008 wlan_details_show_popup_menu_cb(void *widg _U_, GdkEvent *event, wlanstat_t *et)
1009 {
1010         GdkEventButton *bevent = (GdkEventButton *)event;
1011         gint row;
1012         gint column;
1013
1014         /* To qoute the "Gdk Event Structures" doc:
1015          * "Normally button 1 is the left mouse button, 2 is the middle button, and 3 is the right button" */
1016         if(event->type==GDK_BUTTON_PRESS && bevent->button==3){
1017                 /* if this is a right click on one of our columns, select it and popup the context menu */
1018                 if(gtk_clist_get_selection_info(GTK_CLIST(et->details),
1019                                                 (gint) (((GdkEventButton *)event)->x),
1020                                                 (gint) (((GdkEventButton *)event)->y),
1021                                                 &row, &column)) {
1022                         gtk_clist_unselect_all(GTK_CLIST(et->details));
1023                         gtk_clist_select_row(GTK_CLIST(et->details), row, -1);
1024
1025                         gtk_menu_popup(GTK_MENU(et->details_menu), NULL, NULL, NULL, NULL,
1026                                        bevent->button, bevent->time);
1027                 }
1028         }
1029
1030         return FALSE;
1031 }
1032
1033 static GtkItemFactoryEntry wlan_details_list_menu_items[] =
1034 {
1035         /* Match */
1036         {"/Apply as Filter", NULL, NULL, 0, "<Branch>", NULL,},
1037         {"/Apply as Filter/Selected", NULL,
1038                 GTK_MENU_FUNC(wlan_details_select_filter_cb), CALLBACK_MATCH(ACTYPE_SELECTED), NULL, NULL,},
1039         {"/Apply as Filter/Not Selected", NULL,
1040                 GTK_MENU_FUNC(wlan_details_select_filter_cb), CALLBACK_MATCH(ACTYPE_NOT_SELECTED), NULL, NULL,},
1041         {"/Apply as Filter/... and Selected", NULL,
1042                 GTK_MENU_FUNC(wlan_details_select_filter_cb), CALLBACK_MATCH(ACTYPE_AND_SELECTED), NULL, NULL,},
1043         {"/Apply as Filter/... or Selected", NULL,
1044                 GTK_MENU_FUNC(wlan_details_select_filter_cb), CALLBACK_MATCH(ACTYPE_OR_SELECTED), NULL, NULL,},
1045         {"/Apply as Filter/... and not Selected", NULL,
1046                 GTK_MENU_FUNC(wlan_details_select_filter_cb), CALLBACK_MATCH(ACTYPE_AND_NOT_SELECTED), NULL, NULL,},
1047         {"/Apply as Filter/... or not Selected", NULL,
1048                 GTK_MENU_FUNC(wlan_details_select_filter_cb), CALLBACK_MATCH(ACTYPE_OR_NOT_SELECTED), NULL, NULL,},
1049
1050         /* Prepare */
1051         {"/Prepare a Filter", NULL, NULL, 0, "<Branch>", NULL,},
1052         {"/Prepare a Filter/Selected", NULL,
1053                 GTK_MENU_FUNC(wlan_details_select_filter_cb), CALLBACK_PREPARE(ACTYPE_SELECTED), NULL, NULL,},
1054         {"/Prepare a Filter/Not Selected", NULL,
1055                 GTK_MENU_FUNC(wlan_details_select_filter_cb), CALLBACK_PREPARE(ACTYPE_NOT_SELECTED), NULL, NULL,},
1056         {"/Prepare a Filter/... and Selected", NULL,
1057                 GTK_MENU_FUNC(wlan_details_select_filter_cb), CALLBACK_PREPARE(ACTYPE_AND_SELECTED), NULL, NULL,},
1058         {"/Prepare a Filter/... or Selected", NULL,
1059                 GTK_MENU_FUNC(wlan_details_select_filter_cb), CALLBACK_PREPARE(ACTYPE_OR_SELECTED), NULL, NULL,},
1060         {"/Prepare a Filter/... and not Selected", NULL,
1061                 GTK_MENU_FUNC(wlan_details_select_filter_cb), CALLBACK_PREPARE(ACTYPE_AND_NOT_SELECTED), NULL, NULL,},
1062         {"/Prepare a Filter/... or not Selected", NULL,
1063                 GTK_MENU_FUNC(wlan_details_select_filter_cb), CALLBACK_PREPARE(ACTYPE_OR_NOT_SELECTED), NULL, NULL,},
1064
1065         /* Find Frame */
1066         {"/Find Frame", NULL, NULL, 0, "<Branch>", NULL,},
1067         {"/Find Frame/Find Frame", NULL,
1068                 GTK_MENU_FUNC(wlan_details_select_filter_cb), CALLBACK_FIND_FRAME(ACTYPE_SELECTED), NULL, NULL,},
1069         /* Find Next */
1070         {"/Find Frame/Find Next", NULL,
1071                 GTK_MENU_FUNC(wlan_details_select_filter_cb), CALLBACK_FIND_NEXT(ACTYPE_SELECTED), NULL, NULL,},
1072         /* Find Previous */
1073         {"/Find Frame/Find Previous", NULL,
1074                 GTK_MENU_FUNC(wlan_details_select_filter_cb), CALLBACK_FIND_PREVIOUS(ACTYPE_SELECTED), NULL, NULL,},
1075         /* Colorize Host Traffic */
1076         {"/Colorize Host Traffic", NULL,
1077                 GTK_MENU_FUNC(wlan_details_select_filter_cb), CALLBACK_COLORIZE(ACTYPE_SELECTED), NULL, NULL,}
1078
1079 };
1080
1081 static void
1082 wlan_details_create_popup_menu(wlanstat_t *hs)
1083 {
1084         GtkItemFactory *item_factory;
1085
1086         item_factory = gtk_item_factory_new(GTK_TYPE_MENU, "<main>", NULL);
1087
1088         gtk_item_factory_create_items_ac(item_factory, sizeof(wlan_details_list_menu_items)/sizeof(wlan_details_list_menu_items[0]), wlan_details_list_menu_items, hs, 2);
1089
1090         hs->details_menu = gtk_item_factory_get_widget(item_factory, "<main>");
1091         g_signal_connect(hs->details, "button_press_event", G_CALLBACK(wlan_details_show_popup_menu_cb), hs);
1092 }
1093
1094 static void
1095 wlanstat_dlg_create (void)
1096 {
1097         wlanstat_t *hs;
1098         GString *error_string;
1099         GtkWidget *top_label;
1100         GtkWidget *pane;
1101         GtkWidget  *scrolled_window;
1102         GtkWidget *bbox;
1103         GtkWidget  *vbox;
1104         GtkWidget  *hbox;
1105         GtkWidget *resolv_cb;
1106         GtkWidget *existing_cb;
1107         GtkWidget *close_bt;
1108         GtkWidget *help_bt;
1109         GtkTooltips *tooltips = gtk_tooltips_new();
1110         GtkWidget *copy_bt;
1111         column_arrows *col_arrows;
1112         GtkWidget *column_lb;
1113         char title[256];
1114         int i;
1115
1116         hs=g_malloc (sizeof(wlanstat_t));
1117         hs->num_entries = 0;
1118         hs->ep_list = NULL;
1119         hs->number_of_packets = 0;
1120         hs->resolve_names = TRUE;
1121         hs->show_only_existing = FALSE;
1122
1123         g_snprintf (title, 255, "Wireshark: WLAN Traffic Statistics: %s",
1124                     cf_get_display_name(&cfile));
1125         wlanstat_dlg_w = window_new_with_geom (GTK_WINDOW_TOPLEVEL, title, "WLAN Statistics");
1126         gtk_window_set_default_size (GTK_WINDOW(wlanstat_dlg_w), 750, 400);
1127
1128         vbox=gtk_vbox_new (FALSE, 3);
1129         gtk_container_add(GTK_CONTAINER(wlanstat_dlg_w), vbox);
1130         gtk_container_set_border_width (GTK_CONTAINER(vbox), 12);
1131
1132         top_label = gtk_label_new ("WLAN Traffic Statistics");
1133         gtk_box_pack_start (GTK_BOX (vbox), top_label, FALSE, FALSE, 0);
1134
1135         pane = gtk_vpaned_new();
1136         gtk_box_pack_start (GTK_BOX (vbox), pane,TRUE, TRUE, 0);
1137         gtk_widget_show(pane);
1138
1139         /* init a scrolled window for overview */
1140         scrolled_window = scrolled_window_new (NULL, NULL);
1141         gtk_paned_pack1(GTK_PANED(pane), scrolled_window, TRUE, TRUE);
1142         gtk_paned_set_position(GTK_PANED(pane), 200);
1143
1144         hs->table = gtk_clist_new (NUM_COLS);
1145         gtk_container_add (GTK_CONTAINER (scrolled_window), hs->table);
1146
1147         gtk_clist_column_titles_show (GTK_CLIST (hs->table));
1148
1149         gtk_clist_set_compare_func(GTK_CLIST(hs->table), wlan_sort_column);
1150         gtk_clist_set_sort_column(GTK_CLIST(hs->table), 2);
1151         gtk_clist_set_sort_type(GTK_CLIST(hs->table), GTK_SORT_ASCENDING);
1152
1153         /* sort by column feature */
1154         col_arrows = (column_arrows *) g_malloc(sizeof(column_arrows) * NUM_COLS);
1155
1156         for (i=0; i<NUM_COLS; i++) {
1157                 col_arrows[i].table = gtk_table_new(2, 2, FALSE);
1158                 gtk_table_set_col_spacings(GTK_TABLE(col_arrows[i].table), 5);
1159                 column_lb = gtk_label_new(titles[i]);
1160                 gtk_table_attach(GTK_TABLE(col_arrows[i].table), column_lb, 0, 1, 0, 2,
1161                                  GTK_SHRINK, GTK_SHRINK, 0, 0);
1162                 gtk_widget_show(column_lb);
1163
1164                 col_arrows[i].ascend_pm = xpm_to_widget(clist_ascend_xpm);
1165                 gtk_table_attach(GTK_TABLE(col_arrows[i].table), col_arrows[i].ascend_pm,
1166                                  1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
1167                 col_arrows[i].descend_pm = xpm_to_widget(clist_descend_xpm);
1168                 gtk_table_attach(GTK_TABLE(col_arrows[i].table), col_arrows[i].descend_pm,
1169                                  1, 2, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0);
1170                 /* make ssid be the default sort order */
1171                 if (i == 2) {
1172                         gtk_widget_show(col_arrows[i].ascend_pm);
1173                 }
1174                 if (i == 0 || i == 2 || i == 11) {
1175                         gtk_clist_set_column_justification(GTK_CLIST(hs->table), i, GTK_JUSTIFY_LEFT);
1176                 } else {
1177                         gtk_clist_set_column_justification(GTK_CLIST(hs->table), i, GTK_JUSTIFY_RIGHT);
1178                 }
1179                 gtk_clist_set_column_auto_resize(GTK_CLIST(hs->table), i, TRUE);
1180                 gtk_clist_set_column_widget(GTK_CLIST(hs->table), i, col_arrows[i].table);
1181                 gtk_widget_show(col_arrows[i].table);
1182         }
1183
1184         g_signal_connect(GTK_CLIST(hs->table), "click-column", G_CALLBACK(wlan_click_column_cb), col_arrows);
1185         g_signal_connect(GTK_CLIST(hs->table), "select-row", G_CALLBACK(wlan_select_cb), hs);
1186         g_signal_connect(GTK_CLIST(hs->table), "unselect-row", G_CALLBACK(wlan_unselect_cb), hs);
1187
1188         /* init a scrolled window for details */
1189         scrolled_window = scrolled_window_new (NULL, NULL);
1190         gtk_paned_pack2(GTK_PANED(pane), scrolled_window, FALSE, TRUE);
1191
1192         hs->details = gtk_clist_new (NUM_DETAIL_COLS);
1193         gtk_container_add (GTK_CONTAINER (scrolled_window), hs->details);
1194
1195         gtk_clist_column_titles_show (GTK_CLIST (hs->details));
1196
1197         gtk_clist_set_compare_func(GTK_CLIST(hs->details), wlan_detail_sort_column);
1198         gtk_clist_set_sort_column(GTK_CLIST(hs->details), 0);
1199         gtk_clist_set_sort_type(GTK_CLIST(hs->details), GTK_SORT_ASCENDING);
1200
1201         /* sort by column feature */
1202         col_arrows = (column_arrows *) g_malloc(sizeof(column_arrows) * NUM_DETAIL_COLS);
1203
1204         for (i=0; i<NUM_DETAIL_COLS; i++) {
1205                 col_arrows[i].table = gtk_table_new(2, 2, FALSE);
1206                 gtk_table_set_col_spacings(GTK_TABLE(col_arrows[i].table), 5);
1207                 column_lb = gtk_label_new(detail_titles[i]);
1208                 gtk_table_attach(GTK_TABLE(col_arrows[i].table), column_lb, 0, 1, 0, 2,
1209                                  GTK_SHRINK, GTK_SHRINK, 0, 0);
1210                 gtk_widget_show(column_lb);
1211
1212                 col_arrows[i].ascend_pm = xpm_to_widget(clist_ascend_xpm);
1213                 gtk_table_attach(GTK_TABLE(col_arrows[i].table), col_arrows[i].ascend_pm,
1214                                  1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
1215                 col_arrows[i].descend_pm = xpm_to_widget(clist_descend_xpm);
1216                 gtk_table_attach(GTK_TABLE(col_arrows[i].table), col_arrows[i].descend_pm,
1217                                  1, 2, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0);
1218                 /* make ssid be the default sort order */
1219                 if (i == 0) {
1220                         gtk_widget_show(col_arrows[i].ascend_pm);
1221                 }
1222                 if (i == 0 || i == 9) {
1223                         gtk_clist_set_column_justification(GTK_CLIST(hs->details), i, GTK_JUSTIFY_LEFT);
1224                 } else {
1225                         gtk_clist_set_column_justification(GTK_CLIST(hs->details), i, GTK_JUSTIFY_RIGHT);
1226                 }
1227                 gtk_clist_set_column_auto_resize(GTK_CLIST(hs->details), i, TRUE);
1228                 gtk_clist_set_column_widget(GTK_CLIST(hs->details), i, col_arrows[i].table);
1229                 gtk_widget_show(col_arrows[i].table);
1230         }
1231
1232         g_signal_connect(GTK_CLIST(hs->details), "click-column", G_CALLBACK(wlan_detail_click_column_cb), col_arrows);
1233
1234         /* create popup menu for this table */
1235         wlan_create_popup_menu(hs);
1236         wlan_details_create_popup_menu(hs);
1237
1238         error_string=register_tap_listener ("wlan", hs, NULL, wlanstat_reset,
1239                                             wlanstat_packet, wlanstat_draw);
1240         if (error_string) {
1241                 simple_dialog (ESD_TYPE_ERROR, ESD_BTN_OK, error_string->str);
1242                 g_string_free (error_string, TRUE);
1243                 g_free (hs);
1244                 return;
1245         }
1246
1247         hbox = gtk_hbox_new(FALSE, 3);
1248         gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1249
1250         resolv_cb = gtk_check_button_new_with_mnemonic("Name resolution");
1251         gtk_container_add(GTK_CONTAINER(hbox), resolv_cb);
1252         gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(resolv_cb), TRUE);
1253         gtk_tooltips_set_tip(tooltips, resolv_cb, "Show results of name resolutions rather than the \"raw\" values. "
1254                              "Please note: The corresponding name resolution must be enabled.", NULL);
1255
1256         g_signal_connect(resolv_cb, "toggled", G_CALLBACK(wlan_resolve_toggle_dest), hs);
1257
1258         existing_cb = gtk_check_button_new_with_mnemonic("Only show existing networks");
1259         gtk_container_add(GTK_CONTAINER(hbox), existing_cb);
1260         gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(existing_cb), FALSE);
1261         gtk_tooltips_set_tip(tooltips, existing_cb, "This option disables probe requests for "
1262                              "unknown networks.", NULL);
1263         g_signal_connect(existing_cb, "toggled", G_CALLBACK(wlan_existing_toggle_dest), hs);
1264
1265         /* Button row. */
1266         if (topic_available (HELP_STATS_WLAN_TRAFFIC_DIALOG)) {
1267                 bbox = dlg_button_row_new (GTK_STOCK_CLOSE, GTK_STOCK_COPY, GTK_STOCK_HELP, NULL);
1268         } else {
1269                 bbox = dlg_button_row_new (GTK_STOCK_CLOSE, GTK_STOCK_COPY, NULL);
1270         }
1271
1272         gtk_box_pack_end (GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
1273
1274         close_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLOSE);
1275         window_set_cancel_button (wlanstat_dlg_w, close_bt, window_cancel_button_cb);
1276
1277         copy_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_COPY);
1278         gtk_tooltips_set_tip(tooltips, copy_bt,
1279                              "Copy all statistical values of this page to the clipboard in CSV (Comma Seperated Values) format.", NULL);
1280         g_signal_connect(copy_bt, "clicked", G_CALLBACK(wlan_copy_as_csv), hs->table);
1281
1282         if (topic_available (HELP_STATS_WLAN_TRAFFIC_DIALOG)) {
1283                 help_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP);
1284                 g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb), (gpointer)HELP_STATS_WLAN_TRAFFIC_DIALOG);
1285         }
1286
1287         g_signal_connect (wlanstat_dlg_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
1288         g_signal_connect (wlanstat_dlg_w, "destroy", G_CALLBACK(win_destroy_cb), hs);
1289
1290         gtk_widget_show_all (wlanstat_dlg_w);
1291         window_present (wlanstat_dlg_w);
1292
1293         cf_retap_packets (&cfile, FALSE);
1294 }
1295
1296 static void
1297 wlanstat_launch (GtkWidget *w _U_, gpointer data _U_)
1298 {
1299         if (wlanstat_dlg_w) {
1300                 reactivate_window(wlanstat_dlg_w);
1301         } else {
1302                 wlanstat_dlg_create ();
1303         }
1304 }
1305
1306 void
1307 register_tap_listener_wlanstat (void)
1308 {
1309         register_stat_menu_item ("WLAN Traffic...", REGISTER_STAT_GROUP_UNSORTED,
1310                                  wlanstat_launch, NULL, NULL, NULL);
1311 }