wireshark_main_window.h

Go to the documentation of this file.

 
#ifndef WIRESHARK_MAIN_WINDOW_H
#define WIRESHARK_MAIN_WINDOW_H


 
#include <stdio.h>
 
#include <config.h>
 
#include "ui/ws_ui_util.h"
#include "ui/iface_toolbar.h"
 
#ifdef HAVE_LIBPCAP
#include "ui/capture_opts.h"
#endif
#include "ui/plugins/include/plugin_if.h"
 
#include <epan/timestamp.h>
 
#include <capture/capture_session.h>
 
#include <QMainWindow>
#include <QPointer>
 
#ifdef _WIN32
# include <QTimer>
#else
# include <QSocketNotifier>
#endif
 
#include "capture_file_dialog.h"
#include "capture_file_properties_dialog.h"
#include <ui/qt/utils/field_information.h>
#include <ui/qt/widgets/display_filter_entry.h>
#include "main_window.h"
#include "rtp_stream_dialog.h"
#include "rtp_analysis_dialog.h"
#include "tlskeylog_launcher_dialog.h"
 
class AccordionFrame;
class DataSourceTab;
class CaptureOptionsDialog;
class DisStreamDialog;
class InPacketSearch;
class PrintDialog;
class FileSetDialog;
class FilterDialog;
class FunnelStatistics;
class WelcomePage;
class PacketCommentDialog;
class PacketDiagram;
class PacketList;
class ProtoTree;
#if defined(HAVE_LIBNL) && defined(HAVE_NL80211)
class WirelessFrame;
#endif
class FilterExpressionToolBar;
class WiresharkApplication;
 
class QAction;
class QActionGroup;
 
namespace Ui {
    class WiresharkMainWindow;
}
 
Q_DECLARE_METATYPE(ts_type)
Q_DECLARE_METATYPE(ts_precision)
 

class WiresharkMainWindow : public MainWindow
{
    Q_OBJECT
 
public:
    explicit WiresharkMainWindow(QWidget *parent = nullptr);

    ~WiresharkMainWindow();
 
#ifdef HAVE_LIBPCAP
    capture_session *captureSession() { return &cap_session_; }

    info_data_t *captureInfoData() { return &info_data_; }
#endif

    QMenu *createPopupMenu() override;

    void setFunnelMenus(void);

    void removeAdditionalToolbar(QString toolbarName);

    void addInterfaceToolbar(const iface_toolbar *toolbar_entry);

    void removeInterfaceToolbar(const char *menu_title);

    QString getMwFileName();

    void setMwFileName(QString fileName);
 
protected:
    bool eventFilter(QObject *obj, QEvent *event) override;

    bool event(QEvent *event) override;

    void keyPressEvent(QKeyEvent *event) override;

    void closeEvent(QCloseEvent *event) override;

    void dragEnterEvent(QDragEnterEvent *event) override;

    void dropEvent(QDropEvent *event) override;

    void changeEvent(QEvent *event) override;

    void openRecentCaptureFile(const QString &filename) override;

    bool tryClosingCaptureFile(QString before_what, FileCloseContext context = Default) override;
 
private:
    enum MatchSelected {
        MatchSelectedReplace,  
        MatchSelectedAnd,      
        MatchSelectedOr,       
        MatchSelectedNot,      
        MatchSelectedAndNot,   
        MatchSelectedOrNot     
    };
 
    Ui::WiresharkMainWindow   *main_ui_;              
    QFont                      mono_font_;             
#if defined(HAVE_LIBNL) && defined(HAVE_NL80211)
    WirelessFrame             *wireless_frame_;        
#endif
    QWidget                   *previous_focus_;        
    FileSetDialog             *file_set_dialog_;       
    QActionGroup              *show_hide_actions_;     
    QActionGroup              *time_display_actions_;  
    QActionGroup              *time_precision_actions_;
    FunnelStatistics          *funnel_statistics_;     
    QAction                   *action_telephony_dis_streams_; 
    QAction                   *action_telephony_imsi_list_; 
    QList<QPair<QAction *, bool>> freeze_actions_;     
    QPointer<QWidget>          freeze_focus_;          
    QMap<QAction *, ts_type>   td_actions;             
    QMap<QAction *, ts_precision> tp_actions;          
    bool                       was_maximized_;         
 
