diff options
Diffstat (limited to 'ui/qt/wireshark_main_window_slots.cpp')
-rw-r--r-- | ui/qt/wireshark_main_window_slots.cpp | 4062 |
1 files changed, 4062 insertions, 0 deletions
diff --git a/ui/qt/wireshark_main_window_slots.cpp b/ui/qt/wireshark_main_window_slots.cpp new file mode 100644 index 0000000..74943ad --- /dev/null +++ b/ui/qt/wireshark_main_window_slots.cpp @@ -0,0 +1,4062 @@ +/* main_window_slots.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> + +// Qt 5.5.0 + Visual C++ 2013 +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable:4996) +#endif + +#include "wireshark_main_window.h" + +/* + * The generated Ui_WiresharkMainWindow::setupUi() can grow larger than our configured limit, + * so turn off -Wframe-larger-than= for ui_main_window.h. + */ +DIAG_OFF(frame-larger-than=) +#include <ui_wireshark_main_window.h> +DIAG_ON(frame-larger-than=) + +#ifdef _WIN32 +#include <windows.h> +#endif + +#include "ui/dissect_opts.h" + +#ifdef HAVE_LIBPCAP +#include "ui/capture.h" +#endif + +#include "ui/commandline.h" + +#include "ui/urls.h" + +#include "epan/color_filters.h" +#include "epan/export_object.h" + +#include "wsutil/file_util.h" +#include "wsutil/filesystem.h" +#include <wsutil/wslog.h> +#include <wsutil/ws_assert.h> + +#include "epan/addr_resolv.h" +#include "epan/column.h" +#include "epan/dfilter/dfilter-macro.h" +#include "epan/conversation_filter.h" +#include "epan/epan_dissect.h" +#include "epan/filter_expressions.h" +#include "epan/prefs.h" +#include "epan/plugin_if.h" +#include "epan/uat.h" +#include "epan/uat-int.h" +#include "epan/value_string.h" + +#ifdef HAVE_LUA +#include <epan/wslua/init_wslua.h> +#endif + +#include "ui/alert_box.h" +#ifdef HAVE_LIBPCAP +#include "ui/capture_ui_utils.h" +#endif + +#include "ui/capture_globals.h" +#include "ui/help_url.h" +#include "ui/main_statusbar.h" +#include "ui/preference_utils.h" +#include "ui/recent.h" +#include "ui/recent_utils.h" +#include "ui/ssl_key_export.h" +#include "ui/ws_ui_util.h" +#include "ui/all_files_wildcard.h" +#include "ui/qt/simple_dialog.h" + +#include <ui/qt/utils/variant_pointer.h> +#include <ui/qt/widgets/drag_drop_toolbar.h> +#include "ui/qt/widgets/wireshark_file_dialog.h" + +#ifdef HAVE_SOFTWARE_UPDATE +#include "ui/software_update.h" +#endif + +#include "about_dialog.h" +#include "bluetooth_att_server_attributes_dialog.h" +#include "bluetooth_devices_dialog.h" +#include "bluetooth_hci_summary_dialog.h" +#include "capture_file_dialog.h" +#include "capture_file_properties_dialog.h" +#ifdef HAVE_LIBPCAP +#include "capture_options_dialog.h" +#endif +#include <ui/qt/utils/color_utils.h> +#include "coloring_rules_dialog.h" +#include "conversation_dialog.h" +#include "conversation_colorize_action.h" +#include "conversation_hash_tables_dialog.h" +#include "enabled_protocols_dialog.h" +#include "decode_as_dialog.h" +#include <ui/qt/widgets/display_filter_edit.h> +#include "display_filter_expression_dialog.h" +#include "dissector_tables_dialog.h" +#include "endpoint_dialog.h" +#include "expert_info_dialog.h" +#include "export_object_action.h" +#include "export_object_dialog.h" +#include "export_pdu_dialog.h" +#include "extcap_options_dialog.h" +#include "file_set_dialog.h" +#include "filter_action.h" +#include "filter_dialog.h" +#include "firewall_rules_dialog.h" +#include "follow_stream_action.h" +#include "follow_stream_dialog.h" +#include "funnel_statistics.h" +#include "gsm_map_summary_dialog.h" +#include "iax2_analysis_dialog.h" +#include "interface_toolbar.h" +#include "io_graph_dialog.h" +#include <ui/qt/widgets/additional_toolbar.h> +#include "lbm_stream_dialog.h" +#include "lbm_lbtrm_transport_dialog.h" +#include "lbm_lbtru_transport_dialog.h" +#include "lte_mac_statistics_dialog.h" +#include "lte_rlc_statistics_dialog.h" +#include "lte_rlc_graph_dialog.h" +#include "main_application.h" +#include "manuf_dialog.h" +#include "mtp3_summary_dialog.h" +#include "multicast_statistics_dialog.h" +#include "packet_comment_dialog.h" +#include "packet_diagram.h" +#include "packet_dialog.h" +#include "packet_list.h" +#include "credentials_dialog.h" +#include "preferences_dialog.h" +#include "print_dialog.h" +#include "profile_dialog.h" +#include "protocol_hierarchy_dialog.h" +#include <ui/qt/utils/qt_ui_utils.h> +#include "resolved_addresses_dialog.h" +#include "rpc_service_response_time_dialog.h" +#include "rtp_stream_dialog.h" +#include "rtp_analysis_dialog.h" +#include "sctp_all_assocs_dialog.h" +#include "sctp_assoc_analyse_dialog.h" +#include "sctp_graph_dialog.h" +#include "sequence_dialog.h" +#include "show_packet_bytes_dialog.h" +#include "tlskeylog_launcher_dialog.h" +#include "stats_tree_dialog.h" +#include "strip_headers_dialog.h" +#include <ui/qt/utils/stock_icon.h> +#include "supported_protocols_dialog.h" +#include "tap_parameter_dialog.h" +#include "tcp_stream_dialog.h" +#include "time_shift_dialog.h" +#include "uat_dialog.h" +#include "voip_calls_dialog.h" +#include "wlan_statistics_dialog.h" +#include <ui/qt/widgets/wireless_timeline.h> + +#include <functional> +#include <QClipboard> +#include <QFileInfo> +#include <QMessageBox> +#include <QMetaObject> +#include <QToolBar> +#include <QDesktopServices> +#include <QUrl> +#include <QMutex> + +// XXX You must uncomment QT_WINEXTRAS_LIB lines in CMakeList.txt and +// cmakeconfig.h.in. +// #if defined(QT_WINEXTRAS_LIB) +// #include <QWinJumpList> +// #include <QWinJumpListCategory> +// #include <QWinJumpListItem> +// #endif + +// +// Public slots +// + +bool WiresharkMainWindow::openCaptureFile(QString cf_path, QString read_filter, unsigned int type, gboolean is_tempfile) +{ + QString file_name = ""; + dfilter_t *rfcode = NULL; + df_error_t *df_err = NULL; + int err; + gboolean name_param; + gboolean ret = true; + + // was a file name given as function parameter? + name_param = !cf_path.isEmpty(); + + for (;;) { + + if (cf_path.isEmpty()) { + CaptureFileDialog open_dlg(this, capture_file_.capFile()); + + if (open_dlg.open(file_name, type, read_filter)) { + cf_path = file_name; + } else { + ret = false; + goto finish; + } + } else { + this->welcome_page_->getInterfaceFrame()->showRunOnFile(); + } + + // TODO detect call from "cf_read" -> "update_progress_dlg" + // ("capture_file_.capFile()->read_lock"), possibly queue opening the + // file and return early to avoid the warning in testCaptureFileClose. + + QString before_what(tr(" before opening another file")); + if (!testCaptureFileClose(before_what)) { + ret = false; + goto finish; + } + + if (dfilter_compile(qUtf8Printable(read_filter), &rfcode, &df_err)) { + cf_set_rfcode(CaptureFile::globalCapFile(), rfcode); + } else { + /* Not valid. Tell the user, and go back and run the file + selection box again once they dismiss the alert. */ + //bad_dfilter_alert_box(top_level, read_filter->str); + QMessageBox::warning(this, tr("Invalid Display Filter"), + QString("The filter expression ") + + read_filter + + QString(" isn't a valid display filter. (") + + df_err->msg + QString(")."), + QMessageBox::Ok); + df_error_free(&df_err); + if (!name_param) { + // go back to the selection dialogue only if the file + // was selected from this dialogue + cf_path.clear(); + continue; + } + } + + /* Make the file name available via MainWindow */ + setMwFileName(cf_path); + + /* Try to open the capture file. This closes the current file if it succeeds. */ + CaptureFile::globalCapFile()->window = this; + if (cf_open(CaptureFile::globalCapFile(), qUtf8Printable(cf_path), type, is_tempfile, &err) != CF_OK) { + /* We couldn't open it; don't dismiss the open dialog box, + just leave it around so that the user can, after they + dismiss the alert box popped up for the open error, + try again. */ + CaptureFile::globalCapFile()->window = NULL; + dfilter_free(rfcode); + cf_path.clear(); + continue; + } + + switch (cf_read(CaptureFile::globalCapFile(), /*reloading=*/FALSE)) { + case CF_READ_OK: + case CF_READ_ERROR: + /* Just because we got an error, that doesn't mean we were unable + to read any of the file; we handle what we could get from the + file. */ + break; + + case CF_READ_ABORTED: + /* The user bailed out of re-reading the capture file; the + capture file has been closed - just free the capture file name + string and return (without changing the last containing + directory). */ + capture_file_.setCapFile(NULL); + ret = false; + goto finish; + } + break; + } + + mainApp->setLastOpenDirFromFilename(cf_path); + + main_ui_->statusBar->showExpert(); + +finish: +#ifdef HAVE_LIBPCAP + if (global_commandline_info.quit_after_cap) + exit(0); +#endif + return ret; +} + +void WiresharkMainWindow::filterPackets(QString new_filter, bool force) +{ + cf_status_t cf_status; + + cf_status = cf_filter_packets(CaptureFile::globalCapFile(), new_filter.toUtf8().data(), force); + + if (cf_status == CF_OK) { + if (new_filter.length() > 0) { + int index = df_combo_box_->findText(new_filter); + if (index == -1) { + df_combo_box_->insertItem(0, new_filter); + df_combo_box_->setCurrentIndex(0); + } else { + df_combo_box_->setCurrentIndex(index); + } + } else { + df_combo_box_->lineEdit()->clear(); + } + // Only after the display filter has been updated, + // disable the arrow button + emit displayFilterSuccess(true); + } else { + emit displayFilterSuccess(false); + } +} + +void WiresharkMainWindow::layoutToolbars() +{ + Qt::ToolButtonStyle tbstyle = Qt::ToolButtonIconOnly; + switch (prefs.gui_toolbar_main_style) { + case TB_STYLE_TEXT: + tbstyle = Qt::ToolButtonTextOnly; + break; + case TB_STYLE_BOTH: + tbstyle = Qt::ToolButtonTextUnderIcon; + break; + } + + main_ui_->mainToolBar->setToolButtonStyle(tbstyle); + + main_ui_->mainToolBar->setVisible(recent.main_toolbar_show); + main_ui_->displayFilterToolBar->setVisible(recent.filter_toolbar_show); +#if defined(HAVE_LIBNL) && defined(HAVE_NL80211) + main_ui_->wirelessToolBar->setVisible(recent.wireless_toolbar_show); +#endif + main_ui_->statusBar->setVisible(recent.statusbar_show); + + foreach(QAction *action, main_ui_->menuInterfaceToolbars->actions()) { + QToolBar *toolbar = action->data().value<QToolBar *>(); + if (g_list_find_custom(recent.interface_toolbars, action->text().toUtf8(), (GCompareFunc)strcmp)) { + toolbar->setVisible(true); + } else { + toolbar->setVisible(false); + } + } + + QList<QToolBar *> toolbars = findChildren<QToolBar *>(); + foreach(QToolBar *bar, toolbars) { + AdditionalToolBar *iftoolbar = dynamic_cast<AdditionalToolBar *>(bar); + if (iftoolbar) { + bool visible = false; + if (g_list_find_custom(recent.gui_additional_toolbars, qUtf8Printable(iftoolbar->menuName()), (GCompareFunc)strcmp)) + visible = true; + + iftoolbar->setVisible(visible); + + } + } +} + +void WiresharkMainWindow::updatePreferenceActions() +{ + main_ui_->actionViewPacketList->setEnabled(prefs_has_layout_pane_content(layout_pane_content_plist)); + main_ui_->actionViewPacketDetails->setEnabled(prefs_has_layout_pane_content(layout_pane_content_pdetails)); + main_ui_->actionViewPacketBytes->setEnabled(prefs_has_layout_pane_content(layout_pane_content_pbytes)); + main_ui_->actionViewPacketDiagram->setEnabled(prefs_has_layout_pane_content(layout_pane_content_pdiagram)); + + main_ui_->actionViewNameResolutionPhysical->setChecked(gbl_resolv_flags.mac_name); + main_ui_->actionViewNameResolutionNetwork->setChecked(gbl_resolv_flags.network_name); + main_ui_->actionViewNameResolutionTransport->setChecked(gbl_resolv_flags.transport_name); +} + +void WiresharkMainWindow::updateRecentActions() +{ + main_ui_->actionViewMainToolbar->setChecked(recent.main_toolbar_show); + main_ui_->actionViewFilterToolbar->setChecked(recent.filter_toolbar_show); + main_ui_->actionViewWirelessToolbar->setChecked(recent.wireless_toolbar_show); + main_ui_->actionViewStatusBar->setChecked(recent.statusbar_show); + main_ui_->actionViewPacketList->setChecked(recent.packet_list_show && prefs_has_layout_pane_content(layout_pane_content_plist)); + main_ui_->actionViewPacketDetails->setChecked(recent.tree_view_show && prefs_has_layout_pane_content(layout_pane_content_pdetails)); + main_ui_->actionViewPacketBytes->setChecked(recent.byte_view_show && prefs_has_layout_pane_content(layout_pane_content_pbytes)); + main_ui_->actionViewPacketDiagram->setChecked(recent.packet_diagram_show && prefs_has_layout_pane_content(layout_pane_content_pdiagram)); + + foreach(QAction *action, main_ui_->menuInterfaceToolbars->actions()) { + if (g_list_find_custom(recent.interface_toolbars, action->text().toUtf8(), (GCompareFunc)strcmp)) { + action->setChecked(true); + } else { + action->setChecked(false); + } + } + + foreach(QAction * action, main_ui_->menuAdditionalToolbars->actions()) { + ext_toolbar_t * toolbar = VariantPointer<ext_toolbar_t>::asPtr(action->data()); + bool checked = false; + if (toolbar && g_list_find_custom(recent.gui_additional_toolbars, toolbar->name, (GCompareFunc)strcmp)) + checked = true; + + action->setChecked(checked); + } + + foreach(QAction* tda, td_actions.keys()) { + if (recent.gui_time_format == td_actions[tda]) { + tda->setChecked(true); + } + } + foreach(QAction* tpa, tp_actions.keys()) { + if (recent.gui_time_precision == tp_actions[tpa]) { + tpa->setChecked(true); + break; + } + } + main_ui_->actionViewTimeDisplaySecondsWithHoursAndMinutes->setChecked(recent.gui_seconds_format == TS_SECONDS_HOUR_MIN_SEC); + + main_ui_->actionViewColorizePacketList->setChecked(recent.packet_list_colorize); + + main_ui_->actionGoAutoScroll->setChecked(recent.capture_auto_scroll); +} + +// Don't connect to this directly. Connect to or emit fiterAction(...) instead. +void WiresharkMainWindow::queuedFilterAction(QString action_filter, FilterAction::Action action, FilterAction::ActionType type) +{ + QString cur_filter, new_filter; + + if (!df_combo_box_) return; + cur_filter = df_combo_box_->lineEdit()->text(); + + switch (type) { + case FilterAction::ActionTypePlain: + new_filter = action_filter; + break; + case FilterAction::ActionTypeAnd: + if (cur_filter.length()) { + new_filter = "(" + cur_filter + ") && (" + action_filter + ")"; + } + else { + new_filter = action_filter; + } + break; + case FilterAction::ActionTypeOr: + if (cur_filter.length()) { + new_filter = "(" + cur_filter + ") || (" + action_filter + ")"; + } else { + new_filter = action_filter; + } + break; + case FilterAction::ActionTypeNot: + new_filter = "!(" + action_filter + ")"; + break; + case FilterAction::ActionTypeAndNot: + if (cur_filter.length()) { + new_filter = "(" + cur_filter + ") && !(" + action_filter + ")"; + } else { + new_filter = "!(" + action_filter + ")"; + } + break; + case FilterAction::ActionTypeOrNot: + if (cur_filter.length()) { + new_filter = "(" + cur_filter + ") || !(" + action_filter + ")"; + } else { + new_filter = "!(" + action_filter + ")"; + } + break; + default: + ws_assert_not_reached(); + break; + } + + switch (action) { + case FilterAction::ActionApply: + df_combo_box_->lineEdit()->setText(new_filter); + df_combo_box_->applyDisplayFilter(); + break; + case FilterAction::ActionColorize: + colorizeWithFilter(new_filter.toUtf8()); + break; + case FilterAction::ActionCopy: + mainApp->clipboard()->setText(new_filter); + break; + case FilterAction::ActionFind: + main_ui_->searchFrame->findFrameWithFilter(new_filter); + break; + case FilterAction::ActionPrepare: + df_combo_box_->lineEdit()->setText(new_filter); + df_combo_box_->lineEdit()->setFocus(); + break; + case FilterAction::ActionWebLookup: + { + QString url = QString("https://www.google.com/search?q=") + new_filter; + QDesktopServices::openUrl(QUrl(url)); + break; + } + default: + ws_assert_not_reached(); + break; + } +} + +// Capture callbacks + +#ifdef HAVE_LIBPCAP +void WiresharkMainWindow::captureCapturePrepared(capture_session *session) { + setTitlebarForCaptureInProgress(); + + setWindowIcon(mainApp->captureIcon()); + + /* Disable menu items that make no sense if you're currently running + a capture. */ + bool handle_toolbars = (session->session_will_restart ? false : true); + setForCaptureInProgress(true, handle_toolbars, session->capture_opts->ifaces); +// set_capture_if_dialog_for_capture_in_progress(TRUE); + +// /* Don't set up main window for a capture file. */ +// main_set_for_capture_file(FALSE); + showCapture(); +} + +void WiresharkMainWindow::captureCaptureUpdateStarted(capture_session *session) { + + /* We've done this in "prepared" above, but it will be cleared while + switching to the next multiple file. */ + setTitlebarForCaptureInProgress(); + setWindowIcon(mainApp->captureIcon()); + + bool handle_toolbars = (session->session_will_restart ? false : true); + setForCaptureInProgress(true, handle_toolbars, session->capture_opts->ifaces); + + setForCapturedPackets(true); +} + +void WiresharkMainWindow::captureCaptureUpdateFinished(capture_session *session) { + + /* The capture isn't stopping any more - it's stopped. */ + capture_stopping_ = false; + + /* Update the main window as appropriate */ + updateForUnsavedChanges(); + + /* Enable menu items that make sense if you're not currently running + a capture. */ + bool handle_toolbars = (session->session_will_restart ? false : true); + setForCaptureInProgress(false, handle_toolbars); + setMenusForCaptureFile(); + + setWindowIcon(mainApp->normalIcon()); + popLiveCaptureInProgress(); + + if (global_commandline_info.quit_after_cap) { + // Command line asked us to quit after capturing. + // Don't pop up a dialog to ask for unsaved files etc. + exit(0); + } +} + +void WiresharkMainWindow::captureCaptureFixedFinished(capture_session *) { + + /* The capture isn't stopping any more - it's stopped. */ + capture_stopping_ = false; + + /* Enable menu items that make sense if you're not currently running + a capture. */ + setForCaptureInProgress(false); + /* There isn't a real capture_file structure yet, so just force disabling + menu options. They will "refresh" when the capture file is reloaded to + display packets */ + setMenusForCaptureFile(true); + + setWindowIcon(mainApp->normalIcon()); + popLiveCaptureInProgress(); + + if (global_commandline_info.quit_after_cap) { + // Command line asked us to quit after capturing. + // Don't pop up a dialog to ask for unsaved files etc. + exit(0); + } +} + +void WiresharkMainWindow::captureCaptureFailed(capture_session *) { + /* Capture isn't stopping any more. */ + capture_stopping_ = false; + + setForCaptureInProgress(false); + showWelcome(); + + // Reset expert information indicator + main_ui_->statusBar->captureFileClosing(); + mainApp->popStatus(WiresharkApplication::FileStatus); + + setWindowIcon(mainApp->normalIcon()); + popLiveCaptureInProgress(); + + if (global_commandline_info.quit_after_cap) { + // Command line asked us to quit after capturing. + // Don't pop up a dialog to ask for unsaved files etc. + exit(0); + } +} +#endif // HAVE_LIBPCAP + +// Callbacks from cfile.c and file.c via CaptureFile::captureFileCallback + +void WiresharkMainWindow::captureEventHandler(CaptureEvent ev) +{ + switch (ev.captureContext()) { + + case CaptureEvent::File: + switch (ev.eventType()) { + case CaptureEvent::Opened: + captureFileOpened(); + break; + case CaptureEvent::Closing: + captureFileClosing(); + break; + case CaptureEvent::Closed: + captureFileClosed(); + break; + case CaptureEvent::Started: + captureFileReadStarted(tr("Loading")); + break; + case CaptureEvent::Finished: + captureFileReadFinished(); + break; + default: + break; + } + break; + + case CaptureEvent::Reload: + switch (ev.eventType()) { + case CaptureEvent::Started: + captureFileReadStarted(tr("Reloading")); + break; + case CaptureEvent::Finished: + captureFileReadFinished(); + break; + default: + break; + } + break; + + case CaptureEvent::Rescan: + switch (ev.eventType()) { + case CaptureEvent::Started: + setMenusForCaptureFile(true); + captureFileReadStarted(tr("Rescanning")); + break; + case CaptureEvent::Finished: + captureFileReadFinished(); + break; + default: + break; + } + break; + + case CaptureEvent::Retap: + switch (ev.eventType()) { + case CaptureEvent::Started: + freeze(); + break; + case CaptureEvent::Finished: + thaw(); + break; + case CaptureEvent::Flushed: + draw_tap_listeners(FALSE); + break; + default: + break; + } + break; + + case CaptureEvent::Merge: + switch (ev.eventType()) { + case CaptureEvent::Started: + mainApp->popStatus(WiresharkApplication::FileStatus); + mainApp->pushStatus(WiresharkApplication::FileStatus, tr("Merging files."), QString()); + break; + case CaptureEvent::Finished: + mainApp->popStatus(WiresharkApplication::FileStatus); + break; + default: + break; + } + break; + + case CaptureEvent::Save: + switch (ev.eventType()) { + case CaptureEvent::Started: + { + QFileInfo file_info(ev.filePath()); + mainApp->popStatus(WiresharkApplication::FileStatus); + mainApp->pushStatus(WiresharkApplication::FileStatus, tr("Saving %1…").arg(file_info.fileName())); + break; + } + default: + break; + } + break; + +#ifdef HAVE_LIBPCAP + case CaptureEvent::Capture: + switch (ev.eventType()) { + case CaptureEvent::Prepared: + captureCapturePrepared(ev.capSession()); + break; + case CaptureEvent::Stopping: + capture_stopping_ = true; + setMenusForCaptureStopping(); + break; + case CaptureEvent::Failed: + captureCaptureFailed(ev.capSession()); + default: + break; + } + break; + + case CaptureEvent::Update: + switch (ev.eventType()) { + case CaptureEvent::Started: + captureCaptureUpdateStarted(ev.capSession()); + break; + case CaptureEvent::Finished: + captureCaptureUpdateFinished(ev.capSession()); + break; + default: + break; + } + break; + + case CaptureEvent::Fixed: + switch (ev.eventType()) { + case CaptureEvent::Finished: + captureCaptureFixedFinished(ev.capSession()); + break; + default: + break; + } + break; +#endif + } +} + +void WiresharkMainWindow::captureFileOpened() { + if (capture_file_.window() != this) return; + + file_set_dialog_->fileOpened(capture_file_.capFile()); + setMenusForFileSet(true); + emit setCaptureFile(capture_file_.capFile()); +} + +void WiresharkMainWindow::captureFileReadStarted(const QString &action) { +// tap_param_dlg_update(); + + /* Set up main window for a capture file. */ +// main_set_for_capture_file(TRUE); + + mainApp->popStatus(WiresharkApplication::FileStatus); + QString msg = QString(tr("%1: %2")).arg(action).arg(capture_file_.fileName()); + QString msgtip = QString(); + mainApp->pushStatus(WiresharkApplication::FileStatus, msg, msgtip); + showCapture(); + main_ui_->actionAnalyzeReloadLuaPlugins->setEnabled(false); + main_ui_->wirelessTimelineWidget->captureFileReadStarted(capture_file_.capFile()); +} + +void WiresharkMainWindow::captureFileReadFinished() { + if (!capture_file_.capFile()->is_tempfile && capture_file_.capFile()->filename) { + /* Add this filename to the list of recent files in the "Recent Files" submenu */ + add_menu_recent_capture_file(capture_file_.capFile()->filename); + + /* Remember folder for next Open dialog and save it in recent */ + mainApp->setLastOpenDirFromFilename(capture_file_.capFile()->filename); + } + + /* Update the appropriate parts of the main window. */ + updateForUnsavedChanges(); + + /* enable wireless timeline if capture allows it */ + main_ui_->wirelessTimelineWidget->captureFileReadFinished(); + + /* Enable menu items that make sense if you have some captured packets. */ + setForCapturedPackets(true); + + main_ui_->statusBar->setFileName(capture_file_); + main_ui_->actionAnalyzeReloadLuaPlugins->setEnabled(true); + + packet_list_->captureFileReadFinished(); + + emit setDissectedCaptureFile(capture_file_.capFile()); +} + +void WiresharkMainWindow::captureFileClosing() { + setMenusForCaptureFile(true); + setForCapturedPackets(false); + setForCaptureInProgress(false); + + // Reset expert information indicator + main_ui_->statusBar->captureFileClosing(); + main_ui_->searchFrame->animatedHide(); + main_ui_->goToFrame->animatedHide(); + // gtk_widget_show(expert_info_none); + emit setCaptureFile(NULL); + emit setDissectedCaptureFile(NULL); +} + +void WiresharkMainWindow::captureFileClosed() { + packets_bar_update(); + + file_set_dialog_->fileClosed(); + setMenusForFileSet(false); + setWindowModified(false); + + // Reset expert information indicator + main_ui_->statusBar->captureFileClosing(); + mainApp->popStatus(WiresharkApplication::FileStatus); + + setWSWindowTitle(); + setWindowIcon(mainApp->normalIcon()); + setMenusForSelectedPacket(); + setMenusForSelectedTreeRow(); + +#ifdef HAVE_LIBPCAP + if (!global_capture_opts.multi_files_on) + showWelcome(); +#endif +} + +// +// Private slots +// + +// ui/gtk/capture_dlg.c:start_capture_confirmed + +void WiresharkMainWindow::startCapture() { + startCapture(QStringList()); +} + +void WiresharkMainWindow::startCapture(QStringList interfaces _U_) { +#ifdef HAVE_LIBPCAP + interface_options *interface_opts; + guint i; + interface_t *device; + gboolean can_start_capture = TRUE; + + if (interfaces.count() > 0) { + global_capture_opts.num_selected = 0; + for (i = 0; i < global_capture_opts.all_ifaces->len; i++) { + device = &g_array_index(global_capture_opts.all_ifaces, interface_t, i); + + if (interfaces.contains(device->name)) { + device->selected = TRUE; + global_capture_opts.num_selected++; + } + else { + device->selected = FALSE; + } + } + } + + /* did the user ever select a capture interface before? */ + if (global_capture_opts.num_selected == 0) { + QString msg = QString(tr("No interface selected.")); + mainApp->pushStatus(WiresharkApplication::TemporaryStatus, msg); + main_ui_->actionCaptureStart->setChecked(false); + return; + } + + for (i = 0; i < global_capture_opts.all_ifaces->len; i++) { + device = &g_array_index(global_capture_opts.all_ifaces, interface_t, i); + if (device->selected && (device->if_info.type == IF_EXTCAP)) { + /* device is EXTCAP and is selected. Check if all mandatory + * settings are set. + */ + if (extcap_requires_configuration(device->name)) + { + /* Request openning of extcap options dialog */ + QString device_name(device->name); + emit showExtcapOptions(device_name, false); + /* Cancel start of capture */ + can_start_capture = FALSE; + } + } + } + + /* If some of extcap was not configured, do not start with the capture */ + if (!can_start_capture) { + QString msg = QString(tr("Configure all extcaps before start of capture.")); + mainApp->pushStatus(WiresharkApplication::TemporaryStatus, msg); + main_ui_->actionCaptureStart->setChecked(false); + return; + } + + // Ideally we should have disabled the start capture + // toolbar buttons and menu items. This may not be the + // case, e.g. with QtMacExtras. + if (!capture_filter_valid_) { + QString msg = QString(tr("Invalid capture filter.")); + mainApp->pushStatus(WiresharkApplication::TemporaryStatus, msg); + main_ui_->actionCaptureStart->setChecked(false); + return; + } + + showCapture(); + + /* XXX - we might need to init other pref data as well... */ + main_ui_->actionGoAutoScroll->setChecked(recent.capture_auto_scroll); + + /* XXX - can this ever happen? */ + if (cap_session_.state != CAPTURE_STOPPED) + return; + + /* close the currently loaded capture file */ + cf_close((capture_file *)cap_session_.cf); + + /* Copy the selected interfaces to the set of interfaces to use for + this capture. */ + collect_ifaces(&global_capture_opts); + + CaptureFile::globalCapFile()->window = this; + info_data_.ui.ui = this; + if (capture_start(&global_capture_opts, NULL, &cap_session_, &info_data_, + main_window_update)) { + capture_options *capture_opts = cap_session_.capture_opts; + GString *interface_names; + + /* Add "interface name<live capture in progress>" on main status bar */ + interface_names = get_iface_list_string(capture_opts, 0); + if (strlen(interface_names->str) > 0) { + g_string_append(interface_names, ":"); + } + g_string_append(interface_names, " "); + + mainApp->popStatus(WiresharkApplication::FileStatus); + QString msg = QString("%1<live capture in progress>").arg(interface_names->str); + QString msgtip = QString("to file: "); + if (capture_opts->save_file) + msgtip += capture_opts->save_file; + mainApp->pushStatus(WiresharkApplication::FileStatus, msg, msgtip); + g_string_free(interface_names, TRUE); + + /* The capture succeeded, which means the capture filter syntax is + valid; add this capture filter to the recent capture filter list. */ + QByteArray filter_ba; + for (i = 0; i < global_capture_opts.ifaces->len; i++) { + interface_opts = &g_array_index(global_capture_opts.ifaces, interface_options, i); + if (interface_opts->cfilter) { + recent_add_cfilter(interface_opts->name, interface_opts->cfilter); + if (filter_ba.isEmpty()) { + filter_ba = interface_opts->cfilter; + } else { + /* Not the first selected interface; is its capture filter + the same as the one the other interfaces we've looked + at have? */ + /* XXX: GCC 12.1 has a bogus warning at -O2 and higher + * even though the isEmpty() check guarantees that + * filter_ba.constData() is never NULL or empty. + */ +#if WS_IS_AT_LEAST_GNUC_VERSION(12,1) +DIAG_OFF(stringop-overread) +#endif + if (strcmp(interface_opts->cfilter, filter_ba.constData()) != 0) { +#if WS_IS_AT_LEAST_GNUC_VERSION(12,1) +DIAG_ON(stringop-overread) +#endif + /* No, so not all selected interfaces have the same capture + filter. */ + filter_ba.clear(); + } + } + } + } + if (!filter_ba.isEmpty()) { + recent_add_cfilter(NULL, filter_ba.constData()); + } + } else { + CaptureFile::globalCapFile()->window = NULL; + } +#endif // HAVE_LIBPCAP +} + +void WiresharkMainWindow::popLiveCaptureInProgress() { + /* Pop the "<live capture in progress>" message off the status bar. */ + main_ui_->statusBar->setFileName(capture_file_); +} + +void WiresharkMainWindow::stopCapture() { +//#ifdef HAVE_AIRPCAP +// if (airpcap_if_active) +// airpcap_set_toolbar_stop_capture(airpcap_if_active); +//#endif + +#ifdef HAVE_LIBPCAP + capture_stop(&cap_session_); +#endif // HAVE_LIBPCAP + +} + +// Keep focus rects from showing through the welcome screen. Primarily for +// macOS. +void WiresharkMainWindow::mainStackChanged(int) +{ + for (int i = 0; i < main_ui_->mainStack->count(); i++) { + main_ui_->mainStack->widget(i)->setEnabled(i == main_ui_->mainStack->currentIndex()); + } +} + +// XXX - Copied from ui/gtk/menus.c + +/** + * Add the capture filename (with an absolute path) to the "Recent Files" menu. + */ +// XXX - We should probably create a RecentFile class. +void WiresharkMainWindow::updateRecentCaptures() { + QAction *ra; + QMenu *recentMenu = main_ui_->menuOpenRecentCaptureFile; + QString action_cf_name; + + if (!recentMenu) { + return; + } + recentMenu->clear(); + +#if 0 +#if defined(QT_WINEXTRAS_LIB) + QWinJumpList recent_jl(this); + QWinJumpListCategory *recent_jlc = recent_jl.recent(); + if (recent_jlc) { + recent_jlc->clear(); + recent_jlc->setVisible(true); + } +#endif +#endif +#if defined(Q_OS_MAC) + if (!dock_menu_) { + dock_menu_ = new QMenu(); + dock_menu_->setAsDockMenu(); + } + dock_menu_->clear(); +#endif + + /* Iterate through the actions in menuOpenRecentCaptureFile, + * removing special items, a maybe duplicate entry and every item above count_max */ + int shortcut = Qt::Key_0; + foreach(recent_item_status *ri, mainApp->recentItems()) { + // Add the new item + ra = new QAction(recentMenu); + ra->setData(ri->filename); + // XXX - Needs get_recent_item_status or equivalent + ra->setEnabled(ri->accessible); + recentMenu->insertAction(NULL, ra); + action_cf_name = ra->data().toString(); + if (shortcut <= Qt::Key_9) { + ra->setShortcut(Qt::META | (Qt::Key)shortcut); + shortcut++; + } + ra->setText(action_cf_name); + connect(ra, SIGNAL(triggered()), this, SLOT(recentActionTriggered())); + +/* This is slow, at least on my VM here. The added links also open Wireshark + * in a new window. It might make more sense to add a recent item when we + * open a capture file. */ +#if 0 +#if defined(QT_WINEXTRAS_LIB) + if (recent_jlc) { + QFileInfo fi(ri->filename); + QWinJumpListItem *jli = recent_jlc->addLink( + fi.fileName(), + QApplication::applicationFilePath(), + QStringList() << "-r" << ri->filename + ); + // XXX set icon + jli->setWorkingDirectory(QDir::toNativeSeparators(QApplication::applicationDirPath())); + } +#endif +#endif +#if defined(Q_OS_MAC) + QAction *rda = new QAction(dock_menu_); + QFileInfo fi(ri->filename); + rda->setText(fi.fileName()); + dock_menu_->insertAction(NULL, rda); + connect(rda, SIGNAL(triggered()), ra, SLOT(trigger())); +#endif + } + + if (recentMenu->actions().count() > 0) { + // Separator + "Clear" + // XXX - Do we really need this? + ra = new QAction(recentMenu); + ra->setSeparator(true); + recentMenu->insertAction(NULL, ra); + + ra = new QAction(recentMenu); + ra->setText(tr("Clear Menu")); + recentMenu->insertAction(NULL, ra); + connect(ra, SIGNAL(triggered()), mainApp, SLOT(clearRecentCaptures())); + } else { + if (main_ui_->actionDummyNoFilesFound) { + recentMenu->addAction(main_ui_->actionDummyNoFilesFound); + } + } +} + +void WiresharkMainWindow::recentActionTriggered() { + QAction *ra = qobject_cast<QAction*>(sender()); + + if (ra) { + QString cfPath = ra->data().toString(); + openCaptureFile(cfPath); + } +} + +QString WiresharkMainWindow::commentToMenuText(QString text, int max_len) +{ + text = text.trimmed().replace(QRegularExpression("(\\r?\\n|\\r\\n?)+"), " "); + if (text.size() > 0) { + if (text.size() > max_len) { + text.truncate(max_len); + text += "…"; + } + } + else { + text = tr("(empty comment)", "placeholder for empty comment"); + } + return text; +} + +void WiresharkMainWindow::setEditCommentsMenu() +{ + main_ui_->menuPacketComment->clear(); + QAction *action = main_ui_->menuPacketComment->addAction(tr("Add New Comment…")); + connect(action, &QAction::triggered, this, &WiresharkMainWindow::addPacketComment); + action->setShortcut(QKeySequence(Qt::CTRL | Qt::ALT | Qt::Key_C)); + if (selectedRows().count() == 1) { + const int thisRow = selectedRows().first(); + frame_data * current_frame = frameDataForRow(thisRow); + wtap_block_t pkt_block = cf_get_packet_block(capture_file_.capFile(), current_frame); + guint nComments = wtap_block_count_option(pkt_block, OPT_COMMENT); + if (nComments > 0) { + main_ui_->menuPacketComment->addSeparator(); + for (guint i = 0; i < nComments; i++) { + QString comment = packet_list_->getPacketComment(i); + comment = this->commentToMenuText(comment); + action = main_ui_->menuPacketComment->addAction(tr("Edit \"%1\"", "edit packet comment").arg(comment)); + connect(action, &QAction::triggered, this, &WiresharkMainWindow::editPacketComment); + action->setData(i); + } + + main_ui_->menuPacketComment->addSeparator(); + for (guint i = 0; i < nComments; i++) { + QString comment = packet_list_->getPacketComment(i); + comment = this->commentToMenuText(comment); + action = main_ui_->menuPacketComment->addAction(tr("Delete \"%1\"", "delete packet comment").arg(comment)); + connect(action, &QAction::triggered, this, &WiresharkMainWindow::deletePacketComment); + action->setData(i); + } + main_ui_->menuPacketComment->addSeparator(); + action = main_ui_->menuPacketComment->addAction(tr("Delete packet comments")); + connect(action, &QAction::triggered, this, &WiresharkMainWindow::deleteCommentsFromPackets); + } + wtap_block_unref(pkt_block); + } + if (selectedRows().count() > 1) { + main_ui_->menuPacketComment->addSeparator(); + action = main_ui_->menuPacketComment->addAction(tr("Delete comments from %n packet(s)", nullptr, static_cast<int>(selectedRows().count()))); + connect(action, &QAction::triggered, this, &WiresharkMainWindow::deleteCommentsFromPackets); + } +} + +void WiresharkMainWindow::setMenusForSelectedPacket() +{ + gboolean is_ip = FALSE, is_tcp = FALSE, is_udp = FALSE, is_sctp = FALSE, is_tls = FALSE, is_rtp = FALSE, is_lte_rlc = FALSE, + is_quic = FALSE, is_exported_pdu = FALSE; + + /* Making the menu context-sensitive allows for easier selection of the + desired item and has the added benefit, with large captures, of + avoiding needless looping through huge lists for marked, ignored, + or time-referenced packets. */ + + /* We have one or more items in the packet list */ + bool have_frames = false; + /* A frame is selected */ + bool frame_selected = false; + bool multi_selection = false; + /* A visible packet comes after this one in the selection history */ + bool next_selection_history = false; + /* A visible packet comes before this one in the selection history */ + bool previous_selection_history = false; + /* We have marked frames. (XXX - why check frame_selected?) */ + bool have_marked = false; + /* We have a marked frame other than the current frame (i.e., + we have at least one marked frame, and either there's more + than one marked frame or the current frame isn't marked). */ + bool another_is_marked = false; + /* One or more frames are hidden by a display filter */ + bool have_filtered = false; + /* One or more frames have been ignored */ + bool have_ignored = false; + bool have_time_ref = false; + /* We have a time reference frame other than the current frame (i.e., + we have at least one time reference frame, and either there's more + than one time reference frame or the current frame isn't a + time reference frame). (XXX - why check frame_selected?) */ + bool another_is_time_ref = false; + + QList<QAction *> cc_actions = QList<QAction *>() + << main_ui_->actionViewColorizeConversation1 << main_ui_->actionViewColorizeConversation2 + << main_ui_->actionViewColorizeConversation3 << main_ui_->actionViewColorizeConversation4 + << main_ui_->actionViewColorizeConversation5 << main_ui_->actionViewColorizeConversation6 + << main_ui_->actionViewColorizeConversation7 << main_ui_->actionViewColorizeConversation8 + << main_ui_->actionViewColorizeConversation9 << main_ui_->actionViewColorizeConversation10; + + if (capture_file_.capFile()) { + QList<int> rows = selectedRows(); + frame_data * current_frame = 0; + if (rows.count() > 0) + current_frame = frameDataForRow(rows.at(0)); + + frame_selected = rows.count() == 1; + if (packet_list_->multiSelectActive()) + { + frame_selected = false; + multi_selection = true; + } + next_selection_history = packet_list_->haveNextHistory(); + previous_selection_history = packet_list_->havePreviousHistory(); + have_frames = capture_file_.capFile()->count > 0; + have_marked = capture_file_.capFile()->marked_count > 0; + another_is_marked = have_marked && rows.count() <= 1 && + !(capture_file_.capFile()->marked_count == 1 && frame_selected && current_frame->marked); + have_filtered = capture_file_.capFile()->displayed_count > 0 && capture_file_.capFile()->displayed_count != capture_file_.capFile()->count; + have_ignored = capture_file_.capFile()->ignored_count > 0; + have_time_ref = capture_file_.capFile()->ref_time_count > 0; + another_is_time_ref = have_time_ref && rows.count() <= 1 && + !(capture_file_.capFile()->ref_time_count == 1 && frame_selected && current_frame->ref_time); + + if (capture_file_.capFile()->edt && ! multi_selection) + { + proto_get_frame_protocols(capture_file_.capFile()->edt->pi.layers, + &is_ip, &is_tcp, &is_udp, &is_sctp, + &is_tls, &is_rtp, &is_lte_rlc); + /* TODO: to follow a QUIC stream we need a *decrypted* QUIC connection, i.e. checking for "quic" in the protocol stack is not enough */ + is_quic = proto_is_frame_protocol(capture_file_.capFile()->edt->pi.layers, "quic"); + is_exported_pdu = proto_is_frame_protocol(capture_file_.capFile()->edt->pi.layers, "exported_pdu"); + /* For Exported PDU there is a tag inserting IP addresses into the SRC and DST columns */ + if (is_exported_pdu && + (capture_file_.capFile()->edt->pi.net_src.type == AT_IPv4 || capture_file_.capFile()->edt->pi.net_src.type == AT_IPv6) && + (capture_file_.capFile()->edt->pi.net_dst.type == AT_IPv4 || capture_file_.capFile()->edt->pi.net_dst.type == AT_IPv6)) { + is_ip = TRUE; + } + foreach (FollowStreamAction *follow_action, main_ui_->menuFollow->findChildren<FollowStreamAction *>()) { + /* QUIC has TLS handshakes; don't enabled Follow TLS Stream if + * there's QUIC. + */ + gboolean is_frame = proto_is_frame_protocol(capture_file_.capFile()->edt->pi.layers, follow_action->filterName()); + if (g_strcmp0(follow_action->filterName(), "tls") == 0) { + follow_action->setEnabled(is_frame && !is_quic); + } else { + follow_action->setEnabled(is_frame); + } + } + } + } + + main_ui_->actionEditMarkPacket->setText(tr("&Mark/Unmark Packet(s)", "", static_cast<int>(selectedRows().count()))); + main_ui_->actionEditIgnorePacket->setText(tr("&Ignore/Unignore Packet(s)", "", static_cast<int>(selectedRows().count()))); + + main_ui_->actionCopyListAsText->setEnabled(selectedRows().count() > 0); + main_ui_->actionCopyListAsCSV->setEnabled(selectedRows().count() > 0); + main_ui_->actionCopyListAsYAML->setEnabled(selectedRows().count() > 0); + + main_ui_->actionEditMarkPacket->setEnabled(frame_selected || multi_selection); + main_ui_->actionEditMarkAllDisplayed->setEnabled(have_frames); + /* Unlike un-ignore, do not allow unmark of all frames when no frames are displayed */ + main_ui_->actionEditUnmarkAllDisplayed->setEnabled(have_marked); + main_ui_->actionEditNextMark->setEnabled(another_is_marked); + main_ui_->actionEditPreviousMark->setEnabled(another_is_marked); + + GArray * linkTypes = Q_NULLPTR; + if (capture_file_.capFile() && capture_file_.capFile()->linktypes) + linkTypes = capture_file_.capFile()->linktypes; + + bool enableEditComments = linkTypes && wtap_dump_can_write(capture_file_.capFile()->linktypes, WTAP_COMMENT_PER_PACKET); + main_ui_->menuPacketComment->setEnabled(enableEditComments && selectedRows().count() > 0); + main_ui_->actionDeleteAllPacketComments->setEnabled(enableEditComments); + + main_ui_->actionEditIgnorePacket->setEnabled(frame_selected || multi_selection); + main_ui_->actionEditIgnoreAllDisplayed->setEnabled(have_filtered); + /* Allow un-ignore of all frames even with no frames currently displayed */ + main_ui_->actionEditUnignoreAllDisplayed->setEnabled(have_ignored); + + // XXX: Should we allow frames that don't have a time stamp to be + // set as time references? "Time" references are also used to reset + // the "Cumulative Bytes", so it's not entirely useless. + main_ui_->actionEditSetTimeReference->setEnabled(frame_selected); + main_ui_->actionEditUnsetAllTimeReferences->setEnabled(have_time_ref); + main_ui_->actionEditNextTimeReference->setEnabled(another_is_time_ref); + main_ui_->actionEditPreviousTimeReference->setEnabled(another_is_time_ref); + main_ui_->actionEditTimeShift->setEnabled(have_frames); + + main_ui_->actionGoGoToLinkedPacket->setEnabled(false); + main_ui_->actionGoNextHistoryPacket->setEnabled(next_selection_history); + main_ui_->actionGoPreviousHistoryPacket->setEnabled(previous_selection_history); + + foreach(QAction *cc_action, cc_actions) { + cc_action->setEnabled(frame_selected); + } + main_ui_->actionViewColorizeNewColoringRule->setEnabled(frame_selected); + + main_ui_->actionViewColorizeResetColorization->setEnabled(tmp_color_filters_used()); + + main_ui_->actionViewShowPacketInNewWindow->setEnabled(frame_selected); + main_ui_->actionViewEditResolvedName->setEnabled(frame_selected && is_ip); + + emit packetInfoChanged(capture_file_.packetInfo()); + +// set_menu_sensitivity(ui_manager_main_menubar, "/Menubar/ViewMenu/NameResolution/ResolveName", +// frame_selected && (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name || +// gbl_resolv_flags.transport_name)); + + main_ui_->actionToolsFirewallAclRules->setEnabled(frame_selected); + + main_ui_->actionStatisticsTcpStreamRoundTripTime->setEnabled(is_tcp); + main_ui_->actionStatisticsTcpStreamStevens->setEnabled(is_tcp); + main_ui_->actionStatisticsTcpStreamTcptrace->setEnabled(is_tcp); + main_ui_->actionStatisticsTcpStreamThroughput->setEnabled(is_tcp); + main_ui_->actionStatisticsTcpStreamWindowScaling->setEnabled(is_tcp); + + main_ui_->actionSCTPAnalyseThisAssociation->setEnabled(is_sctp); + main_ui_->actionSCTPShowAllAssociations->setEnabled(is_sctp); + main_ui_->actionSCTPFilterThisAssociation->setEnabled(is_sctp); + main_ui_->actionTelephonyRtpStreamAnalysis->setEnabled(is_rtp); + main_ui_->actionTelephonyRtpPlayer->setEnabled(is_rtp); + main_ui_->actionTelephonyLteRlcGraph->setEnabled(is_lte_rlc); +} + +void WiresharkMainWindow::setMenusForSelectedTreeRow(FieldInformation *finfo) { + + bool can_match_selected = false; + bool is_framenum = false; + bool have_subtree = false; + bool can_open_url = false; + bool have_packet_bytes = false; + QByteArray field_filter; + int field_id = -1; + + field_info * fi = 0; + if (finfo) + fi = finfo->fieldInfo(); + + if (capture_file_.capFile()) { + capture_file_.capFile()->finfo_selected = fi; + + if (fi && fi->tree_type != -1) { + have_subtree = true; + } + + if (fi && fi->ds_tvb && (fi->length > 0)) { + have_packet_bytes = true; + } + } + + if (capture_file_.capFile() != NULL && fi != NULL) { + header_field_info *hfinfo = fi->hfinfo; + int linked_frame = -1; + + can_match_selected = proto_can_match_selected(capture_file_.capFile()->finfo_selected, capture_file_.capFile()->edt); + if (hfinfo && hfinfo->type == FT_FRAMENUM) { + is_framenum = true; + linked_frame = fvalue_get_uinteger(fi->value); + } + + char *tmp_field = proto_construct_match_selected_string(fi, capture_file_.capFile()->edt); + field_filter = tmp_field; + wmem_free(NULL, tmp_field); + emit fieldFilterChanged(field_filter); + + field_id = fi->hfinfo->id; + /* if the selected field isn't a protocol, get its parent */ + if (!proto_registrar_is_protocol(field_id)) { + field_id = proto_registrar_get_parent(fi->hfinfo->id); + } + + if (field_id >= 0) { + can_open_url = true; + main_ui_->actionContextWikiProtocolPage->setData(field_id); + main_ui_->actionContextFilterFieldReference->setData(field_id); + } else { + main_ui_->actionContextWikiProtocolPage->setData(QVariant()); + main_ui_->actionContextFilterFieldReference->setData(QVariant()); + } + + if (linked_frame > 0) { + main_ui_->actionGoGoToLinkedPacket->setData(linked_frame); + } else { + main_ui_->actionGoGoToLinkedPacket->setData(QVariant()); + } + } + + // Always enable / disable the following items. + main_ui_->actionCopyAllVisibleItems->setEnabled(capture_file_.capFile() != NULL && ! packet_list_->multiSelectActive()); + main_ui_->actionCopyAllVisibleSelectedTreeItems->setEnabled(can_match_selected); + main_ui_->actionEditCopyDescription->setEnabled(can_match_selected); + main_ui_->actionEditCopyFieldName->setEnabled(can_match_selected); + main_ui_->actionEditCopyValue->setEnabled(can_match_selected); + main_ui_->actionEditCopyAsFilter->setEnabled(can_match_selected); + + main_ui_->actionAnalyzeShowPacketBytes->setEnabled(have_packet_bytes); + main_ui_->actionFileExportPacketBytes->setEnabled(have_packet_bytes); + + main_ui_->actionViewExpandSubtrees->setEnabled(have_subtree); + main_ui_->actionViewCollapseSubtrees->setEnabled(have_subtree); + + main_ui_->actionGoGoToLinkedPacket->setEnabled(is_framenum); + + main_ui_->actionAnalyzeApplyAsColumn->setEnabled(can_match_selected); + + main_ui_->actionContextShowLinkedPacketInNewWindow->setEnabled(is_framenum); + + main_ui_->actionContextWikiProtocolPage->setEnabled(can_open_url); + main_ui_->actionContextFilterFieldReference->setEnabled(can_open_url); + + +// Only enable / disable the following items if we have focus so that we +// don't clobber anything we may have set in setMenusForSelectedPacket. + if (!proto_tree_ || !proto_tree_->hasFocus()) return; + + emit packetInfoChanged(capture_file_.packetInfo()); + + // set_menu_sensitivity(ui_manager_tree_view_menu, "/TreeViewPopup/ResolveName", + // frame_selected && (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name || + // gbl_resolv_flags.transport_name)); + +} + +void WiresharkMainWindow::interfaceSelectionChanged() +{ +#ifdef HAVE_LIBPCAP + // XXX This doesn't disable the toolbar button when using + // QtMacExtras. + if (global_capture_opts.num_selected > 0 && capture_filter_valid_) { + main_ui_->actionCaptureStart->setEnabled(true); + } else { + main_ui_->actionCaptureStart->setEnabled(false); + } +#endif // HAVE_LIBPCAP +} + +void WiresharkMainWindow::captureFilterSyntaxChanged(bool valid) +{ + capture_filter_valid_ = valid; + interfaceSelectionChanged(); +} + +void WiresharkMainWindow::startInterfaceCapture(bool valid, const QString capture_filter) +{ + capture_filter_valid_ = valid; + welcome_page_->setCaptureFilter(capture_filter); + QString before_what(tr(" before starting a new capture")); + if (testCaptureFileClose(before_what)) { + // The interface tree will update the selected interfaces via its timer + // so no need to do anything here. + startCapture(QStringList()); + } +} + +void WiresharkMainWindow::applyGlobalCommandLineOptions() +{ + if (global_dissect_options.time_format != TS_NOT_SET) { + foreach(QAction* tda, td_actions.keys()) { + if (global_dissect_options.time_format == td_actions[tda]) { + tda->setChecked(true); + // XXX - this means that if the user sets the + // time stamp format with the -t flag, that + // setting will persist and will be used as + // the default the next time Wireshark is run. + recent.gui_time_format = global_dissect_options.time_format; + timestamp_set_type(global_dissect_options.time_format); + break; + } + } + } + if (global_dissect_options.time_precision != TS_PREC_NOT_SET) { + foreach(QAction* tpa, tp_actions.keys()) { + if (global_dissect_options.time_precision == tp_actions[tpa]) { + tpa->setChecked(true); + // XXX - this means that if the user sets the + // time stamp precision with the -t flag, that + // setting will persist and will be used as + // the default the next time Wireshark is run. + recent.gui_time_precision = global_dissect_options.time_precision; + timestamp_set_precision(global_dissect_options.time_precision); + break; + } + } + } + if (global_commandline_info.full_screen) { + this->showFullScreen(); + } +} + +void WiresharkMainWindow::redissectPackets() +{ + if (capture_file_.capFile()) { + cf_redissect_packets(capture_file_.capFile()); + main_ui_->statusBar->expertUpdate(); + } + + proto_free_deregistered_fields(); +} + +void WiresharkMainWindow::checkDisplayFilter() +{ + if (!df_combo_box_->checkDisplayFilter()) { + g_free(CaptureFile::globalCapFile()->dfilter); + CaptureFile::globalCapFile()->dfilter = NULL; + } +} + +void WiresharkMainWindow::fieldsChanged() +{ + gchar *err_msg = NULL; + if (!color_filters_reload(&err_msg, color_filter_add_cb)) { + simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_msg); + g_free(err_msg); + } + tap_listeners_dfilter_recompile(); + + emit checkDisplayFilter(); + + if (have_custom_cols(&CaptureFile::globalCapFile()->cinfo)) { + // Recreate packet list columns according to new/changed/deleted fields + packet_list_->fieldsChanged(CaptureFile::globalCapFile()); + } + + emit reloadFields(); +} + +void WiresharkMainWindow::reloadLuaPlugins() +{ +#ifdef HAVE_LUA + if (mainApp->isReloadingLua()) + return; + + gboolean uses_lua_filehandler = FALSE; + + if (capture_file_.capFile()) { + // Check if the current capture file is opened with a Lua FileHandler + capture_file *cf = capture_file_.capFile(); + uses_lua_filehandler = wtap_uses_lua_filehandler(cf->provider.wth); + + if (uses_lua_filehandler && cf->unsaved_changes) { + // Prompt to save the file before reloading, in case the FileHandler has changed + QString before_what(tr(" before reloading Lua plugins")); + if (!testCaptureFileClose(before_what, Reload)) { + return; + } + } + } + + mainApp->setReloadingLua(true); + + wslua_reload_plugins(NULL, NULL); + this->clearAddedPacketMenus(); + funnel_statistics_reload_menus(); + reloadDynamicMenus(); + closePacketDialogs(); + + // Preferences may have been deleted so close all widgets using prefs + main_ui_->preferenceEditorFrame->animatedHide(); + + mainApp->readConfigurationFiles(true); + commandline_options_reapply(); + + fieldsChanged(); + prefs_apply_all(); + + if (uses_lua_filehandler) { + // Reload the file in case the FileHandler has changed + if (cf_reload(capture_file_.capFile()) != CF_OK) { + cf_close(capture_file_.capFile()); + } + proto_free_deregistered_fields(); + } else { + redissectPackets(); + } + + mainApp->setReloadingLua(false); + SimpleDialog::displayQueuedMessages(); +#endif +} + +void WiresharkMainWindow::showAccordionFrame(AccordionFrame *show_frame, bool toggle) +{ + QList<AccordionFrame *>frame_list = QList<AccordionFrame *>() + << main_ui_->goToFrame << main_ui_->searchFrame + << main_ui_->addressEditorFrame << main_ui_->columnEditorFrame + << main_ui_->preferenceEditorFrame << main_ui_->filterExpressionFrame; + + frame_list.removeAll(show_frame); + foreach(AccordionFrame *af, frame_list) af->animatedHide(); + + if (toggle) { + if (show_frame->isVisible()) { + show_frame->animatedHide(); + return; + } + } + show_frame->animatedShow(); +} + +void WiresharkMainWindow::showColumnEditor(int column) +{ + setPreviousFocus(); + main_ui_->columnEditorFrame->editColumn(column); + showAccordionFrame(main_ui_->columnEditorFrame); +} + +void WiresharkMainWindow::showPreferenceEditor() +{ + showAccordionFrame(main_ui_->preferenceEditorFrame); +} + +void WiresharkMainWindow::initViewColorizeMenu() +{ + QList<QAction *> cc_actions = QList<QAction *>() + << main_ui_->actionViewColorizeConversation1 << main_ui_->actionViewColorizeConversation2 + << main_ui_->actionViewColorizeConversation3 << main_ui_->actionViewColorizeConversation4 + << main_ui_->actionViewColorizeConversation5 << main_ui_->actionViewColorizeConversation6 + << main_ui_->actionViewColorizeConversation7 << main_ui_->actionViewColorizeConversation8 + << main_ui_->actionViewColorizeConversation9 << main_ui_->actionViewColorizeConversation10; + + guint8 color_num = 1; + + foreach(QAction *cc_action, cc_actions) { + cc_action->setData(color_num); + connect(cc_action, SIGNAL(triggered()), this, SLOT(colorizeConversation())); + + const color_filter_t *colorf = color_filters_tmp_color(color_num); + if (colorf) { + QColor bg = ColorUtils::fromColorT(colorf->bg_color); + QColor fg = ColorUtils::fromColorT(colorf->fg_color); + cc_action->setIcon(StockIcon::colorIcon(bg.rgb(), fg.rgb(), QString::number(color_num))); + } + color_num++; + } + +#ifdef Q_OS_MAC + // Spotlight uses Cmd+Space + main_ui_->actionViewColorizeResetColorization->setShortcut(QKeySequence("Meta+Space")); +#endif +} + +void WiresharkMainWindow::addStatsPluginsToMenu() { + GList *cfg_list = stats_tree_get_cfg_list(); + QAction *stats_tree_action; + QMenu *parent_menu; + bool first_item = true; + + for (GList *iter = g_list_first(cfg_list); iter; iter = gxx_list_next(iter)) { + stats_tree_cfg *cfg = gxx_list_data(stats_tree_cfg *, iter); + if (!menu_groups_.contains(cfg->stat_group)) { + continue; + } + if (cfg->plugin) { + if (first_item) { + main_ui_->menuStatistics->addSeparator(); + first_item = false; + } + + parent_menu = main_ui_->menuStatistics; + // gtk/main_menubar.c compresses double slashes, hence SkipEmptyParts +#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0) + QStringList cfg_name_parts = QString(cfg->name).split("/", Qt::SkipEmptyParts); +#else + QStringList cfg_name_parts = QString(cfg->name).split("/", QString::SkipEmptyParts); +#endif + if (cfg_name_parts.isEmpty()) continue; + + QString stat_name = cfg_name_parts.takeLast(); + if (!cfg_name_parts.isEmpty()) { + QString menu_name = cfg_name_parts.join("/"); + parent_menu = findOrAddMenu(parent_menu, menu_name); + } + + stats_tree_action = new QAction(stat_name, this); + stats_tree_action->setData(QString::fromUtf8(cfg->abbr)); + parent_menu->addAction(stats_tree_action); + connect(stats_tree_action, &QAction::triggered, this, [this]() { + QAction* action = qobject_cast<QAction*>(sender()); + if (action) { + openStatisticsTreeDialog(action->data().toString().toUtf8()); + } + }); + } + } + g_list_free(cfg_list); +} + +void WiresharkMainWindow::setFeaturesEnabled(bool enabled) +{ + main_ui_->menuBar->setEnabled(enabled); + main_ui_->mainToolBar->setEnabled(enabled); + main_ui_->displayFilterToolBar->setEnabled(enabled); + if (enabled) + { + main_ui_->statusBar->clearMessage(); +#ifdef HAVE_LIBPCAP + main_ui_->actionGoAutoScroll->setChecked(recent.capture_auto_scroll); +#endif + } + else + { + main_ui_->statusBar->showMessage(tr("Please wait while Wireshark is initializing…")); + } +} + +// Display Filter Toolbar + +void WiresharkMainWindow::on_actionNewDisplayFilterExpression_triggered() +{ + main_ui_->filterExpressionFrame->addExpression(df_combo_box_->lineEdit()->text()); +} + +void WiresharkMainWindow::onFilterSelected(QString filterText, bool prepare) +{ + if (filterText.length() <= 0) + return; + + df_combo_box_->setDisplayFilter(filterText); + // Holding down the Shift key will only prepare filter. + if (!prepare) + df_combo_box_->applyDisplayFilter(); +} + +void WiresharkMainWindow::onFilterPreferences() +{ + emit showPreferencesDialog(PrefsModel::typeToString(PrefsModel::FilterButtons)); +} + +void WiresharkMainWindow::onFilterEdit(int uatIndex) +{ + main_ui_->filterExpressionFrame->editExpression(uatIndex); +} + +void WiresharkMainWindow::openStatCommandDialog(const QString &menu_path, const char *arg, void *userdata) +{ + QString slot = QString("statCommand%1").arg(menu_path); + QMetaObject::invokeMethod(this, slot.toLatin1().constData(), Q_ARG(const char *, arg), Q_ARG(void *, userdata)); +} + +void WiresharkMainWindow::openTapParameterDialog(const QString cfg_str, const QString arg, void *userdata) +{ + TapParameterDialog *tp_dialog = TapParameterDialog::showTapParameterStatistics(*this, capture_file_, cfg_str, arg, userdata); + if (!tp_dialog) return; + + connect(tp_dialog, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType)), + this, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType))); + connect(tp_dialog, SIGNAL(updateFilter(QString)), + df_combo_box_->lineEdit(), SLOT(setText(QString))); + tp_dialog->show(); +} + +void WiresharkMainWindow::openTapParameterDialog() +{ + QAction *tpa = qobject_cast<QAction *>(QObject::sender()); + if (!tpa) return; + + const QString cfg_str = tpa->data().toString(); + openTapParameterDialog(cfg_str, NULL, NULL); +} + +#if defined(HAVE_SOFTWARE_UPDATE) && defined(Q_OS_WIN) +void WiresharkMainWindow::softwareUpdateRequested() { + // testCaptureFileClose doesn't use this string because we aren't + // going to launch another dialog, but maybe we'll change that. + QString before_what(tr(" before updating")); + if (!testCaptureFileClose(before_what, Update)) { + mainApp->rejectSoftwareUpdate(); + } +} +#endif + +// File Menu + +void WiresharkMainWindow::connectFileMenuActions() +{ + connect(main_ui_->actionFileOpen, &QAction::triggered, this, + [this]() { openCaptureFile(); }); + + connect(main_ui_->actionFileMerge, &QAction::triggered, this, + [this]() { mergeCaptureFile(); }); + + connect(main_ui_->actionFileImportFromHexDump, &QAction::triggered, this, + [this]() { importCaptureFile(); }); + + connect(main_ui_->actionFileClose, &QAction::triggered, this, [this]() { + QString before_what(tr(" before closing the file")); + if (testCaptureFileClose(before_what)) { + showWelcome(); + } + }); + + connect(main_ui_->actionFileSave, &QAction::triggered, this, + [this]() { saveCaptureFile(capture_file_.capFile(), false); }); + + connect(main_ui_->actionFileSaveAs, &QAction::triggered, this, + [this]() { saveAsCaptureFile(capture_file_.capFile()); }); + + connect(main_ui_->actionFileSetListFiles, &QAction::triggered, this, + [this]() { file_set_dialog_->show(); }); + + connect(main_ui_->actionFileSetNextFile, &QAction::triggered, this, [this]() { + fileset_entry *entry = fileset_get_next(); + + if (entry) { + QString new_cf_path = entry->fullname; + openCaptureFile(new_cf_path); + } + }); + + connect(main_ui_->actionFileSetPreviousFile, &QAction::triggered, this, [this]() { + fileset_entry *entry = fileset_get_previous(); + + if (entry) { + QString new_cf_path = entry->fullname; + openCaptureFile(new_cf_path); + } + }); + + connect(main_ui_->actionFileExportPackets, &QAction::triggered, this, + [this]() { exportSelectedPackets(); }); + + connect(main_ui_->actionFileExportAsPlainText, &QAction::triggered, this, + [this]() { exportDissections(export_type_text); }); + + connect(main_ui_->actionFileExportAsCSV, &QAction::triggered, this, + [this]() { exportDissections(export_type_csv); }); + + connect(main_ui_->actionFileExportAsCArrays, &QAction::triggered, this, + [this]() { exportDissections(export_type_carrays); }); + + connect(main_ui_->actionFileExportAsPSML, &QAction::triggered, this, + [this]() { exportDissections(export_type_psml); }); + + connect(main_ui_->actionFileExportAsPDML, &QAction::triggered, this, + [this]() { exportDissections(export_type_pdml); }); + + connect(main_ui_->actionFileExportAsJSON, &QAction::triggered, this, + [this]() { exportDissections(export_type_json); }); + + connect(main_ui_->actionFileExportPacketBytes, &QAction::triggered, this, + [this]() { exportPacketBytes(); }, Qt::QueuedConnection); + + connect(main_ui_->actionFileExportPDU, &QAction::triggered, this, + [this]() { exportPDU(); }); + + connect(main_ui_->actionFileStripHeaders, &QAction::triggered, this, + [this]() { stripPacketHeaders(); }); + + connect(main_ui_->actionFileExportTLSSessionKeys, &QAction::triggered, this, + [this]() { exportTLSSessionKeys(); }); + + connect(main_ui_->actionFilePrint, &QAction::triggered, this, + [this]() { printFile(); }); +} + +void WiresharkMainWindow::exportPacketBytes() +{ + QString file_name; + + if (!capture_file_.capFile() || !capture_file_.capFile()->finfo_selected) return; + + file_name = WiresharkFileDialog::getSaveFileName(this, + mainApp->windowTitleString(tr("Export Selected Packet Bytes")), + mainApp->openDialogInitialDir().canonicalPath(), + tr("Raw data (*.bin *.dat *.raw);;All Files (" ALL_FILES_WILDCARD ")") + ); + + if (file_name.length() > 0) { + const guint8 *data_p; + + data_p = tvb_get_ptr(capture_file_.capFile()->finfo_selected->ds_tvb, 0, -1) + + capture_file_.capFile()->finfo_selected->start; + write_file_binary_mode(qUtf8Printable(file_name), data_p, capture_file_.capFile()->finfo_selected->length); + + /* Save the directory name for future file dialogs. */ + mainApp->setLastOpenDirFromFilename(file_name); + } +} + +void WiresharkMainWindow::exportPDU() +{ + ExportPDUDialog *exportpdu_dialog = new ExportPDUDialog(this); + + if (exportpdu_dialog->isMinimized() == true) + { + exportpdu_dialog->showNormal(); + } + else + { + exportpdu_dialog->show(); + } + + exportpdu_dialog->raise(); + exportpdu_dialog->activateWindow(); +} + +void WiresharkMainWindow::stripPacketHeaders() +{ + StripHeadersDialog *stripheaders_dialog = new StripHeadersDialog(this); + + if (stripheaders_dialog->isMinimized() == true) + { + stripheaders_dialog->showNormal(); + } + else + { + stripheaders_dialog->show(); + } + + stripheaders_dialog->raise(); + stripheaders_dialog->activateWindow(); +} + + +void WiresharkMainWindow::exportTLSSessionKeys() +{ + QString file_name; + QString save_title; + int keylist_len; + + keylist_len = ssl_session_key_count(); + /* don't show up the dialog, if no data has to be saved */ + if (keylist_len < 1) { + /* shouldn't happen as the menu item should have been greyed out */ + QMessageBox::warning( + this, + tr("No Keys"), + tr("There are no TLS Session Keys to save."), + QMessageBox::Ok + ); + return; + } + + save_title.append(mainApp->windowTitleString(tr("Export TLS Session Keys (%Ln key(s))", "", keylist_len))); + file_name = WiresharkFileDialog::getSaveFileName(this, + save_title, + mainApp->openDialogInitialDir().canonicalPath(), + tr("TLS Session Keys (*.keys *.txt);;All Files (" ALL_FILES_WILDCARD ")") + ); + if (file_name.length() > 0) { + gsize keylist_length; + gchar *keylist = ssl_export_sessions(&keylist_length); + write_file_binary_mode(qUtf8Printable(file_name), keylist, keylist_length); + + /* Save the directory name for future file dialogs. */ + mainApp->setLastOpenDirFromFilename(file_name); + g_free(keylist); + } +} + +void WiresharkMainWindow::printFile() +{ + capture_file *cf = capture_file_.capFile(); + g_return_if_fail(cf); + + QList<int> rows = packet_list_->selectedRows(true); + + QStringList entries; + foreach (int row, rows) + entries << QString::number(row); + QString selRange = entries.join(","); + + PrintDialog * pdlg_ = new PrintDialog(this, cf, selRange); + pdlg_->setWindowModality(Qt::ApplicationModal); + pdlg_->show(); +} + +// Edit Menu + +void WiresharkMainWindow::connectEditMenuActions() +{ + connect(main_ui_->actionCopyAllVisibleItems, &QAction::triggered, this, + [this]() { copySelectedItems(CopyAllVisibleItems); }); + + connect(main_ui_->actionCopyListAsText, &QAction::triggered, this, + [this]() { copySelectedItems(CopyListAsText); }); + + connect(main_ui_->actionCopyListAsCSV, &QAction::triggered, this, + [this]() { copySelectedItems(CopyListAsCSV); }); + + connect(main_ui_->actionCopyListAsYAML, &QAction::triggered, this, + [this]() { copySelectedItems(CopyListAsYAML); }); + + connect(main_ui_->actionCopyAllVisibleSelectedTreeItems, &QAction::triggered, this, + [this]() { copySelectedItems(CopyAllVisibleSelectedTreeItems); }); + + connect(main_ui_->actionEditCopyDescription, &QAction::triggered, this, + [this]() { copySelectedItems(CopySelectedDescription); }); + + connect(main_ui_->actionEditCopyFieldName, &QAction::triggered, this, + [this]() { copySelectedItems(CopySelectedFieldName); }); + + connect(main_ui_->actionEditCopyValue, &QAction::triggered, this, + [this]() { copySelectedItems(CopySelectedValue); }); + + connect(main_ui_->actionEditCopyAsFilter, &QAction::triggered, this, + [this]() { matchFieldFilter(FilterAction::ActionCopy, FilterAction::ActionTypePlain); }); + + connect(main_ui_->actionEditFindPacket, &QAction::triggered, this, + [this]() { findPacket(); }); + + connect(main_ui_->actionEditFindNext, &QAction::triggered, this, + [this]() { main_ui_->searchFrame->findNext(); }); + + connect(main_ui_->actionEditFindPrevious, &QAction::triggered, this, + [this]() { main_ui_->searchFrame->findPrevious(); }); + + // The items below are used in the packet list and detail context menus. + // Use QueuedConnections so that the context menus aren't destroyed + // prematurely. + connect(main_ui_->actionEditMarkPacket, &QAction::triggered, this, [this]() { + freeze(); + packet_list_->markFrame(); + thaw(); + setMenusForSelectedPacket(); + }, Qt::QueuedConnection); + + connect(main_ui_->actionEditMarkAllDisplayed, &QAction::triggered, this, [this]() { + freeze(); + packet_list_->markAllDisplayedFrames(true); + thaw(); + setMenusForSelectedPacket(); + }, Qt::QueuedConnection); + + connect(main_ui_->actionEditUnmarkAllDisplayed, &QAction::triggered, this, [this]() { + freeze(); + packet_list_->markAllDisplayedFrames(false); + thaw(); + setMenusForSelectedPacket(); + }, Qt::QueuedConnection); + + connect(main_ui_->actionEditNextMark, &QAction::triggered, this, [this]() { + if (capture_file_.capFile()) { + cf_find_packet_marked(capture_file_.capFile(), SD_FORWARD); + } + }, Qt::QueuedConnection); + + connect(main_ui_->actionEditPreviousMark, &QAction::triggered, this, [this]() { + if (capture_file_.capFile()) { + cf_find_packet_marked(capture_file_.capFile(), SD_BACKWARD); + } + }, Qt::QueuedConnection); + + connect(main_ui_->actionEditIgnorePacket, &QAction::triggered, this, [this]() { + freeze(); + packet_list_->ignoreFrame(); + thaw(); + setMenusForSelectedPacket(); + }, Qt::QueuedConnection); + + connect(main_ui_->actionEditIgnoreAllDisplayed, &QAction::triggered, this, [this]() { + freeze(); + packet_list_->ignoreAllDisplayedFrames(true); + thaw(); + setMenusForSelectedPacket(); + }, Qt::QueuedConnection); + + connect(main_ui_->actionEditUnignoreAllDisplayed, &QAction::triggered, this, [this]() { + freeze(); + packet_list_->ignoreAllDisplayedFrames(false); + thaw(); + setMenusForSelectedPacket(); + }, Qt::QueuedConnection); + + connect(main_ui_->actionEditSetTimeReference, &QAction::triggered, this, [this]() { + packet_list_->setTimeReference(); + setMenusForSelectedPacket(); + }, Qt::QueuedConnection); + + connect(main_ui_->actionEditUnsetAllTimeReferences, &QAction::triggered, this, [this]() { + packet_list_->unsetAllTimeReferences(); + setMenusForSelectedPacket(); + }, Qt::QueuedConnection); + + connect(main_ui_->actionEditNextTimeReference, &QAction::triggered, this, [this]() { + if (!capture_file_.capFile()) return; + cf_find_packet_time_reference(capture_file_.capFile(), SD_FORWARD); + }, Qt::QueuedConnection); + + connect(main_ui_->actionEditPreviousTimeReference, &QAction::triggered, this, [this]() { + if (!capture_file_.capFile()) return; + cf_find_packet_time_reference(capture_file_.capFile(), SD_BACKWARD); + }, Qt::QueuedConnection); + + connect(main_ui_->actionEditTimeShift, &QAction::triggered, this, + [this]() { editTimeShift(); }, Qt::QueuedConnection); + + connect(main_ui_->actionDeleteAllPacketComments, &QAction::triggered, this, + [this]() { deleteAllPacketComments(); }, Qt::QueuedConnection); + + connect(main_ui_->actionEditInjectSecrets, &QAction::triggered, this, + [this]() { injectSecrets(); }, Qt::QueuedConnection); + + connect(main_ui_->actionEditDiscardAllSecrets, &QAction::triggered, this, + [this]() { discardAllSecrets(); }, Qt::QueuedConnection); + + connect(main_ui_->actionEditConfigurationProfiles, &QAction::triggered, this, + [this]() { editConfigurationProfiles(); }, Qt::QueuedConnection); + + connect(main_ui_->actionEditPreferences, &QAction::triggered, this, + [this]() { showPreferencesDialog(PrefsModel::typeToString(PrefsModel::Appearance)); }, Qt::QueuedConnection); +} + +// XXX This should probably be somewhere else. +void WiresharkMainWindow::copySelectedItems(WiresharkMainWindow::CopySelected selection_type) +{ + char label_str[ITEM_LABEL_LENGTH]; + QString clip; + + if (!capture_file_.capFile()) return; + + field_info *finfo_selected = capture_file_.capFile()->finfo_selected; + + switch (selection_type) { + case CopySelectedDescription: + if (proto_tree_->selectionModel()->hasSelection()) { + QModelIndex idx = proto_tree_->selectionModel()->selectedIndexes().first(); + clip = idx.data(Qt::DisplayRole).toString(); + } + break; + case CopySelectedFieldName: + if (finfo_selected && finfo_selected->hfinfo->abbrev != 0) { + clip.append(finfo_selected->hfinfo->abbrev); + } + break; + case CopySelectedValue: + if (finfo_selected && capture_file_.capFile()->edt != 0) { + gchar* field_str = get_node_field_value(finfo_selected, capture_file_.capFile()->edt); + clip.append(field_str); + g_free(field_str); + } + break; + case CopyAllVisibleItems: + clip = proto_tree_->toString(); + break; + case CopyAllVisibleSelectedTreeItems: + if (proto_tree_->selectionModel()->hasSelection()) { + clip = proto_tree_->toString(proto_tree_->selectionModel()->selectedIndexes().first()); + } + break; + case CopyListAsText: + case CopyListAsCSV: + case CopyListAsYAML: + if (packet_list_->selectedRows().count() > 0) + { + QList<int> rows = packet_list_->selectedRows(); + QStringList content; + + PacketList::SummaryCopyType copyType = PacketList::CopyAsText; + if (selection_type == CopyListAsCSV) + copyType = PacketList::CopyAsCSV; + else if (selection_type == CopyListAsYAML) + copyType = PacketList::CopyAsYAML; + + if ((copyType == PacketList::CopyAsText) || + (copyType == PacketList::CopyAsCSV)) { + QString headerEntry = packet_list_->createHeaderSummaryText(copyType); + content << headerEntry; + } + foreach (int row, rows) + { + QModelIndex idx = packet_list_->model()->index(row, 0); + if (! idx.isValid()) + continue; + + QString entry = packet_list_->createSummaryText(idx, copyType); + content << entry; + } + + if (content.count() > 0) { + clip = content.join("\n"); + // + // Each YAML item ends with a newline, so the string + // ends with a newline already if it's CopyListAsYAML. + // If we add a newline, there'd be an extra blank + // line. + // + // Otherwise, we've used newlines as separators, not + // terminators, so there's no final newline. Add it. + // + if (selection_type != CopyListAsYAML) + clip += "\n"; + } + } + break; + } + + if (clip.length() == 0) { + /* If no representation then... Try to read the value */ + proto_item_fill_label(capture_file_.capFile()->finfo_selected, label_str); + clip.append(label_str); + } + + if (clip.length()) { + mainApp->clipboard()->setText(clip); + } else { + QString err = tr("Couldn't copy text. Try another item."); + mainApp->pushStatus(WiresharkApplication::TemporaryStatus, err); + } +} + +void WiresharkMainWindow::findPacket() +{ + if (! packet_list_->model() || packet_list_->model()->rowCount() < 1) { + return; + } + setPreviousFocus(); + if (!main_ui_->searchFrame->isVisible()) { + showAccordionFrame(main_ui_->searchFrame, true); + } else { + main_ui_->searchFrame->animatedHide(); + } + main_ui_->searchFrame->setFocus(); +} + +void WiresharkMainWindow::editTimeShift() +{ + TimeShiftDialog *ts_dialog = new TimeShiftDialog(this, capture_file_.capFile()); + connect(ts_dialog, SIGNAL(finished(int)), this, SLOT(editTimeShiftFinished(int))); + + connect(this, SIGNAL(setCaptureFile(capture_file*)), + ts_dialog, SLOT(setCaptureFile(capture_file*))); + connect(ts_dialog, SIGNAL(timeShifted()), packet_list_, SLOT(applyTimeShift())); + + ts_dialog->setWindowModality(Qt::ApplicationModal); + ts_dialog->setAttribute(Qt::WA_DeleteOnClose); + ts_dialog->show(); +} + +void WiresharkMainWindow::editTimeShiftFinished(int) +{ + if (capture_file_.capFile()->unsaved_changes) { + updateForUnsavedChanges(); + } +} + +void WiresharkMainWindow::addPacketComment() +{ + QList<int> rows = selectedRows(); + if (rows.count() == 0) + return; + + frame_data * fdata = frameDataForRow(rows.at(0)); + if (! fdata) + return; + + PacketCommentDialog* pc_dialog; + pc_dialog = new PacketCommentDialog(false, this, NULL); + connect(pc_dialog, &QDialog::finished, std::bind(&WiresharkMainWindow::addPacketCommentFinished, this, pc_dialog, std::placeholders::_1)); + pc_dialog->setWindowModality(Qt::ApplicationModal); + pc_dialog->setAttribute(Qt::WA_DeleteOnClose); + pc_dialog->show(); +} + +void WiresharkMainWindow::addPacketCommentFinished(PacketCommentDialog* pc_dialog _U_, int result _U_) +{ + if (result == QDialog::Accepted) { + packet_list_->addPacketComment(pc_dialog->text()); + updateForUnsavedChanges(); + } +} + +void WiresharkMainWindow::editPacketComment() +{ + QList<int> rows = selectedRows(); + if (rows.count() != 1) + return; + + QAction *ra = qobject_cast<QAction*>(sender()); + guint nComment = ra->data().toUInt(); + PacketCommentDialog* pc_dialog; + pc_dialog = new PacketCommentDialog(true, this, packet_list_->getPacketComment(nComment)); + connect(pc_dialog, &QDialog::finished, std::bind(&WiresharkMainWindow::editPacketCommentFinished, this, pc_dialog, std::placeholders::_1, nComment)); + pc_dialog->setWindowModality(Qt::ApplicationModal); + pc_dialog->setAttribute(Qt::WA_DeleteOnClose); + pc_dialog->show(); +} + +void WiresharkMainWindow::editPacketCommentFinished(PacketCommentDialog* pc_dialog _U_, int result _U_, guint nComment) +{ + if (result == QDialog::Accepted) { + packet_list_->setPacketComment(nComment, pc_dialog->text()); + updateForUnsavedChanges(); + } +} + +void WiresharkMainWindow::deletePacketComment() +{ + QAction *ra = qobject_cast<QAction*>(sender()); + guint nComment = ra->data().toUInt(); + packet_list_->setPacketComment(nComment, QString("")); + updateForUnsavedChanges(); +} + +void WiresharkMainWindow::deleteCommentsFromPackets() +{ + packet_list_->deleteCommentsFromPackets(); + updateForUnsavedChanges(); +} + +void WiresharkMainWindow::deleteAllPacketComments() +{ + QMessageBox *msg_dialog = new QMessageBox(); + connect(msg_dialog, SIGNAL(finished(int)), this, SLOT(deleteAllPacketCommentsFinished(int))); + + msg_dialog->setIcon(QMessageBox::Question); + msg_dialog->setText(tr("Are you sure you want to remove all packet comments?")); + + msg_dialog->setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel); + msg_dialog->setDefaultButton(QMessageBox::Ok); + + msg_dialog->setWindowModality(Qt::ApplicationModal); + msg_dialog->setAttribute(Qt::WA_DeleteOnClose); + msg_dialog->show(); +} + +void WiresharkMainWindow::deleteAllPacketCommentsFinished(int result) +{ + if (result == QMessageBox::Ok) { + /* XXX Do we need a wait/hourglass for large files? */ + packet_list_->deleteAllPacketComments(); + updateForUnsavedChanges(); + } +} + +void WiresharkMainWindow::injectSecrets() +{ + int keylist_len; + + keylist_len = ssl_session_key_count(); + /* don't do anything if no data has to be saved */ + if (keylist_len < 1) { + QMessageBox::Button ret = QMessageBox::warning( + this, + tr("No TLS Secrets"), + tr("There are no available secrets used to decrypt TLS traffic in the capture file.\ + Would you like to view information about how to decrypt TLS traffic on the wiki?"), + QMessageBox::Yes | QMessageBox::No, + QMessageBox::No); + + if (ret != QMessageBox::Yes) return; + + QUrl wiki_url = QString(WS_WIKI_URL("TLS/#tls-decryption")); + QDesktopServices::openUrl(wiki_url); + return; + } + + if (!capture_file_.isValid()) + return; + + /* XXX: It would be nice to handle other types of secrets that + * can be written to a DSB, maybe have a proper dialog. + */ + capture_file *cf = capture_file_.capFile(); + tls_export_dsb(cf); + updateForUnsavedChanges(); +} + +void WiresharkMainWindow::discardAllSecrets() +{ + if (!capture_file_.isValid()) + return; + + QMessageBox* msg_dialog = new QMessageBox(); + connect(msg_dialog, SIGNAL(finished(int)), this, SLOT(discardAllSecretsFinished(int))); + + msg_dialog->setIcon(QMessageBox::Question); + msg_dialog->setText(tr("Are you sure you want to discard all decryption secrets?")); + + msg_dialog->setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel); + msg_dialog->setDefaultButton(QMessageBox::Ok); + + msg_dialog->setWindowModality(Qt::ApplicationModal); + msg_dialog->setAttribute(Qt::WA_DeleteOnClose); + msg_dialog->show(); +} + +void WiresharkMainWindow::discardAllSecretsFinished(int result) +{ + if (result == QMessageBox::Ok) { + /* XXX: It would be nice to handle other types of secrets that + * can be written to a DSB, maybe have a proper dialog. + */ + capture_file* cf = capture_file_.capFile(); + if (wtap_file_discard_decryption_secrets(cf->provider.wth)) { + cf->unsaved_changes = TRUE; + updateForUnsavedChanges(); + } + } +} + +void WiresharkMainWindow::editConfigurationProfiles() +{ + ProfileDialog *cp_dialog = new ProfileDialog(); + cp_dialog->setWindowModality(Qt::ApplicationModal); + cp_dialog->setAttribute(Qt::WA_DeleteOnClose); + cp_dialog->show(); +} + +void WiresharkMainWindow::showPreferencesDialog(QString module_name) +{ + PreferencesDialog *pref_dialog = new PreferencesDialog(this); + connect(pref_dialog, SIGNAL(destroyed(QObject*)), mainApp, SLOT(flushAppSignals())); + saveWindowGeometry(); // Save in case the layout panes are rearranged + + pref_dialog->setPane(module_name); + pref_dialog->setWindowModality(Qt::ApplicationModal); + pref_dialog->setAttribute(Qt::WA_DeleteOnClose); + pref_dialog->show(); +} + +// View Menu + +void WiresharkMainWindow::connectViewMenuActions() +{ + connect(main_ui_->actionViewFullScreen, &QAction::triggered, this, [this](bool checked) { + if (checked) { + // Save the state for future restore + was_maximized_ = this->isMaximized(); + this->showFullScreen(); + } else { + // Restore the previous state + if (was_maximized_) { + this->showMaximized(); + } else { + this->showNormal(); + } + } + }); + + connect(main_ui_->actionViewTimeDisplaySecondsWithHoursAndMinutes, &QAction::triggered, this, + [this](bool checked) { setTimeDisplaySecondsWithHoursAndMinutes(checked); }); + + connect(main_ui_->actionViewEditResolvedName, &QAction::triggered, this, + [this]() { editResolvedName(); }); + + connect(main_ui_->actionViewNameResolutionPhysical, &QAction::triggered, this, + [this]() { setNameResolution(); }); + + connect(main_ui_->actionViewNameResolutionNetwork, &QAction::triggered, this, + [this]() { setNameResolution(); }); + + connect(main_ui_->actionViewNameResolutionTransport, &QAction::triggered, this, + [this]() { setNameResolution(); }); + + connect(main_ui_->actionViewZoomIn, &QAction::triggered, this, [this]() { + recent.gui_zoom_level++; + zoomText(); + }); + + connect(main_ui_->actionViewZoomOut, &QAction::triggered, this, [this]() { + recent.gui_zoom_level--; + zoomText(); + }); + + connect(main_ui_->actionViewNormalSize, &QAction::triggered, this, [this]() { + recent.gui_zoom_level = 0; + zoomText(); + }); + + connect(main_ui_->actionViewExpandSubtrees, &QAction::triggered, + proto_tree_, &ProtoTree::expandSubtrees); + + connect(main_ui_->actionViewCollapseSubtrees, &QAction::triggered, + proto_tree_, &ProtoTree::collapseSubtrees); + + connect(main_ui_->actionViewExpandAll, &QAction::triggered, + proto_tree_, &ProtoTree::expandAll); + + connect(main_ui_->actionViewCollapseAll, &QAction::triggered, + proto_tree_, &ProtoTree::collapseAll); + + connect(main_ui_->actionViewColorizePacketList, &QAction::triggered, this, [this](bool checked) { + recent.packet_list_colorize = checked; + packet_list_->recolorPackets(); + }); + + connect(main_ui_->actionViewColoringRules, &QAction::triggered, this, + [this]() { showColoringRulesDialog(); }); + + connect(main_ui_->actionViewColorizeResetColorization, &QAction::triggered, this, [this]() { + gchar *err_msg = NULL; + if (!color_filters_reset_tmp(&err_msg)) { + simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_msg); + g_free(err_msg); + } + packet_list_->recolorPackets(); + setMenusForSelectedPacket(); + }); + + connect(main_ui_->actionViewColorizeNewColoringRule, &QAction::triggered, this, + [this]() { colorizeConversation(true); }); + + connect(main_ui_->actionViewResetLayout, &QAction::triggered, this, [this]() { + recent.gui_geometry_main_upper_pane = 0; + recent.gui_geometry_main_lower_pane = 0; + applyRecentPaneGeometry(); + }); + + connect(main_ui_->actionViewResizeColumns, &QAction::triggered, this, [this]() { + if (! packet_list_->model()) + return; + for (int col = 0; col < packet_list_->model()->columnCount(); col++) { + packet_list_->resizeColumnToContents(col); + recent_set_column_width(col, packet_list_->columnWidth(col)); + } + }); + + connect(main_ui_->actionViewInternalsConversationHashTables, &QAction::triggered, this, [this]() { + ConversationHashTablesDialog *conversation_hash_tables_dlg = new ConversationHashTablesDialog(this); + conversation_hash_tables_dlg->show(); + }); + + connect(main_ui_->actionViewInternalsDissectorTables, &QAction::triggered, this, [this]() { + DissectorTablesDialog *dissector_tables_dlg = new DissectorTablesDialog(this); + dissector_tables_dlg->show(); + }); + + connect(main_ui_->actionViewInternalsSupportedProtocols, &QAction::triggered, this, [this]() { + SupportedProtocolsDialog *supported_protocols_dlg = new SupportedProtocolsDialog(this); + supported_protocols_dlg->show(); + }); + + connect(main_ui_->actionViewShowPacketInNewWindow, &QAction::triggered, this, + [this]() { openPacketDialog(); }); + + // This is only used in ProtoTree. Defining it here makes more sense. + connect(main_ui_->actionContextShowLinkedPacketInNewWindow, &QAction::triggered, this, + [this]() { openPacketDialog(true); }); + + connect(main_ui_->actionViewReload_as_File_Format_or_Capture, &QAction::triggered, this, + [this]() { reloadCaptureFileAsFormatOrCapture(); }); + + connect(main_ui_->actionViewReload, &QAction::triggered, this, + [this]() { reloadCaptureFile(); }); +} + +void WiresharkMainWindow::showHideMainWidgets(QAction *action) +{ + if (!action) { + return; + } + bool show = action->isChecked(); + QWidget *widget = action->data().value<QWidget*>(); + + // We may have come from the toolbar context menu, so check/uncheck each + // action as well. + if (widget == main_ui_->mainToolBar) { + recent.main_toolbar_show = show; + main_ui_->actionViewMainToolbar->setChecked(show); + } else if (widget == main_ui_->displayFilterToolBar) { + recent.filter_toolbar_show = show; + main_ui_->actionViewFilterToolbar->setChecked(show); +#if defined(HAVE_LIBNL) && defined(HAVE_NL80211) + } else if (widget == main_ui_->wirelessToolBar) { + recent.wireless_toolbar_show = show; + main_ui_->actionViewWirelessToolbar->setChecked(show); +#endif + } else if (widget == main_ui_->statusBar) { + recent.statusbar_show = show; + main_ui_->actionViewStatusBar->setChecked(show); + } else if (widget == packet_list_) { + recent.packet_list_show = show; + main_ui_->actionViewPacketList->setChecked(show); + } else if (widget == proto_tree_) { + recent.tree_view_show = show; + main_ui_->actionViewPacketDetails->setChecked(show); + } else if (widget == byte_view_tab_) { + recent.byte_view_show = show; + main_ui_->actionViewPacketBytes->setChecked(show); + } else if (widget == packet_diagram_) { + recent.packet_diagram_show = show; + main_ui_->actionViewPacketDiagram->setChecked(show); + } else { + foreach(QAction *action, main_ui_->menuInterfaceToolbars->actions()) { + QToolBar *toolbar = action->data().value<QToolBar *>(); + if (widget == toolbar) { + GList *entry = g_list_find_custom(recent.interface_toolbars, action->text().toUtf8(), (GCompareFunc)strcmp); + if (show && !entry) { + recent.interface_toolbars = g_list_append(recent.interface_toolbars, g_strdup(action->text().toUtf8().constData())); + } else if (!show && entry) { + recent.interface_toolbars = g_list_remove(recent.interface_toolbars, entry->data); + } + action->setChecked(show); + } + } + + ext_toolbar_t * toolbar = VariantPointer<ext_toolbar_t>::asPtr(action->data()); + if (toolbar) { + GList *entry = g_list_find_custom(recent.gui_additional_toolbars, toolbar->name, (GCompareFunc)strcmp); + if (show && !entry) { + recent.gui_additional_toolbars = g_list_append(recent.gui_additional_toolbars, g_strdup(toolbar->name)); + } else if (!show && entry) { + recent.gui_additional_toolbars = g_list_remove(recent.gui_additional_toolbars, entry->data); + } + action->setChecked(show); + + QList<QToolBar *> toolbars = findChildren<QToolBar *>(); + foreach(QToolBar *bar, toolbars) { + AdditionalToolBar *iftoolbar = dynamic_cast<AdditionalToolBar *>(bar); + if (iftoolbar && iftoolbar->menuName().compare(toolbar->name) == 0) { + iftoolbar->setVisible(show); + } + } + } + } + + if (widget) { + widget->setVisible(show); + } +} + +void WiresharkMainWindow::setTimestampFormat(QAction *action) +{ + if (!action) { + return; + } + ts_type tsf = action->data().value<ts_type>(); + if (recent.gui_time_format != tsf) { + timestamp_set_type(tsf); + recent.gui_time_format = tsf; + + if (packet_list_) { + packet_list_->resetColumns(); + packet_list_->resizeAllColumns(true); + } + } +} + +void WiresharkMainWindow::setTimestampPrecision(QAction *action) +{ + if (!action) { + return; + } + ts_precision tsp = action->data().value<ts_precision>(); + if (recent.gui_time_precision != tsp) { + timestamp_set_precision(tsp); + recent.gui_time_precision = tsp; + + if (packet_list_) { + packet_list_->resetColumns(); + packet_list_->resizeAllColumns(true); + } + } +} + +void WiresharkMainWindow::setTimeDisplaySecondsWithHoursAndMinutes(bool checked) +{ + if (checked) { + recent.gui_seconds_format = TS_SECONDS_HOUR_MIN_SEC; + } else { + recent.gui_seconds_format = TS_SECONDS_DEFAULT; + } + timestamp_set_seconds_type(recent.gui_seconds_format); + + if (packet_list_) { + packet_list_->resetColumns(); + packet_list_->resizeAllColumns(true); + } +} + +void WiresharkMainWindow::editResolvedName() +{ + //int column = packet_list_->selectedColumn(); + int column = -1; + + if (packet_list_->contextMenuActive() || packet_list_->hasFocus()) { + if (packet_list_->currentIndex().isValid()) { + column = packet_list_->currentIndex().column(); + } + } + + main_ui_->addressEditorFrame->editAddresses(capture_file_, column); + showAccordionFrame(main_ui_->addressEditorFrame); +} + +void WiresharkMainWindow::setNameResolution() +{ + gbl_resolv_flags.mac_name = main_ui_->actionViewNameResolutionPhysical->isChecked() ? TRUE : FALSE; + gbl_resolv_flags.network_name = main_ui_->actionViewNameResolutionNetwork->isChecked() ? TRUE : FALSE; + gbl_resolv_flags.transport_name = main_ui_->actionViewNameResolutionTransport->isChecked() ? TRUE : FALSE; + + if (packet_list_) { + packet_list_->resetColumns(); + } + mainApp->emitAppSignal(WiresharkApplication::NameResolutionChanged); +} + +void WiresharkMainWindow::zoomText() +{ + mainApp->zoomTextFont(recent.gui_zoom_level); +} + +void WiresharkMainWindow::showColoringRulesDialog() +{ + ColoringRulesDialog *coloring_rules_dialog = new ColoringRulesDialog(this); + connect(coloring_rules_dialog, &ColoringRulesDialog::accepted, + packet_list_, &PacketList::recolorPackets); + connect(coloring_rules_dialog, &ColoringRulesDialog::filterAction, + this, &WiresharkMainWindow::filterAction); + + coloring_rules_dialog->setWindowModality(Qt::ApplicationModal); + coloring_rules_dialog->setAttribute(Qt::WA_DeleteOnClose); + coloring_rules_dialog->show(); +} + +// actionViewColorizeConversation1 - 10 +void WiresharkMainWindow::colorizeConversation(bool create_rule) +{ + QAction *colorize_action = qobject_cast<QAction *>(sender()); + if (!colorize_action) return; + + if (capture_file_.capFile() && selectedRows().count() > 0) { + packet_info *pi = capture_file_.packetInfo(); + guint8 cc_num = colorize_action->data().toUInt(); + gchar *filter = conversation_filter_from_packet(pi); + if (filter == NULL) { + mainApp->pushStatus(WiresharkApplication::TemporaryStatus, tr("Unable to build conversation filter.")); + return; + } + + if (create_rule) { + ColoringRulesDialog coloring_rules_dialog(this, filter); + connect(&coloring_rules_dialog, &ColoringRulesDialog::accepted, + packet_list_, &PacketList::recolorPackets); + connect(&coloring_rules_dialog, &ColoringRulesDialog::filterAction, + this, &WiresharkMainWindow::filterAction); + coloring_rules_dialog.exec(); + } else { + gchar *err_msg = NULL; + if (!color_filters_set_tmp(cc_num, filter, FALSE, &err_msg)) { + simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_msg); + g_free(err_msg); + } + packet_list_->recolorPackets(); + } + } + setMenusForSelectedPacket(); +} + +void WiresharkMainWindow::colorizeActionTriggered() +{ + QByteArray filter; + int color_number = -1; + + ConversationAction *conv_action = qobject_cast<ConversationAction *>(sender()); + if (conv_action) { + filter = conv_action->filter(); + color_number = conv_action->colorNumber(); + } else { + ColorizeAction *colorize_action = qobject_cast<ColorizeAction *>(sender()); + if (colorize_action) { + filter = colorize_action->filter(); + color_number = colorize_action->colorNumber(); + } + } + + colorizeWithFilter(filter, color_number); +} + +void WiresharkMainWindow::colorizeWithFilter(QByteArray filter, int color_number) +{ + if (filter.isEmpty()) return; + + if (color_number > 0) { + // Assume "Color X" + gchar *err_msg = NULL; + if (!color_filters_set_tmp(color_number, filter.constData(), FALSE, &err_msg)) { + simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_msg); + g_free(err_msg); + } + packet_list_->recolorPackets(); + } else { + // New coloring rule + ColoringRulesDialog coloring_rules_dialog(window(), filter); + connect(&coloring_rules_dialog, &ColoringRulesDialog::accepted, + packet_list_, &PacketList::recolorPackets); + connect(&coloring_rules_dialog, &ColoringRulesDialog::filterAction, + this, &WiresharkMainWindow::filterAction); + coloring_rules_dialog.exec(); + } + main_ui_->actionViewColorizeResetColorization->setEnabled(tmp_color_filters_used()); +} + +void WiresharkMainWindow::openPacketDialog(bool from_reference) +{ + frame_data * fdata = Q_NULLPTR; + + /* Find the frame for which we're popping up a dialog */ + if (from_reference) { + guint32 framenum = fvalue_get_uinteger(capture_file_.capFile()->finfo_selected->value); + if (framenum == 0) + return; + + fdata = frame_data_sequence_find(capture_file_.capFile()->provider.frames, framenum); + } else if (selectedRows().count() == 1) { + fdata = frameDataForRow(selectedRows().at(0)); + } else if (selectedRows().count() > 1) + return; + + /* If we have a frame, pop up the dialog */ + if (fdata) { + PacketDialog *packet_dialog = new PacketDialog(*this, capture_file_, fdata); + + connect(packet_dialog, &PacketDialog::showProtocolPreferences, + this, &WiresharkMainWindow::showPreferencesDialog); + connect(packet_dialog, SIGNAL(editProtocolPreference(preference*, pref_module*)), + main_ui_->preferenceEditorFrame, SLOT(editPreference(preference*, pref_module*))); + + connect(this, &WiresharkMainWindow::closePacketDialogs, packet_dialog, &PacketDialog::close); + zoomText(); // Emits mainApp->zoomMonospaceFont(QFont) + + packet_dialog->show(); + } +} + +void WiresharkMainWindow::reloadCaptureFileAsFormatOrCapture() +{ + capture_file *cf = CaptureFile::globalCapFile(); + + if (cf->unsaved_changes) { + QString before_what(tr(" before reloading the file")); + if (!testCaptureFileClose(before_what, Reload)) + return; + } + + if (cf->open_type == WTAP_TYPE_AUTO) + cf->open_type = open_info_name_to_type("MIME Files Format"); + else /* TODO: This should be latest format chosen by user */ + cf->open_type = WTAP_TYPE_AUTO; + + cf_reload(cf); +} + +void WiresharkMainWindow::reloadCaptureFile() +{ + capture_file *cf = CaptureFile::globalCapFile(); + + if (cf->unsaved_changes) { + QString before_what(tr(" before reloading the file")); + if (!testCaptureFileClose(before_what, Reload)) + return; + } + + cf_reload(cf); +} + + +// Expand / collapse slots in proto_tree + +// Go Menu + +void WiresharkMainWindow::connectGoMenuActions() +{ + connect(main_ui_->actionGoGoToPacket, &QAction::triggered, this, [this]() { + if (! packet_list_->model() || packet_list_->model()->rowCount() < 1) { + return; + } + setPreviousFocus(); + + showAccordionFrame(main_ui_->goToFrame, true); + if (main_ui_->goToFrame->isVisible()) { + main_ui_->goToLineEdit->clear(); + main_ui_->goToLineEdit->setFocus(); + } + }); + + connect(main_ui_->actionGoGoToLinkedPacket, &QAction::triggered, this, [this]() { + QAction *gta = qobject_cast<QAction*>(sender()); + if (!gta) return; + + bool ok = false; + int packet_num = gta->data().toInt(&ok); + if (!ok) return; + + packet_list_->goToPacket(packet_num); + }); + + connect(main_ui_->actionGoNextPacket, &QAction::triggered, + packet_list_, &PacketList::goNextPacket); + + connect(main_ui_->actionGoPreviousPacket, &QAction::triggered, + packet_list_, &PacketList::goPreviousPacket); + + connect(main_ui_->actionGoFirstPacket, &QAction::triggered, + packet_list_, &PacketList::goFirstPacket); + + connect(main_ui_->actionGoLastPacket, &QAction::triggered, + packet_list_, &PacketList::goLastPacket); + + connect(main_ui_->actionGoNextConversationPacket, &QAction::triggered, this, + [this]() { goToConversationFrame(true); }); + + connect(main_ui_->actionGoPreviousConversationPacket, &QAction::triggered, this, + [this]() { goToConversationFrame(false); }); + + connect(main_ui_->actionGoNextHistoryPacket, &QAction::triggered, + packet_list_, &PacketList::goNextHistoryPacket); + + connect(main_ui_->actionGoPreviousHistoryPacket, &QAction::triggered, + packet_list_, &PacketList::goPreviousHistoryPacket); + + // triggered is whenever the user clicks the button; save that as + // the new recent value + connect(main_ui_->actionGoAutoScroll, &QAction::triggered, this, + [](bool checked) { recent.capture_auto_scroll = checked; }); + + // toggled is whenever the value changes; if it changes programmatically + // (e.g., the user scrolls upwards so we stop auto scrolling) change + // whether the button is checked but don't save value to recent (it's + // a temporary change) + connect(main_ui_->actionGoAutoScroll, &QAction::toggled, this, + [this](bool checked) { packet_list_->setVerticalAutoScroll(checked); }); +} + +void WiresharkMainWindow::goToConversationFrame(bool go_next) { + gchar *filter = NULL; + dfilter_t *dfcode = NULL; + gboolean found_packet = FALSE; + packet_info *pi = capture_file_.packetInfo(); + + if (!pi) { + // No packet was selected, or multiple packets were selected. + return; + } + + /* Try to build a conversation + * filter in the order TCP, UDP, IP, Ethernet and apply the + * coloring */ + filter = conversation_filter_from_packet(pi); + if (filter == NULL) { + mainApp->pushStatus(WiresharkApplication::TemporaryStatus, tr("Unable to build conversation filter.")); + g_free(filter); + return; + } + + if (!dfilter_compile(filter, &dfcode, NULL)) { + /* The attempt failed; report an error. */ + mainApp->pushStatus(WiresharkApplication::TemporaryStatus, tr("Error compiling filter for this conversation.")); + g_free(filter); + return; + } + + found_packet = cf_find_packet_dfilter(capture_file_.capFile(), dfcode, go_next ? SD_FORWARD : SD_BACKWARD); + + if (!found_packet) { + /* We didn't find a packet */ + mainApp->pushStatus(WiresharkApplication::TemporaryStatus, tr("No previous/next packet in conversation.")); + } + + dfilter_free(dfcode); + g_free(filter); +} + +// Capture Menu + +void WiresharkMainWindow::connectCaptureMenuActions() +{ +#ifdef HAVE_LIBPCAP + connect(main_ui_->actionCaptureOptions, &QAction::triggered, this, + [this]() { showCaptureOptionsDialog(); }); +#endif + + connect(main_ui_->actionCaptureStart, &QAction::triggered, this, + [this]() { startCaptureTriggered(); }); + + connect(main_ui_->actionCaptureStop, &QAction::triggered, this, + [this]() { stopCapture(); }); + +#ifdef HAVE_LIBPCAP + connect(main_ui_->actionCaptureRestart, &QAction::triggered, this, [this]() { + QString before_what(tr(" before restarting the capture")); + cap_session_.capture_opts->restart = TRUE; + if (!testCaptureFileClose(before_what, Restart)) { + return; + } + startCapture(QStringList()); + }); +#endif // HAVE_LIBPCAP + + connect(main_ui_->actionCaptureCaptureFilters, &QAction::triggered, this, [this]() { + FilterDialog *capture_filter_dlg = new FilterDialog(window(), FilterDialog::CaptureFilter); + capture_filter_dlg->setWindowModality(Qt::ApplicationModal); + capture_filter_dlg->setAttribute(Qt::WA_DeleteOnClose); + capture_filter_dlg->show(); + }); + +#ifdef HAVE_LIBPCAP + connect(main_ui_->actionCaptureRefreshInterfaces, &QAction::triggered, this, [this]() { + main_ui_->actionCaptureRefreshInterfaces->setEnabled(false); + mainApp->refreshLocalInterfaces(); + main_ui_->actionCaptureRefreshInterfaces->setEnabled(true); + }); +#endif +} + +void WiresharkMainWindow::showCaptureOptionsDialog() +{ +#ifdef HAVE_LIBPCAP + if (!capture_options_dialog_) { + capture_options_dialog_ = new CaptureOptionsDialog(this); + + connect(capture_options_dialog_, &CaptureOptionsDialog::startCapture, this, [this]() { startCapture(); }); + connect(capture_options_dialog_, &CaptureOptionsDialog::stopCapture, this, &WiresharkMainWindow::stopCapture); + + connect(capture_options_dialog_, &CaptureOptionsDialog::interfacesChanged, + this->welcome_page_, &WelcomePage::interfaceSelected); + connect(capture_options_dialog_, &CaptureOptionsDialog::interfacesChanged, + this->welcome_page_->getInterfaceFrame(), &InterfaceFrame::updateSelectedInterfaces); + connect(capture_options_dialog_, &CaptureOptionsDialog::interfaceListChanged, + this->welcome_page_->getInterfaceFrame(), &InterfaceFrame::interfaceListChanged); + connect(capture_options_dialog_, &CaptureOptionsDialog::captureFilterTextEdited, + this->welcome_page_, &WelcomePage::setCaptureFilterText); + // Propagate selection changes from main UI to dialog. + connect(this->welcome_page_, &WelcomePage::interfacesChanged, + capture_options_dialog_, &CaptureOptionsDialog::interfaceSelected); + + connect(capture_options_dialog_, &CaptureOptionsDialog::setFilterValid, + this, &WiresharkMainWindow::startInterfaceCapture); + + connect(capture_options_dialog_, &CaptureOptionsDialog::showExtcapOptions, + this, &WiresharkMainWindow::showExtcapOptionsDialog); + } + capture_options_dialog_->updateInterfaces(); + + if (capture_options_dialog_->isMinimized()) { + capture_options_dialog_->showNormal(); + } else { + capture_options_dialog_->show(); + } + + capture_options_dialog_->raise(); + capture_options_dialog_->activateWindow(); +#endif +} + +void WiresharkMainWindow::startCaptureTriggered() +{ +//#ifdef HAVE_AIRPCAP +// airpcap_if_active = airpcap_if_selected; +// if (airpcap_if_active) +// airpcap_set_toolbar_start_capture(airpcap_if_active); +//#endif + +// if (cap_open_w) { +// /* +// * There's an options dialog; get the values from it and close it. +// */ +// gboolean success; + +// /* Determine if "capture start" while building of the "capture options" window */ +// /* is in progress. If so, ignore the "capture start. */ +// /* XXX: Would it be better/cleaner for the "capture options" window code to */ +// /* disable the capture start button temporarily ? */ +// if (cap_open_complete == FALSE) { +// return; /* Building options window: ignore "capture start" */ +// } +// success = capture_dlg_prep(cap_open_w); +// window_destroy(GTK_WIDGET(cap_open_w)); +// if (!success) +// return; /* error in options dialog */ +// } + +#ifdef HAVE_LIBPCAP + if (global_capture_opts.num_selected == 0) { + QString err_msg = tr("No Interface Selected."); + mainApp->pushStatus(WiresharkApplication::TemporaryStatus, err_msg); + main_ui_->actionCaptureStart->setChecked(false); + return; + } + + /* XXX - will closing this remove a temporary file? */ + QString before_what(tr(" before starting a new capture")); + if (testCaptureFileClose(before_what)) { + startCapture(QStringList()); + } else { + // simply clicking the button sets it to 'checked' even though we've + // decided to do nothing, so undo that + main_ui_->actionCaptureStart->setChecked(false); + } +#endif // HAVE_LIBPCAP +} + +// Analyze Menu + +struct epan_uat; + +void WiresharkMainWindow::connectAnalyzeMenuActions() +{ + connect(main_ui_->actionAnalyzeDisplayFilters, &QAction::triggered, this, [=]() { + FilterDialog *display_filter_dlg = new FilterDialog(window(), FilterDialog::DisplayFilter); + display_filter_dlg->setWindowModality(Qt::ApplicationModal); + display_filter_dlg->setAttribute(Qt::WA_DeleteOnClose); + display_filter_dlg->show(); + }); + + connect(main_ui_->actionAnalyzeDisplayFilterMacros, &QAction::triggered, this, [=]() { + struct epan_uat* dfm_uat; + dfilter_macro_get_uat(&dfm_uat); + UatDialog *uat_dlg = new UatDialog(parentWidget(), dfm_uat); + connect(uat_dlg, SIGNAL(destroyed(QObject*)), mainApp, SLOT(flushAppSignals())); + + uat_dlg->setWindowModality(Qt::ApplicationModal); + uat_dlg->setAttribute(Qt::WA_DeleteOnClose); + uat_dlg->show(); + }); + + connect(main_ui_->actionDisplayFilterExpression, &QAction::triggered, this, [=]() { + DisplayFilterExpressionDialog *dfe_dialog = new DisplayFilterExpressionDialog(this); + + connect(dfe_dialog, &DisplayFilterExpressionDialog::insertDisplayFilter, + qobject_cast<SyntaxLineEdit *>(df_combo_box_->lineEdit()), &SyntaxLineEdit::insertFilter); + + dfe_dialog->show(); + }); + + connect(main_ui_->actionAnalyzeApplyAsColumn, &QAction::triggered, this, &WiresharkMainWindow::applyFieldAsColumn); + + connect(main_ui_->actionAnalyzeEnabledProtocols, &QAction::triggered, this, [=]() { + EnabledProtocolsDialog *enable_proto_dialog = new EnabledProtocolsDialog(this); + connect(enable_proto_dialog, SIGNAL(destroyed(QObject*)), mainApp, SLOT(flushAppSignals())); + + enable_proto_dialog->setWindowModality(Qt::ApplicationModal); + enable_proto_dialog->setAttribute(Qt::WA_DeleteOnClose); + enable_proto_dialog->show(); + }); + + connect(main_ui_->actionAnalyzeDecodeAs, &QAction::triggered, this, [=]() { + QAction *da_action = qobject_cast<QAction*>(sender()); + bool create_new = da_action && da_action->property("create_new").toBool(); + + DecodeAsDialog *da_dialog = new DecodeAsDialog(this, capture_file_.capFile(), create_new); + connect(da_dialog, SIGNAL(destroyed(QObject*)), mainApp, SLOT(flushAppSignals())); + + da_dialog->setWindowModality(Qt::ApplicationModal); + da_dialog->setAttribute(Qt::WA_DeleteOnClose); + da_dialog->show(); + }); + + connect(main_ui_->actionAnalyzeReloadLuaPlugins, &QAction::triggered, this, &WiresharkMainWindow::reloadLuaPlugins); + + connect(main_ui_->actionAnalyzeShowPacketBytes, &QAction::triggered, this, [=]() { + ShowPacketBytesDialog *spbd = new ShowPacketBytesDialog(*this, capture_file_); + spbd->addCodecs(text_codec_map_); + spbd->show(); + }); + + connect(main_ui_->actionAnalyzeExpertInfo, &QAction::triggered, this, [=]() { + statCommandExpertInfo(NULL, NULL); + }); +} + +void WiresharkMainWindow::filterMenuAboutToShow() +{ + QMenu * menu = qobject_cast<QMenu *>(sender()); + QString field_filter; + + if (capture_file_.capFile() && capture_file_.capFile()->finfo_selected) { + char *tmp_field = proto_construct_match_selected_string(capture_file_.capFile()->finfo_selected, + capture_file_.capFile()->edt); + field_filter = QString(tmp_field); + wmem_free(NULL, tmp_field); + } + bool enable = ! field_filter.isEmpty(); + bool prepare = menu->objectName().compare("menuPrepareAFilter") == 0; + + menu->clear(); + QActionGroup * group = FilterAction::createFilterGroup(field_filter, prepare, enable, menu); + menu->addActions(group->actions()); +} + +void WiresharkMainWindow::matchFieldFilter(FilterAction::Action action, FilterAction::ActionType filter_type) +{ + QString field_filter; + + if (packet_list_->contextMenuActive() || packet_list_->hasFocus()) { + field_filter = packet_list_->getFilterFromRowAndColumn(packet_list_->currentIndex()); + } else if (capture_file_.capFile() && capture_file_.capFile()->finfo_selected) { + char *tmp_field = proto_construct_match_selected_string(capture_file_.capFile()->finfo_selected, + capture_file_.capFile()->edt); + field_filter = QString(tmp_field); + wmem_free(NULL, tmp_field); + } + + if (field_filter.isEmpty()) { + QString err = tr("No filter available. Try another %1.").arg(packet_list_->contextMenuActive() ? tr("column") : tr("item")); + mainApp->pushStatus(WiresharkApplication::TemporaryStatus, err); + return; + } + + setDisplayFilter(field_filter, action, filter_type); +} + +void WiresharkMainWindow::applyFieldAsColumn() +{ + if (capture_file_.capFile() != 0 && capture_file_.capFile()->finfo_selected != 0) { + header_field_info *hfinfo = capture_file_.capFile()->finfo_selected->hfinfo; + int col = column_prefs_has_custom(hfinfo->abbrev); + if (col == -1) { + insertColumn(hfinfo->name, hfinfo->abbrev); + } else { + QString status; + if (QString(hfinfo->name) == get_column_title(col)) { + status = tr("The \"%1\" column already exists.").arg(hfinfo->name); + } else { + status = tr("The \"%1\" column already exists as \"%2\".").arg(hfinfo->name).arg(get_column_title(col)); + } + mainApp->pushStatus(WiresharkApplication::TemporaryStatus, status); + + if (!get_column_visible(col)) { + packet_list_->setColumnHidden(col, false); + set_column_visible(col, TRUE); + prefs_main_write(); + } + } + } +} + +void WiresharkMainWindow::applyConversationFilter() +{ + ConversationAction *conv_action = qobject_cast<ConversationAction*>(sender()); + if (!conv_action) return; + + packet_info *pinfo = capture_file_.packetInfo(); + if (!pinfo) return; + + QByteArray conv_filter = conv_action->filter(); + if (conv_filter.isEmpty()) return; + + if (conv_action->isFilterValid(pinfo)) { + + df_combo_box_->lineEdit()->setText(conv_filter); + df_combo_box_->applyDisplayFilter(); + } +} + +void WiresharkMainWindow::applyExportObject() +{ + ExportObjectAction *export_action = qobject_cast<ExportObjectAction*>(sender()); + if (!export_action) + return; + + ExportObjectDialog* export_dialog = new ExportObjectDialog(*this, capture_file_, export_action->exportObject()); + export_dialog->setWindowModality(Qt::ApplicationModal); + export_dialog->setAttribute(Qt::WA_DeleteOnClose); + export_dialog->show(); +} + +void WiresharkMainWindow::openFollowStreamDialog(int proto_id, guint stream_num, guint sub_stream_num, bool use_stream_index) { + FollowStreamDialog *fsd = new FollowStreamDialog(*this, capture_file_, proto_id); + connect(fsd, SIGNAL(updateFilter(QString, bool)), this, SLOT(filterPackets(QString, bool))); + connect(fsd, SIGNAL(goToPacket(int)), packet_list_, SLOT(goToPacket(int))); + fsd->addCodecs(text_codec_map_); + fsd->show(); + if (use_stream_index) { + // If a specific conversation was requested, then ignore any previous + // display filters and display all related packets. + fsd->follow("", true, stream_num, sub_stream_num); + } else { + fsd->follow(getFilter()); + } +} + +void WiresharkMainWindow::openFollowStreamDialog(int proto_id) { + openFollowStreamDialog(proto_id, 0, 0, false); +} + +void WiresharkMainWindow::openSCTPAllAssocsDialog() +{ + SCTPAllAssocsDialog *sctp_dialog = new SCTPAllAssocsDialog(this, capture_file_.capFile()); + connect(sctp_dialog, SIGNAL(filterPackets(QString, bool)), + this, SLOT(filterPackets(QString, bool))); + connect(this, SIGNAL(setCaptureFile(capture_file*)), + sctp_dialog, SLOT(setCaptureFile(capture_file*))); + sctp_dialog->fillTable(); + + if (sctp_dialog->isMinimized() == true) + { + sctp_dialog->showNormal(); + } + else + { + sctp_dialog->show(); + } + + sctp_dialog->raise(); + sctp_dialog->activateWindow(); +} + +void WiresharkMainWindow::on_actionSCTPShowAllAssociations_triggered() +{ + openSCTPAllAssocsDialog(); +} + +void WiresharkMainWindow::on_actionSCTPAnalyseThisAssociation_triggered() +{ + const sctp_assoc_info_t* assoc = SCTPAssocAnalyseDialog::findAssocForPacket(capture_file_.capFile()); + if (!assoc) { + return; + } + SCTPAssocAnalyseDialog *sctp_analyse = new SCTPAssocAnalyseDialog(this, assoc, capture_file_.capFile()); + connect(sctp_analyse, SIGNAL(filterPackets(QString, bool)), + this, SLOT(filterPackets(QString, bool))); + + if (sctp_analyse->isMinimized() == true) + { + sctp_analyse->showNormal(); + } + else + { + sctp_analyse->show(); + } + + sctp_analyse->raise(); + sctp_analyse->activateWindow(); +} + +void WiresharkMainWindow::on_actionSCTPFilterThisAssociation_triggered() +{ + const sctp_assoc_info_t* assoc = SCTPAssocAnalyseDialog::findAssocForPacket(capture_file_.capFile()); + if (assoc) { + QString newFilter = QString("sctp.assoc_index==%1").arg(assoc->assoc_id); + assoc = NULL; + emit filterPackets(newFilter, false); + } +} + +// -z wlan,stat +void WiresharkMainWindow::statCommandWlanStatistics(const char *arg, void *) +{ + WlanStatisticsDialog *wlan_stats_dlg = new WlanStatisticsDialog(*this, capture_file_, arg); + connect(wlan_stats_dlg, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType)), + this, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType))); + wlan_stats_dlg->show(); +} + +// -z expert +void WiresharkMainWindow::statCommandExpertInfo(const char *, void *) +{ + const DisplayFilterEdit *df_edit = dynamic_cast<DisplayFilterEdit *>(df_combo_box_->lineEdit()); + ExpertInfoDialog *expert_dialog = new ExpertInfoDialog(*this, capture_file_, df_edit->text()); + + connect(expert_dialog->getExpertInfoView(), SIGNAL(goToPacket(int, int)), + packet_list_, SLOT(goToPacket(int, int))); + connect(expert_dialog, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType)), + this, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType))); + + expert_dialog->show(); +} + + +// Next / previous / first / last slots in packet_list + +// Statistics Menu + +void WiresharkMainWindow::connectStatisticsMenuActions() +{ + connect(main_ui_->actionStatisticsCaptureFileProperties, &QAction::triggered, this, [=]() { + CaptureFilePropertiesDialog *capture_file_properties_dialog = new CaptureFilePropertiesDialog(*this, capture_file_); + connect(capture_file_properties_dialog, SIGNAL(captureCommentChanged()), + this, SLOT(updateForUnsavedChanges())); + capture_file_properties_dialog->show(); + }); + + connect(main_ui_->actionStatisticsResolvedAddresses, &QAction::triggered, this, &WiresharkMainWindow::showResolvedAddressesDialog); + + connect(main_ui_->actionStatisticsProtocolHierarchy, &QAction::triggered, this, [=]() { + ProtocolHierarchyDialog *phd = new ProtocolHierarchyDialog(*this, capture_file_); + connect(phd, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType)), + this, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType))); + phd->show(); + }); + + connect(main_ui_->actionStatisticsConversations, &QAction::triggered, this, &WiresharkMainWindow::showConversationsDialog); + connect(main_ui_->actionStatisticsEndpoints, &QAction::triggered, this, &WiresharkMainWindow::showEndpointsDialog); + + connect(main_ui_->actionStatisticsPacketLengths, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("plen"); }); + + connect(main_ui_->actionStatisticsIOGraph, &QAction::triggered, this, [=]() { statCommandIOGraph(NULL, NULL); }); + + connect(main_ui_->actionStatisticsFlowGraph, &QAction::triggered, this, [=]() { + SequenceDialog *sequence_dialog = new SequenceDialog(*this, capture_file_); + sequence_dialog->show(); + }); + + connect(main_ui_->actionStatisticsCollectd, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("collectd"); }); + connect(main_ui_->actionStatisticsDNS, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("dns"); }); + connect(main_ui_->actionStatisticsHART_IP, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("hart_ip"); }); + connect(main_ui_->actionStatisticsHpfeeds, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("hpfeeds"); }); + connect(main_ui_->actionStatisticsHTTP2, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("http2"); }); + connect(main_ui_->actionStatisticsUdpMulticastStreams, &QAction::triggered, this, [=]() { statCommandMulticastStatistics(NULL, NULL); }); + + connect(main_ui_->actionStatistics29WestTopics_Advertisements_by_Topic, &QAction::triggered, this, [=]() { + openStatisticsTreeDialog("lbmr_topic_ads_topic"); + }); + + connect(main_ui_->actionStatistics29WestTopics_Advertisements_by_Source, &QAction::triggered, this, [=]() { + openStatisticsTreeDialog("lbmr_topic_ads_source"); + }); + + connect(main_ui_->actionStatistics29WestTopics_Advertisements_by_Transport, &QAction::triggered, this, [=]() { + openStatisticsTreeDialog("lbmr_topic_ads_transport"); + }); + + connect(main_ui_->actionStatistics29WestTopics_Queries_by_Topic, &QAction::triggered, this, [=]() { + openStatisticsTreeDialog("lbmr_topic_queries_topic"); + }); + + connect(main_ui_->actionStatistics29WestTopics_Queries_by_Receiver, &QAction::triggered, this, [=]() { + openStatisticsTreeDialog("lbmr_topic_queries_receiver"); + }); + + connect(main_ui_->actionStatistics29WestTopics_Wildcard_Queries_by_Pattern, &QAction::triggered, this, [=]() { + openStatisticsTreeDialog("lbmr_topic_queries_pattern"); + }); + + connect(main_ui_->actionStatistics29WestTopics_Wildcard_Queries_by_Receiver, &QAction::triggered, this, [=]() { + openStatisticsTreeDialog("lbmr_topic_queries_pattern_receiver"); + }); + + connect(main_ui_->actionStatistics29WestQueues_Advertisements_by_Queue, &QAction::triggered, this, [=]() { + openStatisticsTreeDialog("lbmr_queue_ads_queue"); + }); + + connect(main_ui_->actionStatistics29WestQueues_Advertisements_by_Source, &QAction::triggered, this, [=]() { + openStatisticsTreeDialog("lbmr_queue_ads_source"); + }); + + connect(main_ui_->actionStatistics29WestQueues_Queries_by_Queue, &QAction::triggered, this, [=]() { + openStatisticsTreeDialog("lbmr_queue_queries_queue"); + }); + + connect(main_ui_->actionStatistics29WestQueues_Queries_by_Receiver, &QAction::triggered, this, [=]() { + openStatisticsTreeDialog("lbmr_queue_queries_receiver"); + }); + + connect(main_ui_->actionStatistics29WestUIM_Streams, &QAction::triggered, this, [=]() { + LBMStreamDialog *stream_dialog = new LBMStreamDialog(this, capture_file_.capFile()); + // connect(stream_dialog, SIGNAL(goToPacket(int)), + // packet_list_, SLOT(goToPacket(int))); + connect(this, SIGNAL(setCaptureFile(capture_file*)), + stream_dialog, SLOT(setCaptureFile(capture_file*))); + stream_dialog->show(); + }); + + connect(main_ui_->actionStatistics29WestLBTRM, &QAction::triggered, this, [=]() { + LBMLBTRMTransportDialog * lbtrm_dialog = new LBMLBTRMTransportDialog(this, capture_file_.capFile()); + connect(lbtrm_dialog, SIGNAL(goToPacket(int)), + packet_list_, SLOT(goToPacket(int))); + connect(this, SIGNAL(setCaptureFile(capture_file*)), + lbtrm_dialog, SLOT(setCaptureFile(capture_file*))); + lbtrm_dialog->show(); + }); + + connect(main_ui_->actionStatistics29WestLBTRU, &QAction::triggered, this, [=]() { + LBMLBTRUTransportDialog * lbtru_dialog = new LBMLBTRUTransportDialog(this, capture_file_.capFile()); + connect(lbtru_dialog, SIGNAL(goToPacket(int)), + packet_list_, SLOT(goToPacket(int))); + connect(this, SIGNAL(setCaptureFile(capture_file*)), + lbtru_dialog, SLOT(setCaptureFile(capture_file*))); + lbtru_dialog->show(); + }); + + connect(main_ui_->actionStatisticsTcpStreamStevens, &QAction::triggered, this, [=]() { openTcpStreamDialog(GRAPH_TSEQ_STEVENS); }); + connect(main_ui_->actionStatisticsTcpStreamTcptrace, &QAction::triggered, this, [=]() { openTcpStreamDialog(GRAPH_TSEQ_TCPTRACE); }); + connect(main_ui_->actionStatisticsTcpStreamThroughput, &QAction::triggered, this, [=]() { openTcpStreamDialog(GRAPH_THROUGHPUT); }); + connect(main_ui_->actionStatisticsTcpStreamRoundTripTime, &QAction::triggered, this, [=]() { openTcpStreamDialog(GRAPH_RTT); }); + connect(main_ui_->actionStatisticsTcpStreamWindowScaling, &QAction::triggered, this, [=]() { openTcpStreamDialog(GRAPH_WSCALE); }); + + connect(main_ui_->actionStatisticsANCP, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("ancp"); }); + + connect(main_ui_->actionStatisticsBACappInstanceId, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("bacapp_instanceid"); }); + connect(main_ui_->actionStatisticsBACappIP, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("bacapp_ip"); }); + connect(main_ui_->actionStatisticsBACappObjectId, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("bacapp_objectid"); }); + connect(main_ui_->actionStatisticsBACappService, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("bacapp_service"); }); + + connect(main_ui_->actionStatisticsHTTPPacketCounter, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("http"); }); + connect(main_ui_->actionStatisticsHTTPRequests, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("http_req"); }); + connect(main_ui_->actionStatisticsHTTPLoadDistribution, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("http_srv"); }); + connect(main_ui_->actionStatisticsHTTPRequestSequences, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("http_seq"); }); + + connect(main_ui_->actionStatisticsSametime, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("sametime"); }); + + connect(main_ui_->actionStatisticsSOMEIPmessages, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("someip_messages"); }); + connect(main_ui_->actionStatisticsSOMEIPSDentries, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("someipsd_entries"); }); + + connect(main_ui_->actionStatisticsLTP, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("ltp"); }); +} + +void WiresharkMainWindow::openTcpStreamDialog(int graph_type) +{ + TCPStreamDialog *stream_dialog = new TCPStreamDialog(this, capture_file_.capFile(), (tcp_graph_type)graph_type); + connect(stream_dialog, SIGNAL(goToPacket(int)), + packet_list_, SLOT(goToPacket(int))); + connect(this, SIGNAL(setCaptureFile(capture_file*)), + stream_dialog, SLOT(setCaptureFile(capture_file*))); + if (stream_dialog->result() == QDialog::Accepted) { + stream_dialog->show(); + } +} + +// -z mcast,stat +void WiresharkMainWindow::statCommandMulticastStatistics(const char *arg, void *) +{ + MulticastStatisticsDialog *mcast_stats_dlg = new MulticastStatisticsDialog(*this, capture_file_, arg); + connect(mcast_stats_dlg, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType)), + this, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType))); + mcast_stats_dlg->show(); +} + +void WiresharkMainWindow::openStatisticsTreeDialog(const gchar *abbr) +{ + StatsTreeDialog *st_dialog = new StatsTreeDialog(*this, capture_file_, abbr); +// connect(st_dialog, SIGNAL(goToPacket(int)), +// packet_list_, SLOT(goToPacket(int))); + st_dialog->show(); +} + +// -z io,stat +void WiresharkMainWindow::statCommandIOGraph(const char *, void *) +{ + const DisplayFilterEdit *df_edit = qobject_cast<DisplayFilterEdit *>(df_combo_box_->lineEdit()); + QString displayFilter; + if (df_edit) + displayFilter = df_edit->text(); + + IOGraphDialog *iog_dialog = new IOGraphDialog(*this, capture_file_, displayFilter); + connect(iog_dialog, SIGNAL(goToPacket(int)), packet_list_, SLOT(goToPacket(int))); + connect(this, SIGNAL(reloadFields()), iog_dialog, SLOT(reloadFields())); + iog_dialog->show(); +} + +// Telephony Menu + +void WiresharkMainWindow::connectTelephonyMenuActions() +{ + connect(main_ui_->actionTelephonyVoipCalls, &QAction::triggered, this, [=]() { + VoipCallsDialog *dialog = VoipCallsDialog::openVoipCallsDialogVoip(*this, capture_file_, packet_list_); + dialog->show(); + }); + + connect(main_ui_->actionTelephonyIax2StreamAnalysis, &QAction::triggered, this, [=]() { + Iax2AnalysisDialog *iax2_analysis_dialog = new Iax2AnalysisDialog(*this, capture_file_); + connect(iax2_analysis_dialog, &Iax2AnalysisDialog::goToPacket, this, [=](int packet) { packet_list_->goToPacket(packet); }); + iax2_analysis_dialog->show(); + }); + + connect(main_ui_->actionTelephonyISUPMessages, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("isup_msg"); }); + + connect(main_ui_->actionTelephonyGsmMapSummary, &QAction::triggered, this, [=]() { + GsmMapSummaryDialog *gms_dialog = new GsmMapSummaryDialog(*this, capture_file_); + gms_dialog->show(); + }); + + connect(main_ui_->actionTelephonyLteMacStatistics, &QAction::triggered, this, [=]() { statCommandLteMacStatistics(NULL, NULL); }); + connect(main_ui_->actionTelephonyLteRlcGraph, &QAction::triggered, this, [=]() { + // We don't yet know the channel. + launchRLCGraph(false, 0, 0, 0, 0, 0); + }); + connect(main_ui_->actionTelephonyLteRlcStatistics, &QAction::triggered, this, [=]() { statCommandLteRlcStatistics(NULL, NULL); }); + + connect(main_ui_->actionTelephonyMtp3Summary, &QAction::triggered, this, [=]() { + Mtp3SummaryDialog *mtp3s_dialog = new Mtp3SummaryDialog(*this, capture_file_); + mtp3s_dialog->show(); + }); + + connect(main_ui_->actionTelephonyOsmuxPacketCounter, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("osmux"); }); + + connect(main_ui_->actionTelephonyRtpStreams, &QAction::triggered, this, &WiresharkMainWindow::openTelephonyRtpStreamsDialog); + connect(main_ui_->actionTelephonyRtpStreamAnalysis, &QAction::triggered, this, &WiresharkMainWindow::openRtpStreamAnalysisDialog); + connect(main_ui_->actionTelephonyRtpPlayer, &QAction::triggered, this, &WiresharkMainWindow::openRtpPlayerDialog); + + connect(main_ui_->actionTelephonyRTSPPacketCounter, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("rtsp"); }); + + connect(main_ui_->actionTelephonySMPPOperations, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("smpp_commands"); }); + + connect(main_ui_->actionTelephonyUCPMessages, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("ucp_messages"); }); + + connect(main_ui_->actionTelephonyF1APMessages, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("f1ap"); }); + + connect(main_ui_->actionTelephonyNGAPMessages, &QAction::triggered, this, [=]() { openStatisticsTreeDialog("ngap"); }); + + connect(main_ui_->actionTelephonySipFlows, &QAction::triggered, this, [=]() { + VoipCallsDialog *dialog = VoipCallsDialog::openVoipCallsDialogSip(*this, capture_file_, packet_list_); + dialog->show(); + }); +} + +RtpPlayerDialog *WiresharkMainWindow::openTelephonyRtpPlayerDialog() +{ + RtpPlayerDialog *dialog; + +#ifdef HAVE_LIBPCAP + dialog = RtpPlayerDialog::openRtpPlayerDialog(*this, capture_file_, packet_list_, captureSession()->state != CAPTURE_STOPPED); +#else + dialog = RtpPlayerDialog::openRtpPlayerDialog(*this, capture_file_, packet_list_, false); +#endif + + dialog->show(); + + return dialog; +} + +RtpAnalysisDialog *WiresharkMainWindow::openTelephonyRtpAnalysisDialog() +{ + RtpAnalysisDialog *dialog; + + dialog = RtpAnalysisDialog::openRtpAnalysisDialog(*this, capture_file_, packet_list_); + dialog->show(); + + return dialog; +} + +// -z mac-lte,stat +void WiresharkMainWindow::statCommandLteMacStatistics(const char *arg, void *) +{ + LteMacStatisticsDialog *lte_mac_stats_dlg = new LteMacStatisticsDialog(*this, capture_file_, arg); + connect(lte_mac_stats_dlg, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType)), + this, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType))); + lte_mac_stats_dlg->show(); +} + +void WiresharkMainWindow::statCommandLteRlcStatistics(const char *arg, void *) +{ + LteRlcStatisticsDialog *lte_rlc_stats_dlg = new LteRlcStatisticsDialog(*this, capture_file_, arg); + connect(lte_rlc_stats_dlg, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType)), + this, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType))); + // N.B. It is necessary for the RLC Statistics window to launch the RLC graph in this way, to ensure + // that the goToPacket() signal/slot connection gets set up... + connect(lte_rlc_stats_dlg, SIGNAL(launchRLCGraph(bool, guint16, guint8, guint16, guint16, guint8)), + this, SLOT(launchRLCGraph(bool, guint16, guint8, guint16, guint16, guint8))); + + lte_rlc_stats_dlg->show(); +} + +void WiresharkMainWindow::launchRLCGraph(bool channelKnown, + guint16 ueid, guint8 rlcMode, + guint16 channelType, guint16 channelId, guint8 direction) +{ + LteRlcGraphDialog *lrg_dialog = new LteRlcGraphDialog(*this, capture_file_, channelKnown); + connect(lrg_dialog, SIGNAL(goToPacket(int)), packet_list_, SLOT(goToPacket(int))); + // This is a bit messy, but wanted to hide these parameters from users of + // on_actionTelephonyLteRlcGraph_triggered(). + if (channelKnown) { + lrg_dialog->setChannelInfo(ueid, rlcMode, channelType, channelId, direction); + } + lrg_dialog->show(); +} + +RtpStreamDialog *WiresharkMainWindow::openTelephonyRtpStreamsDialog() +{ + RtpStreamDialog *dialog = RtpStreamDialog::openRtpStreamDialog(*this, capture_file_, packet_list_); + dialog->show(); + + return dialog; +} + +void WiresharkMainWindow::openRtpStreamAnalysisDialog() +{ + QVector<rtpstream_id_t *> stream_ids; + QString err; + + if (QGuiApplication::keyboardModifiers().testFlag(Qt::ControlModifier)) { + err = findRtpStreams(&stream_ids, true); + } else { + err = findRtpStreams(&stream_ids, false); + } + if (!err.isNull()) { + QMessageBox::warning(this, tr("RTP packet search failed"), + err, + QMessageBox::Ok); + } else { + openTelephonyRtpAnalysisDialog()->addRtpStreams(stream_ids); + } + foreach(rtpstream_id_t *id, stream_ids) { + rtpstream_id_free(id); + g_free(id); + } +} + +void WiresharkMainWindow::openRtpPlayerDialog() +{ + QVector<rtpstream_id_t *> stream_ids; + QString err; + + if (QGuiApplication::keyboardModifiers().testFlag(Qt::ControlModifier)) { + err = findRtpStreams(&stream_ids, true); + } else { + err = findRtpStreams(&stream_ids, false); + } + if (!err.isNull()) { + QMessageBox::warning(this, tr("RTP packet search failed"), + err, + QMessageBox::Ok); +#ifdef QT_MULTIMEDIA_LIB + } else { + openTelephonyRtpPlayerDialog()->addRtpStreams(stream_ids); +#endif // QT_MULTIMEDIA_LIB + } + foreach(rtpstream_id_t *id, stream_ids) { + rtpstream_id_free(id); + g_free(id); + } +} + +// Wireless Menu + +void WiresharkMainWindow::connectWirelessMenuActions() +{ + connect(main_ui_->actionBluetoothATT_Server_Attributes, &QAction::triggered, this, [=]() { + BluetoothAttServerAttributesDialog *bluetooth_att_sever_attributes_dialog = new BluetoothAttServerAttributesDialog(*this, capture_file_); + connect(bluetooth_att_sever_attributes_dialog, SIGNAL(goToPacket(int)), + packet_list_, SLOT(goToPacket(int))); + connect(bluetooth_att_sever_attributes_dialog, SIGNAL(updateFilter(QString, bool)), + this, SLOT(filterPackets(QString, bool))); + bluetooth_att_sever_attributes_dialog->show(); + }); + + connect(main_ui_->actionBluetoothDevices, &QAction::triggered, this, [=]() { + BluetoothDevicesDialog *bluetooth_devices_dialog = new BluetoothDevicesDialog(*this, capture_file_, packet_list_); + connect(bluetooth_devices_dialog, SIGNAL(goToPacket(int)), + packet_list_, SLOT(goToPacket(int))); + connect(bluetooth_devices_dialog, SIGNAL(updateFilter(QString, bool)), + this, SLOT(filterPackets(QString, bool))); + bluetooth_devices_dialog->show(); + }); + + connect(main_ui_->actionBluetoothHCI_Summary, &QAction::triggered, this, [=]() { + BluetoothHciSummaryDialog *bluetooth_hci_summary_dialog = new BluetoothHciSummaryDialog(*this, capture_file_); + connect(bluetooth_hci_summary_dialog, SIGNAL(goToPacket(int)), + packet_list_, SLOT(goToPacket(int))); + connect(bluetooth_hci_summary_dialog, SIGNAL(updateFilter(QString, bool)), + this, SLOT(filterPackets(QString, bool))); + bluetooth_hci_summary_dialog->show(); + }); + + connect(main_ui_->actionWirelessWlanStatistics, &QAction::triggered, this, [=]() { statCommandWlanStatistics(NULL, NULL); }); +} + +// Tools Menu + +void WiresharkMainWindow::connectToolsMenuActions() +{ + connect(main_ui_->actionToolsFirewallAclRules, &QAction::triggered, this, [=]() { + FirewallRulesDialog *firewall_rules_dialog = new FirewallRulesDialog(*this, capture_file_); + firewall_rules_dialog->show(); + }); + + connect(main_ui_->actionToolsCredentials, &QAction::triggered, this, [=]() { + CredentialsDialog *credentials_dialog = new CredentialsDialog(*this, capture_file_, packet_list_); + credentials_dialog->show(); + }); + + connect(main_ui_->actionToolsMacLookup, &QAction::triggered, this, [=]() { + ManufDialog *manuf_dialog = new ManufDialog(*this, capture_file_); + manuf_dialog->show(); + }); + + connect(main_ui_->actionToolsTLSKeylog, &QAction::triggered, this, &WiresharkMainWindow::openTLSKeylogDialog); +} + +// Help Menu +void WiresharkMainWindow::connectHelpMenuActions() +{ + + connect(main_ui_->actionHelpAbout, &QAction::triggered, this, [=]() { + AboutDialog *about_dialog = new AboutDialog(this); + + if (about_dialog->isMinimized() == true) + { + about_dialog->showNormal(); + } + else + { + about_dialog->show(); + } + + about_dialog->raise(); + about_dialog->activateWindow(); + }); + + connect(main_ui_->actionHelpContents, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(HELP_CONTENT); }); + connect(main_ui_->actionHelpMPWireshark, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(LOCALPAGE_MAN_WIRESHARK); }); + connect(main_ui_->actionHelpMPWireshark_Filter, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(LOCALPAGE_MAN_WIRESHARK_FILTER); }); + connect(main_ui_->actionHelpMPCapinfos, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(LOCALPAGE_MAN_CAPINFOS); }); + connect(main_ui_->actionHelpMPDumpcap, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(LOCALPAGE_MAN_DUMPCAP); }); + connect(main_ui_->actionHelpMPEditcap, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(LOCALPAGE_MAN_EDITCAP); }); + connect(main_ui_->actionHelpMPMergecap, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(LOCALPAGE_MAN_MERGECAP); }); + connect(main_ui_->actionHelpMPRawshark, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(LOCALPAGE_MAN_RAWSHARK); }); + connect(main_ui_->actionHelpMPReordercap, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(LOCALPAGE_MAN_REORDERCAP); }); + connect(main_ui_->actionHelpMPText2pcap, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(LOCALPAGE_MAN_TEXT2PCAP); }); + connect(main_ui_->actionHelpMPTShark, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(LOCALPAGE_MAN_TSHARK); }); + connect(main_ui_->actionHelpWebsite, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(ONLINEPAGE_HOME); }); + connect(main_ui_->actionHelpFAQ, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(ONLINEPAGE_FAQ); }); + connect(main_ui_->actionHelpAsk, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(ONLINEPAGE_ASK); }); + connect(main_ui_->actionHelpDownloads, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(ONLINEPAGE_DOWNLOAD); }); + connect(main_ui_->actionHelpWiki, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(ONLINEPAGE_WIKI); }); + connect(main_ui_->actionHelpSampleCaptures, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(ONLINEPAGE_SAMPLE_FILES); }); + connect(main_ui_->actionHelpReleaseNotes, &QAction::triggered, this, [=]() { mainApp->helpTopicAction(LOCALPAGE_RELEASE_NOTES); }); +} + +#ifdef HAVE_SOFTWARE_UPDATE +void WiresharkMainWindow::checkForUpdates() +{ + software_update_check(); +} +#endif + +void WiresharkMainWindow::setPreviousFocus() { + previous_focus_ = mainApp->focusWidget(); + if (previous_focus_ != nullptr) { + connect(previous_focus_, SIGNAL(destroyed()), this, SLOT(resetPreviousFocus())); + } +} + +void WiresharkMainWindow::resetPreviousFocus() { + previous_focus_ = nullptr; +} + +void WiresharkMainWindow::goToCancelClicked() +{ + main_ui_->goToFrame->animatedHide(); + if (previous_focus_) { + disconnect(previous_focus_, SIGNAL(destroyed()), this, SLOT(resetPreviousFocus())); + previous_focus_->setFocus(); + resetPreviousFocus(); + } +} + +void WiresharkMainWindow::goToGoClicked() +{ + gotoFrame(main_ui_->goToLineEdit->text().toInt()); + + goToCancelClicked(); +} + +void WiresharkMainWindow::goToLineEditReturnPressed() +{ + goToGoClicked(); +} + +void WiresharkMainWindow::showResolvedAddressesDialog() +{ + QString capFileName; + wtap* wth = Q_NULLPTR; + if (capture_file_.isValid()) + { + capFileName = capture_file_.capFile()->filename; + wth = capture_file_.capFile()->provider.wth; + } + ResolvedAddressesDialog *resolved_addresses_dialog = + new ResolvedAddressesDialog(this, capFileName, wth); + resolved_addresses_dialog->show(); +} + +void WiresharkMainWindow::showConversationsDialog() +{ + ConversationDialog *conv_dialog = new ConversationDialog(*this, capture_file_); + connect(conv_dialog, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType)), + this, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType))); + connect(conv_dialog, SIGNAL(openFollowStreamDialog(int, guint, guint)), + this, SLOT(openFollowStreamDialog(int, guint, guint))); + connect(conv_dialog, SIGNAL(openTcpStreamGraph(int)), + this, SLOT(openTcpStreamDialog(int))); + conv_dialog->show(); +} + +void WiresharkMainWindow::showEndpointsDialog() +{ + EndpointDialog *endp_dialog = new EndpointDialog(*this, capture_file_); + connect(endp_dialog, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType)), + this, SIGNAL(filterAction(QString, FilterAction::Action, FilterAction::ActionType))); + connect(endp_dialog, SIGNAL(openFollowStreamDialog(int)), + this, SLOT(openFollowStreamDialog(int))); + connect(endp_dialog, SIGNAL(openTcpStreamGraph(int)), + this, SLOT(openTcpStreamDialog(int))); + endp_dialog->show(); +} + +void WiresharkMainWindow::externalMenuItemTriggered() +{ + QAction * triggerAction = NULL; + QVariant v; + ext_menubar_t * entry = NULL; + + if (QObject::sender()) { + triggerAction = (QAction *)QObject::sender(); + v = triggerAction->data(); + + if (v.canConvert<void *>()) { + entry = (ext_menubar_t *)v.value<void *>(); + + if (entry->type == EXT_MENUBAR_ITEM) { + entry->callback(EXT_MENUBAR_QT_GUI, (gpointer)((void *)main_ui_), entry->user_data); + } else { + QDesktopServices::openUrl(QUrl(QString((gchar *)entry->user_data))); + } + } + } +} + +void WiresharkMainWindow::extcap_options_finished(int result) +{ + if (result == QDialog::Accepted) { + QString before_what(tr(" before starting a new capture")); + if (testCaptureFileClose(before_what)) { + startCapture(QStringList()); + } + } + this->welcome_page_->getInterfaceFrame()->interfaceListChanged(); +} + +void WiresharkMainWindow::showExtcapOptionsDialog(QString &device_name, bool startCaptureOnClose) +{ + ExtcapOptionsDialog * extcap_options_dialog = ExtcapOptionsDialog::createForDevice(device_name, startCaptureOnClose, this); + /* The dialog returns null, if the given device name is not a valid extcap device */ + if (extcap_options_dialog) { + extcap_options_dialog->setModal(true); + extcap_options_dialog->setAttribute(Qt::WA_DeleteOnClose); + if (startCaptureOnClose) { + connect(extcap_options_dialog, SIGNAL(finished(int)), + this, SLOT(extcap_options_finished(int))); + } +#ifdef HAVE_LIBPCAP + if (capture_options_dialog_ && startCaptureOnClose) { + /* Allow capture options dialog to close */ + connect(extcap_options_dialog, SIGNAL(accepted()), + capture_options_dialog_, SLOT(accept())); + } +#endif + extcap_options_dialog->show(); + } +} + +void WiresharkMainWindow::on_actionContextWikiProtocolPage_triggered() +{ + QAction *wa = qobject_cast<QAction*>(sender()); + if (!wa) return; + + bool ok = false; + int field_id = wa->data().toInt(&ok); + if (!ok) return; + + const QString proto_abbrev = proto_registrar_get_abbrev(field_id); + + int ret = QMessageBox::question(this, mainApp->windowTitleString(tr("Wiki Page for %1").arg(proto_abbrev)), + tr("<p>The Wireshark Wiki is maintained by the community.</p>" + "<p>The page you are about to load might be wonderful, " + "incomplete, wrong, or nonexistent.</p>" + "<p>Proceed to the wiki?</p>"), + QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes); + + if (ret != QMessageBox::Yes) return; + + QUrl wiki_url = QString(WS_WIKI_URL("Protocols/%1")).arg(proto_abbrev); + QDesktopServices::openUrl(wiki_url); +} + +void WiresharkMainWindow::on_actionContextFilterFieldReference_triggered() +{ + QAction *wa = qobject_cast<QAction*>(sender()); + if (!wa) return; + + bool ok = false; + int field_id = wa->data().toInt(&ok); + if (!ok) return; + + const QString proto_abbrev = proto_registrar_get_abbrev(field_id); + + QUrl dfref_url = QString(WS_DOCS_URL "/dfref/%1/%2") + .arg(proto_abbrev[0]) + .arg(proto_abbrev); + QDesktopServices::openUrl(dfref_url); +} + +void WiresharkMainWindow::activatePluginIFToolbar(bool) +{ + QAction *sendingAction = dynamic_cast<QAction *>(sender()); + if (!sendingAction || !sendingAction->data().isValid()) + return; + + ext_toolbar_t *toolbar = VariantPointer<ext_toolbar_t>::asPtr(sendingAction->data()); + + QList<QToolBar *> toolbars = findChildren<QToolBar *>(); + foreach(QToolBar *bar, toolbars) { + AdditionalToolBar *iftoolbar = dynamic_cast<AdditionalToolBar *>(bar); + if (iftoolbar && iftoolbar->menuName().compare(toolbar->name) == 0) { + if (iftoolbar->isVisible()) { + iftoolbar->setVisible(false); + sendingAction->setChecked(true); + } else { + iftoolbar->setVisible(true); + sendingAction->setChecked(true); + } + } + } +} + +void WiresharkMainWindow::rtpPlayerDialogReplaceRtpStreams(QVector<rtpstream_id_t *> stream_ids _U_) +{ +#ifdef QT_MULTIMEDIA_LIB + openTelephonyRtpPlayerDialog()->replaceRtpStreams(stream_ids); +#endif +} + +void WiresharkMainWindow::rtpPlayerDialogAddRtpStreams(QVector<rtpstream_id_t *> stream_ids _U_) +{ +#ifdef QT_MULTIMEDIA_LIB + openTelephonyRtpPlayerDialog()->addRtpStreams(stream_ids); +#endif +} + +void WiresharkMainWindow::rtpPlayerDialogRemoveRtpStreams(QVector<rtpstream_id_t *> stream_ids _U_) +{ +#ifdef QT_MULTIMEDIA_LIB + openTelephonyRtpPlayerDialog()->removeRtpStreams(stream_ids); +#endif +} + +void WiresharkMainWindow::rtpAnalysisDialogReplaceRtpStreams(QVector<rtpstream_id_t *> stream_ids) +{ + openTelephonyRtpAnalysisDialog()->replaceRtpStreams(stream_ids); +} + +void WiresharkMainWindow::rtpAnalysisDialogAddRtpStreams(QVector<rtpstream_id_t *> stream_ids) +{ + openTelephonyRtpAnalysisDialog()->addRtpStreams(stream_ids); +} + +void WiresharkMainWindow::rtpAnalysisDialogRemoveRtpStreams(QVector<rtpstream_id_t *> stream_ids) +{ + openTelephonyRtpAnalysisDialog()->removeRtpStreams(stream_ids); +} + +void WiresharkMainWindow::rtpStreamsDialogSelectRtpStreams(QVector<rtpstream_id_t *> stream_ids) +{ + openTelephonyRtpStreamsDialog()->selectRtpStream(stream_ids); +} + +void WiresharkMainWindow::rtpStreamsDialogDeselectRtpStreams(QVector<rtpstream_id_t *> stream_ids) +{ + openTelephonyRtpStreamsDialog()->deselectRtpStream(stream_ids); +} + +#ifdef _MSC_VER +#pragma warning(pop) +#endif |