guint
fill_advanced_prefs(module_t *module, gpointer root_ptr)
{
QTreeWidgetItem *root_item = static_cast<QTreeWidgetItem *>(root_ptr);
if (!module || !root_item) return 1;
if (module->numprefs < 1 && !prefs_module_has_submodules(module)) return 0;
QString module_title = module->title;
QTreeWidgetItem *tl_item = new QTreeWidgetItem(root_item);
tl_item->setText(0, module_title);
tl_item->setToolTip(0, QString("<span>%1</span>").arg(module->description));
tl_item->setFirstColumnSpanned(true);
QList<QTreeWidgetItem *>tl_children;
for (GList *pref_l = module->prefs; pref_l && pref_l->data; pref_l = g_list_next(pref_l)) {
pref_t *pref = (pref_t *) pref_l->data;
if (pref->type == PREF_OBSOLETE || pref->type == PREF_STATIC_TEXT) continue;
const char *type_name = prefs_pref_type_name(pref);
if (!type_name) continue;
pref_stash(pref, NULL);
QTreeWidgetItem *item = new QTreeWidgetItem();
QString full_name = QString(module->name ? module->name : module->parent->name) + "." + pref->name;
QString type_desc = gchar_free_to_qstring(prefs_pref_type_description(pref));
QString default_value = gchar_free_to_qstring(prefs_pref_to_str(pref, pref_stashed));
item->setData(0, Qt::UserRole, qVariantFromValue(pref));
item->setText(0, full_name);
item->setToolTip(0, QString("<span>%1</span>").arg(pref->description));
item->setToolTip(1, QObject::tr("Has this preference been changed?"));
item->setText(2, type_name);
item->setToolTip(2, QString("<span>%1</span>").arg(type_desc));
item->setToolTip(3, QString("<span>%1</span>").arg(
default_value.isEmpty() ? default_value : QObject::tr("Default value is empty")));
tl_children << item;
// .uat is a void * so it wins the "useful key value" prize.
if (pref->varp.uat) {
pref_ptr_to_pref_[pref->varp.uat] = pref;
}
}
tl_item->addChildren(tl_children);
if(prefs_module_has_submodules(module))
return prefs_modules_foreach_submodules(module, fill_advanced_prefs, tl_item);
return 0;
}
void PreferencesDialog::updateItem(QTreeWidgetItem &item)
{
pref_t *pref = item.data(pref_ptr_col_, Qt::UserRole).value<pref_t *>();
if (!pref) return;
QString cur_value = gchar_free_to_qstring(prefs_pref_to_str(pref, pref_stashed)).remove(QRegExp("\n\t"));
bool is_changed = false;
QFont font = item.font(0);
if (pref->type == PREF_UAT || pref->type == PREF_CUSTOM) {
item.setText(1, tr("Unknown"));
} else if (stashedPrefIsDefault(pref)) {
item.setText(1, tr("Default"));
} else {
item.setText(1, tr("Changed"));
is_changed = true;
}
font.setBold(is_changed);
item.setFont(0, font);
item.setFont(0, font);
item.setFont(1, font);
item.setFont(2, font);
item.setFont(3, font);
item.setText(3, cur_value);
}
void WiresharkApplication::helpTopicAction(topic_action_e action)
{
QString url = gchar_free_to_qstring(topic_action_url(action));
if(!url.isEmpty()) {
QDesktopServices::openUrl(QUrl(url));
}
}
void UatDialog::on_buttonBox_helpRequested()
{
if (!uat_) return;
QString help_page = uat_->help, url;
help_page.append(".html");
url = gchar_free_to_qstring(user_guide_url(help_page.toUtf8().constData()));
if (!url.isNull()) {
QDesktopServices::openUrl(QUrl(url));
}
}
void StatsTreeDialog::fillTree()
{
GString *error_string;
if (!st_cfg_ || file_closed_) return;
QString display_name = gchar_free_to_qstring(stats_tree_get_displayname(st_cfg_->name));
// The GTK+ UI appends "Stats Tree" to the window title. If we do the same
// here we should expand the name completely, e.g. to "Statistics Tree".
setWindowSubtitle(display_name);
st_cfg_->pr = &cfg_pr_;
cfg_pr_.st_dlg = this;
if (st_) {
stats_tree_free(st_);
}
st_ = stats_tree_new(st_cfg_, NULL, displayFilter());
// Add number of columns for this stats_tree
QStringList header_labels;
for (int count = 0; count<st_->num_columns; count++) {
header_labels.push_back(stats_tree_get_column_name(count));
}
statsTreeWidget()->setColumnCount(header_labels.count());
statsTreeWidget()->setHeaderLabels(header_labels);
resize(st_->num_columns*80+80, height());
statsTreeWidget()->setSortingEnabled(false);
error_string = register_tap_listener(st_cfg_->tapname,
st_,
st_->filter,
st_cfg_->flags,
resetTap,
stats_tree_packet,
drawTreeItems);
if (error_string) {
QMessageBox::critical(this, tr("%1 failed to attach to tap").arg(display_name),
error_string->str);
g_string_free(error_string, TRUE);
reject();
}
cf_retap_packets(cap_file_.capFile());
drawTreeItems(st_);
statsTreeWidget()->setSortingEnabled(true);
remove_tap_listener(st_);
st_cfg_->pr = NULL;
}
void StatsTreeDialog::fillTree()
{
if (!st_cfg_ || file_closed_) return;
QString display_name = gchar_free_to_qstring(stats_tree_get_displayname(st_cfg_->name));
// The GTK+ UI appends "Stats Tree" to the window title. If we do the same
// here we should expand the name completely, e.g. to "Statistics Tree".
setWindowSubtitle(display_name);
st_cfg_->pr = &cfg_pr_;
cfg_pr_.st_dlg = this;
if (st_) {
stats_tree_free(st_);
}
QString display_filter = displayFilter();
st_ = stats_tree_new(st_cfg_, NULL, display_filter.toUtf8().constData());
// Add number of columns for this stats_tree
QStringList header_labels;
for (int count = 0; count<st_->num_columns; count++) {
header_labels.push_back(stats_tree_get_column_name(count));
}
statsTreeWidget()->setColumnCount(header_labels.count());
statsTreeWidget()->setHeaderLabels(header_labels);
statsTreeWidget()->setSortingEnabled(false);
if (!registerTapListener(st_cfg_->tapname,
st_,
st_->filter,
st_cfg_->flags,
resetTap,
stats_tree_packet,
drawTreeItems)) {
reject(); // XXX Stay open instead?
return;
}
cap_file_.retapPackets();
drawTreeItems(st_);
statsTreeWidget()->setSortingEnabled(true);
removeTapListeners();
st_cfg_->pr = NULL;
}
void UatDialog::setUat(epan_uat *uat)
{
QString title(tr("Unknown User Accessible Table"));
uat_ = uat;
ui->pathLabel->clear();
ui->pathLabel->setEnabled(false);
help_button_->setEnabled(false);
if (uat_) {
if (uat_->name) {
title = uat_->name;
}
QString abs_path = gchar_free_to_qstring(uat_get_actual_filename(uat_, FALSE));
ui->pathLabel->setText(abs_path);
ui->pathLabel->setUrl(QUrl::fromLocalFile(abs_path).toString());
ui->pathLabel->setToolTip(tr("Open ") + uat->filename);
ui->pathLabel->setEnabled(true);
uat_model_ = new UatModel(NULL, uat);
uat_delegate_ = new UatDelegate;
ui->uatTreeView->setModel(uat_model_);
ui->uatTreeView->setItemDelegate(uat_delegate_);
connect(uat_model_, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
this, SLOT(modelDataChanged(QModelIndex)));
connect(ui->uatTreeView, SIGNAL(currentItemChanged(QModelIndex,QModelIndex)),
this, SLOT(viewCurrentChanged(QModelIndex,QModelIndex)));
ok_button_->setEnabled(!uat_model_->hasErrors());
if (uat_->help && strlen(uat_->help) > 0) {
help_button_->setEnabled(true);
}
connect(this, SIGNAL(rejected()), this, SLOT(rejectChanges()));
connect(this, SIGNAL(accepted()), this, SLOT(acceptChanges()));
}
setWindowTitle(title);
}
void UatDialog::setUat(epan_uat *uat)
{
QString title(tr("Unknown User Accessible Table"));
uat_ = uat;
ui->uatTreeWidget->clear();
ui->uatTreeWidget->setColumnCount(0);
ui->pathLabel->clear();
ui->pathLabel->setEnabled(false);
help_button_->setEnabled(false);
if (uat_) {
if (uat_->name) {
title = uat_->name;
}
QString abs_path = gchar_free_to_qstring(uat_get_actual_filename(uat_, FALSE));
ui->pathLabel->setText(abs_path);
ui->pathLabel->setUrl(QUrl::fromLocalFile(abs_path).toString());
ui->pathLabel->setToolTip(tr("Open ") + uat->filename);
ui->pathLabel->setEnabled(true);
ui->uatTreeWidget->setColumnCount(uat_->ncols);
for (guint col = 0; col < uat->ncols; col++) {
ui->uatTreeWidget->headerItem()->setText(col, uat_->fields[col].title);
}
updateItems();
if (uat_->help && strlen(uat_->help) > 0) {
help_button_->setEnabled(true);
}
}
setWindowTitle(title);
}
void PreferenceEditorFrame::editPreference(preference *pref, pref_module *module)
{
pref_ = pref;
module_ = module;
if (!pref || !module) {
hide();
return;
}
ui->modulePreferencesToolButton->setText(tr("Open %1 preferences").arg(module_->title));
pref_stash(pref_, NULL);
ui->preferenceTitleLabel->setText(pref->title);
// Convert the pref description from plain text to rich text.
QString description;
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
description = Qt::escape(pref->description);
#else
description = QString(pref->description).toHtmlEscaped();
#endif
description.replace('\n', "<br>");
QString tooltip = QString("<span>%1</span>").arg(description);
ui->preferenceTitleLabel->setToolTip(tooltip);
ui->preferenceLineEdit->setToolTip(tooltip);
ui->preferenceLineEdit->clear();
ui->preferenceLineEdit->setSyntaxState(SyntaxLineEdit::Empty);
disconnect(ui->preferenceLineEdit);
bool show = false;
switch (pref_->type) {
case PREF_UINT:
new_uint_ = pref->stashed_val.uint;
connect(ui->preferenceLineEdit, SIGNAL(textEdited(QString)),
this, SLOT(uintLineEditTextEdited(QString)));
show = true;
break;
case PREF_STRING:
new_str_ = pref->stashed_val.string;
connect(ui->preferenceLineEdit, SIGNAL(textEdited(QString)),
this, SLOT(stringLineEditTextEdited(QString)));
show = true;
break;
case PREF_RANGE:
g_free(new_range_);
new_range_ = range_copy(pref->stashed_val.range);
connect(ui->preferenceLineEdit, SIGNAL(textEdited(QString)),
this, SLOT(rangeLineEditTextEdited(QString)));
show = true;
break;
default:
break;
}
if (show) {
ui->preferenceLineEdit->setText(gchar_free_to_qstring(prefs_pref_to_str(pref_, pref_stashed)).remove(QRegExp("\n\t")));
animatedShow();
}
}
const QString bits_s_to_qstring(const double bits_s)
{
return gchar_free_to_qstring(
format_size(bits_s, format_size_unit_none|format_size_prefix_si));
}
ColoringRulesDialog::ColoringRulesDialog(QWidget *parent, QString add_filter) :
GeometryStateDialog(parent),
ui(new Ui::ColoringRulesDialog),
colorRuleModel_(palette().color(QPalette::Text), palette().color(QPalette::Base), this),
colorRuleDelegate_(this)
{
ui->setupUi(this);
if (parent) loadGeometry(parent->width() * 2 / 3, parent->height() * 4 / 5);
setWindowTitle(wsApp->windowTitleString(tr("Coloring Rules %1").arg(get_profile_name())));
ui->coloringRulesTreeView->setModel(&colorRuleModel_);
ui->coloringRulesTreeView->setItemDelegate(&colorRuleDelegate_);
ui->coloringRulesTreeView->viewport()->setAcceptDrops(true);
for (int i = 0; i < colorRuleModel_.columnCount(); i++) {
ui->coloringRulesTreeView->resizeColumnToContents(i);
}
#ifdef Q_OS_MAC
ui->newToolButton->setAttribute(Qt::WA_MacSmallSize, true);
ui->deleteToolButton->setAttribute(Qt::WA_MacSmallSize, true);
ui->copyToolButton->setAttribute(Qt::WA_MacSmallSize, true);
ui->clearToolButton->setAttribute(Qt::WA_MacSmallSize, true);
ui->pathLabel->setAttribute(Qt::WA_MacSmallSize, true);
#endif
connect(ui->coloringRulesTreeView->selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
this, SLOT(colorRuleSelectionChanged(const QItemSelection &, const QItemSelection &)));
connect(&colorRuleDelegate_, SIGNAL(invalidField(const QModelIndex&, const QString&)),
this, SLOT(invalidField(const QModelIndex&, const QString&)));
connect(&colorRuleDelegate_, SIGNAL(validField(const QModelIndex&)),
this, SLOT(validField(const QModelIndex&)));
connect(&colorRuleModel_, SIGNAL(rowsInserted(const QModelIndex &, int, int)), this, SLOT(rowCountChanged()));
connect(&colorRuleModel_, SIGNAL(rowsRemoved(const QModelIndex &, int, int)), this, SLOT(rowCountChanged()));
rowCountChanged();
import_button_ = ui->buttonBox->addButton(tr("Import" UTF8_HORIZONTAL_ELLIPSIS), QDialogButtonBox::ApplyRole);
import_button_->setToolTip(tr("Select a file and add its filters to the end of the list."));
export_button_ = ui->buttonBox->addButton(tr("Export" UTF8_HORIZONTAL_ELLIPSIS), QDialogButtonBox::ApplyRole);
export_button_->setToolTip(tr("Save filters in a file."));
QPushButton *copy_button = ui->buttonBox->addButton(tr("Copy from"), QDialogButtonBox::ActionRole);
CopyFromProfileMenu *copy_from_menu = new CopyFromProfileMenu(COLORFILTERS_FILE_NAME, copy_button);
copy_button->setMenu(copy_from_menu);
copy_button->setToolTip(tr("Copy coloring rules from another profile."));
copy_button->setEnabled(copy_from_menu->haveProfiles());
connect(copy_from_menu, SIGNAL(triggered(QAction *)), this, SLOT(copyFromProfile(QAction *)));
QString abs_path = gchar_free_to_qstring(get_persconffile_path(COLORFILTERS_FILE_NAME, TRUE));
if (file_exists(abs_path.toUtf8().constData())) {
ui->pathLabel->setText(abs_path);
ui->pathLabel->setUrl(QUrl::fromLocalFile(abs_path).toString());
ui->pathLabel->setToolTip(tr("Open ") + COLORFILTERS_FILE_NAME);
ui->pathLabel->setEnabled(true);
}
if (!add_filter.isEmpty()) {
colorRuleModel_.addColor(false, add_filter, palette().color(QPalette::Text), palette().color(QPalette::Base));
//setup the buttons appropriately
ui->coloringRulesTreeView->setCurrentIndex(colorRuleModel_.index(0, 0));
//set edit on display filter
ui->coloringRulesTreeView->edit(colorRuleModel_.index(0, 1));
}else {
ui->coloringRulesTreeView->setCurrentIndex(QModelIndex());
}
checkUnknownColorfilters();
updateHint();
}
bool FollowStreamDialog::follow(QString previous_filter, bool use_stream_index)
{
int tmp_fd;
QString follow_filter;
const char *hostname0 = NULL, *hostname1 = NULL;
char *port0 = NULL, *port1 = NULL;
QString server_to_client_string;
QString client_to_server_string;
QString both_directions_string;
follow_stats_t stats;
tcp_stream_chunk sc;
size_t nchars;
gboolean is_tcp = FALSE, is_udp = FALSE;
beginRetapPackets();
resetStream();
if (file_closed_)
{
QMessageBox::warning(this, tr("No capture file."), tr("Please make sure you have a capture file opened."));
return false;
}
if (cap_file_.capFile()->edt == NULL)
{
QMessageBox::warning(this, tr("Error following stream."), tr("Capture file invalid."));
return false;
}
proto_get_frame_protocols(cap_file_.capFile()->edt->pi.layers, NULL, &is_tcp, &is_udp, NULL, NULL, NULL, NULL);
switch (follow_type_)
{
case FOLLOW_TCP:
if (!is_tcp) {
QMessageBox::warning(this, tr("Error following stream."), tr("Please make sure you have a TCP packet selected."));
return false;
}
break;
case FOLLOW_UDP:
if (!is_udp) {
QMessageBox::warning(this, tr("Error following stream."), tr("Please make sure you have a UDP packet selected."));
return false;
}
break;
case FOLLOW_SSL:
/* we got ssl so we can follow */
removeStreamControls();
if (!epan_dissect_packet_contains_field(cap_file_.capFile()->edt, "ssl")) {
QMessageBox::critical(this, tr("Error following stream."),
tr("Please make sure you have an SSL packet selected."));
return false;
}
break;
}
if (follow_type_ == FOLLOW_TCP || follow_type_ == FOLLOW_SSL)
{
/* Create a new filter that matches all packets in the TCP stream,
and set the display filter entry accordingly */
reset_tcp_reassembly();
} else {
reset_udp_follow();
}
if (use_stream_index) {
follow_filter = gchar_free_to_qstring(
build_follow_index_filter((follow_type_ == FOLLOW_TCP) ? TCP_STREAM : UDP_STREAM));
} else {
follow_filter = gchar_free_to_qstring(build_follow_conv_filter(&cap_file_.capFile()->edt->pi));
}
if (follow_filter.isEmpty()) {
QMessageBox::warning(this,
tr("Error creating filter for this stream."),
tr("A transport or network layer header is needed."));
return false;
}
if (follow_type_ == FOLLOW_TCP || follow_type_ == FOLLOW_SSL)
{
/* Create a temporary file into which to dump the reassembled data
from the TCP stream, and set "data_out_file" to refer to it, so
that the TCP code will write to it.
XXX - it might be nicer to just have the TCP code directly
append stuff to the text widget for the TCP stream window,
if we can arrange that said window not pop up until we're
done. */
gchar *data_out_filename;
tmp_fd = create_tempfile(&data_out_filename, "follow");
data_out_filename_ = data_out_filename;
if (tmp_fd == -1) {
QMessageBox::warning(this, "Error",
"Could not create temporary file %1: %2",
data_out_filename_, g_strerror(errno));
data_out_filename_.clear();
return false;
}
data_out_file = fdopen(tmp_fd, "w+b");
if (data_out_file == NULL) {
QMessageBox::warning(this, "Error",
"Could not create temporary file %1: %2",
data_out_filename_, g_strerror(errno));
//ws_close(tmp_fd);
ws_unlink(data_out_filename_.toUtf8().constData());
data_out_filename_.clear();
return false;
}
}
/* append the negation */
if(!previous_filter.isEmpty()) {
filter_out_filter_ = QString("%1 and !(%2)")
.arg(previous_filter).arg(follow_filter);
}
else
{
filter_out_filter_ = QString("!(%1)").arg(follow_filter);
}
switch (follow_type_)
{
case FOLLOW_TCP:
{
int stream_count = get_tcp_stream_count() - 1;
ui->streamNumberSpinBox->blockSignals(true);
ui->streamNumberSpinBox->setMaximum(stream_count);
ui->streamNumberSpinBox->setValue(get_follow_index(TCP_STREAM));
ui->streamNumberSpinBox->blockSignals(false);
ui->streamNumberSpinBox->setToolTip(tr("%Ln total stream(s).", "", stream_count));
ui->streamNumberLabel->setToolTip(ui->streamNumberSpinBox->toolTip());
break;
}
case FOLLOW_UDP:
{
/* data will be passed via tap callback*/
if (!registerTapListener("udp_follow", &follow_info_,
follow_filter.toUtf8().constData(),
0, NULL, udp_queue_packet_data, NULL)) {
return false;
}
int stream_count = get_udp_stream_count() - 1;
ui->streamNumberSpinBox->blockSignals(true);
ui->streamNumberSpinBox->setMaximum(stream_count);
ui->streamNumberSpinBox->setValue(get_follow_index(UDP_STREAM));
ui->streamNumberSpinBox->blockSignals(false);
ui->streamNumberSpinBox->setToolTip(tr("%Ln total stream(s).", "", stream_count));
ui->streamNumberLabel->setToolTip(ui->streamNumberSpinBox->toolTip());
break;
}
case FOLLOW_SSL:
/* we got ssl so we can follow */
if (!registerTapListener("ssl", &follow_info_,
follow_filter.toUtf8().constData(), 0,
NULL, ssl_queue_packet_data, NULL)) {
return false;
}
break;
}
/* Run the display filter so it goes in effect - even if it's the
same as the previous display filter. */
emit updateFilter(follow_filter, TRUE);
switch (follow_type_)
{
case FOLLOW_TCP:
break;
case FOLLOW_UDP:
case FOLLOW_SSL:
removeTapListeners();
break;
}
if (follow_type_ == FOLLOW_TCP)
{
/* Check whether we got any data written to the file. */
if (empty_tcp_stream) {
QMessageBox::warning(this, "Error",
"The packets in the capture file for that stream have no data.");
//ws_close(tmp_fd);
ws_unlink(data_out_filename_.toUtf8().constData());
data_out_filename_.clear();
return false;
}
/* Go back to the top of the file and read the first tcp_stream_chunk
* to ensure that the IP addresses and port numbers in the drop-down
* list are tied to the correct lines displayed by follow_read_stream()
* later on (which also reads from this file). Close the file when
* we're done.
*
* We read the data now, before we pop up a window, in case the
* read fails. We use the data later.
*/
rewind(data_out_file);
nchars=fread(&sc, 1, sizeof(sc), data_out_file);
if (nchars != sizeof(sc)) {
if (ferror(data_out_file)) {
QMessageBox::warning(this, "Error",
QString(tr("Could not read from temporary file %1: %2"))
.arg(data_out_filename_)
.arg(g_strerror(errno)));
} else {
QMessageBox::warning(this, "Error",
QString(tr("Short read from temporary file %1: expected %2, got %3"))
.arg(data_out_filename_)
.arg((unsigned long)sizeof(sc))
.arg((unsigned long)nchars));
}
//ws_close(tmp_fd);
ws_unlink(data_out_filename_.toUtf8().constData());
data_out_filename_.clear();
return false;
}
fclose(data_out_file);
data_out_file = NULL;
}
/* Stream to show */
follow_stats(&stats);
if (stats.is_ipv6) {
struct e_in6_addr ipaddr;
memcpy(&ipaddr, stats.ip_address[0], 16);
hostname0 = get_hostname6(&ipaddr);
memcpy(&ipaddr, stats.ip_address[1], 16);
hostname1 = get_hostname6(&ipaddr);
} else {
guint32 ipaddr;
memcpy(&ipaddr, stats.ip_address[0], 4);
hostname0 = get_hostname(ipaddr);
memcpy(&ipaddr, stats.ip_address[1], 4);
hostname1 = get_hostname(ipaddr);
}
switch (follow_type_)
{
case FOLLOW_TCP:
port0 = tcp_port_to_display(NULL, stats.port[0]);
port1 = tcp_port_to_display(NULL, stats.port[1]);
break;
case FOLLOW_UDP:
port0 = udp_port_to_display(NULL, stats.port[0]);
port1 = udp_port_to_display(NULL, stats.port[1]);
break;
case FOLLOW_SSL:
port0 = tcp_port_to_display(NULL, stats.port[0]);
port1 = tcp_port_to_display(NULL, stats.port[1]);
break;
}
follow_info_.is_ipv6 = stats.is_ipv6;
if (follow_type_ == FOLLOW_TCP)
{
/* Host 0 --> Host 1 */
if ((sc.src_port == stats.port[0]) &&
((stats.is_ipv6 && (memcmp(sc.src_addr, stats.ip_address[0], 16) == 0)) ||
(!stats.is_ipv6 && (memcmp(sc.src_addr, stats.ip_address[0], 4) == 0)))) {
server_to_client_string =
QString("%1:%2 %3 %4:%5 (%6)")
.arg(hostname0).arg(port0)
.arg(UTF8_RIGHTWARDS_ARROW)
.arg(hostname1).arg(port1)
.arg(gchar_free_to_qstring(format_size(
stats.bytes_written[0],
format_size_unit_bytes|format_size_prefix_si)));
} else {
server_to_client_string =
QString("%1:%2 %3 %4:%5 (%6)")
.arg(hostname1).arg(port1)
.arg(UTF8_RIGHTWARDS_ARROW)
.arg(hostname0).arg(port0)
.arg(gchar_free_to_qstring(format_size(
stats.bytes_written[0],
format_size_unit_bytes|format_size_prefix_si)));
}
/* Host 1 --> Host 0 */
if ((sc.src_port == stats.port[1]) &&
((stats.is_ipv6 && (memcmp(sc.src_addr, stats.ip_address[1], 16) == 0)) ||
(!stats.is_ipv6 && (memcmp(sc.src_addr, stats.ip_address[1], 4) == 0)))) {
client_to_server_string =
QString("%1:%2 %3 %4:%5 (%6)")
.arg(hostname0).arg(port0)
.arg(UTF8_RIGHTWARDS_ARROW)
.arg(hostname1).arg(port1)
.arg(gchar_free_to_qstring(format_size(
stats.bytes_written[1],
format_size_unit_bytes|format_size_prefix_si)));
} else {
client_to_server_string =
QString("%1:%2 %3 %4:%5 (%6)")
.arg(hostname1).arg(port1)
.arg(UTF8_RIGHTWARDS_ARROW)
.arg(hostname0).arg(port0)
.arg(gchar_free_to_qstring(format_size(
stats.bytes_written[1],
format_size_unit_bytes|format_size_prefix_si)));
}
}
else
{
if ((follow_info_.client_port == stats.port[0]) &&
((stats.is_ipv6 && (memcmp(follow_info_.client_ip.data, stats.ip_address[0], 16) == 0)) ||
(!stats.is_ipv6 && (memcmp(follow_info_.client_ip.data, stats.ip_address[0], 4) == 0)))) {
server_to_client_string =
QString("%1:%2 %3 %4:%5 (%6)")
.arg(hostname0).arg(port0)
.arg(UTF8_RIGHTWARDS_ARROW)
.arg(hostname1).arg(port1)
.arg(gchar_free_to_qstring(format_size(
follow_info_.bytes_written[0],
format_size_unit_bytes|format_size_prefix_si)));
client_to_server_string =
QString("%1:%2 %3 %4:%5 (%6)")
.arg(hostname1).arg(port1)
.arg(UTF8_RIGHTWARDS_ARROW)
.arg(hostname0).arg(port0)
.arg(gchar_free_to_qstring(format_size(
follow_info_.bytes_written[1],
format_size_unit_bytes|format_size_prefix_si)));
} else {
server_to_client_string =
QString("%1:%2 %3 %4:%5 (%6)")
.arg(hostname1).arg(port1)
.arg(UTF8_RIGHTWARDS_ARROW)
.arg(hostname0).arg(port0)
.arg(gchar_free_to_qstring(format_size(
follow_info_.bytes_written[0],
format_size_unit_bytes|format_size_prefix_si)));
client_to_server_string =
QString("%1:%2 %3 %4:%5 (%6)")
.arg(hostname0).arg(port0)
.arg(UTF8_RIGHTWARDS_ARROW)
.arg(hostname1).arg(port1)
.arg(gchar_free_to_qstring(format_size(
follow_info_.bytes_written[1],
format_size_unit_bytes|format_size_prefix_si)));
}
}
wmem_free(NULL, port0);
wmem_free(NULL, port1);
/* Both Stream Directions */
switch (follow_type_)
{
case FOLLOW_TCP:
both_directions_string = QString("Entire conversation (%1)")
.arg(gchar_free_to_qstring(format_size(
stats.bytes_written[0] + stats.bytes_written[1],
format_size_unit_bytes|format_size_prefix_si)));
setWindowSubtitle(tr("Follow TCP Stream (%1)").arg(follow_filter));
break;
case FOLLOW_UDP:
both_directions_string = QString("Entire conversation (%1)")
.arg(gchar_free_to_qstring(format_size(
follow_info_.bytes_written[0] + follow_info_.bytes_written[1],
format_size_unit_bytes|format_size_prefix_si)));
setWindowSubtitle(tr("Follow UDP Stream (%1)").arg(follow_filter));
break;
case FOLLOW_SSL:
both_directions_string = QString("Entire conversation (%1)")
.arg(gchar_free_to_qstring(format_size(
follow_info_.bytes_written[0] + follow_info_.bytes_written[1],
format_size_unit_bytes|format_size_prefix_si)));
setWindowSubtitle(tr("Follow SSL Stream (%1)").arg(follow_filter));
break;
}
ui->cbDirections->clear();
ui->cbDirections->addItem(both_directions_string);
ui->cbDirections->addItem(client_to_server_string);
ui->cbDirections->addItem(server_to_client_string);
followStream();
fillHintLabel(-1);
if (data_out_file) {
fclose(data_out_file);
data_out_file = NULL;
}
endRetapPackets();
return true;
}
MainWindowPreferencesFrame::MainWindowPreferencesFrame(QWidget *parent) :
QFrame(parent),
ui(new Ui::MainWindowPreferencesFrame)
{
ui->setupUi(this);
pref_geometry_save_position_ = prefFromPrefPtr(&prefs.gui_geometry_save_position);
pref_geometry_save_size_ = prefFromPrefPtr(&prefs.gui_geometry_save_size);
pref_geometry_save_maximized_ = prefFromPrefPtr(&prefs.gui_geometry_save_maximized);
pref_fileopen_style_ = prefFromPrefPtr(&prefs.gui_fileopen_style);
pref_fileopen_dir_ = prefFromPrefPtr(&prefs.gui_fileopen_dir);
pref_recent_df_entries_max_ = prefFromPrefPtr(&prefs.gui_recent_df_entries_max);
pref_recent_files_count_max_ = prefFromPrefPtr(&prefs.gui_recent_files_count_max);
pref_ask_unsaved_ = prefFromPrefPtr(&prefs.gui_ask_unsaved);
pref_toolbar_main_style_ = prefFromPrefPtr(&prefs.gui_toolbar_main_style);
pref_toolbar_filter_style_ = prefFromPrefPtr(&prefs.gui_toolbar_filter_style);
QStyleOption style_opt;
QString indent_ss = QString(
"QRadioButton, QLineEdit, QLabel {"
" margin-left: %1px;"
"}"
).arg(ui->geometryCheckBox->style()->subElementRect(QStyle::SE_CheckBoxContents, &style_opt).left());
ui->foStyleLastOpenedRadioButton->setStyleSheet(indent_ss);
ui->foStyleSpecifiedRadioButton->setStyleSheet(indent_ss);
ui->maxFilterLineEdit->setStyleSheet(indent_ss);
ui->maxRecentLineEdit->setStyleSheet(indent_ss);
int num_entry_width = ui->maxFilterLineEdit->fontMetrics().height() * 3;
ui->maxFilterLineEdit->setMaximumWidth(num_entry_width);
ui->maxRecentLineEdit->setMaximumWidth(num_entry_width);
QString globalLanguagesPath(QString(get_datafile_dir()) + "/languages/");
QString userLanguagesPath(gchar_free_to_qstring(get_persconffile_path("languages/", FALSE)));
QStringList filenames = QDir(":/i18n/").entryList(QStringList("wireshark_*.qm"));
filenames += QDir(globalLanguagesPath).entryList(QStringList("wireshark_*.qm"));
filenames += QDir(userLanguagesPath).entryList(QStringList("wireshark_*.qm"));
for (int i = 0; i < filenames.size(); i += 1) {
QString locale;
locale = filenames[i];
locale.truncate(locale.lastIndexOf('.'));
locale.remove(0, locale.indexOf('_') + 1);
QString lang = QLocale::languageToString(QLocale(locale).language());
QIcon ico = QIcon();
if (QFile::exists(QString(":/languages/%1.svg").arg(locale)))
ico.addFile(QString(":/languages/%1.svg").arg(locale));
if (QFile::exists(globalLanguagesPath + locale + ".svg"))
ico.addFile(globalLanguagesPath + locale + ".svg");
if (QFile::exists(userLanguagesPath + locale + ".svg"))
ico.addFile(userLanguagesPath + locale + ".svg");
ui->languageComboBox->addItem(ico, lang, locale);
}
ui->languageComboBox->setItemData(0, USE_SYSTEM_LANGUAGE);
ui->languageComboBox->model()->sort(0);
for (int i = 0; i < ui->languageComboBox->count(); i += 1) {
if (QString(language) == ui->languageComboBox->itemData(i).toString()) {
ui->languageComboBox->setCurrentIndex(i);
break;
}
}
}
bool FollowStreamDialog::follow(QString previous_filter, bool use_stream_index, int stream_num)
{
QString follow_filter;
const char *hostname0 = NULL, *hostname1 = NULL;
char *port0 = NULL, *port1 = NULL;
QString server_to_client_string;
QString client_to_server_string;
QString both_directions_string;
gboolean is_follower = FALSE;
resetStream();
if (file_closed_)
{
QMessageBox::warning(this, tr("No capture file."), tr("Please make sure you have a capture file opened."));
return false;
}
if (cap_file_.capFile()->edt == NULL)
{
QMessageBox::warning(this, tr("Error following stream."), tr("Capture file invalid."));
return false;
}
is_follower = proto_is_frame_protocol(cap_file_.capFile()->edt->pi.layers, proto_get_protocol_filter_name(get_follow_proto_id(follower_)));
if (!is_follower) {
QMessageBox::warning(this, tr("Error following stream."), tr("Please make sure you have a %1 packet selected.").arg
(proto_get_protocol_short_name(find_protocol_by_id(get_follow_proto_id(follower_)))));
return false;
}
if (follow_type_ == FOLLOW_SSL)
{
/* we got ssl so we can follow */
removeStreamControls();
}
follow_reset_stream(&follow_info_);
/* Create a new filter that matches all packets in the TCP stream,
and set the display filter entry accordingly */
if (use_stream_index) {
follow_filter = gchar_free_to_qstring(get_follow_index_func(follower_)(stream_num));
} else {
follow_filter = gchar_free_to_qstring(get_follow_conv_func(follower_)(&cap_file_.capFile()->edt->pi, &stream_num));
}
if (follow_filter.isEmpty()) {
QMessageBox::warning(this,
tr("Error creating filter for this stream."),
tr("A transport or network layer header is needed."));
return false;
}
/* append the negation */
if(!previous_filter.isEmpty()) {
filter_out_filter_ = QString("%1 and !(%2)")
.arg(previous_filter).arg(follow_filter);
}
else
{
filter_out_filter_ = QString("!(%1)").arg(follow_filter);
}
/* data will be passed via tap callback*/
if (!registerTapListener(get_follow_tap_string(follower_), &follow_info_,
follow_filter.toUtf8().constData(),
0, NULL, get_follow_tap_handler(follower_), NULL)) {
return false;
}
switch (follow_type_)
{
case FOLLOW_TCP:
{
int stream_count = get_tcp_stream_count();
ui->streamNumberSpinBox->blockSignals(true);
ui->streamNumberSpinBox->setMaximum(stream_count-1);
ui->streamNumberSpinBox->setValue(stream_num);
ui->streamNumberSpinBox->blockSignals(false);
ui->streamNumberSpinBox->setToolTip(tr("%Ln total stream(s).", "", stream_count));
ui->streamNumberLabel->setToolTip(ui->streamNumberSpinBox->toolTip());
break;
}
case FOLLOW_UDP:
{
int stream_count = get_udp_stream_count();
ui->streamNumberSpinBox->blockSignals(true);
ui->streamNumberSpinBox->setMaximum(stream_count-1);
ui->streamNumberSpinBox->setValue(stream_num);
ui->streamNumberSpinBox->blockSignals(false);
ui->streamNumberSpinBox->setToolTip(tr("%Ln total stream(s).", "", stream_count));
ui->streamNumberLabel->setToolTip(ui->streamNumberSpinBox->toolTip());
break;
}
case FOLLOW_SSL:
case FOLLOW_HTTP:
/* No extra handling */
break;
}
beginRetapPackets();
updateWidgets(true);
/* Run the display filter so it goes in effect - even if it's the
same as the previous display filter. */
emit updateFilter(follow_filter, TRUE);
removeTapListeners();
hostname0 = address_to_name(&follow_info_.client_ip);
hostname1 = address_to_name(&follow_info_.server_ip);
port0 = get_follow_port_to_display(follower_)(NULL, follow_info_.client_port);
port1 = get_follow_port_to_display(follower_)(NULL, follow_info_.server_port);
server_to_client_string =
QString("%1:%2 %3 %4:%5 (%6)")
.arg(hostname0).arg(port0)
.arg(UTF8_RIGHTWARDS_ARROW)
.arg(hostname1).arg(port1)
.arg(gchar_free_to_qstring(format_size(
follow_info_.bytes_written[0],
format_size_unit_bytes|format_size_prefix_si)));
client_to_server_string =
QString("%1:%2 %3 %4:%5 (%6)")
.arg(hostname1).arg(port1)
.arg(UTF8_RIGHTWARDS_ARROW)
.arg(hostname0).arg(port0)
.arg(gchar_free_to_qstring(format_size(
follow_info_.bytes_written[1],
format_size_unit_bytes|format_size_prefix_si)));
wmem_free(NULL, port0);
wmem_free(NULL, port1);
both_directions_string = QString("Entire conversation (%1)")
.arg(gchar_free_to_qstring(format_size(
follow_info_.bytes_written[0] + follow_info_.bytes_written[1],
format_size_unit_bytes|format_size_prefix_si)));
setWindowSubtitle(tr("Follow %1 Stream (%2)").arg(proto_get_protocol_short_name(find_protocol_by_id(get_follow_proto_id(follower_))))
.arg(follow_filter));
ui->cbDirections->clear();
ui->cbDirections->addItem(both_directions_string);
ui->cbDirections->addItem(client_to_server_string);
ui->cbDirections->addItem(server_to_client_string);
followStream();
fillHintLabel(-1);
updateWidgets(false);
endRetapPackets();
return true;
}
const QString file_size_to_qstring(const gint64 size)
{
return gchar_free_to_qstring(
format_size(size, format_size_unit_bytes|format_size_prefix_si));
}
void InterfaceTree::getInterfaceList()
{
#ifdef HAVE_LIBPCAP
GList *if_list;
int err;
gchar *err_str = NULL;
clear();
if_list = capture_interface_list(&err, &err_str,main_window_update);
if_list = g_list_sort(if_list, if_list_comparator_alph);
if (if_list == NULL) {
QTreeWidgetItem *ti = new QTreeWidgetItem();
QLabel *err_label = new QLabel(gchar_free_to_qstring(err_str));
err_label->setWordWrap(true);
setColumnCount(1);
addTopLevelItem(ti);
setItemWidget(ti, 0, err_label);
resizeColumnToContents(0);
return;
} else if (err_str) {
g_free(err_str);
}
// XXX Do we need to check for this? capture_interface_list returns an error if the length is 0.
if (g_list_length(if_list) > 0) {
interface_t device;
setDisabled(false);
for (guint i = 0; i < global_capture_opts.all_ifaces->len; i++) {
QList<int> *points;
device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
/* Continue if capture device is hidden */
if (device.hidden) {
continue;
}
QTreeWidgetItem *ti = new QTreeWidgetItem();
ti->setText(0, QString().fromUtf8(device.display_name));
ti->setData(0, Qt::UserRole, QString(device.name));
points = new QList<int>();
ti->setData(1, Qt::UserRole, qVariantFromValue(points));
addTopLevelItem(ti);
// XXX Add other device information
resizeColumnToContents(1);
if (strstr(prefs.capture_device, device.name) != NULL) {
device.selected = TRUE;
global_capture_opts.num_selected++;
global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i);
g_array_insert_val(global_capture_opts.all_ifaces, i, device);
}
if (device.selected) {
ti->setSelected(true);
}
}
}
free_interface_list(if_list);
resizeEvent(NULL);
if (!stat_timer_) {
updateStatistics();
stat_timer_ = new QTimer(this);
connect(stat_timer_, SIGNAL(timeout()), this, SLOT(updateStatistics()));
stat_timer_->start(stat_update_interval_);
}
#else
QTreeWidgetItem *ti = new QTreeWidgetItem();
clear();
setColumnCount(1);
ti->setText(0, tr("Interface information not available"));
addTopLevelItem(ti);
resizeColumnToContents(0);
#endif // HAVE_LIBPCAP
}
void TCPStreamDialog::fillGraph()
{
QCustomPlot *sp = ui->streamPlot;
if (sp->graphCount() < 1) return;
base_graph_->setLineStyle(QCPGraph::lsNone);
tracer_->setGraph(NULL);
// base_graph_ is always visible.
for (int i = 0; i < sp->graphCount(); i++) {
sp->graph(i)->clearData();
sp->graph(i)->setVisible(i == 0 ? true : false);
}
base_graph_->setScatterStyle(QCPScatterStyle(QCPScatterStyle::ssDisc, pkt_point_size_));
sp->xAxis->setLabel(time_s_label_);
sp->xAxis->setNumberFormat("gb");
sp->xAxis->setNumberPrecision(6);
sp->yAxis->setNumberFormat("f");
sp->yAxis->setNumberPrecision(0);
sp->yAxis2->setVisible(false);
sp->yAxis2->setLabel(QString());
if (!cap_file_) {
QString dlg_title = QString(tr("No Capture Data"));
setWindowTitle(dlg_title);
title_->setText(dlg_title);
sp->setEnabled(false);
sp->yAxis->setLabel(QString());
sp->replot();
return;
}
ts_offset_ = 0;
seq_offset_ = 0;
bool first = true;
guint64 bytes_fwd = 0;
guint64 bytes_rev = 0;
int pkts_fwd = 0;
int pkts_rev = 0;
time_stamp_map_.clear();
for (struct segment *seg = graph_.segments; seg != NULL; seg = seg->next) {
if (!compareHeaders(seg)) {
bytes_rev += seg->th_seglen;
pkts_rev++;
continue;
}
bytes_fwd += seg->th_seglen;
pkts_fwd++;
double ts = seg->rel_secs + seg->rel_usecs / 1000000.0;
if (first) {
if (ts_origin_conn_) ts_offset_ = ts;
if (seq_origin_zero_) seq_offset_ = seg->th_seq;
first = false;
}
time_stamp_map_.insertMulti(ts - ts_offset_, seg);
}
switch (graph_.type) {
case GRAPH_TSEQ_STEVENS:
fillStevens();
break;
case GRAPH_TSEQ_TCPTRACE:
fillTcptrace();
break;
case GRAPH_THROUGHPUT:
fillThroughput();
break;
case GRAPH_RTT:
fillRoundTripTime();
break;
case GRAPH_WSCALE:
fillWindowScale();
break;
default:
break;
}
sp->setEnabled(true);
stream_desc_ = tr("%1 %2 pkts, %3 %4 %5 pkts, %6 ")
.arg(UTF8_RIGHTWARDS_ARROW)
.arg(gchar_free_to_qstring(format_size(pkts_fwd, format_size_unit_none|format_size_prefix_si)))
.arg(gchar_free_to_qstring(format_size(bytes_fwd, format_size_unit_bytes|format_size_prefix_si)))
.arg(UTF8_LEFTWARDS_ARROW)
.arg(gchar_free_to_qstring(format_size(pkts_rev, format_size_unit_none|format_size_prefix_si)))
.arg(gchar_free_to_qstring(format_size(bytes_rev, format_size_unit_bytes|format_size_prefix_si)));
mouseMoved(NULL);
resetAxes();
tracer_->setGraph(base_graph_);
// XXX QCustomPlot doesn't seem to draw any sort of focus indicator.
sp->setFocus();
}