    /* the following values are maintained so that the capture file name and status
    is available when there is no cf structure available */
 
    QString mwFileName_; 
 
    bool capture_stopping_;     
    bool capture_filter_valid_; 
#ifdef HAVE_LIBPCAP
    capture_session            cap_session_;             
    CaptureOptionsDialog      *capture_options_dialog_;  
    info_data_t                info_data_;               
#endif
    InPacketSearch *in_packet_search_; 
    QPoint dragStartPosition; 
 
    QPointer<TLSKeylogDialog> tlskeylog_dialog_; 

    void freeze();

    void thaw();

    void mergeCaptureFile();

    void importCaptureFile();

    bool saveCaptureFile(capture_file *cf, bool dont_reopen);

    bool saveAsCaptureFile(capture_file *cf, bool must_support_comments = false, bool dont_reopen = false);

    void exportSelectedPackets();

    void exportDissections(export_type_e export_type);

    void enableAggregationView(bool enable) const;
 
#ifdef Q_OS_WIN
    void fileAddExtension(QString &file_name, int file_type, ws_compression_type compression_type);
#endif

    void captureStop(bool discard = false);

    void initMainToolbarIcons();

    void initShowHideMainWidgets();

    void initTimeDisplayFormatMenu();

    void initTimePrecisionFormatMenu();

    void initFreezeActions();

    void setMenusForCaptureFile(bool force_disable = false) override;

    void setMenusForCaptureInProgress(bool capture_in_progress = false);

    void setMenusForCaptureStopping();

    void setForCapturedPackets(bool have_captured_packets);

    void setMenusForFileSet(bool enable_list_files);

    void updateStyleSheet();

    void externalMenuHelper(ext_menu_t *menu, QMenu *subMenu, int depth);

    void setForCaptureInProgress(bool capture_in_progress = false, bool handle_toolbars = false, GArray *ifaces = NULL);

    QMenu *findOrAddMenu(QMenu *parent_menu, const QStringList &menu_parts);

    QMenu *findOrAddMenubar(const QString menu_text);

    void captureFileReadStarted(const QString &action);

    void addMenusandSubmenus(QAction *action, QMenu *cur_menu);

    void removeMenusandSubmenus(QAction *action, QMenu *cur_menu);

    void addMenuActions(QList<QAction *> &actions, int menu_group);

    void removeMenuActions(QList<QAction *> &actions, int menu_group);

    void goToConversationFrame(bool go_next, bool start_current = true);

    void colorizeWithFilter(QByteArray filter, int color_number = -1);
 
signals:
    void setDissectedCaptureFile(capture_file *cf);

    void closePacketDialogs();

    void reloadFields();

    void packetInfoChanged(struct _packet_info *pinfo);

    void fieldFilterChanged(const QByteArray field_filter);

    void selectRtpStream(rtpstream_id_t *id);

    void deselectRtpStream(rtpstream_id_t *id);
 
#ifdef HAVE_LIBPCAP
    void showExtcapOptions(QString &device_name, bool startCaptureOnClose);
#endif
 
public slots:
    // Qt lets you connect signals and slots using functors (new, manual style)
    // and strings (old style). Functors are preferred since they're connected at
    // compile time and less error prone.
    //
    // If you're manually connecting a signal to a slot, don't prefix its name
    // with "on_". Otherwise Qt will try to automatically connect it and you'll
    // get runtime warnings.
 
    // in main_window_slots.cpp

    bool openCaptureFile(QString cf_path, QString display_filter, unsigned int type, bool is_tempfile = false);

    bool openCaptureFile(QString cf_path = QString(), QString display_filter = QString()) { return openCaptureFile(cf_path, display_filter, WTAP_TYPE_AUTO); }
 

    void layoutToolbars();

    void updatePreferenceActions();

    void updateRecentActions();

    void updateAggregationView() const;

    void setTitlebarForCaptureFile();

    void showCaptureOptionsDialog();
 
#ifdef HAVE_LIBPCAP
    void captureCapturePrepared(capture_session *session);

    void captureCaptureUpdateStarted(capture_session *session);

