qt/models/enabled_protocols_model.cpp

/* enabled_protocols_model.cpp
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

#include <QSortFilterProxyModel>

#include <ui/qt/models/enabled_protocols_model.h>
#include <epan/packet.h>
#include <epan/disabled_protos.h>

#include <ui/qt/utils/variant_pointer.h>
#include "wireshark_application.h"

class ProtocolTreeItem : public EnabledProtocolItem
{
public:
    ProtocolTreeItem(protocol_t* proto, EnabledProtocolItem* parent)
        : EnabledProtocolItem(proto_get_protocol_short_name(proto), proto_get_protocol_long_name(proto), proto_is_protocol_enabled(proto), parent),
        proto_(proto)
    {

    }

    virtual ~ProtocolTreeItem() {}

protected:
    virtual void applyValuePrivate(gboolean value)
    {
        if (! proto_can_toggle_protocol(proto_get_id(proto_)) || proto_is_pino(proto_)) {
            return;
        }
        proto_set_decoding(proto_get_id(proto_), value);
    }

private:
    protocol_t* proto_;
};

class HeuristicTreeItem : public EnabledProtocolItem
{
public:
    HeuristicTreeItem(heur_dtbl_entry_t *heuristic, EnabledProtocolItem* parent)
        : EnabledProtocolItem(heuristic->short_name, heuristic->display_name, heuristic->enabled, parent),
        heuristic_table_(heuristic)
    {
        type_ = EnabledProtocolItem::Heuristic;
    }

    virtual ~HeuristicTreeItem() {}

protected:
    virtual void applyValuePrivate(gboolean value)
    {
        heuristic_table_->enabled = value;
    }

private:
    heur_dtbl_entry_t *heuristic_table_;
};


EnabledProtocolItem::EnabledProtocolItem(QString name, QString description, bool enabled, EnabledProtocolItem* parent) :
    ModelHelperTreeItem<EnabledProtocolItem>(parent),
    name_(name),
    description_(description),
    enabled_(enabled),
    enabledInit_(enabled),
    type_(EnabledProtocolItem::Standard)
{
}

EnabledProtocolItem::~EnabledProtocolItem()
{
}

EnabledProtocolItem::EnableProtocolType EnabledProtocolItem::type() const
{
    return type_;
}

bool EnabledProtocolItem::applyValue()
{
    if (enabledInit_ != enabled_) {
        applyValuePrivate(enabled_);
        return true;
    }

    return false;
}


EnabledProtocolsModel::EnabledProtocolsModel(QObject *parent) :
    QAbstractItemModel(parent),
    root_(new ProtocolTreeItem(NULL, NULL))
{
}

EnabledProtocolsModel::~EnabledProtocolsModel()
{
    delete root_;
}

int EnabledProtocolsModel::rowCount(const QModelIndex &parent) const
{
   EnabledProtocolItem *parent_item;
    if (parent.column() > 0)
        return 0;

    if (!parent.isValid())
        parent_item = root_;
    else
        parent_item = static_cast<EnabledProtocolItem*>(parent.internalPointer());

    if (parent_item == NULL)
        return 0;

    return parent_item->childCount();
}

int EnabledProtocolsModel::columnCount(const QModelIndex&) const
{
    return colLast;
}

QVariant EnabledProtocolsModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {

        switch ((enum EnabledProtocolsColumn)section) {
        case colProtocol:
            return tr("Protocol");
        case colDescription:
            return tr("Description");
        default:
            break;
        }
    }
    return QVariant();
}

QModelIndex EnabledProtocolsModel::parent(const QModelIndex& index) const
{
    if (!index.isValid())
        return QModelIndex();

    EnabledProtocolItem* item = static_cast<EnabledProtocolItem*>(index.internalPointer());
    if (item != NULL) {
        EnabledProtocolItem* parent_item = item->parentItem();
        if (parent_item != NULL) {
            if (parent_item == root_)
                return QModelIndex();

            return createIndex(parent_item->row(), 0, parent_item);
        }
    }

    return QModelIndex();
}

QModelIndex EnabledProtocolsModel::index(int row, int column, const QModelIndex& parent) const
{
    if (!hasIndex(row, column, parent))
        return QModelIndex();

    EnabledProtocolItem *parent_item, *child_item;

    if (!parent.isValid())
        parent_item = root_;
    else
        parent_item = static_cast<EnabledProtocolItem*>(parent.internalPointer());

    Q_ASSERT(parent_item);

    child_item = parent_item->child(row);
    if (child_item) {
        return createIndex(row, column, child_item);
    }

    return QModelIndex();
}

Qt::ItemFlags EnabledProtocolsModel::flags(const QModelIndex &index) const
{
    if (!index.isValid())
        return Qt::ItemFlags();

    Qt::ItemFlags flags = QAbstractItemModel::flags(index);
    switch(index.column())
    {
    case colProtocol:
        flags |= Qt::ItemIsUserCheckable;
        break;
    default:
        break;
    }

    return flags;
}

QVariant EnabledProtocolsModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid())
        return QVariant();

    EnabledProtocolItem* item = static_cast<EnabledProtocolItem*>(index.internalPointer());
    if (item == NULL)
        return QVariant();

    switch (role)
    {
    case Qt::DisplayRole:
        switch ((enum EnabledProtocolsColumn)index.column())
        {
        case colProtocol:
            return item->name();
        case colDescription:
            return item->description();
        default:
            break;
        }
        break;
    case Qt::CheckStateRole:
        switch ((enum EnabledProtocolsColumn)index.column())
        {
        case colProtocol:
            return item->enabled() ? Qt::Checked : Qt::Unchecked;
        default:
            break;
        }
        break;
    case DATA_PROTOCOL_TYPE:
        return QVariant::fromValue(item->type());
        break;
    default:
    break;
    }

    return QVariant();
}

bool EnabledProtocolsModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
    if (!index.isValid())
        return false;

    if ((role != Qt::EditRole) &&
        ((index.column() == colProtocol) && (role != Qt::CheckStateRole)))
        return false;

    if (data(index, role) == value) {
        // Data appears unchanged, do not do additional checks.
        return true;
    }

    EnabledProtocolItem* item = static_cast<EnabledProtocolItem*>(index.internalPointer());
    if (item == NULL)
        return false;

    item->setEnabled(value == Qt::Checked ? true : false);

    QVector<int> roles;
    roles << role;

    emit dataChanged(index, index, roles);

    return true;
}

static void addHeuristicItem(gpointer data, gpointer user_data)
{
    heur_dtbl_entry_t* heur = (heur_dtbl_entry_t*)data;
    ProtocolTreeItem* protocol_item = (ProtocolTreeItem*)user_data;

    HeuristicTreeItem* heuristic_row = new HeuristicTreeItem(heur, protocol_item);
    protocol_item->prependChild(heuristic_row);
}

void EnabledProtocolsModel::populate()
{
    void *cookie;
    protocol_t *protocol;

    emit beginResetModel();

    // Iterate over all the protocols
    for (int i = proto_get_first_protocol(&cookie); i != -1; i = proto_get_next_protocol(&cookie))
    {
        if (proto_can_toggle_protocol(i))
        {
            protocol = find_protocol_by_id(i);
            ProtocolTreeItem* protocol_row = new ProtocolTreeItem(protocol, root_);
            root_->prependChild(protocol_row);

            proto_heuristic_dissector_foreach(protocol, addHeuristicItem, protocol_row);
        }
    }

    emit endResetModel();
}

void EnabledProtocolsModel::applyChanges(bool writeChanges)
{
    bool redissect = false;

    for (int proto_index = 0; proto_index < root_->childCount(); proto_index++) {
        EnabledProtocolItem* proto = root_->child(proto_index);
        redissect |= proto->applyValue();
        for (int heur_index = 0; heur_index < proto->childCount(); heur_index++) {
            EnabledProtocolItem* heur = proto->child(heur_index);
            redissect |= heur->applyValue();
        }
    }

    if (redissect) {
        saveChanges(writeChanges);
    }
}

void EnabledProtocolsModel::disableProtocol(struct _protocol *protocol)
{
    ProtocolTreeItem disabled_proto(protocol, NULL);
    disabled_proto.setEnabled(false);
    if (disabled_proto.applyValue()) {
        saveChanges();
    }
}

void EnabledProtocolsModel::saveChanges(bool writeChanges)
{
    if (writeChanges) {
        save_enabled_and_disabled_lists();
    }
    wsApp->emitAppSignal(WiresharkApplication::PacketDissectionChanged);
}


EnabledProtocolsProxyModel::EnabledProtocolsProxyModel(QObject * parent)
: QSortFilterProxyModel(parent),
type_(EnabledProtocolsProxyModel::EveryWhere),
protocolType_(EnabledProtocolItem::Any),
filter_()
{}

bool EnabledProtocolsProxyModel::lessThan(const QModelIndex &left, const QModelIndex &right) const
{
    //Use EnabledProtocolItem directly for better performance
    EnabledProtocolItem* left_item = static_cast<EnabledProtocolItem*>(left.internalPointer());
    EnabledProtocolItem* right_item = static_cast<EnabledProtocolItem*>(right.internalPointer());

    if ((left_item != NULL) && (right_item != NULL)) {

        int compare_ret = 0;

        if (left.column() == EnabledProtocolsModel::colProtocol)
            compare_ret = left_item->name().compare(right_item->name(), Qt::CaseInsensitive);
        else if (left.column() == EnabledProtocolsModel::colDescription)
            compare_ret = left_item->description().compare(right_item->description(), Qt::CaseInsensitive);

        if (compare_ret < 0)
            return true;
    }

    return false;
}

Qt::ItemFlags EnabledProtocolsProxyModel::flags(const QModelIndex &index) const
{
    Qt::ItemFlags flags = Qt::NoItemFlags;
    if (index.isValid())
    {
        QModelIndex source = mapToSource(index);
        if (filterAcceptsSelf(source.row(), source.parent()) )
        {
            flags = Qt::ItemIsEnabled;
            flags |= Qt::ItemIsSelectable;
            flags |= Qt::ItemIsUserCheckable;
        }
    }

    return flags;
}

bool EnabledProtocolsProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
{
    if (filterAcceptsSelf(sourceRow, sourceParent))
        return true;

#if 0
    QModelIndex parent = sourceParent;
    while (parent.isValid())
    {
        if (filterAcceptsSelf(parent.row(), parent.parent()))
            return true;
        parent = parent.parent();
    }
#endif

    if (filterAcceptsChild(sourceRow, sourceParent))
        return true;

    return false;
}

bool EnabledProtocolsProxyModel::filterAcceptsSelf(int sourceRow, const QModelIndex &sourceParent) const
{
    QModelIndex nameIdx = sourceModel()->index(sourceRow, EnabledProtocolsModel::colProtocol, sourceParent);
    if (! nameIdx.isValid())
        return false;
    EnabledProtocolItem* item = static_cast<EnabledProtocolItem*>(nameIdx.internalPointer());
    if (! item)
        return false;

    QRegExp regex(filter_, Qt::CaseInsensitive);

    if ((type_ != EnabledProtocolsProxyModel::EnabledItems && type_ != EnabledProtocolsProxyModel::DisabledItems) &&
        (protocolType_ == EnabledProtocolItem::Any || protocolType_ == item->type()) )
    {
        if (! filter_.isEmpty())
        {
            if (item->name().contains(regex) && type_ != OnlyDescription)
                return true;

            if (item->description().contains(regex) && type_ != OnlyProtocol)
                return true;
        }
        else
            return true;
    }
    else if (type_ == EnabledProtocolsProxyModel::EnabledItems && item->enabled())
        return true;
    else if (type_ == EnabledProtocolsProxyModel::DisabledItems && ! item->enabled())
        return true;

    return false;
}

bool EnabledProtocolsProxyModel::filterAcceptsChild(int sourceRow, const QModelIndex &sourceParent) const
{
    QModelIndex item = sourceModel()->index(sourceRow, EnabledProtocolsModel::colProtocol, sourceParent);
    if (! item.isValid())
        return false;

    int childCount = item.model()->rowCount(item);
    if (childCount == 0)
        return false;

    for (int i = 0; i < childCount; i++)
    {
        if (filterAcceptsSelf(i, item))
            return true;
#if 0
        /* Recursive search disabled for performance reasons */
        if (filterAcceptsChild(i, item))
            return true;
