forked from osmocom/wireshark
![João Valverde](/assets/img/avatar_default.png)
Experience has shown that: 1. The current logging methods are not very reliable or practical. A logging bitmask makes little sense as the user-facing interface (who would want debug but not crtical messages for example?); it's computer-friendly and user-unfriendly. More importantly the console log level preference is initialized too late in the startup process to be used for the logging subsystem and that fact raises a number of annoying and hard-to-fix usability issues. 2. Coding around G_MESSAGES_DEBUG to comply with our log level mask and not clobber the user's settings or not create unexpected log misses is unworkable and generally follows the principle of most surprise. The fact that G_MESSAGES_DEBUG="all" can leak to other programs using GLib is also annoying. 3. The non-structured GLib logging API is very opinionated and lacks configurability beyond replacing the log handler. 4. Windows GUI has some special code to attach to a console, but it would be nice to abstract away the rest under a single interface. 5. Using this logger seems to be noticeably faster. Deprecate the console log level preference and extend our API to implement a log handler in wsutil/wslog.h to provide easy-to-use, flexible and dependable logging during all execution phases. Log levels have a hierarchy, from most verbose to least verbose (debug to error). When a given level is set everything above that is also enabled. The log level can be set with an environment variable or a command line option (parsed as soon as possible but still later than the environment). The default log level is "message". Dissector logging is not included because it is not clear what log domain they should use. An explosion to thousands of domains is not desirable and putting everything in a single domain is probably too coarse and noisy. For now I think it makes sense to let them do their own thing using g_log_default_handler() and continue using the G_MESSAGES_DEBUG mechanism with specific domains for each individual dissector. In the future a mechanism may be added to selectively enable these domains at runtime while trying to avoid the problems introduced by G_MESSAGES_DEBUG.
387 lines
10 KiB
C++
387 lines
10 KiB
C++
/* capture_file.cpp
|
|
*
|
|
* Wireshark - Network traffic analyzer
|
|
* By Gerald Combs <gerald@wireshark.org>
|
|
* Copyright 1998 Gerald Combs
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0-or-later
|
|
*/
|
|
|
|
#include "capture_file.h"
|
|
|
|
/*
|
|
* @file Capture file class
|
|
*
|
|
* Wraps the capture_file struct, cfile global, and callbacks.
|
|
*/
|
|
|
|
#include "globals.h"
|
|
capture_file cfile;
|
|
|
|
#include "file.h"
|
|
|
|
#include "epan/epan_dissect.h"
|
|
|
|
#include "ui/capture.h"
|
|
|
|
#include <QFileInfo>
|
|
#include <QTimer>
|
|
#include <QDebug>
|
|
|
|
CaptureEvent::CaptureEvent(Context ctx, EventType evt) :
|
|
_ctx(ctx),
|
|
_evt(evt),
|
|
_session(Q_NULLPTR)
|
|
{
|
|
}
|
|
|
|
CaptureEvent::CaptureEvent(Context ctx, EventType evt, QString file) :
|
|
_ctx(ctx),
|
|
_evt(evt),
|
|
_filePath(file),
|
|
_session(Q_NULLPTR)
|
|
{
|
|
}
|
|
|
|
CaptureEvent::CaptureEvent(Context ctx, EventType evt, capture_session * session) :
|
|
_ctx(ctx),
|
|
_evt(evt),
|
|
_session(session)
|
|
{
|
|
}
|
|
|
|
CaptureEvent::CaptureEvent(const CaptureEvent &ce) :
|
|
_ctx(ce._ctx),
|
|
_evt(ce._evt),
|
|
_filePath(ce._filePath),
|
|
_session(ce._session)
|
|
{
|
|
}
|
|
|
|
CaptureEvent::Context CaptureEvent::captureContext() const
|
|
{ return _ctx; }
|
|
|
|
CaptureEvent::EventType CaptureEvent::eventType() const
|
|
{ return _evt; }
|
|
|
|
QString CaptureEvent::filePath() const
|
|
{ return _filePath; }
|
|
|
|
capture_session * CaptureEvent::capSession() const
|
|
{ return _session; }
|
|
|
|
// To do:
|
|
// - Add getters and (if needed) setters:
|
|
// - Full filename
|
|
// - Capture state (stopped, prepared, running).
|
|
// - Call common_create_progress_dlg. This would let us manage the stop
|
|
// flag here as well as emit progress signals.
|
|
|
|
QString CaptureFile::no_capture_file_ = QObject::tr("[no capture file]");
|
|
|
|
CaptureFile::CaptureFile(QObject *parent, capture_file *cap_file) :
|
|
QObject(parent),
|
|
cap_file_(cap_file),
|
|
file_state_(QString())
|
|
{
|
|
#ifdef HAVE_LIBPCAP
|
|
capture_callback_add(captureCallback, (gpointer) this);
|
|
#endif
|
|
cf_callback_add(captureFileCallback, (gpointer) this);
|
|
}
|
|
|
|
CaptureFile::~CaptureFile()
|
|
{
|
|
cf_callback_remove(captureFileCallback, this);
|
|
}
|
|
|
|
bool CaptureFile::isValid() const
|
|
{
|
|
if (cap_file_ && cap_file_->state != FILE_CLOSED) { // XXX FILE_READ_IN_PROGRESS as well?
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int CaptureFile::currentRow()
|
|
{
|
|
if (isValid())
|
|
return cap_file_->current_row;
|
|
return -1;
|
|
}
|
|
|
|
const QString CaptureFile::filePath()
|
|
{
|
|
QString path;
|
|
|
|
if (isValid()) {
|
|
//
|
|
// Sadly, some UN*Xes don't necessarily use UTF-8
|
|
// for their file names, so we have to map the
|
|
// file path to UTF-8. If that fails, we're somewhat
|
|
// stuck.
|
|
//
|
|
char *utf8_filename = g_filename_to_utf8(cap_file_->filename,
|
|
-1,
|
|
NULL,
|
|
NULL,
|
|
NULL);
|
|
if (utf8_filename) {
|
|
path = QString::fromUtf8(utf8_filename);
|
|
g_free(utf8_filename);
|
|
} else {
|
|
// So what the heck else can we do here?
|
|
path = QString();
|
|
}
|
|
} else {
|
|
path = QString();
|
|
}
|
|
return path;
|
|
}
|
|
|
|
const QString CaptureFile::fileName()
|
|
{
|
|
QString path, name;
|
|
|
|
path = filePath();
|
|
if (!path.isEmpty()) {
|
|
QFileInfo cfi(path);
|
|
name = cfi.fileName();
|
|
} else {
|
|
name = QString();
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
const QString CaptureFile::fileBaseName()
|
|
{
|
|
QString baseName;
|
|
|
|
if (isValid()) {
|
|
char *basename = cf_get_basename(cap_file_);
|
|
baseName = basename;
|
|
g_free(basename);
|
|
} else {
|
|
baseName = QString();
|
|
}
|
|
return baseName;
|
|
}
|
|
|
|
const QString CaptureFile::fileDisplayName()
|
|
{
|
|
QString displayName;
|
|
|
|
if (isValid()) {
|
|
char *display_name = cf_get_display_name(cap_file_);
|
|
displayName = display_name;
|
|
g_free(display_name);
|
|
} else {
|
|
displayName = QString();
|
|
}
|
|
return displayName;
|
|
}
|
|
|
|
const QString CaptureFile::fileTitle()
|
|
{
|
|
QString title;
|
|
|
|
if (isValid()) {
|
|
title = fileDisplayName() + file_state_;
|
|
} else {
|
|
title = no_capture_file_;
|
|
}
|
|
return title;
|
|
}
|
|
|
|
struct _packet_info *CaptureFile::packetInfo()
|
|
{
|
|
if (capFile() && capFile()->edt) {
|
|
return &(capFile()->edt->pi);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
int CaptureFile::timestampPrecision()
|
|
{
|
|
if (capFile() && capFile()->provider.wth) {
|
|
return wtap_file_tsprec(capFile()->provider.wth);
|
|
}
|
|
return WTAP_TSPREC_UNKNOWN;
|
|
}
|
|
|
|
void CaptureFile::retapPackets()
|
|
{
|
|
if (cap_file_) {
|
|
cf_retap_packets(cap_file_);
|
|
}
|
|
}
|
|
|
|
void CaptureFile::delayedRetapPackets()
|
|
{
|
|
QTimer::singleShot(0, this, SLOT(retapPackets()));
|
|
}
|
|
|
|
void CaptureFile::reload()
|
|
{
|
|
if (cap_file_ && cap_file_->state == FILE_READ_DONE) {
|
|
cf_reload(cap_file_);
|
|
}
|
|
}
|
|
|
|
void CaptureFile::stopLoading()
|
|
{
|
|
setCaptureStopFlag(true);
|
|
}
|
|
|
|
capture_file *CaptureFile::globalCapFile()
|
|
{
|
|
return &cfile;
|
|
}
|
|
|
|
gpointer CaptureFile::window()
|
|
{
|
|
if (cap_file_) return cap_file_->window;
|
|
return NULL;
|
|
}
|
|
|
|
void CaptureFile::setCaptureStopFlag(bool stop_flag)
|
|
{
|
|
if (cap_file_) cap_file_->stop_flag = stop_flag;
|
|
}
|
|
|
|
void CaptureFile::captureFileCallback(gint event, gpointer data, gpointer user_data)
|
|
{
|
|
CaptureFile *capture_file = static_cast<CaptureFile *>(user_data);
|
|
if (!capture_file) return;
|
|
|
|
capture_file->captureFileEvent(event, data);
|
|
}
|
|
|
|
#ifdef HAVE_LIBPCAP
|
|
void CaptureFile::captureCallback(gint event, capture_session *cap_session, gpointer user_data)
|
|
{
|
|
CaptureFile *capture_file = static_cast<CaptureFile *>(user_data);
|
|
if (!capture_file) return;
|
|
|
|
capture_file->captureSessionEvent(event, cap_session);
|
|
}
|
|
#endif
|
|
|
|
void CaptureFile::captureFileEvent(int event, gpointer data)
|
|
{
|
|
switch(event) {
|
|
case(cf_cb_file_opened):
|
|
cap_file_ = (capture_file *) data;
|
|
emit captureEvent(CaptureEvent(CaptureEvent::File, CaptureEvent::Opened));
|
|
break;
|
|
case(cf_cb_file_closing):
|
|
file_state_ = tr(" [closing]");
|
|
emit captureEvent(CaptureEvent(CaptureEvent::File, CaptureEvent::Closing));
|
|
break;
|
|
case(cf_cb_file_closed):
|
|
file_state_ = tr(" [closed]");
|
|
emit captureEvent(CaptureEvent(CaptureEvent::File, CaptureEvent::Closed));
|
|
cap_file_ = NULL;
|
|
file_state_ = QString();
|
|
break;
|
|
case(cf_cb_file_read_started):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::File, CaptureEvent::Started));
|
|
break;
|
|
case(cf_cb_file_read_finished):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::File, CaptureEvent::Finished));
|
|
break;
|
|
case(cf_cb_file_reload_started):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Reload, CaptureEvent::Started));
|
|
break;
|
|
case(cf_cb_file_reload_finished):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Reload, CaptureEvent::Finished));
|
|
break;
|
|
case(cf_cb_file_rescan_started):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Rescan, CaptureEvent::Started));
|
|
break;
|
|
case(cf_cb_file_rescan_finished):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Rescan, CaptureEvent::Finished));
|
|
break;
|
|
case(cf_cb_file_retap_started):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Retap, CaptureEvent::Started));
|
|
break;
|
|
case(cf_cb_file_retap_finished):
|
|
/* Flush any pending tapped packet before emitting captureFileRetapFinished() */
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Retap, CaptureEvent::Finished));
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Retap, CaptureEvent::Flushed));
|
|
break;
|
|
case(cf_cb_file_merge_started):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Merge, CaptureEvent::Started));
|
|
break;
|
|
case(cf_cb_file_merge_finished):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Merge, CaptureEvent::Finished));
|
|
break;
|
|
|
|
case(cf_cb_file_fast_save_finished):
|
|
// gtk/main.c calls main_cf_cb_file_rescan_finished. Should we do
|
|
// the equivalent?
|
|
break;
|
|
|
|
case(cf_cb_file_save_started):
|
|
{
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Save, CaptureEvent::Started, QString((const char *)data)));
|
|
break;
|
|
}
|
|
case(cf_cb_file_save_finished):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Save, CaptureEvent::Finished));
|
|
break;
|
|
case(cf_cb_file_save_failed):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Save, CaptureEvent::Failed));
|
|
break;
|
|
case(cf_cb_file_save_stopped):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Save, CaptureEvent::Stopped));
|
|
break;
|
|
|
|
default:
|
|
qWarning() << "CaptureFile::captureFileCallback: event " << event << " unknown";
|
|
Q_ASSERT(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#ifdef HAVE_LIBPCAP
|
|
void CaptureFile::captureSessionEvent(int event, capture_session *cap_session)
|
|
{
|
|
switch(event) {
|
|
case(capture_cb_capture_prepared):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Capture, CaptureEvent::Prepared, cap_session));
|
|
cap_file_ = cap_session->cf;
|
|
break;
|
|
case(capture_cb_capture_update_started):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Update, CaptureEvent::Started, cap_session));
|
|
break;
|
|
case(capture_cb_capture_update_continue):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Update, CaptureEvent::Continued, cap_session));
|
|
break;
|
|
case(capture_cb_capture_update_finished):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Update, CaptureEvent::Finished, cap_session));
|
|
break;
|
|
case(capture_cb_capture_fixed_started):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Fixed, CaptureEvent::Started, cap_session));
|
|
break;
|
|
case(capture_cb_capture_fixed_continue):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Fixed, CaptureEvent::Continued, cap_session));
|
|
break;
|
|
case(capture_cb_capture_fixed_finished):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Fixed, CaptureEvent::Finished, cap_session));
|
|
break;
|
|
case(capture_cb_capture_stopping):
|
|
/* Beware: this state won't be called, if the capture child
|
|
* closes the capturing on it's own! */
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Capture, CaptureEvent::Stopping, cap_session));
|
|
break;
|
|
case(capture_cb_capture_failed):
|
|
emit captureEvent(CaptureEvent(CaptureEvent::Capture, CaptureEvent::Failed, cap_session));
|
|
break;
|
|
default:
|
|
qWarning() << "main_capture_callback: event " << event << " unknown";
|
|
}
|
|
}
|
|
#endif // HAVE_LIBPCAP
|