    void captureCaptureUpdateFinished(capture_session *session);

    void captureCaptureFixedFinished(capture_session *cap_session);

    void captureCaptureFailed(capture_session *);
#endif

    void captureFileOpened();

    void captureFileReadFinished();

    void captureFileClosing();

    void captureFileClosed();

    void launchRLCGraph(bool channelKnown, uint8_t RAT, uint16_t ueid, uint8_t rlcMode,
                        uint16_t channelType, uint16_t channelId, uint8_t direction);
 
#ifdef HAVE_LUA
    void openLuaDebuggerDialog();
#endif

    void rtpPlayerDialogReplaceRtpStreams(QVector<rtpstream_id_t *> stream_ids);

    void rtpPlayerDialogAddRtpStreams(QVector<rtpstream_id_t *> stream_ids);

    void rtpPlayerDialogRemoveRtpStreams(QVector<rtpstream_id_t *> stream_ids);

    void rtpAnalysisDialogReplaceRtpStreams(QVector<rtpstream_id_t *> stream_ids);

    void rtpAnalysisDialogAddRtpStreams(QVector<rtpstream_id_t *> stream_ids);

    void rtpAnalysisDialogRemoveRtpStreams(QVector<rtpstream_id_t *> stream_ids);

    void rtpStreamsDialogSelectRtpStreams(QVector<rtpstream_id_t *> stream_ids);

    void rtpStreamsDialogDeselectRtpStreams(QVector<rtpstream_id_t *> stream_ids);
 
protected slots:
    void applyFilter(QString new_filter = QString(), bool force = false) override;
 
private slots:
    void onAppInitialized();

    void captureEventHandler(CaptureEvent ev);

    void initViewColorizeMenu();

    void initConversationMenus();

    static bool addExportObjectsMenuItem(const void *key, void *value, void *userdata);

    void initExportObjectsMenus();

    static bool addFollowStreamMenuItem(const void *key, void *value, void *userdata);

    void initFollowStreamMenus();

    void startCapture(QStringList interfaces);

    void startCapture();

    void pushLiveCaptureInProgress();

    void popLiveCaptureInProgress();

    void stopCapture();

    void aggregationViewChanged(bool enable) const;

    void loadWindowGeometry();

    void saveWindowGeometry();

    void mainStackChanged(int);

    void updateRecentCaptures();

    void addPacketComment();

    void editPacketComment();

    void deletePacketComment();

    void deleteCommentsFromPackets();

    QString commentToMenuText(QString text, int max_len = 40);

    void setEditCommentsMenu();

    void setMenusForSelectedPacket();

    void setMenusForSelectedTreeRow(FieldInformation *fi = NULL);

    void interfaceSelectionChanged();

    void captureFilterSyntaxChanged(bool valid);

    void redissectPackets();

    void checkDisplayFilter();

    void fieldsChanged();

    void reloadLuaPlugins();

    void showAccordionFrame(AccordionFrame *show_frame, bool toggle = false);

    void showColumnEditor(int column);

    void showPreferenceEditor();

    void addStatsPluginsToMenu();

    void addDynamicMenus();

    void reloadDynamicMenus();

    void addPluginIFStructures();

    QMenu *searchSubMenu(QString objectName);

    void activatePluginIFToolbar(bool);

    void startInterfaceCapture(bool valid, const QString capture_filter);

    void applyGlobalCommandLineOptions();

    void setFeaturesEnabled(bool enabled = true);

    void on_actionNewDisplayFilterExpression_triggered();

    void onFilterSelected(QString filterText, bool prepare);

    void onFilterPreferences();

    void onFilterEdit(int uatIndex);

    void queuedFilterAction(QString filter, FilterAction::Action action, FilterAction::ActionType type);

    void openStatCommandDialog(const QString &menu_path, const char *arg, void *userdata);

    void openTapParameterDialog(const QString cfg_str, const QString arg, void *userdata);

    void openTapParameterDialog();

    void connectFileMenuActions();

    void exportPacketBytes();

    void exportPDU();

    void stripPacketHeaders();

    void exportTLSSessionKeys();

    void printFile();

    void connectEditMenuActions();

    void copySelectedItems(WiresharkMainWindow::CopySelected selection_type);