#endif
    }

    return false;
}

void EnabledProtocolsProxyModel::setFilter(const QString& filter, EnabledProtocolsProxyModel::SearchType type,
    EnabledProtocolItem::EnableProtocolType protocolType)
{
    filter_ = filter;
    type_ = type;
    protocolType_ = protocolType;
    invalidateFilter();
}

void EnabledProtocolsProxyModel::setItemsEnable(EnabledProtocolsProxyModel::EnableType enableType, QModelIndex parent)
{
    if (! sourceModel())
        return;

    if (! parent.isValid())
        emit beginResetModel();

    for (int row = 0; row < rowCount(parent); row++)
    {
        QModelIndex idx = index(row, EnabledProtocolsModel::colProtocol, parent);

        QModelIndex sIdx = mapToSource(idx);
        if (sIdx.isValid())
        {
            EnabledProtocolItem* item = static_cast<EnabledProtocolItem*>(sIdx.internalPointer());
            if (item && (protocolType_ == EnabledProtocolItem::Any || protocolType_ == item->type()) )
            {
                Qt::CheckState enable = idx.data(Qt::CheckStateRole).value<Qt::CheckState>();
                if (enableType == Enable)
                    enable = Qt::Checked;
                else if (enableType == Disable)
                    enable = Qt::Unchecked;
                else
                    enable = enable == Qt::Checked ? Qt::Unchecked : Qt::Checked;

                sourceModel()->setData(mapToSource(idx), QVariant::fromValue(enable), Qt::CheckStateRole);
            }
        }

        setItemsEnable(enableType, idx);
    }


    if (! parent.isValid())
        emit endResetModel();
}