![Roland Knall](/assets/img/avatar_default.png)
Change-Id: Ied32cf386074b97cfea38ffe6b8be6b916164712 Reviewed-on: https://code.wireshark.org/review/34873 Petri-Dish: Roland Knall <rknall@gmail.com> Tested-by: Petri Dish Buildbot Reviewed-by: Roland Knall <rknall@gmail.com>
1309 lines
37 KiB
C++
1309 lines
37 KiB
C++
/* profile_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 "config.h"
|
|
|
|
#include <errno.h>
|
|
|
|
#include "glib.h"
|
|
#include "ui/profile.h"
|
|
#include "ui/recent.h"
|
|
#include "wsutil/filesystem.h"
|
|
#include "epan/prefs.h"
|
|
|
|
#include <ui/qt/models/profile_model.h>
|
|
|
|
#include <ui/qt/utils/color_utils.h>
|
|
#include <ui/qt/utils/qt_ui_utils.h>
|
|
#include <ui/qt/utils/wireshark_zip_helper.h>
|
|
|
|
#include <QDir>
|
|
#include <QFont>
|
|
#include <QTemporaryDir>
|
|
|
|
Q_LOGGING_CATEGORY(profileLogger, "wireshark.profiles")
|
|
|
|
ProfileSortModel::ProfileSortModel(QObject * parent):
|
|
QSortFilterProxyModel (parent),
|
|
ft_(ProfileSortModel::AllProfiles),
|
|
ftext_(QString())
|
|
{}
|
|
|
|
bool ProfileSortModel::lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const
|
|
{
|
|
QModelIndex left = source_left;
|
|
if ( source_left.column() != ProfileModel::COL_NAME )
|
|
left = source_left.sibling(source_left.row(), ProfileModel::COL_NAME);
|
|
|
|
QModelIndex right = source_right;
|
|
if ( source_right.column() != ProfileModel::COL_NAME )
|
|
right = source_right.sibling(source_right.row(), ProfileModel::COL_NAME);
|
|
|
|
bool igL = left.data(ProfileModel::DATA_IS_GLOBAL).toBool();
|
|
bool igR = right.data(ProfileModel::DATA_IS_GLOBAL).toBool();
|
|
|
|
if (left.data(ProfileModel::DATA_STATUS).toInt() == PROF_STAT_DEFAULT)
|
|
igL = true;
|
|
if (right.data(ProfileModel::DATA_STATUS).toInt() == PROF_STAT_DEFAULT)
|
|
igR = true;
|
|
|
|
if ( igL && ! igR )
|
|
return true;
|
|
else if ( ! igL && igR )
|
|
return false;
|
|
else if ( igL && igR )
|
|
{
|
|
if (left.data(ProfileModel::DATA_STATUS) == PROF_STAT_DEFAULT)
|
|
return true;
|
|
}
|
|
|
|
if ( left.data().toString().compare(right.data().toString()) <= 0 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
void ProfileSortModel::setFilterType(FilterType ft)
|
|
{
|
|
ft_ = ft;
|
|
invalidateFilter();
|
|
}
|
|
|
|
void ProfileSortModel::setFilterString(QString txt)
|
|
{
|
|
ftext_ = ! txt.isEmpty() ? txt : "";
|
|
invalidateFilter();
|
|
}
|
|
|
|
QStringList ProfileSortModel::filterTypes()
|
|
{
|
|
QMap<int, QString> filter_types_;
|
|
filter_types_.insert(ProfileSortModel::AllProfiles, tr("All profiles"));
|
|
filter_types_.insert(ProfileSortModel::PersonalProfiles, tr("Personal profiles"));
|
|
filter_types_.insert(ProfileSortModel::GlobalProfiles, tr("Global profiles"));
|
|
|
|
return filter_types_.values();
|
|
}
|
|
|
|
bool ProfileSortModel::filterAcceptsRow(int source_row, const QModelIndex &) const
|
|
{
|
|
bool accept = true;
|
|
QModelIndex idx = sourceModel()->index(source_row, ProfileModel::COL_NAME);
|
|
|
|
if ( ft_ != ProfileSortModel::AllProfiles )
|
|
{
|
|
bool gl = idx.data(ProfileModel::DATA_IS_GLOBAL).toBool();
|
|
if ( ft_ == ProfileSortModel::PersonalProfiles && gl )
|
|
accept = false;
|
|
else if ( ft_ == ProfileSortModel::GlobalProfiles && ! gl )
|
|
accept = false;
|
|
}
|
|
|
|
if ( ftext_.length() > 0 )
|
|
{
|
|
QString name = idx.data().toString();
|
|
if ( ! name.contains(ftext_, Qt::CaseInsensitive) )
|
|
accept = false;
|
|
}
|
|
|
|
return accept;
|
|
}
|
|
|
|
ProfileModel::ProfileModel(QObject * parent) :
|
|
QAbstractTableModel(parent)
|
|
{
|
|
/* Store preset profile name */
|
|
set_profile_ = get_profile_name();
|
|
|
|
reset_default_ = false;
|
|
profiles_imported_ = false;
|
|
|
|
last_set_row_ = 0;
|
|
|
|
/* Set filenames for profiles */
|
|
GList *files, *file;
|
|
files = g_hash_table_get_keys(const_cast<GHashTable *>(allowed_profile_filenames()));
|
|
file = g_list_first(files);
|
|
while (file) {
|
|
profile_files_ << static_cast<char *>(file->data);
|
|
file = gxx_list_next(file);
|
|
}
|
|
g_list_free(files);
|
|
|
|
loadProfiles();
|
|
}
|
|
|
|
void ProfileModel::loadProfiles()
|
|
{
|
|
emit beginResetModel();
|
|
|
|
bool refresh = profiles_.count() > 0;
|
|
|
|
if ( refresh )
|
|
profiles_.clear();
|
|
else
|
|
init_profile_list();
|
|
|
|
GList *fl_entry = edited_profile_list();
|
|
while (fl_entry && fl_entry->data)
|
|
{
|
|
profiles_ << reinterpret_cast<profile_def *>(fl_entry->data);
|
|
fl_entry = gxx_list_next(fl_entry);
|
|
}
|
|
|
|
emit endResetModel();
|
|
}
|
|
|
|
GList * ProfileModel::entry(profile_def *ref) const
|
|
{
|
|
GList *fl_entry = edited_profile_list();
|
|
while (fl_entry && fl_entry->data)
|
|
{
|
|
profile_def *profile = reinterpret_cast<profile_def *>(fl_entry->data);
|
|
if ( QString(ref->name).compare(profile->name) == 0 &&
|
|
QString(ref->reference).compare(profile->reference) == 0 &&
|
|
ref->is_global == profile->is_global &&
|
|
ref->status == profile->status )
|
|
{
|
|
return fl_entry;
|
|
}
|
|
|
|
fl_entry = gxx_list_next(fl_entry);
|
|
}
|
|
|
|
return Q_NULLPTR;
|
|
}
|
|
|
|
GList *ProfileModel::at(int row) const
|
|
{
|
|
if ( row < 0 || row >= profiles_.count() )
|
|
return Q_NULLPTR;
|
|
|
|
profile_def * prof = profiles_.at(row);
|
|
return entry(prof);
|
|
}
|
|
|
|
bool ProfileModel::changesPending() const
|
|
{
|
|
if ( reset_default_ )
|
|
return true;
|
|
|
|
if ( g_list_length(edited_profile_list()) != g_list_length(current_profile_list()) )
|
|
return true;
|
|
|
|
bool pending = false;
|
|
GList *fl_entry = edited_profile_list();
|
|
while (fl_entry && fl_entry->data && ! pending) {
|
|
profile_def *profile = reinterpret_cast<profile_def *>(fl_entry->data);
|
|
pending = ( profile->status == PROF_STAT_NEW || profile->status == PROF_STAT_CHANGED || profile->status == PROF_STAT_COPY );
|
|
fl_entry = gxx_list_next(fl_entry);
|
|
}
|
|
|
|
return pending;
|
|
}
|
|
|
|
bool ProfileModel::importPending() const
|
|
{
|
|
return profiles_imported_;
|
|
}
|
|
|
|
bool ProfileModel::userProfilesExist() const
|
|
{
|
|
bool user_exists = false;
|
|
for ( int cnt = 0; cnt < rowCount() && ! user_exists; cnt++ )
|
|
{
|
|
QModelIndex idx = index(cnt, ProfileModel::COL_NAME);
|
|
if ( ! idx.data(ProfileModel::DATA_IS_GLOBAL).toBool() && ! idx.data(ProfileModel::DATA_IS_DEFAULT).toBool() )
|
|
user_exists = true;
|
|
}
|
|
|
|
return user_exists;
|
|
}
|
|
|
|
int ProfileModel::rowCount(const QModelIndex &) const
|
|
{
|
|
return profiles_.count();
|
|
}
|
|
|
|
int ProfileModel::columnCount(const QModelIndex &) const
|
|
{
|
|
return static_cast<int>(_LAST_ENTRY);
|
|
}
|
|
|
|
profile_def * ProfileModel::guard(const QModelIndex &index) const
|
|
{
|
|
if ( ! index.isValid() )
|
|
return Q_NULLPTR;
|
|
|
|
return guard(index.row());
|
|
}
|
|
|
|
profile_def * ProfileModel::guard(int row) const
|
|
{
|
|
if ( row < 0 || profiles_.count() <= row )
|
|
return Q_NULLPTR;
|
|
|
|
if ( ! edited_profile_list() )
|
|
{
|
|
static_cast<QList<profile_def *>>(profiles_).clear();
|
|
return Q_NULLPTR;
|
|
}
|
|
|
|
return profiles_.value(row, Q_NULLPTR);
|
|
}
|
|
|
|
QVariant ProfileModel::dataDisplay(const QModelIndex &index) const
|
|
{
|
|
profile_def * prof = guard(index);
|
|
if ( ! prof )
|
|
return QVariant();
|
|
|
|
switch (index.column())
|
|
{
|
|
case COL_NAME:
|
|
return QString(prof->name);
|
|
case COL_TYPE:
|
|
if ( prof->status == PROF_STAT_DEFAULT )
|
|
return tr("Default");
|
|
else if ( prof->is_global )
|
|
return tr("Global");
|
|
else
|
|
return tr("Personal");
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
QVariant ProfileModel::dataFontRole(const QModelIndex &index) const
|
|
{
|
|
if ( ! index.isValid() || profiles_.count() <= index.row() )
|
|
return QVariant();
|
|
|
|
profile_def * prof = guard(index.row());
|
|
if ( ! prof )
|
|
return QVariant();
|
|
|
|
QFont font;
|
|
|
|
if ( prof->is_global )
|
|
font.setItalic(true);
|
|
|
|
if ( ! prof->is_global && ! checkDuplicate(index) )
|
|
{
|
|
if ( ( set_profile_.compare(prof->name) == 0 && prof->status == PROF_STAT_EXISTS ) ||
|
|
( set_profile_.compare(prof->reference) == 0 && prof->status == PROF_STAT_CHANGED ) )
|
|
font.setBold(true);
|
|
}
|
|
|
|
if ( prof->status == PROF_STAT_DEFAULT && reset_default_ )
|
|
font.setStrikeOut(true);
|
|
|
|
return font;
|
|
}
|
|
|
|
bool ProfileModel::checkIfDeleted(int row) const
|
|
{
|
|
QModelIndex idx = index(row, ProfileModel::COL_NAME);
|
|
return checkIfDeleted(idx);
|
|
}
|
|
|
|
bool ProfileModel::checkIfDeleted(const QModelIndex &index) const
|
|
{
|
|
profile_def * prof = guard(index);
|
|
if ( ! prof )
|
|
return false;
|
|
|
|
QStringList deletedNames;
|
|
|
|
GList * current = current_profile_list();
|
|
|
|
/* search the current list as long as we have not found anything */
|
|
while ( current )
|
|
{
|
|
bool found = false;
|
|
GList * edited = edited_profile_list();
|
|
profile_def * profcurr = static_cast<profile_def *>(current->data);
|
|
|
|
if ( ! profcurr->is_global && profcurr->status != PROF_STAT_DEFAULT )
|
|
{
|
|
while ( edited && ! found )
|
|
{
|
|
profile_def * profed = static_cast<profile_def *>(edited->data);
|
|
if ( ! profed->is_global && profed->status != PROF_STAT_DEFAULT )
|
|
{
|
|
if ( g_strcmp0(profcurr->name, profed->name) == 0 || g_strcmp0(profcurr->name, profed->reference) == 0 )
|
|
{
|
|
if ( profed->status == profcurr->status && prof->status != PROF_STAT_NEW && prof->status != PROF_STAT_COPY )
|
|
found = true;
|
|
}
|
|
}
|
|
|
|
edited = gxx_list_next(edited);
|
|
}
|
|
|
|
/* profile has been deleted, check if it has the name we ask for */
|
|
if ( ! found )
|
|
deletedNames << profcurr->name;
|
|
}
|
|
|
|
current = gxx_list_next(current);
|
|
}
|
|
|
|
if ( deletedNames.contains(prof->name) )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ProfileModel::checkInvalid(const QModelIndex &index) const
|
|
{
|
|
profile_def * prof = guard(index);
|
|
if ( ! prof )
|
|
return false;
|
|
|
|
int ref = this->findAsReference(prof->name);
|
|
if ( ref == index.row() )
|
|
return false;
|
|
|
|
profile_def * pg = guard(ref);
|
|
if ( pg && pg->status == PROF_STAT_CHANGED && g_strcmp0(pg->name, pg->reference) != 0 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ProfileModel::checkDuplicate(const QModelIndex &index, bool isOriginalToDuplicate) const
|
|
{
|
|
profile_def * prof = guard(index);
|
|
if ( ! prof || ( ! isOriginalToDuplicate && prof->status == PROF_STAT_EXISTS ) )
|
|
return false;
|
|
|
|
QList<int> rows = this->findAllByNameAndVisibility(prof->name, prof->is_global, false);
|
|
int found = 0;
|
|
profile_def * check = Q_NULLPTR;
|
|
for(int cnt = 0; cnt < rows.count(); cnt++)
|
|
{
|
|
int row = rows.at(cnt);
|
|
|
|
if ( row == index.row() )
|
|
continue;
|
|
|
|
check = guard(row);
|
|
if ( ! check || ( isOriginalToDuplicate && check->status == PROF_STAT_EXISTS ) )
|
|
continue;
|
|
|
|
found++;
|
|
}
|
|
|
|
if ( found > 0 )
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
QVariant ProfileModel::dataBackgroundRole(const QModelIndex &index) const
|
|
{
|
|
if ( ! index.isValid() || profiles_.count() <= index.row() )
|
|
return QVariant();
|
|
|
|
profile_def * prof = guard(index.row());
|
|
if ( ! prof )
|
|
return QVariant();
|
|
|
|
if ( prof->status == PROF_STAT_DEFAULT && reset_default_ )
|
|
return ColorUtils::fromColorT(&prefs.gui_text_deprecated);
|
|
|
|
if ( prof->status != PROF_STAT_DEFAULT && ! prof->is_global )
|
|
{
|
|
/* Highlights errorneous line */
|
|
if ( checkInvalid(index) || checkIfDeleted(index) || checkDuplicate(index) || ! checkNameValidity(prof->name) )
|
|
return ColorUtils::fromColorT(&prefs.gui_text_invalid);
|
|
|
|
/* Highlights line, which has been duplicated by another index */
|
|
if ( checkDuplicate(index, true) )
|
|
return ColorUtils::fromColorT(&prefs.gui_text_valid);
|
|
}
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
QVariant ProfileModel::dataToolTipRole(const QModelIndex &idx) const
|
|
{
|
|
if ( ! idx.isValid() || profiles_.count() <= idx.row() )
|
|
return QVariant();
|
|
|
|
profile_def * prof = guard(idx.row());
|
|
if ( ! prof )
|
|
return QVariant();
|
|
|
|
if (prof->is_global)
|
|
return tr("This is a system provided profile");
|
|
else
|
|
return dataPath(idx);
|
|
}
|
|
|
|
QVariant ProfileModel::dataPath(const QModelIndex &index) const
|
|
{
|
|
if ( ! index.isValid() || profiles_.count() <= index.row() )
|
|
return QVariant();
|
|
|
|
profile_def * prof = guard(index.row());
|
|
if ( ! prof )
|
|
return QVariant();
|
|
|
|
if ( checkInvalid(index) )
|
|
{
|
|
int ref = this->findAsReference(prof->name);
|
|
if ( ref != index.row() && ref >= 0 )
|
|
{
|
|
profile_def * prof = guard(ref);
|
|
QString msg = tr("A profile change for this name is pending");
|
|
if ( prof )
|
|
msg.append(tr(" (See: %1)").arg(prof->name));
|
|
return msg;
|
|
}
|
|
|
|
return tr("This is an invalid profile definition");
|
|
}
|
|
|
|
if ( ( prof->status == PROF_STAT_NEW || prof->status == PROF_STAT_CHANGED || prof->status == PROF_STAT_COPY ) && checkDuplicate(index) )
|
|
return tr("A profile already exists with this name");
|
|
|
|
if ( checkIfDeleted(index) )
|
|
{
|
|
return tr("A profile with this name is being deleted");
|
|
}
|
|
|
|
if ( prof->is_import )
|
|
return tr("Imported profile");
|
|
|
|
switch (prof->status)
|
|
{
|
|
case PROF_STAT_DEFAULT:
|
|
if (!reset_default_)
|
|
return gchar_free_to_qstring(get_persconffile_path("", FALSE));
|
|
else
|
|
return tr("Resetting to default");
|
|
case PROF_STAT_EXISTS:
|
|
{
|
|
QString profile_path;
|
|
if (prof->is_global) {
|
|
profile_path = gchar_free_to_qstring(get_global_profiles_dir());
|
|
} else {
|
|
profile_path = gchar_free_to_qstring(get_profiles_dir());
|
|
}
|
|
profile_path.append(QDir::separator()).append(prof->name);
|
|
return profile_path;
|
|
}
|
|
case PROF_STAT_NEW:
|
|
{
|
|
QString errMsg;
|
|
|
|
if ( ! checkNameValidity(prof->name, &errMsg) )
|
|
return errMsg;
|
|
else
|
|
return tr("Created from default settings");
|
|
}
|
|
case PROF_STAT_CHANGED:
|
|
{
|
|
QString msg;
|
|
if ( ! ProfileModel::checkNameValidity(QString(prof->name), &msg) )
|
|
return msg;
|
|
|
|
if (prof->reference)
|
|
return tr("Renamed from: %1").arg(prof->reference);
|
|
|
|
return QVariant();
|
|
}
|
|
case PROF_STAT_COPY:
|
|
{
|
|
QString msg;
|
|
|
|
/* this should always be the case, but just as a precaution it is checked */
|
|
if (prof->reference)
|
|
{
|
|
msg = tr("Copied from: %1").arg(prof->reference);
|
|
QString appendix;
|
|
|
|
/* A global profile is neither deleted or removed, only system provided is allowed as appendix */
|
|
if ( profile_exists(prof->reference, TRUE) && prof->from_global )
|
|
appendix = tr("system provided");
|
|
/* A default model as reference can neither be deleted or renamed, so skip if the reference was one */
|
|
else if ( ! index.data(ProfileModel::DATA_IS_DEFAULT).toBool() )
|
|
{
|
|
/* find a non-global, non-default profile which could be referenced by this one. Those are the only
|
|
* ones which could be renamed or deleted */
|
|
int row = this->findByNameAndVisibility(prof->reference, false, true);
|
|
profile_def * ref = guard(row);
|
|
|
|
/* The reference is itself a copy of the original, therefore it is not accepted */
|
|
if ( ref && ( ref->status == PROF_STAT_COPY || ref->status == PROF_STAT_NEW ) && QString(ref->name).compare(prof->reference) != 0 )
|
|
ref = Q_NULLPTR;
|
|
|
|
/* found no other profile, original one had to be deleted */
|
|
if ( ! ref || row == index.row() || checkIfDeleted(row) )
|
|
{
|
|
appendix = tr("deleted");
|
|
}
|
|
/* found another profile, so the reference had been renamed, it the status is changed */
|
|
else if ( ref && ref->status == PROF_STAT_CHANGED )
|
|
{
|
|
appendix = tr("renamed to %1").arg(ref->name);
|
|
}
|
|
}
|
|
|
|
if ( appendix.length() > 0 )
|
|
msg.append(QString(" (%1)").arg(appendix));
|
|
}
|
|
|
|
return msg;
|
|
}
|
|
}
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
QVariant ProfileModel::data(const QModelIndex &index, int role) const
|
|
{
|
|
profile_def * prof = guard(index);
|
|
if ( ! prof )
|
|
return QVariant();
|
|
|
|
switch ( role )
|
|
{
|
|
case Qt::DisplayRole:
|
|
return dataDisplay(index);
|
|
case Qt::FontRole:
|
|
return dataFontRole(index);
|
|
case Qt::BackgroundColorRole:
|
|
return dataBackgroundRole(index);
|
|
case Qt::ToolTipRole:
|
|
return dataToolTipRole(index);
|
|
case ProfileModel::DATA_STATUS:
|
|
return qVariantFromValue(prof->status);
|
|
case ProfileModel::DATA_IS_DEFAULT:
|
|
return qVariantFromValue(prof->status == PROF_STAT_DEFAULT);
|
|
case ProfileModel::DATA_IS_GLOBAL:
|
|
return qVariantFromValue(prof->is_global);
|
|
case ProfileModel::DATA_IS_SELECTED:
|
|
{
|
|
QModelIndex selected = activeProfile();
|
|
profile_def * selprof = guard(selected);
|
|
if ( selprof )
|
|
{
|
|
if ( selprof && selprof->is_global != prof->is_global )
|
|
return qVariantFromValue(false);
|
|
|
|
if ( selprof && strcmp(selprof->name, prof->name) == 0 )
|
|
return qVariantFromValue(true);
|
|
}
|
|
return qVariantFromValue(false);
|
|
}
|
|
case ProfileModel::DATA_PATH:
|
|
return dataPath(index);
|
|
case ProfileModel::DATA_INDEX_VALUE_IS_URL:
|
|
if ( index.column() <= ProfileModel::COL_TYPE )
|
|
return qVariantFromValue(false);
|
|
return qVariantFromValue(true);
|
|
case ProfileModel::DATA_PATH_IS_NOT_DESCRIPTION:
|
|
if ( prof->status == PROF_STAT_NEW || prof->status == PROF_STAT_COPY
|
|
|| ( prof->status == PROF_STAT_DEFAULT && reset_default_ )
|
|
|| prof->status == PROF_STAT_CHANGED || prof->is_import )
|
|
return qVariantFromValue(false);
|
|
else
|
|
return qVariantFromValue(true);
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
QVariant ProfileModel::headerData(int section, Qt::Orientation orientation, int role) const
|
|
{
|
|
if ( orientation == Qt::Horizontal && role == Qt::DisplayRole )
|
|
{
|
|
switch (section)
|
|
{
|
|
case COL_NAME:
|
|
return tr("Profile");
|
|
case COL_TYPE:
|
|
return tr("Type");
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
Qt::ItemFlags ProfileModel::flags(const QModelIndex &index) const
|
|
{
|
|
Qt::ItemFlags fl = QAbstractTableModel::flags(index);
|
|
|
|
profile_def * prof = guard(index);
|
|
if ( ! prof )
|
|
return fl;
|
|
|
|
if ( index.column() == ProfileModel::COL_NAME && prof->status != PROF_STAT_DEFAULT && ! prof->is_global )
|
|
fl |= Qt::ItemIsEditable;
|
|
|
|
return fl;
|
|
}
|
|
|
|
int ProfileModel::findByName(QString name)
|
|
{
|
|
int row = findByNameAndVisibility(name, false);
|
|
if ( row < 0 )
|
|
row = findByNameAndVisibility(name, true);
|
|
|
|
return row;
|
|
}
|
|
|
|
int ProfileModel::findAsReference(QString reference) const
|
|
{
|
|
int found = -1;
|
|
if ( reference.length() <= 0 )
|
|
return found;
|
|
|
|
for ( int cnt = 0; cnt < profiles_.count() && found < 0; cnt++ )
|
|
{
|
|
profile_def * prof = guard(cnt);
|
|
if ( prof && reference.compare(prof->reference) == 0 )
|
|
found = cnt;
|
|
}
|
|
|
|
return found;
|
|
}
|
|
|
|
int ProfileModel::findByNameAndVisibility(QString name, bool isGlobal, bool searchReference) const
|
|
{
|
|
QList<int> result = findAllByNameAndVisibility(name, isGlobal, searchReference);
|
|
return result.count() == 0 ? -1 : result.at(0);
|
|
}
|
|
|
|
QList<int> ProfileModel::findAllByNameAndVisibility(QString name, bool isGlobal, bool searchReference) const
|
|
{
|
|
QList<int> result;
|
|
|
|
for ( int cnt = 0; cnt < profiles_.count(); cnt++ )
|
|
{
|
|
profile_def * prof = guard(cnt);
|
|
if ( prof && static_cast<bool>(prof->is_global) == isGlobal )
|
|
{
|
|
if ( name.compare(prof->name) == 0 || ( searchReference && name.compare(prof->reference) == 0 ) )
|
|
result << cnt;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
QModelIndex ProfileModel::addNewProfile(QString name)
|
|
{
|
|
int cnt = 1;
|
|
QString newName = name;
|
|
while(findByNameAndVisibility(newName) >= 0)
|
|
{
|
|
newName = QString("%1 %2").arg(name).arg(QString::number(cnt));
|
|
cnt++;
|
|
}
|
|
|
|
add_to_profile_list(newName.toUtf8().constData(), newName.toUtf8().constData(), PROF_STAT_NEW, FALSE, FALSE, FALSE);
|
|
loadProfiles();
|
|
|
|
return index(findByName(newName), COL_NAME);
|
|
}
|
|
|
|
QModelIndex ProfileModel::duplicateEntry(QModelIndex idx, int new_status)
|
|
{
|
|
profile_def * prof = guard(idx);
|
|
if ( ! prof )
|
|
return QModelIndex();
|
|
|
|
/* only new and copied stati can be set */
|
|
if ( new_status != PROF_STAT_NEW && new_status != PROF_STAT_COPY )
|
|
new_status = PROF_STAT_COPY;
|
|
|
|
/* this is a copy from a personal profile, check if the original has been a
|
|
* new profile or a preexisting one. In the case of a new profile, restart
|
|
* with the state PROF_STAT_NEW */
|
|
if ( prof->status == PROF_STAT_COPY && ! prof->from_global )
|
|
{
|
|
int row = findByNameAndVisibility(prof->reference, false);
|
|
profile_def * copyParent = guard(row);
|
|
if ( copyParent && copyParent->status == PROF_STAT_NEW )
|
|
return duplicateEntry(index(row, ProfileModel::COL_NAME), PROF_STAT_NEW);
|
|
}
|
|
|
|
/* Rules for figuring out the name to copy from:
|
|
*
|
|
* General, use copy name
|
|
* If status of copy is new or changed => use copy reference
|
|
* If copy is non global and status of copy is != changed, use original parent name
|
|
*/
|
|
QString parent = prof->name;
|
|
if ( prof->status == PROF_STAT_CHANGED )
|
|
parent = prof->reference;
|
|
else if ( ! prof->is_global && prof->status != PROF_STAT_NEW && prof->status != PROF_STAT_CHANGED )
|
|
parent = get_profile_parent (prof->name);
|
|
|
|
if ( parent.length() == 0 )
|
|
return QModelIndex();
|
|
|
|
/* parent references the parent profile to be used, parentName is the base for the new name */
|
|
QString parentName = parent;
|
|
/* the user has changed the profile name, therefore this is also the name to be used */
|
|
if ( prof->status != PROF_STAT_EXISTS )
|
|
parentName = prof->name;
|
|
|
|
/* check to ensure we do not end up with (copy) (copy) (copy) ... */
|
|
QRegExp rx("\\s+(\\(\\s*" + tr("copy", "noun") + "\\s*\\d*\\))");
|
|
if ( rx.indexIn(parentName) >= 0 )
|
|
parentName.replace(rx, "");
|
|
|
|
QString new_name;
|
|
/* if copy is global and name has not been used before, use that, else create first copy */
|
|
if (prof->is_global && findByNameAndVisibility(parentName) < 0)
|
|
new_name = QString(prof->name);
|
|
else
|
|
new_name = QString("%1 (%2)").arg(parentName).arg(tr("copy", "noun"));
|
|
|
|
/* check if copy already exists and iterate, until an unused version is found */
|
|
int cnt = 1;
|
|
while(findByNameAndVisibility(new_name) >= 0)
|
|
{
|
|
new_name = QString("%1 (%2 %3)").arg(parentName).arg(tr("copy", "noun")).arg(QString::number(cnt));
|
|
cnt++;
|
|
}
|
|
|
|
/* if this would be a copy, but the original is already a new one, this is a copy as well */
|
|
if ( new_status == PROF_STAT_COPY && prof->status == PROF_STAT_NEW )
|
|
new_status = PROF_STAT_NEW;
|
|
|
|
/* add element */
|
|
add_to_profile_list(new_name.toUtf8().constData(), parent.toUtf8().constData(), new_status, FALSE, prof->from_global ? prof->from_global : prof->is_global, FALSE);
|
|
|
|
/* reload profile list in model */
|
|
loadProfiles();
|
|
|
|
int row = findByNameAndVisibility(new_name, false);
|
|
/* sanity check, if adding the profile went correctly */
|
|
if ( row < 0 || row == idx.row() )
|
|
return QModelIndex();
|
|
|
|
/* return the index of the profile */
|
|
return index(row, COL_NAME);
|
|
}
|
|
|
|
void ProfileModel::deleteEntry(QModelIndex idx)
|
|
{
|
|
if ( ! idx.isValid() )
|
|
return;
|
|
|
|
QModelIndexList temp;
|
|
temp << idx;
|
|
deleteEntries(temp);
|
|
}
|
|
|
|
void ProfileModel::deleteEntries(QModelIndexList idcs)
|
|
{
|
|
bool changes = false;
|
|
|
|
QList<int> indeces;
|
|
foreach ( QModelIndex idx, idcs )
|
|
{
|
|
if ( ! indeces.contains(idx.row()) && ! idx.data(ProfileModel::DATA_IS_GLOBAL).toBool() )
|
|
indeces << idx.row();
|
|
}
|
|
/* Security blanket. This ensures, that we start deleting from the end and do not get any issues iterating the list */
|
|
std::sort(indeces.begin(), indeces.end(), std::less<int>());
|
|
|
|
foreach ( int row, indeces )
|
|
{
|
|
profile_def * prof = guard(row);
|
|
if ( ! prof )
|
|
continue;
|
|
|
|
if ( prof->is_global )
|
|
continue;
|
|
|
|
if ( prof->status == PROF_STAT_DEFAULT )
|
|
{
|
|
reset_default_ = ! reset_default_;
|
|
}
|
|
else
|
|
{
|
|
GList * fl_entry = entry(prof);
|
|
if ( fl_entry )
|
|
{
|
|
changes = true;
|
|
remove_from_profile_list(fl_entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( changes )
|
|
loadProfiles();
|
|
|
|
if ( reset_default_ )
|
|
{
|
|
emit layoutAboutToBeChanged();
|
|
emit dataChanged(index(0, 0), index(rowCount(), columnCount()));
|
|
emit layoutChanged();
|
|
}
|
|
}
|
|
|
|
bool ProfileModel::resetDefault() const
|
|
{
|
|
return reset_default_;
|
|
}
|
|
|
|
void ProfileModel::doResetModel(bool reset_import)
|
|
{
|
|
reset_default_ = false;
|
|
if ( reset_import )
|
|
profiles_imported_ = false;
|
|
|
|
loadProfiles();
|
|
}
|
|
|
|
QModelIndex ProfileModel::activeProfile() const
|
|
{
|
|
QList<int> rows = this->findAllByNameAndVisibility(set_profile_, false, true);
|
|
foreach ( int row, rows )
|
|
{
|
|
profile_def * prof = profiles_.at(row);
|
|
if ( prof->is_global || checkDuplicate(index(row, ProfileModel::COL_NAME) ) )
|
|
return QModelIndex();
|
|
|
|
if ( ( set_profile_.compare(prof->name) == 0 && ( prof->status == PROF_STAT_EXISTS || prof->status == PROF_STAT_DEFAULT ) ) ||
|
|
( set_profile_.compare(prof->reference) == 0 && prof->status == PROF_STAT_CHANGED ) )
|
|
return index(row, ProfileModel::COL_NAME);
|
|
}
|
|
|
|
return QModelIndex();
|
|
}
|
|
|
|
bool ProfileModel::setData(const QModelIndex &idx, const QVariant &value, int role)
|
|
{
|
|
last_set_row_ = -1;
|
|
|
|
if ( role != Qt::EditRole || ! value.isValid() || value.toString().isEmpty() )
|
|
return false;
|
|
|
|
QString newValue = value.toString();
|
|
profile_def * prof = guard(idx);
|
|
if ( ! prof || prof->status == PROF_STAT_DEFAULT )
|
|
return false;
|
|
|
|
last_set_row_ = idx.row();
|
|
|
|
QString current(prof->name);
|
|
if ( current.compare(newValue) != 0 )
|
|
{
|
|
g_free(prof->name);
|
|
prof->name = qstring_strdup(newValue);
|
|
|
|
if (prof->reference && g_strcmp0(prof->name, prof->reference) == 0 && ! ( prof->status == PROF_STAT_NEW || prof->status == PROF_STAT_COPY )) {
|
|
prof->status = PROF_STAT_EXISTS;
|
|
} else if (prof->status == PROF_STAT_EXISTS) {
|
|
prof->status = PROF_STAT_CHANGED;
|
|
}
|
|
emit itemChanged(idx);
|
|
}
|
|
|
|
loadProfiles();
|
|
|
|
return true;
|
|
}
|
|
|
|
int ProfileModel::lastSetRow() const
|
|
{
|
|
return last_set_row_;
|
|
}
|
|
|
|
bool ProfileModel::copyTempToProfile(QString tempPath, QString profilePath, bool * wasEmpty)
|
|
{
|
|
bool was_empty = true;
|
|
|
|
QDir profileDir(profilePath);
|
|
if ( ! profileDir.mkpath(profilePath) || ! QFile::exists(tempPath) )
|
|
return false;
|
|
|
|
QDir tempProfile(tempPath);
|
|
tempProfile.setFilter(QDir::Files | QDir::Hidden | QDir::NoSymLinks);
|
|
QFileInfoList files = tempProfile.entryInfoList();
|
|
if ( files.count() <= 0 )
|
|
return false;
|
|
|
|
int created = 0;
|
|
foreach ( QFileInfo finfo, files)
|
|
{
|
|
QString tempFile = finfo.absoluteFilePath();
|
|
QString profileFile = profilePath + QDir::separator() + finfo.fileName();
|
|
|
|
if ( ! profile_files_.contains(finfo.fileName()) )
|
|
{
|
|
was_empty = false;
|
|
continue;
|
|
}
|
|
|
|
if ( ! QFile::exists(tempFile) || QFile::exists(profileFile) )
|
|
continue;
|
|
|
|
if ( QFile::copy(tempFile, profileFile) )
|
|
created++;
|
|
}
|
|
|
|
if ( wasEmpty )
|
|
*wasEmpty = was_empty;
|
|
|
|
if ( created > 0 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
QFileInfoList ProfileModel::uniquePaths(QFileInfoList lst)
|
|
{
|
|
QStringList files;
|
|
QFileInfoList newLst;
|
|
|
|
foreach ( QFileInfo entry, lst )
|
|
{
|
|
if ( ! files.contains(entry.absoluteFilePath()) )
|
|
{
|
|
if ( entry.exists() && entry.isDir() )
|
|
{
|
|
newLst << entry.absoluteFilePath();
|
|
files << entry.absoluteFilePath();
|
|
}
|
|
}
|
|
}
|
|
|
|
return newLst;
|
|
}
|
|
|
|
QFileInfoList ProfileModel::filterProfilePath(QString path, QFileInfoList ent, bool fromZip)
|
|
{
|
|
QFileInfoList result = ent;
|
|
QDir temp(path);
|
|
temp.setSorting(QDir::Name);
|
|
temp.setFilter(QDir::Dirs | QDir::NoSymLinks | QDir::NoDotAndDotDot);
|
|
QFileInfoList entries = temp.entryInfoList();
|
|
if ( ! fromZip )
|
|
entries << QFileInfo(path);
|
|
foreach ( QFileInfo entry, entries )
|
|
{
|
|
QDir fPath(entry.absoluteFilePath());
|
|
fPath.setSorting(QDir::Name);
|
|
fPath.setFilter(QDir::Files | QDir::NoSymLinks);
|
|
QFileInfoList fEntries = fPath.entryInfoList();
|
|
bool found = false;
|
|
for ( int cnt = 0; cnt < fEntries.count() && ! found; cnt++)
|
|
{
|
|
if ( config_file_exists_with_entries(fEntries[cnt].absoluteFilePath().toUtf8().constData(), '#') )
|
|
found = true;
|
|
}
|
|
|
|
if ( found )
|
|
{
|
|
result.append(entry);
|
|
}
|
|
else
|
|
{
|
|
if ( path.compare(entry.absoluteFilePath()) != 0 )
|
|
result.append(filterProfilePath(entry.absoluteFilePath(), result, fromZip));
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
#ifdef HAVE_MINIZIP
|
|
QStringList ProfileModel::exportFileList(QModelIndexList items)
|
|
{
|
|
QStringList result;
|
|
|
|
foreach(QModelIndex idx, items)
|
|
{
|
|
profile_def * prof = guard(idx);
|
|
if ( ! prof || prof->is_global || QString(prof->name).compare(DEFAULT_PROFILE) == 0 )
|
|
continue;
|
|
|
|
if ( ! idx.data(ProfileModel::DATA_PATH_IS_NOT_DESCRIPTION).toBool() )
|
|
continue;
|
|
|
|
QString path = idx.data(ProfileModel::DATA_PATH).toString();
|
|
QDir temp(path);
|
|
temp.setSorting(QDir::Name);
|
|
temp.setFilter(QDir::Files | QDir::NoSymLinks | QDir::NoDotAndDotDot);
|
|
QFileInfoList entries = temp.entryInfoList();
|
|
foreach ( QFileInfo fi, entries )
|
|
result << fi.absoluteFilePath();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool ProfileModel::exportProfiles(QString filename, QModelIndexList items, QString *err)
|
|
{
|
|
if ( changesPending() )
|
|
{
|
|
if ( err )
|
|
err->append(tr("Exporting profiles while changes are pending is not allowed"));
|
|
return false;
|
|
}
|
|
|
|
/* Write recent file for current profile before exporting */
|
|
write_profile_recent();
|
|
|
|
QStringList files = exportFileList(items);
|
|
if ( files.count() == 0 )
|
|
{
|
|
if ( err )
|
|
err->append((tr("No profiles found to export")));
|
|
return false;
|
|
}
|
|
|
|
if ( WireSharkZipHelper::zip(filename, files, gchar_free_to_qstring(get_profiles_dir()) + QDir::separator() ) )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
/* This check runs BEFORE the file has been unzipped! */
|
|
bool ProfileModel::acceptFile(QString fileName, int fileSize)
|
|
{
|
|
if ( fileName.toLower().endsWith(".zip") )
|
|
return false;
|
|
|
|
if ( fileSize > 1024 * 512 )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
QString ProfileModel::cleanName(QString fileName)
|
|
{
|
|
QStringList parts = fileName.split(QDir::separator());
|
|
QString temp = parts[parts.count() - 1].replace( QRegExp( "[" + QRegExp::escape( illegalCharacters() ) + "]" ), QString( "_" ) );
|
|
temp = parts.join(QDir::separator());
|
|
return temp;
|
|
}
|
|
|
|
int ProfileModel::importProfilesFromZip(QString filename, int * skippedCnt, QStringList *result)
|
|
{
|
|
QTemporaryDir dir;
|
|
#if 0
|
|
dir.setAutoRemove(false);
|
|
g_printerr("Temp dir for unzip: %s\n", dir.path().toUtf8().constData());
|
|
#endif
|
|
|
|
int cnt = 0;
|
|
if ( dir.isValid() )
|
|
{
|
|
WireSharkZipHelper::unzip(filename, dir.path(), &ProfileModel::acceptFile, &ProfileModel::cleanName);
|
|
cnt = importProfilesFromDir(dir.path(), skippedCnt, true, result);
|
|
}
|
|
|
|
return cnt;
|
|
}
|
|
#endif
|
|
|
|
int ProfileModel::importProfilesFromDir(QString dirname, int * skippedCnt, bool fromZip, QStringList *result)
|
|
{
|
|
int count = 0;
|
|
int skipped = 0;
|
|
QDir profileDir(gchar_free_to_qstring(get_profiles_dir()));
|
|
QDir dir(dirname);
|
|
|
|
if ( skippedCnt )
|
|
*skippedCnt = 0;
|
|
|
|
if ( dir.exists() )
|
|
{
|
|
QFileInfoList entries = uniquePaths(filterProfilePath(dirname, QFileInfoList(), fromZip));
|
|
|
|
int entryCount = 0;
|
|
foreach ( QFileInfo fentry, entries )
|
|
{
|
|
Q_ASSERT(fentry.fileName().length() > 0);
|
|
bool wasEmpty = true;
|
|
bool success = false;
|
|
|
|
entryCount++;
|
|
|
|
QString profilePath = profileDir.absolutePath() + QDir::separator() + fentry.fileName();
|
|
QString tempPath = fentry.absoluteFilePath();
|
|
|
|
if ( fentry.fileName().compare(DEFAULT_PROFILE, Qt::CaseInsensitive) == 0 || QFile::exists(profilePath) )
|
|
{
|
|
skipped++;
|
|
continue;
|
|
}
|
|
|
|
if ( result )
|
|
*result << fentry.fileName();
|
|
|
|
success = copyTempToProfile(tempPath, profilePath, &wasEmpty);
|
|
if ( success )
|
|
{
|
|
count++;
|
|
add_to_profile_list(fentry.fileName().toUtf8().constData(), fentry.fileName().toUtf8().constData(), PROF_STAT_NEW, FALSE, FALSE, TRUE);
|
|
}
|
|
else if ( ! wasEmpty && QFile::exists(profilePath) )
|
|
{
|
|
QDir dh(profilePath);
|
|
dh.rmdir(profilePath);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
if ( count > 0 )
|
|
{
|
|
profiles_imported_ = true;
|
|
loadProfiles();
|
|
}
|
|
|
|
if ( skippedCnt )
|
|
*skippedCnt = skipped;
|
|
|
|
return count;
|
|
}
|
|
|
|
void ProfileModel::markAsImported(QStringList importedItems)
|
|
{
|
|
if ( importedItems.count() <= 0 )
|
|
return;
|
|
|
|
profiles_imported_ = true;
|
|
|
|
foreach ( QString item, importedItems )
|
|
{
|
|
int row = findByNameAndVisibility(item, false);
|
|
profile_def * prof = guard(row);
|
|
if ( ! prof )
|
|
continue;
|
|
|
|
prof->is_import = true;
|
|
}
|
|
}
|
|
|
|
bool ProfileModel::clearImported(QString *msg)
|
|
{
|
|
QList<int> rows;
|
|
bool result = true;
|
|
for ( int cnt = 0; cnt < rowCount(); cnt++ )
|
|
{
|
|
profile_def * prof = guard(cnt);
|
|
if ( prof && prof->is_import && ! rows.contains(cnt) )
|
|
rows << cnt;
|
|
}
|
|
/* Security blanket. This ensures, that we start deleting from the end and do not get any issues iterating the list */
|
|
std::sort(rows.begin(), rows.end(), std::less<int>());
|
|
|
|
char * ret_path = Q_NULLPTR;
|
|
for ( int cnt = 0; cnt < rows.count() && result; cnt++ )
|
|
{
|
|
int row = rows.at(cnt);
|
|
if ( delete_persconffile_profile ( index(row, ProfileModel::COL_NAME).data().toString().toUtf8().constData(), &ret_path ) != 0 )
|
|
{
|
|
if ( msg )
|
|
{
|
|
QString errmsg = QString("%1\n\"%2\":\n%3").arg(tr("Can't delete profile directory")).arg(ret_path).arg(g_strerror(errno));
|
|
msg->append(errmsg);
|
|
}
|
|
|
|
result = false;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
QString ProfileModel::illegalCharacters()
|
|
{
|
|
#ifdef _WIN32
|
|
/* According to https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions */
|
|
return QString("<>:\"/\\|?*");
|
|
#else
|
|
return QDir::separator();
|
|
#endif
|
|
|
|
}
|
|
|
|
bool ProfileModel::checkNameValidity(QString name, QString *msg)
|
|
{
|
|
QString message;
|
|
bool invalid = false;
|
|
QString msgChars;
|
|
|
|
QString invalid_dir_chars = illegalCharacters();
|
|
|
|
for ( int cnt = 0; cnt < invalid_dir_chars.length() && ! invalid; cnt++ )
|
|
{
|
|
msgChars += invalid_dir_chars[cnt] + " ";
|
|
if ( name.contains(invalid_dir_chars[cnt]) )
|
|
invalid = true;
|
|
}
|
|
#ifdef _WIN32
|
|
if ( invalid )
|
|
{
|
|
message = tr("A profile name cannot contain the following characters: %1").arg(msgChars);
|
|
}
|
|
|
|
if ( message.isEmpty() && ( name.startsWith('.') || name.endsWith('.') ) )
|
|
message = tr("A profile cannot start or end with a period (.)");
|
|
#else
|
|
if ( invalid )
|
|
message = tr("A profile name cannot contain the '/' character");
|
|
#endif
|
|
|
|
if (! message.isEmpty()) {
|
|
if (msg)
|
|
msg->append(message);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
QString ProfileModel::activeProfileName()
|
|
{
|
|
ProfileModel model;
|
|
QModelIndex idx = model.activeProfile();
|
|
return idx.data(ProfileModel::COL_NAME).toString();
|
|
}
|
|
|
|
QString ProfileModel::activeProfilePath()
|
|
{
|
|
ProfileModel model;
|
|
QModelIndex idx = model.activeProfile();
|
|
return idx.data(ProfileModel::DATA_PATH).toString();
|
|
}
|
|
|
|
/*
|
|
* Editor modelines
|
|
*
|
|
* Local Variables:
|
|
* c-basic-offset: 4
|
|
* tab-width: 8
|
|
* indent-tabs-mode: nil
|
|
* End:
|
|
*
|
|
* ex: set shiftwidth=4 tabstop=8 expandtab:
|
|
* :indentSize=4:tabSize=8:noTabs=true:
|
|
*/
|