    void findPacket();

    void editTimeShift();

    void editConfigurationProfiles();

    void editTimeShiftFinished(int result);

    void addPacketCommentFinished(PacketCommentDialog *pc_dialog, int result);

    void editPacketCommentFinished(PacketCommentDialog *pc_dialog, int result, unsigned nComment);

    void deleteAllPacketComments();

    void deleteAllPacketCommentsFinished(int result);

    void injectSecrets(const char *proto_name, const char *wiki_link);

    void discardAllSecrets();

    void discardAllSecretsFinished(int result);

    void showPreferencesDialog(QString module_name) override;

    void connectViewMenuActions();

    void showHideMainWidgets(QAction *action);

    void setTimestampFormat(QAction *action);

    void setTimestampPrecision(QAction *action);

    void setTimeDisplaySecondsWithHoursAndMinutes(bool checked);

    void editResolvedName();

    void setNameResolution();

    void showColoringRulesDialog();

    void colorizeConversation(bool create_rule = false);

    void colorizeActionTriggered();

    void openPacketDialog(bool from_reference = false);

    void reloadCaptureFileAsFormatOrCapture();

    void reloadCaptureFile();

    void connectGoMenuActions();

    void setPreviousFocus();

    void resetPreviousFocus();

    void connectCaptureMenuActions();

    void startCaptureTriggered();

    void connectAnalyzeMenuActions();

    void matchFieldFilter(FilterAction::Action action, FilterAction::ActionType filter_type);

    void applyFieldAsColumn();

    void filterMenuAboutToShow();

    void applyConversationFilter();

    void applyExportObject();

    void openFollowStreamDialog(int proto_id, unsigned stream_num, unsigned sub_stream_num, bool use_stream_index = true);

    void openFollowStreamDialog(int proto_id);

    void openIOGraph(bool filtered, QVector<uint> conv_ids, QVector<QVariant> conv_agg);

    void statCommandExpertInfo(const char *, void *);

    void connectHelpMenuActions();

    void goToCancelClicked();

    void goToGoClicked();

    void goToLineEditReturnPressed();

    void connectStatisticsMenuActions();

    void showResolvedAddressesDialog();

    void showConversationsDialog();

    void showEndpointsDialog();

    void showDistributionDialog(const QString &abbreviation);
    void showDistributionDialog();

    void openTcpStreamDialog(int graph_type);
    void openTcpDedupDialog();

    void openSCTPAllAssocsDialog();

    void on_actionSCTPShowAllAssociations_triggered();

    void on_actionSCTPAnalyseThisAssociation_triggered();

    void on_actionSCTPFilterThisAssociation_triggered();

    void statCommandMulticastStatistics(const char *, void *);

    void statCommandWlanStatistics(const char *, void *);

    void openStatisticsTreeDialog(const char *abbr);

    void statCommandIOGraph(const char *, void *);

    void showIOGraphDialog(io_graph_item_unit_t value_units, QString yfield) override;

    void showPlotDialog(const QString &y_field = QString(), bool filtered = false) override;

    void connectTelephonyMenuActions();

    DisStreamDialog *openTelephonyDisStreamsDialog();

    RtpStreamDialog *openTelephonyRtpStreamsDialog();

    RtpPlayerDialog *openTelephonyRtpPlayerDialog();

    RtpAnalysisDialog *openTelephonyRtpAnalysisDialog();

    void statCommandLteMacStatistics(const char *arg, void *);

    void statCommandLteRlcStatistics(const char *arg, void *);

    void openRtpStreamAnalysisDialog();

    void openRtpPlayerDialog();

    void connectWirelessMenuActions();

    void connectToolsMenuActions();

    void externalMenuItemTriggered();

    void on_actionContextWikiProtocolPage_triggered();

    void on_actionContextFilterFieldReference_triggered();

    void extcap_options_finished(int result);

    void showExtcapOptionsDialog(QString device_name, bool startCaptureOnClose);

    QString findRtpStreams(QVector<rtpstream_id_t *> *stream_ids, bool reverse);

    void openTLSKeylogDialog();

    friend class MainApplication;
};
 
#endif // WIRESHARK_MAIN_WINDOW_H