gtk/mac_lte_stat_dlg.c

   1 /* mac_lte_stat_dlg.c
   2  * Copyright 2009 Martin Mathieson
   3  * (originally based upon wlan_stat_dlg.c)
   4  *
   5  * $Id$
   6  *
   7  * Wireshark - Network traffic analyzer
   8  * By Gerald Combs <gerald@wireshark.org>
   9  * Copyright 1998 Gerald Combs
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License
  13  * as published by the Free Software Foundation; either version 2
  14  * of the License, or (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  24  */
  25
  26
  27 /* TODO:
  28    - CSV export?
  29 */
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include "config.h"
  33 #endif
  34
  35 #ifdef HAVE_SYS_TYPES_H
  36 #include <sys/types.h>
  37 #endif
  38
  39 #include <string.h>
  40
  41 #include <gtk/gtk.h>
  42
  43 #include "gtk/gtkglobals.h"
  44
  45 #include <epan/packet.h>
  46 #include <epan/packet_info.h>
  47 #include <epan/tap.h>
  48 #include <epan/dissectors/packet-mac-lte.h>
  49
  50 #include "../simple_dialog.h"
  51 #include "../stat_menu.h"
  52
  53 #include "gtk/dlg_utils.h"
  54 #include "gtk/gui_stat_menu.h"
  55 #include "gtk/tap_param_dlg.h"
  56 #include "gtk/gui_utils.h"
  57 #include "gtk/help_dlg.h"
  58 #include "gtk/main.h"
  59
  60 /**********************************************/
  61 /* Table column identifiers and title strings */
  62
  63 enum {
  64     RNTI_COLUMN,
  65     RNTI_TYPE_COLUMN,
  66     UEID_COLUMN,
  67     UL_FRAMES_COLUMN,
  68     UL_BYTES_COLUMN,
  69     UL_BW_COLUMN,
  70     UL_PADDING_PERCENT_COLUMN,
  71     UL_RETX_FRAMES_COLUMN,
  72     DL_FRAMES_COLUMN,
  73     DL_BYTES_COLUMN,
  74     DL_BW_COLUMN,
  75     DL_CRC_FAILED_COLUMN,
  76     DL_CRC_HIGH_CODE_RATE_COLUMN,
  77     DL_CRC_PDSCH_LOST_COLUMN,
  78     DL_RETX_FRAMES_COLUMN,
  79     TABLE_COLUMN,
  80     NUM_UE_COLUMNS
  81 };
  82
  83 enum {
  84     CCCH_COLUMN=1,
  85     LCID1_COLUMN,
  86     LCID2_COLUMN,
  87     LCID3_COLUMN,
  88     LCID4_COLUMN,
  89     LCID5_COLUMN,
  90     LCID6_COLUMN,
  91     LCID7_COLUMN,
  92     LCID8_COLUMN,
  93     LCID9_COLUMN,
  94     LCID10_COLUMN,
  95     PREDEFINED_COLUMN,
  96     NUM_CHANNEL_COLUMNS
  97 };
  98
  99 static const gchar *ue_titles[] = { "RNTI", "Type", "UEId",
 100                                     "UL Frames", "UL Bytes", "UL MBit/sec", "UL Padding %", "UL ReTX",
 101                                     "DL Frames", "DL Bytes", "DL MBit/sec", "DL CRC Failed", "DL CRC High Code Rate", "DL CRC PDSCH Lost", "DL ReTX"};
 102
 103 static const gchar *channel_titles[] = { "CCCH",
 104                                          "LCID 1", "LCID 2", "LCID 3", "LCID 4", "LCID 5",
 105                                          "LCID 6", "LCID 7", "LCID 8", "LCID 9", "LCID 10",
 106                                          "Predefined"};
 107
 108
 109 /* Stats for one UE */
 110 typedef struct mac_lte_row_data {
 111     /* Key for matching this row */
 112     guint16  rnti;
 113     guint8   rnti_type;
 114     guint16  ueid;
 115
 116     gboolean is_predefined_data;
 117
 118     guint32  UL_frames;
 119     guint32  UL_raw_bytes;   /* all bytes */
 120     guint32  UL_total_bytes; /* payload */
 121     nstime_t UL_time_start;
 122     nstime_t UL_time_stop;
 123     guint32  UL_padding_bytes;
 124     guint32  UL_CRC_errors;
 125     guint32  UL_retx_frames;
 126
 127     guint32  DL_frames;
 128     guint32  DL_total_bytes;
 129     nstime_t DL_time_start;
 130     nstime_t DL_time_stop;
 131     guint32  DL_CRC_failures;
 132     guint32  DL_CRC_high_code_rate;
 133     guint32  DL_CRC_PDSCH_lost;
 134     guint32  DL_retx_frames;
 135
 136     guint32  UL_bytes_for_lcid[11];
 137     guint32  UL_sdus_for_lcid[11];
 138     guint32  DL_bytes_for_lcid[11];
 139     guint32  DL_sdus_for_lcid[11];
 140 } mac_lte_row_data;
 141
 142
 143 /* One row/UE in the UE table */
 144 typedef struct mac_lte_ep {
 145     struct mac_lte_ep* next;
 146     struct mac_lte_row_data stats;
 147     GtkTreeIter iter;
 148     gboolean iter_valid;
 149 } mac_lte_ep_t;
 150
 151
 152 /* Common channel stats */
 153 typedef struct mac_lte_common_stats {
 154     guint32 all_frames;
 155     guint32 bch_frames;
 156     guint32 bch_bytes;
 157     guint32 pch_frames;
 158     guint32 pch_bytes;
 159     guint32 rar_frames;
 160     guint32 rar_entries;
 161
 162     guint16  max_ul_ues_in_tti;
 163     guint16  max_dl_ues_in_tti;
 164 } mac_lte_common_stats;
 165
 166
 167 static const char * selected_ue_row_names[] = {"UL SDUs", "UL Bytes", "DL SDUs", "DL Bytes"};
 168
 169
 170 /* Used to keep track of whole MAC LTE statistics window */
 171 typedef struct mac_lte_stat_t {
 172     /* Stats window itself */
 173     GtkWidget  *mac_lte_stat_dlg_w;
 174
 175     char       *filter;
 176
 177     /* Labels */
 178     GtkWidget  *mac_lte_stat_ues_lb;
 179     GtkWidget  *ul_filter_bt;
 180     GtkWidget  *dl_filter_bt;
 181     GtkWidget  *uldl_filter_bt;
 182
 183     GtkWidget  *show_dct_errors_cb;
 184     GtkWidget  *dct_error_substring_lb;
 185     GtkWidget  *dct_error_substring_te;
 186
 187     GtkWidget  *ul_max_ues_per_tti;
 188     GtkWidget  *dl_max_ues_per_tti;
 189
 190     /* Common stats */
 191     mac_lte_common_stats common_stats;
 192     GtkWidget *common_bch_frames;
 193     GtkWidget *common_bch_bytes;
 194     GtkWidget *common_pch_frames;
 195     GtkWidget *common_pch_bytes;
 196     GtkWidget *common_rar_frames;
 197     GtkWidget *common_rar_entries;
 198
 199     /* Keep track of unique rntis & ueids */
 200     guint8 used_ueids[65535];
 201     guint8 used_rntis[65535];
 202     guint16 number_of_ueids;
 203     guint16 number_of_rntis;
 204
 205     guint16 selected_rnti;
 206     guint16 selected_ueid;
 207
 208     /* Labels in selected UE 'table' */
 209     GtkWidget *selected_ue_column_entry[NUM_CHANNEL_COLUMNS][5];
 210
 211     GtkTreeView   *ue_table;
 212     mac_lte_ep_t  *ep_list;
 213 } mac_lte_stat_t;
 214
 215
 216 /* Reset the statistics window */
 217 static void
 218 mac_lte_stat_reset(void *phs)
 219 {
 220     mac_lte_stat_t* mac_lte_stat = (mac_lte_stat_t *)phs;
 221     mac_lte_ep_t* list = mac_lte_stat->ep_list;
 222     gchar title[256];
 223     GtkListStore *store;
 224     gint i, n;
 225
 226     /* Set the title */
 227     if (mac_lte_stat->mac_lte_stat_dlg_w != NULL) {
 228         g_snprintf(title, sizeof(title), "Wireshark: LTE MAC Traffic Statistics: %s (filter=\"%s\")",
 229                    cf_get_display_name(&cfile),
 230                    mac_lte_stat->filter ? mac_lte_stat->filter : "none");
 231         gtk_window_set_title(GTK_WINDOW(mac_lte_stat->mac_lte_stat_dlg_w), title);
 232     }
 233
 234     g_snprintf(title, sizeof(title), "UL/DL-SCH data (0 entries)");
 235     gtk_frame_set_label(GTK_FRAME(mac_lte_stat->mac_lte_stat_ues_lb), title);
 236
 237     /* Reset counts of unique ueids & rntis */
 238     memset(mac_lte_stat->used_ueids, 0, 65535);
 239     mac_lte_stat->number_of_ueids = 0;
 240     memset(mac_lte_stat->used_rntis, 0, 65535);
 241     mac_lte_stat->number_of_rntis = 0;
 242
 243     /* Zero common stats */
 244     memset(&(mac_lte_stat->common_stats), 0, sizeof(mac_lte_common_stats));
 245
 246     /* Remove all entries from the UE list */
 247     store = GTK_LIST_STORE(gtk_tree_view_get_model(mac_lte_stat->ue_table));
 248     gtk_list_store_clear(store);
 249
 250     if (!list) {
 251         return;
 252     }
 253
 254     mac_lte_stat->ep_list = NULL;
 255
 256     /* Set all of the channel counters to 0 */
 257     for (n=1; n <=4; n++) {
 258         for (i=CCCH_COLUMN; i < NUM_CHANNEL_COLUMNS; i++) {
 259              gtk_label_set_text(GTK_LABEL(mac_lte_stat->selected_ue_column_entry[i][n]), "0");
 260         }
 261     }
 262 }
 263
 264
 265 /* Allocate a mac_lte_ep_t struct to store info for new UE */
 266 static mac_lte_ep_t* alloc_mac_lte_ep(struct mac_lte_tap_info *si, packet_info *pinfo _U_)
 267 {
 268     mac_lte_ep_t* ep;
 269     int n;
 270
 271     if (!si) {
 272         return NULL;
 273     }
 274
 275     if (!(ep = g_malloc(sizeof(mac_lte_ep_t)))) {
 276         return NULL;
 277     }
 278
 279     /* Copy SI data into ep->stats */
 280     ep->stats.rnti = si->rnti;
 281     ep->stats.rnti_type = si->rntiType;
 282     ep->stats.ueid = si->ueid;
 283
 284     /* Counts for new UE are all 0 */
 285     ep->stats.UL_frames = 0;
 286     ep->stats.DL_frames = 0;
 287     ep->stats.UL_total_bytes = 0;
 288     ep->stats.UL_raw_bytes = 0;
 289     ep->stats.UL_padding_bytes = 0;
 290     ep->stats.DL_total_bytes = 0;
 291     ep->stats.UL_CRC_errors = 0;
 292     ep->stats.DL_CRC_failures = 0;
 293     ep->stats.DL_CRC_high_code_rate = 0;
 294     ep->stats.DL_CRC_PDSCH_lost = 0;
 295     ep->stats.UL_retx_frames = 0;
 296     ep->stats.DL_retx_frames = 0;
 297
 298     for (n=0; n < 11; n++) {
 299         ep->stats.UL_sdus_for_lcid[n] = 0;
 300         ep->stats.UL_bytes_for_lcid[n] = 0;
 301     }
 302     ep->stats.DL_total_bytes = 0;
 303     for (n=0; n < 11; n++) {
 304         ep->stats.DL_sdus_for_lcid[n] = 0;
 305         ep->stats.DL_bytes_for_lcid[n] = 0;
 306     }
 307
 308     ep->next = NULL;
 309
 310     ep->iter_valid = FALSE;
 311
 312     return ep;
 313 }
 314
 315
 316 /* Update counts of unique rntis & ueids */
 317 static void update_ueid_rnti_counts(guint16 rnti, guint16 ueid, mac_lte_stat_t *hs)
 318 {
 319     if (!hs->used_ueids[ueid]) {
 320         hs->used_ueids[ueid] = TRUE;
 321         hs->number_of_ueids++;
 322     }
 323     if (!hs->used_rntis[rnti]) {
 324         hs->used_rntis[rnti] = TRUE;
 325         hs->number_of_rntis++;
 326     }
 327 }
 328
 329
 330 /* Process stat struct for a MAC LTE frame */
 331 static int
 332 mac_lte_stat_packet(void *phs, packet_info *pinfo, epan_dissect_t *edt _U_,
 333                     const void *phi)
 334 {
 335     int n;
 336
 337     /* Get reference to stat window instance */
 338     mac_lte_stat_t *hs = (mac_lte_stat_t *)phs;
 339     mac_lte_ep_t *tmp = NULL, *te = NULL;
 340
 341     /* Cast tap info struct */
 342     struct mac_lte_tap_info *si = (struct mac_lte_tap_info *)phi;
 343
 344     if (!hs) {
 345         return 0;
 346     }
 347
 348     hs->common_stats.all_frames++;
 349
 350     /* For common channels, just update global counters */
 351     switch (si->rntiType) {
 352         case P_RNTI:
 353             hs->common_stats.pch_frames++;
 354             hs->common_stats.pch_bytes += si->single_number_of_bytes;
 355             return 1;
 356         case SI_RNTI:
 357         case NO_RNTI:
 358             hs->common_stats.bch_frames++;
 359             hs->common_stats.bch_bytes += si->single_number_of_bytes;
 360             return 1;
 361         case RA_RNTI:
 362             hs->common_stats.rar_frames++;
 363             hs->common_stats.rar_entries += si->number_of_rars;
 364             return 1;
 365         case C_RNTI:
 366         case SPS_RNTI:
 367             /* Drop through for per-UE update */
 368             break;
 369
 370         default:
 371             /* Error */
 372             return 0;
 373     }
 374
 375     /* Check max UEs/tti counter */
 376     switch (si->direction) {
 377         case DIRECTION_UPLINK:
 378             hs->common_stats.max_ul_ues_in_tti =
 379                 MAX(hs->common_stats.max_ul_ues_in_tti, si->ueInTTI);
 380             break;
 381         case DIRECTION_DOWNLINK:
 382             hs->common_stats.max_dl_ues_in_tti =
 383                 MAX(hs->common_stats.max_dl_ues_in_tti, si->ueInTTI);
 384             break;
 385     }
 386
 387     /* For per-UE data, must create a new row if none already existing */
 388     if (!hs->ep_list) {
 389         /* Allocate new list */
 390         hs->ep_list = alloc_mac_lte_ep(si, pinfo);
 391         /* Make it the first/only entry */
 392         te = hs->ep_list;
 393
 394         /* Update counts of unique ueids & rntis */
 395         update_ueid_rnti_counts(si->rnti, si->ueid, hs);
 396     } else {
 397         /* Look among existing rows for this RNTI */
 398         for (tmp = hs->ep_list;(tmp != NULL); tmp = tmp->next) {
 399             /* Match only by RNTI and UEId together */
 400             if ((tmp->stats.rnti == si->rnti) &&
 401                 (tmp->stats.ueid == si->ueid)){
 402                 te = tmp;
 403                 break;
 404             }
 405         }
 406
 407         /* Not found among existing, so create a new one anyway */
 408         if (te == NULL) {
 409             if ((te = alloc_mac_lte_ep(si, pinfo))) {
 410                 /* Add new item to end of list */
 411                 mac_lte_ep_t *p = hs->ep_list;
 412                 while (p->next) {
 413                     p = p->next;
 414                 }
 415                 p->next = te;
 416                 te->next = NULL;
 417
 418                 /* Update counts of unique ueids & rntis */
 419                 update_ueid_rnti_counts(si->rnti, si->ueid, hs);
 420             }
 421         }
 422     }
 423
 424     /* Really should have a row pointer by now */
 425     if (!te) {
 426         return 0;
 427     }
 428
 429     /* Update entry with details from si */
 430     te->stats.rnti = si->rnti;
 431     te->stats.is_predefined_data = si->isPredefinedData;
 432
 433     /* Uplink */
 434     if (si->direction == DIRECTION_UPLINK) {
 435         if (si->isPHYRetx) {
 436             te->stats.UL_retx_frames++;
 437             return 1;
 438         }
 439
 440         if (si->crcStatusValid && (si->crcStatus != crc_success)) {
 441             te->stats.UL_CRC_errors++;
 442             return 1;
 443         }
 444
 445         /* Update time range */
 446         if (te->stats.UL_frames == 0) {
 447             te->stats.UL_time_start = si->time;
 448         }
 449         te->stats.UL_time_stop = si->time;
 450
 451         te->stats.UL_frames++;
 452
 453         te->stats.UL_raw_bytes += si->raw_length;
 454         te->stats.UL_padding_bytes += si->padding_bytes;
 455
 456         if (si->isPredefinedData) {
 457             te->stats.UL_total_bytes += si->single_number_of_bytes;
 458         }
 459         else {
 460             for (n=0; n < 11; n++) {
 461                 if (si->bytes_for_lcid[n]) {
 462                     te->stats.UL_sdus_for_lcid[n] += si->sdus_for_lcid[n];
 463                 }
 464                 te->stats.UL_bytes_for_lcid[n] += si->bytes_for_lcid[n];
 465                 te->stats.UL_total_bytes += si->bytes_for_lcid[n];
 466             }
 467         }
 468     }
 469
 470     /* Downlink */
 471     else {
 472         if (si->isPHYRetx) {
 473             te->stats.DL_retx_frames++;
 474             return 1;
 475         }
 476
 477         if (si->crcStatusValid && (si->crcStatus != crc_success)) {
 478             switch (si->crcStatus) {
 479                 case crc_fail:
 480                     te->stats.DL_CRC_failures++;
 481                     break;
 482                 case crc_high_code_rate:
 483                     te->stats.DL_CRC_high_code_rate++;
 484                     break;
 485                 case crc_pdsch_lost:
 486                     te->stats.DL_CRC_PDSCH_lost++;
 487                     break;
 488                 default:
 489                     /* Something went wrong! */
 490                     break;
 491             }
 492             return 1;
 493         }
 494
 495         /* Update time range */
 496         if (te->stats.DL_frames == 0) {
 497             te->stats.DL_time_start = si->time;
 498         }
 499         te->stats.DL_time_stop = si->time;
 500
 501         te->stats.DL_frames++;
 502
 503         if (si->isPredefinedData) {
 504             te->stats.DL_total_bytes += si->single_number_of_bytes;
 505         }
 506         else {
 507             for (n=0; n < 11; n++) {
 508                 if (si->bytes_for_lcid[n]) {
 509                     te->stats.DL_sdus_for_lcid[n] += si->sdus_for_lcid[n];
 510                 }
 511                 te->stats.DL_bytes_for_lcid[n] += si->bytes_for_lcid[n];
 512                 te->stats.DL_total_bytes += si->bytes_for_lcid[n];
 513             }
 514         }
 515     }
 516
 517     return 1;
 518 }
 519
 520
 521 /* Draw the UE details table according to the current UE selection */
 522 static void
 523 mac_lte_ue_details(mac_lte_ep_t *mac_stat_ep, mac_lte_stat_t *hs)
 524 {
 525     int n;
 526     gchar buff[32];
 527     guint8 show_dct_errors;
 528
 529     /**********************************/
 530     /* Set data one row at a time     */
 531
 532     /* UL SDUs */
 533     for (n=0; n < PREDEFINED_COLUMN-1; n++) {
 534         g_snprintf(buff, sizeof(buff), "%u",
 535                    (mac_stat_ep != NULL) ? mac_stat_ep->stats.UL_sdus_for_lcid[n] : 0);
 536          gtk_label_set_text(GTK_LABEL(hs->selected_ue_column_entry[n+1][1]), buff);
 537     }
 538
 539     /* Predefined */
 540     if (mac_stat_ep != NULL) {
 541         g_snprintf(buff, sizeof(buff), "%u",
 542                    mac_stat_ep->stats.is_predefined_data ? mac_stat_ep->stats.UL_frames : 0);
 543     }
 544     else {
 545         g_snprintf(buff, sizeof(buff), "%u", 0);
 546     }
 547     gtk_label_set_text(GTK_LABEL(hs->selected_ue_column_entry[PREDEFINED_COLUMN][1]), buff);
 548
 549
 550     /* UL Bytes */
 551     for (n=0; n < PREDEFINED_COLUMN-1; n++) {
 552         g_snprintf(buff, sizeof(buff), "%u",
 553                    (mac_stat_ep != NULL) ? mac_stat_ep->stats.UL_bytes_for_lcid[n] : 0);
 554         gtk_label_set_text(GTK_LABEL(hs->selected_ue_column_entry[n+1][2]), buff);
 555     }
 556
 557     /* Predefined */
 558     if (mac_stat_ep != NULL) {
 559         g_snprintf(buff, sizeof(buff), "%u",
 560                    mac_stat_ep->stats.is_predefined_data ? mac_stat_ep->stats.UL_total_bytes : 0);
 561     }
 562     else {
 563         g_snprintf(buff, sizeof(buff), "%u", 0);
 564     }
 565     gtk_label_set_text(GTK_LABEL(hs->selected_ue_column_entry[PREDEFINED_COLUMN][2]), buff);
 566
 567
 568     /* DL SDUs */
 569     for (n=0; n < PREDEFINED_COLUMN-1; n++) {
 570         g_snprintf(buff, sizeof(buff), "%u",
 571                    (mac_stat_ep != NULL) ? mac_stat_ep->stats.DL_sdus_for_lcid[n] : 0);
 572         gtk_label_set_text(GTK_LABEL(hs->selected_ue_column_entry[n+1][3]), buff);
 573     }
 574     /* Predefined */
 575     if (mac_stat_ep != NULL) {
 576         g_snprintf(buff, sizeof(buff), "%u",
 577                    mac_stat_ep->stats.is_predefined_data ? mac_stat_ep->stats.DL_frames : 0);
 578     }
 579     else {
 580         g_snprintf(buff, sizeof(buff), "%u", 0);
 581     }
 582     gtk_label_set_text(GTK_LABEL(hs->selected_ue_column_entry[PREDEFINED_COLUMN][3]), buff);
 583
 584
 585     /* DL Bytes */
 586     for (n=0; n < PREDEFINED_COLUMN-1; n++) {
 587         g_snprintf(buff, sizeof(buff), "%u",
 588                    (mac_stat_ep != NULL) ? mac_stat_ep->stats.DL_bytes_for_lcid[n] : 0);
 589         gtk_label_set_text(GTK_LABEL(hs->selected_ue_column_entry[n+1][4]), buff);
 590     }
 591     /* Predefined */
 592     if (mac_stat_ep != NULL) {
 593         g_snprintf(buff, sizeof(buff), "%u",
 594                    mac_stat_ep->stats.is_predefined_data ? mac_stat_ep->stats.DL_total_bytes : 0);
 595     }
 596     else {
 597         g_snprintf(buff, sizeof(buff), "%u", 0);
 598     }
 599     gtk_label_set_text(GTK_LABEL(hs->selected_ue_column_entry[PREDEFINED_COLUMN][4]), buff);
 600
 601     /* Remember selected UE */
 602     if (mac_stat_ep) {
 603         hs->selected_rnti = mac_stat_ep->stats.rnti;
 604         hs->selected_ueid = mac_stat_ep->stats.ueid;
 605     }
 606
 607     /* Enable/disable filter controls */
 608     gtk_widget_set_sensitive(hs->ul_filter_bt, mac_stat_ep != NULL);
 609     gtk_widget_set_sensitive(hs->dl_filter_bt, mac_stat_ep != NULL);
 610     gtk_widget_set_sensitive(hs->uldl_filter_bt, mac_stat_ep != NULL);
 611     gtk_widget_set_sensitive(hs->show_dct_errors_cb, mac_stat_ep != NULL);
 612
 613     /* Enabling substring control only if errors enabled */
 614     show_dct_errors = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hs->show_dct_errors_cb));
 615     gtk_widget_set_sensitive(hs->dct_error_substring_lb, show_dct_errors && (mac_stat_ep != NULL));
 616     gtk_widget_set_sensitive(hs->dct_error_substring_te, show_dct_errors && (mac_stat_ep != NULL));
 617 }
 618
 619
 620 /* Calculate and return a bandwidth figure, in Mbs */
 621 static float calculate_bw(nstime_t *start_time, nstime_t *stop_time, guint32 bytes)
 622 {
 623     if (memcmp(start_time, stop_time, sizeof(nstime_t)) != 0) {
 624         float elapsed_ms = (((float)stop_time->secs - (float)start_time->secs) * 1000) +
 625                            (((float)stop_time->nsecs - (float)start_time->nsecs) / 1000000);
 626         return ((bytes * 8) / elapsed_ms) / 1000;
 627     }
 628     else {
 629         return 0.0;
 630     }
 631 }
 632
 633
 634 /* (Re)draw the whole dialog window */
 635 static void
 636 mac_lte_stat_draw(void *phs)
 637 {
 638     gchar   buff[32];
 639     guint16 number_of_ues = 0;
 640     gchar title[256];
 641
 642     /* Look up the statistics window */
 643     mac_lte_stat_t *hs = (mac_lte_stat_t *)phs;
 644     mac_lte_ep_t* list = hs->ep_list, *tmp = 0;
 645
 646     GtkListStore *ues_store;
 647     GtkTreeSelection *sel;
 648     GtkTreeModel *model;
 649     GtkTreeIter iter;
 650
 651     /* System data */
 652     g_snprintf(buff, sizeof(buff), "Max UL UEs/TTI: %u", hs->common_stats.max_ul_ues_in_tti);
 653     gtk_label_set_text(GTK_LABEL(hs->ul_max_ues_per_tti), buff);
 654     g_snprintf(buff, sizeof(buff), "Max DL UEs/TTI: %u", hs->common_stats.max_dl_ues_in_tti);
 655     gtk_label_set_text(GTK_LABEL(hs->dl_max_ues_per_tti), buff);
 656
 657     /* Common channel data */
 658     g_snprintf(buff, sizeof(buff), "BCH Frames: %u", hs->common_stats.bch_frames);
 659     gtk_label_set_text(GTK_LABEL(hs->common_bch_frames), buff);
 660     g_snprintf(buff, sizeof(buff), "BCH Bytes: %u", hs->common_stats.bch_bytes);
 661     gtk_label_set_text(GTK_LABEL(hs->common_bch_bytes), buff);
 662     g_snprintf(buff, sizeof(buff), "PCH Frames: %u", hs->common_stats.pch_frames);
 663     gtk_label_set_text(GTK_LABEL(hs->common_pch_frames), buff);
 664     g_snprintf(buff, sizeof(buff), "PCH Bytes: %u", hs->common_stats.pch_bytes);
 665     gtk_label_set_text(GTK_LABEL(hs->common_pch_bytes), buff);
 666     g_snprintf(buff, sizeof(buff), "RAR Frames: %u", hs->common_stats.rar_frames);
 667     gtk_label_set_text(GTK_LABEL(hs->common_rar_frames), buff);
 668     g_snprintf(buff, sizeof(buff), "RAR Entries: %u", hs->common_stats.rar_entries);
 669     gtk_label_set_text(GTK_LABEL(hs->common_rar_entries), buff);
 670
 671
 672     /* Per-UE table entries */
 673     ues_store = GTK_LIST_STORE(gtk_tree_view_get_model(hs->ue_table));
 674
 675     /* Set title that shows how many UEs currently in table */
 676     for (tmp = list; (tmp!=NULL); tmp=tmp->next, number_of_ues++);
 677     g_snprintf(title, sizeof(title), "UL/DL-SCH data (%u entries - %u unique RNTIs, %u unique UEIds)",
 678                number_of_ues, hs->number_of_rntis, hs->number_of_ueids);
 679     gtk_frame_set_label(GTK_FRAME(hs->mac_lte_stat_ues_lb), title);
 680
 681     /* Update title to include number of UEs and frames */
 682     g_snprintf(title, sizeof(title), "Wireshark: LTE MAC Traffic Statistics: %s (%u UEs, %u frames) (filter=\"%s\")",
 683                cf_get_display_name(&cfile),
 684                number_of_ues,
 685                hs->common_stats.all_frames,
 686                hs->filter ? hs->filter : "none");
 687     gtk_window_set_title(GTK_WINDOW(hs->mac_lte_stat_dlg_w), title);
 688
 689
 690     for (tmp = list; tmp; tmp=tmp->next) {
 691
 692         /* Calculate bandwidth */
 693         float UL_bw = calculate_bw(&tmp->stats.UL_time_start,
 694                                    &tmp->stats.UL_time_stop,
 695                                    tmp->stats.UL_total_bytes);
 696         float DL_bw = calculate_bw(&tmp->stats.DL_time_start,
 697                                    &tmp->stats.DL_time_stop,
 698                                    tmp->stats.DL_total_bytes);
 699
 700         if (tmp->iter_valid != TRUE) {
 701             /* Add to list control if not drawn this UE before */
 702             gtk_list_store_append(ues_store, &tmp->iter);
 703             tmp->iter_valid = TRUE;
 704         }
 705
 706         /* Set each column for this row */
 707         gtk_list_store_set(ues_store, &tmp->iter,
 708                            RNTI_COLUMN, tmp->stats.rnti,
 709                            RNTI_TYPE_COLUMN,
 710                                (tmp->stats.rnti_type == C_RNTI) ? "C-RNTI" : "SPS-RNTI",
 711                            UEID_COLUMN, tmp->stats.ueid,
 712                            UL_FRAMES_COLUMN, tmp->stats.UL_frames,
 713                            UL_BYTES_COLUMN, tmp->stats.UL_total_bytes,
 714                            UL_BW_COLUMN, UL_bw,
 715                            UL_PADDING_PERCENT_COLUMN,
 716                                 tmp->stats.UL_total_bytes ?
 717                                     (((float)tmp->stats.UL_padding_bytes / (float)tmp->stats.UL_raw_bytes) * 100.0) :
 718                                     0.0,
 719                            UL_RETX_FRAMES_COLUMN, tmp->stats.UL_retx_frames,
 720                            DL_FRAMES_COLUMN, tmp->stats.DL_frames,
 721                            DL_BYTES_COLUMN, tmp->stats.DL_total_bytes,
 722                            DL_BW_COLUMN, DL_bw,
 723                            DL_CRC_FAILED_COLUMN, tmp->stats.DL_CRC_failures,
 724                            DL_CRC_HIGH_CODE_RATE_COLUMN, tmp->stats.DL_CRC_high_code_rate,
 725                            DL_CRC_PDSCH_LOST_COLUMN, tmp->stats.DL_CRC_PDSCH_lost,
 726                            DL_RETX_FRAMES_COLUMN, tmp->stats.DL_retx_frames,
 727                            TABLE_COLUMN, tmp,
 728                            -1);
 729     }
 730
 731     /* Reselect UE? */
 732     if (hs->selected_rnti != 0) {
 733         GtkTreeIter *ue_iter = NULL;
 734         mac_lte_ep_t *ep = hs->ep_list;
 735         while (ep != NULL) {
 736             if ((ep->stats.ueid == hs->selected_ueid) &&
 737                 (ep->stats.rnti == hs->selected_rnti)) {
 738                 ue_iter = &ep->iter;
 739                 break;
 740             }
 741             ep = ep->next;
 742         }
 743         if (ue_iter != NULL) {
 744             /* Make selection */
 745             gtk_tree_selection_select_iter(gtk_tree_view_get_selection(hs->ue_table),
 746                                            ue_iter);
 747         }
 748     }
 749
 750     /* If there is a UE selected, update its counters in details window */
 751     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(hs->ue_table));
 752     if (gtk_tree_selection_get_selected(sel, &model, &iter)) {
 753         mac_lte_ep_t *ep;
 754
 755         gtk_tree_model_get(model, &iter, TABLE_COLUMN, &ep, -1);
 756         mac_lte_ue_details(ep, hs);
 757     }
 758 }
 759
 760
 761 /* Compose and set appropriate display filter */
 762 typedef enum Direction_t {UL_Only, DL_Only, UL_and_DL} Direction_t;
 763 static void set_filter_expression(guint16  ueid,
 764                                   guint16  rnti,
 765                                   Direction_t direction,
 766                                   gint     showDCTErrors,
 767                                   const gchar    *DCTErrorSubstring,
 768                                   mac_lte_stat_t *hs)
 769 {
 770     #define MAX_FILTER_LEN 256
 771     static char buffer[MAX_FILTER_LEN];
 772     int offset = 0;
 773
 774     /* Create the filter expression */
 775
 776     /* Errors */
 777     if (showDCTErrors) {
 778         if (strlen(DCTErrorSubstring) > 0) {
 779             offset += g_snprintf(buffer+offset, MAX_FILTER_LEN-offset,
 780                                  "(dct2000.error-comment and (dct2000.comment contains \"%s\")) or (",
 781                                  DCTErrorSubstring);
 782         }
 783         else {
 784             offset += g_snprintf(buffer+offset, MAX_FILTER_LEN-offset,
 785                                  "dct2000.error-comment or (");
 786         }
 787     }
 788
 789     /* Filter expression */
 790     if (hs->filter) {
 791         offset += g_snprintf(buffer+offset, MAX_FILTER_LEN-offset, "%s and ", hs->filter);
 792     }
 793
 794     /* Direction */
 795     switch (direction) {
 796         case UL_Only:
 797             offset += g_snprintf(buffer+offset, MAX_FILTER_LEN-offset, "(mac-lte.direction == 0) and ");
 798             break;
 799         case DL_Only:
 800             offset += g_snprintf(buffer+offset, MAX_FILTER_LEN-offset, "(mac-lte.direction == 1) and ");
 801             break;
 802         default:
 803             break;
 804     }
 805
 806     /* Selected UE */
 807     offset += g_snprintf(buffer+offset, MAX_FILTER_LEN-offset,
 808                          "mac-lte.rnti == %u and mac-lte.ueid == %u",
 809                          rnti, ueid);
 810
 811     /* Close parenthesis */
 812     if (showDCTErrors) {
 813             offset += g_snprintf(buffer+offset, MAX_FILTER_LEN-offset,
 814                                  ")");
 815     }
 816
 817     /* Set its value to our new string */
 818     gtk_entry_set_text(GTK_ENTRY(main_display_filter_widget), buffer);
 819
 820     /* Run the filter */
 821     main_filter_packets(&cfile, buffer, TRUE);
 822 }
 823
 824 /* Respond to UL filter button being clicked by building and using filter */
 825 static void ul_filter_clicked(GtkWindow *win _U_, mac_lte_stat_t* hs)
 826 {
 827     GtkTreeSelection *sel;
 828     GtkTreeModel *model;
 829     GtkTreeIter iter;
 830
 831     /* If there is a UE selected, update its counters in details window */
 832     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(hs->ue_table));
 833     if (gtk_tree_selection_get_selected(sel, &model, &iter)) {
 834         mac_lte_ep_t *ep;
 835
 836         /* Get the UE details */
 837         gtk_tree_model_get(model, &iter, TABLE_COLUMN, &ep, -1);
 838
 839         set_filter_expression(ep->stats.ueid, ep->stats.rnti, UL_Only,
 840                               gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hs->show_dct_errors_cb)),
 841                               gtk_entry_get_text(GTK_ENTRY(hs->dct_error_substring_te)),
 842                               hs);
 843     }
 844 }
 845
 846 /* Respond to DL filter button being clicked by building and using filter */
 847 static void dl_filter_clicked(GtkWindow *win _U_, mac_lte_stat_t* hs)
 848 {
 849     GtkTreeSelection *sel;
 850     GtkTreeModel *model;
 851     GtkTreeIter iter;
 852
 853     /* If there is a UE selected, update its counters in details window */
 854     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(hs->ue_table));
 855     if (gtk_tree_selection_get_selected(sel, &model, &iter)) {
 856         mac_lte_ep_t *ep;
 857
 858         /* Get the UE details */
 859         gtk_tree_model_get(model, &iter, TABLE_COLUMN, &ep, -1);
 860
 861         set_filter_expression(ep->stats.ueid, ep->stats.rnti, DL_Only,
 862                               gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hs->show_dct_errors_cb)),
 863                               gtk_entry_get_text(GTK_ENTRY(hs->dct_error_substring_te)),
 864                               hs);
 865     }
 866
 867 }
 868
 869 /* Respond to UL/DL filter button being clicked by building and using filter */
 870 static void uldl_filter_clicked(GtkWindow *win _U_, mac_lte_stat_t* hs)
 871 {
 872     GtkTreeSelection *sel;
 873     GtkTreeModel *model;
 874     GtkTreeIter iter;
 875
 876     /* If there is a UE selected, update its counters in details window */
 877     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(hs->ue_table));
 878     if (gtk_tree_selection_get_selected(sel, &model, &iter)) {
 879         mac_lte_ep_t *ep;
 880
 881         /* Get the UE details */
 882         gtk_tree_model_get(model, &iter, TABLE_COLUMN, &ep, -1);
 883
 884         set_filter_expression(ep->stats.ueid, ep->stats.rnti, UL_and_DL,
 885                               gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hs->show_dct_errors_cb)),
 886                               gtk_entry_get_text(GTK_ENTRY(hs->dct_error_substring_te)),
 887                               hs);
 888     }
 889
 890 }
 891
 892
 893 /* What to do when a list item is selected/unselected */
 894 static void mac_lte_select_cb(GtkTreeSelection *sel, gpointer data)
 895 {
 896     mac_lte_stat_t *hs = (mac_lte_stat_t *)data;
 897     mac_lte_ep_t   *ep;
 898     GtkTreeModel   *model;
 899     GtkTreeIter    iter;
 900
 901     if (gtk_tree_selection_get_selected(sel, &model, &iter)) {
 902         /* Show details of selected UE */
 903         gtk_tree_model_get(model, &iter, TABLE_COLUMN, &ep, -1);
 904         mac_lte_ue_details(ep, hs);
 905     }
 906     else {
 907         mac_lte_ue_details(NULL, hs);
 908     }
 909 }
 910
 911 /* When DCT errors check-box is toggled, enable substring controls accordingly */
 912 static void mac_lte_dct_errors_cb(GtkTreeSelection *sel _U_, gpointer data)
 913 {
 914     mac_lte_stat_t *hs = (mac_lte_stat_t*)data;
 915     guint8 show_dct_errors = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hs->show_dct_errors_cb));
 916
 917     gtk_widget_set_sensitive(hs->dct_error_substring_lb, show_dct_errors);
 918     gtk_widget_set_sensitive(hs->dct_error_substring_te, show_dct_errors);
 919 }
 920
 921
 922 /* Destroy the stats window */
 923 static void win_destroy_cb(GtkWindow *win _U_, gpointer data)
 924 {
 925     mac_lte_stat_t *hs = (mac_lte_stat_t *)data;
 926
 927     protect_thread_critical_region();
 928     remove_tap_listener(hs);
 929     unprotect_thread_critical_region();
 930
 931     if (hs->mac_lte_stat_dlg_w != NULL) {
 932         window_destroy(hs->mac_lte_stat_dlg_w);
 933         hs->mac_lte_stat_dlg_w = NULL;
 934     }
 935     mac_lte_stat_reset(hs);
 936     g_free(hs->filter);
 937     g_free(hs);
 938 }
 939
 940
 941 /* Create a new MAC LTE stats dialog */
 942 static void gtk_mac_lte_stat_init(const char *optarg, void *userdata _U_)
 943 {
 944     mac_lte_stat_t    *hs;
 945     const char    *filter = NULL;
 946     GString       *error_string;
 947     GtkWidget     *ues_scrolled_window;
 948     GtkWidget     *bbox;
 949     GtkWidget     *top_level_vbox;
 950
 951     GtkWidget     *system_row_hbox;
 952     GtkWidget     *common_row_hbox;
 953     GtkWidget     *ues_vb;
 954     GtkWidget     *selected_ue_hb;
 955
 956     GtkWidget     *mac_lte_stat_system_lb;
 957     GtkWidget     *mac_lte_stat_common_channel_lb;
 958     GtkWidget     *mac_lte_stat_selected_ue_lb;
 959     GtkWidget     *selected_ue_vbox[NUM_CHANNEL_COLUMNS];
 960     GtkWidget     *selected_ue_column_titles[5];
 961
 962     GtkWidget     *mac_lte_stat_filters_lb;
 963     GtkWidget     *filter_buttons_hb;
 964
 965     GtkWidget     *close_bt;
 966     GtkWidget     *help_bt;
 967
 968     GtkTooltips   *tooltips = gtk_tooltips_new();
 969     GtkListStore  *store;
 970
 971     GtkTreeView       *tree_view;
 972     GtkCellRenderer   *renderer;
 973     GtkTreeViewColumn *column;
 974     GtkTreeSelection  *sel;
 975     gchar title[256];
 976     gint i, n;
 977
 978     /* Check for a filter string */
 979     if (strncmp(optarg, "mac-lte,stat,", 13) == 0) {
 980         /* Skip those characters from filter to display */
 981         filter = optarg + 13;
 982     }
 983     else {
 984         /* No filter */
 985         filter = NULL;
 986     }
 987
 988
 989     /* Create dialog */
 990     hs = g_malloc(sizeof(mac_lte_stat_t));
 991     hs->ep_list = NULL;
 992
 993     /* Copy filter (so can be used for window title at reset) */
 994     if (filter) {
 995         hs->filter = g_strdup(filter);
 996     }
 997     else {
 998         hs->filter = NULL;
 999     }
1000
1001     /* Set title */
1002     g_snprintf(title, sizeof(title), "Wireshark: LTE MAC Statistics: %s",
1003                cf_get_display_name(&cfile));
1004
1005     /* Create top-level window */
1006     hs->mac_lte_stat_dlg_w = window_new_with_geom(GTK_WINDOW_TOPLEVEL, title, "LTE MAC Statistics");
1007
1008     /* Window size */
1009     gtk_window_set_default_size(GTK_WINDOW(hs->mac_lte_stat_dlg_w), 750, 300);
1010
1011     /* Will stack widgets vertically inside dlg */
1012     top_level_vbox = gtk_vbox_new(FALSE, 3);       /* FALSE = not homogeneous */
1013     gtk_container_add(GTK_CONTAINER(hs->mac_lte_stat_dlg_w), top_level_vbox);
1014
1015     gtk_container_set_border_width(GTK_CONTAINER(top_level_vbox), 6);
1016     gtk_widget_show(top_level_vbox);
1017
1018
1019     /**********************************************/
1020     /* System data                                */
1021     /**********************************************/
1022     mac_lte_stat_system_lb = gtk_frame_new("System Data");
1023
1024     /* Add max UEs/TTI counts in one row */
1025     system_row_hbox = gtk_hbox_new(FALSE, 0);
1026     gtk_container_add(GTK_CONTAINER(mac_lte_stat_system_lb), system_row_hbox);
1027     gtk_container_set_border_width(GTK_CONTAINER(system_row_hbox), 5);
1028
1029     gtk_box_pack_start(GTK_BOX(top_level_vbox), mac_lte_stat_system_lb, FALSE, FALSE, 0);
1030
1031     /* Create labels (that will hold label and counter value) */
1032     hs->ul_max_ues_per_tti = gtk_label_new("Max UL UEs/TTI:");
1033     gtk_misc_set_alignment(GTK_MISC(hs->ul_max_ues_per_tti), 0.0f, .5f);
1034     gtk_container_add(GTK_CONTAINER(system_row_hbox), hs->ul_max_ues_per_tti);
1035     gtk_widget_show(hs->ul_max_ues_per_tti);
1036
1037     hs->dl_max_ues_per_tti = gtk_label_new("Max DL UEs/TTI:");
1038     gtk_misc_set_alignment(GTK_MISC(hs->dl_max_ues_per_tti), 0.0f, .5f);
1039     gtk_container_add(GTK_CONTAINER(system_row_hbox), hs->dl_max_ues_per_tti);
1040     gtk_widget_show(hs->dl_max_ues_per_tti);
1041
1042
1043     /**********************************************/
1044     /* Common Channel data                        */
1045     /**********************************************/
1046     mac_lte_stat_common_channel_lb = gtk_frame_new("Common Channel Data");
1047
1048     /* Will add BCH and PCH counters into one row */
1049     common_row_hbox = gtk_hbox_new(FALSE, 0);
1050     gtk_container_add(GTK_CONTAINER(mac_lte_stat_common_channel_lb), common_row_hbox);
1051     gtk_container_set_border_width(GTK_CONTAINER(common_row_hbox), 5);
1052
1053     gtk_box_pack_start(GTK_BOX(top_level_vbox), mac_lte_stat_common_channel_lb, FALSE, FALSE, 0);
1054
1055     /* Create labels (that will hold label and counter value) */
1056     hs->common_bch_frames = gtk_label_new("BCH Frames:");
1057     gtk_misc_set_alignment(GTK_MISC(hs->common_bch_frames), 0.0f, .5f);
1058     gtk_container_add(GTK_CONTAINER(common_row_hbox), hs->common_bch_frames);
1059     gtk_widget_show(hs->common_bch_frames);
1060
1061     hs->common_bch_bytes = gtk_label_new("BCH Bytes:");
1062     gtk_misc_set_alignment(GTK_MISC(hs->common_bch_bytes), 0.0f, .5f);
1063     gtk_container_add(GTK_CONTAINER(common_row_hbox), hs->common_bch_bytes);
1064     gtk_widget_show(hs->common_bch_bytes);
1065
1066     hs->common_pch_frames = gtk_label_new("PCH Frames:");
1067     gtk_misc_set_alignment(GTK_MISC(hs->common_pch_frames), 0.0f, .5f);
1068     gtk_container_add(GTK_CONTAINER(common_row_hbox), hs->common_pch_frames);
1069     gtk_widget_show(hs->common_pch_frames);
1070
1071     hs->common_pch_bytes = gtk_label_new("PCH Bytes:");
1072     gtk_misc_set_alignment(GTK_MISC(hs->common_pch_bytes), 0.0f, .5f);
1073     gtk_container_add(GTK_CONTAINER(common_row_hbox), hs->common_pch_bytes);
1074     gtk_widget_show(hs->common_pch_bytes);
1075
1076     hs->common_rar_frames = gtk_label_new("RAR Frames:");
1077     gtk_misc_set_alignment(GTK_MISC(hs->common_rar_frames), 0.0f, .5f);
1078     gtk_container_add(GTK_CONTAINER(common_row_hbox), hs->common_rar_frames);
1079     gtk_widget_show(hs->common_rar_frames);
1080
1081     hs->common_rar_entries = gtk_label_new("RAR Entries:");
1082     gtk_misc_set_alignment(GTK_MISC(hs->common_rar_entries), 0.0f, .5f);
1083     gtk_container_add(GTK_CONTAINER(common_row_hbox), hs->common_rar_entries);
1084     gtk_widget_show(hs->common_rar_entries);
1085
1086     /**********************************************/
1087     /* UL/DL-SCH data                             */
1088     /**********************************************/
1089
1090     hs->mac_lte_stat_ues_lb = gtk_frame_new("UL/DL-SCH Data (0 UEs)");
1091     ues_vb = gtk_vbox_new(FALSE, 0);
1092     gtk_container_add(GTK_CONTAINER(hs->mac_lte_stat_ues_lb), ues_vb);
1093     gtk_container_set_border_width(GTK_CONTAINER(ues_vb), 5);
1094
1095     ues_scrolled_window = scrolled_window_new(NULL, NULL);
1096     gtk_box_pack_start(GTK_BOX(ues_vb), ues_scrolled_window, TRUE, TRUE, 0);
1097     gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(ues_scrolled_window),
1098                                         GTK_SHADOW_IN);
1099
1100     /* Create the table of UE data */
1101     store = gtk_list_store_new(NUM_UE_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_INT,
1102                                G_TYPE_INT, G_TYPE_INT, G_TYPE_FLOAT, G_TYPE_FLOAT, G_TYPE_INT, /* UL */
1103                                G_TYPE_INT, G_TYPE_INT, G_TYPE_FLOAT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT,  G_TYPE_INT, /* DL */
1104                                G_TYPE_POINTER);
1105     hs->ue_table = GTK_TREE_VIEW(tree_view_new(GTK_TREE_MODEL(store)));
1106     gtk_container_add(GTK_CONTAINER (ues_scrolled_window), GTK_WIDGET(hs->ue_table));
1107     g_object_unref(G_OBJECT(store));
1108
1109     tree_view = hs->ue_table;
1110     gtk_tree_view_set_headers_visible(tree_view, TRUE);
1111     gtk_tree_view_set_headers_clickable(tree_view, TRUE);
1112
1113     /* Create the titles for each column of the per-UE table */
1114     for (i = 0; i < TABLE_COLUMN; i++) {
1115         renderer = gtk_cell_renderer_text_new();
1116         column = gtk_tree_view_column_new_with_attributes(ue_titles[i], renderer,
1117                                                           "text", i, NULL);
1118         gtk_tree_view_column_set_sort_column_id(column, i);
1119
1120         if (i == 0) {
1121             /* Expand first column (RNTI, which is Key) */
1122             gtk_tree_view_column_set_expand(column, TRUE);
1123         } else {
1124             /* For other columns, set all of the free space to be on the left */
1125             g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
1126         }
1127         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
1128         gtk_tree_view_column_set_resizable(column, TRUE);
1129         gtk_tree_view_append_column(tree_view, column);
1130     }
1131
1132     /* Set callback function for selecting a row in the UE table */
1133     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(hs->ue_table));
1134     gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
1135     g_signal_connect(sel, "changed", G_CALLBACK(mac_lte_select_cb), hs);
1136
1137     gtk_box_pack_start(GTK_BOX(top_level_vbox), hs->mac_lte_stat_ues_lb, TRUE, TRUE, 0);
1138
1139
1140     /**********************************************/
1141     /* Details of selected UE                     */
1142     /**********************************************/
1143
1144     mac_lte_stat_selected_ue_lb = gtk_frame_new("Selected UE details");
1145
1146     selected_ue_hb = gtk_hbox_new(FALSE, 6);
1147     gtk_container_add(GTK_CONTAINER(mac_lte_stat_selected_ue_lb), selected_ue_hb);
1148     gtk_container_set_border_width(GTK_CONTAINER(selected_ue_hb), 5);
1149
1150     /********************************/
1151     /* First (row titles) column    */
1152     selected_ue_vbox[0] = gtk_vbox_new(FALSE, 0);
1153     gtk_container_add(GTK_CONTAINER(selected_ue_hb), selected_ue_vbox[0]);
1154
1155     selected_ue_column_titles[0] = gtk_label_new("");
1156     gtk_misc_set_alignment(GTK_MISC(selected_ue_column_titles[0]), 0.0f, 0.0f);
1157     gtk_container_add(GTK_CONTAINER(selected_ue_vbox[0]), selected_ue_column_titles[0]);
1158
1159     for (n=1; n < 5; n++) {
1160         selected_ue_column_titles[n] = gtk_label_new(selected_ue_row_names[n-1]);
1161         gtk_misc_set_alignment(GTK_MISC(selected_ue_column_titles[n]), 0.0f, 0.0f);
1162         gtk_container_add(GTK_CONTAINER(selected_ue_vbox[0]), selected_ue_column_titles[n]);
1163         gtk_widget_show(selected_ue_column_titles[n]);
1164     }
1165
1166
1167     /*************************/
1168     /* Other columns         */
1169     for (i=CCCH_COLUMN; i < NUM_CHANNEL_COLUMNS; i++) {
1170         selected_ue_vbox[i] = gtk_vbox_new(FALSE, 0);
1171         gtk_container_add(GTK_CONTAINER(selected_ue_hb), selected_ue_vbox[i]);
1172
1173         /* Channel title */
1174         hs->selected_ue_column_entry[i][0] = gtk_label_new(channel_titles[i-1]);
1175         gtk_misc_set_alignment(GTK_MISC(hs->selected_ue_column_entry[i][0]), 0.5f, 0.0f);
1176         gtk_container_add(GTK_CONTAINER(selected_ue_vbox[i]), hs->selected_ue_column_entry[i][0]);
1177
1178         /* Counts for this channel */
1179         for (n=1; n < 5; n++) {
1180             hs->selected_ue_column_entry[i][n] = gtk_label_new("0");
1181             gtk_misc_set_alignment(GTK_MISC(hs->selected_ue_column_entry[i][n]), 1.0f, 0.0f);
1182             gtk_container_add(GTK_CONTAINER(selected_ue_vbox[i]), hs->selected_ue_column_entry[i][n]);
1183             gtk_widget_show(hs->selected_ue_column_entry[i][n]);
1184         }
1185     }
1186
1187     gtk_box_pack_start(GTK_BOX(top_level_vbox), mac_lte_stat_selected_ue_lb, FALSE, FALSE, 0);
1188
1189
1190     /**************************************/
1191     /* Filter on RNTI/UEId                */
1192     /**************************************/
1193     mac_lte_stat_filters_lb = gtk_frame_new("Filter on UE");
1194
1195     /* Horizontal row of filter controls */
1196     filter_buttons_hb = gtk_hbox_new(FALSE, 6);
1197     gtk_container_add(GTK_CONTAINER(mac_lte_stat_filters_lb), filter_buttons_hb);
1198     gtk_container_set_border_width(GTK_CONTAINER(filter_buttons_hb), 2);
1199
1200     /* Add filters box to top-level window */
1201     gtk_box_pack_start(GTK_BOX(top_level_vbox), mac_lte_stat_filters_lb, FALSE, FALSE, 0);
1202
1203     /* Filter buttons */
1204
1205     /* UL only */
1206     hs->ul_filter_bt = gtk_button_new_with_label("Set UL display filter on selected this RNTI / UEId");
1207     gtk_box_pack_start(GTK_BOX(filter_buttons_hb), hs->ul_filter_bt, FALSE, FALSE, 0);
1208     g_signal_connect(hs->ul_filter_bt, "clicked", G_CALLBACK(ul_filter_clicked), hs);
1209     gtk_widget_set_sensitive(hs->ul_filter_bt, FALSE);
1210     gtk_widget_show(hs->ul_filter_bt);
1211     gtk_tooltips_set_tip(tooltips, hs->ul_filter_bt,
1212                          "Generate and set a filter showing only UL frames with selected RNTI and UEId",
1213                          NULL);
1214
1215     /* DL only */
1216     hs->dl_filter_bt = gtk_button_new_with_label("Set DL display filter on selected this RNTI / UEId");
1217     gtk_box_pack_start(GTK_BOX(filter_buttons_hb), hs->dl_filter_bt, FALSE, FALSE, 0);
1218     g_signal_connect(hs->dl_filter_bt, "clicked", G_CALLBACK(dl_filter_clicked), hs);
1219     gtk_widget_set_sensitive(hs->dl_filter_bt, FALSE);
1220     gtk_widget_show(hs->dl_filter_bt);
1221     gtk_tooltips_set_tip(tooltips, hs->dl_filter_bt,
1222                          "Generate and set a filter showing only DL frames with selected RNTI and UEId",
1223                          NULL);
1224
1225     /* UL and DL */
1226     hs->uldl_filter_bt = gtk_button_new_with_label("Set UL / DL display filter on selected this RNTI / UEId");
1227     gtk_box_pack_start(GTK_BOX(filter_buttons_hb), hs->uldl_filter_bt, FALSE, FALSE, 0);
1228     g_signal_connect(hs->uldl_filter_bt, "clicked", G_CALLBACK(uldl_filter_clicked), hs);
1229     gtk_widget_set_sensitive(hs->uldl_filter_bt, FALSE);
1230     gtk_widget_show(hs->uldl_filter_bt);
1231     gtk_tooltips_set_tip(tooltips, hs->uldl_filter_bt,
1232                          "Generate and set a filter showing only frames with selected RNTI and UEId",
1233                          NULL);
1234
1235
1236     /* Allow DCT errors to be shown... */
1237     hs->show_dct_errors_cb = gtk_check_button_new_with_mnemonic("Show DCT2000 error strings");
1238     gtk_container_add(GTK_CONTAINER(filter_buttons_hb), hs->show_dct_errors_cb);
1239     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hs->show_dct_errors_cb), FALSE);
1240     g_signal_connect(hs->show_dct_errors_cb, "toggled", G_CALLBACK(mac_lte_dct_errors_cb), hs);
1241     gtk_tooltips_set_tip(tooltips, hs->show_dct_errors_cb, "When checked, generated filters will "
1242                          "include DCT2000 error strings", NULL);
1243     /* Initially disabled */
1244     gtk_widget_set_sensitive(hs->show_dct_errors_cb, FALSE);
1245
1246     /* ... optionally limited by a substring */
1247     hs->dct_error_substring_lb = gtk_label_new("...containing");
1248     gtk_box_pack_start(GTK_BOX(filter_buttons_hb), hs->dct_error_substring_lb, FALSE, FALSE, 0);
1249     gtk_widget_show(hs->dct_error_substring_lb);
1250     gtk_widget_set_sensitive(hs->dct_error_substring_lb, FALSE);
1251
1252     hs->dct_error_substring_te = gtk_entry_new();
1253     gtk_box_pack_start(GTK_BOX(filter_buttons_hb), hs->dct_error_substring_te, FALSE, FALSE, 0);
1254     gtk_widget_show(hs->dct_error_substring_te);
1255     gtk_widget_set_sensitive(hs->dct_error_substring_te, FALSE);
1256     gtk_tooltips_set_tip(tooltips, hs->dct_error_substring_te,
1257                          "If given, only match error strings containing this substring", NULL);
1258
1259
1260     /**********************************************/
1261     /* Register the tap listener                  */
1262     /**********************************************/
1263
1264     error_string = register_tap_listener("mac-lte", hs,
1265                                          filter, 0,
1266                                          mac_lte_stat_reset,
1267                                          mac_lte_stat_packet,
1268                                          mac_lte_stat_draw);
1269     if (error_string) {
1270         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
1271         g_string_free(error_string, TRUE);
1272         g_free(hs);
1273         return;
1274     }
1275
1276
1277     /************************************/
1278     /* Button row.                      */
1279     /************************************/
1280
1281     bbox = dlg_button_row_new (GTK_STOCK_CLOSE, GTK_STOCK_HELP, NULL);
1282     gtk_box_pack_end (GTK_BOX(top_level_vbox), bbox, FALSE, FALSE, 0);
1283
1284     /* Add the close button */
1285     close_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLOSE);
1286     window_set_cancel_button(hs->mac_lte_stat_dlg_w, close_bt, window_cancel_button_cb);
1287
1288     help_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP);
1289     g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb), (gpointer)HELP_STATS_LTE_MAC_TRAFFIC_DIALOG);
1290
1291     /* Set callbacks */
1292     g_signal_connect(hs->mac_lte_stat_dlg_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
1293     g_signal_connect(hs->mac_lte_stat_dlg_w, "destroy", G_CALLBACK(win_destroy_cb), hs);
1294
1295     /* Show the window */
1296     gtk_widget_show_all(hs->mac_lte_stat_dlg_w);
1297     window_present(hs->mac_lte_stat_dlg_w);
1298
1299     /* Retap */
1300     cf_retap_packets(&cfile);
1301     gdk_window_raise(hs->mac_lte_stat_dlg_w->window);
1302 }
1303
1304
1305 static tap_param mac_lte_stat_params[] = {
1306     { PARAM_FILTER, "Filter", NULL }
1307 };
1308
1309 static tap_param_dlg mac_lte_stat_dlg = {
1310     "LTE MAC Stats",
1311     "mac-lte,stat",
1312     gtk_mac_lte_stat_init,
1313     -1,
1314     G_N_ELEMENTS(mac_lte_stat_params),
1315     mac_lte_stat_params
1316 };
1317
1318
1319 /* Register this tap listener (need void on own so line register function found) */
1320 void
1321 register_tap_listener_mac_lte_stat(void)
1322 {
1323     register_dfilter_stat(&mac_lte_stat_dlg, "_LTE/_MAC", REGISTER_STAT_GROUP_TELEPHONY);
1324 }
1325