Mirror/zeek
1
0
Fork 0
mirror of https://github.com/zeek/zeek.git synced 2025-10-02 06:38:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Move DebugLogger to zeek namespaces

Browse source
This commit is contained in:
Tim Wojtulewicz 2020-07-21 14:16:42 -07:00
parent a2a435360a
commit 886fc102b8
40 changed files with 358 additions and 317 deletions
Download patch file Download diff file Expand all files Collapse all files

28
src/DebugLogger.cc
View file

@ -7,18 +7,28 @@
#include "Net.h"
#include "plugin/Plugin.h"
DebugLogger debug_logger;
zeek::detail::DebugLogger zeek::detail::debug_logger;
zeek::detail::DebugLogger& debug_logger = zeek::detail::debug_logger;
namespace zeek::detail {
// Same order here as in DebugStream.
DebugLogger::Stream DebugLogger::streams[NUM_DBGS] = {
{ "serial", 0, false }, { "rules", 0, false },
{ "serial", 0, false },
{ "rules", 0, false },
{ "string", 0, false },
{ "notifiers", 0, false }, { "main-loop", 0, false },
{ "dpd", 0, false }, { "tm", 0, false },
{ "logging", 0, false }, {"input", 0, false },
{ "threading", 0, false }, { "file_analysis", 0, false },
{ "plugins", 0, false }, { "zeekygen", 0, false },
{ "pktio", 0, false }, { "broker", 0, false },
{ "notifiers", 0, false },
{ "main-loop", 0, false },
{ "dpd", 0, false },
{ "tm", 0, false },
{ "logging", 0, false },
{"input", 0, false },
{ "threading", 0, false },
{ "file_analysis", 0, false },
{ "plugins", 0, false },
{ "zeekygen", 0, false },
{ "pktio", 0, false },
{ "broker", 0, false },
{ "scripts", 0, false},
{ "supervisor", 0, false}
};
@ -183,4 +193,6 @@ void DebugLogger::Log(const zeek::plugin::Plugin& plugin, const char* fmt, ...)
fflush(file);
}
} // namespace zeek::detail
#endif

53
src/DebugLogger.h
View file

