ui/qt/models/export_objects_model.cpp

   1 /* export_objects_model.cpp
   2  * Data model for Export Objects.
   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 "export_objects_model.h"
  12
  13 #include <ui/qt/utils/qt_ui_utils.h>
  14 #include <ui/qt/utils/variant_pointer.h>
  15 #include <wsutil/filesystem.h>
  16 #include <epan/prefs.h>
  17
  18 #include <QDir>
  19
  20 extern "C" {
  21
  22 static void
  23 object_list_add_entry(void *gui_data, export_object_entry_t *entry) {
  24     export_object_list_gui_t *object_list = (export_object_list_gui_t*)gui_data;
  25
  26     if (object_list && object_list->model)
  27         object_list->model->addObjectEntry(entry);
  28 }
  29
  30 static export_object_entry_t*
  31 object_list_get_entry(void *gui_data, int row) {
  32     export_object_list_gui_t *object_list = (export_object_list_gui_t*)gui_data;
  33
  34     if (object_list && object_list->model)
  35         return object_list->model->objectEntry(row);
  36
  37     return NULL;
  38 }
  39
  40 } // extern "C"
  41
  42
  43
  44
  45 ExportObjectModel::ExportObjectModel(register_eo_t* eo, QObject *parent) :
  46     QAbstractTableModel(parent),
  47     eo_(eo)
  48 {
  49     eo_gui_data_.model = this;
  50
  51     export_object_list_.add_entry = object_list_add_entry;
  52     export_object_list_.get_entry = object_list_get_entry;
  53     export_object_list_.gui_data = (void*)&eo_gui_data_;
  54 }
  55
  56 ExportObjectModel::~ExportObjectModel()
  57 {
  58     foreach (QVariant v, objects_) {
  59         eo_free_entry(VariantPointer<export_object_entry_t>::asPtr(v));
  60     }
  61 }
  62
  63 QVariant ExportObjectModel::data(const QModelIndex &index, int role) const
  64 {
  65     if ((!index.isValid()) || ((role != Qt::DisplayRole) && (role != Qt::UserRole))) {
  66         return QVariant();
  67     }
  68
  69     if (role == Qt::DisplayRole)
  70     {
  71         export_object_entry_t *entry = VariantPointer<export_object_entry_t>::asPtr(objects_.value(index.row()));
  72         if (entry == NULL)
  73             return QVariant();
  74
  75         switch(index.column())
  76         {
  77         case colPacket:
  78             return QString::number(entry->pkt_num);
  79         case colHostname:
  80             return QString::fromUtf8(entry->hostname);
  81         case colContent:
  82             return QString::fromUtf8(entry->content_type);
  83         case colSize:
  84             return file_size_to_qstring(entry->payload_len);
  85         case colFilename:
  86             return QString::fromUtf8(entry->filename);
  87         }
  88     }
  89     else if (role == Qt::UserRole)
  90     {
  91         return objects_.value(index.row());
  92     }
  93
  94     return QVariant();
  95 }
  96
  97 QVariant ExportObjectModel::headerData(int section, Qt::Orientation orientation, int role) const
  98 {
  99     if (role != Qt::DisplayRole || orientation != Qt::Horizontal)
 100         return QVariant();
 101
 102     switch (section) {
 103     case colPacket:
 104         return tr("Packet");
 105     case colHostname:
 106         return tr("Hostname");
 107     case colContent:
 108         return tr("Content Type");
 109     case colSize:
 110         return tr("Size");
 111     case colFilename:
 112         return tr("Filename");
 113     }
 114
 115     return QVariant();
 116 }
 117
 118 int ExportObjectModel::rowCount(const QModelIndex &parent) const
 119 {
 120     // there are no children
 121     if (parent.isValid()) {
 122         return 0;
 123     }
 124
 125     return static_cast<int>(objects_.count());
 126 }
 127
 128 int ExportObjectModel::columnCount(const QModelIndex&) const
 129 {
 130     return colExportObjectMax;
 131 }
 132
 133 void ExportObjectModel::addObjectEntry(export_object_entry_t *entry)
 134 {
 135     if (entry == NULL)
 136         return;
 137
 138     int count = static_cast<int>(objects_.count());
 139     beginInsertRows(QModelIndex(), count, count);
 140     objects_.append(VariantPointer<export_object_entry_t>::asQVariant(entry));
 141     endInsertRows();
 142 }
 143
 144 export_object_entry_t* ExportObjectModel::objectEntry(int row)
 145 {
 146     return VariantPointer<export_object_entry_t>::asPtr(objects_.value(row));
 147 }
 148
 149 bool ExportObjectModel::saveEntry(QModelIndex &index, QString filename)
 150 {
 151     if (!index.isValid() || filename.isEmpty())
 152         return false;
 153
 154     export_object_entry_t *entry = VariantPointer<export_object_entry_t>::asPtr(objects_.value(index.row()));
 155     if (entry == NULL)
 156         return false;
 157
 158     if (filename.length() > 0) {
 159         write_file_binary_mode(qUtf8Printable(filename), entry->payload_data, entry->payload_len);
 160     }
 161
 162     return true;
 163 }
 164
 165 void ExportObjectModel::saveAllEntries(QString path)
 166 {
 167     if (path.isEmpty())
 168         return;
 169
 170     QDir save_dir(path);
 171     export_object_entry_t *entry;
 172
 173     for (QList<QVariant>::iterator it = objects_.begin(); it != objects_.end(); ++it)
 174     {
 175         entry = VariantPointer<export_object_entry_t>::asPtr(*it);
 176         if (entry == NULL)
 177             continue;
 178
 179         unsigned count = 0;
 180         QString filename;
 181
 182         do {
 183             GString *safe_filename;
 184
 185             if (entry->filename)
 186                 safe_filename = eo_massage_str(entry->filename,
 187                     EXPORT_OBJECT_MAXFILELEN, count);
 188             else {
 189                 char generic_name[EXPORT_OBJECT_MAXFILELEN+1];
 190                 const char *ext;
 191                 ext = eo_ct2ext(entry->content_type);
 192                 snprintf(generic_name, sizeof(generic_name),
 193                     "object%u%s%s", entry->pkt_num, ext ? "." : "",
 194                     ext ? ext : "");
 195                 safe_filename = eo_massage_str(generic_name,
 196                     EXPORT_OBJECT_MAXFILELEN, count);
 197             }
 198             filename = QString::fromUtf8(safe_filename->str);
 199             g_string_free(safe_filename, TRUE);
 200         } while (save_dir.exists(filename) && ++count < prefs.gui_max_export_objects);
 201         write_file_binary_mode(qUtf8Printable(save_dir.filePath(filename)),
 202                                entry->payload_data, entry->payload_len);
 203     }
 204 }
 205
 206 void ExportObjectModel::resetObjects()
 207 {
 208     export_object_gui_reset_cb reset_cb = get_eo_reset_func(eo_);
 209
 210     beginResetModel();
 211     objects_.clear();
 212     endResetModel();
 213
 214     if (reset_cb)
 215         reset_cb();
 216 }
 217
 218 // Called by taps
 219 /* Runs at the beginning of tapping only */
 220 void ExportObjectModel::resetTap(void *tapdata)
 221 {
 222     export_object_list_t *tap_object = (export_object_list_t *)tapdata;
 223     export_object_list_gui_t *object_list = (export_object_list_gui_t *)tap_object->gui_data;
 224     if (object_list && object_list->model)
 225         object_list->model->resetObjects();
 226 }
 227
 228 const char* ExportObjectModel::getTapListenerName()
 229 {
 230     return get_eo_tap_listener_name(eo_);
 231 }
 232
 233 void* ExportObjectModel::getTapData()
 234 {
 235     return &export_object_list_;
 236 }
 237
 238 tap_packet_cb ExportObjectModel::getTapPacketFunc()
 239 {
 240     return get_eo_packet_func(eo_);
 241 }
 242
 243 void ExportObjectModel::removeTap()
 244 {
 245     eo_gui_data_.model = NULL;
 246 }
 247
 248
 249
 250 ExportObjectProxyModel::ExportObjectProxyModel(QObject * parent)
 251     : QSortFilterProxyModel(parent)
 252 {
 253
 254 }
 255
 256 bool ExportObjectProxyModel::lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const
 257 {
 258     export_object_entry_t *left_entry = VariantPointer<export_object_entry_t>::asPtr(sourceModel()->data(source_left, Qt::UserRole)),
 259                           *right_entry = VariantPointer<export_object_entry_t>::asPtr(sourceModel()->data(source_right, Qt::UserRole));
 260
 261     if ((left_entry != NULL) && (right_entry != NULL))
 262     {
 263         switch (source_left.column())
 264         {
 265         case ExportObjectModel::colPacket:
 266             return left_entry->pkt_num < right_entry->pkt_num;
 267         case ExportObjectModel::colSize:
 268             return left_entry->payload_len < right_entry->payload_len;
 269         case ExportObjectModel::colFilename:
 270             break;
 271         }
 272     }
 273
 274     return QSortFilterProxyModel::lessThan(source_left, source_right);
 275 }
 276
 277 void ExportObjectProxyModel::setContentFilterString(QString filter_)
 278 {
 279     contentFilter_ = filter_;
 280     invalidateFilter();
 281 }
 282
 283 void ExportObjectProxyModel::setTextFilterString(QString filter_)
 284 {
 285     textFilter_ = filter_;
 286     invalidateFilter();
 287 }
 288
 289 bool ExportObjectProxyModel::filterAcceptsRow(int source_row, const QModelIndex &/*source_parent*/) const
 290 {
 291     if (contentFilter_.length() > 0)
 292     {
 293         QModelIndex idx = sourceModel()->index(source_row, ExportObjectModel::colContent);
 294         if (!idx.isValid())
 295             return false;
 296
 297         if (contentFilter_.compare(idx.data().toString()) != 0)
 298             return false;
 299     }
 300
 301     if (textFilter_.length() > 0)
 302     {
 303         QModelIndex hostIdx = sourceModel()->index(source_row, ExportObjectModel::colHostname);
 304         QModelIndex fileIdx = sourceModel()->index(source_row, ExportObjectModel::colFilename);
 305         if (!hostIdx.isValid() || !fileIdx.isValid())
 306             return false;
 307
 308         QString host = hostIdx.data().toString();
 309         QString file = fileIdx.data().toString();
 310
 311         if (!host.contains(textFilter_) && !file.contains(textFilter_))
 312             return false;
 313     }
 314
 315     return true;
 316 }