ui/qt/models/interface_tree_model.cpp

   1 /* interface_tree_model.cpp
   2  * Model for the interface data for display in the interface frame
   3  *
   4  * Wireshark - Network traffic analyzer
   5  * By Gerald Combs <gerald@wireshark.org>
   6  * Copyright 1998 Gerald Combs
   7  *
   8  * SPDX-License-Identifier: GPL-2.0-or-later
   9  */
  10
  11 #include "config.h"
  12
  13 #include <ui/qt/models/interface_tree_model.h>
  14
  15 #ifdef HAVE_LIBPCAP
  16 #include "ui/capture.h"
  17 #include "capture/capture-pcap-util.h"
  18 #include "capture_opts.h"
  19 #include "ui/capture_ui_utils.h"
  20 #include "ui/capture_globals.h"
  21 #endif
  22
  23 #include "wsutil/filesystem.h"
  24
  25 #include <ui/qt/utils/qt_ui_utils.h>
  26 #include <ui/qt/utils/stock_icon.h>
  27 #include "main_application.h"
  28
  29 /* Needed for the meta type declaration of QList<int>* */
  30 #include <ui/qt/models/sparkline_delegate.h>
  31
  32 #include "extcap.h"
  33
  34 const QString InterfaceTreeModel::DefaultNumericValue = QObject::tr("default");
  35
  36 /**
  37  * This is the data model for interface trees. It implies, that the index within
  38  * global_capture_opts.all_ifaces is identical to the row. This is always the case, even
  39  * when interfaces are hidden by the proxy model. But for this to work, every access
  40  * to the index from within the view, has to be filtered through the proxy model.
  41  */
  42 InterfaceTreeModel::InterfaceTreeModel(QObject *parent) :
  43     QAbstractTableModel(parent)
  44 #ifdef HAVE_LIBPCAP
  45     ,stat_cache_(NULL)
  46 #endif
  47 {
  48     connect(mainApp, &MainApplication::appInitialized, this, &InterfaceTreeModel::interfaceListChanged);
  49     connect(mainApp, &MainApplication::localInterfaceListChanged, this, &InterfaceTreeModel::interfaceListChanged);
  50 }
  51
  52 InterfaceTreeModel::~InterfaceTreeModel(void)
  53 {
  54 #ifdef HAVE_LIBPCAP
  55     if (stat_cache_) {
  56         capture_stat_stop(stat_cache_);
  57         stat_cache_ = NULL;
  58     }
  59 #endif // HAVE_LIBPCAP
  60 }
  61
  62 QString InterfaceTreeModel::interfaceError()
  63 {
  64 #ifdef HAVE_LIBPCAP
  65     //
  66     // First, see if there was an error fetching the interfaces.
  67     // If so, report it.
  68     //
  69     if (global_capture_opts.ifaces_err != 0)
  70     {
  71         return tr(global_capture_opts.ifaces_err_info);
  72     }
  73
  74     //
  75     // Otherwise, if there are no rows, there were no interfaces
  76     // found.
  77     //
  78     if (rowCount() == 0)
  79     {
  80         return tr("No interfaces found.");
  81     }
  82
  83     //
  84     // No error.  Return an empty string.
  85     //
  86     return "";
  87 #else
  88     //
  89     // We were built without pcap support, so we have no notion of
  90     // local interfaces.
  91     //
  92     return tr("This version of Wireshark was built without packet capture support.");
  93 #endif
  94 }
  95
  96 int InterfaceTreeModel::rowCount(const QModelIndex &) const
  97 {
  98 #ifdef HAVE_LIBPCAP
  99     return (global_capture_opts.all_ifaces ? global_capture_opts.all_ifaces->len : 0);
 100 #else
 101     /* Currently no interfaces available for libpcap-less builds */
 102     return 0;
 103 #endif
 104 }
 105
 106 int InterfaceTreeModel::columnCount(const QModelIndex &) const
 107 {
 108     /* IFTREE_COL_MAX is not being displayed, it is the definition for the maximum numbers of columns */
 109     return ((int) IFTREE_COL_MAX);
 110 }
 111
 112 QVariant InterfaceTreeModel::data(const QModelIndex &index, int role) const
 113 {
 114 #ifdef HAVE_LIBPCAP
 115     bool interfacesLoaded = true;
 116     if (! global_capture_opts.all_ifaces || global_capture_opts.all_ifaces->len == 0)
 117         interfacesLoaded = false;
 118
 119     if (!index.isValid())
 120         return QVariant();
 121
 122     int row = index.row();
 123     InterfaceTreeColumns col = (InterfaceTreeColumns) index.column();
 124
 125     if (interfacesLoaded)
 126     {
 127         interface_t *device = &g_array_index(global_capture_opts.all_ifaces, interface_t, row);
 128
 129         /* Data for display in cell */
 130         if (role == Qt::DisplayRole)
 131         {
 132             /* Only the name is being displayed */
 133             if (col == IFTREE_COL_NAME)
 134             {
 135                 return QString(device->name);
 136             }
 137             else if (col == IFTREE_COL_DESCRIPTION)
 138             {
 139                 return QString(device->if_info.friendly_name);
 140             }
 141             else if (col == IFTREE_COL_DISPLAY_NAME)
 142             {
 143                 return QString(device->display_name);
 144             }
 145             else if (col == IFTREE_COL_PIPE_PATH)
 146             {
 147                 return QString(device->if_info.name);
 148             }
 149             else if (col == IFTREE_COL_CAPTURE_FILTER)
 150             {
 151                 if (device->cfilter && strlen(device->cfilter) > 0)
 152                     return html_escape(QString(device->cfilter));
 153             }
 154             else if (col == IFTREE_COL_EXTCAP_PATH)
 155             {
 156                 return QString(device->if_info.extcap);
 157             }
 158             else if (col == IFTREE_COL_SNAPLEN)
 159             {
 160                 return device->has_snaplen ? QString::number(device->snaplen) : DefaultNumericValue;
 161             }
 162 #ifdef CAN_SET_CAPTURE_BUFFER_SIZE
 163             else if (col == IFTREE_COL_BUFFERLEN)
 164             {
 165                 return QString::number(device->buffer);
 166             }
 167 #endif
 168             else if (col == IFTREE_COL_TYPE)
 169             {
 170                 return QVariant::fromValue((int)device->if_info.type);
 171             }
 172             else if (col == IFTREE_COL_COMMENT)
 173             {
 174                 QString comment = gchar_free_to_qstring(capture_dev_user_descr_find(device->name));
 175                 if (comment.length() > 0)
 176                     return comment;
 177                 else
 178                     return QString(device->if_info.vendor_description);
 179             }
 180             else if (col == IFTREE_COL_DLT)
 181             {
 182                 // XXX - this is duplicated in
 183                 // InterfaceTreeWidgetItem::updateInterfaceColumns;
 184                 // it should be done in common code somewhere.
 185                 QString linkname;
 186                 if (device->active_dlt == -1)
 187                     linkname = "Unknown";
 188                 else {
 189                     linkname = QObject::tr("DLT %1").arg(device->active_dlt);
 190                     for (GList *list = device->links; list != Q_NULLPTR; list = gxx_list_next(list)) {
 191                         link_row *linkr = gxx_list_data(link_row *, list);
 192                         if (linkr->dlt == device->active_dlt) {
 193                             linkname = linkr->name;
 194                             break;
 195                         }
 196                     }
 197                 }
 198
 199                 return linkname;
 200             }
 201             else
 202             {
 203                 /* Return empty string for every other DisplayRole */
 204                 return QVariant();
 205             }
 206         }
 207         else if (role == Qt::CheckStateRole)
 208         {
 209             if (col == IFTREE_COL_HIDDEN)
 210             {
 211                 /* Hidden is a de-selection, therefore inverted logic here */
 212                 return device->hidden ? Qt::Unchecked : Qt::Checked;
 213             }
 214             else if (col == IFTREE_COL_PROMISCUOUSMODE)
 215             {
 216                 return device->pmode ? Qt::Checked : Qt::Unchecked;
 217             }
 218 #ifdef HAVE_PCAP_CREATE
 219             else if (col == IFTREE_COL_MONITOR_MODE)
 220             {
 221                 return device->monitor_mode_enabled ? Qt::Checked : Qt::Unchecked;
 222             }
 223 #endif
 224         }
 225         /* Used by SparkLineDelegate for loading the data for the statistics line */
 226         else if (role == Qt::UserRole)
 227         {
 228             if (col == IFTREE_COL_STATS)
 229             {
 230                 if ((active.contains(device->name) && active[device->name]) && points.contains(device->name))
 231                     return QVariant::fromValue(points[device->name]);
 232             }
 233             else if (col == IFTREE_COL_ACTIVE)
 234             {
 235                 if (active.contains(device->name))
 236                     return QVariant::fromValue(active[device->name]);
 237             }
 238             else if (col == IFTREE_COL_HIDDEN)
 239             {
 240                 return QVariant::fromValue((bool)device->hidden);
 241             }
 242         }
 243         /* Displays the configuration icon for extcap interfaces */
 244         else if (role == Qt::DecorationRole)
 245         {
 246             if (col == IFTREE_COL_EXTCAP)
 247             {
 248                 if (device->if_info.type == IF_EXTCAP)
 249                     return QIcon(StockIcon("x-capture-options"));
 250             }
 251         }
 252         else if (role == Qt::TextAlignmentRole)
 253         {
 254             if (col == IFTREE_COL_EXTCAP)
 255             {
 256                 return Qt::AlignRight;
 257             }
 258         }
 259         /* Displays the tooltip for each row */
 260         else if (role == Qt::ToolTipRole)
 261         {
 262             return toolTipForInterface(row);
 263         }
 264     }
 265 #else
 266     Q_UNUSED(index)
 267     Q_UNUSED(role)
 268 #endif
 269
 270     return QVariant();
 271 }
 272
 273 QVariant InterfaceTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
 274 {
 275     if (orientation == Qt::Horizontal)
 276     {
 277         if (role == Qt::DisplayRole)
 278         {
 279             if (section == IFTREE_COL_HIDDEN)
 280             {
 281                 return tr("Show");
 282             }
 283             else if (section == IFTREE_COL_NAME)
 284             {
 285                 return tr("Interface Name");
 286             }
 287             else if (section == IFTREE_COL_DESCRIPTION)
 288             {
 289                 return tr("Friendly Name");
 290             }
 291             else if (section == IFTREE_COL_DISPLAY_NAME)
 292             {
 293                 return tr("Friendly Name");
 294             }
 295             else if (section == IFTREE_COL_PIPE_PATH)
 296             {
 297                 return tr("Local Pipe Path");
 298             }
 299             else if (section == IFTREE_COL_COMMENT)
 300             {
 301                 return tr("Comment");
 302             }
 303             else if (section == IFTREE_COL_DLT)
 304             {
 305                 return tr("Link-Layer Header");
 306             }
 307             else if (section == IFTREE_COL_PROMISCUOUSMODE)
 308             {
 309                 return tr("Promiscuous");
 310             }
 311             else if (section == IFTREE_COL_SNAPLEN)
 312             {
 313                 return tr("Snaplen (B)");
 314             }
 315 #ifdef CAN_SET_CAPTURE_BUFFER_SIZE
 316             else if (section == IFTREE_COL_BUFFERLEN)
 317             {
 318                 return tr("Buffer (MB)");
 319             }
 320 #endif
 321 #ifdef HAVE_PCAP_CREATE
 322             else if (section == IFTREE_COL_MONITOR_MODE)
 323             {
 324                 return tr("Monitor Mode");
 325             }
 326 #endif
 327             else if (section == IFTREE_COL_CAPTURE_FILTER)
 328             {
 329                 return tr("Capture Filter");
 330             }
 331         }
 332     }
 333
 334     return QVariant();
 335 }
 336
 337 QVariant InterfaceTreeModel::getColumnContent(int idx, int col, int role)
 338 {
 339     return InterfaceTreeModel::data(index(idx, col), role);
 340 }
 341
 342 #ifdef HAVE_PCAP_REMOTE
 343 bool InterfaceTreeModel::isRemote(int idx)
 344 {
 345     interface_t *device = &g_array_index(global_capture_opts.all_ifaces, interface_t, idx);
 346     if (device->remote_opts.src_type == CAPTURE_IFREMOTE)
 347         return true;
 348     return false;
 349 }
 350 #endif
 351
 352 /**
 353  * The interface list has changed. global_capture_opts.all_ifaces may have been reloaded
 354  * or changed with current data. beginResetModel() and endResetModel() will signalize the
 355  * proxy model and the view, that the data has changed and the view has to reload
 356  */
 357 void InterfaceTreeModel::interfaceListChanged()
 358 {
 359     beginResetModel();
 360
 361     points.clear();
 362     active.clear();
 363
 364     endResetModel();
 365 }
 366
 367 /*
 368  * Displays the tooltip code for the given device index.
 369  */
 370 QVariant InterfaceTreeModel::toolTipForInterface(int idx) const
 371 {
 372 #ifdef HAVE_LIBPCAP
 373     if (! global_capture_opts.all_ifaces || global_capture_opts.all_ifaces->len <= (unsigned) idx)
 374         return QVariant();
 375
 376     interface_t *device = &g_array_index(global_capture_opts.all_ifaces, interface_t, idx);
 377
 378     QString tt_str = "<p>";
 379     if (device->no_addresses > 0)
 380     {
 381         tt_str += QStringLiteral("%1: %2")
 382                 .arg(device->no_addresses > 1 ? tr("Addresses") : tr("Address"))
 383                 .arg(html_escape(device->addresses))
 384                 .replace('\n', ", ");
 385     }
 386     else if (device->if_info.type == IF_EXTCAP)
 387     {
 388         tt_str = tr("Extcap interface: %1").arg(get_basename(device->if_info.extcap));
 389     }
 390     else
 391     {
 392         tt_str = tr("No addresses");
 393     }
 394     tt_str += "<br/>";
 395
 396     QString cfilter = device->cfilter;
 397     if (cfilter.isEmpty())
 398     {
 399         tt_str += tr("No capture filter");
 400     }
 401     else
 402     {
 403         tt_str += QStringLiteral("%1: %2")
 404                 .arg(tr("Capture filter"))
 405                 .arg(html_escape(cfilter));
 406     }
 407     tt_str += "</p>";
 408
 409     return tt_str;
 410 #else
 411     Q_UNUSED(idx)
 412
 413     return QVariant();
 414 #endif
 415 }
 416
 417 #ifdef HAVE_LIBPCAP
 418 void InterfaceTreeModel::setCache(if_stat_cache_t *stat_cache)
 419 {
 420     stopStatistic();
 421     stat_cache_ = stat_cache;
 422 }
 423
 424 void InterfaceTreeModel::stopStatistic()
 425 {
 426     if (stat_cache_)
 427     {
 428         capture_stat_stop(stat_cache_);
 429         stat_cache_ = NULL;
 430     }
 431 }
 432 #endif
 433
 434 void InterfaceTreeModel::updateStatistic(unsigned int idx)
 435 {
 436 #ifdef HAVE_LIBPCAP
 437     if (! global_capture_opts.all_ifaces || global_capture_opts.all_ifaces->len <= (unsigned) idx)
 438         return;
 439
 440     interface_t *device = &g_array_index(global_capture_opts.all_ifaces, interface_t, idx);
 441
 442     if (device->if_info.type == IF_PIPE || device->if_info.type == IF_EXTCAP)
 443         return;
 444
 445     if (!stat_cache_)
 446     {
 447         // Start gathering statistics using dumpcap
 448         //
 449         // The stat cache will only properly configure if it has the list
 450         // of interfaces in global_capture_opts->all_ifaces.
 451         // We crash if we try to do this from InterfaceFrame::showEvent,
 452         // because main.cpp calls mainw->show() before capture_opts_init().
 453         stat_cache_ = capture_stat_start(&global_capture_opts);
 454     }
 455
 456     struct pcap_stat stats;
 457     unsigned diff = 0;
 458     bool isActive = false;
 459
 460     if (capture_stats(stat_cache_, device->name, &stats))
 461     {
 462         if ( (int) stats.ps_recv > 0 )
 463             isActive = true;
 464
 465         if ((int)(stats.ps_recv - device->last_packets) >= 0)
 466         {
 467             diff = stats.ps_recv - device->last_packets;
 468             device->packet_diff = diff;
 469         }
 470         device->last_packets = stats.ps_recv;
 471     }
 472
 473     points[device->name].append(diff);
 474
 475     if (active[device->name] != isActive)
 476     {
 477         emit layoutAboutToBeChanged();
 478         active[device->name] = isActive;
 479         emit layoutChanged();
 480     }
 481
 482     emit dataChanged(index(idx, IFTREE_COL_STATS), index(idx, IFTREE_COL_STATS));
 483
 484 #else
 485     Q_UNUSED(idx)
 486 #endif
 487 }
 488
 489 QItemSelection InterfaceTreeModel::selectedDevices()
 490 {
 491     QItemSelection mySelection;
 492 #ifdef HAVE_LIBPCAP
 493     for (int idx = 0; idx < rowCount(); idx++)
 494     {
 495         interface_t *device = &g_array_index(global_capture_opts.all_ifaces, interface_t, idx);
 496
 497         if (device->selected)
 498         {
 499             QModelIndex selectIndex = index(idx, 0);
 500             mySelection.merge(
 501                     QItemSelection(selectIndex, index(selectIndex.row(), columnCount() - 1)),
 502                     QItemSelectionModel::SelectCurrent
 503                     );
 504         }
 505     }
 506 #endif
 507     return mySelection;
 508 }
 509
 510 bool InterfaceTreeModel::updateSelectedDevices(QItemSelection sourceSelection)
 511 {
 512     bool selectionHasChanged = false;
 513 #ifdef HAVE_LIBPCAP
 514     QList<int> selectedIndices;
 515
 516     QItemSelection::const_iterator it = sourceSelection.constBegin();
 517     while (it != sourceSelection.constEnd())
 518     {
 519         QModelIndexList indeces = ((QItemSelectionRange) (*it)).indexes();
 520
 521         QModelIndexList::const_iterator cit = indeces.constBegin();
 522         while (cit != indeces.constEnd())
 523         {
 524             QModelIndex index = (QModelIndex) (*cit);
 525             if (! selectedIndices.contains(index.row()))
 526             {
 527                 selectedIndices.append(index.row());
 528             }
 529             ++cit;
 530         }
 531         ++it;
 532     }
 533
 534     global_capture_opts.num_selected = 0;
 535
 536     for (unsigned int idx = 0; idx < global_capture_opts.all_ifaces->len; idx++)
 537     {
 538         interface_t *device = &g_array_index(global_capture_opts.all_ifaces, interface_t, idx);
 539         if (selectedIndices.contains(idx))
 540         {
 541             if (! device->selected)
 542                 selectionHasChanged = true;
 543             device->selected = true;
 544             global_capture_opts.num_selected++;
 545         } else {
 546             if (device->selected)
 547                 selectionHasChanged = true;
 548             device->selected = false;
 549         }
 550     }
 551 #else
 552     Q_UNUSED(sourceSelection)
 553 #endif
 554     return selectionHasChanged;
 555 }