@ -9,6 +9,20 @@
#include <string>
#include <set>
#define DBG_LOG(stream, args...) \
if ( zeek::detail::debug_logger.IsEnabled(stream) ) \
zeek::detail::debug_logger.Log(stream, args)
#define DBG_LOG_VERBOSE(stream, args...) \
if ( zeek::detail::debug_logger.IsVerbose() && zeek::detail::debug_logger.IsEnabled(stream) ) \
zeek::detail::debug_logger.Log(stream, args)
#define DBG_PUSH(stream) zeek::detail::debug_logger.PushIndent(stream)
#define DBG_POP(stream) zeek::detail::debug_logger.PopIndent(stream)
#define PLUGIN_DBG_LOG(plugin, args...) zeek::detail::debug_logger.Log(plugin, args)
namespace zeek {
namespace plugin { class Plugin; }
// To add a new debugging stream, add a constant here as well as
// an entry to DebugLogger::streams in DebugLogger.cc.
@ -34,18 +48,7 @@ enum DebugStream {
NUM_DBGS // Has to be last
};
#define DBG_LOG(stream, args...) \
if ( debug_logger.IsEnabled(stream) ) \
debug_logger.Log(stream, args)
#define DBG_LOG_VERBOSE(stream, args...) \
if ( debug_logger.IsVerbose() && debug_logger.IsEnabled(stream) ) \
debug_logger.Log(stream, args)
#define DBG_PUSH(stream) debug_logger.PushIndent(stream)
#define DBG_POP(stream) debug_logger.PopIndent(stream)
#define PLUGIN_DBG_LOG(plugin, args...) debug_logger.Log(plugin, args)
namespace zeek::plugin { class Plugin; }
namespace detail {
class DebugLogger {
public:
@ -96,6 +99,32 @@ private:
extern DebugLogger debug_logger;
} // namespace detail
} // namespace zeek
using DebugLogger [[deprecated("Remove in v4.1. Use zeek::detail::DebugLogger.")]] = zeek::detail::DebugLogger;
using DebugStream [[deprecated("Remove in v4.1. Use zeek::DebugStream.")]] = zeek::DebugStream;
constexpr auto DBG_SERIAL [[deprecated("Remove in v4.1. Use zeek::DBG_SERIAL.")]] = zeek::DBG_SERIAL;
constexpr auto DBG_RULES [[deprecated("Remove in v4.1. Use zeek::DBG_RULES.")]] = zeek::DBG_RULES;
constexpr auto DBG_STRING [[deprecated("Remove in v4.1. Use zeek::DBG_STRING.")]] = zeek::DBG_STRING;
constexpr auto DBG_NOTIFIERS [[deprecated("Remove in v4.1. Use zeek::DBG_NOTIFIERS.")]] = zeek::DBG_NOTIFIERS;
constexpr auto DBG_MAINLOOP [[deprecated("Remove in v4.1. Use zeek::DBG_MAINLOOP.")]] = zeek::DBG_MAINLOOP;
constexpr auto DBG_ANALYZER [[deprecated("Remove in v4.1. Use zeek::DBG_ANALYZER.")]] = zeek::DBG_ANALYZER;
constexpr auto DBG_TM [[deprecated("Remove in v4.1. Use zeek::DBG_TM.")]] = zeek::DBG_TM;
constexpr auto DBG_LOGGING [[deprecated("Remove in v4.1. Use zeek::DBG_LOGGING.")]] = zeek::DBG_LOGGING;
constexpr auto DBG_INPUT [[deprecated("Remove in v4.1. Use zeek::DBG_INPUT.")]] = zeek::DBG_INPUT;
constexpr auto DBG_THREADING [[deprecated("Remove in v4.1. Use zeek::DBG_THREADING.")]] = zeek::DBG_THREADING;
constexpr auto DBG_FILE_ANALYSIS [[deprecated("Remove in v4.1. Use zeek::DBG_FILE_ANALYSIS.")]] = zeek::DBG_FILE_ANALYSIS;
constexpr auto DBG_PLUGINS [[deprecated("Remove in v4.1. Use zeek::DBG_PLUGINS.")]] = zeek::DBG_PLUGINS;
constexpr auto DBG_ZEEKYGEN [[deprecated("Remove in v4.1. Use zeek::DBG_ZEEKYGEN.")]] = zeek::DBG_ZEEKYGEN;
constexpr auto DBG_PKTIO [[deprecated("Remove in v4.1. Use zeek::DBG_PKTIO.")]] = zeek::DBG_PKTIO;
constexpr auto DBG_BROKER [[deprecated("Remove in v4.1. Use zeek::DBG_BROKER.")]] = zeek::DBG_BROKER;
constexpr auto DBG_SCRIPTS [[deprecated("Remove in v4.1. Use zeek::DBG_SCRIPTS.")]] = zeek::DBG_SCRIPTS;
constexpr auto DBG_SUPERVISOR [[deprecated("Remove in v4.1. Use zeek::DBG_SUPERVISOR.")]] = zeek::DBG_SUPERVISOR;
extern zeek::detail::DebugLogger& debug_logger;
#else
#define DBG_LOG(args...)
#define DBG_LOG_VERBOSE(args...)

2
src/Expr.cc
View file

@ -4154,7 +4154,7 @@ ValPtr CallExpr::Eval(Frame* f) const
{
if ( Val* v = trigger->Lookup(this) )
{
DBG_LOG(DBG_NOTIFIERS,
DBG_LOG(zeek::DBG_NOTIFIERS,
"%s: provides cached function result",
trigger->Name());
return {zeek::NewRef{}, v};

4
src/Net.cc
View file

@ -293,7 +293,7 @@ void net_run()
// starting with the first.
if ( ! ready.empty() || loop_counter++ % 100 == 0 )
{
DBG_LOG(DBG_MAINLOOP, "realtime=%.6f ready_count=%zu",
DBG_LOG(zeek::DBG_MAINLOOP, "realtime=%.6f ready_count=%zu",
current_time(), ready.size());
if ( ! ready.empty() )
@ -307,7 +307,7 @@ void net_run()
{
for ( auto src : ready )
{
DBG_LOG(DBG_MAINLOOP, "processing source %s", src->Tag());
DBG_LOG(zeek::DBG_MAINLOOP, "processing source %s", src->Tag());
current_iosrc = src;
src->Process();
}

12
src/Notifier.cc
View file

@ -9,12 +9,12 @@ notifier::Registry notifier::registry;
notifier::Receiver::Receiver()
{
DBG_LOG(DBG_NOTIFIERS, "creating receiver %p", this);
DBG_LOG(zeek::DBG_NOTIFIERS, "creating receiver %p", this);
}
notifier::Receiver::~Receiver()
{
DBG_LOG(DBG_NOTIFIERS, "deleting receiver %p", this);
DBG_LOG(zeek::DBG_NOTIFIERS, "deleting receiver %p", this);
}
notifier::Registry::~Registry()
@ -25,7 +25,7 @@ notifier::Registry::~Registry()
void notifier::Registry::Register(Modifiable* m, notifier::Receiver* r)
{
DBG_LOG(DBG_NOTIFIERS, "registering object %p for receiver %p", m, r);
DBG_LOG(zeek::DBG_NOTIFIERS, "registering object %p for receiver %p", m, r);
registrations.insert({m, r});
++m->num_receivers;
@ -33,7 +33,7 @@ void notifier::Registry::Register(Modifiable* m, notifier::Receiver* r)
void notifier::Registry::Unregister(Modifiable* m, notifier::Receiver* r)
{
DBG_LOG(DBG_NOTIFIERS, "unregistering object %p from receiver %p", m, r);
DBG_LOG(zeek::DBG_NOTIFIERS, "unregistering object %p from receiver %p", m, r);
auto x = registrations.equal_range(m);
for ( auto i = x.first; i != x.second; i++ )
@ -49,7 +49,7 @@ void notifier::Registry::Unregister(Modifiable* m, notifier::Receiver* r)
void notifier::Registry::Unregister(Modifiable* m)
{
DBG_LOG(DBG_NOTIFIERS, "unregistering object %p from all notifiers", m);
DBG_LOG(zeek::DBG_NOTIFIERS, "unregistering object %p from all notifiers", m);
auto x = registrations.equal_range(m);
for ( auto i = x.first; i != x.second; i++ )
@ -60,7 +60,7 @@ void notifier::Registry::Unregister(Modifiable* m)
void notifier::Registry::Modified(Modifiable* m)
{
DBG_LOG(DBG_NOTIFIERS, "object %p has been modified", m);
DBG_LOG(zeek::DBG_NOTIFIERS, "object %p has been modified", m);
auto x = registrations.equal_range(m);
for ( auto i = x.first; i != x.second; i++ )

34
src/RuleMatcher.cc
View file

@ -637,7 +637,7 @@ RuleFileMagicState* RuleMatcher::InitFileMagic() const
bool RuleMatcher::AllRulePatternsMatched(const Rule* r, MatchPos matchpos,
const AcceptingMatchSet& ams)
{
DBG_LOG(DBG_RULES, "Checking rule: %s", r->id);
DBG_LOG(zeek::DBG_RULES, "Checking rule: %s", r->id);
// Check whether all patterns of the rule have matched.
for ( const auto& pattern : r->patterns )
@ -652,7 +652,7 @@ bool RuleMatcher::AllRulePatternsMatched(const Rule* r, MatchPos matchpos,
// FIXME: How to check for offset ??? ###
}
DBG_LOG(DBG_RULES, "All patterns of rule satisfied");
DBG_LOG(zeek::DBG_RULES, "All patterns of rule satisfied");
return true;
}
@ -671,11 +671,11 @@ RuleMatcher::MIME_Matches* RuleMatcher::Match(RuleFileMagicState* state,
}
#ifdef DEBUG
if ( debug_logger.IsEnabled(DBG_RULES) )
if ( debug_logger.IsEnabled(zeek::DBG_RULES) )
{
const char* s = fmt_bytes(reinterpret_cast<const char*>(data),
min(40, static_cast<int>(len)));
DBG_LOG(DBG_RULES, "Matching %s rules on |%s%s|",
DBG_LOG(zeek::DBG_RULES, "Matching %s rules on |%s%s|",
Rule::TypeToString(Rule::FILE_MAGIC), s,
len > 40 ? "..." : "");
}
@ -692,7 +692,7 @@ RuleMatcher::MIME_Matches* RuleMatcher::Match(RuleFileMagicState* state,
if ( ! newmatch )
return rval;
DBG_LOG(DBG_RULES, "New pattern match found");
DBG_LOG(zeek::DBG_RULES, "New pattern match found");
AcceptingMatchSet accepted_matches;
@ -753,7 +753,7 @@ RuleEndpointState* RuleMatcher::InitEndpoint(zeek::analyzer::Analyzer* analyzer,
{
RuleHdrTest* hdr_test = tests[h];
DBG_LOG(DBG_RULES, "HdrTest %d matches (%s%s)", hdr_test->id,
DBG_LOG(zeek::DBG_RULES, "HdrTest %d matches (%s%s)", hdr_test->id,
hdr_test->pattern_rules ? "+" : "-",
hdr_test->pure_rules ? "+" : "-");
@ -868,12 +868,12 @@ void RuleMatcher::Match(RuleEndpointState* state, Rule::PatternType type,
bool newmatch = false;
#ifdef DEBUG
if ( debug_logger.IsEnabled(DBG_RULES) )
if ( debug_logger.IsEnabled(zeek::DBG_RULES) )
{
const char* s =
fmt_bytes((const char *) data, min(40, data_len));
DBG_LOG(DBG_RULES, "Matching %s rules [%d,%d] on |%s%s|",
DBG_LOG(zeek::DBG_RULES, "Matching %s rules [%d,%d] on |%s%s|",
Rule::TypeToString(type), bol, eol, s,
data_len > 40 ? "..." : "");
}
@ -904,7 +904,7 @@ void RuleMatcher::Match(RuleEndpointState* state, Rule::PatternType type,
if ( ! newmatch )
return;
DBG_LOG(DBG_RULES, "New pattern match found");
DBG_LOG(zeek::DBG_RULES, "New pattern match found");
AcceptingMatchSet accepted_matches;
@ -940,17 +940,17 @@ void RuleMatcher::Match(RuleEndpointState* state, Rule::PatternType type,
{
Rule* r = *it;
DBG_LOG(DBG_RULES, "Accepted rule: %s", r->id);
DBG_LOG(zeek::DBG_RULES, "Accepted rule: %s", r->id);
for ( const auto& h : state->hdr_tests )
{
DBG_LOG(DBG_RULES, "Checking for accepted rule on HdrTest %d", h->id);
DBG_LOG(zeek::DBG_RULES, "Checking for accepted rule on HdrTest %d", h->id);
// Skip if rule does not belong to this node.
if ( ! h->ruleset->Contains(r->Index()) )
continue;
DBG_LOG(DBG_RULES, "On current node");
DBG_LOG(zeek::DBG_RULES, "On current node");
// Skip if rule already fired for this connection.
if ( is_member_of(state->matched_rules, r->Index()) )
@ -964,7 +964,7 @@ void RuleMatcher::Match(RuleEndpointState* state, Rule::PatternType type,
state->matched_text.push_back(s);
}
DBG_LOG(DBG_RULES, "And has not already fired");
DBG_LOG(zeek::DBG_RULES, "And has not already fired");
// Eval additional conditions.
if ( ! EvalRuleConditions(r, state, data, data_len, false) )
continue;
@ -1006,11 +1006,11 @@ bool RuleMatcher::ExecRulePurely(Rule* r, zeek::String* s,
if ( is_member_of(state->matched_rules, r->Index()) )
return false;
DBG_LOG(DBG_RULES, "Checking rule %s purely", r->ID());
DBG_LOG(zeek::DBG_RULES, "Checking rule %s purely", r->ID());
if ( EvalRuleConditions(r, state, nullptr, 0, eos) )
{
DBG_LOG(DBG_RULES, "MATCH!");
DBG_LOG(zeek::DBG_RULES, "MATCH!");
if ( s )
ExecRuleActions(r, state, s->Bytes(), s->Len(), eos);
@ -1026,7 +1026,7 @@ bool RuleMatcher::ExecRulePurely(Rule* r, zeek::String* s,
bool RuleMatcher::EvalRuleConditions(Rule* r, RuleEndpointState* state,
const u_char* data, int len, bool eos)
{
DBG_LOG(DBG_RULES, "Evaluating conditions for rule %s", r->ID());
DBG_LOG(zeek::DBG_RULES, "Evaluating conditions for rule %s", r->ID());
// Check for other rules which have to match first.
for ( const auto& pc : r->preconds )
@ -1063,7 +1063,7 @@ bool RuleMatcher::EvalRuleConditions(Rule* r, RuleEndpointState* state,
if ( ! cond->DoMatch(r, state, data, len) )
return false;
DBG_LOG(DBG_RULES, "Conditions met: MATCH! %s", r->ID());
DBG_LOG(zeek::DBG_RULES, "Conditions met: MATCH! %s", r->ID());
return true;
}

36
src/SerializationFormat.cc
View file

@ -107,7 +107,7 @@ bool BinarySerializationFormat::Read(int* v, const char* tag)
return false;
*v = (int) ntohl(tmp);
DBG_LOG(DBG_SERIAL, "Read int %d [%s]", *v, tag);
DBG_LOG(zeek::DBG_SERIAL, "Read int %d [%s]", *v, tag);
return true;
}
@ -117,7 +117,7 @@ bool BinarySerializationFormat::Read(uint16_t* v, const char* tag)
return false;
*v = ntohs(*v);
DBG_LOG(DBG_SERIAL, "Read uint16_t %hu [%s]", *v, tag);
DBG_LOG(zeek::DBG_SERIAL, "Read uint16_t %hu [%s]", *v, tag);
return true;
}
@ -127,7 +127,7 @@ bool BinarySerializationFormat::Read(uint32_t* v, const char* tag)
return false;
*v = ntohl(*v);
DBG_LOG(DBG_SERIAL, "Read uint32_t %" PRIu32 " [%s]", *v, tag);
DBG_LOG(zeek::DBG_SERIAL, "Read uint32_t %" PRIu32 " [%s]", *v, tag);
return true;
}
@ -139,7 +139,7 @@ bool BinarySerializationFormat::Read(int64_t* v, const char* tag)
return false;
*v = ((int64_t(ntohl(x[0]))) << 32) | ntohl(x[1]);
DBG_LOG(DBG_SERIAL, "Read int64_t %" PRId64 " [%s]", *v, tag);
DBG_LOG(zeek::DBG_SERIAL, "Read int64_t %" PRId64 " [%s]", *v, tag);
return true;
}
@ -150,7 +150,7 @@ bool BinarySerializationFormat::Read(uint64_t* v, const char* tag)
return false;
*v = ((uint64_t(ntohl(x[0]))) << 32) | ntohl(x[1]);
DBG_LOG(DBG_SERIAL, "Read uint64_t %" PRIu64 " [%s]", *v, tag);
DBG_LOG(zeek::DBG_SERIAL, "Read uint64_t %" PRIu64 " [%s]", *v, tag);
return true;
}
@ -161,7 +161,7 @@ bool BinarySerializationFormat::Read(bool* v, const char* tag)
return false;
*v = c == '\1' ? true : false;
DBG_LOG(DBG_SERIAL, "Read bool %s [%s]", *v ? "true" : "false", tag);
DBG_LOG(zeek::DBG_SERIAL, "Read bool %s [%s]", *v ? "true" : "false", tag);
return true;
}
@ -171,14 +171,14 @@ bool BinarySerializationFormat::Read(double* d, const char* tag)
return false;
*d = ntohd(*d);
DBG_LOG(DBG_SERIAL, "Read double %.6f [%s]", *d, tag);
DBG_LOG(zeek::DBG_SERIAL, "Read double %.6f [%s]", *d, tag);
return true;
}
bool BinarySerializationFormat::Read(char* v, const char* tag)
{
bool ret = ReadData(v, 1);
DBG_LOG(DBG_SERIAL, "Read char %s [%s]", fmt_bytes(v, 1), tag);
DBG_LOG(zeek::DBG_SERIAL, "Read char %s [%s]", fmt_bytes(v, 1), tag);
return ret;
}
@ -216,7 +216,7 @@ bool BinarySerializationFormat::Read(char** str, int* len, const char* tag)
*str = s;
DBG_LOG(DBG_SERIAL, "Read %d bytes |%s| [%s]", l, fmt_bytes(*str, l), tag);
DBG_LOG(zeek::DBG_SERIAL, "Read %d bytes |%s| [%s]", l, fmt_bytes(*str, l), tag);
return true;
}
@ -301,34 +301,34 @@ bool BinarySerializationFormat::Read(struct in6_addr* addr, const char* tag)
bool BinarySerializationFormat::Write(char v, const char* tag)
{
DBG_LOG(DBG_SERIAL, "Write char %s [%s]", fmt_bytes(&v, 1), tag);
DBG_LOG(zeek::DBG_SERIAL, "Write char %s [%s]", fmt_bytes(&v, 1), tag);
return WriteData(&v, 1);
}
bool BinarySerializationFormat::Write(uint16_t v, const char* tag)
{
DBG_LOG(DBG_SERIAL, "Write uint16_t %hu [%s]", v, tag);
DBG_LOG(zeek::DBG_SERIAL, "Write uint16_t %hu [%s]", v, tag);
v = htons(v);
return WriteData(&v, sizeof(v));
}
bool BinarySerializationFormat::Write(uint32_t v, const char* tag)
{
DBG_LOG(DBG_SERIAL, "Write uint32_t %" PRIu32 " [%s]", v, tag);
DBG_LOG(zeek::DBG_SERIAL, "Write uint32_t %" PRIu32 " [%s]", v, tag);
v = htonl(v);
return WriteData(&v, sizeof(v));
}
bool BinarySerializationFormat::Write(int v, const char* tag)
{
DBG_LOG(DBG_SERIAL, "Write int %d [%s]", v, tag);
DBG_LOG(zeek::DBG_SERIAL, "Write int %d [%s]", v, tag);
uint32_t tmp = htonl((uint32_t) v);
return WriteData(&tmp, sizeof(tmp));
}
bool BinarySerializationFormat::Write(uint64_t v, const char* tag)
{
DBG_LOG(DBG_SERIAL, "Write uint64_t %" PRIu64 " [%s]", v, tag);
DBG_LOG(zeek::DBG_SERIAL, "Write uint64_t %" PRIu64 " [%s]", v, tag);
uint32_t x[2];
x[0] = htonl(v >> 32);
x[1] = htonl(v & 0xffffffff);
@ -337,7 +337,7 @@ bool BinarySerializationFormat::Write(uint64_t v, const char* tag)
bool BinarySerializationFormat::Write(int64_t v, const char* tag)
{
DBG_LOG(DBG_SERIAL, "Write int64_t %" PRId64 " [%s]", v, tag);
DBG_LOG(zeek::DBG_SERIAL, "Write int64_t %" PRId64 " [%s]", v, tag);
uint32_t x[2];
x[0] = htonl(v >> 32);
x[1] = htonl(v & 0xffffffff);
@ -346,14 +346,14 @@ bool BinarySerializationFormat::Write(int64_t v, const char* tag)
bool BinarySerializationFormat::Write(double d, const char* tag)
{
DBG_LOG(DBG_SERIAL, "Write double %.6f [%s]", d, tag);
DBG_LOG(zeek::DBG_SERIAL, "Write double %.6f [%s]", d, tag);
d = htond(d);
return WriteData(&d, sizeof(d));
}
bool BinarySerializationFormat::Write(bool v, const char* tag)
{
DBG_LOG(DBG_SERIAL, "Write bool %s [%s]", v ? "true" : "false", tag);
DBG_LOG(zeek::DBG_SERIAL, "Write bool %s [%s]", v ? "true" : "false", tag);
char c = v ? '\1' : '\0';
return WriteData(&c, 1);
}
@ -432,7 +432,7 @@ bool BinarySerializationFormat::WriteSeparator()
bool BinarySerializationFormat::Write(const char* buf, int len, const char* tag)
{
DBG_LOG(DBG_SERIAL, "Write bytes |%s| [%s]", fmt_bytes(buf, len), tag);
DBG_LOG(zeek::DBG_SERIAL, "Write bytes |%s| [%s]", fmt_bytes(buf, len), tag);
uint32_t l = htonl(len);
return WriteData(&l, sizeof(l)) && WriteData(buf, len);
}

8
src/Timer.cc
View file

@ -79,7 +79,7 @@ TimerMgr::~TimerMgr()
int TimerMgr::Advance(double arg_t, int max_expire)
{
DBG_LOG(DBG_TM, "advancing timer mgr to %.6f", arg_t);
DBG_LOG(zeek::DBG_TM, "advancing timer mgr to %.6f", arg_t);
t = arg_t;
last_timestamp = 0;
@ -122,7 +122,7 @@ PQ_TimerMgr::~PQ_TimerMgr()
void PQ_TimerMgr::Add(Timer* timer)
{
DBG_LOG(DBG_TM, "Adding timer %s (%p) at %.6f",
DBG_LOG(zeek::DBG_TM, "Adding timer %s (%p) at %.6f",
timer_type_to_string(timer->Type()), timer, timer->Time());
// Add the timer even if it's already expired - that way, if
@ -139,7 +139,7 @@ void PQ_TimerMgr::Expire()
Timer* timer;
while ( (timer = Remove()) )
{
DBG_LOG(DBG_TM, "Dispatching timer %s (%p)",
DBG_LOG(zeek::DBG_TM, "Dispatching timer %s (%p)",
timer_type_to_string(timer->Type()), timer);
timer->Dispatch(t, true);
--current_timers[timer->Type()];
@ -161,7 +161,7 @@ int PQ_TimerMgr::DoAdvance(double new_t, int max_expire)
// whether we should delete it too.
(void) Remove();
DBG_LOG(DBG_TM, "Dispatching timer %s (%p)",
DBG_LOG(zeek::DBG_TM, "Dispatching timer %s (%p)",
timer_type_to_string(timer->Type()), timer);
timer->Dispatch(new_t, false);
delete timer;

26
src/Trigger.cc
View file

@ -135,7 +135,7 @@ Trigger::Trigger(zeek::detail::Expr* arg_cond, zeek::detail::Stmt* arg_body,
location = arg_location;
timeout_value = -1;
DBG_LOG(DBG_NOTIFIERS, "%s: instantiating", Name());
DBG_LOG(zeek::DBG_NOTIFIERS, "%s: instantiating", Name());
if ( is_return )
{
@ -204,7 +204,7 @@ void Trigger::Terminate()
Trigger::~Trigger()
{
DBG_LOG(DBG_NOTIFIERS, "%s: deleting", Name());
DBG_LOG(zeek::DBG_NOTIFIERS, "%s: deleting", Name());
for ( ValCache::iterator i = cache.begin(); i != cache.end(); ++i )
Unref(i->second);
@ -230,11 +230,11 @@ bool Trigger::Eval()
if ( disabled )
return true;
DBG_LOG(DBG_NOTIFIERS, "%s: evaluating", Name());
DBG_LOG(zeek::DBG_NOTIFIERS, "%s: evaluating", Name());
if ( delayed )
{
DBG_LOG(DBG_NOTIFIERS, "%s: skipping eval due to delayed call",
DBG_LOG(zeek::DBG_NOTIFIERS, "%s: skipping eval due to delayed call",
Name());
return false;
}
@ -277,7 +277,7 @@ bool Trigger::Eval()
if ( f->HasDelayed() )
{
DBG_LOG(DBG_NOTIFIERS, "%s: eval has delayed", Name());
DBG_LOG(zeek::DBG_NOTIFIERS, "%s: eval has delayed", Name());
assert(!v);
Unref(f);
return false;
@ -286,13 +286,13 @@ bool Trigger::Eval()
if ( ! v || v->IsZero() )
{
// Not true. Perhaps next time...
DBG_LOG(DBG_NOTIFIERS, "%s: trigger condition is false", Name());
DBG_LOG(zeek::DBG_NOTIFIERS, "%s: trigger condition is false", Name());
Unref(f);
Init();
return false;
}
DBG_LOG(DBG_NOTIFIERS, "%s: trigger condition is true, executing",
DBG_LOG(zeek::DBG_NOTIFIERS, "%s: trigger condition is true, executing",
Name());
v = nullptr;
@ -314,7 +314,7 @@ bool Trigger::Eval()
#ifdef DEBUG
const char* pname = copy_string(trigger->Name());
DBG_LOG(DBG_NOTIFIERS, "%s: trigger has parent %s, caching result", Name(), pname);
DBG_LOG(zeek::DBG_NOTIFIERS, "%s: trigger has parent %s, caching result", Name(), pname);
delete [] pname;
#endif
@ -344,7 +344,7 @@ void Trigger::Timeout()
if ( disabled )
return;
DBG_LOG(DBG_NOTIFIERS, "%s: timeout", Name());
DBG_LOG(zeek::DBG_NOTIFIERS, "%s: timeout", Name());
if ( timeout_stmts )
{
stmt_flow_type flow;
@ -367,7 +367,7 @@ void Trigger::Timeout()
#ifdef DEBUG
const char* pname = copy_string(trigger->Name());
DBG_LOG(DBG_NOTIFIERS, "%s: trigger has parent %s, caching timeout result", Name(), pname);
DBG_LOG(zeek::DBG_NOTIFIERS, "%s: trigger has parent %s, caching timeout result", Name(), pname);
delete [] pname;
#endif
auto queued = trigger->Cache(frame->GetCall(), v.get());
@ -408,7 +408,7 @@ void Trigger::Register(Val* val)
void Trigger::UnregisterAll()
{
DBG_LOG(DBG_NOTIFIERS, "%s: unregistering all", Name());
DBG_LOG(zeek::DBG_NOTIFIERS, "%s: unregistering all", Name());
for ( const auto& o : objs )
{
@ -427,7 +427,7 @@ void Trigger::Attach(Trigger *trigger)
#ifdef DEBUG
const char* pname = copy_string(trigger->Name());
DBG_LOG(DBG_NOTIFIERS, "%s: attaching to %s", Name(), pname);
DBG_LOG(zeek::DBG_NOTIFIERS, "%s: attaching to %s", Name(), pname);
delete [] pname;
#endif
@ -510,7 +510,7 @@ double Manager::GetNextTimeout()
void Manager::Process()
{
DBG_LOG(DBG_NOTIFIERS, "evaluating all pending triggers");
DBG_LOG(zeek::DBG_NOTIFIERS, "evaluating all pending triggers");
// While we iterate over the list, executing statements, we may
// in fact trigger new triggers and thereby modify the list.

2
src/ZeekString.cc
View file

@ -13,7 +13,7 @@
#include "util.h"
#ifdef DEBUG
#define DEBUG_STR(msg) DBG_LOG(DBG_STRING, msg)
#define DEBUG_STR(msg) DBG_LOG(zeek::DBG_STRING, msg)
#else
#define DEBUG_STR(msg)
#endif

22
src/analyzer/Analyzer.cc
View file

@ -413,7 +413,7 @@ bool Analyzer::AddChildAnalyzer(Analyzer* analyzer, bool init)
if ( init )
analyzer->Init();
DBG_LOG(DBG_ANALYZER, "%s added child %s",
DBG_LOG(zeek::DBG_ANALYZER, "%s added child %s",
fmt_analyzer(this).c_str(), fmt_analyzer(analyzer).c_str());
return true;
}
@ -446,7 +446,7 @@ bool Analyzer::RemoveChild(const analyzer_list& children, ID id)
if ( i->finished || i->removing )
return false;
DBG_LOG(DBG_ANALYZER, "%s disabling child %s",
DBG_LOG(zeek::DBG_ANALYZER, "%s disabling child %s",
fmt_analyzer(this).c_str(), fmt_analyzer(i).c_str());
// We just flag it as being removed here but postpone
// actually doing that to later. Otherwise, we'd need
@ -559,7 +559,7 @@ void Analyzer::DeleteChild(analyzer_list::iterator i)
child->removing = false;
}
DBG_LOG(DBG_ANALYZER, "%s deleted child %s 3",
DBG_LOG(zeek::DBG_ANALYZER, "%s deleted child %s 3",
fmt_analyzer(this).c_str(), fmt_analyzer(child).c_str());
children.erase(i);
@ -570,7 +570,7 @@ void Analyzer::AddSupportAnalyzer(SupportAnalyzer* analyzer)
{
if ( HasSupportAnalyzer(analyzer->GetAnalyzerTag(), analyzer->IsOrig()) )
{
DBG_LOG(DBG_ANALYZER, "%s already has %s %s",
DBG_LOG(zeek::DBG_ANALYZER, "%s already has %s %s",
fmt_analyzer(this).c_str(),
analyzer->IsOrig() ? "originator" : "responder",
fmt_analyzer(analyzer).c_str());
@ -598,7 +598,7 @@ void Analyzer::AddSupportAnalyzer(SupportAnalyzer* analyzer)
analyzer->Init();
DBG_LOG(DBG_ANALYZER, "%s added %s support %s",
DBG_LOG(zeek::DBG_ANALYZER, "%s added %s support %s",
fmt_analyzer(this).c_str(),
analyzer->IsOrig() ? "originator" : "responder",
fmt_analyzer(analyzer).c_str());
@ -606,7 +606,7 @@ void Analyzer::AddSupportAnalyzer(SupportAnalyzer* analyzer)
void Analyzer::RemoveSupportAnalyzer(SupportAnalyzer* analyzer)
{
DBG_LOG(DBG_ANALYZER, "%s disabled %s support analyzer %s",
DBG_LOG(zeek::DBG_ANALYZER, "%s disabled %s support analyzer %s",
fmt_analyzer(this).c_str(),
analyzer->IsOrig() ? "originator" : "responder",
fmt_analyzer(analyzer).c_str());
@ -646,33 +646,33 @@ SupportAnalyzer* Analyzer::FirstSupportAnalyzer(bool orig)
void Analyzer::DeliverPacket(int len, const u_char* data, bool is_orig,
uint64_t seq, const zeek::IP_Hdr* ip, int caplen)
{
DBG_LOG(DBG_ANALYZER, "%s DeliverPacket(%d, %s, %" PRIu64", %p, %d) [%s%s]",
DBG_LOG(zeek::DBG_ANALYZER, "%s DeliverPacket(%d, %s, %" PRIu64", %p, %d) [%s%s]",
fmt_analyzer(this).c_str(), len, is_orig ? "T" : "F", seq, ip, caplen,
fmt_bytes((const char*) data, min(40, len)), len > 40 ? "..." : "");
}
void Analyzer::DeliverStream(int len, const u_char* data, bool is_orig)
{
DBG_LOG(DBG_ANALYZER, "%s DeliverStream(%d, %s) [%s%s]",
DBG_LOG(zeek::DBG_ANALYZER, "%s DeliverStream(%d, %s) [%s%s]",
fmt_analyzer(this).c_str(), len, is_orig ? "T" : "F",
fmt_bytes((const char*) data, min(40, len)), len > 40 ? "..." : "");
}
void Analyzer::Undelivered(uint64_t seq, int len, bool is_orig)
{
DBG_LOG(DBG_ANALYZER, "%s Undelivered(%" PRIu64", %d, %s)",
DBG_LOG(zeek::DBG_ANALYZER, "%s Undelivered(%" PRIu64", %d, %s)",
fmt_analyzer(this).c_str(), seq, len, is_orig ? "T" : "F");
}
void Analyzer::EndOfData(bool is_orig)
{
DBG_LOG(DBG_ANALYZER, "%s EndOfData(%s)",
DBG_LOG(zeek::DBG_ANALYZER, "%s EndOfData(%s)",
fmt_analyzer(this).c_str(), is_orig ? "T" : "F");
}
void Analyzer::FlipRoles()
{
DBG_LOG(DBG_ANALYZER, "%s FlipRoles()", fmt_analyzer(this).c_str());
DBG_LOG(zeek::DBG_ANALYZER, "%s FlipRoles()", fmt_analyzer(this).c_str());
LOOP_OVER_CHILDREN(i)
(*i)->FlipRoles();

28
src/analyzer/Manager.cc
View file

@ -105,14 +105,14 @@ void Manager::InitPostScript()
void Manager::DumpDebug()
{
#ifdef DEBUG
DBG_LOG(DBG_ANALYZER, "Available analyzers after zeek_init():");
DBG_LOG(zeek::DBG_ANALYZER, "Available analyzers after zeek_init():");
std::list<Component*> all_analyzers = GetComponents();
for ( std::list<Component*>::const_iterator i = all_analyzers.begin(); i != all_analyzers.end(); ++i )
DBG_LOG(DBG_ANALYZER, " %s (%s)", (*i)->Name().c_str(),
DBG_LOG(zeek::DBG_ANALYZER, " %s (%s)", (*i)->Name().c_str(),
IsEnabled((*i)->Tag()) ? "enabled" : "disabled");
DBG_LOG(DBG_ANALYZER, " ");
DBG_LOG(DBG_ANALYZER, "Analyzers by port:");
DBG_LOG(zeek::DBG_ANALYZER, " ");
DBG_LOG(zeek::DBG_ANALYZER, "Analyzers by port:");
for ( analyzer_map_by_port::const_iterator i = analyzers_by_port_tcp.begin(); i != analyzers_by_port_tcp.end(); i++ )
{
@ -121,7 +121,7 @@ void Manager::DumpDebug()
for ( tag_set::const_iterator j = i->second->begin(); j != i->second->end(); j++ )
s += std::string(GetComponentName(*j)) + " ";
DBG_LOG(DBG_ANALYZER, " %d/tcp: %s", i->first, s.c_str());
DBG_LOG(zeek::DBG_ANALYZER, " %d/tcp: %s", i->first, s.c_str());
}
for ( analyzer_map_by_port::const_iterator i = analyzers_by_port_udp.begin(); i != analyzers_by_port_udp.end(); i++ )
@ -131,7 +131,7 @@ void Manager::DumpDebug()
for ( tag_set::const_iterator j = i->second->begin(); j != i->second->end(); j++ )
s += std::string(GetComponentName(*j)) + " ";
DBG_LOG(DBG_ANALYZER, " %d/udp: %s", i->first, s.c_str());
DBG_LOG(zeek::DBG_ANALYZER, " %d/udp: %s", i->first, s.c_str());
}
#endif
@ -148,7 +148,7 @@ bool Manager::EnableAnalyzer(const Tag& tag)
if ( ! p )
return false;
DBG_LOG(DBG_ANALYZER, "Enabling analyzer %s", p->Name().c_str());
DBG_LOG(zeek::DBG_ANALYZER, "Enabling analyzer %s", p->Name().c_str());
p->SetEnabled(true);
return true;
@ -161,7 +161,7 @@ bool Manager::EnableAnalyzer(zeek::EnumVal* val)
if ( ! p )
return false;
DBG_LOG(DBG_ANALYZER, "Enabling analyzer %s", p->Name().c_str());
DBG_LOG(zeek::DBG_ANALYZER, "Enabling analyzer %s", p->Name().c_str());
p->SetEnabled(true);
return true;
@ -174,7 +174,7 @@ bool Manager::DisableAnalyzer(const Tag& tag)
if ( ! p )
return false;
DBG_LOG(DBG_ANALYZER, "Disabling analyzer %s", p->Name().c_str());
DBG_LOG(zeek::DBG_ANALYZER, "Disabling analyzer %s", p->Name().c_str());
p->SetEnabled(false);
return true;
@ -187,7 +187,7 @@ bool Manager::DisableAnalyzer(zeek::EnumVal* val)
if ( ! p )
return false;
DBG_LOG(DBG_ANALYZER, "Disabling analyzer %s", p->Name().c_str());
DBG_LOG(zeek::DBG_ANALYZER, "Disabling analyzer %s", p->Name().c_str());
p->SetEnabled(false);
return true;
@ -195,7 +195,7 @@ bool Manager::DisableAnalyzer(zeek::EnumVal* val)
void Manager::DisableAllAnalyzers()
{
DBG_LOG(DBG_ANALYZER, "Disabling all analyzers");
DBG_LOG(zeek::DBG_ANALYZER, "Disabling all analyzers");
std::list<Component*> all_analyzers = GetComponents();
for ( std::list<Component*>::const_iterator i = all_analyzers.begin(); i != all_analyzers.end(); ++i )
@ -260,7 +260,7 @@ bool Manager::RegisterAnalyzerForPort(const Tag& tag, TransportProto proto, uint
#ifdef DEBUG
const char* name = GetComponentName(tag).c_str();
DBG_LOG(DBG_ANALYZER, "Registering analyzer %s for port %" PRIu32 "/%d", name, port, proto);
DBG_LOG(zeek::DBG_ANALYZER, "Registering analyzer %s for port %" PRIu32 "/%d", name, port, proto);
#endif
l->insert(tag);
@ -276,7 +276,7 @@ bool Manager::UnregisterAnalyzerForPort(const Tag& tag, TransportProto proto, ui
#ifdef DEBUG
const char* name = GetComponentName(tag).c_str();
DBG_LOG(DBG_ANALYZER, "Unregistering analyzer %s for port %" PRIu32 "/%d", name, port, proto);
DBG_LOG(zeek::DBG_ANALYZER, "Unregistering analyzer %s for port %" PRIu32 "/%d", name, port, proto);
#endif
l->erase(tag);
@ -524,7 +524,7 @@ void Manager::ExpireScheduledAnalyzers()
conns.erase(i);
DBG_LOG(DBG_ANALYZER, "Expiring expected analyzer %s for connection %s",
DBG_LOG(zeek::DBG_ANALYZER, "Expiring expected analyzer %s for connection %s",
zeek::analyzer_mgr->GetComponentName(a->analyzer).c_str(),
fmt_conn_id(a->conn.orig, 0, a->conn.resp, a->conn.resp_p));

4
src/analyzer/Manager.h
View file

@ -416,11 +416,11 @@ extern zeek::analyzer::Manager*& analyzer_mgr [[deprecated("Remove in v4.1. Use
// message.
#ifdef DEBUG
# define DBG_ANALYZER(conn, txt) \
DBG_LOG(DBG_ANALYZER, "%s " txt, \
DBG_LOG(zeek::DBG_ANALYZER, "%s " txt, \
fmt_conn_id(conn->OrigAddr(), ntohs(conn->OrigPort()), \
conn->RespAddr(), ntohs(conn->RespPort())));
# define DBG_ANALYZER_ARGS(conn, fmt, args...) \
DBG_LOG(DBG_ANALYZER, "%s " fmt, \
DBG_LOG(zeek::DBG_ANALYZER, "%s " fmt, \
fmt_conn_id(conn->OrigAddr(), ntohs(conn->OrigPort()), \
conn->RespAddr(), ntohs(conn->RespPort())), ##args);
#else

12
src/analyzer/protocol/pia/PIA.cc
View file

@ -73,7 +73,7 @@ void PIA::AddToBuffer(Buffer* buffer, int len, const u_char* data, bool is_orig,
void PIA::ReplayPacketBuffer(zeek::analyzer::Analyzer* analyzer)
{
DBG_LOG(DBG_ANALYZER, "PIA replaying %d total packet bytes", pkt_buffer.size);
DBG_LOG(zeek::DBG_ANALYZER, "PIA replaying %d total packet bytes", pkt_buffer.size);
for ( DataBlock* b = pkt_buffer.head; b; b = b->next )
analyzer->DeliverPacket(b->len, b->data, b->is_orig, -1, b->ip, 0);
@ -149,7 +149,7 @@ void PIA_UDP::ActivateAnalyzer(zeek::analyzer::Tag tag, const zeek::detail::Rule
{
if ( pkt_buffer.state == MATCHING_ONLY )
{
DBG_LOG(DBG_ANALYZER, "analyzer found but buffer already exceeded");
DBG_LOG(zeek::DBG_ANALYZER, "analyzer found but buffer already exceeded");
// FIXME: This is where to check whether an analyzer
// supports partial connections once we get such.
@ -210,7 +210,7 @@ void PIA_TCP::FirstPacket(bool is_orig, const zeek::IP_Hdr* ip)
static struct tcphdr* tcp4 = nullptr;
static zeek::IP_Hdr* ip4_hdr = nullptr;
DBG_LOG(DBG_ANALYZER, "PIA_TCP[%d] FirstPacket(%s)", GetID(), (is_orig ? "T" : "F"));
DBG_LOG(zeek::DBG_ANALYZER, "PIA_TCP[%d] FirstPacket(%s)", GetID(), (is_orig ? "T" : "F"));
if ( ! ip )
{
@ -296,7 +296,7 @@ void PIA_TCP::ActivateAnalyzer(zeek::analyzer::Tag tag, const zeek::detail::Rule
{
if ( stream_buffer.state == MATCHING_ONLY )
{
DBG_LOG(DBG_ANALYZER, "analyzer found but buffer already exceeded");
DBG_LOG(zeek::DBG_ANALYZER, "analyzer found but buffer already exceeded");
// FIXME: This is where to check whether an analyzer supports
// partial connections once we get such.
@ -348,7 +348,7 @@ void PIA_TCP::ActivateAnalyzer(zeek::analyzer::Tag tag, const zeek::detail::Rule
// (4) We hand the two reassemblers to the TCP Analyzer (our parent),
// turning reassembly now on for all subsequent data.
DBG_LOG(DBG_ANALYZER, "PIA_TCP switching from packet-mode to stream-mode");
DBG_LOG(zeek::DBG_ANALYZER, "PIA_TCP switching from packet-mode to stream-mode");
stream_mode = true;
// FIXME: The reassembler will query the endpoint for state. Not sure
@ -425,7 +425,7 @@ void PIA_TCP::DeactivateAnalyzer(zeek::analyzer::Tag tag)
void PIA_TCP::ReplayStreamBuffer(zeek::analyzer::Analyzer* analyzer)
{
DBG_LOG(DBG_ANALYZER, "PIA_TCP replaying %d total stream bytes", stream_buffer.size);
DBG_LOG(zeek::DBG_ANALYZER, "PIA_TCP replaying %d total stream bytes", stream_buffer.size);
for ( DataBlock* b = stream_buffer.head; b; b = b->next )
{

6
src/analyzer/protocol/tcp/TCP.cc
View file

@ -1247,7 +1247,7 @@ void TCP_Analyzer::DeliverPacket(int len, const u_char* data, bool is_orig,
if ( child->Removing() )
child->Done();
DBG_LOG(DBG_ANALYZER, "%s deleted child %s",
DBG_LOG(zeek::DBG_ANALYZER, "%s deleted child %s",
fmt_analyzer(this).c_str(), fmt_analyzer(child).c_str());
i = packet_children.erase(i);
delete child;
@ -1763,7 +1763,7 @@ bool TCP_Analyzer::HadGap(bool is_orig) const
void TCP_Analyzer::AddChildPacketAnalyzer(zeek::analyzer::Analyzer* a)
{
DBG_LOG(DBG_ANALYZER, "%s added packet child %s",
DBG_LOG(zeek::DBG_ANALYZER, "%s added packet child %s",
this->GetAnalyzerName(), a->GetAnalyzerName());
packet_children.push_back(a);
@ -1905,7 +1905,7 @@ void TCP_ApplicationAnalyzer::DeliverPacket(int len, const u_char* data,
const zeek::IP_Hdr* ip, int caplen)
{
Analyzer::DeliverPacket(len, data, is_orig, seq, ip, caplen);
DBG_LOG(DBG_ANALYZER, "TCP_ApplicationAnalyzer ignoring DeliverPacket(%d, %s, %" PRIu64", %p, %d) [%s%s]",
DBG_LOG(zeek::DBG_ANALYZER, "TCP_ApplicationAnalyzer ignoring DeliverPacket(%d, %s, %" PRIu64", %p, %d) [%s%s]",
len, is_orig ? "T" : "F", seq, ip, caplen,
fmt_bytes((const char*) data, std::min(40, len)), len > 40 ? "..." : "");
}

64
src/broker/Manager.cc
View file

@ -143,7 +143,7 @@ Manager::~Manager()
void Manager::InitPostScript()
{
DBG_LOG(DBG_BROKER, "Initializing");
DBG_LOG(zeek::DBG_BROKER, "Initializing");
log_batch_size = get_option("Broker::log_batch_size")->AsCount();
default_log_topic_prefix =
@ -355,7 +355,7 @@ uint16_t Manager::Listen(const string& addr, uint16_t port)
// Register as a "does-count" source now.
iosource_mgr->Register(this, false);
DBG_LOG(DBG_BROKER, "Listening on %s:%" PRIu16,
DBG_LOG(zeek::DBG_BROKER, "Listening on %s:%" PRIu16,
addr.empty() ? "INADDR_ANY" : addr.c_str(), port);
return bound_port;
@ -366,7 +366,7 @@ void Manager::Peer(const string& addr, uint16_t port, double retry)
if ( bstate->endpoint.is_shutdown() )
return;
DBG_LOG(DBG_BROKER, "Starting to peer with %s:%" PRIu16,
DBG_LOG(zeek::DBG_BROKER, "Starting to peer with %s:%" PRIu16,
addr.c_str(), port);
auto e = zeekenv("ZEEK_DEFAULT_CONNECT_RETRY");
@ -393,7 +393,7 @@ void Manager::Unpeer(const string& addr, uint16_t port)
if ( bstate->endpoint.is_shutdown() )
return;
DBG_LOG(DBG_BROKER, "Stopping to peer with %s:%" PRIu16,
DBG_LOG(zeek::DBG_BROKER, "Stopping to peer with %s:%" PRIu16,
addr.c_str(), port);
FlushLogBuffers();
@ -421,7 +421,7 @@ bool Manager::PublishEvent(string topic, std::string name, broker::vector args)
if ( peer_count == 0 )
return true;
DBG_LOG(DBG_BROKER, "Publishing event: %s",
DBG_LOG(zeek::DBG_BROKER, "Publishing event: %s",
RenderEvent(topic, name, args).c_str());
broker::zeek::Event ev(std::move(name), std::move(args));
bstate->endpoint.publish(move(topic), ev.move_data());
@ -485,7 +485,7 @@ bool Manager::PublishIdentifier(std::string topic, std::string id)
}
broker::zeek::IdentifierUpdate msg(move(id), move(*data));
DBG_LOG(DBG_BROKER, "Publishing id-update: %s",
DBG_LOG(zeek::DBG_BROKER, "Publishing id-update: %s",
RenderMessage(topic, msg.as_data()).c_str());
bstate->endpoint.publish(move(topic), msg.move_data());
++statistics.num_ids_outgoing;
@ -537,7 +537,7 @@ bool Manager::PublishLogCreate(zeek::EnumVal* stream, zeek::EnumVal* writer,
auto bwriter_id = broker::enum_value(move(writer_id));
broker::zeek::LogCreate msg(move(bstream_id), move(bwriter_id), move(writer_info), move(fields_data));
DBG_LOG(DBG_BROKER, "Publishing log creation: %s", RenderMessage(topic, msg.as_data()).c_str());
DBG_LOG(zeek::DBG_BROKER, "Publishing log creation: %s", RenderMessage(topic, msg.as_data()).c_str());
if ( peer.node != NoPeer.node )
// Direct message.
@ -622,7 +622,7 @@ bool Manager::PublishLogWrite(zeek::EnumVal* stream, zeek::EnumVal* writer, stri
broker::zeek::LogWrite msg(move(bstream_id), move(bwriter_id), move(path),
move(serial_data));
DBG_LOG(DBG_BROKER, "Buffering log record: %s", RenderMessage(topic, msg.as_data()).c_str());
DBG_LOG(zeek::DBG_BROKER, "Buffering log record: %s", RenderMessage(topic, msg.as_data()).c_str());
if ( log_buffers.size() <= (unsigned int)stream_id_num )
log_buffers.resize(stream_id_num + 1);
@ -665,7 +665,7 @@ size_t Manager::LogBuffer::Flush(broker::endpoint& endpoint, size_t log_batch_si
size_t Manager::FlushLogBuffers()
{
DBG_LOG(DBG_BROKER, "Flushing all log buffers");
DBG_LOG(zeek::DBG_BROKER, "Flushing all log buffers");
auto rval = 0u;
for ( auto& lb : log_buffers )
@ -711,7 +711,7 @@ bool Manager::AutoPublishEvent(string topic, zeek::Val* event)
return false;
}
DBG_LOG(DBG_BROKER, "Enabling auto-publising of event %s to topic %s", handler->Name(), topic.c_str());
DBG_LOG(zeek::DBG_BROKER, "Enabling auto-publising of event %s to topic %s", handler->Name(), topic.c_str());
handler->AutoPublish(move(topic));
return true;
@ -743,7 +743,7 @@ bool Manager::AutoUnpublishEvent(const string& topic, zeek::Val* event)
}
DBG_LOG(DBG_BROKER, "Disabling auto-publishing of event %s to topic %s", handler->Name(), topic.c_str());
DBG_LOG(zeek::DBG_BROKER, "Disabling auto-publishing of event %s to topic %s", handler->Name(), topic.c_str());
handler->AutoUnpublish(topic);
return true;
@ -827,7 +827,7 @@ zeek::RecordVal* Manager::MakeEvent(val_list* args, zeek::detail::Frame* frame)
bool Manager::Subscribe(const string& topic_prefix)
{
DBG_LOG(DBG_BROKER, "Subscribing to topic prefix %s", topic_prefix.c_str());
DBG_LOG(zeek::DBG_BROKER, "Subscribing to topic prefix %s", topic_prefix.c_str());
bstate->subscriber.add_topic(topic_prefix, ! after_zeek_init);
// For backward compatibility, we also may receive messages on
@ -847,7 +847,7 @@ bool Manager::Forward(string topic_prefix)
if ( prefix == topic_prefix )
return false;
DBG_LOG(DBG_BROKER, "Forwarding topic prefix %s", topic_prefix.c_str());
DBG_LOG(zeek::DBG_BROKER, "Forwarding topic prefix %s", topic_prefix.c_str());
Subscribe(topic_prefix);
forwarded_prefixes.emplace_back(std::move(topic_prefix));
return true;
@ -858,12 +858,12 @@ bool Manager::Unsubscribe(const string& topic_prefix)
for ( size_t i = 0; i < forwarded_prefixes.size(); ++i )
if ( forwarded_prefixes[i] == topic_prefix )
{
DBG_LOG(DBG_BROKER, "Unforwading topic prefix %s", topic_prefix.c_str());
DBG_LOG(zeek::DBG_BROKER, "Unforwading topic prefix %s", topic_prefix.c_str());
forwarded_prefixes.erase(forwarded_prefixes.begin() + i);
break;
}
DBG_LOG(DBG_BROKER, "Unsubscribing from topic prefix %s", topic_prefix.c_str());
DBG_LOG(zeek::DBG_BROKER, "Unsubscribing from topic prefix %s", topic_prefix.c_str());
bstate->subscriber.remove_topic(topic_prefix, ! after_zeek_init);
return true;
}
@ -1016,11 +1016,11 @@ void Manager::ProcessStoreEventInsertUpdate(const zeek::TableValPtr& table,
if ( insert )
{
DBG_LOG(DBG_BROKER, "Store %s: Insert: %s:%s (%s:%s)", store_id.c_str(), to_string(key).c_str(), to_string(data).c_str(), key.get_type_name(), data.get_type_name());
DBG_LOG(zeek::DBG_BROKER, "Store %s: Insert: %s:%s (%s:%s)", store_id.c_str(), to_string(key).c_str(), to_string(data).c_str(), key.get_type_name(), data.get_type_name());
}
else
{
DBG_LOG(DBG_BROKER, "Store %s: Update: %s->%s (%s)", store_id.c_str(), to_string(old_value).c_str(), to_string(data).c_str(), data.get_type_name());
DBG_LOG(zeek::DBG_BROKER, "Store %s: Update: %s->%s (%s)", store_id.c_str(), to_string(old_value).c_str(), to_string(data).c_str(), data.get_type_name());
}
if ( table->GetType()->IsSet() && data.get_type() != broker::data::type::none )
@ -1104,7 +1104,7 @@ void Manager::ProcessStoreEvent(broker::data msg)
return;
auto key = erase.key();
DBG_LOG(DBG_BROKER, "Store %s: Erase key %s", erase.store_id().c_str(), to_string(key).c_str());
DBG_LOG(zeek::DBG_BROKER, "Store %s: Erase key %s", erase.store_id().c_str(), to_string(key).c_str());
const auto& its = table->GetType()->AsTableType()->GetIndexTypes();
assert( its.size() == 1 );
auto zeek_key = data_to_val(key, its[0].get());
@ -1129,7 +1129,7 @@ void Manager::ProcessStoreEvent(broker::data msg)
if ( ! table )
return;
DBG_LOG(DBG_BROKER, "Store %s: Store expired key %s", expire.store_id().c_str(), to_string(expire.key()).c_str());
DBG_LOG(zeek::DBG_BROKER, "Store %s: Store expired key %s", expire.store_id().c_str(), to_string(expire.key()).c_str());
#endif /* DEBUG */
}
else
@ -1150,7 +1150,7 @@ void Manager::ProcessEvent(const broker::topic& topic, broker::zeek::Event ev)
auto name = std::move(ev.name());
auto args = std::move(ev.args());
DBG_LOG(DBG_BROKER, "Process event: %s %s",
DBG_LOG(zeek::DBG_BROKER, "Process event: %s %s",
name.data(), RenderMessage(args).data());
++statistics.num_events_incoming;
auto handler = zeek::event_registry->Lookup(name);
@ -1168,7 +1168,7 @@ void Manager::ProcessEvent(const broker::topic& topic, broker::zeek::Event ev)
if ( strncmp(p.data(), topic_string.data(), p.size()) != 0 )
continue;
DBG_LOG(DBG_BROKER, "Skip processing of forwarded event: %s %s",
DBG_LOG(zeek::DBG_BROKER, "Skip processing of forwarded event: %s %s",
name.data(), RenderMessage(args).data());
return;
}
@ -1221,7 +1221,7 @@ void Manager::ProcessEvent(const broker::topic& topic, broker::zeek::Event ev)
bool bro_broker::Manager::ProcessLogCreate(broker::zeek::LogCreate lc)
{
DBG_LOG(DBG_BROKER, "Received log-create: %s", RenderMessage(lc.as_data()).c_str());
DBG_LOG(zeek::DBG_BROKER, "Received log-create: %s", RenderMessage(lc.as_data()).c_str());
if ( ! lc.valid() )
{
zeek::reporter->Warning("received invalid broker LogCreate: %s",
@ -1286,7 +1286,7 @@ bool bro_broker::Manager::ProcessLogCreate(broker::zeek::LogCreate lc)
bool bro_broker::Manager::ProcessLogWrite(broker::zeek::LogWrite lw)
{
DBG_LOG(DBG_BROKER, "Received log-write: %s", RenderMessage(lw.as_data()).c_str());
DBG_LOG(zeek::DBG_BROKER, "Received log-write: %s", RenderMessage(lw.as_data()).c_str());
if ( ! lw.valid() )
{
@ -1370,7 +1370,7 @@ bool bro_broker::Manager::ProcessLogWrite(broker::zeek::LogWrite lw)
bool Manager::ProcessIdentifierUpdate(broker::zeek::IdentifierUpdate iu)
{
DBG_LOG(DBG_BROKER, "Received id-update: %s", RenderMessage(iu.as_data()).c_str());
DBG_LOG(zeek::DBG_BROKER, "Received id-update: %s", RenderMessage(iu.as_data()).c_str());
if ( ! iu.valid() )
{
@ -1406,7 +1406,7 @@ bool Manager::ProcessIdentifierUpdate(broker::zeek::IdentifierUpdate iu)
void Manager::ProcessStatus(broker::status stat)
{
DBG_LOG(DBG_BROKER, "Received status message: %s", RenderMessage(stat).c_str());
DBG_LOG(zeek::DBG_BROKER, "Received status message: %s", RenderMessage(stat).c_str());
auto ctx = stat.context<broker::endpoint_info>();
@ -1474,7 +1474,7 @@ void Manager::ProcessStatus(broker::status stat)
void Manager::ProcessError(broker::error err)
{
DBG_LOG(DBG_BROKER, "Received error message: %s", RenderMessage(err).c_str());
DBG_LOG(zeek::DBG_BROKER, "Received error message: %s", RenderMessage(err).c_str());
if ( ! Broker::error )
return;
@ -1509,7 +1509,7 @@ void Manager::ProcessError(broker::error err)
void Manager::ProcessStoreResponse(StoreHandleVal* s, broker::store::response response)
{
DBG_LOG(DBG_BROKER, "Received store response: %s", RenderMessage(response).c_str());
DBG_LOG(zeek::DBG_BROKER, "Received store response: %s", RenderMessage(response).c_str());
auto request = pending_queries.find(std::make_pair(response.id, s));
@ -1561,7 +1561,7 @@ StoreHandleVal* Manager::MakeMaster(const string& name, broker::backend type,
if ( LookupStore(name) )
return nullptr;
DBG_LOG(DBG_BROKER, "Creating master for data store %s", name.c_str());
DBG_LOG(zeek::DBG_BROKER, "Creating master for data store %s", name.c_str());
auto it = opts.find("path");
@ -1679,7 +1679,7 @@ StoreHandleVal* Manager::MakeClone(const string& name, double resync_interval,
if ( LookupStore(name) )
return nullptr;
DBG_LOG(DBG_BROKER, "Creating clone for data store %s", name.c_str());
DBG_LOG(zeek::DBG_BROKER, "Creating clone for data store %s", name.c_str());
auto result = bstate->endpoint.attach_clone(name, resync_interval,
stale_interval,
@ -1708,7 +1708,7 @@ StoreHandleVal* Manager::LookupStore(const string& name)
bool Manager::CloseStore(const string& name)
{
DBG_LOG(DBG_BROKER, "Closing data store %s", name.c_str());
DBG_LOG(zeek::DBG_BROKER, "Closing data store %s", name.c_str());
auto s = data_stores.find(name);
if ( s == data_stores.end() )
@ -1764,7 +1764,7 @@ bool Manager::AddForwardedStore(const std::string& name, zeek::TableValPtr table
return false;
}
DBG_LOG(DBG_BROKER, "Adding table forward for data store %s", name.c_str());
DBG_LOG(zeek::DBG_BROKER, "Adding table forward for data store %s", name.c_str());
forwarded_stores.emplace(name, std::move(table));
PrepareForwarding(name);
@ -1781,7 +1781,7 @@ void Manager::PrepareForwarding(const std::string &name)
return;
handle->forward_to = forwarded_stores.at(name);
DBG_LOG(DBG_BROKER, "Resolved table forward for data store %s", name.c_str());
DBG_LOG(zeek::DBG_BROKER, "Resolved table forward for data store %s", name.c_str());
}
} // namespace bro_broker

2
src/file_analysis/Analyzer.cc
View file

@ -8,7 +8,7 @@ file_analysis::ID file_analysis::Analyzer::id_counter = 0;
file_analysis::Analyzer::~Analyzer()
{
DBG_LOG(DBG_FILE_ANALYSIS, "Destroy file analyzer %s",
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "Destroy file analyzer %s",
file_mgr->GetComponentName(tag).c_str());
}

14
src/file_analysis/AnalyzerSet.cc
View file

@ -54,7 +54,7 @@ bool AnalyzerSet::Add(const file_analysis::Tag& tag, zeek::RecordValPtr args)
if ( analyzer_map.Lookup(key.get()) )
{
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Instantiate analyzer %s skipped: already exists",
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Instantiate analyzer %s skipped: already exists",
file->GetID().c_str(),
file_mgr->GetComponentName(tag).c_str());
@ -89,7 +89,7 @@ bool AnalyzerSet::AddMod::Perform(AnalyzerSet* set)
{
if ( set->analyzer_map.Lookup(key.get()) )
{
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Add analyzer %s skipped: already exists",
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Add analyzer %s skipped: already exists",
a->GetFile()->GetID().c_str(),
file_mgr->GetComponentName(a->Tag()).c_str());
@ -120,12 +120,12 @@ bool AnalyzerSet::Remove(const file_analysis::Tag& tag,
if ( ! a )
{
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Skip remove analyzer %s",
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Skip remove analyzer %s",
file->GetID().c_str(), file_mgr->GetComponentName(tag).c_str());
return false;
}
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Remove analyzer %s",
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Remove analyzer %s",
file->GetID().c_str(),
file_mgr->GetComponentName(tag).c_str());
@ -186,7 +186,7 @@ file_analysis::Analyzer* AnalyzerSet::InstantiateAnalyzer(const Tag& tag,
void AnalyzerSet::Insert(file_analysis::Analyzer* a,
std::unique_ptr<zeek::detail::HashKey> key)
{
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Add analyzer %s",
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Add analyzer %s",
file->GetID().c_str(), file_mgr->GetComponentName(a->Tag()).c_str());
analyzer_map.Insert(key.get(), a);
@ -198,7 +198,7 @@ void AnalyzerSet::DrainModifications()
if ( mod_queue.empty() )
return;
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Start analyzer mod queue flush",
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Start analyzer mod queue flush",
file->GetID().c_str());
do
{
@ -207,6 +207,6 @@ void AnalyzerSet::DrainModifications()
delete mod;
mod_queue.pop();
} while ( ! mod_queue.empty() );
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] End flushing analyzer mod queue.",
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] End flushing analyzer mod queue.",
file->GetID().c_str());
}

28
src/file_analysis/File.cc
View file

@ -89,7 +89,7 @@ File::File(const std::string& file_id, const std::string& source_name, Connectio
{
StaticInit();
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Creating new File object", file_id.c_str());
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Creating new File object", file_id.c_str());
val = zeek::make_intrusive<zeek::RecordVal>(zeek::id::fa_file);
val->Assign(id_idx, zeek::make_intrusive<zeek::StringVal>(file_id.c_str()));
@ -106,7 +106,7 @@ File::File(const std::string& file_id, const std::string& source_name, Connectio
File::~File()
{
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Destroying File object", id.c_str());
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Destroying File object", id.c_str());
delete file_reassembler;
for ( auto a : done_analyzers )
@ -231,7 +231,7 @@ void File::IncrementByteCount(uint64_t size, int field_idx)
void File::SetTotalBytes(uint64_t size)
{
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Total bytes %" PRIu64, id.c_str(), size);
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Total bytes %" PRIu64, id.c_str(), size);
val->Assign(total_bytes_idx, zeek::val_mgr->Count(size));
}
@ -258,7 +258,7 @@ bool File::AddAnalyzer(file_analysis::Tag tag, zeek::RecordVal* args)
bool File::AddAnalyzer(file_analysis::Tag tag, zeek::RecordValPtr args)
{
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Queuing addition of %s analyzer",
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Queuing addition of %s analyzer",
id.c_str(), file_mgr->GetComponentName(tag).c_str());
if ( done )
@ -272,7 +272,7 @@ bool File::RemoveAnalyzer(file_analysis::Tag tag, zeek::RecordVal* args)
bool File::RemoveAnalyzer(file_analysis::Tag tag, zeek::RecordValPtr args)
{
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Queuing remove of %s analyzer",
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Queuing remove of %s analyzer",
id.c_str(), file_mgr->GetComponentName(tag).c_str());
return done ? false : analyzers.QueueRemove(tag, std::move(args));
@ -386,7 +386,7 @@ void File::DeliverStream(const u_char* data, uint64_t len)
LookupFieldDefaultCount(missing_bytes_idx) == 0 )
InferMetadata();
DBG_LOG(DBG_FILE_ANALYSIS,
DBG_LOG(zeek::DBG_FILE_ANALYSIS,
"[%s] %" PRIu64 " stream bytes in at offset %" PRIu64 "; %s [%s%s]",
id.c_str(), len, stream_offset,
IsComplete() ? "complete" : "incomplete",
@ -398,10 +398,10 @@ void File::DeliverStream(const u_char* data, uint64_t len)
while ( (a = analyzers.NextEntry(c)) )
{
DBG_LOG(DBG_FILE_ANALYSIS, "stream delivery to analyzer %s", file_mgr->GetComponentName(a->Tag()).c_str());
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "stream delivery to analyzer %s", file_mgr->GetComponentName(a->Tag()).c_str());
if ( ! a->GotStreamDelivery() )
{
DBG_LOG(DBG_FILE_ANALYSIS, "skipping stream delivery to analyzer %s", file_mgr->GetComponentName(a->Tag()).c_str());
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "skipping stream delivery to analyzer %s", file_mgr->GetComponentName(a->Tag()).c_str());
int num_bof_chunks_behind = bof_buffer.chunks.size();
if ( ! bof_was_full )
@ -490,7 +490,7 @@ void File::DeliverChunk(const u_char* data, uint64_t len, uint64_t offset)
IncrementByteCount(len, overflow_bytes_idx);
}
DBG_LOG(DBG_FILE_ANALYSIS,
DBG_LOG(zeek::DBG_FILE_ANALYSIS,
"[%s] %" PRIu64 " chunk bytes in at offset %" PRIu64 "; %s [%s%s]",
id.c_str(), len, offset,
IsComplete() ? "complete" : "incomplete",
@ -502,7 +502,7 @@ void File::DeliverChunk(const u_char* data, uint64_t len, uint64_t offset)
while ( (a = analyzers.NextEntry(c)) )
{
DBG_LOG(DBG_FILE_ANALYSIS, "chunk delivery to analyzer %s", file_mgr->GetComponentName(a->Tag()).c_str());
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "chunk delivery to analyzer %s", file_mgr->GetComponentName(a->Tag()).c_str());
if ( ! a->Skipping() )
{
if ( ! a->DeliverChunk(data, len, offset) )
@ -538,7 +538,7 @@ void File::DataIn(const u_char* data, uint64_t len)
void File::EndOfFile()
{
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] End of file", id.c_str());
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] End of file", id.c_str());
if ( done )
return;
@ -553,7 +553,7 @@ void File::EndOfFile()
// any stream analyzers.
if ( ! bof_buffer.full )
{
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] File over but bof_buffer not full.", id.c_str());
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] File over but bof_buffer not full.", id.c_str());
bof_buffer.full = true;
DeliverStream((const u_char*) "", 0);
}
@ -577,7 +577,7 @@ void File::EndOfFile()
void File::Gap(uint64_t offset, uint64_t len)
{
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Gap of size %" PRIu64 " at offset %" PRIu64,
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Gap of size %" PRIu64 " at offset %" PRIu64,
id.c_str(), len, offset);
if ( file_reassembler && ! file_reassembler->IsCurrentlyFlushing() )
@ -589,7 +589,7 @@ void File::Gap(uint64_t offset, uint64_t len)
if ( ! bof_buffer.full )
{
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] File gap before bof_buffer filled, continued without attempting to fill bof_buffer.", id.c_str());
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] File gap before bof_buffer filled, continued without attempting to fill bof_buffer.", id.c_str());
bof_buffer.full = true;
DeliverStream((const u_char*) "", 0);
}

4
src/file_analysis/FileTimer.cc
View file

@ -9,7 +9,7 @@ using namespace file_analysis;
FileTimer::FileTimer(double t, const std::string& id, double interval)
: zeek::detail::Timer(t + interval, zeek::detail::TIMER_FILE_ANALYSIS_INACTIVITY), file_id(id)
{
DBG_LOG(DBG_FILE_ANALYSIS, "New %f second timeout timer for %s",
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "New %f second timeout timer for %s",
interval, file_id.c_str());
}
@ -23,7 +23,7 @@ void FileTimer::Dispatch(double t, bool is_expire)
double last_active = file->GetLastActivityTime();
double inactive_time = t > last_active ? t - last_active : 0.0;
DBG_LOG(DBG_FILE_ANALYSIS, "Checking inactivity for %s, last active at %f, "
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "Checking inactivity for %s, last active at %f, "
"inactive for %f", file_id.c_str(), last_active, inactive_time);
if ( last_active == 0.0 )

16
src/file_analysis/Manager.cc
View file

@ -78,11 +78,11 @@ void Manager::SetHandle(const string& handle)
return;
#ifdef DEBUG
if ( debug_logger.IsEnabled(DBG_FILE_ANALYSIS) )
if ( debug_logger.IsEnabled(zeek::DBG_FILE_ANALYSIS) )
{
zeek::String tmp{handle};
auto rendered = tmp.Render();
DBG_LOG(DBG_FILE_ANALYSIS, "Set current handle to %s", rendered);
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "Set current handle to %s", rendered);
delete [] rendered;
}
#endif
@ -371,14 +371,14 @@ void Manager::Timeout(const string& file_id, bool is_terminating)
if ( file->postpone_timeout && ! is_terminating )
{
DBG_LOG(DBG_FILE_ANALYSIS, "Postpone file analysis timeout for %s",
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "Postpone file analysis timeout for %s",
file->GetID().c_str());
file->UpdateLastActivityTime();
file->ScheduleInactivityTimer();
return;
}
DBG_LOG(DBG_FILE_ANALYSIS, "File analysis timeout for %s",
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "File analysis timeout for %s",
file->GetID().c_str());
RemoveFile(file->GetID());
@ -389,7 +389,7 @@ bool Manager::IgnoreFile(const string& file_id)
if ( ! LookupFile(file_id) )
return false;
DBG_LOG(DBG_FILE_ANALYSIS, "Ignore FileID %s", file_id.c_str());
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "Ignore FileID %s", file_id.c_str());
ignored.insert(file_id);
return true;
@ -405,7 +405,7 @@ bool Manager::RemoveFile(const string& file_id)
if ( ! f )
return false;
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Remove file", file_id.c_str());
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Remove file", file_id.c_str());
f->EndOfFile();
@ -430,7 +430,7 @@ string Manager::GetFileID(const zeek::analyzer::Tag& tag, Connection* c, bool is
if ( ! get_file_handle )
return "";
DBG_LOG(DBG_FILE_ANALYSIS, "Raise get_file_handle() for protocol analyzer %s",
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "Raise get_file_handle() for protocol analyzer %s",
zeek::analyzer_mgr->GetComponentName(tag).c_str());
const auto& tagval = tag.AsVal();
@ -471,7 +471,7 @@ Analyzer* Manager::InstantiateAnalyzer(const Tag& tag,
return nullptr;
}
DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Instantiate analyzer %s",
DBG_LOG(zeek::DBG_FILE_ANALYSIS, "[%s] Instantiate analyzer %s",
f->id.c_str(), GetComponentName(tag).c_str());
Analyzer* a;

30
src/input/Manager.cc
View file

@ -297,7 +297,7 @@ bool Manager::CreateStream(Stream* info, zeek::RecordVal* description)
info->description = description;
DBG_LOG(DBG_INPUT, "Successfully created new input stream %s",
DBG_LOG(zeek::DBG_INPUT, "Successfully created new input stream %s",
name.c_str());
return true;
@ -451,7 +451,7 @@ bool Manager::CreateEventStream(zeek::RecordVal* fval)
readers[stream->reader] = stream;
DBG_LOG(DBG_INPUT, "Successfully created event stream %s",
DBG_LOG(zeek::DBG_INPUT, "Successfully created event stream %s",
stream->name.c_str());
return true;
@ -707,7 +707,7 @@ bool Manager::CreateTableStream(zeek::RecordVal* fval)
readers[stream->reader] = stream;
DBG_LOG(DBG_INPUT, "Successfully created table stream %s",
DBG_LOG(zeek::DBG_INPUT, "Successfully created table stream %s",
stream->name.c_str());
return true;
@ -794,7 +794,7 @@ bool Manager::CreateAnalysisStream(zeek::RecordVal* fval)
readers[stream->reader] = stream;
DBG_LOG(DBG_INPUT, "Successfully created analysis stream %s",
DBG_LOG(zeek::DBG_INPUT, "Successfully created analysis stream %s",
stream->name.c_str());
return true;
@ -864,7 +864,7 @@ bool Manager::RemoveStream(Stream *i)
i->removed = true;
DBG_LOG(DBG_INPUT, "Successfully queued removal of stream %s",
DBG_LOG(zeek::DBG_INPUT, "Successfully queued removal of stream %s",
i->name.c_str());
i->reader->Stop();
@ -895,7 +895,7 @@ bool Manager::RemoveStreamContinuation(ReaderFrontend* reader)
}
#ifdef DEBUG
DBG_LOG(DBG_INPUT, "Successfully executed removal of stream %s",
DBG_LOG(zeek::DBG_INPUT, "Successfully executed removal of stream %s",
i->name.c_str());
#endif
@ -1009,7 +1009,7 @@ bool Manager::ForceUpdate(const string &name)
i->reader->Update();
#ifdef DEBUG
DBG_LOG(DBG_INPUT, "Forcing update of stream %s", name.c_str());
DBG_LOG(zeek::DBG_INPUT, "Forcing update of stream %s", name.c_str());
#endif
return true; // update is async :(
@ -1326,13 +1326,13 @@ void Manager::EndCurrentSend(ReaderFrontend* reader)
}
#ifdef DEBUG
DBG_LOG(DBG_INPUT, "Got EndCurrentSend stream %s", i->name.c_str());
DBG_LOG(zeek::DBG_INPUT, "Got EndCurrentSend stream %s", i->name.c_str());
#endif
if ( i->stream_type != TABLE_STREAM )
{
#ifdef DEBUG
DBG_LOG(DBG_INPUT, "%s is event, sending end of data", i->name.c_str());
DBG_LOG(zeek::DBG_INPUT, "%s is event, sending end of data", i->name.c_str());
#endif
// just signal the end of the data source
SendEndOfData(i);
@ -1406,7 +1406,7 @@ void Manager::EndCurrentSend(ReaderFrontend* reader)
stream->currDict->SetDeleteFunc(input_hash_delete_func);
#ifdef DEBUG
DBG_LOG(DBG_INPUT, "EndCurrentSend complete for stream %s",
DBG_LOG(zeek::DBG_INPUT, "EndCurrentSend complete for stream %s",
i->name.c_str());
#endif
@ -1431,7 +1431,7 @@ void Manager::SendEndOfData(ReaderFrontend* reader)
void Manager::SendEndOfData(const Stream *i)
{
#ifdef DEBUG
DBG_LOG(DBG_INPUT, "SendEndOfData for stream %s",
DBG_LOG(zeek::DBG_INPUT, "SendEndOfData for stream %s",
i->name.c_str());
#endif
SendEvent(end_of_data, 2, new zeek::StringVal(i->name.c_str()),
@ -1451,7 +1451,7 @@ void Manager::Put(ReaderFrontend* reader, Value* *vals)
}
#ifdef DEBUG
DBG_LOG(DBG_INPUT, "Put for stream %s",
DBG_LOG(zeek::DBG_INPUT, "Put for stream %s",
i->name.c_str());
#endif
@ -1680,7 +1680,7 @@ void Manager::Clear(ReaderFrontend* reader)
}
#ifdef DEBUG
DBG_LOG(DBG_INPUT, "Got Clear for stream %s",
DBG_LOG(zeek::DBG_INPUT, "Got Clear for stream %s",
i->name.c_str());
#endif
@ -1816,7 +1816,7 @@ void Manager::SendEvent(zeek::EventHandlerPtr ev, const int numvals, ...) const
vl.reserve(numvals);
#ifdef DEBUG
DBG_LOG(DBG_INPUT, "SendEvent with %d vals",
DBG_LOG(zeek::DBG_INPUT, "SendEvent with %d vals",
numvals);
#endif
@ -1837,7 +1837,7 @@ void Manager::SendEvent(zeek::EventHandlerPtr ev, list<zeek::Val*> events) const
vl.reserve(events.size());
#ifdef DEBUG
DBG_LOG(DBG_INPUT, "SendEvent with %" PRIuPTR " vals (list)",
DBG_LOG(zeek::DBG_INPUT, "SendEvent with %" PRIuPTR " vals (list)",
events.size());
#endif

14
src/input/readers/binary/Binary.cc
View file

@ -60,7 +60,7 @@ bool Binary::CloseInput()
}
#ifdef DEBUG
Debug(DBG_INPUT, "Binary reader starting close");
Debug(zeek::DBG_INPUT, "Binary reader starting close");
#endif
in->close();
@ -68,7 +68,7 @@ bool Binary::CloseInput()
in = nullptr;
#ifdef DEBUG
Debug(DBG_INPUT, "Binary reader finished close");
Debug(zeek::DBG_INPUT, "Binary reader finished close");
#endif
return true;
@ -129,14 +129,14 @@ bool Binary::DoInit(const ReaderInfo& info, int num_fields,
return false;
#ifdef DEBUG
Debug(DBG_INPUT, "Binary reader created, will perform first update");
Debug(zeek::DBG_INPUT, "Binary reader created, will perform first update");
#endif
// after initialization - do update
DoUpdate();
#ifdef DEBUG
Debug(DBG_INPUT, "Binary reader did first update");
Debug(zeek::DBG_INPUT, "Binary reader did first update");
#endif
return true;
@ -256,7 +256,7 @@ bool Binary::DoUpdate()
EndCurrentSend();
#ifdef DEBUG
Debug(DBG_INPUT, "DoUpdate finished successfully");
Debug(zeek::DBG_INPUT, "DoUpdate finished successfully");
#endif
return true;
@ -272,12 +272,12 @@ bool Binary::DoHeartbeat(double network_time, double current_time)
case MODE_REREAD:
case MODE_STREAM:
#ifdef DEBUG
Debug(DBG_INPUT, "Starting Heartbeat update");
Debug(zeek::DBG_INPUT, "Starting Heartbeat update");
#endif
Update(); // call update and not DoUpdate, because update
// checks disabled.
#ifdef DEBUG
Debug(DBG_INPUT, "Finished with heartbeat update");
Debug(zeek::DBG_INPUT, "Finished with heartbeat update");
#endif
break;
default:

14
src/input/readers/raw/Raw.cc
View file

@ -311,7 +311,7 @@ bool Raw::CloseInput()
return false;
}
#ifdef DEBUG
Debug(DBG_INPUT, "Raw reader starting close");
Debug(zeek::DBG_INPUT, "Raw reader starting close");
#endif
file.reset(nullptr);
@ -326,7 +326,7 @@ bool Raw::CloseInput()
}
#ifdef DEBUG
Debug(DBG_INPUT, "Raw reader finished close");
Debug(zeek::DBG_INPUT, "Raw reader finished close");
#endif
return true;
@ -421,14 +421,14 @@ bool Raw::DoInit(const ReaderInfo& info, int num_fields, const Field* const* fie
return result;
#ifdef DEBUG
Debug(DBG_INPUT, "Raw reader created, will perform first update");
Debug(zeek::DBG_INPUT, "Raw reader created, will perform first update");
#endif
// after initialization - do update
DoUpdate();
#ifdef DEBUG
Debug(DBG_INPUT, "First update went through");
Debug(zeek::DBG_INPUT, "First update went through");
#endif
return true;
}
@ -697,7 +697,7 @@ bool Raw::DoUpdate()
#ifdef DEBUG
Debug(DBG_INPUT, "DoUpdate finished successfully");
Debug(zeek::DBG_INPUT, "DoUpdate finished successfully");
#endif
return true;
@ -713,12 +713,12 @@ bool Raw::DoHeartbeat(double network_time, double current_time)
case MODE_REREAD:
case MODE_STREAM:
#ifdef DEBUG
Debug(DBG_INPUT, "Starting Heartbeat update");
Debug(zeek::DBG_INPUT, "Starting Heartbeat update");
#endif
Update(); // call update and not DoUpdate, because update
// checks disabled.
#ifdef DEBUG
Debug(DBG_INPUT, "Finished with heartbeat update");
Debug(zeek::DBG_INPUT, "Finished with heartbeat update");
#endif
break;
default:

12
src/iosource/Manager.cc
View file

@ -40,7 +40,7 @@ void Manager::WakeupHandler::Process()
void Manager::WakeupHandler::Ping(const std::string& where)
{
DBG_LOG(DBG_MAINLOOP, "Pinging WakeupHandler from %s", where.c_str());
DBG_LOG(zeek::DBG_MAINLOOP, "Pinging WakeupHandler from %s", where.c_str());
flare.Fire();
}
@ -174,7 +174,7 @@ void Manager::FindReadySources(std::vector<IOSource*>* ready)
}
}
DBG_LOG(DBG_MAINLOOP, "timeout: %f ready size: %zu time_to_poll: %d\n",
DBG_LOG(zeek::DBG_MAINLOOP, "timeout: %f ready size: %zu time_to_poll: %d\n",
timeout, ready->size(), time_to_poll);
// If we didn't find any IOSources with zero timeouts or it's time to
@ -243,7 +243,7 @@ bool Manager::RegisterFd(int fd, IOSource* src)
if ( ret != -1 )
{
events.push_back({});
DBG_LOG(DBG_MAINLOOP, "Registered fd %d from %s", fd, src->Tag());
DBG_LOG(zeek::DBG_MAINLOOP, "Registered fd %d from %s", fd, src->Tag());
fd_map[fd] = src;
Wakeup("RegisterFd");
@ -264,7 +264,7 @@ bool Manager::UnregisterFd(int fd, IOSource* src)
EV_SET(&event, fd, EVFILT_READ, EV_DELETE, 0, 0, NULL);
int ret = kevent(event_queue, &event, 1, NULL, 0, NULL);
if ( ret != -1 )
DBG_LOG(DBG_MAINLOOP, "Unregistered fd %d from %s", fd, src->Tag());
DBG_LOG(zeek::DBG_MAINLOOP, "Unregistered fd %d from %s", fd, src->Tag());
fd_map.erase(fd);
@ -371,7 +371,7 @@ PktSrc* Manager::OpenPktSrc(const std::string& path, bool is_live)
PktSrc* ps = (*component->Factory())(npath, is_live);
assert(ps);
DBG_LOG(DBG_PKTIO, "Created packet source of type %s for %s", component->Name().c_str(), npath.c_str());
DBG_LOG(zeek::DBG_PKTIO, "Created packet source of type %s for %s", component->Name().c_str(), npath.c_str());
Register(ps);
return ps;
@ -410,7 +410,7 @@ PktDumper* Manager::OpenPktDumper(const std::string& path, bool append)
// Set an error message if it didn't open successfully.
pd->Error("could not open");
DBG_LOG(DBG_PKTIO, "Created packer dumper of type %s for %s", component->Name().c_str(), npath.c_str());
DBG_LOG(zeek::DBG_PKTIO, "Created packer dumper of type %s for %s", component->Name().c_str(), npath.c_str());
pd->Init();
pkt_dumpers.push_back(pd);

6
src/iosource/PktDumper.cc
View file

@ -62,13 +62,13 @@ void PktDumper::Opened(const Properties& arg_props)
{
is_open = true;
props = arg_props;
DBG_LOG(DBG_PKTIO, "Opened dumper %s", props.path.c_str());
DBG_LOG(zeek::DBG_PKTIO, "Opened dumper %s", props.path.c_str());
}
void PktDumper::Closed()
{
is_open = false;
DBG_LOG(DBG_PKTIO, "Closed dumper %s", props.path.c_str());
DBG_LOG(zeek::DBG_PKTIO, "Closed dumper %s", props.path.c_str());
props.path = "";
}
@ -76,7 +76,7 @@ void PktDumper::Error(const std::string& msg)
{
errmsg = msg;
DBG_LOG(DBG_PKTIO, "Error with dumper %s: %s",
DBG_LOG(zeek::DBG_PKTIO, "Error with dumper %s: %s",
IsOpen() ? props.path.c_str() : "<not open>",
msg.c_str());
}

6
src/iosource/PktSrc.cc
View file

@ -123,7 +123,7 @@ void PktSrc::Opened(const Properties& arg_props)
zeek::reporter->FatalError("Failed to register pktsrc fd with iosource_mgr");
}
DBG_LOG(DBG_PKTIO, "Opened source %s", props.path.c_str());
DBG_LOG(zeek::DBG_PKTIO, "Opened source %s", props.path.c_str());
}
void PktSrc::Closed()
@ -133,7 +133,7 @@ void PktSrc::Closed()
if ( props.is_live && props.selectable_fd != -1 )
iosource_mgr->UnregisterFd(props.selectable_fd, this);
DBG_LOG(DBG_PKTIO, "Closed source %s", props.path.c_str());
DBG_LOG(zeek::DBG_PKTIO, "Closed source %s", props.path.c_str());
}
void PktSrc::Error(const std::string& msg)
@ -141,7 +141,7 @@ void PktSrc::Error(const std::string& msg)
// We don't report this immediately, Bro will ask us for the error
// once it notices we aren't open.
errbuf = msg;
DBG_LOG(DBG_PKTIO, "Error with source %s: %s",
DBG_LOG(zeek::DBG_PKTIO, "Error with source %s: %s",
IsOpen() ? props.path.c_str() : "<not open>",
msg.c_str());
}

46
src/logging/Manager.cc
View file

@ -319,7 +319,7 @@ bool Manager::CreateStream(zeek::EnumVal* id, zeek::RecordVal* sval)
streams[idx]->enable_remote = zeek::id::find_val("Log::enable_remote_logging")->AsBool();
DBG_LOG(DBG_LOGGING, "Created new logging stream '%s', raising event %s",
DBG_LOG(zeek::DBG_LOGGING, "Created new logging stream '%s', raising event %s",
streams[idx]->name.c_str(), event ? streams[idx]->event->Name() : "<none>");
return true;
@ -341,7 +341,7 @@ bool Manager::RemoveStream(zeek::EnumVal* id)
{
WriterInfo* winfo = i->second;
DBG_LOG(DBG_LOGGING, "Removed writer '%s' from stream '%s'",
DBG_LOG(zeek::DBG_LOGGING, "Removed writer '%s' from stream '%s'",
winfo->writer->Name(), stream->name.c_str());
winfo->writer->Stop();
@ -354,7 +354,7 @@ bool Manager::RemoveStream(zeek::EnumVal* id)
delete stream;
streams[idx] = nullptr;
DBG_LOG(DBG_LOGGING, "Removed logging stream '%s'", sname.c_str());
DBG_LOG(zeek::DBG_LOGGING, "Removed logging stream '%s'", sname.c_str());
return true;
}
@ -370,7 +370,7 @@ bool Manager::EnableStream(zeek::EnumVal* id)
stream->enabled = true;
DBG_LOG(DBG_LOGGING, "Reenabled logging stream '%s'", stream->name.c_str());
DBG_LOG(zeek::DBG_LOGGING, "Reenabled logging stream '%s'", stream->name.c_str());
return true;
}
@ -386,7 +386,7 @@ bool Manager::DisableStream(zeek::EnumVal* id)
stream->enabled = false;
DBG_LOG(DBG_LOGGING, "Disabled logging stream '%s'", stream->name.c_str());
DBG_LOG(zeek::DBG_LOGGING, "Disabled logging stream '%s'", stream->name.c_str());
return true;
}
@ -641,18 +641,18 @@ bool Manager::AddFilter(zeek::EnumVal* id, zeek::RecordVal* fval)
ODesc desc;
writer->Describe(&desc);
DBG_LOG(DBG_LOGGING, "Created new filter '%s' for stream '%s'",
DBG_LOG(zeek::DBG_LOGGING, "Created new filter '%s' for stream '%s'",
filter->name.c_str(), stream->name.c_str());
DBG_LOG(DBG_LOGGING, " writer : %s", desc.Description());
DBG_LOG(DBG_LOGGING, " path : %s", filter->path.c_str());
DBG_LOG(DBG_LOGGING, " path_func : %s", (filter->path_func ? "set" : "not set"));
DBG_LOG(DBG_LOGGING, " pred : %s", (filter->pred ? "set" : "not set"));
DBG_LOG(zeek::DBG_LOGGING, " writer : %s", desc.Description());
DBG_LOG(zeek::DBG_LOGGING, " path : %s", filter->path.c_str());
DBG_LOG(zeek::DBG_LOGGING, " path_func : %s", (filter->path_func ? "set" : "not set"));
DBG_LOG(zeek::DBG_LOGGING, " pred : %s", (filter->pred ? "set" : "not set"));
for ( int i = 0; i < filter->num_fields; i++ )
{
threading::Field* field = filter->fields[i];
DBG_LOG(DBG_LOGGING, " field %10s: %s",
DBG_LOG(zeek::DBG_LOGGING, " field %10s: %s",
field->name, zeek::type_name(field->type));
}
#endif
@ -678,7 +678,7 @@ bool Manager::RemoveFilter(zeek::EnumVal* id, const string& name)
{
Filter* filter = *i;
stream->filters.erase(i);
DBG_LOG(DBG_LOGGING, "Removed filter '%s' from stream '%s'",
DBG_LOG(zeek::DBG_LOGGING, "Removed filter '%s' from stream '%s'",
filter->name.c_str(), stream->name.c_str());
delete filter;
return true;
@ -686,7 +686,7 @@ bool Manager::RemoveFilter(zeek::EnumVal* id, const string& name)
}
// If we don't find the filter, we don't treat that as an error.
DBG_LOG(DBG_LOGGING, "No filter '%s' for removing from stream '%s'",
DBG_LOG(zeek::DBG_LOGGING, "No filter '%s' for removing from stream '%s'",
name.c_str(), stream->name.c_str());
return true;
@ -774,7 +774,7 @@ bool Manager::Write(zeek::EnumVal* id, zeek::RecordVal* columns_arg)
path = v->AsString()->CheckString();
#ifdef DEBUG
DBG_LOG(DBG_LOGGING, "Path function for filter '%s' on stream '%s' return '%s'",
DBG_LOG(zeek::DBG_LOGGING, "Path function for filter '%s' on stream '%s' return '%s'",
filter->name.c_str(), stream->name.c_str(), path.c_str());
#endif
}
@ -901,7 +901,7 @@ bool Manager::Write(zeek::EnumVal* id, zeek::RecordVal* columns_arg)
DeleteVals(filter->num_fields, vals);
#ifdef DEBUG
DBG_LOG(DBG_LOGGING, "Hook prevented writing to filter '%s' on stream '%s'",
DBG_LOG(zeek::DBG_LOGGING, "Hook prevented writing to filter '%s' on stream '%s'",
filter->name.c_str(), stream->name.c_str());
#endif
return true;
@ -912,7 +912,7 @@ bool Manager::Write(zeek::EnumVal* id, zeek::RecordVal* columns_arg)
writer->Write(filter->num_fields, vals);
#ifdef DEBUG
DBG_LOG(DBG_LOGGING, "Wrote record to filter '%s' on stream '%s'",
DBG_LOG(zeek::DBG_LOGGING, "Wrote record to filter '%s' on stream '%s'",
filter->name.c_str(), stream->name.c_str());
#endif
}
@ -1254,7 +1254,7 @@ bool Manager::WriteFromRemote(zeek::EnumVal* id, zeek::EnumVal* writer, const st
#ifdef DEBUG
ODesc desc;
id->Describe(&desc);
DBG_LOG(DBG_LOGGING, "unknown stream %s in Manager::Write()",
DBG_LOG(zeek::DBG_LOGGING, "unknown stream %s in Manager::Write()",
desc.Description());
#endif
DeleteVals(num_fields, vals);
@ -1276,7 +1276,7 @@ bool Manager::WriteFromRemote(zeek::EnumVal* id, zeek::EnumVal* writer, const st
#ifdef DEBUG
ODesc desc;
id->Describe(&desc);
DBG_LOG(DBG_LOGGING, "unknown writer %s in Manager::Write()",
DBG_LOG(zeek::DBG_LOGGING, "unknown writer %s in Manager::Write()",
desc.Description());
#endif
DeleteVals(num_fields, vals);
@ -1285,7 +1285,7 @@ bool Manager::WriteFromRemote(zeek::EnumVal* id, zeek::EnumVal* writer, const st
w->second->writer->Write(num_fields, vals);
DBG_LOG(DBG_LOGGING,
DBG_LOG(zeek::DBG_LOGGING,
"Wrote pre-filtered record to path '%s' on stream '%s'",
path.c_str(), stream->name.c_str());
@ -1484,7 +1484,7 @@ void Manager::InstallRotationTimer(WriterInfo* winfo)
zeek::detail::timer_mgr->Add(winfo->rotation_timer);
DBG_LOG(DBG_LOGGING, "Scheduled rotation timer for %s to %.6f",
DBG_LOG(zeek::DBG_LOGGING, "Scheduled rotation timer for %s to %.6f",
winfo->writer->Name(), winfo->rotation_timer->Time());
}
}
@ -1552,7 +1552,7 @@ std::string Manager::FormatRotationPath(zeek::EnumValPtr writer,
void Manager::Rotate(WriterInfo* winfo)
{
DBG_LOG(DBG_LOGGING, "Rotating %s at %.6f",
DBG_LOG(zeek::DBG_LOGGING, "Rotating %s at %.6f",
winfo->writer->Name(), network_time);
static auto default_ppf = zeek::id::find_func("Log::__default_rotation_postprocessor");
@ -1584,12 +1584,12 @@ bool Manager::FinishedRotation(WriterFrontend* writer, const char* new_name, con
if ( ! success )
{
DBG_LOG(DBG_LOGGING, "Non-successful rotating writer '%s', file '%s' at %.6f,",
DBG_LOG(zeek::DBG_LOGGING, "Non-successful rotating writer '%s', file '%s' at %.6f,",
writer->Name(), filename, network_time);
return true;
}
DBG_LOG(DBG_LOGGING, "Finished rotating %s at %.6f, new name %s",
DBG_LOG(zeek::DBG_LOGGING, "Finished rotating %s at %.6f, new name %s",
writer->Name(), network_time, new_name);
WriterInfo* winfo = FindWriter(writer);

4
src/logging/WriterBackend.cc
View file

@ -209,7 +209,7 @@ bool WriterBackend::Write(int arg_num_fields, int num_writes, Value*** vals)
#ifdef DEBUG
const char* msg = Fmt("Number of fields don't match in WriterBackend::Write() (%d vs. %d)",
arg_num_fields, num_fields);
Debug(DBG_LOGGING, msg);
Debug(zeek::DBG_LOGGING, msg);
#endif
DeleteVals(num_writes, vals);
@ -227,7 +227,7 @@ bool WriterBackend::Write(int arg_num_fields, int num_writes, Value*** vals)
#ifdef DEBUG
const char* msg = Fmt("Field #%d type doesn't match in WriterBackend::Write() (%d vs. %d)",
i, vals[j][i]->type, fields[i]->type);
Debug(DBG_LOGGING, msg);
Debug(zeek::DBG_LOGGING, msg);
#endif
DisableFrontend();
DeleteVals(num_writes, vals);

2
src/plugin/ComponentManager.h
View file

@ -250,7 +250,7 @@ void ComponentManager<T, C>::RegisterComponent(C* component,
reporter->FatalError("Component '%s::%s' defined more than once",
module.c_str(), cname.c_str());
DBG_LOG(DBG_PLUGINS, "Registering component %s (tag %s)",
DBG_LOG(zeek::DBG_PLUGINS, "Registering component %s (tag %s)",
component->Name().c_str(), component->Tag().AsString().c_str());
components_by_name.insert(std::make_pair(cname, component));

30
src/plugin/Manager.cc
View file

@ -65,7 +65,7 @@ void Manager::SearchDynamicPlugins(const std::string& dir)
if ( ! is_dir(dir) )
{
DBG_LOG(DBG_PLUGINS, "Not a valid plugin directory: %s", dir.c_str());
DBG_LOG(zeek::DBG_PLUGINS, "Not a valid plugin directory: %s", dir.c_str());
return;
}
@ -91,14 +91,14 @@ void Manager::SearchDynamicPlugins(const std::string& dir)
if ( dynamic_plugins.find(lower_name) != dynamic_plugins.end() )
{
DBG_LOG(DBG_PLUGINS, "Found already known plugin %s in %s, ignoring", name.c_str(), dir.c_str());
DBG_LOG(zeek::DBG_PLUGINS, "Found already known plugin %s in %s, ignoring", name.c_str(), dir.c_str());
return;
}
// Record it, so that we can later activate it.
dynamic_plugins.insert(std::make_pair(lower_name, dir));
DBG_LOG(DBG_PLUGINS, "Found plugin %s in %s", name.c_str(), dir.c_str());
DBG_LOG(zeek::DBG_PLUGINS, "Found plugin %s in %s", name.c_str(), dir.c_str());
return;
}
@ -108,7 +108,7 @@ void Manager::SearchDynamicPlugins(const std::string& dir)
if ( ! d )
{
DBG_LOG(DBG_PLUGINS, "Cannot open directory %s", dir.c_str());
DBG_LOG(zeek::DBG_PLUGINS, "Cannot open directory %s", dir.c_str());
return;
}
@ -128,7 +128,7 @@ void Manager::SearchDynamicPlugins(const std::string& dir)
if( stat(path.c_str(), &st) < 0 )
{
DBG_LOG(DBG_PLUGINS, "Cannot stat %s: %s", path.c_str(), strerror(errno));
DBG_LOG(zeek::DBG_PLUGINS, "Cannot stat %s: %s", path.c_str(), strerror(errno));
continue;
}
@ -172,14 +172,14 @@ bool Manager::ActivateDynamicPluginInternal(const std::string& name, bool ok_if_
std::string dir = m->second + "/";
DBG_LOG(DBG_PLUGINS, "Activating plugin %s", name.c_str());
DBG_LOG(zeek::DBG_PLUGINS, "Activating plugin %s", name.c_str());
// Add the "scripts" and "bif" directories to ZEEKPATH.
std::string scripts = dir + "scripts";
if ( is_dir(scripts) )
{
DBG_LOG(DBG_PLUGINS, " Adding %s to ZEEKPATH", scripts.c_str());
DBG_LOG(zeek::DBG_PLUGINS, " Adding %s to ZEEKPATH", scripts.c_str());
add_to_bro_path(scripts);
}
@ -192,7 +192,7 @@ bool Manager::ActivateDynamicPluginInternal(const std::string& name, bool ok_if_
if ( is_file(init) )
{
DBG_LOG(DBG_PLUGINS, " Loading %s", init.c_str());
DBG_LOG(zeek::DBG_PLUGINS, " Loading %s", init.c_str());
warn_if_legacy_script(init);
scripts_to_load.push_back(init);
break;
@ -206,7 +206,7 @@ bool Manager::ActivateDynamicPluginInternal(const std::string& name, bool ok_if_
if ( is_file(init) )
{
DBG_LOG(DBG_PLUGINS, " Loading %s", init.c_str());
DBG_LOG(zeek::DBG_PLUGINS, " Loading %s", init.c_str());
warn_if_legacy_script(init);
scripts_to_load.push_back(init);
break;
@ -219,7 +219,7 @@ bool Manager::ActivateDynamicPluginInternal(const std::string& name, bool ok_if_
if ( is_file(init) )
{
DBG_LOG(DBG_PLUGINS, " Loading %s", init.c_str());
DBG_LOG(zeek::DBG_PLUGINS, " Loading %s", init.c_str());
warn_if_legacy_script(init);
scripts_to_load.push_back(init);
break;
@ -230,7 +230,7 @@ bool Manager::ActivateDynamicPluginInternal(const std::string& name, bool ok_if_
string dypattern = dir + "/lib/*." + HOST_ARCHITECTURE + DYNAMIC_PLUGIN_SUFFIX;
DBG_LOG(DBG_PLUGINS, " Searching for shared libraries %s", dypattern.c_str());
DBG_LOG(zeek::DBG_PLUGINS, " Searching for shared libraries %s", dypattern.c_str());
glob_t gl;
@ -256,7 +256,7 @@ bool Manager::ActivateDynamicPluginInternal(const std::string& name, bool ok_if_
current_plugin->SetDynamic(true);
current_plugin->DoConfigure();
DBG_LOG(DBG_PLUGINS, " InitialzingComponents");
DBG_LOG(zeek::DBG_PLUGINS, " InitialzingComponents");
current_plugin->InitializeComponents();
plugins_by_path.insert(std::make_pair(normalize_path(dir), current_plugin));
@ -276,7 +276,7 @@ bool Manager::ActivateDynamicPluginInternal(const std::string& name, bool ok_if_
current_sopath = nullptr;
current_plugin = nullptr;
DBG_LOG(DBG_PLUGINS, " Loaded %s", path);
DBG_LOG(zeek::DBG_PLUGINS, " Loaded %s", path);
}
globfree(&gl);
@ -284,7 +284,7 @@ bool Manager::ActivateDynamicPluginInternal(const std::string& name, bool ok_if_
else
{
DBG_LOG(DBG_PLUGINS, " No shared library found");
DBG_LOG(zeek::DBG_PLUGINS, " No shared library found");
}
// Mark this plugin as activated by clearing the path.
@ -573,7 +573,7 @@ void Manager::DisableHook(zeek::plugin::HookType hook, Plugin* plugin)
void Manager::RequestEvent(EventHandlerPtr handler, Plugin* plugin)
{
DBG_LOG(DBG_PLUGINS, "Plugin %s requested event %s",
DBG_LOG(zeek::DBG_PLUGINS, "Plugin %s requested event %s",
plugin->Name().c_str(), handler->Name());
handler->SetGenerateAlways();
}

4
src/scan.l
View file

@ -650,7 +650,7 @@ static int load_files(const char* orig_file)
zeekygen_mgr->Script(file_path);
DBG_LOG(DBG_SCRIPTS, "Loading %s", file_path.c_str());
DBG_LOG(zeek::DBG_SCRIPTS, "Loading %s", file_path.c_str());
// "orig_file", could be an alias for yytext, which is ephemeral
// and will be zapped after the yy_switch_to_buffer() below.
@ -1064,6 +1064,6 @@ bool ScannedFile::AlreadyScanned() const
break;
}
DBG_LOG(DBG_SCRIPTS, "AlreadyScanned result (%d) %s", rval, canonical_path.data());
DBG_LOG(zeek::DBG_SCRIPTS, "AlreadyScanned result (%d) %s", rval, canonical_path.data());
return rval;
}

18
src/supervisor/Supervisor.cc
View file

@ -217,7 +217,7 @@ Supervisor::Supervisor(Supervisor::Config cfg, SupervisorStemHandle sh)
stem_stderr.prefix = "[supervisor:STDERR] ";
stem_stderr.stream = stderr;
DBG_LOG(DBG_SUPERVISOR, "forked stem process %d", stem_pid);
DBG_LOG(zeek::DBG_SUPERVISOR, "forked stem process %d", stem_pid);
setsignal(SIGCHLD, supervisor_signal_handler);
int status;
@ -251,14 +251,14 @@ Supervisor::~Supervisor()
if ( ! stem_pid )
{
DBG_LOG(DBG_SUPERVISOR, "shutdown, stem process already exited");
DBG_LOG(zeek::DBG_SUPERVISOR, "shutdown, stem process already exited");
return;
}
iosource_mgr->UnregisterFd(signal_flare.FD(), this);
iosource_mgr->UnregisterFd(stem_pipe->InFD(), this);
DBG_LOG(DBG_SUPERVISOR, "shutdown, killing stem process %d", stem_pid);
DBG_LOG(zeek::DBG_SUPERVISOR, "shutdown, killing stem process %d", stem_pid);
auto kill_res = kill(stem_pid, SIGTERM);
@ -318,12 +318,12 @@ void Supervisor::ReapStem()
if ( WIFEXITED(status) )
{
DBG_LOG(DBG_SUPERVISOR, "stem process exited with status %d",
DBG_LOG(zeek::DBG_SUPERVISOR, "stem process exited with status %d",
WEXITSTATUS(status));
}
else if ( WIFSIGNALED(status) )
{
DBG_LOG(DBG_SUPERVISOR, "stem process terminated by signal %d",
DBG_LOG(zeek::DBG_SUPERVISOR, "stem process terminated by signal %d",
WTERMSIG(status));
}
else
@ -384,7 +384,7 @@ void Supervisor::HandleChildSignal()
{
if ( last_signal >= 0 )
{
DBG_LOG(DBG_SUPERVISOR, "Supervisor received signal %d", last_signal);
DBG_LOG(zeek::DBG_SUPERVISOR, "Supervisor received signal %d", last_signal);
last_signal = -1;
}
@ -394,7 +394,7 @@ void Supervisor::HandleChildSignal()
{
ReapStem();
DBG_LOG(DBG_SUPERVISOR, "Supervisor processed child signal %s",
DBG_LOG(zeek::DBG_SUPERVISOR, "Supervisor processed child signal %s",
stem_pid ? "(spurious)" : "");
}
@ -471,7 +471,7 @@ void Supervisor::HandleChildSignal()
"redirected stderr pipe");
}
DBG_LOG(DBG_SUPERVISOR, "stem process revived, new pid: %d", stem_pid);
DBG_LOG(zeek::DBG_SUPERVISOR, "stem process revived, new pid: %d", stem_pid);
// Parent supervisor process resends node configurations to recreate
// the desired process hierarchy.
@ -591,7 +591,7 @@ size_t Supervisor::ProcessMessages()
for ( auto& msg : msgs )
{
DBG_LOG(DBG_SUPERVISOR, "read msg from Stem: %s", msg.data());
DBG_LOG(zeek::DBG_SUPERVISOR, "read msg from Stem: %s", msg.data());
std::vector<std::string> msg_tokens;
tokenize_string(msg, " ", &msg_tokens);
const auto& type = msg_tokens[0];

10
src/threading/BasicThread.cc
View file

@ -96,7 +96,7 @@ void BasicThread::Start()
thread = std::thread(&BasicThread::launcher, this);
DBG_LOG(DBG_THREADING, "Started thread %s", name);
DBG_LOG(zeek::DBG_THREADING, "Started thread %s", name);
OnStart();
}
@ -109,7 +109,7 @@ void BasicThread::SignalStop()
if ( terminating )
return;
DBG_LOG(DBG_THREADING, "Signaling thread %s to terminate ...", name);
DBG_LOG(zeek::DBG_THREADING, "Signaling thread %s to terminate ...", name);
OnSignalStop();
}
@ -119,7 +119,7 @@ void BasicThread::WaitForStop()
if ( ! started )
return;
DBG_LOG(DBG_THREADING, "Waiting for thread %s to terminate and process last queue items...", name);
DBG_LOG(zeek::DBG_THREADING, "Waiting for thread %s to terminate and process last queue items...", name);
OnWaitForStop();
@ -145,7 +145,7 @@ void BasicThread::Join()
zeek::reporter->FatalError("Failure joining thread %s with error %s", name, e.what());
}
DBG_LOG(DBG_THREADING, "Joined with thread %s", name);
DBG_LOG(zeek::DBG_THREADING, "Joined with thread %s", name);
}
void BasicThread::Kill()
@ -160,7 +160,7 @@ void BasicThread::Kill()
void BasicThread::Done()
{
DBG_LOG(DBG_THREADING, "Thread %s has finished", name);
DBG_LOG(zeek::DBG_THREADING, "Thread %s has finished", name);
terminating = true;
killed = true;

14
src/threading/Manager.cc
View file

@ -21,7 +21,7 @@ void HeartbeatTimer::Dispatch(double t, bool is_expire)
Manager::Manager()
{
DBG_LOG(DBG_THREADING, "Creating thread manager ...");
DBG_LOG(zeek::DBG_THREADING, "Creating thread manager ...");
did_process = true;
next_beat = 0;
@ -36,7 +36,7 @@ Manager::~Manager()
void Manager::Terminate()
{
DBG_LOG(DBG_THREADING, "Terminating thread manager ...");
DBG_LOG(zeek::DBG_THREADING, "Terminating thread manager ...");
terminating = true;
// First process remaining thread output for the message threads.
@ -64,7 +64,7 @@ void Manager::Terminate()
void Manager::AddThread(BasicThread* thread)
{
DBG_LOG(DBG_THREADING, "Adding thread %s ...", thread->Name());
DBG_LOG(zeek::DBG_THREADING, "Adding thread %s ...", thread->Name());
all_threads.push_back(thread);
if ( ! heartbeat_timer_running )
@ -73,13 +73,13 @@ void Manager::AddThread(BasicThread* thread)
void Manager::AddMsgThread(MsgThread* thread)
{
DBG_LOG(DBG_THREADING, "%s is a MsgThread ...", thread->Name());
DBG_LOG(zeek::DBG_THREADING, "%s is a MsgThread ...", thread->Name());
msg_threads.push_back(thread);
}
void Manager::KillThreads()
{
DBG_LOG(DBG_THREADING, "Killing threads ...");
DBG_LOG(zeek::DBG_THREADING, "Killing threads ...");
for ( all_thread_list::iterator i = all_threads.begin(); i != all_threads.end(); i++ )
(*i)->Kill();
@ -87,7 +87,7 @@ void Manager::KillThreads()
void Manager::KillThread(BasicThread* thread)
{
DBG_LOG(DBG_THREADING, "Killing thread %s ...", thread->Name());
DBG_LOG(zeek::DBG_THREADING, "Killing thread %s ...", thread->Name());
thread->Kill();
}
@ -144,7 +144,7 @@ bool Manager::SendEvent(MsgThread* thread, const std::string& name, const int nu
}
#ifdef DEBUG
DBG_LOG(DBG_INPUT, "Thread %s: SendEvent for event %s with %d vals",
DBG_LOG(zeek::DBG_INPUT, "Thread %s: SendEvent for event %s with %d vals",
thread->Name(), name.c_str(), num_vals);
#endif

12
src/threading/MsgThread.cc
View file

@ -107,7 +107,7 @@ public:
class DebugMessage final : public OutputMessage<MsgThread>
{
public:
DebugMessage(DebugStream arg_stream, MsgThread* thread, const char* arg_msg)
DebugMessage(zeek::DebugStream arg_stream, MsgThread* thread, const char* arg_msg)
: OutputMessage<MsgThread>("DebugMessage", thread)
{ stream = arg_stream; msg = copy_string(arg_msg); }
@ -120,7 +120,7 @@ public:
}
private:
const char* msg;
DebugStream stream;
zeek::DebugStream stream;
};
#endif
@ -351,7 +351,7 @@ void MsgThread::InternalError(const char* msg)
#ifdef DEBUG
void MsgThread::Debug(DebugStream stream, const char* msg)
void MsgThread::Debug(zeek::DebugStream stream, const char* msg)
{
SendOut(new DebugMessage(stream, this, msg));
}
@ -366,7 +366,7 @@ void MsgThread::SendIn(BasicInputMessage* msg, bool force)
return;
}
DBG_LOG(DBG_THREADING, "Sending '%s' to %s ...", msg->Name(), Name());
DBG_LOG(zeek::DBG_THREADING, "Sending '%s' to %s ...", msg->Name(), Name());
queue_in.Put(msg);
++cnt_sent_in;
@ -399,7 +399,7 @@ BasicOutputMessage* MsgThread::RetrieveOut()
if ( ! msg )
return nullptr;
DBG_LOG(DBG_THREADING, "Retrieved '%s' from %s", msg->Name(), Name());
DBG_LOG(zeek::DBG_THREADING, "Retrieved '%s' from %s", msg->Name(), Name());
return msg;
}
@ -413,7 +413,7 @@ BasicInputMessage* MsgThread::RetrieveIn()
#ifdef DEBUG
std::string s = Fmt("Retrieved '%s' in %s", msg->Name(), Name());
Debug(DBG_THREADING, s.c_str());
Debug(zeek::DBG_THREADING, s.c_str());
#endif
return msg;

2
src/threading/MsgThread.h
View file

@ -170,7 +170,7 @@ public:
*
* @param msg The message. It will be prefixed with the thread's name.
*/
void Debug(DebugStream stream, const char* msg);
void Debug(zeek::DebugStream stream, const char* msg);
#endif
/**

22
src/zeekygen/Manager.cc
View file

@ -24,7 +24,7 @@ static void DbgAndWarn(const char* msg)
return;
zeek::reporter->Warning("%s", msg);
DBG_LOG(DBG_ZEEKYGEN, "%s", msg);
DBG_LOG(zeek::DBG_ZEEKYGEN, "%s", msg);
}
static void WarnMissingScript(const char* type, const zeek::detail::ID* id,
@ -145,7 +145,7 @@ void Manager::Script(const string& path)
ScriptInfo* info = new ScriptInfo(name, path);
scripts.map[name] = info;
all_info.push_back(info);
DBG_LOG(DBG_ZEEKYGEN, "Made ScriptInfo %s", name.c_str());
DBG_LOG(zeek::DBG_ZEEKYGEN, "Made ScriptInfo %s", name.c_str());
if ( ! info->IsPkgLoader() )
return;
@ -162,7 +162,7 @@ void Manager::Script(const string& path)
PackageInfo* pkginfo = new PackageInfo(name);
packages.map[name] = pkginfo;
all_info.push_back(pkginfo);
DBG_LOG(DBG_ZEEKYGEN, "Made PackageInfo %s", name.c_str());
DBG_LOG(zeek::DBG_ZEEKYGEN, "Made PackageInfo %s", name.c_str());
}
void Manager::ScriptDependency(const string& path, const string& dep)
@ -189,7 +189,7 @@ void Manager::ScriptDependency(const string& path, const string& dep)
}
script_info->AddDependency(depname);
DBG_LOG(DBG_ZEEKYGEN, "Added script dependency %s for %s",
DBG_LOG(zeek::DBG_ZEEKYGEN, "Added script dependency %s for %s",
depname.c_str(), name.c_str());
for ( size_t i = 0; i < comment_buffer.size(); ++i )
@ -213,7 +213,7 @@ void Manager::ModuleUsage(const string& path, const string& module)
}
script_info->AddModule(module);
DBG_LOG(DBG_ZEEKYGEN, "Added module usage %s in %s",
DBG_LOG(zeek::DBG_ZEEKYGEN, "Added module usage %s in %s",
module.c_str(), name.c_str());
}
@ -269,7 +269,7 @@ void Manager::StartType(zeek::detail::IDPtr id)
return;
}
DBG_LOG(DBG_ZEEKYGEN, "Making IdentifierInfo (incomplete) %s, in %s",
DBG_LOG(zeek::DBG_ZEEKYGEN, "Making IdentifierInfo (incomplete) %s, in %s",
id->Name(), script.c_str());
incomplete_type = CreateIdentifierInfo(std::move(id), script_info);
}
@ -288,7 +288,7 @@ void Manager::Identifier(zeek::detail::IDPtr id)
{
if ( incomplete_type->Name() == id->Name() )
{
DBG_LOG(DBG_ZEEKYGEN, "Finished document for type %s", id->Name());
DBG_LOG(zeek::DBG_ZEEKYGEN, "Finished document for type %s", id->Name());
incomplete_type->CompletedTypeDecl();
incomplete_type = nullptr;
return;
@ -318,7 +318,7 @@ void Manager::Identifier(zeek::detail::IDPtr id)
{
// Internally-created identifier (e.g. file/proto analyzer enum tags).
// Handled specially since they don't have a script location.
DBG_LOG(DBG_ZEEKYGEN, "Made internal IdentifierInfo %s",
DBG_LOG(zeek::DBG_ZEEKYGEN, "Made internal IdentifierInfo %s",
id->Name());
CreateIdentifierInfo(id, nullptr);
return;
@ -333,7 +333,7 @@ void Manager::Identifier(zeek::detail::IDPtr id)
return;
}
DBG_LOG(DBG_ZEEKYGEN, "Making IdentifierInfo %s, in script %s",
DBG_LOG(zeek::DBG_ZEEKYGEN, "Making IdentifierInfo %s, in script %s",
id->Name(), script.c_str());
CreateIdentifierInfo(std::move(id), script_info);
}
@ -357,7 +357,7 @@ void Manager::RecordField(const zeek::detail::ID* id, const zeek::TypeDecl* fiel
string script = NormalizeScriptPath(path);
idd->AddRecordField(field, script, comment_buffer);
comment_buffer.clear();
DBG_LOG(DBG_ZEEKYGEN, "Document record field %s, identifier %s, script %s",
DBG_LOG(zeek::DBG_ZEEKYGEN, "Document record field %s, identifier %s, script %s",
field->id, id->Name(), script.c_str());
}
@ -395,7 +395,7 @@ void Manager::Redef(const zeek::detail::ID* id, const string& path,
script_info->AddRedef(id_info);
comment_buffer.clear();
last_identifier_seen = id_info;
DBG_LOG(DBG_ZEEKYGEN, "Added redef of %s from %s",
DBG_LOG(zeek::DBG_ZEEKYGEN, "Added redef of %s from %s",
id->Name(), from_script.c_str());
}

16
src/zeekygen/ScriptInfo.cc
View file

@ -187,7 +187,7 @@ void ScriptInfo::DoInitPostScript()
if ( id->IsType() )
{
types.push_back(info);
DBG_LOG(DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a type",
DBG_LOG(zeek::DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a type",
id->Name(), name.c_str());
continue;
}
@ -196,17 +196,17 @@ void ScriptInfo::DoInitPostScript()
{
switch ( id->GetType()->AsFuncType()->Flavor() ) {
case zeek::FUNC_FLAVOR_HOOK:
DBG_LOG(DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a hook",
DBG_LOG(zeek::DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a hook",
id->Name(), name.c_str());
hooks.push_back(info);
break;
case zeek::FUNC_FLAVOR_EVENT:
DBG_LOG(DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a event",
DBG_LOG(zeek::DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a event",
id->Name(), name.c_str());
events.push_back(info);
break;
case zeek::FUNC_FLAVOR_FUNCTION:
DBG_LOG(DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a function",
DBG_LOG(zeek::DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a function",
id->Name(), name.c_str());
functions.push_back(info);
break;
@ -222,13 +222,13 @@ void ScriptInfo::DoInitPostScript()
{
if ( id->GetAttr(zeek::detail::ATTR_REDEF) )
{
DBG_LOG(DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a redef_option",
DBG_LOG(zeek::DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a redef_option",
id->Name(), name.c_str());
redef_options.push_back(info);
}
else
{
DBG_LOG(DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a constant",
DBG_LOG(zeek::DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a constant",
id->Name(), name.c_str());
constants.push_back(info);
}
@ -237,7 +237,7 @@ void ScriptInfo::DoInitPostScript()
}
else if ( id->IsOption() )
{
DBG_LOG(DBG_ZEEKYGEN, "Filter id '%s' in '%s' as an runtime option",
DBG_LOG(zeek::DBG_ZEEKYGEN, "Filter id '%s' in '%s' as an runtime option",
id->Name(), name.c_str());
options.push_back(info);
@ -249,7 +249,7 @@ void ScriptInfo::DoInitPostScript()
// documentation.
continue;
DBG_LOG(DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a state variable",
DBG_LOG(zeek::DBG_ZEEKYGEN, "Filter id '%s' in '%s' as a state variable",
id->Name(), name.c_str());
state_vars.push_back(info);
}

8
src/zeekygen/Target.cc
View file

@ -179,7 +179,7 @@ static vector<T*> filter_matches(const vector<Info*>& from, Target* t)
if ( t->MatchesPattern(d) )
{
DBG_LOG(DBG_ZEEKYGEN, "'%s' matched pattern for target '%s'",
DBG_LOG(zeek::DBG_ZEEKYGEN, "'%s' matched pattern for target '%s'",
d->Name().c_str(), t->Name().c_str());
rval.push_back(d);
}
@ -212,7 +212,7 @@ TargetFile::~TargetFile()
if ( f )
fclose(f);
DBG_LOG(DBG_ZEEKYGEN, "Wrote out-of-date target '%s'", name.c_str());
DBG_LOG(zeek::DBG_ZEEKYGEN, "Wrote out-of-date target '%s'", name.c_str());
}
@ -331,7 +331,7 @@ void PackageTarget::DoFindDependencies(const vector<Info*>& infos)
pkg_deps[j]->Name().size()))
continue;
DBG_LOG(DBG_ZEEKYGEN, "Script %s associated with package %s",
DBG_LOG(zeek::DBG_ZEEKYGEN, "Script %s associated with package %s",
script->Name().c_str(), pkg_deps[j]->Name().c_str());
pkg_manifest[pkg_deps[j]].push_back(script);
script_deps.push_back(script);
@ -510,7 +510,7 @@ void ScriptTarget::DoGenerate() const
zeek::reporter->Warning("Failed to unlink %s: %s", f.c_str(),
strerror(errno));
DBG_LOG(DBG_ZEEKYGEN, "Delete stale script file %s", f.c_str());
DBG_LOG(zeek::DBG_ZEEKYGEN, "Delete stale script file %s", f.c_str());
}
return;