stratoshark_main_window.h

Go to the documentation of this file.

 
#pragma once
 
#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_combo.h>
#include "main_window.h"
 
class AccordionFrame;
class DataSourceTab;
class CaptureOptionsDialog;
class PrintDialog;
class FileSetDialog;
class FilterDialog;
class FunnelStatistics;
class PacketCommentDialog;
class PacketList;
class ProtoTree;
class FilterExpressionToolBar;
class WiresharkApplication;
 
class QAction;
class QActionGroup;
 
namespace Ui {
    class StratosharkMainWindow;
}
 
Q_DECLARE_METATYPE(ts_type)
Q_DECLARE_METATYPE(ts_precision)
 
 
class StratosharkMainWindow : public MainWindow
{
    Q_OBJECT
 
public:
    explicit StratosharkMainWindow(QWidget *parent = nullptr);
 
    ~StratosharkMainWindow();
 
#ifdef HAVE_LIBPCAP
    capture_session *captureSession() { return &cap_session_; }
 
    info_data_t *captureInfoData() { return &info_data_; }
#endif
 
    QMenu *createPopupMenu() override;
 
    CaptureFile *captureFile() { return &capture_file_; }
 
    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::StratosharkMainWindow *main_ui_;          
    QFont                      mono_font_;         
    QWidget                   *previous_focus_;    
    FileSetDialog             *file_set_dialog_;   
    QActionGroup              *show_hide_actions_; 
    QActionGroup              *time_display_actions_;   
    QActionGroup              *time_precision_actions_;  
    FunnelStatistics          *funnel_statistics_;  
    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_;     
    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
 
    QPoint dragStartPosition; 
    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);
 
#ifdef Q_OS_WIN
    void fileAddExtension(QString &file_name, int file_type, ws_compression_type compression_type);
#endif
 
    void captureStop();
 
    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);
 
    void captureFileReadStarted(const QString &action);
 
    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);
 
#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 filterPackets(QString new_filter = QString(), bool force = false) override;
 
    void updateForUnsavedChanges();
 
    void layoutToolbars();
 
    void updatePreferenceActions();
 
    void updateRecentActions();
 
    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 *);
 
    void captureCaptureFailed(capture_session *);
#endif
 
    void captureFileOpened();
 
    void captureFileReadFinished();
 
    void captureFileClosing();
 
    void captureFileClosed();
 
#ifdef HAVE_LUA
    void openLuaDebuggerDialog();
#endif
 
private slots:
    void captureEventHandler(CaptureEvent ev);
 
    void initViewColorizeMenu();
 
    void initConversationMenus();
 
    static bool addFollowStreamMenuItem(const void *key, void *value, void *userdata);
 
    void initFollowStreamMenus();
 
    // in main_window_slots.cpp
    void startCapture(QStringList);
 
    void startCapture();
 
    void pushLiveCaptureInProgress();
 
    void popLiveCaptureInProgress();
 
    void stopCapture();
 
    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 printFile();
 
    void connectEditMenuActions();
 
    void copySelectedItems(StratosharkMainWindow::CopySelected selection_type);
 
    void findPacket();
 
    void editTimeShift();
 
    void editConfigurationProfiles();
 
    void editTimeShiftFinished(int);
 
    void addPacketCommentFinished(PacketCommentDialog *pc_dialog, int result);
 
    void editPacketCommentFinished(PacketCommentDialog *pc_dialog, int result, unsigned nComment);
 
    void deleteAllPacketComments();
 
    void deleteAllPacketCommentsFinished(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 zoomText();
 
    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 openFollowStreamDialog(int proto_id, unsigned stream_num, unsigned sub_stream_num, bool use_stream_index = true);
 
    void openFollowStreamDialog(int proto_id);
 
    void statCommandExpertInfo(const char *, void *);
 
    void connectToolsMenuActions();
 
    void connectHelpMenuActions();
 
    void goToCancelClicked();
 
    void goToGoClicked();
 
    void goToLineEditReturnPressed();
 
    void connectStatisticsMenuActions();
 
    void showResolvedAddressesDialog();
 
    void showConversationsDialog();
 
    void showEndpointsDialog();
 
    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 externalMenuItemTriggered();
 
    void on_actionContextWikiProtocolPage_triggered();
 
    void on_actionContextFilterFieldReference_triggered();
 
    void extcap_options_finished(int result);
 
    void showExtcapOptionsDialog(QString device_name, bool startCaptureOnClose);
 
    friend class MainApplication;
};